Saravanan666/pypi-org huggingface dataset:
Package: dynamixel-helper
Easy Dynamixel Helper🌏English,한국어This helper is a wrapper for the Dynamixel-SDK. With this, configure and drive your motor more quickly. You do not need to know how the SDK works. In other words, this helper makes it easy to modify the control table.pipinstalldynamixel_helper--userTable of ContentsFeaturesSimple ExampleGetting StartedPrerequisitesInstallationTutorialsRelease NotesCurrent CoverageModel ListControl TableContributingStyle GuideMaintainersLicenses💎 FeaturesBaud rate auto-matchingProtocol auto-matchingPort auto-matching (Easy connections in multi-USB)Motor configurations in JSON formatSupport for Python 3 and 2Make your code simple and cleanEasy to use even for beginners.🐣 Simple ExampleThe following code is an example of turning on the motor torque.fromdynamixel_helperimportDxlHelperhelper=DxlHelper("preset/{my_robot}.json")motor=helper.get_motor(0)# id: 0motor.set_torque(True)🚀 Getting StartedPrerequisitespip (package manager)# Python 2sudoaptinstallpython-pip
python-mpipinstall-Upip# Python 3sudoaptinstallpython3-pip
python3-mpipinstall-UpipDynamixel SDKCAUTION💥: Please install thepipbeforeinstalling theDynamixel SDK. Otherwise, when you install thisDynamixel Helper, you will get an dependency error ofDynamixel SDK.You need to install the officialDynamixel SDKbefore using this helper.Click here: Dynamixel SDK InstallationClone the official SDK repository into your custom folder, for example, I created~/lib.gitclonehttps://github.com/ROBOTIS-GIT/DynamixelSDK.gitGo into the folder/DynamixelSDK/pythonof your cloned SDK.cd${your_download_path}/DynamixelSDK/pythonRunsetup.pywith--useroption to install the library. Administrator privileges, a.k.a.sudo, are not recommended. More informationhere.pythonsetup.pyinstall--userInstallationSimply typepipcommand below to install this helper.pipinstalldynamixel_helper--user🌱 TutorialsGo to tutorials🚩 Release NotesGo to release notes🔭 Current CoverageModel ListTested modelsXM430-W210XL430-W250Non-tested models (Only the control tables are included.)AX-12WXL-320Control TableDifferent models have slightly different control tables. Please check the documentation for each model. Just click the model name above to go to the document.EEPROM sectiondrive mode (w)operating mode (w)RAM sectiontorque (r/w)goal velocity (w)goal position (w)present velocity (r)present position (r)💌 ContributingWe will welcome whatever your contribution is!If you are planning to send a newPull request, please send them into thedevelopBranch.😍Style GuideThis style guide is only a recommendation, never more important than your interest and contributions.Our default Python style isPEP 8.If you useVSCodeas your code editor, please refer to the following settings. This setting is a part of oursetting.json.{"editor.tabSize":4,"[json]":{"editor.tabSize":2},"python.linting.pylintEnabled":false,"python.linting.pep8Enabled":true,"python.linting.enabled":true}🔧 MaintainersHong-ryul JungInitial workryul1206Il-ho OhInitial workohilho📜 LicensesThe contents of this repository are subject to theMIT Licenseby default, except as noted below.Dynamixel SDK is under theApache-2.0
Package: dynamo
This module allows you to interact with DynamoDB much like a native Python dictionary.Usageimport dynamo

ACCESS_KEY = 'XXXXXX'
SECRET_ACCESS_KEY = 'XXXXXX/XXXXXXXXX+XXXXXXX'
TABLE_NAME = 'XXXXX'

table = dynamo.table(TABLE_NAME, (ACCESS_KEY, SECRET_ACCESS_KEY))

