Saravanan666/pypi-org huggingface dataset:
Package: duel
DuelTeam Name: Python Buds
Team Members: Alexis Dougherty, Aaron Gonzalez, Zachary Stanford, Grace Wilcox, and Joshua Zimmerman
Github:https://github.com/AlexisDougherty13/DuelHow to run:After pip install duel, open the XLaunch application, then type 'python3 -m duel' into the console to run the game.
You might need to be in the root directory to run the game.PyPi Package NameThe PyPi Package Name is duelHow to PlayObjectiveManeuver sword and position in order to avoid your opponent's attacks. Match your opponent's guard and deflect incoming strikes. Attack the opponent in low, mid, and high guarding positions.  Move your sword into your opponent's from above or below to disarm, but be quick for they can reclaim their fallen sword by ducking near it. If you strike where your opponent is not prepared, you will slay them. The first duelist to reach the opponent's flag on the opposite side of the field claims victory!ControlsPlayer 1A/D - Left/Right MovementW/S - Guard Up/DownS(while in low guard) - DuckSpace - JumpF - Sword ThrustPlayer 2Left/Right Arrow - Left/Right MovementUp/Down Arrow - Guard Up/DownDown Arrow(while in low guard) - DuckRight Shift - JumpRight Ctrl - Sword Thrust
Package: duelpy
duelpyThis is a python package for solving with Preference Based Multi Armed Bandit problems, also known as dueling bandits. Refer tothis paperfor an overview of the field.You can compare the implemented algorithms in an experiment by runningpython3 -m duelpy.experiments.cliThe experiments are still rather limited. The command-line interface can
currently only run regret-based comparisons in a limited set of configurations.
Pass the--helpflag for more information.Seethe documentationfor more information about the implemented algorithms.
Package: duet
duetA simple future-based async library for pythonDuet takes inspiration from the amazingtriolibrary and thestructured concurrencyapproach to async programming that it uses.
However, duet differs from trio in two major ways:Instead of a full-blown implementation of asynchronous IO, duet relies  on theFutureinterface for parallelism, and provides a way to run async/await
coroutines around thoseFutures. This is useful if you are using an API that
returns futures, such as RPC libraries like gRPC. The standardFutureinterface does not implement__await__directly, soFutureinstances must
be wrapped induet.AwaitableFuture.duet is re-entrant. At the top level, you run async code by callingduet.run(foo). Insidefoosuppose you call a function that has not yet
been fully refactored to be asynchronous, but itself callsduet.run(bar).
Most async libraries, includingtrioandasyncio, will raise an exception
if you try to "re-enter" the event loop in this way, but duet allows it. We
have found that this can simplify the process of refactoring code to be
asynchronous because you don't have to completely separate the sync and async
parts of your codebase all at once.InstallationInstall from pypi:pip install duetNoteduet is not an official Google project.
Package: duet-async
duetNOTE: duet-async has been renamedduet. Please use that instead.A simple future-based async library for pythonDuet takes inspiration from the amazingtriolibrary and thestructured concurrencyapproach to async programming that it uses.
However, duet differs from trio in two major ways:Instead of a full-blown implementation of asynchronous IO, duet relies  on theFutureinterface for parallelism, and provides a way to run async/await
coroutines around thoseFutures. This is useful if you are using an API that
returns futures, such as RPC libraries like gRPC. The standardFutureinterface does not implement__await__directly, soFutureinstances must
be wrapped induet.AwaitableFuture.duet is re-entrant. At the top level, you run async code by callingduet.run(foo). Insidefoosuppose you call a function that has not yet
been fully refactored to be asynchronous, but itself callsduet.run(bar).
Most async libraries, includingtrioandasyncio, will raise an exception
if you try to "re-enter" the event loop in this way, but duet allows it. We
have found that this can simplify the process of refactoring code to be
asynchronous because you don't have to completely separate the sync and async
parts of your codebase all at once.InstallationInstall from pypi:pip install duet-asyncNoteduet is not an official Google project.
Package: duetwebapi
DuetWebAPIPython interface to Duet RepRap V3 firmware via Http REST API.Works over IP network.Does not support passwords on the printer.Supported boards:Duet 3 + SBCDuet 3 standaloneDuet 2 standaloneInstallpip install duetwebapiAlternatively:pip install -e "git+https://github.com/AndyEveritt/DuetWebAPI.git@master#egg=duetwebapi"UsageSee 'examples.py' for examples.fromduetwebapiimportDuetWebAPIprinter=DuetWebAPI(f'http://{printer_hostname}')REST APIThe REST API allows for the following operations:MethodDescriptionget_model(key: str = None) -> DictGet Duet object model. RRF3 onlysend_code(code: str) -> DictSend G/M/T-code to Duetget_file(filename: str, directory: str = 'gcodes', binary: bool = False) -> strDownload file from Duetupload_file(file: str | bytes | StringIO | TextIOWrapper | BytesIO, filename: str, directory: str = 'gcodes') -> DictUpload file to Duetget_fileinfo(filename: str = None, directory: str = 'gcodes') -> DictGet file infodelete_file(filename: str, directory: str = 'gcodes') -> DictDelete file on Duetmove_file(from_path: str, to_path: str, force: bool = False) -> DictMove file on Duet, can be used to rename filesget_directory(directory: str) -> List[Dict]Get a list of all the files & directories in a directorycreate_directory(directory: str) -> DictCreate a new directoryWrapperAn additional wrapper is provided to make repetative tasks easierMethodDescriptionemergency_stop() -> NoneSend M112 > M999start_print(filename: str) -> Dictstart a print on duetpause_print() -> Dictpause current printstop_print(leave_heaters: bool) -> Dictstop current print, will pause first if not pausedget_coords() -> Dictreturn the current position of all the movement axesget_layer() -> intreturn the current layer number of the printget_num_extruders() -> intreturn the number of extruders currently configuredget_num_tools() -> intreturn the number of tools currently configuredget_status() -> strreturn the current Duet statusget_temperature() -> List[Dict]return a list of all the analog sensors and their valueget_current_tool() -> intreturn the current tool numberget_messagebox() -> Dictreturn the details of a message displayed viaM291if one existsacknowledge_message(response: int) -> Dictsend an acknowledgement to a message if one exists. Response options are0(continue), and1(cancel)
Package: duffel-api
duffel-apiPython client library for theDuffel API.RequirementsPython 3.8+Getting startedpipinstallduffel-apiUsageYou first need to set the API token you can find in the Duffeldashboardunder the section
Developers > Access Tokens.Once you have the token, you can callDuffel()with the value:fromduffel_apiimportDuffelaccess_token='test_...'client=Duffel(access_token=access_token)After you have a client you can interact with, you can make calls to the Duffel API:fromduffel_apiimportDuffelclient=Duffel(access_token='test...')offer_requests=client.offer_requests.list()foroffer_requestinoffer_requests:print(offer_request.id)You can find a complete example of booking a flight in./examples/book-flight.py.DevelopmentTestingRun all the tests:toxAs part of runningtox, a code coverage report is built for you. You can navigate it by openinghtmlcov/index.htmlin a browser, or if in a OS that supports it by usingopen(alternativexdg-open):open./htmlcov/index.htmlPackagingSetup pypi config (~/.pypirc):[pypi]
  username = __token__
  password = pypi-generated-token

