Saravanan666/pypi-org huggingface dataset:
Package: dynattr
dynattrDeveloper GuideSetup# create conda environment$mambaenvcreate-fenv.yml# update conda environment$mambaenvupdate-ndynattr--fileenv.ymlInstallpipinstall-e.# install from pypipipinstalldynattrnbdev# activate conda environment$condaactivatedynattr# make sure the dynattr package is installed in development mode$pipinstall-e.# make changes under nbs/ directory# ...# compile to have changes apply to the dynattr package$nbdev_preparePublishing# publish to pypi$nbdev_pypi# publish to conda$nbdev_conda--build_args'-c conda-forge'$nbdev_conda--mambabuild--build_args'-c conda-forge -c dsm-72'UsageInstallationInstall latest from the GitHubrepository:$pipinstallgit+https://github.com/dsm-72/dynattr.gitor fromconda$condainstall-cdsm-72dynattror frompypi$pipinstalldynattrDocumentationDocumentation can be found hosted on GitHubrepositorypages. Additionally you can find
package manager specific guidelines oncondaandpypirespectively.ExamplefromatypimportStrQfromtypingimportClassVarclassFoo(DynamicAttributesMixin):X:str='X'x:str='X'Z:ClassVar[str]='Z'toinstname=lambdax:f'_{x}'totypename=lambdax:x.upper()def__init__(self,x:StrQ=None):self.x=(xorself.x)f,b=Foo(x='x'),Foo()(f.x,f.X,f.Z),(b.x,b.X,b.Z),(Foo.x,Foo.X,Foo.Z,)(('x', 'X', 'Z'), ('X', 'X', 'Z'), ('X', 'X', 'Z'))f.getinstclsattr('x',toinstname=None,totypename=None)'X'
Package: dynatype
dynatypeA dynamic type checker for Python.What happens?When you import the module, it silently decorates all your functions with a type checker.How do I use it?Type annotate it like you would in regular Python except using the annotation object (e.g.def f(a: dynatype.annotation(lambda x: type(x) is float or type(x) is int, lambda x: x < 0.5))). That annotation only allows numbers less than 0.5 to be passed into the function.What happens when an innapropriate value is passed?ATypeErroris raised, allowing you to catch the error if you don't want the program to stop.
Package: dyncache
Dynamic input-output caching for deterministic functionsFeaturesKeep It Simple, Stupid: A single decorator that does everything for youAutomagically detects if the decorated function is changed and transparently
updates cache accordingly without ever returning cached results of the old
function.Installationpip3 install dyncacheExamples# Import the classfromdyncacheimportCache# Use with default options. It will create a file "circle_area.dyncache" into# the current directory.@Cache()defcircle_area(radius):return3.14159*(radius**2)# Empty parentheses are not required for the decorator.@Cachedefcircle_area(radius):return3.14159*(radius**2)circle_area(2)# Calculates and returnscircle_area(3)# Calculates and returnscircle_area(2)# Returns from cache# Saves the cache to /tmp/hello.world.@Cache(root="/tmp",filename="hello.world")defcircle_area(radius):...# Use for function with large input/output -values.@Cache(largeitems=True)defload_all_api_data_for_a_day(day):...# When items are small and cache would update too often, setting autowrite to# False lets you control when the cached data is written to the file.cache=Cache(autowrite=False)@cachedefreally_frequent_function(a,b):......cache.write()# Write cache data to the filesys.exit(0)ContributingSend any issues to GitHub’s issue tracker.Before sending a pull request, format it withBlack(-Sl79)Any changes must be updated to the documentationAll pull requests must be tested with tox (if you are using pyenv, add the installed versions for py35-py38 and pypy3 to .python-version at the root of this repository before running tox)
Package: dynComLogin
Prevent account expiration by automatically logging in to dyn.com.Did you get the friendly “Starting now, if you would like to maintain your
free Dyn account, you must log into your account once a month” email from
dyn.com? Then just have this script executed eg. by cron at least once per
month.Usage: python -m dynComLogin [options]Options:-h,--helpshow this help message and exitMandatory ‘Options’:These ‘options’ must be given.-lLOGIN,--login=LOGINyour dyn.com login. Default: Environment variable
DYN_COM_LOGIN-pPASSWD,--password=PASSWDyour dyn.com password. Default: Environment variable
DYN_COM_PASSWDNotification Options:Specify at least smtpTo if you want to get notification emails.--smtpTo=SMTPTOrecipient of email messages. If given then success or
failure notifications will be sent to this address.--smtpFrom=SMTPFROMsender of email messages--smtpServer=SMTPSERVERSMTP server. Default: Environment variable SMTP_SERVER
or ‘localhost’--smtpLogin=SMTPLOGINlogin for authentification with SMTP server if needed.
Default: Environment variable SMTP_LOGIN--smtpPasswd=SMTPPASSWDpassword for authentification with SMTP serverif
needed. Default: Environment variable SMTP_PASSWD
Package: dyndebug
DynDebug - Dynamic DebugThis library provides the ability to dynamically enable or disable debug through environment configuration.UsageUse the factory method to create a debug instance.  You provide acontextvalue which is used to enable/disable debug through configuration.debug = Debug('MyContext1')Use the debug instance to produce debug contentdebug('This is some debug')Enable the debug at run time by setting the DEBUG environment property to the list of contexts for which you want debug enabled.export DEBUG=MyContext1,MyContext2,...
Package: dyndict
DynDictDynamic Dictionary class for Python adds support for add operation for dictionary classes.DemoPython3.8.3(default,May172020,18:15:42)[GCC10.1.0]onlinuxType"help","copyright","credits"or"license"formoreinformation.>>>fromdyndictimportdyndict>>>dyn=dyndict()>>>dyn{}>>>dyn+={'a':1}>>>dyn{'a':1}>>>dyn+={'b':1}>>>dyn{'a':1,'b':1}>>>dyn+={'b':1}>>>dyn{'a':1,'b':2}>>>dyn+={'list':[]}>>>dyn{'a':1,'b':2,'list':[]}>>>dyn+={'list':[1,2,3]}>>>dyn{'a':1,'b':2,'list':[1,2,3]}>>>dyn+={'list':[{'z':26}]}>>>dyn{'a':1,'b':2,'list':[1,2,3,{'z':26}]}>>>dyn['a']1>>>dyn['list'][3]{'z':26}Installationpipinstalldyndict
Package: dyndnsc-growl
dyndnsc-growl - macOS notifications for dyndnscPlugin fordyndnscthat provides
Growl desktop notifications.Internally usesgntpto implement notifications.Installation# from pypi:$pipinstalldyndnsc-growlRequirementsMacOS 10.8+Python 2.7 or 3.4+0.1 (January 2018)initial public release
Package: dyndnsc-macosnotify
dyndnsc-macosnotify - macOS notifications for dyndnscPlugin fordyndnscthat provides
macOS desktop notifications using notification center.Internally usespyncto implement notifications.Installation# from pypi:$pipinstalldyndnsc-macosnotifyRequirementsMacOS 10.8+Python 2.7 or 3.4+0.1 (January 2018)initial public release
Package: dyndns-updater
dynDNS_updaterstandalone DNS updater for GandiThe main purpose ofdynDNS_updateris to keep the DNS records pointing to your servers up to datewithout any system dependencies(except python, of course) nor any fancy web services to identify their public IPv4 / IPv6UsageInstallpipinstalldyndns-updaterCLIdyndns_updater {now,scheduled} /path/to/your/conf.yamlorpython -m  dyndns_updater {now,scheduled} /path/to/your/conf.yamlMode:now: perform action oncescheduled: perform action every${delta}seconds (see below)Configurationip_identifier:cloudflaredelta:900dns_providers:-gandi:GKDNzPZsdHB8vxA56voERCiCsomedomain.io:subdomain1:Asubdomain2:AAAAsubdomain3:AAAAvariablesdescriptionip_identifierDNS server used to determine your current IP (currently supportingcloudflareandopendns)deltaHow often should dynDNS_updater check and update (in seconds)dns_providerslist ofprovider: API-KEYFeaturesTypes of recordsAAAAASupported DNS providerNameAPI rootGandihttps://api.gandi.net/v5/livednsDeveloppersIf your favorite DNS provider is missing from the list, please consider contributing. Your class just needs to inherit fromUpdaterand possess the following methods to work in dynDNS_updaterclassYourProviderUpdater(Updater):definitialize(self):your_logic="please write unit tests along the way"defcheck_and_update(self):your_logic="please write unit tests along the way"Onboardingpoetry: dependency managerblack: code formatergitclonehttps://github.com/zar3bski/dynDNS_updater.gitcddynDNS_updater
poetryinstallThis will create a virtual env with all dev dependenciesSome usefull commandsrununit tests:poetry run pytestadd dependencies :poetry add some-lib
Package: dynect-client
Just a simple wrapper around the Dynect REST API.  There are three important API functions.getRecords(hostName=”foo.mydomain.com”)Gets all records associated with foo.mydomain.comaddRecord(data=”1.2.3.4”, hostName=”bar.mydomain.com”, type=”A”, TTL=3600)Adds a new DNS A Record for bar.mydomain.com of 1.2.3.4deleteRecord(data=”1.2.3.4”, hostaName=”bar.mydomain.com”, type=”A”)Deleted the 1.2.3.4 A record from bar.mydomain.com>>> import dynect_client
>>> client = dynect_client.DynectDNSClient("mycustomername", "myusername", "mypassword", "mydomain.com")
>>> client.getRecords("foo.mydomain.com")
[{u'status': u'success', u'job_id': 60030085, u'msgs': [{u'INFO': u'get: Found the record', u'SOURCE': u'API-B', u'ERR_CD': None, u'LVL': u'INFO'}], 'value': u'8.8.8.8', 'record': u'foo.mydomain.com', u'data': {u'zone': u'mydomain.com', u'ttl': 600, u'fqdn': u'foo.mydomain.com', u'record_type': u'A', u'rdata': {u'address': u'8.8.8.8'}, u'record_id': 21115048}}, {u'status': u'success', u'job_id': 60030087, u'msgs': [{u'INFO': u'get: Found the record', u'SOURCE': u'API-B', u'ERR_CD': None, u'LVL': u'INFO'}], 'value': u'8.8.4.4', 'record': u'foo.mydomain.com', u'data': {u'zone': u'mydomain.com', u'ttl': 600, u'fqdn': u'foo.mydomain.com', u'record_type': u'A', u'rdata': {u'address': u'8.8.4.4'}, u'record_id': 21115118}}]
Package: dynesty
dynestyA Dynamic Nested Sampling package for computing Bayesian posteriors and
evidences. Pure Python. MIT license.DocumentationDocumentation can be foundhere.InstallationThe most stable release ofdynestycan be installed
throughpipviapip install dynestyThe current (less stable) development version can be installed by runningpython setup.py installfrom inside the repository.DemosSeveral Jupyter notebooks that demonstrate most of the available features
of the code can be foundhere.AttributionIf you find the package useful in your research, please cite at leastbothof these references:The original paperSpeagle (2020)The python implementationKoposov et al. (2023)(the citation info is at the bottom of the page on the right)and ideally also papers describing the underlying methods (see thedocumentationfor more details)Reporting issuesIf you want to report issues, or have questions, please do that ongithub.ContributingPatches and contributions are very welcome! Please seeCONTRIBUTING.mdfor more details.
Package: dynetan
Dynamical Network AnalysisThe Python implementation of Dynamical Network Analysis was built to provide all
functionalities necessary to the analysis of Molecular Dynamics (MD) simulations
using the Dynamical Network Analysis method.InstallInstall the latest version of Dynamical Network Analysis::$ pip install dynetanFor additional details, please seeINSTALL.md.TutorialFor an introduction to this implementation, a jupyter notebook tutorial has been
prepared and released along with its latest publication:Generalized correlation-based dynamical network analysis: a new high-performance
approach for identifying allosteric communications in molecular dynamics
trajectories. J. Chem. Phys. (2020).
DOI: 10.1063/5.0018980DocumentationA full documentation can be found athttps://dynamical-network-analysis.readthedocs.io/en/latest/index.htmlResources and ReferencesFor the background on Dynamical Network Analysis, see the following papers that
describe its development:Generalized correlation-based dynamical network analysis: a new
high-performance approach for identifying allosteric communications in molecular
dynamics trajectories. J. Chem. Phys. (2020).
DOI: 10.1063/5.0018980Experimental and computational determination of tRNA dynamics. FEBS Letters
(2010). DOI: 10.1016/j.febslet.2009.11.061Exit strategies for charged tRNA from GluRS. JMB (2010).
DOI: 10.1016/j.jmb.2010.02.003Dynamical Networks in tRNA:protein complexes. PNAS (2009).
DOI: 10.1073/pnas.0810961106
Package: dynetml2other
dynetml2other_.provides a set of tools for loading Dynamic Network Markup Language (DyNetML) files into theigraph. andNetworkX. Python packages for analyzing networks. It also supports a vanilla network format that uses
dictionaries; while this format doesn’t support the graph libraries’ ability to calculate network features,
it should be much quicker for exploring relationships between nodes.What is DyNetML?DyNetML. is a GraphML-based format for specifying network graphs. It is intended to support ‘Meta-Networks’ that
combine multiple types of nodes that are related in many one- and two-mode networks. It’s the primary format used by theORA. network analysis tool.Why dynetml2other?While potent, ORA is designed to be used through a GUI and doesn’t allow users to manipulate or work with their data
in a programmatic fashion; this makes systematic use of the tool largely impossible. dynetml2other provides a workaround
for this by allowing users to load DyNetML files into graph libraries for Python. Users can manipulate these graphs,
calculate necessary metrics, and then save out the changed results as DyNetML files or any other format of choice.What dynetml2other Is Not:dynetml2other isnota full-featured replacement for ORA or many of its reports.What dynetml2other Is:dynetml2other is a way to use igraph or NetworkX to analyze networks stored in DyNetML. It provides tools for
manipulating DyNetML data that approximate a small number of ORA’s tools form manipulation, and allows users to save
out their work for further manipulation in ORA or other tools.
Package: dynetx
DyNetx - Dynamic Network analysis libraryDyNetx provides implementations of dynamic networks in python (it is built uponnetworkx).The project documentation can be found onReadTheDocs.If you would like to testDyNetxfunctionalities withouth installing anything on your machine consider using the preconfigured Jupyter Hub instances offered bySoBigData++.CitationRossetti, G. (2020) DyNetx: dynamic network analysis library, v0.2.1, Zenodo, doi: 10.5281/zenodo.3953119InstallationIn order to install the library  use pip:pipinstalldynetxor conda:condainstall-cgiuliorossettidynetx
Package: dyneusr-fire
DyNeuSR FireA command line interface forDyNeuSRbased on thePython Firelibrary.UsageDyNeuSR Fireprovides a command line interface forDyNeuSR. It wrapskmapperanddyneusrinto a single pipeline, and uses thePython Firelibrary to automatically generate a simple command line interface that accepts several important options and allows users to customize this pipeline. For more information about DyNeuSR, check out thedocs.To get started, check out theexamples, or try running one of the commands below on your own data.Basic UsageYou can run the entire pipeline from the command line:$dyneusr-fireload_example--size=500-run_mapper--projection=PCA(2)--resolution=10--gain=0.5-visualizeInteractive ModeTo run in interactive mode, you can run the following from the command line:$dyneusr-fireinit----interactiveThis will open an IPython shell.FireisstartingaPythonREPLwiththefollowingobjects:Modules:fire,np,pdObjects:Bunch,Cover,DBSCAN,DyNeuGraph,DyNeuSR,HDBSCAN,KMeans,KeplerMapper,MinMaxScaler,PCA,StandardScaler,TSNE,UMAP,check_estimator,component,f,result,self,tracePython3.7.2|packagedbyconda-forge|(default,Mar192019,20:46:22)Type'copyright','credits'or'license'formoreinformationIPython7.3.0--AnenhancedInteractivePython.Type'?'forhelp.In[1]:Then, you can step through the pipeline:In[1]:pipeline=DyNeuSR()In[2]:pipeline.load_data(X='trefoil.npy',y='trefoil-target.npy')In[3]:pipeline.run_mapper(projection=PCA(2),resolution=10,gain=0.5,clusterer=DBSCAN())In[4]:pipeline.visualize()Or, run it all at once:In[1]:DyNeuSR().load_example().run_mapper(projection=PCA(2),resolution=10,gain=0.5,clusterer=DBSCAN()).visualize()Note, in the examples above,load_exampleis used for demo purposes only. You can replaceload_examplewithload_dataand load your own data by passing the file names of your data and target labels to theXandyarguments, respectively.SetupDependenciesPython 3.6+Required Python Packagesfiredyneusrkmappersklearnumap-learnhdbscanInstall with PIPTo install with pip:pipinstalldyneusr-fireTo install from source:gitclonehttps://github.com/braindynamicslab/dyneusr-fire.gitcddyneusr-fire

