Saravanan666/pypi-org huggingface dataset:
Package: doitoml
doitomlLoad declarative tasks fordoitfrom TOML, JSON, YAML, and other files.docsinstallbuildSee thefull documentationfor more information.Installpipconda(ormamba,micromamba)pip install doitomlconda install -c conda-forge doitomlFeaturesdeclarativeautomation in asinglepyproject.toml, or...other well-known configuration paths likepackage.jsonany number of namespaced TOML, JSON,YAMLfilesfrom any key inside themaugment and simplify existingdodo.pyworkflowsreuse and transformpathsand shell tokensuseglobsand transforms to capture relationships between transformed filesflexibly configureenvironmentvariablesuser-defined Python-basedactionsandup-to-datecheckerscontrol theworking directoryandlog pathsof processes and actionsusetemplateslike Jinja2 and JSON-e for advanced use casesextensibilityin any part of the task definition processall core functionality implemented asentry_point-basedpluginsExtrasThese features require additionalpiporcondapackagespipcondafeaturedoitoml[all]doitoml-with-allall optional featuresdoitoml[jinja2]doitoml-with-jinja2Jinja2 task templatesdoitoml[json-e]doitoml-with-json-eJSON-e task templatesdoitoml[jsonschema]doitoml-with-jsonschemaextra configuration validationdoitoml[yaml]doitoml-with-yamlYAML-based task sourcesUsagedoitomlprovides no additional command line abilities, and is meant to drop in to the
existingdoit runCLI andother commands.A Simple ExampleNoteThedoitomlGitHubrepository has many examples of different configurations,
including the project's ownpyproject.tomlandpackage.json.Thefull documentationincludes more information about building concise,
declarative, reproducible tasks for your project.The simplest way to usedoitomlneeds only apyproject.toml, whichdoitwill
already check for configuration data.# pyproject.toml[project.optional-dependencies]dev=["doitoml"][tool.doit]loader="doitoml"verbosity=2[tool.doitoml.tasks.hello]actions=['echo "Hello World!"']After installing thedevextra dependency...pipinstall-e.[dev]... and running ...doit... you would see ....hello:
HelloWorld!AlternativesIf you don't likedoitoml, ordoit, or even Python, no worries! Butpleaseconsider trying one of these lovely alternatives before giving up and making your team
do everythingThe Hard Way:doitgo-taskjustmakenxFree Softwaredoitomlis licensed under theBSD-3-ClauseLicense.
Package: doit-redis
# Redis backend for [doit](https://github.com/pydoit/doit).This plugin for [doit](https://github.com/pydoit/doit) add a new `redis`backend, using the [redis-py](https://github.com/andymccurdy/redis-py) client.This allows to have a more suitable backend for multi-processing, and it evenallows to run multiple doit processes in parallel.Install:```$ pip install doit-redis```Usage:```DOIT_CONFIG = {'backend': 'redis','dep_file': 'redis://[:password]@localhost:6379/0',  # optional}```
Package: doit-report
# Report command for [doit](https://github.com/pydoit/doit).This plugin for [doit](https://github.com/pydoit/doit) add a newreportcommand, which shows an ASCII or HTML report with the task execution status.Install:` $ pip installdoit-report`Usage:` $ doit report $ doit report--html=out.html`This plugin uses [Astropy](https://github.com/astropy/astropy/)’s[Table](http://docs.astropy.org/en/latest/table/index.html) class to create
a table and print it either to the console in ASCII format or to an HTML page.
Astropy is an heavy dependency (it requires Numpy) for this small plugin, but it
was the easiest way to go for now and I didn’t find similar features in
a lighter package.Note that doit does not save the execution status after each task ends, but only
whendoit runexits. This is an issue for long-running tasks, and would need
either something like [#228](https://github.com/pydoit/doit/pull/228) or a better
backend.Example console output:![console output](https://user-images.githubusercontent.com/311639/34677091-4be1ae52-f48f-11e7-83c7-94d259193176.png)And HTML:![HTML output](https://user-images.githubusercontent.com/311639/34677129-69749560-f48f-11e7-96bf-d9f3e994eb04.png)
Package: doit-tasks
A stupid simple CLI task manager, in Python!Huh?DoIt lets you store your tasks in a handy CLI.For example:$ doit "Fix grandma's internet"
Got it! You need to fix grandma's internet.

$ doit
Here's what you still need to do:
(0): Fix grandma's internetCreditThis tool was inspired by:Zach Holman’s “Boom”:https://github.com/holman/boomBen Tappin’s Python implementation of the above, “Bam”:https://github.com/mrben/bam
Package: doit_tools
doit-toolsPredefined tasks fordoitThis library contains common tasks for:pip-toolsisortTo use these tasks, just install doit-tools and import them in your dodo.py. You
can also configure their behavior by setting the config object's attributes.fromdoit_toolsimportconfig,task_compile,task_syncconfig.main_requirements_source='setup.py'You can find out how to use each task and the config object by reading thedocstrings
Package: doit-watch
doit_watchA watch plugin for the Python task managerdoit.How to useRundoit watch, ordoit watch <TASK>, to run the tasks once if
necessary, and then run them again when any of the input files change.$doitwatch
.MyTask
->Watching324filesforchanges...How to installTo install, add the following to your config files:# requirements.txt
doit-watch>=0.1.0# pyproject.toml (if using)
[tool.doit.plugins.command]
watch = "doit_watch:Watch"# doit.cfg (if using)
[COMMAND]
watch = "doit_watch:Watch"CreditsI didn't write this plugin myself. I took the source code of thedoit-auto1plugin, and
combined thePRof
@bollwyvl and thePRof
@jguillon into a new package, with the name that we all agree the
command should have.
Package: dojahcore
#dojahcore-pythonPython plugin forDojahInstallationInstantiate Dojahfromdojahcore.dojahimportDojahdojah_api_key='test_sk_someRandomSecretKey'dojah_app_id='99999999999'dojah_api=Dojah(api_key=dojah_api_key,app_id=dojah_app_id)# to use the general classdojah_api.general.data_plans()
Package: dojango
Dojango is a reusable django application that helps you to use the client-side
framework dojo within your django project. It provides capabilites to easily
switch between several dojo versions and sources (e.g. aol, google, local) and
delivers helping utilities, that makes the development of rich internet
applications in combination with dojo more comfortable. Also it makes the building
of your own packed dojo release easier. Another goal of this project is, that you
can learn how you have to structure your html to use dojo within your projects.For further documentation go to:https://github.com/klipstein/dojango/wiki
Package: dojinvoice_db
dojinvoice_db同人音声 DBDLsitehttps://www.dlsite.com/maniax/works/voice動かすpipinstalldojinvoice-db$ dvdb
Download pages? >> (`y` or Enter)
<int> ids was committed to existed db!
Now: ./dlsite/00001.html
Now: ./dlsite/00002.html
Now: ./dlsite/00003.html
...注意:DB を一から構築するとかなり時間がかかります. 構築済DBはReleasesからスキーマcreate_table('''work (work_id text primary key,detail_link text not null,title text not null,circle text not null,circle_link text not null,category text not null,sale_date integer not null,age_zone text not null,file_format text not null,file_size text not null,description str not null,monopoly integer not null,price integer not null) ''')create_table('''option (work_id text primary key,thumbnail text,cien_link text,series text,chobit_link text,sales integer,favorites integer,trial_link text,trial_size integer,rating real) ''')create_table('''writer (work_id text,writer text,primary key (work_id, writer)) ''')create_table('''scenario (work_id text,scenario text,primary key (work_id, scenario)) ''')create_table('''illustrator (work_id text,illustrator text,primary key (work_id, illustrator)) ''')create_table('''voice (work_id text,voice text,primary key (work_id, voice)) ''')create_table('''musician (work_id text,musician text,primary key (work_id, musician)) ''')create_table('''genre (work_id text,genre text,primary key (work_id, genre)) ''')
Package: dojo-compass
DojoCompass Labs🧭 developeddojo, an agent-based DeFi simulation software operating at the EVM smart contract level.What can you do with dojo?Simulate the behavior of smart contracts in a decentralized finance (DeFi) ecosystem.Test your trading strategies on real code. Get detailed performance metrics.Seamlessy interact with multiple different protocolsVisualize your results in a dashboard.What's coming nextSwitch from backtesting to live-execution. Check on/interact with your runner in real-time using a telegram bot.More protocolsMore dashboard - more fancyWhat makes dojo unique?Dojo executes the exact same code as the Ethereum Virtual Machine (EVM) and is therefore able to simulate the behavior of smart contracts with accuracy.With dojo, we abstract away solidity and allow you to interact with smart contracts using simple Python interfaces.We provide all historic data, you won't have to care about it at all.Dojo has a built-in dashboard to visualize your simulations.How to get startedWe recommend working through our short tutorials to get started. You can find themhere.If you have any feature request or bug report, please open an issue onGitHub.We are also happy to answer any questions you may have viamail.Some impressions
Package: dojo-exporter
Prometheus openmetrics for DojoA devops component for monitoring your self-hostedSamourai Dojo, which can be integrated with your self-hosted SRE stack. If you don't have one set up already, this won't be useful to you. It's a simple python script that gets the JWT, calls the status endpoint, then transforms the results into prometheus metrics.Installation and Usagepipinstall--upgradepip
pipinstalldojo-exporterDefine the connection parameters to your Dojo via environment variables. There are multiple ways you can set it up. One example is to create an.envfile with the following contents:DOJO_APIKEY=<password># RequiredNET_DMZ_NGINX_IPV4=172.29.1.3# Optional. Default value shownDOJO_BASE_URL=http://${NET_DMZ_NGINX_IPV4}# Optional. Default value shownMETRICS_BIND=127.0.0.1# Optional. Default value shownMETRICS_PORT=9102# Optional. Default value shownI would recommend running this as an unprivileged user via systemd (or anything comparable):useradd-mb/opt-k/dev/null-s$(whichnologin)dojo_exporterCreate/etc/systemd/system/dojo_exporter.service:[Unit]Description=Basic openmetrics for Samourai Dojo[Service]User=dojo_exporterGroup=dojo_exporterEnvironmentFile=/opt/dojo_exporter/.envExecStart=dojo_exporterRestart=on-failureRestartSec=5m[Install]WantedBy=multi-user.targetDevelopmentClone the repo and install dependencies into a local virtual environment:gitclonegit@github.com/bleebl33/dojo_exportercddojo_exporter
python-mvenv.venvsource.venv/bin/activate
pipinstall--upgradepip
pipinstall--editable.
dojo_exporterNote that there is a difference betweensource .envand systemd EnvironmentFile which is that you'll need to have the export keyword. i.e.export DOJO_APIKEY=<password>RoadmapInclude testsChangeprint()messages into sensible logging with configuration debug levels.Review Dojo/admin/dmt/status/status.jsto possibly discover more metrics.DockerfileSecurityThis goes without saying for most cases: A number of necessary dependencies are used which causes nominal exposure tosupply chainattacks. The risk would be that the Dojo apikey is leaked, which could compromise user privacy. There should be no risk of losing funds as private keys are never transmitted to the dojo. You should never run this software on a machine with a hot wallet.Furthermore you can harden the installation by keeping it in a virtual environment, rather than installing it globally. Afterwards you can find the path of the command withwhich dojo_exporterand then set your systemd service up accordingly. e.g.ExecStart=/opt/dojo_exporter/.venv/bin/dojo_exporter
Package: dojo-py
Dojo-pyA very incomplete interface to your Samourai Dojo REST API.All requests are proxied through SOCKS to your Dojo's Tor hidden service URLAuthenticated calls to the Dojo make use of theAuthorizationHTTP header with theBearerscheme.Get StartedInstall from pippipinstalldojo-pySetup## Import the packagefrompydojoimportpyDojo## Set two variables for onion address and API key.## Both can be obtained from your Dojo Maintenance Tool## or your pairing QR codeonion='mytorv3onionaddress.onion'apikey='mydojoapikey'pd=pyDojo(onion,apikey)Status## Get Dojo Status## NOTE: this call requires use of the Admin Key instead## of the API Keypd.get_status()Fees## Get current miner fee rates as per your Dojopd.get_fees()Block header## Get information about a certain block headerblockhash='0000000000000000000a0c3d6bbc0168932613d550cb7875459b6d37ae088211'pd.get_block_header(blockhash)Add extended public key to your Dojo## Add a new extended public key to your Dojo## You must tell the Dojo how to derive addresses## if it is a Segwit enabled public key. `bip49` or `bip84`## You also need to supply a method of import. Valid values## are `new` and `restore`.xpub='ypub...'method='restore'segwit='bip49'pd.add_xpub(xpub=xpub,type=method,segwit=segwit)XPUB Info## Get transactions for a given extended public key tracked## by your Dojoxpub='xpub...'pd.get_xpub(payload)Transactions## Get transactions for a given extended public key or loose addresspayload=('bc1q...','1Gef...','xpub...','ypub...','zpub...')pd.get_transactions(payload)Transaction## Get transactions info for a txidtransaction='6d2c2187169c7e85191edeea9d1db732abdefd14c7f1788d999e14b3096f8476'pd.get_transaction(transaction)PushTx## Push a signed transaction to the network using your Dojo nodetx_hex='long_hex_string'pd.push_transaction(tx_hex)Wallet info## Request details about a collection of HD accounts and/or## loose addresses and/or pubkeys (derived in 3 formats P2PKH,## P2WPKH/P2SH, P2WPKH Bech32) including a list of unspent## transaction outputs.payload=('bc1q...','1Gef...','xpub...','ypub...','zpub...')pd.get_wallet(payload)
Package: dojo-referee
Dojo Referee is just another Coding Dojo assistant tool, but with GUI.How to use$ pip install dojo-referee
$ dojo-refereeFeaturesCountdown for pilot iterationSound notificationsChangelog0.1.0Adds sound notifications for start and end of an iterationMinor fixes and improvements0.0.2Fix logging: using logging properly instead of print()Adds support for bumpversion0.0.1Basic countdown timer for 5 minutes coding dojo iteration
Package: dojot-flow-node
# dojot-flow-node-pythonA Python library that allows you to integrate your own node on Dojot's [FlowBroker](https://github.com/dojot/flowbroker).## How to build your own node1) You need to create a class that extends the `DataHandlerBase` class, thisclass is the responsable by implements your node behavior. The following methods__must be__ implemented:- get_node_representation_path- get_metadata- get_locale_data- handle_message2) Is necessary to create a `.html` file that describes your node. You can find how to create it using the [NodeRed documentation](https://nodered.org/docs/creating-nodes/). Dojot's FlowBroker uses the [NodeRed](https://nodered.org/) frontend.3) You need to encapsulate your code into a docker container.4) Publish your container in some public repository like [DockerHub](https://hub.docker.com/) or some private based on [DockerRegistry](https://docs.docker.com/registry).5) Call the FlowBroker endpoint to add a new node. Please check the [FlowBroker documentation](https://dojot.github.io/flowbroker/apiary_latest.html) to checkhow this endpoint works.## SampleA sample node is attached to this package to illustrate the steps described inthe previous section. It's a simple node that converts a Celcius temperaturemeasure into Kelvin.### How to buildBuild the docker image:```shcd sample_nodedocker build -t <your dockerHub username>/kelvin .```Publish it on your DockerHub:```shdocker push <your dockerHub username>/kelvin```Acquire a Dojot's token:```shcurl -X POST http://127.0.0.1:8000/auth \-H 'Content-Type:application/json' \-d '{"username": "admin", "passwd" : "admin"}'```This command will return a JWT token, you need to store it on an environmentvariable:```shexport JWT=<the value returned>```Add the Kelvin node to Dojot.```shcurl -H "Authorization: Bearer ${JWT}" http://localhost:8000/flows/v1/node -H 'content-type: application/json' -d '{"image": "<your dockerHub username>/kelvin:latest", "id":"kelvin"}'```Now the Kelvin node will be available on `converters` category into the FlowBroker Dojot's interface.
Package: dojot.module
# dojot-module-python [![PyPI version](https://badge.fury.io/py/dojot.module.svg)](https://badge.fury.io/py/dojot.module)Common library to be used within dojot modules.Attention: As of version v2.0, this library no longer has integration with the old “auth” service, but with the “keycloak” service.
Be aware that the environment variablesKEYCLOAK_USERandKEYCLOAK_PASSWORDwill probably have to be passed to services that use this library. This user should be able to get the existing realm lists from keycloak.
Package: dojo-toolkit
Toolkit for python coding dojos.Source:https://github.com/grupy-sanca/dojo-toolkitFeaturesTimer to determine the pilot’s turnDisplay notifications on pilot’s time up, tests passed and failedDojo Semaphor through OS notificationsRun tests after each saveHow to useInstallation:$ pip install dojo-toolkitRunning:$ dojo /path/to/code/directory/For detailed information about running from source:CONTRIBUING.rstTo see the options available use:$ dojo --helpContributingCheck theCONTRIBUING.rstfile to discover how you can help the development of dojo-toolkit.DependenciesPython 3(Optional)Libnotify
Package: dojson
AboutDoJSON is a simple Pythonic JSON to JSON converter.InstallationDoJSON is on PyPI so all you need is:$pipinstalldojsonDocumentationDocumentation is readable athttps://dojson.readthedocs.io/or
it can be built using Sphinx:$pipinstalldojson[docs]$pythonsetup.pybuild_sphinxTestingRunning the test suite is as simple as:$pythonsetup.pytestExampleA simple example on how to convert MARCXML to JSON:fromdojson.contrib.marc21.utilsimportcreate_record,split_streamfromdojson.contrib.marc21importmarc21[marc21.do(create_record(data))fordatainsplit_stream(open('/tmp/data.xml','r'))]
Package: dokang-pdf
This is a PDF harvester for Dokang (https://github.com/Polyconseil/dokang).Build status:Usagefrom dokang_pdf import PdfHarvesterLicenseDokang is written by Polyconseil and is licensed under the 3-clause
BSD license, a copy of which is included in the source.Change logdokang_pdf 0.4.0 (2023-02-09)Bump pdfminer3kSupport of Python 3.7 and 3.8Drop support of Python <=3.6dokang_pdf 0.3.0 (2016-02-01)Support of Python 3.dokang_pdf 0.2.0 (2014-06-24)Initial version.
Package: doker
DokerDokerstands fordocument maker.InstallationRun in console:python3 -m pip install doker --userUsageCreateminimal.yaml:root: .Createmain.rst:Minimal Document================**Hello**,*world*!And run in console:doker --pdf minimalFindminimal.pdfin the current directory.Deeper divingSeeexamplesfor most popular use cases.DocumentationRead theuser’s manualfor usage details.LicenseSource code is licensed underMIT license.
Package: dokg
My test package 😁😁😁STEP to upload your package1. Install the required packages:Setuptools: Setuptools is a package development process library designed for creating and distributing Python packages.Wheel: The Wheel package provides a bdist_wheel command for setuptools. It creates .whl file which is directly installable through the pip install command. We'll then upload the same file to pypi.org.Twine: The Twine package provides a secure, authenticated, and verified connection between your system and PyPi over HTTPS.Tqdm: This is a smart progress meter used internally by Twine.sudo python -m pip install --upgrade pip setuptools wheel
sudo python -m pip install tqdm
sudo python -m pip install --user --upgrade twine2. Setup projectCreate folder structure follow this repoPackage file sampledokg#!/usr/bin/env python
echo "hey there, this is my first pip package"Make script excecutable:chmod +x dokrCreate a setup file setup.py in your package. This file will contain all your package metadata information.import setuptools

with open("README.md", "r") as fh:
    long_description = fh.read()


setuptools.setup(
    name = 'dokg',
    version = '0.3',
    scripts = ['dokg'],
    author = 'Hai V.Dam',
    author_email = 'haidv@tomochain.com',
    description  = 'My test package',
    long_description = long_description,
    long_description_content_type = "text/markdown",
    url = 'https://github.com/naviat/dokg',
    packages = setuptools.find_packages(),
    classifiers = [
         "Programming Language :: Python :: 3",
         "Programming Language :: Python :: 2",
         "License :: OSI Approved :: MIT License",
         "Operating System :: OS Independent",
    ],
)3. Compiling Your PackageGo into your package folder and execute this command:python setup.py bdist_wheel. This will create a  structure like this:.
├── LICENSE
├── README.md
├── build
│   ├── bdist.macosx-10.7-x86_64
│   └── scripts-3.7
│       └── dokg
├── dist
│   └── dokg-0.3-py3-none-any.whl
├── dokg
├── dokg.egg-info
│   ├── PKG-INFO
│   ├── SOURCES.txt
│   ├── dependency_links.txt
│   └── top_level.txt
└── setup.pybuild: build package information.dist: Contains your .whl file. A WHL file is a package saved in the Wheel format, which is the standard built-package format used for Python distributions. You can directly install a .whl file using pip install some_package.whl on your systemproject.egg.info: An egg package contains compiled bytecode, package information, dependency links, and captures the info used by the setup.py test command when running tests.4. Upload on pipCreate pypirc: The Pypirc file stores the PyPi repository information. Create a file in the home directoryfor Windows :C:\Users\UserName\.pypircfor *nix :~/.pypircAnd add the following content to it. Replace javatechy with your username. 😝😝😝[distutils] 
index-servers=pypi
[pypi] 
repository = https://upload.pypi.org/legacy/ 
username = naviatTo upload your dist/*.whl file on PyPi, use Twine:python -m twine upload dist/*NOTE: When upgrade your package => delete all file indistfolder before run the command above
Package: doki-net
Doki-netExamplesPlenty of examples can be found in the aptly named examples folder.Structure of nodes and edgesEach node and edge is a JSON object. The structure of each type of node and edge is
shown below:ANN:node:{"bias":0.0,// Bias of the node"type":Type.RELU// Type refers to the activation function of a node and is set using an enum}edge:"from":0// The index of the node that this edge takes a value from"to":1// The index of the node that this edge sends the value to"weight":0.1// The weight of the edgeRNN (Fully-Recurrent):node:{"alpha":0.0,// Alpha is the weight of recurrent signal"bias":0.0,// Bias of the node"type":Type.RELU}CNN (In-Development):