Saravanan666/pypi-org huggingface dataset:
Package: dace-query
DescriptionThe dace-query package lets easily query DACE and access public and private data using a simple utility tool.InstallationThe dace-query package is available on PyPi and can be installed usingpiporconda:# Install using pippipinstalldace-query# Update using pippipinstalldace-query--upgrade# Install using conda
# First, create a conda environmentcondacreate-n<env_name>python=3.9# python version equal or upper than 3.9
# Second, activate the environmentcondaactivate<env_name># Finally, install using anaconda pippipinstalldace-queryMake sure the package is installed correctly :# Import daceimportdace_query# List content of the dace packagehelp(dace)AuthenticationIn order to access the private data of DACE, an authentication system has been implemented.
This one works very simply, it just requires three things detailed in the following subsections:A DACE accountAn API keyA local .dacerc file1. Create an accountRegister on theDACE web portalwith a university email address.2. Generate the DACE API keyTo obtain an API key:Login on DACE (https://dace.unige.ch)Go to the user profileClick on [Generate a new API key]Copy this new API key into the .dacerc file3. The .dacerc fileThe.dacercfile, (you have to create it), located by default in the home directory (~/.dacerc) and in TOML
format, defines a user section with a key-value pair specifying the user’s API key (see below).[user]key=apiKey:<xxx-xxx-xxx>For example, if your API key is 12345678-1234-5678-1234-567812345678, then the .dacerc file will be :[user]key=apiKey:12345678-1234-5678-1234-567812345678To create the .dacerc file on Linux or macOs, open a terminal window and type :printf'[user]\nkey = apiKey:%s\n'"your-api-key-here">~/.dacercQuickstart# Import the ready-to-use exoplanet instancefromdace_query.exoplanetimportExoplanet# Retrieve data from the exoplanet databaseresult:dict=Exoplanet.query_database(limit=10,output_format='dict')# Get the planet namesplanet_names:list=result.get('obj_id_catname')# Print the planet namesprint(planet_names)For more examples of uses, such asfiltering bad quality data(see Usage examples)ContactIn case of questions, proposals or problems, feel free to contact theDACE support.LinksDACE website
Package: daceypy
DACEyPyPython wrapper of DACE, the Differential Algebra Computational Toolbox.IntroductionDACEyPy is a Python wrapper of DACE, the Differential Algebra Computational Toolbox
(https://github.com/dacelib/dace).Additionally, since DACEyPy 1.1.0, the Adaptive Domain Splitting (ADS) library is included.
This is documented in theADSdoc folder.SetupDACEyPy requires Python >= 3.7, running under:Windows (x86, x64, ARM64),Linux (x86, x64, ARM64),MacOs (x64, ARM64).To use this library in other architectures, it is necessary to recompile the
DACE core (as a dynamic-link library) and set the path in the code, see the lib folder.DACEyPy can be installed using pip.DocumentationThe documentation is availablehere.TutorialsThe original DACE C++ tutorials have been translated to Python and are available in theTutorialsfolder.
Package: dache
Forked from Django’s cache framework, Dache is a Python library that provides
a unified API across various cache backends.WARNING: This package is still in development.Do NOT use it in
production!Installationpip install dacheUsage>>> import dache
>>> cache = dache.Cache('locmem://')
>>> cache.set('key', {'value': 1234})
>>> cache.get('key')
{'value': 1234}Built-in backends:BackendRequired Python Package(s)URLFilefile:///DIR_PATHLevelDBleveldbleveldb:///DIR_PATHLocal memorylocmem://Memcachedpython-memcachedorpython3-memcachedpylibmcmemcached://HOST:PORTpylibmc://HOST:PORTRedisredisandhiredisredis:///HOST:PORT/DBTo register a custom backend, you can useregister_backend():>>> import dache
>>> dache.register_backend('awesome', 'my.backend.MyAwesomeCache')
Package: dacio-libpythonpro
Repositório de exemplo do projeto PyTools.Confs de travis-ci, pyup e arquivos requirements!Para instalar o setup da libcomo teste:Crie um venv de teste e ative-a;Rode o comando:pip install -e <path_diretorio_file_setup>OBS:
1 - Os comandos tags serve para gerar tags no seu projeto
servindo também como nota de release(versão).git tag <Nome da Tag>git push --tags2 - Para gerar o arquivo da lib pra enviar ao pypi.org
deve-se após todas as configurações e testes roda o comando:python setup.py sdist2.1 - Também para subir o arquivo para o pypi.org deve
instalar a dependência: pip install twine.
2.2 - Após a instalação rode o comando do terminal para realizar o
upload da lib para o pypi.org. DA forma abaixo será enviado todos os arquivos
dentro do diretório dist.twine upload dist/*
Package: dacite-ignore-case
dacite-ignore-caseInitialize dataclasses from dictionaries (based on dacite) but with case ignorance.Usageimportdacite_ignore_casefromdataclassesimportdataclass@dataclassclassMyClass:myKey:strdata={'mykey':'value'}c=dacite_ignore_case.from_dict(MyClass,data)Installationpip3 install dacite_ignore_case
Package: dacite-retrofit
dacite-retrofitAdacitefork withPEP 585&PEP 604typehint
support in Python 3.8+. See the original project for documentation.Installationdacite-retrofitis available on PyPI:pip install dacite-retrofitIt can also be installed from source:pip install git+https://github.com/trag1c/dacite-retrofit.gitWarningUnlikedacite(which supports Python 3.6+),dacite-retrofitonly supports
Python 3.8+.DevelopmentThis fork usespoetry,black,mypy,pytestandisort:$poetryrunblack.$poetryrunmypydacite$poetryrunpytest--covdacite$poetryrunisort.Originally created byKonrad Hałas.
Package: dacon
open-apiG-drive에서 다운 받기문제점:지금 방식은 데이터 원본을 깃허브에 올려야 함. 그래서 용량이 큰 데이터는 불가능.해결방법:대회 데이터는 Google Drive에 올라감. 그렇다면 open-api에서 Google Drive에 접근하여 데이터를 받아올 수 있으면 괜찮을 것03/22 이슈 사항구글 드라이브에 업로드된 파일명이 한글인 경우, decoding 에러가 발생 (해결 가능)또한 zip 파일 이름이 한글인 경우에는 다운로드조차 불가능 (해결 방법 모름)
Package: dacot
dacot: DataCOVID Transformerdacotgenera nuevos datasets a partir de los datos disponibles en losEstudios de movilidad a partir de la telefonía móvil"realizados por el Instituto Nacional de Estadística. Se recomienda leer y
entender la información suministrada por el INE para entender el alcance de
dichos estudios.Cada ejecución dedacotgenera un nuevo directorio dentro dedata/output/con el formatooutput_ESTUDIO_YYYYMMDD-VERSIONdonde:ESTUDIOse corresponde al estudio correspondiente (em2oem3)YYYYse corresponde al año (2020)MMse corresponde al mes (10)DDse corresponde al día (01)VERSIONse corresponde a la versión del programa utilizada.Dentro de este directorio se generan directorios adicionales, con el formatoYYYY-MM-DDcorrespondientes a los datos del INE. Dentro de cada uno de éstos
se encuentran dos directorios adicionales:original: contiene los ficheros originales del INE, sin modificaciones.province flux: contiene los datasets generados con información de
provincia, con los siguientes ficheros:flux.csv: Flujos (> 15 personas) con información provincial.flux-inter.csv: Flujos (> 15 personas) interprovinciales.flux-intra.csv: Flujos (> 15 personas) intraprovinciales.Asimismo, estos ficheros se concatenan y se guardan el el directorio de salida.InstalaciónSe recomienda utilizar unvirtualenv:virtualenv --python python3 .venv
source .venv/bin/activate
pip install .UsoUna vez instalado se puede ejecutar el programadacot:$ dacot em2
dacot version 0.0.1.dev1
Checking directories...

                 Base path: data
    INE data download path: data/raw/datos_disponibles_20201021-0.0.1.dev1.zip
         Interim data path: data/interim
     Output directory path: data/output/output_20201021-0.0.1.dev1
(...)O bien, sin instalarlo:$ python dacot/run.pyAcknowledgementsEste programa forma parte del proyectodistancia
COVIDCSICCOV19-039, que ha sido posible
gracias al apoyo delCSICy deAena.
Package: dacq2py
## SynopsisTools for the analysis of electrophysiological data collected primarily with Axona recording products using Python.## Code ExampleMain entry class is Trial contained in dacq2py_util i.e.` import dacq2py_util T =dacq2py_util.Trial('/path/to/dataset/mytrial')`The “usual” Axona dataset includes the following files:mytrial.setmytrial.1mytrial.2mytrial.3mytrial.4mytrial.posmytrial.eegNote that you shouldn’t specify a suffix when constructing the filename in the code example above.You can now start analysing your data! i.e.` T.plotEEGPower() T.plotMap(tetrode=1, cluster=4) `## MotivationAnalysis using Axona’s Tint cluster cutting program is great but limited. This extends that functionality.## InstallationEasiest way is with pip (under Linux, don’t know how this works under other OS’s):> pip install dacq2pyThis should install all the pre-requisites, which are as follows:numpyscipymatplotlibscikits-learn[astropy](http://www.astropy.org/) (for NaN-friendly convolution)skimage[mahotas](http://mahotas.readthedocs.org/en/latest/)Optional packages include:[klustakwik](https://github.com/klusta-team/klustakwik)Download the files and extract to a folder and make sure it’s on your Python path## API ReferenceMost classes/ methods have some explanatory text. The files in the docs folder are extracted from that using standard Python tools.## TestsTo be implemented.## ContributorsRobin Hayman.## LicenseDo what you want license.
Package: dact
dactdact is a CLI Package in Python focusing towards decreasing development setup time while working with React + Django Full Stack Development.
dact setup the whole, ready to work, Django project with React in just a single line command.
It handles all the urls, views, webpack, loaders, babel,etc. for the user in just a single command. Using dact, a developer can start writing their React code and see it render on their Django Web App.GeeksForGeeks Article -https://www.geeksforgeeks.org/djangoreact-full-stack-development-setup-using-dact/Installing dactpip install dactDjango + ReactStart a Django Project with default Frontend app namedact myprojectStart Django Project with custom Frontend app namedact myproject appnameRequirementsYou must havenpminstalled in your system.You must havePythoninstalled in your system.Python and pip or pip3 must be added to your environment.How to install this Package(for Development)Clone this Repocd dactpip3 install -e .On successfull setup of your project, you should see something like this:How to work with dactTo start the Servercd myprojectpython manage.py runserverTo start working on the frontendStart watching the changes usingdact-watchLetdact-watchrun in a different terminal. Make sure you rundact-watchin the same directory asmanage.py.Edit your React Front-end at :reactfrontend > static > src > App.jsMake your changes and save your file.Refresh your page.
Package: dactyl
DactylDocumentation tools for enterprise-quality documentation from Markdown source. Dactyl has advanced features to enablesingle-sourcingand an extensible syntax for building well-organized, visually attractive docs. It generates output in HTML (natively), and can make PDFs if you havePrinceinstalled.InstallationDactyl requiresPython 3. Install withpip:sudo pip3 install dactylOr a local install in a virtualenv:# Create an activate a virtualenv so the package and dependencies are localizedvirtualenv-p`whichpython3`venv_dactylsourcevenv_dactyl/bin/activate
pip3installdactylDocumentationDactyl's documentation is built from this repository'sexamples/section. You can see the finished version at:https://dactyl.link
Package: dacutil
Data Analytic UtilsInstallpipinstalldacutilor devpipinstallgit+https://github.com/attapon-th/dacutil@mainUsagefromdacutilimport(datediff,get_config,check_mod11,df_strip,worker,Addict)Functionsget_configsupport file type:inijsonyamltomlExamplefromdacutilimportget_config,Addict# get config from fileconfig:Addict=get_config("path/to/file.ini")# orconfig:Addict=get_config("file://path/to/file.ini")# get config from urlconfig:Addict=get_config("http://example.com/file.json")# orconfig:Addict=get_config("https://example.com/file.json")
Package: dacwinapi
DacWin APIThe Python package dacwinapi makes it easy to manage information about your DacWin referral system. This package is specifically designed to interact with the DacWin API and allows you to manage information about an application's users, referral campaigns, rewards and events.DacWin home page:https://referral-dev.dactechnologies.netInstallationTo installdacwinapi, you can use pip:pipinstalldacwinapiBefore using this package you must have the API key of the application you want to manage. If this is not the case yet,Go to your customer area:https://referral-devuser.dactechnologies.netIn theApplicationssection:Add an application and copy the generated API key.Or, open your application's edit window andregenerate a new API keyif you no longer have the old one.How to use this package1. CampaignsfromdacwinapiimportCampaignService# create an instance of CampaignServicecampaignService=CampaignService(api_key="your_app_api_key")# retrieve the list of campaigns of the appcampaigns=campaignService.getAll()# retrieve one campaign datacampaigns=campaignService.getOne(1)# 1 is the campaign idNOTE: Creating a campaign is only done on your DacWin customer interface.2. App usersfromdacwinapiimportAppUserService# create an instance of AppUserServiceappUserService=AppUserService(api_key="your_app_api_key")# add new app user with referral informationapp_user_created=awaitappUserService.create(reference="3ddd",referrer_referral_code="AAAAA")print(app_user_created)# retrieve the list of app users of the appapp_users=appUserService.getAll()# retieve one app user by her idapp_user=appUserService.getOne(id=1)# 2 is the app user id# retieve one app user by her referenceapp_user=appUserService.getOne(reference="a2sddd")# "a2sddd" is the app user reference3. EventsfromdacwinapiimportEventService# create an instance of EventServiceeventService=EventService(api_key="your_app_api_key")# add a new event for specific app user and campaignevent_created=eventService.create(name="ddd",campaign_id=18,app_user_id=14)print(event_created)# retrieve the list of events of the appevents=eventService.getAll()# retrieve the list of app's events of specific campaignevents=eventService.getAll(campaign_id=12)# retrieve one eventevent=eventService.getOne(12)# 12 is the event id4. RewardsfromdacwinapiimportRewardService# create an instance of RewardServicerewardService=RewardService(api_key="your_app_api_key")# retrieve the list of rewards of the apprewards=rewardService.getAll()# retrieve the list of app's rewards of specific campaignrewards=rewardService.getAll(campaign_id=12)# retrieve one rewardreward=rewardService.getOne(id=12)
Package: dacy
DaCy: An efficient and unified framework for danish NLPDaCy is a Danish natural language preprocessing framework made with SpaCy. Its largest pipeline has achieved State-of-the-Art performance on Named entity recognition, part-of-speech tagging and dependency parsing for Danish. Feel free to try out thedemo. This repository contains material for using DaCy, reproducing the results and guides on the usage of the package. Furthermore, it also contains behavioral tests for biases and robustness of Danish NLP pipelines.🔧 InstallationYou can installdacyviapipfromPyPI:pipinstalldacy👩‍💻 UsageTo use the model you first have to download either the small, medium, or large model. To see a list of all available models:importdacyformodelindacy.models():print(model)# ...# da_dacy_small_trf-0.2.0# da_dacy_medium_trf-0.2.0# da_dacy_large_trf-0.2.0To download and load a model simply execute:nlp=dacy.load("da_dacy_medium_trf-0.2.0")# or equivalently (always loads the latest version)nlp=dacy.load("medium")To see more examples, see thedocumentation.📖 DocumentationDocumentation📚Getting startedGuides and instructions on how to use DaCy and its features.🦾PerformanceA detailed description of the performance of DaCy and comparison with similar Danish models📰News and changelogNew additions, changes and version history.🎛API ReferencesThe detailed reference for DaCy's API. Including function documentation🙋FAQFrequently asked questionsTraining and reproductionThe foldertrainingcontains a range of folders with a SpaCy project for each model version. This allows for the reproduction of the results.Want to learn more about how DaCy initially came to be, check out thisblog post.💬 Where to ask questionsTo report issues or request features, please use theGitHub Issue Tracker.
Questions related to SpaCy are kindly referred to the SpaCy GitHub or forum. Otherwise, please use the Discussion Forums.Type📚FAQFAQ🚨Bug ReportsGitHub Issue Tracker🎁Feature Requests & IdeasGitHub Issue Tracker👩‍💻Usage QuestionsGitHub Discussions🗯General DiscussionGitHub Discussions
Package: dada
Dada is a CLI project manager – written in Python. It can be used
for switching quickly between projects and scaffolding them.InstallingInstall and update using pip:$ pip install dadaDada supports Python 3.7 and newer.Creating new projectsTo create a new letter, type:$ dada new letterLinksWebsite:https://palletsprojects.com/p/click/Documentation:https://click.palletsprojects.com/License:BSDReleases:https://pypi.org/project/click/Code:https://github.com/pallets/clickIssue tracker:https://github.com/pallets/click/issuesTest status:Linux, Mac:https://travis-ci.org/pallets/clickWindows:https://ci.appveyor.com/project/pallets/clickTest coverage:https://codecov.io/gh/pallets/click
Package: dada-openapi-client
dada_openapi_client达达开放平台的签名封装dada_client支持的功能根据达达开放平台的签名规则进行签名签名规则安装pipinstalldada_openapi_client使用fromdada_openapi_client.dada_clientimportDdMakeSignbody={"source_id":"73753","v":"1.0","format":"json","body":"{\"order_id\":\"111111111\"}","timestamp":"1574927842"}d=DdMakeSign(appKey='dada11111111111',app_secret='111111111111111111111111')print(d.make_sign(body=body))
Package: dadaptation
D-AdaptationLearning rate free learning for SGD, AdaGrad and Adam!by Aaron Defazio and Konstantin Mishchenko(Arxiv)pip install dadaptationNEW V3.0 release uses an improved algorithm that may give different results from past versions. The old version is still availiable under experimental/d_adapt_adam_preprint.NEW: ProdigyWe have recently released theProdigymethod, which grows the adapted learning rate faster than D-Adaptation in theory and practice. Try it out if D-Adaptation is under-estimating the learning rate.How To CiteIf you use D-Adaptation in a publication, please cite our work as@ARTICLE{defazio2023dadapt,
author = {Aaron Defazio and Konstantin Mishchenko},
title = {Learning-Rate-Free Learning by D-Adaptation},
journal = {The 40th International Conference on Machine Learning (ICML 2023)},
year = {2023}
}DetailsThe provided Pytorch Optimizer classes are drop-in replacements, either copy into your project or use via pip with dadaptation.DAdaptSGD,  dadaptation.DAdaptAdam or dadaptation.DAdaptAdaGrad.Set the LR parameter to 1.0. This parameter is not ignored. Setting it larger to smaller will directly scale up or down the D-Adapted learning rate estimate.Different per-layer learning rates can be achieved by setting the layer_scale value in each parameter-group. It defaults to 1.0, and scales each layer's learning rate relative to the other layers.Use the same learning rate scheduler you would normally use on the problem.The Adam variant supports AdamW style weight decay, just set decouple=True. It is not turned on by default, so if you are replacing your adam implementation, make sure you use decoupled if necessary.It may be necessary to use larger weight decay than you would normally use, try a factor of 2 or 4 bigger if you see overfitting. D-Adaptation uses larger learning rates than people typically hand-choose, in some cases that requires more decay.Use the log_every setting to see the learning rate being used (d*lr) and the current D bound.Only the AdaGrad version supports sparse gradients. It does not adapt as efficiently as the other variants and should be considered experimental.Change LogVersion 3.2Added support for layer-wise scaling to DAdaptAdam.Version 3.0Major improvements to DAdaptAdam, improving the performance particularly on Transformer models. This variant may behave differently in practice. The old version is availiable under experimental/d_adapt_adam_preprint if you wish to continue to use it.The IP variant is now the main variant of the method.Added Lion. This is highly experimental. Feedback on it's performance is welcome.Version 2.0Added Adan - should still be considered experimental.Added support for PyTorch's Fully Sharded Data Parallel.Improved support of edge cases such as learning rate zero.Improved logging - uses Python logging rather than print statementsExperimental resultsLicenseSee theLicense file.
Package: dadapy
DADApy is a Python package for the characterisation of manifolds in high dimensional spaces.HomepageFor more details and tutorials, visit the homepage at:https://dadapy.readthedocs.io/Quick Exampleimportnumpyasnpfromdadapy.dataimportData# Generate a simple 3D gaussian datasetX=np.random.normal(0,1,(1000,3))# initialise the "Data" class with the set of coordinatesdata=Data(X)# compute distances up to the 100th nearest neighbourdata.compute_distances(maxk=100)# compute the intrinsic dimension using 2nn estimatordata.compute_id_2NN()# compute the density using PAk, a point adaptive kNN estimatordata.compute_density_PAk()# find the peaks of the density profile through the ADP algorithmdata.compute_clustering_ADP()Currently implemented algorithmsIntrinsic dimension estimatorsTwo-NN estimatorFacco et al.,Scientific Reports(2017)Gride estimatorDenti et al.,Scientific Reports(2022)Density estimatorskNN estimatork*NN estimator (kNN with adaptive choice of k)PAk estimatorRodriguez et al.,JCTC(2018)Density peaks clustering methodsDensity peaks clusteringRodriguez and Laio,Science(2014)Advanced density peaks clusteringd’Errico et al.,Information Sciences(2021)k-peak clusteringSormani, Rodriguez and Laio,JCTC(2020)Manifold comparison toolsNeighbourhood overlapDoimo et al.,NeurIPS(2020)Information imbalanceGlielmo et al.,PNAS Nexus(2022)InstallationThe package is compatible with Python >= 3.7 (tested on 3.7, 3.8 and 3.9). We currently only support Unix-based systems, including Linux and macOS.
For Windows-machines we suggest using theWindows Subsystem for Linux (WSL).The package requiresnumpy,scipyandscikit-learn, andmatplotlibfor the visualisations.The package contains Cython-generated C extensions that are automatically compiled during install.The latest release is available through pippipinstalldadapyTo install the latest development version, clone the source code from github
and install it with pip as followsgitclonehttps://github.com/sissa-data-science/DADApy.gitcdDADApy
pipinstall.Citing DADApyA description of the package is availablehere.Please consider citing it if you found this package useful for your research@article{dadapy,title={DADApy: Distance-based analysis of data-manifolds in Python},journal={Patterns},pages={100589},year={2022},issn={2666-3899},doi={https://doi.org/10.1016/j.patter.2022.100589},url={https://www.sciencedirect.com/science/article/pii/S2666389922002070},author={Aldo Glielmo and Iuri Macocco and Diego Doimo and Matteo Carli and Claudio Zeni and Romina Wild and Maria d’Errico and Alex Rodriguez and Alessandro Laio},}
Package: dadard-apis-common-pack
This package is used by the APIs deployed ondadard.fr.It calls the Main API to check the subscriptions and the profiles’ key.Install it this way :pip installdadard-apis-common-packYou can import the package in your code this way :fromCommonPackimportCommonCallerprofile_key='some_private_key'# check if the key is associated to a valid userCommonCaller.check_profile_key(profile_key)# check if the api given has been subscribed by this keyCommonCaller.check_is_subscribed(profile_key,api_name)# check if the api given has not been subscribed by this keyCommonCaller.check_is_not_subscribed(profile_key,api_name)