Saravanan666/pypi-org huggingface dataset:
Package: depthai-mock
Depthai-MockThis tool allows you to record the packets produced by DepthAI device into your disk
and then play them back again as they would be produced normally - but without actually running the DepthAIInstallationpython3 -m pip install depthai-mockUsageusage: depthai_mock [-h] [-nd] [-t TIME] [-ai] [-b BLOB] [-bc BLOB_CONFIG] [-p PATH] [-s STREAMS [STREAMS ...]]

optional arguments:
  -h, --help            show this help message and exit
  -nd, --no-display     Do not try display the incoming frames
  -t TIME, --time TIME  Limits the max time of the recording. Mandatory whenused with -nd (--no-display) option
  -ai, --enable-ai      Store also the nnet results
  -b BLOB, --blob BLOB  Path to nnet model .blob file
  -bc BLOB_CONFIG, --blob-config BLOB_CONFIG
                        Path to nnet model config .json file
  -p PATH, --path PATH  Path where to store the captured data
  -s STREAMS [STREAMS ...], --streams STREAMS [STREAMS ...]
                        Define which streams to enable Format: stream_name or stream_name,max_fps Example: -s metaout previewout Example: -s metaout previewout,10 depth_sipp,10Having DepthAI connected, rundepthai_mock -s previewoutthen, whendatafolder is there, you can unplug the DepthAI and runcd depthai_mock
python3 test.py -p ../data
Package: depthai-sdk
DepthAI SDKDepthAI SDK is a Python package, containing convenience classes and functions that help in most common tasks while using DepthAI API.To know more about the DepthAI itself, visitour documentationorour webpageInstallationTo install this package, run the following command in your terminal window$ python3 -m pip install depthai-sdk:warning:If you're using Raspberry Pi, providing a Pi Wheels extra package url can significantly speed up the installation process by providing prebuilt binaries for OpenCV$ pip install --extra-index-url https://www.piwheels.org/simple/ depthai-sdkUsagePlease visitDepthAI SDK documentation page.APIPlease visitDepthAI SDK APIfor full API reference
Package: depth-armory
_                                                          
      dM.                                                         
     ,MMb                                                         
     d'YM.   ___  __ ___  __    __     _____  ___  __ ____    ___ 
    ,P `Mb   `MM 6MM `MM 6MMb  6MMb   6MMMMMb `MM 6MM `MM(    )M' 
    d'  YM.   MM69 "  MM69 `MM69 `Mb 6M'   `Mb MM69 "  `Mb    d'  
___,P____Mb___MM______MM____MM____MM_MM_____MM_MM_______YM.__,P___
   d'    YM.  MM      MM    MM    MM MM     MM MM        MM  M    \ 
