Saravanan666/pypi-org huggingface dataset:
Package: draft-kings
DraftKings Python ClientIntroductionTo the best of my knowledge,DraftKingsdoes not have an "official", well-documented public-facing API.Instead, they have variousHTTPendpoints that do not require authentication (so are "public" in this manner).These "public" endpoints allow one to fetch data for various resources including contests for a specific sport, or
players that are draftable for a given contest (as well as relevant metadata).AsDraftKingsmakes no guarantees about it's "public" API, this client makes no guarantees that the existing API
methods will work consistently.DocumentationFor documentation about package installation as well as the client's API, please seethe documentation site.
Package: draftquality
# draftqualityThis library provides a set of utilities for building and maintaining
draft (new article creation) quality prediction models for Wikipedia.Installation:pip install draftqualityRepository:https://github.com/wikimedia/draftqualityLicense:MIT## RequirementsOptionally requires the following based on usage:NLTK SentiWordnet -python-mnltk.downloader sentiwordnetNLTK Wordnet -python-mnltk.downloader wordnet## Author
* Aaron Halfaker –https://github.com/halfak
Package: draft-sport
Draft Sport PythonA Python library providing an interface to the Draft Sport Application
Programming Interface (API). Python programmers may use Draft Sport Python
to build Draft Sport API functionality into their applications, without
resorting to raw HTTP requests.Draft Sport Python provides the API interface forhttps://DraftRugby.com.Draft Sport Python is in an early Alpha state of development. Bugs, missing
features and general absurdity abound. Questions, bug reports, suggestions,
and any other discourse are warmly welcomed.InstallationDraft Sport Python is available via PyPi.$ pip install draft-sportBe sure to upgrade regularly, as Draft Sport Python is in Alpha development.
Things are changing rapidly!$ pip install --upgrade draft-sport
Package: drafttopic
# Draft topicPredicting topics to new drafts based on Wikiprojects on English Wikipedia.## Setting upMake sure to have a working python3 environment.
Install requirements using:` pip install-rrequirements `Install the library using:` python setup.py install `## Generating machine-readable WikiProjects dataUse the following utility from root directory to generate machine-readable WikiProjects data:` ./utility fetch_wikiprojects--output<output_file_name.json> `## Generating mid-level category to WikiProjects mappingUse the following utility from root directory to generate a mapping of high-level topic categories to list of WikiProjects contained in them:` ./utility trim_wikiprojects--wikiprojectswp--outputoutmid `## Labeling a list of page-ids with the wikiprojects and mid-level categories each page belongs toUse the following utility from root directory to label a list of page-ids with the wikiprojects and the mid-level categories the page belongs to.` ./utility fetch_page_wikiprojects--api-host=https://en.wikipedia.org/--input=wikiproject_page_ids.json--output=enwiki.labeled_wikiprojects.json--mid_level_wp=outmid.json--verbose`In above, the input to the script should be a json containing a list of
observations, each observation having apage_id: <page-id>mapping.
Additionally also pass the mid-level wikiprojects json for the script to
generate wikiprojects to mid-level categories mapping. The script augments the
given list with the mentioned fields, writing them to a new file specified by“output”## Generating predictions for a set of page-ids on WikipediaFor generating topic predictions for a set of revision-ids, download the relevant model and use revscoring’s [score](https://github.com/wikimedia/revscoring/blob/master/revscoring/utilities/score.py) API
to generate predictions. Note that the revision-ids need to be in a file with a format specified by the API. Use the revision ID of the most recent revision for a page to get a good prediction.
Package: drag
Drag: A Webook listener dragging along its dockerized serviceMinimalistic GitHub/GitLab webhook listener for use in an existing Docker image.ProblemThe basic premise for Docker and other virtualization environments is to
isolate the single service they provide from the environment, for containment,
ease of administration, and security.Sometimes, however, it is necessary to inform the running service of changes,
without having to recreate the entire container. For example, a web or DNS
server should serve new files or use a different configuration.The classic solution is to expose the directory tree in question to the host or
another container, which updates the contents. That works great unless the
server needs to be informed when it should start to use the new data.Running the update process on the host is often not an option. Running it
inside another container requires either a listener in the service container
(which brings us back to square one) or exposing the Docker control socket to
the container, with security and dependency problems.Alternatives include running a service manager inside the container.Solution: Webhook inside the service containerdragis an easy way of adding a webhook to an existing container.
Just create aDockerfileinheriting from the original service, installingdragand using it as a wrapper for the original command.FROMcznic/knot:latestRUNaptupdate&&\aptinstall--no-install-recommends--yespython3-pipgitssh&&\aptclean&&\rm-rf/var/lib/apt/lists/*RUNpip3installdrag&&rm-rf${HOME}/.cache# `drag` is configured by environment variables# The secret that must be part of a GitHub- or GitLab-style requestENVDRAG_SECRET123# The command to execute, passed to a shellENVDRAG_COMMANDcd/storage/data&&gitupdate&&knotcreload# Ensure everything is up to date at start (cannot reload daemon yet)ENVDRAG_INITcd/storage/data&&gitupdate# Just prepend `drag` to the original command lineCMD["drag","knot","-c","/config/knot.cfg']Operationdragforks a child process, which listen for HTTP webhook requests on port
1291, verifying them againstDRAG_SECRET, before runningDRAG_COMMAND.The main process replaces itself by what the service process, so it maintains
process ID 1, and termination of the service process will be managed by Docker
as usual.HTTPS supportHTTPS support is missing on purpose, as it is expected that you already run
your HTTPS proxy somewhere. If not, have a look athttps-portal, which can be
configured e.g. with the following lines ofdocker-compose.yml:version:'2'services:reverse-proxy:image:steveltn/https-portal:1restart:unless-stoppedvolumes:-./ssl-certs:/var/lib/https-portal-./vhosts:/var/www/vhostsports:-'80:80'-'443:443'environment:DOMAINS:|hook.example.com -> dockerhost:1291,(more domains here)
Package: dragala
dragalaImagine an AI assistant that speaks Python, taking your natural language requests and turning them into instant, executable scripts. That's the power of dragala, an open-source command-line tool designed to supercharge your productivity and automate repetitive tasks.QuickstartInstall dragala with pip:pip install dragalaExecute a prompt and closedragala Just say helloConfigurationdragala usesgemini-promodel for completions. You can config API KEY by modifying~/.dragla/config.yaml. You can get an API key fromai.google.dev.LicenseThis project is licensed under the Apache License 2.0 - see theLICENSEfile for details.InspirationThis project is inspired byhttps://github.com/AbanteAI/rawdog. It's designed to be a lightweight, open-source alternative that's easy to use and extend.
Package: dragmap-meth
# dragmap_meth (dragmap_meth.py)Alignment of BS-Seq reads using [dragmap](https://github.com/Illumina/DRAGMAP).## IntroThis works for single-end reads and forpaired-end reads from the
directional protocol(most common).## Installation### Installdragmap-methviapipdragmap-methis available onhttps://pypi.org/project/dragmap-meth/` pip installdragmap-meth`## Installdragmap-methviaconda` conda env create-nenv4dragmap-meth--fileenvironment.yaml python=3 git clonehttps://github.com/xie186/dragmap-meth.gitcddragmap-meth/`## QuickStartThe commands:` pythondragmap-meth.pybuildhashtable-rref.fa-oref/ pythondragmap-meth.pydragmap-htref/-r1t_R1.fastq.gz-r2t_R2.fastq.gz |samtools view-bS--odragmap-meth.bam`will createdragmap-meth.bam.
To align single end-reads, specify only 1 file:-r1 some_read.fastq.gz### Dependencies` Python 3.10.1 dragmap `## Reference:Introducing DRAGMAP, the new genome mapper in DRAGEN-GATK:https://gatk.broadinstitute.org/hc/en-us/articles/4410953761563-Introducing-DRAGMAP-the-new-genome-mapper-in-DRAGEN-GATKDemystifying the versions of GRCh38/hg38 Reference Genomes, how they are used in DRAGEN™ and their impact on accuracy:https://www.illumina.com/science/genomics-research/articles/dragen-demystifying-reference-genomes.htmlhttps://github.com/DavidStreid/bio_docker/tree/main/dragmaphttps://github.com/HudsonAlpha/CSL_public_benchmark## AcknowledgementSpecial thanks to [bwa-meth](https://github.com/brentp/bwa-meth). Part of the codes were adapted from bwa-meth.
Package: dragn
Roll dice in your python programsWhy?I wanted a better API to rolling dice using Python, and the usualrandom.randintis very good,
but doesn't really represent rolling dice quite the way I imagine it.This was a good learning experiment, but I'm not expecting anyone to use it.Who is this for?People building RPGs, or games that would involve dice and who care about how their code looks
like.I may be biased, but I really believe that this library provides a much better interface than
purerandom.randint.How to install$pipinstalldragnHow to use>>fromdragn.diceimportD4,D6,D8>>>D6()1>>>f"You roll the die and the result is{D8()}"'You roll the die and the result is 4'>>>f"You roll 3 dice and you get{[D8()for_inrange(3)]}">>>'You roll 3 dice and you get [3, 1, 8]'>>>four_dice=D4*4>>>f"You roll 4 dice and the results are{four_dice()}"'You roll 4 dice and the results are (4, 3, 1, 2)'>>>f"You roll two dice and the results are{two_dice()}"'You roll two dice and the results are (3, 4)'>>>dice_tower=(D6*2)+D4>>>f"You roll two D6 and a D4 and check the results{dice_tower()}"'You roll two D6 and a D4 and check the results (2, 2, 6)'For more examples, check thetests
Package: dragoman-tool
An Optimized, RML-engine-agnostic Interpreter for Functional Mappings. It planns the optimized execution of FnO functions integrated in RML mapping rules, interprets and transforms the rules into function-free ones efficiently. Since Dragoman is engine-agnostic it can be adopted by any RML-compliant Knowledge Graph creation framework.You can use Dragoman with your own library of functions! Here ishow:Make a copy of functions.py that is located in ./Interpreter/ and rename it (we consider it as new_function_script.py)Edit new_function_script.py by adding your functions definitions following the sctructure provided in the script and save the chnagesGo to the connection.py and replace ".functions" with ".new_function_script" at line 6 and save the changesThat's it! You are ready to go :)Installing and Running the DragomanFrom PyPI (https://pypi.org/project/dragoman-tool/):python3 -m pip install dragoman-tool
python3 -m Interpreter -c /path/to/config/fileFrom Docker (https://hub.docker.com/repository/docker/sdmtib/dragoman):docker run -d -p 4000:4000 -v /path/to/yourdata:/data dragoman

Send a GET request with the configuration file to Dragoman container.
curl localhost:4000/mapping_transformation/data/your-config-file.ini


Get the results from the container (if output folder is inside data folder, results are already in your host)
docker cp CONTAINER_ID:/app/path/to/output .Version1.0LicenseThis work is licensed under Apache 2.0AuthorsSamaneh Jozashoori (samaneh.jozashoori@tib.eu)Enrique Iglesias (iglesias@l3s.de)Maria-Esther Vidal (maria.vidal@tib.eu)
Package: dragonchain-sdk
IntroThis is the Python 3 SDK for interacting with a dragonchain. It provides
functionality to be able to interact with a dragonchain through a simple
sdk with minimal configuration needed.DocumentationAll documentation for this SDK can be foundhereInstallationWindows note: If running on a Windows computer, for the following
section, you will probably have to replacepython3withpythonin the commands below depending on how python3 was installed on your
computer.First ensure that you have python3 installed on your machine.The easiest way to install this repository is with pip. Simply run:python3 -m pip install -U dragonchain-sdkYou can also install this package from source. To do so, get the source
code (via git clone likegit clonehttps://github.com/dragonchain/dragonchain-sdk-python.gitor simply downloading/extracting a source tarball from releases), then
navigate into the root project directory. Now ensure that you have pip
installed and you can install all the requirements for this project
with:python3 -m pip install -U -r requirements.txtOnce these requirements successfully install, run:./run.shbuildsudo./run.shinstallOn windows, simply replace the above 2 commands with:python setup.py build
python setup.py installConfigurationPlease view thedocsfor configurationContributingDragonchain is happy to welcome contributions from the community.
You can get startedon github.
Package: dragon-e
Dragon-EWhat is it?Dragon-E is a simple but powerful library to encode messages. It relies on the end-user having the decryption key.What does it look like?Encoded messages will look something like this:154:221:169:238:253:184:108:204:179:230:206:254:185:220:241:251:179:135:226:169:116:183:139:180:240:245:178:192:254:170:236:195:237:189:148:168:241:166:218:242:86:200:197:139:189:250:243:106:188:232:168:238:189:236:174:150In this case, the original message wasDragon Encryption is a lightweight, easy to use package.and was encoded using the passkeyAV3ry57r0nGp4Ssw0Rd!?.What makes it so amazing?Unlike some other encryption methods, the encoded message's length is not dependent on the passkey's length. This makes it more difficult to guess the passcode.Every part of the passkey is important, meaning that you can't solve it all at once.The longer the message and passkey, the more difficult it is to decode.How can I download it?pip install dragon-eEXAMPLEEncryptingfromdragon_eimportdragon_easdeimportant_info=de.encrypt("Don't share this info with anybody!","V3ry57r0ngS3cuR17yK3Y")withopen('secret_file.dragon','w')asf:f.write(important_info)Decryptingfromdragon_eimportdragon_easdef=open('secret_file.dragon','r')super_secret=f.read()f.close()decrypted=de.decrypt(super_secret,"V3ry57r0ngS3cuR17yK3Y")print("Decoded information: "+decrypted)
Package: dragon-eval
DRAGON EvaluationEvaluation method for the DRAGON (Diagnostic Report Analysis: General Optimization of NLP) challenge.InstallationA pre-built Docker container with the DRAGON evaluation method is available:docker pull joeranbosma/dragon_evalThe DRAGON evaluation method can be pip-installed:pip install dragon_evalOr, alternatively, it can be installed from source:pip install git+https://github.com/DIAGNijmegen/dragon_evalThe evaluation method was tested with Python 3.10. Seerequirements.txtfor a full list of exact package versions.UsageThe Docker container can be used to evaluate the synthetic datasets as specified inevaluate.sh. To evaluate the synthetic tasks, place the predictions to evaluate in thetest-predictionsfolder and run./evaluate.sh.The DRAGON evaluation method can also be used from the command line (if installed with pip):python -m dragon_eval --ground-truth-path="ground-truth" --predictions-path=test-predictions --output-file=metrics.json --folds 0 1 2 3 4 --tasks 000 001 002 003 004 005 006 007The command above should work when executed from thedragon_evalfolder, which needs to be cloned locally for the ground truth and prediction files to be present. Change the paths above when executing the command from a different place or storing the files in a different place. The tasks and folds to evaluate can be changed with the respective parameters.
Package: dragonfluid
The dragonfluid library is a simple extension todragonfly, a library to
create rules or macros that work with Dragon NaturallySpeaking
or Windows Speech Recognition. dragonfluid adds “out of the box”
support for chaining multiple commands in a row without pausing during
speech. You are assumed to be familiar withdragonflyand its use.Learn Morehttp://dragonfluid.readthedocs.org/en/latest/
Package: dragonfly
Dragonfly offers a powerful Python interface to speech
recognition and a high-level language object model to easily
create and use voice commands.  Dragonfly supports following
speech recognition engines:Dragon NaturallySpeaking (DNS), a product ofNuanceWindows Speech Recognition (WSR), included with Microsoft
Windows Vista and freely available for Windows XPBasic exampleA very simple example of Dragonfly usage is to create a static
voice command with a callback that will be called when the
command is spoken.  This is done as follows:from dragonfly.all import Grammar, CompoundRule

# Voice command rule combining spoken form and recognition processing.
class ExampleRule(CompoundRule):
    spec = "do something computer"                  # Spoken form of command.
    def _process_recognition(self, node, extras):   # Callback when command is spoken.
        print "Voice command spoken."

# Create a grammar which contains and loads the command rule.
grammar = Grammar("example grammar")                # Create a grammar to contain the command rule.
grammar.add_rule(ExampleRule())                     # Add the command rule to the grammar.
grammar.load()                                      # Load the grammar.The example above is very basic and doesn’t show any of
Dragonfly’s exciting features, such as dynamic speech elements.
To learn more about these, please take a look at the project’s
documentationhere.
Package: dragonfly-core
dragonfly-coreDragonfly is a collection of Python libraries to create representations of buildings
followingdragonfly-schema.
It abstracts the capabilities ofhoneybee-coreto make it easier to construct models on the urban scale.This repository is the core repository that provides dragonfly's common functionalities.
To extend these functionalities you should install available Dragonfly extensions or write
your own.Here are a number of frequently used extensions for Dragonfly:dragonfly-energy: Adds Energy simulation to Dragonfly.Installationpip install -U dragonfly-coreTo check if Dragonfly command line interface is installed correctly usedragonfly vizand you
should get aviiiiiiiiiiiiizzzzzzzzz!back in response!API DocumentationLocal DevelopmentClone this repo locallygit clone git@github.com:ladybug-tools/dragonfly-core.git#orgit clone https://github.com/ladybug-tools/dragonfly-core.gitInstall dependencies:cd dragonfly-corepip install -r dev-requirements.txtpip install -r requirements.txtRun Tests:python -m pytests tests/Generate Documentation:sphinx-apidoc -f -e -d 4 -o ./docs ./dragonflysphinx-build -b html ./docs ./docs/_build/docs
Package: dragonfly-doe2
dragonfly-doe2Dragonfly extension for energy modeling with the DOE-2 engine.DOE-2is a widely used and accepted freeware building energy analysis program that can predict the energy use and cost for all types of buildings.Installationpip install -U dragonfly-doe2QuickStartimport dragonfly_doe2API DocumentationLocal DevelopmentClone this repo locallygit clone git@github.com:ladybug-tools/dragonfly-doe2#orgit clone https://github.com/ladybug-tools/dragonfly-doe2Install dependencies:cd dragonfly-doe2
pip install -r dev-requirements.txt
pip install -r requirements.txtRun Tests:python -m pytest tests/Generate Documentation:sphinx-apidoc -f -e -d 4 -o ./docs ./dragonfly_doe2sphinx-build -b html ./docs ./docs/_build/docs
Package: dragonfly-energy
dragonfly-energyDragonfly extension for energy simulation.Installationpip install dragonfly-energyQuickStartimportdragonfly_energyAPI DocumentationUsageSince the building geometry in dragonfly is fundamentally 2D, creating a model of
a building and assigning energy model properties can be done with a few lines of
code. Here is an example:fromdragonfly.modelimportModelfromdragonfly.buildingimportBuildingfromdragonfly.storyimportStoryfromdragonfly.room2dimportRoom2Dfromdragonfly.windowparameterimportSimpleWindowRatiofromhoneybee_energy.lib.programtypesimportoffice_program# create the Building objectpts_1=(Point3D(0,0,3),Point3D(0,10,3),Point3D(10,10,3),Point3D(10,0,3))pts_2=(Point3D(10,0,3),Point3D(10,10,3),Point3D(20,10,3),Point3D(20,0,3))pts_3=(Point3D(0,10,3),Point3D(0,20,3),Point3D(10,20,3),Point3D(10,10,3))pts_4=(Point3D(10,10,3),Point3D(10,20,3),Point3D(20,20,3),Point3D(20,10,3))room2d_1=Room2D('Office1',Face3D(pts_1),3)room2d_2=Room2D('Office2',Face3D(pts_2),3)room2d_3=Room2D('Office3',Face3D(pts_3),3)room2d_4=Room2D('Office4',Face3D(pts_4),3)story=Story('OfficeFloor',[room2d_1,room2d_2,room2d_3,room2d_4])story.solve_room_2d_adjacency(0.01)story.set_outdoor_window_parameters(SimpleWindowRatio(0.4))story.multiplier=4building=Building('OfficeBuilding',[story])# assign energy propertiesforroominstory.room_2ds:room.properties.energy.program_type=office_programroom.properties.energy.add_default_ideal_air()# create the Model objectmodel=Model('NewDevelopment',[building])Once a Dragonfly Model has been created, it can be converted to a honeybee Model,
which can then be converted to IDF format like so:# create the dragonfly Model objectmodel=Model('NewDevelopment',[building])# serialize the dragonfly Model to Honeybee Models and convert them to IDFhb_models=model.to_honeybee('Building',use_multiplier=False,tolerance=0.01)idfs=[hb_model.to.idf(hb_model)forhb_modelinhb_models]The dragonfly model can also be serialized to a geoJSON to be simulated with URBANopt.fromladybug.locationimportLocation# create the dragonfly Model objectmodel=Model('NewDevelopment',[building])# create a location for the geoJSON and write it to a folderlocation=Location('Boston','MA','USA',42.366151,-71.019357)sim_folder='./tests/urbanopt_model'geojson,hb_model_jsons,hb_models=model.to.urbanopt(model,location,folder=sim_folder)Local DevelopmentClone this repo locallygit clone git@github.com:ladybug-tools/dragonfly-energy

# or

git clone https://github.com/ladybug-tools/dragonfly-energyInstall dependencies:cd dragonfly-energy
pip install -r dev-requirements.txt
pip install -r requirements.txtRun Tests:python -m pytest tests/Generate Documentation:sphinx-apidoc -f -e -d 4 -o ./docs ./dragonfly_energy
sphinx-build -b html ./docs ./docs/_build/docs
Package: dragonfly-grasshopper
dragonfly-grasshopper:dragon: :green_book: Dragonfly plugin for Grasshopper (aka. dragonfly[+]).This repository contains all Grasshopper components for the dragonfly plugin.
The package includes both the userobjects (.ghuser) and the Python source (.py).
Note that this library only possesses the Grasshopper components and, in order to
run the plugin, the core libraries must be installed in a way that they can be
discovered by Rhino (see dependencies).DependenciesThe dragonfly-grasshopper plugin has the following dependencies (other than Rhino/Grasshopper):ladybug-coreladybug-geometryladybug-comfortladybug-rhinohoneybee-corehoneybee-energyhoneybee-energy-standardsdragonfly-coredragonfly-energyOther Required ComponentsThe dragonfly-grasshopper plugin also requires the Grasshopper components within the
following repositories to be installed in order to work correctly:ladybug-grasshopperhoneybee-grasshopper-corehoneybee-grasshopper-energyhoneybee-grasshopper-radianceInstallationSee theWiki of the lbt-grasshopper repositoryfor the installation instructions for the entire Ladybug Tools Grasshopper plugin
(including this repository).
Package: dragonfly-ies
dragonfly-iesDragonfly extension for export to IES-VE GEM file formatInstallationpip install dragonfly-iesQuickStartimportdragonfly_iesAPI DocumentationLocal DevelopmentClone this repo locallygit clone git@github.com:ladybug-tools/dragonfly-ies#orgit clone https://github.com/ladybug-tools/dragonfly-iesInstall dependencies:cd dragonfly-iespip install -r dev-requirements.txtpip install -r requirements.txtRun Tests:python -m pytest tests/Generate Documentation:sphinx-apidoc -f -e -d 4 -o ./docs ./dragonfly_iessphinx-build -b html ./docs ./docs/_build/docs