# Or, if you have AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY defined as
# environment variables, you can do:
table = dynamo.table(TABLE_NAME)Writing is simple:table['new-key']['attribute'] = ['value']So is reading:>>> table['existing-key']['attribute']
'value'InstallationInstalling dynamo is simple with pip:$ pip install dynamo
Package: dynamo2relion
Dynamo2RelionA Tiny Function to Convert Dynamo Tables to Star Files for RELION 4.0Based ondynamo2mby Alister Burt.InstallationInstallation is carried out via:pipinstalldynamo2relionRequirementsYour directory containing the tilt series directories must be structured as follows:tilt_series_directory#Directory containing all TS directories, link to this directory|-->TS_01#Directory containing TS_01|-->TS_01.mrc#TS_01  image stack. The file extension does not matter.|-->TS_02|-->TS_02.mrc#|-->etc...The program will ask you the path to tilt_series_directory. No directories other than the TS_* directories should be present in tilt_series_directory. Naming convention for the TS_* directories can be any mix of upper of lower case TS and any numbering convention desired.UsageInstructions for use can be found via typing:dynamo2relion--helpFor binning level, simply enter 1 if the coordinates of your particles in the Dynamo table were picked from an unbinned tomogram. If the tomograms the particles were picked in were binned, add the correct binning level: binning is done using IMOD convention, i.e. for a pixel size of 1 A/px, a binning level of 8 would yield 8 A/px.
Package: dynamo-blogger
📰 Blog as a ServiceAn installable django blog application.RequirementsPython (3.6, 3.7, 3.8, 3.9, 3.10)Django (2.2, 3.0, 3.1, 3.2, 4.0)Quick StartInstall usingpip:pip install dynamo_bloggerAdd "dynamo_blogger" to your INSTALLED_APPS setting:INSTALLED_APPS = [
        ...
        'dynamo_blogger',
    ]Include the dynamo_blogger URLs in your project urls.py:path('blog/', include('dynamo_blogger.urls')),Runpython manage.py migrateto create thedynamo_bloggermodels.Start the development server and visithttp://127.0.0.1:8000/blog/Documentation & SupportFull documentation for the project is available atdocs.You may also want to follow the author ontwitter.LicenseDisclaimer: Everything you see here is open and free to use as long as you comply with thelicense. There are no hidden charges. We promise to do our best to fix bugs and improve the code.
