Saravanan666/pypi-org huggingface dataset:
Package: dash-websocket-component
Dash WebSocket ComponentDash WebSocket Component is a Dash component library.Project DescriptionGet started with:Install Dash and its dependencies:https://dash.plotly.com/installationRunpython usage.pyVisithttp://localhost:8050in your web browserContributingSeeCONTRIBUTING.mdInstall dependenciesIf you have selected install_dependencies during the prompt, you can skip this part.Install npm packages$ npm installCreate a virtual env and activate.$ virtualenv venv
$ . venv/bin/activateNote: venv\Scripts\activate for windowsInstall python packages required to build components.$ pip install -r requirements.txtInstall the python packages for testing (optional)$ pip install -r tests/requirements.txtWrite your component code insrc/lib/components/DashWebsocketComponent.react.js.The demo app is insrc/demoand you will import your example component code into your demo app.Test your code in a Python environment:Build your code$ npm run buildRun and modify theusage.pysample dash app:$ python usage.pyWrite tests for your component.A sample test is available intests/test_usage.py, it will loadusage.pyand you can then automate interactions with selenium.Run the tests with$ pytest tests.The Dash team uses these types of integration tests extensively. Browse the Dash component code on GitHub for more examples of testing (e.g.https://github.com/plotly/dash-core-components)Add custom styles to your component by putting your custom CSS files into your distribution folder (dash_websocket_component).Make sure that they are referenced inMANIFEST.inso that they get properly included when you're ready to publish your component.Make sure the stylesheets are added to the_css_distdict indash_websocket_component/__init__.pyso dash will serve them automatically when the component suite is requested.Review your codeCreate a production build and publish:Build your code:$ npm run buildCreate a Python distribution$ python setup.py sdist bdist_wheelThis will create source and wheel distribution in the generated thedist/folder.
SeePyPAfor more information.Test your tarball by copying it into a new environment and installing it locally:$ pip install dash_websocket_component-0.0.1.tar.gzIf it works, then you can publish the component to NPM and PyPI:Publish on PyPI$ twine upload dist/*Cleanup the dist folder (optional)$ rm -rf distPublish on NPM (Optional if chosen False inpublish_on_npm)$ npm publishPublishing your component to NPM will make the JavaScript bundles available on the unpkg CDN. By default, Dash serves the component library's CSS and JS locally, but if you choose to publish the package to NPM you can setserve_locallytoFalseand you may see faster load times.Share your component with the community!https://community.plotly.com/c/dashPublish this repository to GitHubTag your GitHub repository with the plotly-dash tag so that it appears here:https://github.com/topics/plotly-dashCreate a post in the Dash community forum:https://community.plotly.com/c/dash
Package: dasi
DASi DNA DesignDASiis an automatic DNA cloning plan designer aimed for operating on small budgets
by focusing on material re-use.The software converts a nucleotide sequence, or a library of sequences, to an executable
molecular assembly plan while optimizing material cost, assembly efficiency, and assembly time.The key design paradigm for DASi is thatno molecular biology expertiseis required to use DASi. Complete novices should be able to use the software to design and construct new genetic sequences. This also enables automated software programs to automatically design and construct new genetic sequences.The software goals are reminiscent of j5 or Teselegen but focused on:A dead-simple API usable by lab novices, experts or automated software programs.Utilizing information about current laboratory inventory in its optimization
algorithm to minimize costs and turn-around timeStatusDASi is currently under development funded by the DARPA Synergistic Discovery and Design program. DASi is currently being used to connect automatically generate DNA designs to automated biological fabrication facilities (e.g. University of Washington Biofab).UsageDASi completely automates the cloning design work, finding approximately optimal solutions for cloning steps, preferentially using existing plasmids, linear DNA fragments, and primers to design semi-optimal cloning steps and designs.The following command designs the cloning steps for a library of designs. The user only needs to specify the sequences they wish to construct and currently available primers and DNA templates as.genbankor.fastafiles. DASi handles all design aspects.No molecular biology expertise is required to use DASi.dasilibrary_design--designsmydesigns/*.gb--fragmentsfragments/*.gb--primersprimers.fasta--templatesplasmids/*.gb--cost_modelcost.b--outresultsCustomizationDASi optimization parameters are completely customizable. The following are examples of parameters and aspects of DASi that are customizable:primer synthesis costsprimer design parameterssynthetic fragment costsvendor-specific synthetic fragment complexitysequence dependent plasmid assembly efficienciesoptimizing over efficiency vs material costsetc.Planned FeaturesGolden-gate supportheirarchical assemblylibrary support (with bayesian search to optimize shared parts)front-endconnection to fabrication facilityDASi optimization problemBriefly, DASi approximates a solution the following optimization problem:Given a set of 'goal' double-stranded sequences, a set of available single-stranded and double-strand sequences, and a set of actions that can create new sequences, find the optimal set of operations that produces the 'goal' sequences.Formalization of this optimization problem is coming soon.
Package: dasifo
DASIFOWe are working on this project, It is a documentation of different tools needed while working in Data Science project!
and we ll enrich it by some use cases that ll simplify and accelerate working by those technologies...
We are looking to create a python library that will regroups:all kind of Databases connections (SQL, NOSQL) and queries examples.it provides some tutorials of APIs: for example conneting to google Drive, cloud....machine learning!deep learning!artificial intelligence!We install our library 'dasifo'pip3 install dasifo
Or
Make sure you are on the right python's envirement variable.
 Download this Lib from github:
    https://github.com/larou2si/dasifo
 To install it locally, run this line in your terminal
    cd dasifo && python3 setup.py sdist bdist_wheel && pip3 install -e .Uninstall our library 'dasifo'pip3 uninstall dasifoDatabases installationMysql: https://dev.mysql.com/doc/refman/5.7/en/installing.html
PostgresQL: https://www.postgresql.org/docs/current/admin.html
MongoDB: https://docs.mongodb.com/guides/server/install/Support & Questions:Drop a message via mohamed.laroussi.1@esprit.tn
Package: dasima
DASIMADescriptionDasima is a library that helps you send and receive messages in Flask project. It is a simple wrapper around Kombu and support with the publisher/subscriber pattern of your Flask project.Getting StartedBuilt WithPython >=  3.6PrerequisitesMessage Queueex) Redis, RabbitMQ, ActiveMQ, ZeroMQ, Kafka...InstallationInstalling$pipinstalldasimasetting parametersDASIMA_CONNECTION_HOST="localhost"# your Message Queue host ex) redis://0.0.0.0, amqp://id:password@0.0.0.0:portDASIMA_ACCEPT_TYPE="json"# sending data type ex) json, pickle ...DASIMA_EXCHANGE_SETTING=[("test_exchange","one"),]# DASIMA_EXCHANGE_SETTING is list of tuples [(exchange name, type)]# There are two types: 'all' and 'one'.UsageSubscriber Simple examplefromdasimaimportDasimafromflaskimportFlaskapp=Flask(__name__)app.config.update({"DASIMA_CONNECTION_HOST":"pyamqp://localhost:5672","DASIMA_ACCEPT_TYPE":"json","DASIMA_EXCHANGE_SETTING":[("test_exchange","one"),]})dasimamq=Dasima()dasimamq.init_app(app)# Alternatively, auto init_app can be used after putting the flask app into Dasima like Dasima(app)."""same as@dasimamq.after_subscribe_taskdef after_work_func(data, message, result):print("working after on task")"""defafter_task_func(data,message,result):print("working after on task...")dasimamq.resgiter_after_subscribe_task(after_task_func)# Be able to subscribe target functions using the function 'subscribe'# The queue named by subscribed function name will be made, and binding it with routing key# dasimamq.{exchange}.subscribe(routing_key) - "Route key to bind"@dasimamq.test_exchange.subscribe(routing_key="test_routing_key")# @dasimamq.test_exchange.subscribe - if routing key not defined, routing key is defined as function namedeftest_function(x,y):print(x+y)returnx+yif__name__=="__main__":# Call the function 'run_subscribers' to create queues in which consumers process the messages.dasimamq.run_subscribers()app.run(port=5050)Publisher Simple examplefromflaskimportFlaskfromdasimaimportDasimaapp=Flask(__name__)app.config.update({"DASIMA_CONNECTION_HOST":"pyamqp://localhost:5672","DASIMA_ACCEPT_TYPE":"json","DASIMA_EXCHANGE_SETTING":[("test_exchange","one"),]})dasimamq=Dasima()dasimamq.init_app(app)# Alternatively, auto init_app is possible by putting the flask app directly into Dasima(app).@app.route("/send")defsend_message():dasimamq.test_exchange.send_message(data={"x":1,"y":2},routing_key="test_routing_key")return{"data":"send message successful"}@app.route("/receive")defsend_message():res=dasimamq.test_exchange.send_message_and_recevie_result(data={"x":1,"y":2},routing_key="test_routing_key")return{"result":res}if__name__=="__main__":app.run(port=5000)LinksKombu githubRedisRabbitMQContactJISU JEONG-js.jeong@linewalks.com
Package: das-import
Decks Against Society card importerUsageInstall using pipsi:$pipsiinstalldas-importPrepare separate CSV files for black and white cards, each card text in separate line[^1] and run:$ das-import -u <your username> -p <password> -e <target deck ID> -c <card color> <path to file>[^1]: Multiline cards need to be wrapped in double quotes.
Package: dask4dvc
Dask4DVC - Distributed Node ExectuionDVCprovides tools for building and executing the computational graph locally through various methods.
Thedask4dvcpackage combinesDask Distributedwith DVC to make it easier to use with HPC managers likeSlurm.Thedask4dvc repropackage will run the DVC graph in parallel where possible.
Currently,dask4dvc runwill not run stages per experiment sequentially.:warning: This is an experimental packagenotaffiliated in any way with iterative or DVC.UsageDask4DVC provides a CLI similar to DVC.dvc reprobecomesdask4dvc repro.dvc queue startbecomesdask4dvc runYou can follow the progress usingdask4dvc <cmd> --dashboard.SLURM ClusterYou can usedask4dvceasily with a slurm cluster.
This requires a running dask scheduler:fromdask_jobqueueimportSLURMClustercluster=SLURMCluster(cores=1,memory='128GB',queue="gpu",processes=1,walltime='8:00:00',job_cpu=1,job_extra=['-N 1','--cpus-per-task=1','--tasks-per-node=64',"--gres=gpu:1"],scheduler_options={"port":31415})cluster.adapt()with this setup you can then rundask4dvc repro --address 127.0.0.1:31415on the example port31415.You can also use config files withdask4dvc repro --config myconfig.yaml.
Alldask.distributedClusters should be supported.default:SGECluster:queue:regularcores:10memory:16 GB
Package: dask-actor-singleton
dask-actor-singletonThis package works around common transient errors and pitfalls in creating a singleton instance of anActorinDask. It provides a clean interface for retrieving the singleton instance, and allocating it when necessary.Usageimportdask_actor_singletonclassMyActor:def__init__(self,arg):self.value=argdefinc(self):self.value+=1returnself.valueclient=dask.distributed.Client()actor=dask_actor_singleton.get('my_actor',create=lambda:MyActor(8))print(actor.inc().result())# 9# Now, on a different computer / dask.distributed.Client, run this script again:# ...print(actor.inc().result())# 10# If ever the singleton should be deleted, one may call:dask_actor_singleton.discard('my_actor')History2023-09-14 v1.3.4 release. Fixing compatibility with Dask 2023.5.0 and beyond, and theFAW.2021-08-19 v1.3.3 release. Caching times start after object creation finishes; not at the start. This matters for objects with long load times.2021-08-18 v1.3.2 release. Explicitly forget wrapped future.2021-08-18 v1.3.1 release. Free old actor when re-allocating to potentially reduce memory load.2021-08-02 v1.3.0 release. Priority argument added to improve responsiveness alongside larger processing loads.2021-07-29 v1.2.0 release. Added TTL support forget, and better documentation fordiscard.2021-07-29 v1.1.1 release. Fixed issue with "Working holding Actor was lost"2021-07-29 v1.1 release. Supportsdiscardto purge a cached singleton.2021-07-19 v1.0 release.
Package: daskathon
Deploydask-workerprocesses on Marathon in response to load on a Dask
scheduler.  This creates a Marathon application of dask-worker processes.  It
watches a Dask Scheduler object in the local process and, based on current
requested load, scales the Marathon application up and down.RunIt’s not yet clear how to expose all of the necessary options to a command line
interface.  For now we’re doing everything manually.Make an IOLoop running in a separate thread:withMarathonCluster(marathon='http://localhost:8080',cpus=1,mem=512,adaptive=True)asmc:withClient(mc.scheduler_address)asc:x=c.submit(lambdax:x+1,1)assertx.result()==2Create a Client and submit work to the scheduler.  Marathon will scale workers
up and down as neccessary in response to current workload.fromdistributedimportClientc=Client(s.address)future=c.submit(lambdax:x+1,10)TODO[x] Deploy the scheduler on the cluster[x] Support a command line interfaceDocker Testing HarnessThis sets up a docker cluster of one Mesos master and two Mesos agents using
docker-compose.Requires:docker version >= 1.11.1docker-compose version >= 1.7.1docker-compose upRun py.test:py.test dask-marathonWeb UIshttp://localhost:5050/for Mesos master UIhttp://localhost:5051/for the first Mesos agent UIhttp://localhost:8080/for Marathon UIHistoryDask-marathon originally forked fromhttps://github.com/mrocklin/dask-marathon
Package: dask-avro
Dask-AvroAvro reader for Dask.Free software: MIT licenseDocumentation:https://dask-avro.readthedocs.org.Python versions: 2.7, 3.5+FeaturesThis projects provides anAvroformat reader forDask. Provides a convenient
function to read one or more Avro files and partition them arbitrarily.QuickstartUsage:import dask.bag
import dask_avro

delayeds = dask_avro.read_avro("data-*.avro", blocksize=2**26)
data = dask.bag.from_delayed(delayeds)CreditsThis package was created withCookiecutterand thermax/cookiecutter-pypackageproject template.History0.3.0 (2018-06-16)Fixed support for latestfastavrorelease.Requirefastavro>=0.17.0.2.1 (2018-06-15)Pin fastavro version to <=0.19.6 due to breaking changes.0.2.0 (2018-02-12)Added support forfastavro0.16+.0.1.2 (2018-02-12)Fix compatibility withdask0.17.0.0.1.1 (2018-01-18)Pin fastavro version to <0.16 as latest versions don’t allow to use internal
C-based_iter_avrofunction.0.1.0 (2017-02-02)First release on PyPI.
Package: dask-awkward
dask-awkwardConnectingawkward-arrayandDask.InstallingReleases are available from PyPI and conda-forge.PyPI:pip install dask-awkwardconda-forge:conda install dask-awkward -c conda-forgeDocumentationDocumentation is hosted athttps://dask-awkward.readthedocs.io/.AcknowledgementsSupport for this work was provided by NSF grantOAC-2103945.
Package: dask-azureblobfs
Dask Azure Blob FileSystemAzure Blob Storage Backend for DaskFeaturesSupports dask when your data files are stored in the cloud.ImportDaskAzureBlobFileSystemUseabfs://as protocol prefix and you are good to do.For authentication, please read more onUsage.Support for key-value storage which is backed by azure storage. Create an instance ofAzureBlobMapUsageMake the right imports:from azureblobfs.dask import DaskAzureBlobFileSystem
import dask.dataframe as ddthen put all data files in an azure storage container sayclippy, then you can read it:data = dd.read_csv("abfs://noaa/clippy/weather*.csv")
max_by_state = data.groupby("states").max().compute()you would need to set your azure account name in environment variableAZURE_BLOB_ACCOUNT_NAME(which in our above example isnoaa) and the account key inAZURE_BLOB_ACCOUNT_KEY.If you don’t want to use account key and instead want to use SAS, set it in the
environment variableAZURE_BLOB_SAS_TOKENalong with the connection string in the
environment variableAZURE_BLOB_CONNECTION_STRING.InstallationJust:pip install dask-azureblobfsor get the development version if you love to live dangerously:pip install git+https://github.com/manish/dask-azureblobfs@master#egg=dask-azureblobfsCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2018-11-18)First release on PyPI.
Package: dask-bigquery
Dask-BigQueryRead/write data from/toGoogle BigQuerywith Dask.This package uses the BigQuery Storage API. Please refer to thedata extraction pricing tablefor associated costs while using Dask-BigQuery.Installationdask-bigquerycan be installed withpip:pip install dask-bigqueryor withconda:conda install -c conda-forge dask-bigqueryGoogle Cloud permissionsFor reading from BiqQuery, you need the following roles to be enabled on the account:BigQuery Read Session UserBigQuery Data Viewer,BigQuery Data Editor, orBigQuery Data OwnerAlternately,BigQuery Adminwould give you full access to sessions and data.For writing to BigQuery, the following roles are sufficient:BigQuery Data EditorStorage Object CreatorThe minimal permissions to cover reading and writing:BigQuery Data EditorBigQuery Read Session UserStorage Object CreatorAuthenticationBy default,dask-bigquerywill use theApplication Default Credentials. When running code locally, you can set this to use your user credentials by running$gcloudauthapplication-defaultloginUser credentials require interactive login. For settings where this isn't possible, you'll need to create a service account. You can set the Application Default Credentials to the service account key using theGOOGLE_APPLICATION_CREDENTIALSenvironment variable:$exportGOOGLE_APPLICATION_CREDENTIALS=/home/<username>/google.jsonFor information on obtaining the credentials, useGoogle API documentation.Example: read from BigQuerydask-bigqueryassumes that you are already authenticated.importdask_bigqueryddf=dask_bigquery.read_gbq(project_id="your_project_id",dataset_id="your_dataset",table_id="your_table",)ddf.head()Example: write to BigQueryWrite to BigQuery with default credentialsAssuming that client and workers are already provisioned with default credentials:importdaskimportdask_bigqueryddf=dask.datasets.timeseries(freq="1min")res=dask_bigquery.to_gbq(ddf,project_id="my_project_id",dataset_id="my_dataset_id",table_id="my_table_name",)Before loading data into BigQuery,to_gbqwrites intermediary Parquet to a Google Storage bucket. Default bucket name is<your_project_id>-dask-bigquery. You can provide a diferent bucket name by setting the parameter:bucket="my-gs-bucket". After the job is done, the intermediary data is deleted.Write to BigQuery with explicit (non-default) credentials# service account credentialscreds_dict={"type":...,"project_id":...,"private_key_id":...}res=to_gbq(ddf,project_id="my_project_id",dataset_id="my_dataset_id",table_id="my_table_name",credentials=credentials,)Run tests locallyTo run the tests locally you need to be authenticated and have a project created on that account. If you're using a service account, when created you need to select the role of "BigQuery Admin" in the section "Grant this service account access to project".You can run the tests with$ pytest dask_bigqueryif your defaultgcloudproject is set, or manually specify the project ID withDASK_BIGQUERY_PROJECT_ID pytest dask_bigqueryHistoryThis project stems from the discussion inthis Dask issueandthis initial implementationdeveloped byBrett Naul,Jacob Hayes,
andSteven Soojin Kim.LicenseBSD-3
Package: dask-cassandra-loader
dask-cassandra-loaderA data loader which loads data from a Cassandra table into a Dask dataframe. It allows partition elimination, selection and projections pushdown.The project setup is documented ina separate document. Feel free to remove this document (and/or the link to this document) if you don’t need it.InstallationTo install dask-cassandra-loader, do:pip install dask-cassandra-loaderDocumentationIf you want more information about dask_cassandra_loader API, have a look at thedask_cassandra_loader documentation.ContributingIf you want to contribute to the development of dask-cassandra-loader,
have a look at thecontribution guidelines.LicenseCopyright (c) 2020, Netherlands eScience CenterLicensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an “AS IS” BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.CreditsThis package was created withCookiecutterand theNLeSC/python-template.
Package: dask-checkpoint
Dask-checkpointDask-checkpoint is a Python package
that adds a customizable caching capabilities todask.
It builds on top ofdask.delayed,
adding load and save instructions
to the dask graph.fromdask_checkpointimportStorage,taskstorage=Storage.from_fsspec("my_directory")@task(save=True)defadd_one(x):returnx+1x0=add_one(1).compute()# computedwithstorage():x1=add_one(1).compute()# computed and saved to storagex2=add_one(1).compute()# loaded from storagex3=add_one(1).compute()# recomputed, not loaded from storageassertx0==x1==x2==x3InstallationDask-checkpoint can be installed from PyPI:pip install dask-checkpointGetting startedCheck out thetutorialto see Dask-checkpoint in action.DevelopmentTo set up a development environment in a new conda environment,
run the following commands:git clone https://github.com/maurosilber/dask-checkpoint
cd dask-checkpoint
conda env create -f environment-dev.yml
pre-commit installRun tests locally withtox:toxor, if you havemambainstalled:CONDA_EXE=mamba tox
Package: dask-clickhouse
Dask-ClickhouseDask Clickhouse connector.Installationpipinstalldask-clickhouseUsagedask-clickhouseprovidesread_from_tableandwrite_to_tablemethods for parallel IO to and from Clickhouse with Dask.fromdask_clickhouseimportread_clickhousequery="SELECT * FROM example_table"ddf=read_clickhouse(query=query,connection_kwargs={"...":"..."})
Package: dask-cuda
Dask CUDAVarious utilities to improve deployment and management of Dask workers on
CUDA-enabled systems.This library is experimental, and its API is subject to change at any time
without notice.Examplefromdask_cudaimportLocalCUDAClusterfromdask.distributedimportClientcluster=LocalCUDACluster()client=Client(cluster)Documentation is availablehere.What this is notThis library does not automatically convert your Dask code to run on GPUs.It only helps with deployment and management of Dask workers in multi-GPU
systems.  Parallelizing GPU libraries likeRAPIDSandCuPywith Dask is an ongoing effort.  You may wish
to read about this effort atblog.dask.orgfor more
information.  Additional information about Dask-CUDA can also be found in thedocs.