Saravanan666/pypi-org huggingface dataset:
Package: dynamic
Class to create dynamic objects.InstallationInstall throughpip.$ pip install dynamicor get from source$ git clone https://github.com/gravmatt/py-dynamic.git
$ cd py-dynamic
$ python setup.py installImport moduleImport the module into your python project.from dynamic import DynamicUsageCreate object when you need them.me = Dynamic()
me.name = 'Rene'
me.username = 'gravmatt'

print '%s (%s)' % (me.name, me.username)

# Rene (gravmatt)Explicit ModeBy default the explicit is ON.That means if you try to get a value that doesn’t exists, a
AttributeError get raised.me = Dynamic()
me.name = 'Rene'

print me.age # age does not exist

# AttributeError: Property 'age' not foundYou can turn the explicit mode off, by:me = Dynamic(explicit=False)
me.name = 'Rene'

print 'My age:', me.age
# My age: NoneNow when you try to access a property that doesn’t exists,Noneget
returned.LicenceThe MIT License (MIT)Copyright (c) 2016 René TanczosPermission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the
“Software”), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Package: dynamical-networks
Complex Network Representations for Coupled Dynamical Systems: Dynamical NetworksThis repository holds the Python code for analyzing and creating complex network representations of coupled dynamical systems.Example coupled dynamical system represented using a complex network with each node as a state variable's dynamics and edges weighted between coupled variables.Full documentation available here:http://www.audunmyers.com/Dynamical_Networks/Install package as:pip install dynamical_networksSee examples here:https://github.com/myersau3/Dynamical_Networks/tree/main/ExamplesThese examples are for simulating the power grid and manufacturer supplier networks.
Package: dynamic-batcher
dynamic-batcherIntrodynamic_batcheris designed for inferencing DL models using GPU and enforces model’s concurrency.Installationpipinstalldynamic-batcherQuickstartAdditional Requirementspipinstall-rrequirements-test.txtRunredisRUN:dockerrun--rm-p6379:6379-eALLOW_EMPTY_PASSWORD=yesbitnami/redis:latestappENV:REDIS__HOST=localhost
REDIS__PORT=6379RUN:gunicorne2e.app.main:app\-k=uvicorn.workers.UvicornWorker\--workers=4batcherENV:REDIS__HOST=localhost
REDIS__PORT=6379