Package: dynamocacher
dynamocacherDescriptionA package which allows you to use dynamodb to cache output of a slow or expensive function,
to reduce cost and increase the efficiencyDax is supported using a Pynamodb fork, and its highly recommended for performance-critical application
50-100x performance difference is expected with daxToDosDax support  : DoneAuto create table : Donepolicy template : in progressexample readme : DoneExamplescolabNotebookSampleUsagecache this slow functiondefpower(input:dict):'''This is a very bad and slow functionaccept a dict containing these keysbase: floatpower: intand return the power embarrasingly slowlyresponseresult: float'''base=input['base']power=input['power']result=baseforiinrange(power):result*=basereturn{'result':result}defpowerWithCaching(input:dict):cache=Cache.getCache(input,timeout=3600)ifcache:returncacheresult=power(input)Cache.addCache(input=input,output=result)returnresultperformanceExample code for trying it yourselfsampleInput={'base':1+1e-10,'power':86289369}%timeitpower(sampleInput)# 3.72 s ± 35 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)%timeitpowerWithCaching(sampleInput)# 238 ms ± 482 µs without dax%timeitpowerWithCaching(sampleInput)# 5.43 ms with daxSetUpfromdynamocacher.cacherimportCacherclassCache(Cacher):classMeta:table_name='dynamoCache'region='us-east-1'aws_access_key_id=USERaws_secret_access_key=PWbilling_mode='PAY_PER_REQUEST'dax_read_endpoints=['....:8111']# optional dax, note that dax will speed up dynamodb significantlydax_write_endpoints=['....:8111']# optional dax, note that dax will speed up dynamodb significantlycreateTableCache.create_table()basicaddCachesampleInput={'query':'testQuery','fruit':'strawberry'}Cache.addCache(input=sampleInput,output=sampleReturn)getCacheoutput=Cache.getCache(sampleInput,timeout=3600)# ignore cache older than 3600 secondscreating a table with samProperties:TableName:dynamoCachePrimaryKey:Name:cacheKeyType:StringTags:Department:EngineeringAppType:Serverless
Package: dynamoclasses
DynamoClassesAPI interface forAmazon Web Services DynamoDBbuilt on top ofPEP 557 Data Classes.The goal is to have something that is fully adataclassclass, but gets some helpers bolted on allowing for retrieving/storing the objects in DynamoDB.Basic Usage>>>importbotocore>>>>>>frommotoimportmock_dynamodb2>>>>>>fromdynamoclassesimportdynamoclass>>>>>>mock_dynamodb2().start()>>>>>>session=botocore.session.get_session()>>>client=session.create_client("dynamodb")>>>client.create_table(...TableName="inventory",...KeySchema=[...{"AttributeName":"item_id","KeyType":"HASH"},...],...AttributeDefinitions=[...{"AttributeName":"item_id","AttributeType":"S"},...],...ProvisionedThroughput={"ReadCapacityUnits":1,"WriteCapacityUnits":1},...){'TableDescription':...}>>>>>>@dynamoclass(table_name="inventory",partition_key_name="item_id")...classInventoryItem:...item_id:str...>>>item=InventoryItem("hammers")>>>item.save(){'Attributes':...}>>>>>>found_item=InventoryItem.get(partition_key="hammers",sort_key=None)>>>>>>print(found_item.item_id)hammers
Package: dynamocli
DynamoDB CLIIntroductionA simple lightweight command line interface for interacting with an Amazon DynamoDB instance.Mainly intended to work with a local instance, since current tools often struggles to work with a larger local database, but also works with AWS hosted instances.SetupIn order to set up your connection you may use the commanddynamocli set-configor edit the configuration file directly. The file is located in the user configuration folder~/Library/Application Support/dynamoclifor Mac OS~/.local/share/dynamoclifor linuxThe required configurations areAuthentication - Supports three different optionslocal - Connect to local dynamoDBenv - Connect to AWS instance using environment valuescredentials - Connect to AWS instance using .credentials fileTableName - Name of the table in the databasePort - Port of the instance, only required if Authentication = localProfile - AWS profile to use. Only required if Authentication = credentialsRegion - AWS region for the instance. Not needed if Authentication = localUsagedynamocli [-h] [--index INDEX] [--pk PK] [--sk SK] {describe,query,get-config,set-config}positional arguments:{describe,query,get-config,set-config}optional arguments:-h, --help            show this help message and exit--verbose, -v         increase output verbosity--index INDEX, -i INDEX  apecify name of index to use. Omit "pk"--pk PK               partition key value of the index to query--sk SK              sort key value. Defaults to --pk
Package: dynamo-cmdline
Dynamo CLIPython Command-line interface to copy Dynamodb data in parallel batch processing + query natural & Global Secondary Indexes (GSIs).Author: Simon RyuPre-requisiteProfiles in.aws/credentialsare configured for AWS environments (accounts).Installdynamo-cmdlinepackage:pip install dynamo-cmdlineRunning the CLIHelp messageDisplays a help message for using the CLI.$ dynamo -hCommand line interface to copy, query and restore DynamoDB tables and items

positional arguments:
  {copy,restore,query}
    copy                Copy table or items from source to target envrionment
    query               Query items in specified environment's table

optional arguments:
  -h, --help            show this help message and exitCopy tableCreates an on-demand target table backup, truncates all items in the target table and copies all source table items in its place.$ dynamo copy --table foo --source production --target developmentCopyfootable fromproductiontodevelopmentenvironment.Copy itemsCopies queried items from source table to target table. Queries items in source and target table, deletes them from the target table, then copies queried source items to the target table.
