Saravanan666/pypi-org huggingface dataset:
Package: dynamoq
Installationpip install dynamoqSynopsisUseaws configureto set up your AWS command line environment.ddbgetTABLE_NAMEHASH_KEYDYNAMODB_TABLE=mytableddbgetHASH_KEYddbputmytable'{"key": "foo", "data": "xyz"}''{"key": "bar", "data": "xyz"}'ddbscanmytableecho'{"data": "update"}'|ddbupdatemytablemykeyddbupdatemytablemykeyfield1=2field2=[]--condition"field3 eq 456"ddbupdatemytablemykeyfield1=2field2=[]--condition"field4 between 7,8"SeeDynamoDB Conditionsfor more.AuthorsAndrey KislyukLinksProject home page (GitHub)Documentation (Read the Docs)Package distribution (PyPI)Change logBugsPlease report bugs, issues, feature requests, etc. onGitHub.LicenseLicensed under the terms of theApache License, Version 2.0.
Package: dynamoquery
DynamoQueryHelper for building Boto3 DynamoDB queries.DynamoQueryInstallationUsageDynamoQueryDynamoTableDevelopmentVSCodePyCharmVersioningInstallationpython-mpipinstalldynamoqueryUsageYou can find commented usage examples inexamplesdirectory.DynamoQueryimportboto3fromdynamo_queryimportDynamoQuery,DataTabletable_resource=boto3.resource("dynamodb").Table('people')query=DynamoQuery.build_scan(filter_expression=ConditionExpression('first_name')&('last_name','in'),).limit(5,).projection('first_name','last_name','age',).table(table_resource=table_resource,table_keys=('pk',),)...# simple querydata={'first_name':'John','last_name':['Cena','Doe','Carmack'],}result_data_table=query.execute_dict(data)forrecordinresult_data_table.get_records():print(record)# batch getdata_table=DataTable.create().add_record({"pk":"my_pk"},{"pk":"my_pk2"},{"pk":"my_pk3"},)result_data_table=query.execute(data_table)forrecordinresult_data_table.get_records():print(record)DynamoTablefromtypingimportOptionalfromdynamo_queryimportDynamoTable,DynamoDictClass# first, define your record@dataclassclassUserRecord(DynamoDictClass):pk:stremail:strname:strpoints:Optional[int]=None@DynamoDictClass.compute_key("pk")defget_pk(self)->str:returnself.email# Create your dynamo table manager with your record classclassUserTable(DynamoTable[UserRecord]):# provide a set of your table keystable_keys={'pk'}record_class=UserRecord# use this property to define your table resource@propertydeftable(self)->Any:returnboto3.resource("dynamodb").Table("user_table")# okay, let's start using our manageruser_table=UserTable()# add a new record to your tableuser_table.upsert_record(UserRecord(email="user@gmail.com",name="John User",age=12,))# and output all the recordsforuser_recordinuser_table.scan():print(user_record)DevelopmentInstall dependencies withpipenvpython-mpipinstallpipenv
pipenvinstall-dEnablepylintandmypychecks in your IDE.Run unit tests and linting../scripts/before_commit.shAdd false-positive unused entities tovulturewhitelistvulturedynamo_query--make-whitelist>vulture_whitelist.pyVSCodeRecommended.vscode/settings.json{"python.pythonPath":"<pipenv_path>/bin/python","python.linting.pylintEnabled":true,"python.linting.enabled":true,"python.linting.mypyEnabled":true,"python.formatting.provider":"black"}PyCharmInstallmypyunofficial extensionInstallblackextension, enable format on saveRunpylinton saveVersioningdynamo_queryversion followsSemantic Versioning.
Package: dynamoquick
dynamoquickUnder construction! Not ready for use yet! Currently experimenting and planning!Developed by Zuhair (c) 2022Examples of How To Use (1.0 Version)Methods Available:check_exist(client,tablename)
create_table1(dynamodb,tablename,hashname,hashtype,sortname,sorttype,readcapacity,writecapacity)
create_table2(dynamodb,tablename,hashname,hashtype,readcapacity,writecapacity)
load_table(dynamodb,tablename,files)
delete_table(dynamodb,tablename)
view_table_specific(dynamodb,tablename,key,value,projection,page)
update_item(dynamodb,tablename,hashname,hashvalue,updatename,updatevalue,sortname=None,sortvalue=None)
delete_item(dynamodb,tablename,hashname,hashvalue,sortname=None,sortvalue=None)
filter_details1(dynamodb,tablename,queriesname,queriesvalues,client)
filter_details2(dynamodb,tablename,queriesnames,queriesvalues,client)Importing in other program:fromdynamoquickimport*Sample Demofromdynamoquickimport*importboto3dynamodb=boto3.resource("dynamodb",endpoint_url="http://localhost:8000",region_name='us-west-2',aws_access_key_id="fakeid",aws_secret_access_key="fakekey")client=boto3.client('dynamodb',endpoint_url='http://localhost:8000',region_name='us-west-2',aws_access_key_id='fakeid',aws_secret_access_key='fakekey')if__name__=="__main__":tablename=input("TableName:")ifnotcheck_exist(client,tablename):hashname=input("Hashname:")hashtype=input("Hashtype:")readcapacity=input("Readcapacity:")writecapacity=input("Writecapacity:")res=input("Do you have sortkey:")ifres=="yes":sortname=input("Sortname:")sorttype=input("Sorttype:")create_table1(dynamodb,tablename,hashname,hashtype,sortname,sorttype,readcapacity,writecapacity)else:print("No Sort Key")create_table2(dynamodb,tablename,hashname,hashtype,readcapacity,writecapacity)print('Table Created Successfully')else:print('Table with name%salready existed!'%tablename)
Package: dynamore
DYNAMOREDynamore is extremely simple Python library formanaging entitieson DynamoDb. It’s designed to be used together with REST API and only supportssingle table design.InstallationInstall from Pypi:$pipinstalldynamoreQuick startDynamore doesn’t manage your tables so create DynamoDb table beforehand e.g. provisioning by CloudFormation.Here’s the simple example on how to create Person schema and store it to DynamoDb:fromdynamore.dynamodb_proxyimportDynamoDbProxyfromdynamore.entityimportEntityclassPerson(Entity):SCHEMA={"title":"PERSON","type":"object","required":["name","age","gender","id_number"],"properties":{"name":{"type":"string"},"age":{"type":"integer","min":0,"max":123},"gender":{"type":"string","enum":["male","female"]},"id_number":{"type":"string"},},"additionalProperties":False,}ID_ATTRIBUTE="id_number"db=DynamoDbProxy(table_name="MyTable")data={"name":"Jeanne","age":123,"gender":"female","id_number":"123456"}_=db.post(entity_class=Person,data=data)# Get single itemitem=db.get(entity_class=Person,data={"id_number":data["id_number"]})# Get all items of type "Person"items=dynamodb_proxy.get(entity_class=Person)First a new entity class Person defined. It’sschemais defined using jsonschema andid attributedefines the name of the attribute that is used for uniqueness.Dynamore stores data to DynamoDb in the following format:PKSKnameagegenderPERSON123456Jeanne123femaleBy default entity uses partition key “PK” and sort key “SK” value but you can define them otherwise by overriding pr_keys-method.
Package: dynamo-size
dynamo-sizeRoughly calculatesDynamoDB item size.item={'Id':123,'Names':['foo','bar','qux',# 500 more names]}fromdynamo_sizeimportcalculate_bytes,calculate_kbytescalculate_bytes(item)# returns 2025calculate_kbytes(item)# return 1.9775390625 (2025 / 1024)
Package: dynampy
DynampyStands for"dynamically organized Python program". In other words, specify what isabout to be computed, store them ascallbacks, and organize such callbacks in an efficient manner that does not require low-level modification of your code.Functionalityauto-detection of parallelizable computationauto-handled parallelizationpytestTests should be put in thetestsdirectory.To run tests, go to the repo's home directory and runpython -m pytest
Package: dynaphopy
DynaPhoPySoftware to calculate crystal microscopic anharmonic properties
from molecular dynamics (MD) using the normal-mode-decomposition technique.
These properties include the phonon frequency shifts and linewidths,
as well as the renormalized force constanst and thermal properties
by using quasiparticle theory. This code includes interfaces for MD
outputs from VASP and LAMMPS. PHONOPY code is used to obtain harmonic
phonon modes.Online manual:http://abelcarreras.github.io/DynaPhoPy/Installation instructionsRequirementsPython 2.7.x/3.5 or higherPhonopy 2.0 or higher (https://phonopy.github.io/phonopy)MatplotlibScipyh5pypyYAML(optional) pyFFTW (http://www.fftw.org/)(optional) cuda_functions (https://github.com/abelcarreras/cuda_functions)2a. Install from pypi repositorypip install dynaphopy --user2b. Install from source (requires c compiler)Install requirements from requirements.txt:pip install -r requirements.txt --userRun setup.py to install dynaphopypython setup.py install --userExecuting this softwareCommand line methodexecutedynaphopy -hfor detailed description of available optionsdynaphopy input_file MD_file [Options]Interactive modeUse -i option from command line method and follow the instructionsdynaphopy input_file MD_file -iScripting method (as a module)Dynaphopy can be imported as a python moduleIn examples/api_scripts directory an example script is available (script_silicon.py)The comments in the script makes it (hopefully) self explained.Input files for several materials can be found in the same example/inputs directory.
More information in the online manual at:http://abelcarreras.github.io/DynaPhoPyContact infoAbel Carrerasabelcarreras83@gmail.comDonostia International Physics Center (DIPC)Donostia-San Sebastian (Spain)
Package: dynaphos
About the projectA fully differentiable and biologically plausible simulation of cortical prosthetic vision, which can be used for end-to-end optimization.Installationpip install dynaphosGetting StartedDownload the default configuration file (config/params.yaml) fromour repositoryand adjust according to needs.Run thetestsuite.See theexamplesdirectory for simple use cases.Citationvan der Grinten, M. L., de Ruyter van Steveninck, J., Lozano, A., Pijnacker, L., Rueckauer, B., Roelfsema, P., van Gerven, M., van Wezel, R., Güçlü, U., & Güçlütürk, Y. (2022). Biologically plausible phosphene simulation for the differentiable optimization of visual cortical prostheses. [bioRxiv]https://doi.org/10.1101/2022.12.23.521749ExperimentsFor the end-to-end optimization experiments in our BioRxiv publication seethis repository.
All other code that was used for the other experiments in our publication can me made available on request.ContactFeel free to submit an issue, we're happy to help.
Package: dynapipe
Dynamic PipelineAuthor:Tony DongDynamic Pipelineis a high-level API toolkit to help data scientists building models in ensemble way, and automating Machine Learning workflow with simple codes.Comparing other popular "AutoML or Automatic Machine Learning" APIs,Dynamic Pipelineis designed as an omni-ensembled ML workflow optimizer with higher-level API targeting to avoid manual repetitive train-along-evaluate experiments in general pipeline building.To achieve that,Dynamic PipelineappliesPipeline Cluster Traversal Experimentsalgorithm to assemble all cross-matching pipelines covering major tasks of Machine Learning workflow, and apply traversal-experiment to search the optimal model. Besides, by modularizing all key pipeline components in reuseable packages, it allows all components to be custom tunable along with high scalability.The core concept inDynamic PipelineisPipeline Cluster Traversal Experiments, which is a theory, first raised by Tony Dong during Genpact 2020 GVector Conference, to optimize and automate Machine Learning Workflow using ensemble pipelines algorithm.Comparing other automatic or classic machine learning workflow's repetitive experiments using single pipeline,Pipeline Cluster Traversal Experimentsis more powerful, with larger coverage scope, to find the best model without manual intervention, and also more flexible with elasticity to cope with unseen data due to its ensemble designs in each component.Documentation:https://dynamic-pipeline.readthedocs.io/InstallationpipinstalldynapipeLicense:MIT 漏Tony Dong
Package: dynaport
dynaportDynaport serves as a python module that will enable you to dynamically import modules from anywhere on the filesystem. This module acts as a wrapper of the python import library to offer an easy to use syntax for dynamically importing modules in python. Dynaport is able to support Python2, Python3.3, Python3.4, and Python3.5+ automatically.installationpip3 install dynaportimportingfrom dynaport.dynaport import DynaportfunctionsDynaport(config="/path/to/config.json")instantiation of the Dynaport class, has an optional parameterconfigto load a config file. The config parameter can also take a dict as input. Needs to follow the same structure as the config file.Dynaport.get_module(name="module_name", path="/path/to/module.py")loads and returns the moduleDynaport.get_modules(modules=["module1", "module2", "module3"], dict=True)loads and returns multiple modules as a tuple, optionaldictparam to load the modules into a dict.NOTE: module names need to be unique or else they will be overwritten when creating the dictDynaport.get_config()returns the loaded config fileDynaport.set_config(config=/path/to/config.json")same behavior as loading a config on instantiationconfig fileDynaport is able to use a json configuration file to define filepaths to modules you want to import.The current format of the configuration file is as follows:{"modules":{"module_name":"/path/to/module.py"}}featuresall paths can have environment variables put in the path names. Windows can have %name% and Linux can have $namefuture workadd support for yaml files (but not require the dependency to be installed)
Package: dyna_settings
Dynamic project settings enabling automatically switching settings between production and various development and testing environments.Free software: BSD licenseDocumentation:https://dyna_settings.readthedocs.org.FeaturesAutomatically detect when the code is run in a specific type or class of environmentsSimilar to the popular12-Factorbaseddjango-environSupports automatic environment variable overrides or exclusionsSupports broad categories of execution environments, or specific developer/testing setupsHistory0.1.0 (2015-7-6)First release on PyPI.0.1.1 (2015-7-7)Changed module from dyna_settings to coreTrying to figure out why pip install won’t work.
Package: dynash
dynash======A simple "shell" to access DynamoDB via "boto".### Usage# boto dynamodb APIs> dynash [--verbose] [--env=environment]# boto dynamodb2 APIs> dynash2 [--verbose] [--local] [--env=environment]### DescriptionYou can create/delete/list/describe tables, add/modify/delete/list records and more.- ls: list tables- create {tablename}: create table- delete {tablename}: delete table- describe {tablename}: describe table- capacity {tablename} {read_capacity} {write_capacity}: update table capacity- use {tablename}: select table- scan/l: list table content- get {id}: get item(s) from table- put {id} {properties}: add item to table- update {id} {properties}: update item- rm {id}: remove item from table- query/q: query tableand many more (use 'help' to find the available commands)### Note:- Credentials should be in your .boto config file under the [Credentials] (see http://docs.pythonboto.org/en/latest/boto_config_tut.html)- You can specify the DynamoDB region to use and other DynamoDB related configuration entries in your .boto config under the [DynamoDB] section:[DynamoDB]region=us-west-1- You can specify alternative environments in your .boto by adding boto sections prefixed with the environment name, and then selecting the environment at startup:--- .boto -------[Credentials]...[env.Credentials]...[env.DynamoDB]...--- run --------> dynash --env=env- Item related commands use the currently selected table (see 'use' command) but you can pass a table name as first parameter prefixed by ':'- Command completion is enabled (and it will complete table names)- You can set various flags (like debug, verbose, pretty-print, etc.) using the 'set' command (try 'set -l')k- You can redirect the output of commands using standard shell redirection ( > outfile )- You can execute shell commands using '!shell command'
Package: dynasigml
DynaSig-ML packageDynaSig-ML ("Dynamical Signatures - Machine Learning") is a Python
package allowing the easy study of dynamics-function relationships in biomolecules.Online documentation, step-by-step tutorial and installation guide:https://dynasigml.readthedocs.ioCompanion repository for the tutorial:https://github.com/gregorpatof/dynasigml_mir125a_exampleIf you use DynaSig-ML, please cite these two articles:https://doi.org/10.1101/2022.07.06.499058https://doi.org/10.1093/bioinformatics/btab189DynaSig-ML automatically computes and
stores Dynamical Signatures of sequence variants using ENCoM (Elastic Network Contact Model), a sequence-sensitive
coarse-grained normal mode analysis model. These Dynamical Signatures, along with optional additional data (for example
the ddG of folding of the mutation), are then used to automatically train LASSO
multilinear regression, in addition to any number of user-specified machine learning models, provided thay are implemented
in sckikit-learn. The LASSO coefficients are automatically mapped back on the biomolecules'
structure and can be easily visualized using PyMOL, leading to biological insights.The guide provides examples using
experimental miR-125a (a human microRNA) maturation efficiency data, as described in our previous work
(https://doi.org/10.1371/journal.pcbi.1010777). The method is generalizable
to any biomolecule on which mutational data exists, and for which an input structure is known or can be predicted with confidence.
Package: dynasim
DynaSimThe dynasim package simulates dynamic systems in the form:
$$
\mathbf{M}\ddot{\mathbf{x}} + \mathbf{C}\dot{\mathbf{x}} + \mathbf{K}\mathbf{x} + \mathbf{C}n g_c(\mathbf{x}, \dot{\mathbf{x}}) + \mathbf{K}n g_k(\mathbf{x}, \dot{\mathbf{x}}) = \mathbf{f}
$$
where $\mathbf{\Xi}n g{\bullet}(\mathbf{x},\dot{\mathbf{x}})$ represents the nonlinear system forces. For example, a 3DOF Duffing oscillator, connected at one end, would have representative nonlinear forces,
$$
\mathbf{K}n g_n(\mathbf{x}) = \begin{bmatrix}
k{n,1} & - k{n,2} & 0 \
0 & k{n,2} & -k_{n,3} \
0 & 0 & k_{n,3}
\end{bmatrix}
\begin{bmatrix}
x_1^3 \
(x_2-x_1)^3 \
(x_3 - x_2)^3
\end{bmatrix}
$$Installing DynaSimTo install SynaSim, follow these steps:Linux and macOS:python3 -m pip install dynasimWindows:py -m pip install dynasimUsing DynaSimQuickstart GuideTo use DynaSim, here is a quick start guide to generate a 5-DOF oscillating system with some cubic stiffness nonlinearities:import numpy as np
import dynasim

# create required variables
n_dof = 5
nt = 2048
time_span = np.linspace(0, 120, nt)
# time vector of 2048 time points up to 120 seconds

# create vectors of system parameters for sequential MDOF
m_vec = 10.0 * np.ones(n_dof)
c_vec = 1.0 * np.ones(n_dof)
k_vec = 15.0 * np.ones(n_dof)
# imposes every other connection as having an additional cubic stiffness
kn_vec = np.array([25.0 * (i%2) for i in range(n_dof)])

# create nonlinearities
system_nonlin = dynasim.nonlinearities.exponent_stiffness(kn_vec, exponent=3, dofs=n_dof)
# instantiate system and embed nonlinearity
system = dynasim.systems.cantilever(m_vec, c_vec, k_vec, dofs=n_dof, nonlinearity=system_nonlin)

# create excitations and embed to system
system.excitations = [None] * n_dof
system.excitations[-1] = dynasim.actuators.sine_sweep(w_l = 0.5, w_u = 2.0, F0 = 1.0)

# simulate system
data = system.simulate(time_span, z0=None)NonlinearitiesThree nonlinearities are available, exponent stiffness, exponent damping, and Van der Pol dampingdynasim.nonlinearities.exponent_stiffness(kn_vec, exponent=3, dofs=n_dof)
dynasim.nonlinearities.exponent_damping(cn_vec, exponent=0.5, dofs=n_dof)
dynasim.nonlinearities.vanDerPol(cn_vec, dofs=n_dof)These classes contain the $g_k(\mathbf{x}, \dot{\mathbf{x}})$ function.Common system classesThere are a currently two system types available for MDOF systems, which are instantiated from vectors of system parameter values:dynasim.systems.mdof_symmetric(m_, c_, k_, dofs, nonlinearity)
dynasim.systems.mdof_cantilever(m_, c_, k_, dofs, nonlinearity)Actuator classesThe forcing for the system should be a list of actuations, equal in length to the number of DOFs of the system, there many actuation types,dynasim.actuators.sinusoid(...)
dynasim.actuators.white_gaussian(...)
dynasim.actuators.sine_sweep(...)
dynasim.actuators.rand_phase_ms(...)Totally custom systemOne can generate a custom system by instantiating an MDOF system with corresponding modal matrices, but the nonlinearity must also be instantiated anddynasim.base.mdof_system(M, C, K, Cn, Kn)ContactIf you want to contact me you can reach me atmhaywood@ethz.ch.LicenseThis project uses the following license:MIT.
Package: dynasor
dynasoris a tool for calculating total and partial dynamic structure factors as well as related correlation functions from molecular dynamics (MD) simulations.
Analysis of these functions enables one to access the dynamics of a system without resorting to perturbative approaches.
By combining in particular the structure factor with the cross sections (or form factors) of, e.g., neutrons, X-rays or electrons, it is even possible to directly predict experimental spectra.The main input consists of a trajectory from a MD simulation, i.e., a file containing snapshots of the particle coordinates, and optionally velocities that correspond to consecutively and equally spaced points in (simulation) time.dynasorprovides both python and a command line interface.
The following snippet illustrates how one can calculate dynamic structure factors using the former:.. code-block:: pythontraj = Trajectory(‘dump.xyz’, trajectory_format=’extxyz’)
q_points = generate_spherical_qpoints(traj.cell, q_max=20)
sample = compute_dynamic_structure_factors(traj, q_points=q_points, dt=5, window_size=100)
sample.write_to_npy(‘test.npy’)dynasorcan be installed viapiporconda.
Please consult theinstallation section of the user guidefor details.The full documentation can be found in theuser guide.
For questions and help please use thedynasor discussion forum on matsci.org.dynasorand its development are hosted ongitlab.When usingdynasorin your research please cite the following paper:Dynasor – A tool for extracting dynamical structure factors and current correlation functions from molecular dynamics simulationsErik Fransson, Mattias Slabanja, Paul Erhart, and Göran WahnströmAdvanced Theory and Simulations4, 2000240 (2021); DOI:10.1002/adts.202000240
Package: dynast-release
Dynast: Inclusive and efficient quantification of labeling and splicing RNAs for time-resolved metabolic labeling based scRNA-seq experimentsGetting started-Pipeline usage-Technical information-Full documentationDynast is a command-line pipeline that preprocesses data from metabolic labeling scRNA-seq experiments and quantifies the following four mRNA species: unlabeled unspliced, unlabeled spliced, labeled unspliced and labeled spliced. In addition, dynast can perform statistical estimation of these species through expectation maximization (EM) and Bayesian inference.Key featuresComplete quantification of labeling and splicing of RNA.Unlabeled unspliced, unlabeled spliced, labeled unspliced, labeled spliced species quantification.Highly paralellized and optimized pipeline procedures.Statistical estimation procedure that corrects the observed unlabeled and labeled counts via a Bayesian inference framework.
Package: dynasty
dynastyDynasty extracts the class hierachy for your Python package, to track down lost or misplaced classes and help preventravioli code.Installationpip install dynastyUsageimportmypackagefromdynastyimportDynastymypackage_dynasty=Dynasty(mypackage)# display collapsible class hierarchy (in jupyter notebook)mypackage_dynasty.widget()# print class hierarchy to screenmypackage_dynasty.print()AuthorMichal Golan <migolan@gmail.com>migolan@github