__,MMMMMMMMb__MM______MM____MM____MM_MM_____MM_MM________`Mbd'_____\
  d'      YM. MM      MM    MM    MM YM.   ,M9 MM         YMP      
_dM_     _dMM_MM_    _MM_  _MM_  _MM_ YMMMMM9 _MM_         M      
                                                          d'      
                                                      (8),P       
                                                       YMMDescriptionArmory is a tool meant to take in a lot of external and discovery data from a lot of tools, add it to a database and correlate all of related information. It isn't meant to replace any specific tool. It is meant to take the output from various tools, and use it to feed other tools.Additionally, it is meant to be easily extendable. Don't see a module for your favorite tool? Write one up! Want to export data in just the right format for your reporting? Create a new report!InstallationPrerequisitesFirst, set up some kind of virtual environment. I like virtualenvwrapper:http://virtualenvwrapper.readthedocs.io/en/latest/install.htmlActually installingClone the repo:git clone https://github.com/depthsecurity/armoryInstall the module:python setup.py installYou will want to runarmoryat least once in order to create the default config directory:~/.armorywith the defaultsettings.iniand settings for each of the modules.Next editsettings.iniand modify thebase_pathoption. This should point to the root path you are usingfor your current project. You should change this with every project, so you will always be using a clean database. All files generated by modules will be created in here, as well as the sqlite3 database.By default it will be within the current directory-.UsageUsage is split intomodulesandreports.ModulesModules run tools, ingest output, and write it to the database. To see a list of available modules, type:armory -lmTo see a list of module options, type:armory -m <module> -MReportsReports are similar to modules, except they are meant to pull data from the database, and display it in a usable format. To view all of the available reports:armory -lrTo view available report options:armory -r <report> -RInteractive ShellThere is also an interactive shell which usesIPythonas the base and will allow you to run commands or change database values. It can be launched with:armory-shell.
By default, the following will be available:Domain, BaseDomains, IPAddresses, CIDRs, Users, Creds, Vulns, Ports, Urls, ScopeCIDRs.
Package: depthcharge
DepthchargeWhat is Depthcharge?Depthcharge is a toolkit designed to support security research and
"jailbreaking" of embedded platforms using theU-Bootbootloader.
It consists of:An extensible Python 3depthcharge modulePython scriptsbuilt atop of thedepthchargemodule APIDepthcharge "Companion" firmware, which is used to perform attacks requiring a malicious peripheral device.Some example"helper" payload binariesand build scripts to get you started with U-Boot "standalone" program-esque payloads.Project DocumentionMore information can be found in theonline documentationfor the Depthcharge project.IntroductionWhat is Depthcharge?Will this be useful for my situation?What are some of its key features?How do I get started?Python ScriptsPython APICompanion FirmwareTroubleshootingIf you'd like to build this documentation for offline viewing, You can find theSphinx-based documentation "source" in thedocdirectory.BranchesThe Depthcharge source repository contains two primary branches:main- The latest release. This corresponds to what is available onPyPinext- "Bleeding edge" changes scheduled for inclusion in the next release.At each release, the contents ofnextare merged tomainand tagged accordingly.Under some circumstances, selected fixes may be merged to main in order publish
an interim patch release.VersioningDepthcharge uses aSemantic versioningscheme for both the Python API and the Companion Firmware.
The version number for published releases will follow that of the Python API version.
TheCHANGELOGshall document the current version state of both, along
with any compatibility information.Currently, this project uses"unstable"version numbers; API-breaking changes
may occur within this minor version series, if deemed to be sufficiently
beneficial for the future of the project. Refer to the
CHANGELOG for guidance on handling any API changes.Each published release will have a "codename". This serves no real purpose,
other than to amuse the author and add a little fun to preparing releases.
(Maybe they'll even be useful to remember!) The codenames are song titles from
punk bands, increasing alphabetically with each release.LicenseAll Depthcharge components are licensed under theBSD 3-Clause License,
found in theLicense.txtfile. Project files use the correspondingSPDX Identifierto denote this.LogoThe Depthcharge logo was created by the incredibly talentedJuupiter.
Package: depthmap-toolkit
Depthmap toolkitDepthmap toolkit is an utility to convert and visualise the data captured by cgm-scanner.OverviewCGM-Scanner currently captures the data as depthmaps. Depthmap is our own format developed for high compressed data.ToolsVisualisation of depthmapsThe tool accepts only the data captured by cgm-scanner. The data could be captured by any ARCore/AREngine device supporting ToF sensor. Tool could be opened by following command:python toolkit.py depthmap_dir calibration_fileThedepthmap_dirfolder has to contain subfolder depth containing one or more depthmap files.By arrows "<<" and ">>" you can switch to next or previous depthmap in the folder.Export pointcloud will export the data into PLY file in export folder.Export textured mesh will triangulate and texturize the data and export in into OBJ file in export folder.Export poisson mesh will triangulate and extrapolate the data and export in into OBJ file in export folder.All exported data data will be reoriented using depthmap pose (if available)calibration_fileis the txt file with calibration for the device.Visualisation typesThe tool generates 5 different visualisations (from left-to-right order):Depth image - this is a most raw visualisation of depthmapWorld-oriented normals - green value indicates a horizontal surface, blue and red a vertical surface (supported from scan type v1.0)Metrical segmentation visualisation - repeating pattern mapped on surfaces based on world-oriented normals, the pattern repeats every 10 centimeters (this might help ML models to calibrate measures captured by different devices, supported from scan type v1.0), blue is the detected floor, yellow is the detected child/objectConfidence map - amount of IR light reflected into ToF receiver, this information might vary a lot (every sensor uses a different amount of IR light) and it is not recommended to use it for ML trainingRGB photo - captured photo (if available)
Package: depth-stat
depth_stat1 Introductiondepth_statis a tool to extract the sequence depth from depthfile and do some statstics.seehttps://github.com/linzhi2013/depth_stat.2 Installationpip install depth_statThere will be a commanddepth_statcreated under the same directory as yourpipcommand.3 Usage3.1 command line$ depth_stat
usage: depth_stat [-h] -i <file> [-q <str>] [-a <int>] [-b <int>]
                     [-f <file>]

To extract the sequence depth from depthfile.

The depthfile content format:
seqid1 depth1 depth2 depth3 ...
seqid2 depth1 depth2 depth3 ...

This script is part of the MitoZ project, by Guanliang MENG.
See https://github.com/linzhi2013/depth_stat.


optional arguments:
  -h, --help  show this help message and exit
  -i <file>   input depthfile
  -q <str>    sequence id
  -a <int>    the start position, Python-style (0-leftmost)
  -b <int>    the end position, Python-style for slicing
  -f <file>   a file of 'seqid start end' list on each line3.2 in a Python3 scriptIn [1]: from depth_stat import SeqDepth

In [2]: sdj = SeqDepth('DRR095708_mitoscaf.fa.fsa.depth')

In [3]: sdj.extract_range_depth(seqid='scaffold44450', start=0, end=20)
Out[3]: [1, 1, 1, 1, 4, 4, 4, 4, 5, 5, 5, 6, 7, 7, 8, 8, 8, 8, 8, 8]

In [4]: sdj.range_depth_stat(seqid='scaffold44450', start=0, end=20)
Out[4]: ('scaffold44450', 0, 20, 1, 5.15, 8)

In [5]: sdj.range_depth_freq(seqid='scaffold44450', start=0, end=20)
Out[5]: [(1, 4), (4, 4), (5, 3), (6, 1), (7, 2), (8, 6)]AuthorGuanliang MENGCitationThis script is part of the packageMitoZ, when you use the script in your work, please cite:MitoZ: A toolkit for mitochondrial genome assembly, annotation and visualization with NGS data. Guangliang Meng, Yiyuan Li, Chentao Yang, Shanlin Liu (in manuscript)
Package: deptree
IntroductionDisplay installed Python projects as a tree of dependencies.FeaturesOutput compatible withrequirements.txtShow dependencies or dependentsDetect circular dependenciesDetect missing dependenciesRepositoriesDistributions:https://pypi.org/project/deptree/Source code:https://gitlab.com/sinoroc/deptreehttps://github.com/sinoroc/deptreeUsage$ deptree --help
usage: deptree [-h] [--version] [-r] [-f] [project [project ...]]

Display installed Python projects as a tree of dependencies

positional arguments:
  project        name of project whose dependencies (or dependents) to show

optional arguments:
  -h, --help     show this help message and exit
  --version      show program's version number and exit
  -r, --reverse  show dependent projects instead of dependencies
  -f, --flat     show flat list instead of treeExamples$ deptree cryptography
cryptography==2.9  # cryptography
  cffi==1.14.0  # cffi!=1.11.3,>=1.8
    pycparser==2.20  # pycparser
  six==1.14.0  # six>=1.4.1$ deptree --reverse cryptography
cryptography==2.9  # -
  SecretStorage==3.1.2  # cryptography
    keyring==21.2.0  # SecretStorage>=3; sys_platform == "linux"
      twine==3.1.1  # keyring>=15.1$ deptree --flat cryptography
cffi==1.14.0
# pycparser

cryptography==2.9
# six>=1.4.1
# cffi!=1.11.3,>=1.8

pycparser==2.20

six==1.14.0$ deptree --flat --reverse cryptography
# SecretStorage: cryptography
cryptography==2.9

# twine: keyring>=15.1
keyring==21.2.0

# keyring: SecretStorage>=3; sys_platform == "linux"
SecretStorage==3.1.2

twine==3.1.1$ deptree CircularDependencyA
CircularDependencyA==0.0.0  # CircularDependencyA
  CircularDependencyB==0.0.0  # CircularDependencyB
    CircularDependencyA  # !!! CIRCULAR CircularDependencyAInstallationFor better comfort, use as a single-file isolatedzipapp:https://www.python.org/dev/peps/pep-0441/https://docs.python.org/3/library/zipapp.htmlFor example:$ python -m pip install --target ./deptree/ deptree
$ python -m zipapp --python '/usr/bin/env python' --main 'deptree.cli:main' ./deptree/
$ mv ./deptree.pyz ~/.local/bin/deptreeOr usezapp, ortoolmaker.This way the tool can be used in virtual environments without installing it in
the virtual environments. The tool can then see the projects installed in the
virtual environment but without seeing itself.DetailsSimilar projectsjohnnydeppipdeptreepipgrip
Package: deptry
deptryis a command line tool to check for issues with dependencies in a Python project, such as unused or missing dependencies. It supports the following types of projects:Projects that usePoetryand a correspondingpyproject.tomlfileProjects that usePDMand a correspondingpyproject.tomlfileProjects that use arequirements.txtfile according to thepipstandardsDependency issues are detected by scanning for imported modules within all Python files in a directory and its subdirectories, and comparing those to the dependencies listed in the project's requirements.Documentation-ContributingQuickstartInstallationTo adddeptryto your project, run one of the following commands:# Install with poetrypoetryadd--groupdevdeptry# Install with pippipinstalldeptryWarning: When using pip to installdeptry, make sure you install it within the virtual environment of your project. Installingdeptryglobally will not work, since it needs to have access to the metadata of the packages in the virtual environment.Prerequisitesdeptryshould be run within the root directory of the project to be scanned, and the project should be running in its own dedicated virtual environment.UsageTo scan your project for dependency issues, run:deptry.Example output could look as follows:Scanning 2 files...foo/bar.py:1:0: DEP004 'numpy' imported but declared as a dev dependencyfoo/bar.py:2:0: DEP001 'matplotlib' imported but missing from the dependency definitionspyproject.toml: DEP002 'pandas' defined as a dependency but not used in the codebaseFound 3 dependency issues.Configurationdeptrycan be configured by using additional command line arguments, or by adding a[tool.deptry]section inpyproject.toml. For more information, see theUsage and Configurationsection of the documentation..Repository initiated withfpgmaas/cookiecutter-poetry.
Package: deputat
DeputatEinfaches graphisches Benutzer Interface (GUI) zur Vergabe von Schulstunden.Aktuelle Version: 1.1.6Changes in 1.1.6added menubar entriesChanges in 1.1.5fixed requirement error forjsonChanges in 1.1.4added functionality to add/remove/edit subjectsadded default subjects-file./data/subjects.jsonChanges in 1.1.3added*.svgicons tosdistdata can now be exported as*.csvor*.xlsxfixedimporterrorschanged default data location to/home/user/deputat_data/data/fixedFileNotFoundErrorfor*.svgfixed Windows specific bugsfixed MacOS import errorsfixed find iconsInstallation und Starten von deputatInstalliere python3Installiere deputat über pythons packetmanagerPyPi. Gebe dazu
in der Konsolepython3 -m pip install deputateinStarte deputat überpython3 -m deputat
Package: deputil
DepUtilA lightweight dependency manager for Python.NOTE:This is a very early release. WhileDepUtilis perfectly fine to use, there are currently no configuration options for it.InstallationTo install the latest stable version ofDepUtil, use the following command:pipinstalldeputilYou can also install the latest development version using the following command:pipinstallgit+https://github.com/parafoxia/deputilYou may need to prefix these commands with a call to the Python interpreter depending on your OS and Python configuration.UsageTo runDepUtil, you can use either of the following commands:deputilupdate<globexpressions>
python-mdeputilupdate<globexpressions>You can also fetch the latest version of any package by using the following command:deputillatest<packages>ContributingContributions are very much welcome! To get started:Familiarise yourself with thecode of conductHave a look at thecontributing guideLicenseTheDepUtilmodule for Python is licensed under theBSD 3-Clause License.
Package: depwatch
depwatchdepwatch is a simple command-line tool for collecting the times of various events in your project's lifecycle, from code commits to deployments. Event times are retrieved from repository management tools (like GitHub) and CI tools (like CircleCI).InstallationInstall depwatch using pip:$pipinstalldepwatchUsageExecute the command with your access tokens.GITHUB_ACCESS_TOKEN=<your_token> CIRCLECI_ACCESS_TOKEN=<your_token> depwatch <user_name>/<repository_name>The results are output to the output.csv file.$catoutput.csvfirst_committed_at,merged_at,deployed_at2023-02-25T00:48:18+00:00,2023-02-25T00:57:06+00:00,2023-02-25T00:58:11+00:002023-02-25T00:46:52+00:00,2023-02-25T00:54:05+00:00,2023-02-25T00:55:12+00:002023-02-25T00:43:47+00:00,2023-02-25T00:45:33+00:00,2023-02-25T00:46:39+00:00...Note: Using the.envfileAlternatively, you can use the.envfile. Create the.envfile in the directory where you want to run the command as follows.cp .env.example .envSet the values according to the instructions in the.envfile.Note: Scope of the GitHub Personal Access TokenGitHub offerstwo types of personal access tokens, fine-grained personal access tokens and classic personal access tokens. For personal repositories, you can use both. For organizatio repositories, we recommend using classic tokens, as we know that fine-grained tokens do not allow you to get private repositories.If you use fine-grained personal access tokens, specify read-only permissions forContents,Metadata, andPull requests. If you use classic personal access tokens, specifyreposcope.ContributingComming soon!TODO: UseConventional CommitsLicenseThis code is released under the MIT License. SeeLICENSEfor details.
Package: depynd
depynd is a Python library for evaluating dependencies among random variables from data.
It supports learning statistical dependencies for one-to-one, one-to-many, and many-to-many relationships,
where each one corresponds tomutual information (MI) estimation,feature selection, andgraphical model structure learning,respectively. Specifically, depynd supports MI estimation for discrete-continuous mixtures, MI-based feature
selection, and structure learning of undirected graphical models (a.k.a. Markov random fields).
Package: depyro
depyro :money_with_wings:A wrapper for De Giro API, specifically for portfolio analysis. If you have ETFs in your portfolio, use in conjunction withpyholdingsto discover ETF compositions.Get startedSetusernameandpasswordas environment variables or in an.envfile in the root of your project.Instantiate the client and fetch portfolio information.from depyro.core import Depyro
client = Depyro(auth_type="2fa")
>>> Enter authenticator token...
client.get_portfolio_info()
>>>
[
  {
    id: int,
    positionType: str,
    size: int,
    price: float,
    value: float,
    plBase: float,
    breakEvenPrice: float,
    name: str,
    isin: str,
    symbol: str,
    productType: str
  },
]
Package: depythel
depythelis a series of open-source pure Python tools to help you manage dependencies in a variety of different projects.It aims to provide a visual solution to your dependency woes, helping you to make informed judgements about how to
manage your project distribution.InstallationPyPi$pipinstalldepythelLicenseThis project isfree software, and it will always stay free.We respect theessential freedomsof our users, and
so both the API and the CLT are openly licensed underGPL-3.0-or-later.In the same sense, the project’s extensive documentation is freely licensed under theGNU Free Documentation License
v1.3 or later.
Package: depythel-api
depythel APIis an open-source pure Python API tool to help manage dependencies in a variety of different projects.Use this tool if you like the standard depythel CLT, but don’t want the extra baggage that comes with a command line tool.Benefits🎉 No third party dependencies🐍 Compatible with allsupported Python versions(3.7+)👀PEP 561 compatible, with built in support for type checkingInstall$pipinstalldepythel-apiLicenseThe depythel API isfree software, and it will always stay free.We respect theessential freedomsof our users, and
so depythel is openly licensed underGPL-3.0-or-later.
Package: depytrace
depytraceThis project provides an algorithm for fast
extraction of high-conductance trees (calledcore traces)
rooted on designated graph nodes.License:Apache Software LicenseAuthor:Emmanouil (Manios) KrasanakisDependencies:networkx(required)pcst_fast(optional)Roadmap:x: Method ensemble.:x: Application for github project understanding.QuickstartInstall the library in your environment,
for example perpip install depytrace.
Then, create anetworkxgraph, select a root node and run the snippet:importdepytraceasdpgraph,root=...trace=dp.Core()(graph,root)print(dp.conductance(graph,trace))FeaturesNear-linear running time with respect
to the number of edges (doubling the edges,
approximately doubles running time).Provable1+Afactor approximations of maximum conductance,
whereAtend to be small.Extensibility to future breakthroughs on Steiner problems.CustomizationCore trace extraction is actually an NP-complete problem. For this
reason, solutions provided by this library are approximate and trade-off
tightness for speed.In particular, solutions are found
with an algorithm calledtrace contraction, which internally
relies on iteratively solving an NP-complete problems calledELOD
maximization. In turn, the latter can be translated to rooted Steiner tree
problems. To accommodate future theoretical breakthroughs,
the library allows setting up custom ELOD solvers, where tighter solvers
translate to tighter theoretical bounds of the trace contraction algorithm.The dafault ELOD maximizer is a heuristic written in native Python and is
chosen thanks to its cross-platform support. For systems that integrate
thegcccompiler (e.g. Linux, Windows with mingw installed) you can
also use a maximizer provided by the library that adjusts and depends on thepcst_fastSteiner tree solver.
To use the related maximizer, just install thepcst_fastlibrary
(ifgccis properly set up, this should be as simple aspip install pcst_fast) and run the snipper:importdepytraceasdpgraph,root=...trace=dp.Core(dp.cleverRPCST)(graph,root)print(dp.conductance(graph,trace))
Package: deqarclient
deqar-toolsCollections of additional scripts to manage DEQAR datadeqar.pyModule to work with DEQAR APIsimportInstitutions.pyImports lists of higher education institutions, provided in CSV, using the DEQAR Admin APIdeqar-get, deqar-head, deqar-submitSimple shell script wrappers to make requests to DEQAR APIs usingcurldeqar-cli.pySimple CLI to search and browse institutions with reports - incomplete, just written for testing the moduletest-pw.plPerl script to test whether users still have a default password set