For querying with sort keys, the comparision condition is begins_with.$ dynamo copy --table foo --pk pkexample#id --sk skexample#id --source development --target testCopy queried items in its natural table from development to test environment.$ dynamo copy --table foo --pk pkexample#id --index example-index --source prod --target stageCopy queried items in the table's secondary index from production to staging environment.QueryQuery items in specified environment's table.$ dynamo query --table foo pkexample#id --env dev --headPrints the number of items queried as well as the first item returned from the query.$ dynamo query --table foo pkexample#id --env dev --unique entity-typePrints the number of items queried as well as the unique attribute values of the specified field. Atrribute value must be str.
Package: dynamo-consistency
Dynamo Consistency is the consistency plugin for Dynamo Dynamic Data Management System.
Even though Dynamo controls and tracks the history of file transfers between computing sites,
a separate check is needed to ensure files are not lost or accumulated during user or system errors.
Sites that can no longer access files after a power outage, for example,
can cause other problems for the entire data management system.
Transfers requested from the site to another site will fail for missing files.
Sites are chosen incorrectly for production jobs that assume the presence of a local file.
Last disk copies may also be missing, causing a delay for user requests for data.
Another type of inconsistency is caused when files thought to be deleted are still on disk.
This leads to wasted disk space for files that are not accessed, except by accident.
Dynamo Consistency does its check by regularly listing each remote site and
comparing the listed contents to Dynamo’s inventory database.The package also includes a number of modules that can be imported independently
to create custom consistency check runs.
A simple consistency check on a site can be done by doing the following
when an instance ofdynamois installed:from dynamo_consistency import config, datatypes, remotelister, inventorylister

config.LOCATION = '/path/to/config.json'
site = 'T2_US_MIT'                        # For example

inventory_listing = inventorylister.listing(site)
remote_listing = remotelister.listing(site)

