Saravanan666/pypi-org huggingface dataset:
Package: dowpy
FeaturesAbility to download any file typeMulti-threading to run parallel downloads, if supportedResumable downloads on connection lossCross-platform supportTimed bench marks of each individual chunk/overall fileFile verification, via hash checkInstallationTo install DowPy, Use pip:$ pip install dowpyUsageurl="https://gph.to/2BTy5xU"# To create a single thread downloaddow1=SingleDow(url)# To create a multi threaded download with 3 parallel downloadsdow2=MultiDow(url,3)# To start the downloaddow1.start()DocumentationThe following properties can be set BEFORE the download has started:proptypeDesc.urlstringThe direct url to the file to request.chunksintThe # of parallel threads to download the file with (MultiDow only).writeLocationstringFile location to download the file.fileNamestringName of the downloaded file.hashstringKnown hash to test the file withThe following properties return information about the download:proptypeDesc.statusstringReturns the current status of the download (initialized, downloading, complete).sizeInBytesstringReturns the size of the file in bytes.startTimestringStart time of the download.endTimestringEnd time of the download.elapsedTimeStringTotal time of download
Package: dowser-py3
Overview========This is a Python3 fork of dowser library.Original repo: https://github.com/Infinidat/dowserUsage-----To quickly start-up a CherryPy-based server:from dowser.utils import launch_memory_usage_serverlaunch_memory_usage_server()If you want to integrate dowser in your existing CherryPy app:from dowser import Rootclass ExistingCherryPyApp(object):dowser = Root()dowser.exposed = Truetrace = dowser.tracechart = dowser.chartThis will bind `/dowser`, `/trace` and `/chart` to the dowser CherryPy app
Package: dowsing
dowsingShort version:python -m dowsing.pep517 /path/to/repo | jq .orfrom dowsing.pep517 import get_metadata
dist = get_metadata(Path("/path/to/repo"))Basic reasoningI don't want to execute arbitrarysetup.pyin order to find out their basic
metadata.  I don't want to use the pep517 module in a sandbox, because commonly
packages forget to list their build-time dependencies.This project is one step better than grepping source files, but also understandsbuild-systeminpyproject.toml(from PEP 517/518).  It does pretty well run
on a sampling of pypi projects, but does fail on some notable ones (including
setuptools).When it fails, a key will be"??"and due to some quirks in list context, this
can be["?", "?"].A rantThe reality of python packaging, even with recent PEPs, is that most nontrivial
python packages do moderately interesting stuff in theirsetup.py:Imports (either from local code, orsetup_requires)Fetching things from the InternetRunning commandsMaking sure native libs are installed, or there's a working C compilerChoosing deps based on platformFrom the perspective of basically running a distro, they produce messages
intended for humans, rather than actually using the mechanisms that we have in
PEP 508 (environment markers) and 518 (pyproject.toml requires).  There is also
no well-specified way to request native libs, and many projects choose to fail
to runsetup.pywhen libs are missing.GoalsThis project is a bridge to find several things out, about primarily setup.py
but also understanding some popular PEP 517/518 builders as a one-stop-shop, about:doesn't actually execute, so fetches or execs can't cause it to fail [done]cases where we could find out the version string, but it fails to import [done]lets you simulate thepep517module's output on different platforms [done]a lower-level api suitable for making edits to the place where the setup args
are defined [done]to list potential imports, and guess at missing build-time deps (something
likenumpy.distutilsis pretty clear) [todo]Doing this "right"A bunch of this is papering over problems with the current reality.  If you have
an existing sandbox and are ok with ~30% of projects just failing to build, you
can rely on thepep517module's API to actually execute the code on the
current version of python.If you're willing to run the code and have it take longer, take a look at the
pep517 apiget_requires_for_*or have it generate the metadata (assuming
what you want is in there).  An example is indowsing/_demo_pep517.pyThis project'sdowsing.pep517api is designed to do something similar, but not
fail on missing build-time requirements.Further ReadingPEP 241, Metadata 1.0PEP 314, Metadata 1.1PEP 345, Metadata 1.2PEP 566, Metadata 2.1https://packaging.python.org/specifications/core-metadata/https://setuptools.readthedocs.io/en/latest/setuptools.html#metadataLicensedowsing is copyrightTim Hatch, and licensed under
the MIT license.  I am providing code in this repository to you under an open
source license.  This is my personal repository; the license you receive to
my code is from me and not from my employer. See theLICENSEfile for details.
Package: doxa-cli
DOXA CLIThe DOXA CLI is the primary tool for uploading and submitting agents toDOXA: a powerful platform for hosting engaging artificial intelligence competitions.🔗 Compete onDOXA➡️ Join theDOXA Community on DiscordInstallationThe DOXA CLI may be installed usingpipin the following way:pipinstalldoxa-cliUsing the DOXA CLIAssuming you have your PythonScriptsfolder on yourPATH, you can use the DOXA CLI via thedoxacommand in your shell. Otherwise, you will have to usepython -m doxa_cli(orpython3 -m doxa_clion some systems) to access DOXA CLI commands.Logging into the CLI with your DOXA accountBefore you can upload agents to DOXA using the CLI, you must first log in with your DOXA account by running the following command:doxaloginIf supported, this will open an authorisation prompt in your default browser. If you are not already logged in ondoxaai.com, you will first be invited to do so. Thereafter, you wil be asked to authorise the DOXA CLI to have access to your DOXA account. Once you signify your approval, the DOXA CLI will automatically log you in within a few seconds.By default, the DOXA CLI will store its configuration in a location that follows the norm for your operating system (e.g. within%APPDATA%\doxa\doxaon Windows,~/Library/Application Support/doxaon macOS and~/.config/doxaon Linux). You can find this location by runningdoxa config. If for whatever reason you would like to store the DOXA CLI configuration elsewhere (e.g. due to a permissions issue), you may use a different directory by setting theDOXA_CONFIG_DIRECTORYenvironment variable.Logging outYou may log out by running the following command:doxalogoutRetrieving user informationYou can retrieve information on the user account with which you are currently logged in by performing the following command:doxauserUploading agents to DOXAYou may upload and submit agents to DOXA using the following command:doxaupload[AGENTDIRECTORY]The agent directory must contain adoxa.yamlfile informing DOXA how to process your submission.The following is an example of the contents of one suchdoxa.yamlfile:competition:utttenvironment:cpulanguage:pythonentrypoint:evaluate.py
Package: doxcli
About DocCliDoxCli is a cli tool which helps to do day to day jobs.FeaturesCheck if domain is available using GoDaddy API.More features are coming soon...InstallationAs this project is in Alpha mode, it is recommended to install it invirtual env.python3-mvenvname-your-venvsourcepath-to-your-venv/bin/activate