DYNAMIC_BATCHER__BATCH_SIZE=64
DYNAMIC_BATCHER__BATCH_TIME=2RUN:python-mdynamic_batchere2e.batcher.run.add_1--batch-size=64--batch-time=2locustRUN:locust-fe2e/locust/locustfile.pyTestswagger:http://localhost:8000POST/items/batch/{item_id}curl-XPOSThttp://localhost:8000/items/batch/1\-H'Content-Type: application/json'\-d'{
  "content": "string",
  "nested": {
    "key": "string",
    "values": [
      1,
      5,
      2
    ]
  }
}'result:{
  "data": {
    "content": "string",
    "nested": {
      "key": "string",
      "values": [
        1,
        5,
        2
      ],
      "result": [
        2,
        6,
        3
      ]
    },
    "name": "b0878740-47a8-4dd7-bfe8-9c5ed1fee4ea"
  },
  "elapsed_time": 2.551218032836914
}locust:http://localhost:8089ExplanationwhenDYNAMIC_BATCHER__BATCH_SIZE=64andDYNAMIC_BATCHER__BATCH_TIME=2is set,a runningBatchProcessorwaits to run a batch until the amount of requests received is met(requests count=64), for the batch_time(2 seconds). If the time is up, the partial amount of requests will be processed.Startup logstart test daemon
BatchProcessor start: delay=0.001, batch_size=64, batch_time=2Single request(concurrency=1)batch start: 2.001/2, 1/64
batch start: 2,001/2, 1/64
...Concurrent requests(concurrency=100)batch start: 1.653/2, 64/64
batch start: 0.064/2, 64/64
batch start: 0.064/2, 64/64
batch start: 0.064/2, 64/64
batch start: 0.064/2, 64/64
batch start: 0.064/2, 64/64
batch start: 0.064/2, 64/64
batch start: 0.064/2, 64/64
batch start: 0.064/2, 64/64
batch start: 0.064/2, 64/64
batch start: 0.064/2, 64/64
batch start: 0.064/2, 64/64
...
batch start: 2.001/2, 36/64ConceptRef.:NVIDIA Triton’s dynamic batching
Package: dynamic-cast
Dynamic Casting UtilityIntroductionThis Python module provides a dynamic casting utility that enables flexible casting of function arguments and return values based on type annotations. The utility is particularly useful for handling complex type conversions and ensuring compatibility between different data types.InstallationTo use this dynamic casting utility, you can include it in your project by importing thedynamic_castfunction from the module.fromdynamic_castimportdynamic_castUsageBasic UsageThedynamic_castfunction can be applied to functions to dynamically cast their arguments and return values based on the provided type annotations. It supports various scenarios, including handling iterable types, callables, and more.@dynamic_castdefexample_function(arg1:int,arg2:str)->float:# Function logic here.returnresultAdvanced UsageFor more advanced scenarios, the utility provides additional functionality, such as handling generic types, callable types, and class instances.@dynamic_castdefadvanced_function(arg1:List[int],arg2:Dict[str,float])->Tuple[str,int]:# Advanced function logic here.returnresult_tupleExamples.Dynamic Casting of Arguments.@dynamic_castdefexample_function(arg1:Union[str,int],arg2:List[float])->Tuple[str,List[int]]:# Function logic herereturnresult_tupleDynamic Casting of Class InstancesclassExampleClass:@dynamic_castdef__init__(self,arg1:int,arg2:str)->None:# Class initialization logic hereContributingFeel free to contribute to the development of this dynamic casting utility. If you encounter any issues or have suggestions for improvement, please create an issue or submit a pull request.LicenseThis dynamic casting utility is distributed under the MIT License. See theLICENSEfile for more information.
Package: dynamic-chunks
# dynamic_chunksDetermine appropriate chunk sizes for a given xarray dataset based on target chunk size and ‘chunk aspect ratio’The chunk aspect ratio describes the amount of chunks along a given dimension. Take a dataset with two dimensions (aandb). A chunk aspect ratio{‘a’:2, ‘b’:1}means that the number of total chunks alongbis twice that ofb.
This concept was inspired by a discussion with [Rich Signell](https://github.com/rsignell-usgs) at Scipy ‘23. The idea is that one might want to optimize the chunking of a dataset to make e.g. an operation along time n times slower than an operation along spatial dimensions.## Useage
TBW## Developer GuideSet up your development environment withconda:` conda create--namedynamic_rechunking python=3.10 pip conda activate dynamic_rechunking pip install-e".[test]"`
Package: dynamic-cli
Setup📦1.Installing pip [Python Package Manager]$sudoapt-getinstallpython3-pip2.Clone this repository to your local drive$gitclonehttps://github.com/IndianOpenSourceFoundation/dynamic-cli.git3.Install dependencies$pip3install-rrequirements.txt4.Go to dynamic directory$cddynamic-cli/5.Install with pip$pip3install-e.If you face some issue running dynamic on mac, follow the below instructionsNote for mac users: Make sure to add these lines in you~/.bashrcor~/.zhsrc(depending upon your shell) 👇exportLC_ALL=en_US.UTF-8exportLANG=en_US.UTF-8exportLC_CTYPE=en_US.UTF-8Usage🛠Dynamic CLI allows users to search for keywords/issues with some relevant tags.Arguments⚙Usage: Dynamic [OPTIONS]A Modern, user-friendly command-line HTTP client for the API testing, and if you're stuck - Search and browse StackOverflow without leaving the CLI.Options:-st, --start -> Introduces Dynamic CLI-v, --version -> Gives the Version of the CLI-s, --search -> Search a question on Stackoverflow-no, --notion -> Open browser to login to Notion.so-d, --debug -> Turn on Debugging mode-c, --custom -> Setup a custom API key-h, --help -> Shows this message and exit-GET -> Make a GET request to an API-POST -> Make a POST request to an API-DELETE -> Make a DELETE request to an APILicense🗄The project is licensed under the GNU General Public License v3. Check outLICENSEContributingWe're accepting PRs for our open and unassignedissues. Please checkCONTRIBUTING.md. We'd love your contributions!Kindly follow the steps below to get started:1.Forkthisrepository.2.Clone the forked repository.gitclonehttps://github.com/<your-github-username>/project_name.git3.Navigate to the project directory.cddynamic-cli4.Make changes in source code.P.S. If you want to add emojis 😁, useunicodes.
Emojiunicodescan be found athttps://unicode.org/emoji/charts/full-emoji-list.htmlTo include an emoji in a string, copy the unicode (Eg:U+1F600), replace+with000and
prefix it with a\.Eg:\U0001F6045.Stage your changes and commit# Add changes to Indexgitadd.# Commit to the local repogitcommit-m"<your_commit_message>"7.Push your local commits to the remote repo.gitpush8.Create aPR!9.Congratulations!Sit and relax, you've made your contribution to Dynamic-CLI project.Dynamic CLI is a part of these open source programsContributors👨🏽‍💻Credit goes to these people:✨
Package: dynamic-conf
dynamic-configProject configuration variables are declared beforehand and inferred from environment variables or configuration files. Useful while developing and deploying( CI/CD) django web-appsInstallpip install dynamic-confFeaturessupports.envor.pyfilessupports casting with type annotationsYou also don't need to include a sample file. Since theConfigobject would be able to generate.env.pyitself.It also loads Configuration variables from environment variables.
The order of preference isenv variables>env.pyAttributes are lazily evaluated.Getting StartedYou need to subclass theConfigclass.The config file should define all the variables needed for a project.# project/conf.pyfromdynamic_confimportConfig,REQUIREDclassCONFIG(Config):"""singleton to be used for configuring from os.environ and env.py"""# default settingsENV="prod"# optional field with a default valueDB_NAME="db"DB_HOST="127.0.0.1"DB_USER="postgres"DB_PASS=None# even None could be given as default valueSECRET_KEY:str# Python 3 onlyAN_SECRET_KEY=REQUIRED# Python 2 & 3to createproject/env.pyjust run with the path to CONFIG class's module# you could pass environment variables or set already with exportenvDB_PASS='123'dynamic-confproject/conf.py

dynamic-confproject/conf.pyDB_USER='user-1'DB_PASS='123'# pass as list of key-value pair#to filter environment variables with a prefixenvVARS_PREFIX="PROD_"dynamic-confproject/conf.pyPROD_DB_USER="user-2"UsageTo use the config simply import and use particular attribute# project/settings.pyfromconfimportCONFIGDATABASES={"default":{"ENGINE":"django.contrib.gis.db.backends.postgis","HOST":CONFIG.DB_HOST,"NAME":CONFIG.DB_NAME,"USER":CONFIG.DB_USER,"PASSWORD":CONFIG.DB_PASSWORD,"PORT":"5432",}}
Package: dynamic-config
dynamic_configname = "dynamic_config"description = "Distributed dynamic configuration based on Redis"authors = ["Euraxluoeuraxluo@qq.com"]license = "The MIT LICENSE"repository = "https://github.com/Euraxluo/dynamic_config"installpip install dynamic-configUseAgefrom dynamic_config.dynamic_config import DynamicConfig, Filed
from example.conftest import rdb
from loguru import logger

DynamicConfig.register(rdb,logger=logger)

class ConfigTest(DynamicConfig):
    __prefix__ = "test_config"
    __enable__ = True
    x: str = None
    y: str = Filed(None)

print(ConfigTest.x)
print(ConfigTest.y)
ConfigTest.x = 10
ConfigTest.y = [1,2,3,4]
Package: dynamic-diffraction-module
Dynamic Diffraction ModuleA repository meant for (python based) functions on the dynamic diffraction theory. It is closely related to the Matlab writtenhttps://gitlab.desy.de/patrick.rauer/MatlabDiffractionStuff.
The structure, however, is based on the Dynamic Diffraction submodule of thepXCPframework.Documentation:https://patrick.rauer.gitlab.desy.io/dynamic-diffraction-moduleGitLab:https://gitlab.desy.de/patrick.rauer/dynamic-diffraction-modulePyPI:https://pypi.org/project/dynamic-diffraction-module/FeaturesCurrently, the scope of the package is rather rudimentary.
It includes:computing the (modified) Bragg energy for any given plane H for a specific micro- and macroscopic crystal orientationcomputing the (approximative) energy width for any given plane H for a specific micro- and macroscopic crystal orientation in the two beam approximationSelecting the number of reflecting planes in the vicinity of a given photon energy + crystal orientation configurationcomputing reflectivity/transmissivity vs energy for a specified crystal plane H0 can be computed in the two beam approximationRocking curve scans in the two beam approximationHowever, further functionality is to follow soon:n-beam diffractiondiffraction at strained crystals...External packagesnumpy (required)xraylib(prospectively optional,currently required)matplotlibpandasUsageThere is no documentation for the API yet. However, you can find some tutorial *.ipynb scripts in theplaygrounds folderongitlab.LICENSEFree software: GNU GENERAL PUBLIC LICENSE Version 3CreditsThis package was created withCookiecutterand thewaynerv/cookiecutter-pypackageproject template.
Package: dynamic-dispatch
Dynamic DispatchA lightweight, dynamic dispatch implementation for classes and functions. This allows a class or function to delegate
its implementation conditioned on the value of its first argument. This is similar tofunctools.singledispatch,
however this library dispatches over value while the other dispatches over type.InstallYou may install this via thedynamic-dispatchpackage onPyPi:pip3installdynamic-dispatchUsageDevelopmentWhen developing, it is recommended to use Pipenv. To create your development environment:pipenvinstall--devTestingThis library uses theunittestframework. Tests may be run with the following:python3-munittest
Package: dynamic-enc
Dynamic_enc is a package which uses rolling encryption key.Installation$ pip install dynamic_encHow it worksConsider two keys and for our convenience let's consider them as previous key and current keyThe encrypter returns an encrypted string of three parametershashed Current key encrypted by previous keyNew key encrypted by previous keyData(needs to be sent) encrypted by New keyThe whole string is encrypted in current keyeg . '1,2,3' (these 1 ,2, 3 are the above list)MethodsYou have to initialize the module with your custom previous and current key  eg.object = dyno_encrpter(key) #(Key must be an array)You can later reassign keys withassign_key(keys)encrypt(data)This method is uses the method above to encrypt your datadecrypt(data)This method is uses the method above to decrypt your dataget_current_keys()Will return the current keys in usegenerate_key()This method will help to generate keys( you can use it for initialization)Examplesfrom dynamic_enc import *

keys = dyno_encrypter.generate_keys()
encryption_object = dyno_encrypter(keys)

encrypted_data = encryption_object.encrypt("Hello")
decrypted_data = encryption_object.decrypt(encrypted_data)

current_keys = encryption_object.get_current_keys()

print(encrypted_data,decrypted_data,current_keys)Enjoy!!!
Package: dynamic-executor
Dynamic-executor library for changing python code during runtimeDynamic python is ment to be used in test development for creating and updating tests or wherever the need arises to change the code during runtime and have results visible instantaneously without restarting. The main functionality is provided byDynamicModeExecutor().executegenerator that reloads all project-root modules (neither builtin not venv modules are reloaded).DocumentationCheck outdocumentation.InstallationYou can install thedynamic-executorpackage using pip:pipinstalldynamic-executorOr by cloning the repository directly:gitclonegit@github.com:Tesla2000/dynamic_executor.gitAccessPipyGithubUsageYou can go through video tutorial to check utilities of Dynamic Executortutorial.fromdynamic_executorimportDynamicModeExecutorforerror_messageinDynamicModeExecutor().execute(locals(),globals()):pass
Package: dynamic-form
A package to create forms dynamically from a data store during runtime.DocumentationPlease find the documentation onRead the Docs.Installationpip install dynamic-formPurposeThis package was written during a six month internship and was developed as part of the Study Registration Tool
prototype.AuthorsRafael Müller<mailto:rafa.molitoris@gmail.com> - Initial workLaura Badi- Supervisor
Package: dynamicformset
# Dynamic form set for Django appAllows to add and delete forms with a click of a button. Can make forms sortable.## RequirementsDjango framework, jQuery and jQuery UI.## Installation```pip install dynamicformset```## UsageAdd "dynamicformset" to installed apps in django settings file:```pythonINSTALLED_APPS = (...'dynamicformset',...)```Then it can be used in model:```pythonfrom django.forms import formset_factoryfrom dynamicformset import DynamicFormSetmyformset = formset_factory(MyForm, formset=DynamicFormSet, can_order=True, can_delete=True, extra=0)```Make sure required css and js files are included in a template:```{{ myformset.media.css }}{{ myformset.media.js }}```
Package: dynamic-function-loader
dynamic-function-loaderInstallationpip install dynamic-function-loaderOverviewdynamic-function-loader allows dynamically loading a Python function into the current execution
environment from astring.Usageimportdynamic_function_loaderf=dynamic_function_loader.load("def foo():\nreturn 'bar'")f()GlobalsAll functions (and other Python objects) are provided a two symbol tables upon creation; globals and locals.dynamic_function_loader.loadtakes an optional argument calledglobals_dict.
This is used during function creation to provide the loaded function with it's
globals.There are several use cases regarding this:You wish to load the functionas-ifit was defined within your loading script: In this case,
simply pass inglobals(). The loadedfunctionwillhave access to the loading script's symbol table.You wish to load the functionas-ifit was defined in a seperate module:
In this case, either do not pass a value or pass inNoneor{}. The loaded
functionwill nothave access to the loading script's symbol table.You wish to load the function withsomeof the symbol table from the loading script:
In this case, copy the result fromglobals()in the loading script and pare the items from
the script that you donotwish the loaded function to have access to and pass in the result. Be careful!
Python will let you pare down to an empty dict ({}), but your loaded function will havenoaccess to even
the built-ins of Python. Generally, if you do this, it should at least contain those items that begin and end
with__. For example:func_globals={}# You must convert to a list because every# variable you declare alters the symbol tablefork,vinlist(globals().items()):ifk.startswith("__")andk.endswith("__"):func_globals[k]=vNoteAll Python packages used by the imported function must be loadedwithinthe function itself if theglobals_dictthat you pass in does not contain that module already (options 2 and possibly 3 from above).For example, ifrewas not already in the global symbol table you would have to import it as follows:deffoo(regex):importrereturnre.compile(regex)
Package: dynamicgem
dynamicgemLibrary DocumentationGraph embedding methods aim to represent each node of a graph in a low-dimensional vector space while preserving certain graph's properties. Such  methods  have been used to tackle many real-world tasks, e.g.,  friend recommendation in social networks, genome classification in biology networks, and visualizing topics in research using collaboration networks.More recently, much attention has been devoted to extending static embedding techniques to capture graph evolution. Applications include  temporal link prediction, and understanding the evolution dynamics of network communities. Most methods aim to efficiently update the embedding of the graph at each time step using information from previous embedding and from changes in the graph. Some methods also capture the temporal patterns of the evolution in the learned embedding, leading to improved link prediction performance.In this library, we present an easy-to-use toolkit of state-of-the-art dynamic graph embedding  methods.dynamicgemimplements methods which can handle the evolution of networks over time. Further, we provide a comprehensive framework to evaluate the methods by providing support for four tasks on dynamic networks: graph reconstruction, static and temporal link prediction, node classification, and temporal visualization. For each task, our framework includes multiple evaluation metrics to quantify the performance of the methods. We further share synthetic and real networks for evaluation. Thus, our library is an end-to-end framework to experiment with dynamic graph embedding.
Package: dynamicgut
Please use thecobrapy Google
Groupfor help.
Alternatively, you can usegitter.imfor quick questions
and discussions (faster response times).More information about opencobra is available at thewebsite.InstallationUse pip to install DynamicGut fromPyPI(we recommend doing this
inside avirtual environment):pip install dynamicgutDirect installation in virtual environmentIf virtualenvwrapper is not installed,follow the directionsto install virtualenvwrapper.Run examples in a notebookAn example of how to use DynamicGut is provided in a notebook. Here’s how to start Jupyter and run
the notebook from the virtualenv.Referencescobrapydoi:10.1186/1752-0509-7-74ModelSEEDdoi:10.1038/nbt.1672PATRICdoi:10.1093/nar/gkt1099
Package: dynamic-heartbeat
This file requires editingNote to the author: Please add something informative to this READMEbeforereleasing your software, asa little documentation goes a long way.  Both
README.rst (this file) and NEWS.txt (release notes) will be included in your
package metadata which gets displayed in the PyPI page for your project.You can take a look at the README.txt of other projects, such as repoze.bfg
(http://bfg.repoze.org/trac/browser/trunk/README.txt) for some ideas.CreditsDistributeBuildoutmodern-package-templateNews0.0.2Release date: 21-Feb-2024Add documentation.