datatypes.compare(inventory_listing, remote_listing, 'results')In this example,
the list of file LFNs in the inventory and not at the site will be inresults_missing.txt.
The list of file LFNs at the site and not in the inventory will be inresults_orphan.txt.
Thelistingfunctions can be re-implemented to perform the check desired.InstallationDynamo Consistency requires theXRootDPython module to be installed separately.
In addition, it uses the Dynamo Dynamic Data Management package to get inventory listings
and to report results of the consistency check.
Any other needed packages are installed with Dynamo Consistency during installation.The simplest way to install is through pip:pip install dynamo-consistencyThe source code is maintained onGitHub.
Other typicalsetuptoolsmethods are supported by the repository’ssetup.py.
Package: dynamo-dao
Dynamo DaoTyped library for interacting with DynamoDb tables.InstallationAvailable onPyPIpip install dynamo-daoUsageThe following example code shows some basic usage of this package. Note that theExampleDaomust define 4 abstract properties:table_name- Name of the DynamoDb table resource (maps directly to what you'd see on the AWS console).unique_key- The list of keys that together uniquely define an entry in the table.convert_to_dynamo- A method which takes in the object and converts it to the entry in the DynamoDb tableconvert_from_dynamo- The opposite ofconvert_to_dynamofrom typing import NamedTuple

from dynamo_dao import Dao, DynamoObject

class Example(NamedTuple):
    foo: str
    bar: int

class ExampleDao(Dao[Example]):
    table_name = "example"
    unique_key = ["foo"]

    def convert_to_dynamo(self, var: Example) -> DynamoObject:
        return {"foo": var.foo, "bar": var.bar}

    def convert_from_dynamo(self, var: DynamoObject) -> Example:
        return Example(foo=str(var["foo"]), bar=int(var["bar"]))


example_dao = ExampleDao()

example = Example(foo="hi", bar=1)

example_dao.create(example)
result = example_dao.read_one("foo", "hi")

assert example == resultWhy use?The base dao is agenericobject, which means child classes will benefit from type checking on functions likereadandcreate.In the example above, the type ofresultisExample.
Package: dynamodb
python-dynamoDynamoDB SDK AWS implementation in Python developed by AllanKT.DescriptionThis SDK was written to assist the development of applications that use the AWS DynamoDB service, to management CRUD operations.InstallYou can installdynamodbwith pip:PyPi:pipinstalldynamodbUsageFirst to first, set your credentials AMI in a dict object:credentials={'region_name':'<REGION_NAME>','aws_access_key_id':'<ACCESS_KEY>','aws_secret_access_key':'<SECRET_KEY>'}Then define your tables configurations:tablename: (required) Name to your table;uuid: (optional) Set this field if you want it to be automatically filled with a uuid4, with its value as the name of the table's primaryKey;timestamp: (optional) Set this field if you want createdAt and updateAt columns to be filled in automatically;tables=[{'tablename':'teste1','uuid':'id','timestamp':True,},{'tablename':'teste2','uuid':'my_id',},{'tablename':'teste3',}]Importdynamodbin your code and create a connection with database:fromdynamodbimportDynamodynamo=Dynamo(credentials,tables)Use tablesdynamo.teste1dynamo.table['teste1']Insertdynamo.teste1.insert({'x':'teste','y':1,'z':'A'}){'id':'ac38f1...591e14d','x':'teste','y':1,'z':'A','updated_at':1592697324.910402,'created_at':1592697324.910402,}Getd.teste1.get('ac38f1...591e14d'){'id':'ac38f1...591e14d','x':'teste','y':1,'z':'A','updated_at':1592697324.910402,'created_at':1592697324.910402,}Deleted.teste1.delete('ac38f1...591e14d')Batch Insertdatas=[{'x':'teste1','y':1,'z':'A',},{'x':'teste2','y':2,'z':'B',},{'x':'teste3','y':3,'z':'C',}]dynamo.table1.batch_insert(datas)Batch_getdynamo.table1.batch_get(['ac38f1...591e14d','0be3f5...59104ad'])[{'id':'ac38f1...591e14d''x':'teste1','y':1,'z':'A','updated_at':1592697324.910402,'created_at':1592697324.910402,},{'id':'0be3f5...59104ad','x':'teste2','y':2,'z':'B','updated_at':1592697324.910402,'created_at':1592697324.910402,}]Batch_deletedynamo.table1.batch_delete(['ac38f1...591e14d','0be3f5...59104ad'])Scandynamo.teste1.scan({'index':'z-index',# optional'query':{'x':{'and':{'begins_with':'1'}},'y':{'and':{'between':[1,2]}},'z':{'or':{'in':['A','B']}}}})Operations usade:'column_name':{'operator':{'expression_operator ':'value'}}Operators:OperatorDescriptionandAND conditional operatororOR conditional operator<Less Than operator<=Less Than or Equal To operator>Greater than operator>=Greater Than or Equal To operator=Equal Than operator!=Different conditional operatorExpression Operators:Expression OperatorDescriptionbetweenKey between two valuesinKey is contant in a listbegins_withKey begin with the valueattribute_type???contains???Implementation DetailsSupported Python VersionsPython 3.5Python 3.6Python 3.7Licensepython-dynamo is licensed under the Apache License version 2. See ./LICENSE.rst.
Package: dynamodb-autoincrement
python-dynamodb-autoincrementUse optimistic locking to put DynamoDB records with auto-incrementing attributes. This is a Python port ofhttps://github.com/nasa-gcn/dynamodb-autoincrement. Inspired by:https://aws.amazon.com/blogs/aws/new-amazon-dynamodb-transactions/https://bitesizedserverless.com/bite/reliable-auto-increments-in-dynamodb/
Package: dynamodb-backup
Backup aDynamoDBtable to anAvrocontainer.Currently, only full table backups are supported.Installationdynamodb-backupis available on thePython Package Index:pipinstalldynamodb-backupdynamodb-backup optionally supports thesnappycodec for compression if the Python snappy package is installed. This can be
installed using the pip extras install:pipinstalldynamodb-backup[snappy]Usagedynamodb-backup --help
usage: dynamodb-backup [-h] [-c {snappy,none,deflate}] [-s] [-v]
                       schema table destination

Backup a DynamoDB table to an Avro Container

positional arguments:
  schema                Avro Schema to use
  table                 DynamoDB table name
  destination           Destination file path for the backup file

optional arguments:
  -h, --help            show this help message and exit
  -c {snappy,none,deflate}, --codec {snappy,none,deflate}
                        Compression Codec. Default: deflate
  -s, --skip-validation
                        Do not validate records against the avro schema
  -v, --verbose         Verbose logging output
Package: dynamodb-cache
Welcome todynamodb_cacheDocumentationRedis is a good distributive cache. What if I don’t want to manage a server? AWS Dynamodb could be another awesome backend for distributive cache. Reasons are:It takes 5 seconds to create a backend tableNo server to manageIt automatically scale up and downThe pricing can be pay-as-you-goIt can handle 1K + concurrent read easilyTODO: add usage docInstalldynamodb_cacheis released on PyPI, so all you need is:$pipinstalldynamodb_cacheTo upgrade to latest version:$pipinstall--upgradedynamodb_cache
Package: dynamodb-ce
dynamodb-ceInstallationpip install dynamodb-ceOverviewdynamodb-ceis a compiler that can compileDynamoDB Conditional Expressionsinto executable Python truthy functions that evaluate either a Pythondictor a DynamoDB item (with DynamoDB typing).Setting up the parser requires setting expression attribute names and values, just as they would be set
when calling DynamoDB. Expression attribute values can be represented either using Python types or DynamoDB
types.Compilation is done once per (expression, attribute names, attribute values) tuple and cached. The truthy function that is the result of the compilation is designed to beextremelyfast.Lexing and parsing courtesy ofSLY.UsageUsing DynamoDB types:fromdynamodb_ceimportCeParserparser=CeParser(expression_attribute_names={"#path":"body"},expression_attribute_values={':string1':{'S':"a"},':string2':{'S':"b"},':number1':{'N':1},':number2':{'N':2}})item={"body":{"M":{"number1":{"N":1},"number2":{"N":2},"string1":{"S":"a"},"string2":{"S":"b"}}}}parser.evaluate("#path.string2 > #path.string1",item)Using Python typesfromdynamodb_ceimportCeParserparser=CeParser(expression_attribute_names={"#path":"body"},expression_attribute_values={':string1':"a",':string2':"b",':number1':1,':number2':2})item={"body":{"number1":1,"number2":2,"string1":"a","string2":"b"}}parser.evaluate("#path.string2 > #path.string1",item)Using the parsed (compiled) result directlyfromdynamodb_ceimportCeParserparser=CeParser(expression_attribute_names={"#path":"body"},expression_attribute_values={':string1':"a",':string2':"b",':number1':1,':number2':2})item={"body":{"number1":1,"number2":2,"string1":"a","string2":"b"}}truthy=parser.parse("#path.string2 > #path.string1")truthy(item)
Package: dynamo_db_dict
Usage:pip install dynamo_db_dict
from dynamo_db_dict import dynamo_db

db = dynamo_db(aws_access_key_id='YOUR KEY HERE', aws_secret_access_key='YOUR SECRET KEY HERE') # or via: os.environ, ~/.boto, /etc/boto.cfg
# Set table_name_prefix='YOUR_PROJECT_NAME_' if you use the same DynamoDB account for several projects.

# Either create table "user" with hash_key "email" via AWS concole, or via inherited db.create_table(...).
db.user['john@example.com'] = dict(first_name='John', last_name='Johnson') # Put. No need to repeat "email" in dict(...).
john = db.user['john@example.com'] # Get.
assert john == dict(email='john@example.com', first_name='John', last_name='Johnson') # Complete item, with "email".
assert john['first_name'] == 'John' # Key access.
assert john.first_name == 'John' # Attr access.
del db.user['john@example.com'] # Delete.See also:Amazon DynamoDBboto.dynamodb.layer2