pipinstalldoxcliCreate the config file in~/.config/doxcli/config.yamlAnd add your GoDaddy API credentials.godaddy:api_key:api-keyapi_secret:api-secretHow to useAfter the confi file has setup, you can run the following command to check if any domain is available.dox godaddy --name bijaydas.comOutput screenshotContributingThank you for considering contributing to the DocCli!LicenseThe DoxCli is open-sourced software licensed under theMIT license.
Package: doxieapi
doxieapiA Python library for thedeveloper APIof theDoxie Go Wi-Fidocument scanner.Installationdoxieapi is available on PyPI:https://pypi.python.org/pypi/doxieapi. Install with pip:$pipinstalldoxieapiUsageDoxie scanners on the network can discovered automatically using SSDP:>>>fromdoxieapiimportDoxieScanner>>>scanners=DoxieScanner.discover()>>>print(scanners)[<DoxieScanner:DoxiemodelDX250(Doxie_01AFD2)athttp://10.0.1.3:8080/>]Recent and all scans can be listed:>>>scanner=scanners[0]>>>scanner.recent'/DOXIE/JPEG/IMG_0074.JPG'>>>scanner.scans[:2][{'modified':'2010-05-01 00:17:28','name':'/DOXIE/JPEG/IMG_0001.JPG','size':1365552},{'modified':'2010-05-01 00:17:44','name':'/DOXIE/JPEG/IMG_0002.JPG','size':1362595}]Scans can be downloaded individually or all at once:>>>scanner.download_scan("/DOXIE/JPEG/IMG_0001.JPG","/tmp")'/tmp/IMG_0001.JPG'>>>scanner.download_scans("/tmp")['/tmp/IMG_0001.JPG','/tmp/IMG_0002.JPG']Scans can be deleted too:>>>scanner.delete_scan("/DOXIE/JPEG/IMG_0001.JPG")True>>>scanner.delete_scans([scan['name']forscaninscanner.scans])TrueOther attributes from the API can be queried:>>>scanner.firmware'0.26'>>>scanner.network'supersecretwifi'>>>scanner.name'Doxie_01AFD2'>>>scanner.firmware_wifi'1.29'You can also run the module directly to download all available scans from all Doxies on
the network to the current directory:$python-mdoxieapi
DiscoveredDoxiemodelDX250(Doxie_01AFD2)athttp://10.0.1.3:8080/
Saved/Users/dave/Code/doxieapi/doxieapi/IMG_0001.JPG
Saved/Users/dave/Code/doxieapi/doxieapi/IMG_0002.JPGConfigurationConnecting to password-protected Doxies is made possible by putting the password for
each scanner in~/.doxieapi.ini. Create sections named with the scanner's MAC address,
for example:[00:11:22:33:44:55]password=supersecretpasswordCreditsIncludesssdp.pybyDan Krause.
Package: doxmlparser
This is a python package to make it easier to parse the XML output produced by doxygen.The API is generated from the index.xsd and compound.xsd XML schema files using
Dave Kuhlman’s generateDShttps://www.davekuhlman.org/generateDS.htmlThe current code is generated with generateDS version 2.37.15.See the examples directory to get an idea how to use the python module
Package: doxphinx
README - General description of the doxphinx projectCopyright (C) 2018-2023 Angel Linares ZapaterThis program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, version 2, as
published by the Free Software Foundation. See the COPYING file.This program is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.Getting starteddoxphinx is a theme for the Sphinx documentation system. The purpose of doxphinx
is to provide a single mechanism to generate the documentation of a project,
both in HTML and PDF formats, from a common source.This common source of documentation consists of a set of text files written in
reStructuredText markup language along with a set of conventions for writing and
organizing the different files. The Sphinx tool can then be used to
automatically generate a HTML website or a PDF book, both from the same single
documentation source.How to useIn order to use doxphinx to document any project, just install it using:$ pip install doxphinxThen create a directory for the documentation files and using the Sphinx tool:$ sphinx-quickstartInitialize the directory as a Sphinx project and configure the conf.py file that
has been created, and you are ready to build the documentation using doxphinx.See “The doxphinx Handbook” <https://docs.phyglos.org/doxphinx> to learn how to use
doxphinx in your documentation project.At this point you can focus on the actual documentation work for your project.
Whenever the documentation is ready to be published or updated, use Sphinx to format
again the HTML website or the PDF book from the documentation source files.StatusThe doxphinx project is in STABLE status.More informationThe COPYING file contains the GNU License for this software.The RELEASE file describes the main changes in this release.Seehttps://docs.phyglos.org/doxphinxfor more information.
Package: dox-search
DOXPaper:DOX - Document Store Exploration through KeywordsDOX (Document stOre eXploration) is a framework for keyword exploration over Document Stores.Source codeAll code can be found at thesrcfolder.Folders outside are used for bootstrap and runtime configurations.DemoAn online demo of the framework is ready to run inGoogle Colaboratory. This demo uses an instance of a MongoDB database hosted atMongoDB Atlas.DatasetsAll datasets used throughout our experiments can be foundhere.
Package: doxtrings
doXtringsThe doXtrings package is a powerful tool for ensuring the accuracy of your docstrings through automated testing. Docstrings are an essential component of maintaining a well-documented codebase, as they can be seamlessly converted into actual documentation and integrate smoothly with IDEs. However, docstrings are not code, so it can be challenging to detect errors, making them prone to going unnoticed. This is where doXtrings comes in handy. It analyzes all your docstrings, checking for any discrepancies with the method signature, and helps you maintain your docstrings as if they were code. By using doXtrings, you can rest assured that your docstrings are accurate and reliable.Documentation pageCheck out thecomplete documentation
Package: doxx
Documentation:http://doxx.orgWhat is doxx?doxx is a generic text file project build and distribution system. It supports simple YAML formatted build specs and build time text file customization using local or remote text templates (that can be hosted anywhere).For those who prefer the ready-made approach, thedoxx Package Repositorycontains a growing list of resusable, common project types that can be built with a simple set of doxx commands. If you’re looking for a quick way to build Bootstrap, Zurb Foundation, jQuery, Font Awesome, angular.js, ember.js, Ionic mobile apps, software licenses, settings & testing file stubs, and much more, the packages are already built for you.  Use ‘doxx search [query]’ to see if your favorite package is available.Features include:Generic text project support.  Use it for anything from a Bootstrap framework driven website to a statistical analysis script stub.  If it contains text, it should work.Simple, legible YAML syntax build specs that do not require scripting/programming know-howLocal template file supportRemote template file support (from any hosting site that supports GET requests)Github pull shortcodes allow you to include entire Github repositories or cherry pick specific repository files or directories for your projectFull UTF-8 character set support in templates, named text replacement tags in templates, and replacement strings entered by usersSupport for the distribution of binary files with your projectsMulti-processor template file build supportAdditional information is available inthe documentation.Quickstart GuidesUser Quickstart GuideTheUser Quickstart Guidedemonstrates how to build projects from third party developers or from the doxx Package Repository.Developer Quickstart GuideTheDeveloper Quickstart Guidedemonstrates how to develop and distribute reusable, templated projects with doxx.UsageTheUsage Documentationlists the complete set of available commands and options.ChangesChanges are found onthe Changelog.IssuesPleasesubmit a new issue reporton the Github repository.LicenseThe doxx command line application is licensed under theMIT License.Project packages distributed through the doxx Package Repository are licensed under a variety of open source licenses.  Please review the respective project documentation for additional information.SourceSource code is available on theGithub repository.
Package: doxy
Doxydoxyis a Doxygen adregator between repositories![Badge](https://badge.fury.io/py/doxy.pnggit repositoryhttp://github.com/HeeroYui/doxy/Documentationhttp://github.io/HeeroYui/doxy/InstallationRequirements:Python >= 2.7andpipJust run:pip install doxyInstall pip on debian/ubuntu:sudo apt-get install pipInstall pip on ARCH-linux:sudo pacman -S pipInstall pip on MacOs:sudo easy_install pipLicense (APACHE v2.0)Copyright lutin Edouard DUPINLicensed 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.
Package: doxycast
DoxyCast is a documentation generator that helps you to generate beautiful
documentations from the comments you have written in your source code.DoxyCast reads the XML output from Doxygen and generates reStructuredText
sources, which are parsed by Sphinx to generate the documentations.InstallationTo install DoxyCast, execute the following command:pip install doxycastGetting StartedBefore getting started, make sure you have Doxygen and Sphinx installed. Then
add the following to yourconf.py:doxycast_config = {
    "projects": {
        "xml_dir": "path/to/xml",
        "output_dir": "path/to/output",
        "execute_doxygen": True,
        "doxycast_config":
            "INPUT = path/to/sources\n"
            # Other Doxygen options

        # "writer": your_custom_writer # Optional, default ``doxycast.writers.default``
    }
}Note: if you are using the default writer (not using any custom writer), you
also need to install Breathe.
Package: doxygen-interface
This library provide a way to updateDoxygenconfiguration and launch
a build of documentationExamplefromdoxygenimportConfigParserfromdoxygenimportGeneratormy_doxyfile_path="path/to/my/Doxyfile"# 1. Load the configuration from your Doxyfileconfig_parser=ConfigParser()configuration=config_parser.load_configuration(my_doxyfile_path)# 2. Update the configurationconfiguration['PROJECT_NUMBER']='1.2.3.4'configuration['BRIEF_MEMBER_DESC']='NO'configuration['FILE_PATTERNS'].append('*.abc')# 3. Store the configureconfig_parser.store_configuration(configuration,my_doxyfile_path)# 4. Build the doc and generate a zipdoxy_builder=Generator(my_doxyfile_path)output_zip_archive=doxy_builder.build(clean=True,generate_zip=True)
Package: doxygen-junit
Tool that convertsDoxygenXML output to JUnit XML
format. Use on your CI servers to get more helpful feedback.InstallationYou can install, upgrade, and uninstalldoxygen-junitwith these commands:$pipinstalldoxygen-junit$pipinstall--upgradedoxygen-junit$pipuninstalldoxygen-junitUsageRedirectdoxygenstderrto a file:$doxygen2>doxygen-stderr.txtConvert it to JUnit XML format:$doxygen_junit--inputdoxygen-stderr.txt--outputdoxygen-junit.xmlContributorsCredit to@theandrewdavisfor the initial development of
the conversion tool.Releases2.3.0 2021-11-06Add Python 3.10 support, drop 3.6.2.2.1 2020-12-30Add Python 3.9 support.Switch to GitHub Actions for CI.2.2.0 2020-04-21Drop support for Python 3.5.2.1.0 2020-04-18Add--versionCLI argument.2.0.0 2020-03-29Drop Python 2.7.1.4.0 2019-12-14Drop Python 3.4 and support Python 3.8.Include license file.1.3.0 - 2018-07-09Support Python 3.7.1.2.0 - 2018-04-03Properly support JUnit XSD.Drop Python 3.3 support.1.1.0 - 2016-12-31Support Python 3.6.1.0.1 - 2016-10-06Handle warning labels without a space before the preceding colon.1.0.0 - 2016-09-13First release.
Package: doxygenwhere
Python doxygenwhereThis module searches for doxygen installations on system.Usagefindandfind_firstare the most generic functions.findreturns a list of installed doxygen matching the
given options, andfind_firstreturns only the first result.If you are only interested in the latest version of doxygen, useget_latest. To get just the installation path, useget_latest_path. To get
just the version number, useget_latest_version.If you want to use your own version of doxygen.exe instead of the one installed
on your system, useset_doxygen_pathto provide its location.If you want to use a mirror instead of offical doxygen webserver to download
portable doxygen, for example when on an intranet that does not have access
to Internet, useset_download_mirrorand provide the URL of the mirror.
Package: doxyphp2sphinx
# doxyphp2sphinxAPI Documentation generator for PHP projects which use Sphinx.It acts as a compatibility layer between Doxygen (which is good at reading PHP),and Sphinx (which is used by some online services to host HTML docs).- http://www.sphinx-doc.org/en/master/- http://www.doxygen.org/This tool is compatible with Python 2 and 3.## Installation### From source```bashgit clone https://github.com/mike42/python setup.py bdist_wheel --universalpip install dist/doxyphp2sphinx-*.whl```### From pip```bashpip install doxyphp2sphinx```### VerificationTest that you have the command.```doxyphp2sphinx --help```## Command-line useThis package provides the `doxyphp2sphinx` command, which generates `.rst` files as output, given a directoryof `doxygen` XML files.```bashusage: doxyphp2sphinx [-h] [--xml-dir XML_DIR] [--out-dir OUT_DIR] [--verbose][--quiet]root_namespaceGenerate Sphinx-ready reStructuredText documentation or your PHP project,using Doxygen XML as an input.positional arguments:root_namespaceoptional arguments:-h, --help         show this help message and exit--xml-dir XML_DIR  directory to read from--out-dir OUT_DIR  directory to write to--verbose, -v      more output--quiet, -q        less output```## ExampleThe `gfx-php` project uses this tool to publish documentation to [readthedocs.org](https://readthedocs.org/), sowe'll use that as an example:- Code: https://github.com/mike42/gfx-php- Docs: https://gfx-php.readthedocs.io```git clone https://github.com/mike42/gfx-phpcd docsdoxygendoxyphp2sphinx Mike42::GfxPhpmake html```## Licensedoxyphp2sphinx is released under a BSD 2-Clause License. See LICENSE for the full text.
Package: doxyplot
DoxyplotDoxyplot is a plotting wrapper around matplotlib for easy plotting.Installation(Not ready yet)
Use the package managerpipto install Doxyplot.pip install doxyplotUsageimport doxyplot.doxyplot_core as dp

plot = dp.Doxyplot()

x=[1,2,3,4]
y=[4,5,4.5,2]
y2=[5,7,2,1]
y3=[10,9,5,4]
y4=[5,4,2,2]

plot.append_data(x, y, 'r', 'Line1', linewidth=2.0)
plot.append_data(x, y2, 'k', 'Line2', linewidth=2.0)
plot.append_data(x,y3, c='g', label='Line3')
plot.append_data(x,y4, c='b', label='Line4')
plot.construct_plot("Doxyplot", "Time", "Velocity",save="export.png")ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.LicenseMIT