[testpypi]
  username = __token__
  password = pypi-generated-tokenInstall dependencies:pipinstallwheeltwineBuild the package before uploading:pythonsetup.pysdistbdist_wheelUpload packages (test):twineupload-rtestpypi--verbosedist/*The above will upload the packages totest.pypi.orgwhich will allow you to verify all is well
with your upload before uploading it to the main pypi repository.twineupload-rpypi--verbosedist/*
Package: duffy
InfoCommunity Platform Engineering team (of Red Hat) is working on revamping this project and thus, have cleaned this repository bymarking other branches staleClean branch created for developmentto see the current deployed version of Duffy in CentOS CI Infra, check stale/master branch.DuffyDuffy is the middle layer running ci.centos.org that manages the provisioning, maintenance and teardown / rebuild of the Nodes (physical hardware for now, VMs coming soon) that are used to run the tests in the CI Cluster.DevelopmentInstallationTo install Duffy:Clone the repository and navigate into the project directory.git clone https://github.com/CentOS/duffy.git
cd duffySet up and activate a virtual environment.Using native virtual environmentpython3 -m venv duffyenv
source duffyenv/bin/activateOrUsing virtualenv wrappervirtualenv duffyenv
source duffyenv/bin/activateOrUsing Poetry virtual environment shellpoetry shellInstall using Poetrypoetry installRunning Duffy serverViewing CLI usageduffy --helpUsage: duffy [OPTIONS]

  Duffy is the middle layer running ci.centos.org that manages the
  provisioning, maintenance and teardown / rebuild of the Nodes (physical
  hardware for now, VMs coming soon) that are used to run the tests in the CI
  Cluster.

Options:
  -p, --portnumb INTEGER          Set the port value [0-65536]
  -6, --ipv6                      Start the server on an IPv6 address
  -4, --ipv4                      Start the server on an IPv4 address
  -l, --loglevel [critical|error|warning|info|debug|trace]
                                  Set the log level
  --version                       Show the version and exit.
  --help                          Show this message and exit.Starting the server at port 8080 using IP version 4 and setting the log level totraceduffy -p 8000 -4 -l trace* Starting Duffy...
 * Port number : 8000
 * IP version  : 4
 * Log level   : trace
INFO:     Started server process [104283]
INFO:     Waiting for application startup.
TRACE:    ASGI [1] Started scope={'type': 'lifespan', 'asgi': {'version': '3.0', 'spec_version': '2.0'}}
TRACE:    ASGI [1] Receive {'type': 'lifespan.startup'}
TRACE:    ASGI [1] Send {'type': 'lifespan.startup.complete'}
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)Exit out of the server usingCtrl+C
Package: dufte
Deprecationdufte as a stand-alone module has been deprecated and merged intomplx.Da kiekste, wa?This package creates clean and beautiful plots that work on light and dark backgrounds.
Inspired by the work ofEdward Tufte.To use, install withpip install dufteand simply select theduftestyle:importdufteimportmatplotlib.pyplotasplt# global setting:plt.style.use(dufte.style)# with a context manager:withplt.style.context(dufte.style_bar):# ...passCheck outdufte.legend(),dufte.ylabel(), anddufte.show_bar_values()for more
duftiness.Comparison with default MatplotlibSeeherefor how to create the below plots.matplotlibdufte withdufte.legend()matplotlibduftedufte withdufte.show_bar_values()Further reading and other stylesRemove to improve: data-ink ratioRemove to improve: Line Graph EditionShow the Data - Maximize the Data Ink RatioRandal S. Olson's blog entryprettyplotlibWikipedia: ChartjunkOther stylesJohn Garrett,Science PlotsDominik Haitz,Cyberpunk styleDominik Haitz,Matplotlib stylesheetsCarlos da Costa,The Grand Budapest HotelDanny Antaki,vaporwave aestheticsQuantumBlack Labs,QuantumBlackProjects using dufte:perfplotstargraphBackgroundThe position $x_i$ of the line annotations is computed as the solution of a
non-negative least-squares problem\begin{align}
\frac{1}{2}\sum_i (x_i - t_i)^2 \to \min_x,\\
(x_i - x_j)^2 \ge a^2 \quad \forall i,j.
\end{align}where $a$ is the minimum distance between two entries and $t_i$ is the target
position.
Package: dug
A python memoisation framework.Unlike other well known examples, uses run time tracing instead of parsing or meta-evaluation to build up a directed acyclic graph of function dependencies.Unloading values from the cache must be done explicitly but is made easier by support for nested cache contexts.Dug supports manually changing the return value of tracked functions for certain parameters.Dug stands for directed un-cyclic graph.  I know un-cyclic isn’t a real word.InstallationDug can be installed from pypiGetting startedComponentsCache:Created on entering a contextPopulated with tweaks from the owning contextNo support for rebuilding on top of a parent cache, must be recreated from tweaks stored in the context.Should not forward changes on to parent cache.  Nodes in parent cache that have different values from what they would in the child cache should be marked as masked.Identifying nodesNode identifiers must be serializable.
It probably makes sense for node identifiers to just hold a reference to the function and rely on pickle or whatever to deal with the wire format.Stacked contexts, tweaking, and cache invalidationThe rules:
Tweaked nodes are masked.
Nodes depending on masked nodes are also masked.
Nodes marked as masked should not be fetched from the parent context.
The results of nodes marked as masked should be stored in the current context’s cache.
Nodes can be marked as masked and stored in the cache.
Nodes can be marked as masked and not stored in the cache.Tweaking a node:When tweaking a node it is necessary to mark all of its descendants as masked.
This can be done recursively.
On encountering a node that is already marked as masked, it can be assumed that all of its descendants are also marked as masked.  This means that it is not necessary to recurse past it.Re-entering a context:It is possible that on re-entering a context, the parent context will have changed.  It will probably always be necessary to re-tweak all nodes in the context.Some part of the cache will have to be invalidated to account for changes in the new parent.
It might be possible to invalidate only the parts marked masked in the parent context.
It might make sense to always clear the cache on exiting the context no matter what.  This would allow contexts to be used as a way to avoid excessive caching.Garbage collectionIt has been suggested that garbage collection is probably not actually necessary.  Instead rely on discarding contexts to get granular control over what stuff to keep.QuestionsIs there a way to split tweaking from caching?
Package: dugong
The Python Dugong module provides an API for communicating with HTTP
1.1 servers. It is an alternative to the standard library’shttp.client(formerlyhttplib) module. In contrast tohttp.client, Dugong:allows you to send multiple requests right after each other without
having to read the responses first.supports waiting for 100-continue before sending the request body.raises an exception instead of silently delivering partial data if the
connection is closed before all data has been received.raises one specific exception (ConnectionClosed) if the connection
has been closed (whilehttp.clientconnection may raise any ofBrokenPipeError,~http.client.BadStatusLine,ConnectionAbortedError,ConnectionResetError,~http.client.IncompleteReador simply return''on read)supports non-blocking, asynchronous operation and is compatible with
theasynciomodule.can in most cases distinguish between an unavailable DNS server and
an unresolvable hostname.is not compatible with old HTTP 0.9 or 1.0 servers.All request and response headers are represented asstr, but must be
encodable in latin1. Request and response body must bebytes-like
objectsor binary streams.Dugong requires Python 3.3 or newer.InstallationAs usual: download the tarball fromPyPi, extract it, and run# python3 setup.py install [--user]To run the self-tests, installpy.testwith thepytest-catchlogplugin and run# python3 -m pytest test/Getting HelpThe documentation can beread onlineand is also included in thedoc/htmldirectory of the dugong tarball.Please report any bugs on theissue tracker. For discussion and
questions, please subscribe to thedugong mailing list.Development StatusThe Dugong API is not yet stable and may change from one release to
the other. Starting with version 3.5, Dugong uses semantic
versioning. This means changes in the API will be reflected in an
increase of the major version number, i.e. the next
backwards-incompatible version will be 4.0. Projects designed for
e.g. version 3.5 of Dugong are thus recommended to declare a
dependency ondugong >= 3.5, < 4.0.ContributingThe source code is available onGitHub.
Package: duiker
Automatically index your shell history in a full-text search database. Magic!FeaturesUses SQLite3’s excellentFTS4extension to provide full-text search.RespectsHISTTIMEFORMATif set.RequirementsBashPython 3InstallInstall from pip:pip install duikerOr, simply download thesingle Python fileand add it to
yourPATH.SetupImport your existing shell history:history | duiker import -ConfigurationIf you want to automatically import your shell history on-the-fly, you
can addduiker importto yourPROMPT_COMMAND[1].Runduiker magicto print a shell snippet that automatically imports
your last command into Duiker:duiker magicConfigure this shell snippet as part of yourPROMPT_COMMAND. Runduiker magic--helpfor an example.SearchingDuiker indexes your shell history in an SQLite3 full-text search table.You can use anyMATCH[2]expression to search the database:$ duiker search git
2017-04-13 15:50:02         git staged
2017-04-13 15:50:14         git commit -a
2017-04-13 15:55:07         git diff$ duiker search '(git OR fossil) diff'
2017-04-27 15:15:01         git diff
2017-04-27 15:15:49         git diff
2017-04-28 14:49:19         fossil diff
2017-04-28 14:53:09         fossil diff src/main.rs$ duiker search 'sqlite*'
2017-03-04 19:00:42         sqlite3 db.sqlite
2017-03-04 19:13:11         rm db.sqliteLimitationsDuiker only supports Bash at present. Pull requests for other shells
welcome.LicenseMIT[1]https://www.gnu.org/software/bash/manual/html_node/Controlling-the-Prompt.html#Controlling-the-Prompt[2]https://sqlite.org/fts3.html#full_text_index_queries
Package: duinobot
# duinobot-interactive
# Conjunto de clases python para permitir que el robot Multiplo Duinobot N6
# pueda programarse en forma interactiva, sin necesidad de bajar firmware al
# robot. Sin embargo es necesario el soporte del firmware del lado del robot
#
# Copyright (C) 2012-2013 Fernando Lopez <soportelihuen@linti.unlp.edu.ar>
# Copyright (C) 2011 RobotGroup / Multiplo <http://www.robotgroup.com.ar>
# Copyright (C) 2011 Joaquín Bogado <jbogado en linti.unlp.edu.ar>
#
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the RobotGroup Multiplo Pacifist License (RMPL)
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the RMPL license along with this program.
# If not, see <multiplo.com.ar/soft/Mbq/Lic.Minibloq.ESP.pdf>.
###############################################################################
Package: duinobot-socks
# duinobot-interactive
# Conjunto de clases python para permitir que el robot Multiplo Duinobot N6
# pueda programarse en forma interactiva, sin necesidad de bajar firmware al
# robot. Sin embargo es necesario el soporte del firmware del lado del robot
#
# Copyright (C) 2012-2013 Fernando Lopez <soportelihuen@linti.unlp.edu.ar>
# Copyright (C) 2011 RobotGroup / Multiplo <http://www.robotgroup.com.ar>
# Copyright (C) 2011 Joaquín Bogado <jbogado en linti.unlp.edu.ar>
#
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the RobotGroup Multiplo Pacifist License (RMPL)
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the RMPL license along with this program.
# If not, see <multiplo.com.ar/soft/Mbq/Lic.Minibloq.ESP.pdf>.
###############################################################################
Package: dukaan
dukaan is a handly tool for testing your Resource Provider for Windows Azure Store.
It lets you simulate calls that Windows Azure will make to your Resource Provider,
on your development computer.Read the full documentation onGithub.To use dukaan, open your favorite shell and typedukaan init. Dukaan will prompt you
for information on how to connect to your Resource Provider. Then, you can typedukaan createto start testing your Resource Provider.
Package: dukeai
Duke-AI Development PackageThis is a duke development package for the developers.To know more about us can, you visit ourwebsite.check_rate_con_schema: Checks the basic schema whether it is standardized schema or not.from dukeai.rpa_functions.ratecon_schema_check import check_rate_con_schema
check_rate_con_schema(rate_con_data, only_warning=False)check_rate_con_data: Checks the minimum required data in the rate confirmation.from dukeai.rpa_functions.ratecon_data_check import check_rate_con_data
check_rate_con_data(rate_con_data)Get the rate confirmation standardized schemafrom functions.get_ratecon_schema import get_rate_confirmation_schema, get_stops_schema, get_entity_schema
from functions.get_ratecon_schema import get_reference_schema, get_note_schema, get_dates_schema
Package: dukeai-lib
Duke.ai Lib (dukeai_lib)Latest Release: 2023-07-25The dukeai_lib PIP package repository; Contains base functions that are used across multiple internal backend projects making it easier for developers to maintain consistency via a centralized codebase while enabling retroactive updates to core functionality.Modulestoolsgen_random_sha()applicationcheck_access()api_response()utilitiesDecimalEncoder(class)schema_kung_furate_confirmationflatten_ratecon()unflatten_ratecon()accessorialflatten_accessorial()unflatten_accessorial()bill_of_ladingflatten_bol()unflatten_bol()invoiceflatten_invoice()unflatten_invoice()noa_lorflatten_noa_lor()unflatten_noa_lor()classificationdt_multiclass_to_dynamoson()translate_dt_multiclass()classification_template()standardize_classification_name()parse_classification_dynamoson()parse_multiple_classification_dynamoson()schema_utilitiesdict(REFERENCE_OPTIONS)dict(STATES)get_idtype()format_state()parse_incoming_address()format_time()parse_time()Usagepip install dukeai_liband subsequently...import dukeai_liborfrom dukeai_lib.schema_kung_fu import schema_utilities