pipinstall-e.SupportPlease feel free toreportany issues,requestnew features, orproposeimprovements. You can also contact Caleb Geniesse at geniesse [at] stanford [dot] edu.CitationGeniesse, C., Sporns, O., Petri, G., & Saggar, M. (2019).Generating dynamical neuroimaging spatiotemporal representations (DyNeuSR) using topological data analysis.Network Neuroscience. Advance publication. doi:10.1162/netn_a_00093
Package: dynex
The Dynex SDK provides a neuromorphic Ising/QUBO sampler which can be called from any Python code. Developers and application developers already familiar with the Dimod framework, PyQUBO or the Ocean SDK will find it very easy to run computations on the Dynex neuromorphic computing platform: The Dynex Sampler object can simply replace the default sampler object which typically is used to run computations on, for example, the D-Wave system – without the limitations of quantum machines. The Dynex SDK is a suite of open-source Python tools for solving hard problems with neuromorphic computing which helps reformulate your application’s problem for solution by the Dynex computing platform. It also handles communication between your application code and the Dynex neuromorphic computing platform automatically.
Package: dynfc
dynFC: CoDe-Neuro's Dynamic Functional Connectivity ToolsThis repository contains a Python module consisting of a set of tools developed to infer connectivity from fMRI (BOLD) signals. The module contains both phase-lock and correlation (+ cofluctuation) methods. Please be aware that this is still a develepment version and so may contain bugs and limited functionalities.If you have any questions or suggestions, pleaseopen an issue in the relevant tab.Please do not hesitate to suggest improvements to this module.InstallationThe easiest way to install dynfc is via pip (PyPI) with the command below.pip install dynfcIf you would like to specify a version use the following command to install version0.0.1a1, for example.pip install dynfc==0.0.1a1Alternatively one can clone this repository and add it to a project. For that use the following command.git clone https://github.com/CoDe-Neuro/Built onNumpyScipyThe data used for testing was obtained from the repositorybrain-networks/edge-ts. [no license]Please find references for the methods available here in the relevantdocsfor each function.FundingThis project is funded by a Wellcome Trust Seed Award in Science[217316/Z/19/Z].LicenseMIT LicenseCopyright (c) 2021 Lucas G. S. França and Dafnis BatalléPermission 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: dynlab
dynlabDynlab is a python package to make dynamical systems analysis faster and easier, by providing practitioners prebuilt modules for calculating common diagnostics. Dynlab currently offers several easy to use diagnostics for analyzing your dynamical systems including an FTLE calculatorFLTE, an attraction and repulsion rate calculatorAttractionRate, and a trajectory repulsion rate calculatorRhodot. Dynlab also offers users a variety of prewritten flows to experiment and play around with, including the double gyredouble_gyre, the Duffing oscillatorduffing_oscillator, the pendulum with damping and forcingpendulum, the Van Der Pol oscillatorvan_der_pol_oscillator, the Lotka-Voltera flowlotka_volterra, the Lorenz systemlorenz, and many more. Note that all the flows are written in such a way that they can easily be passed to an ode integrator and as such even the autonomous flows will still require a time parameter to be passed to them.This package is readily available on pypi and can be easily installed with the commandpip install dynlab.
Note that dynlab is written with python 3.11 and you may need to update your python installation to take advantage of it.Exampleimport matplotlib.pyplot as plt
from dynlab.diagnostics import FTLE
from dynlab.flows import double_gyre
x = np.linspace(0, 2, 101)
y = np.linspace(0, 1, 101)
ftle = FTLE().compute(x, y, double_gyre, (10, 0), edge_order=2, rtol=1e-8, atol=1e-8)
plt.pcolormesh(x, y, ftle, shading='gouraud')import matplotlib.pyplot as plt
from dynlab.diagnostics import AttractionRate
from dynlab.flows import double_gyre
x = np.linspace(0, 20000, 101)
y = np.linspace(-4000, 4000, 101)
u, v = bickley_jet(0, np.meshgrid(x, y))
attraction_rate, repulsion_rate = AttractionRate().compute(x, y, u=u, v=v, edge_order=2)
# note that lower values of the attraction rate field equate to higher levels of attraction
# so we'll plot the negative of the attraction rate field to highlight areas of greatest attraction.
plt.pcolormesh(x, y, -attraction_rate, shading='gouraud')import matplotlib.pyplot as plt
from dynlab.diagnostics import Rhodot
from dynlab.flows import bead_on_a_rotating_hoop
x = np.linspace(-1, 1, 401)*3
y = np.linspace(-1, 1, 401)*2.5
rhodot, nudot = Rhodot().compute(x, y, f=bead_on_a_rotating_hoop, t=0, edge_order=2)
plt.pcolormesh(x, y, rhodot, shading='gouraud')
Package: dynmix
This is a Python package focused on clustering and mixture models and is being developed as part of my master's dissertation. The objective is to include various routines for dealing with clustering time-series data, including a dynamic clustering option, which is being proposed in my dissertation.It is currently undergoing development with a lot of changes and may contain errors. However, at your own risk, you may install and use the software through PyPi:pip install dynmixThe project is subject to the terms of the Mozilla Public License, v. 2.0. See the LICENSE file in the root of the repository for further details.Copyright © Victhor S. Sartório. All rights reserved.
Package: dynn
# DyNN: Neural Network routines for DyNet[![Build Status](https://travis-ci.org/pmichel31415/dynn.svg?branch=master)](https://travis-ci.org/pmichel31415/dynn) [![Documentation Status](https://readthedocs.org/projects/dynn/badge/?version=latest)](https://dynn.readthedocs.io/en/latest/?badge=latest)A bunch of useful functions and syntactic sugar to make writing neural networks in [DyNet](http://dynet.io/) easier.## PrerequisiteYou will need to install DyNet as explained [here](http://dynet.readthedocs.io/en/latest/python.html)