Saravanan666/pypi-org huggingface dataset:
Package: darknet-config-generator
Darknet Neural Network Configuration Generator@author: Adamu A. SMotivationIf you have used darknet for one of your projects, you also understand the pain of editing the config file when you want to modify your network, optimization, and image augmentation parameters only to realize you forgot to edit another parameter after commencing training (bummer). You will also understand the pain of editing the configuration file to run inference. I implemented this to allow me to describe my neural network in a keras-like fashion and have a darknet config file generated.Give it a try with your next darknet project :-)Content:Introduction.ipynb - Provides an Example Usage of the darknet config generator with YoloV3 Network.example_generated.cfg - The resulting configuration file generation from Introduction.ipynb
Package: darknetpy
Darknetpy is a simple binding for darknet’s yolo (v4) detector.InstallationInstall it from pypicurl https://sh.rustup.rs -sSf | shrustup default nightlypip install darknetpyInstall a pre-built binarypip install https://github.com/danielgatis/darknetpy/raw/master/dist/darknetpy-4.1-cp36-cp36m-linux_x86_64.whlAdvanced options (only for pypi installation)GPU=1 pip install darknetpyto build with CUDA to accelerate by using GPU (CUDA should be in /use/local/cuda).CUDNN=1 pip install darknetpyto build with cuDNN to accelerate training by using GPU (cuDNN should be in /usr/local/cudnn).OPENCV=1 pip install darknetpyto build with OpenCV.OPENMP=1 pip install darknetpyto build with OpenMP support to accelerate Yolo by using multi-core CPU.UsageIn example.py:from darknetpy.detector import Detector

detector = Detector('<absolute-path-to>/darknet/cfg/coco.data',
                    '<absolute-path-to>/darknet/cfg/yolo.cfg',
                    '<absolute-path-to>/darknet/yolo.weights')

results = detector.detect('<absolute-path-to>/darknet/data/dog.jpg')

print(results)Runing:python example.pyResult:[{'right': 194, 'bottom': 353, 'top': 264, 'class': 'dog', 'prob': 0.8198755383491516, 'left': 71}]BuildOn the project root directorydocker pull hoshizora/manylinux1-clang_x86_64docker run --rm -v `pwd`:/io hoshizora/manylinux1-clang_x86_64 /io/build-wheels.sh
Package: dark-phoenix
#Prerequisitespip install html-testRunner#Links
To read  more about html runner follow the link belowhttps://github.com/oldani/HtmlTestRunnerTo read more about python unit test follow link belowhttps://docs.python.org/3/library/unittest.html#How to install
To install using pippython3 -m pip install dark-phoenixTo install a specific versionpython3 -m pip install dark-phoenix==x.x.x#How to Run
To use the runner use the following commandpython3 -m dprunner --testfolder ./tests/
Package: darkprop
Python wrapper of DarkProp, a Monte Carlo simulation code for the propagation
of dark matter particles in matter.InstallationInstall using pip$pipinstall--userdarkpropInstall from the sourceDownload the source code fromDarkProp's homepage.Install dependencies.Eigen 3,GSL, andSWIGare
needed to build the Python wrapper. They can be installed, for exampleUbuntu >= 20.04$sudoaptinstallg++swiglibeigen3-devlibgsl-devFedora$sudodnfinstallg++swigeigen3-develgsl-develThen prepare a python virtual environment and activate it.$python3-mvenvvenv
$sourcevenv/bin/activateBuild and install into the virtual environment. In the root directory of the
source code, execute$python3-mpipinstall.TipIf there is a network problem duringpip install, you can set up a mirror
server. For example, usingTsinghua mirror,
add-ioption topip installcommand$pipinstall-ihttps://pypi.tuna.tsinghua.edu.cn/simpledarkpropExampleInstallJupyter notebookandMatplotlibto run the example.$jupyter-notebookexample/python/basic-example.ipynbUninstall$pipuninstalldarkpropCitationIf you use darkprop in your publications, please cite the paperC. Xia, Y.-H. Xu, and Y.-F. Zhou, Production and attenuation of cosmic-ray
boosted dark matter,JCAP, 2022, 02(02): 028,arXiv: 2111.05559
Package: darkpy
Python Package: darkpyDescription:DarkPy is a Python library that provides some useful calculations.LinksDocumentação:https://jmiante.github.io/darkpyGitHub:https://github.com/jmiante/darkpyPyPI (last version):https://pypi.org/project/darkpyInstallation:pip install darkpyPT-BRDescrição:DarkPy é uma biblioteca Python onde tráz alguns cálculos úteis.Instalação:pip install darkpyDoação:Ajude o Projeto a continuar, qualquer doação é bem vindaCHAVE PIX:d51024a6-4320-4cb6-9241-b0a4d165dfd2PIX Copia e Cola:LinkQRCODE PIX:Nome:Jonathas Henrique Miante -Banco:PicPay
Package: darksearch
DarkSearchPython API wrapper for DarkSearch (darksearch.io). Python 3.6+ is currently supported.InstallpipinstalldarksearchResourcesDocumentationContributingAll contributions (no matter how small) are always welcome.Developmentgitclonegit@github.com:thehappydinoa/DarkSearch.git
poetryinstallTestingpytestPublishingpoetrybuild
poetrypublishLicenseThis software is licensed underMIT
Package: darkseid
DarkseidA python library to interact with comic archives.InstallationPyPi$pip3install--userdarkseidGitHubInstalling the latest version from Github:$gitclonehttps://github.com/Metron-Project/darkseid$cddarkseid$pythonsetup.pyinstallBugs/RequestsPlease use theGitHub issue trackerto submit bugs or request features.LicenseThis project is licensed under theGPLv3 License.
Package: darksky-async
DarkSky - Async Python 3 LibraryDesigned with native asyncio support, this libary is better suited to those who need better concurrency support than running requests insiderun_in_executor.
As this is an asyncio based libary, we do not plan to support Python 2. The minimum Python version needed is 3.5,you can download it hereUsageYou can use several methods to use this libary, including directly calling the helper functionforecast. This offers no setup but is significantly slower due to the need to create the client in the background everytime. Its better to just create the client and save it to a variable than using this function.Client example:importasyncioimportdarksky_asyncasyncdefmain():client=darksky_async.Client("DarkSky key goes here")weather=awaitclient.forecast(37.8267,# latitude-122.4233# longitude)print(weather.currently)print(weather.daily.data[0].timeLocal)# time-based items have a local time# version that allows you to convert between the two easilyloop=asyncio.get_event_loop()loop.run_until_complete(client.forecast(latitude,longitude))Quick example:importasyncioimportdarksky_asyncasyncdefexample_function():result=awaitdarksky_async.forecast(key,latitude,longitude,exclude=['minutely','hourly'],units='si')loop=asyncio.get_event_loop()loop.run_until_complete(example_function())Extra featuresAll time-based entries for DataPoint have a local version as well. Thanks to PyTz we can convert the datetime to the local time for quicker and easier access of time.
All you need to do to access this local time is appendLocalto any time-based datapoint:weather=awaitclient.forecast(37.8267,-122.4233)utc_time=weather.daily.data[0].sunriseTime>>>'2pm'# Abbreviated for simplicitylocal=weather.daily.data[0].sunriseTimeLocal>>>'6am'# -8 hours behind UTC, this time is accurate for Los Angeles, USAThis libary also keeps a track of how much is due. When running a forecast, you can check the current amount due by doing:weather=awaitclient.forecast(lat,lon)print(weather.total_due)The returned amount will be in dollars as per the terms of servicehereAs a note: this is only the daily cost. We cannot track theactualamount owed due to DarkSky having that information on lock down.
Package: darkskysync
Helps to access and synchronize with a remote data storageFeatureslists the available file structure on the remote hostlists the file structure in the local cachesynchronizes the local cache with the remote file structureallows for removing files from the local file systemaccess the remote host over ssh. The user can chose if the synchronization should be done with sftp or rsynchas support for multiple configuration files and multiple templates within the configsDocumentationThe full documentation can be generated with Sphinx0.2.0 (2017-09-28)works with Python 3.6 now0.1.6 (2015-09-15)slicker API0.1.5 (2014-07-15)fixed bug when loading unavailable filesimproved logging0.1.4 (2014-02-19)fixed bug in list available files0.1.3 (2014-02-11)new project urladapted example in docs0.1.2 (2014-01-27)Some bug fixesDocumentation on ssh keygen0.1.1 (2013-12-16)Plenty of bug fixedExtended documentationConnecting to DarkSky over SFTP0.1.0 (2013-09-23)Initial creation
Package: darksorter
dark-sorterDark Sorter is a Python-based utility designed to automatically sort Astrophotography Dark frames. It categorizes the
dark frames based on various parameters such as camera model, gain/ISO settings, temperature, and exposure time. This
utility comes with a Command-Line Interface (CLI) for ease of use.FromToCLIFeaturesCamera Sorting: Sorts dark frames based on the camera model.Gain/ISO Sorting: Categorizes frames based on gain or ISO settings.Temperature Sorting: Sorts frames according to temperature conditions, with a precision of 1°C.Exposure Time Sorting: Organizes dark frames by their exposure time.Duplication Detection: Identifies and avoids creating duplicate frames in the output directory.CLI Interface: Easy-to-use command-line interface for quick sorting.PrerequisitesPython 3.11+InstallationpipinstalldarksorterUsagedarksorterwhere/i/have/all/my/fitsnew/dark/locationCLI Optionsdarksorter--helpContributingIf you wish to contribute to this project, please submit a pull request or open an issue for discussion.LicenseThis project is licensed under the MIT License
Package: darkstar
Dark StarDark Star is a web framework that provides filesystem routing forStarletteand first-class support for server-side rendering.Dark Star routes are defined by their filesystem path and both the route's
backend code and template are contained in the first page.MotivationDark Star aims to provide an easy way to create web applications using theHATEOASandHDAphilosophies
favoured byhtmx. It also aims to reduce the boilerplate
code normally needed when creating web apps. In particular, it looks to reduce
the need of having a separate files for view functions and templates. It tries
to embraceLocality of Behaviourby putting the view function code and template in the same file, and having the
file's path be the route used by Starlette to access the code.Installationpip install darkstarYou can then run the included CLI with:python -m darkstar create-app --helpTo run your new app, you'll need an ASGI server installed, such a Hypercorn, Daphne, or Uvicorn.To run with Uvicorn, first install it:python -m pip install uvicorn[standard]The run your app:python -m uvicorn app:app(This assumes your defined your app as theappvariable in anapp.pyfile.)
Package: dark-web-scraper
:dart: Usage :Currently this is only designed toScrape dark web for onion linksScrape images from dark webWithout tor browser:sparkles: Unique Features :Instead of using TOR browser, Using tor proxyRandomized IP address for anonymitySpoofing user agent to avoid getting tracked:wrench: Current Dependencies:Linux [ used debian based distro ]:gear: Prerequisite :Enable socksUpdate package lists$ sudo apt updateInstall tor package$ sudo apt install torStart Tor service$ sudo service tor startVerify installation status$ sudo service tor status:books: Tutorial :Install using pip$ pip install dark-web-scraper1. Find onion urls from a dark web linkRequest :find_onion_links( str )Response: links will be saved inresult.txtExample :# Main.pyfromdark_web_scraperimportfind_onion_linksfind_onion_links('http://random_url.onion')2. Scrape images on a dark web linkRequest :find_images_from_onion_link( str )Response: Images will be saved in/static/imagesExample :# Main.pyfromdark_web_scraperimportfind_images_from_onion_linkfind_images_from_onion_link('http://random_url.onion'):rocket: Features to be added :Language DetectionLanguage translationOnion link validatorObject detection in imagesNamed entity recognitionSearch specific keywords in a list of urlsSentiment aAnalysis on the webpage contents:warning: Disclaimer:I don't promote illegality.This project is just for educational purposes only
Package: darkwood
Darkwood Data Python ClientInstallationYou can install the Darkwood Data Python client fromPyPI:python -m pip install darkwoodIn order to ensure your shell can discover the command line tool follow the below instructions depending on your operating systemLinux/macOSOn Linux and macOS you can find the user base binary directory by runningpython -m site --user-baseand addingbinto the end. For example, this will typically print~/.local(with~expanded to the absolute path to your home directory) so you’ll need to add~/.local/binto your PATH. You can set your PATH permanently by modifying~/.profile.WindowsOn Windows you can find the user base binary directory by runningpython -m site --user-siteand replacingsite-packageswithScripts. For example, this could returnC:\Users\Username\AppData\Roaming\Python36\site-packagesso you would need to set your PATH to includeC:\Users\Username\AppData\Roaming\Python36\Scripts. You can set your user PATH permanently in the Control Panel. You may need to log out for the PATH changes to take effect.Setupdarkwood-data configure cliThis will result in a file at~/.darkwood/credentials.The client is supported on Python 3.6 and above.How to useThe Darkwood client can be used as a command line application or as a python package.
The cli is nameddarkwood-data.Calling the linking apidarkwood-data entity-mapper --transaction "Amazon Tips*1Z3MJ3KL2 Amzn.com/bi WA"You can also call the Darkwood API in your own Python code, by importing from thedarkwoodpackage.
If you have configured the host machine using thedarkwood-data configure clicommand use:>>> from darkwood.client.call import credit_card_mapper
>>> credit_card_mapper(transaction="Amazon Tips*1Z3MJ3KL2 Amzn.com/bi WA")Additionally, you have the option to explicity pass in credentials>>> from darkwood.client.call import credit_card_mapper
>>> credit_card_mapper(transaction="Amazon Tips*1Z3MJ3KL2 Amzn.com/bi WA", creds=<PASTE-YOUR-DARKWOOD-CREDS>)
Package: darlehen.py
darlehenpyEin kleines Paket zur Berechnung von Darlehen. Bei weitem (noch 😉) nicht so mächtig wie z.B. derHypothekenrechner.Es wird zwischen der Berechnung basierend auf der Monatsrate oder basierend auf der anfänglichen Tilgungsrate unterschieden. Die Angabe einer jährlichen Sondertilgung ist auch möglich.Projekt auf PyPIQuickstartpip install darlehen.py
import darlehenpy.darlehen as darlehen
darlehen.berechne_mit_monatsrate(...)
darlehen.berechne_mit_tilgungsrate(...)Achtung!Punkt als Dezimaltrennzeichen!BeispielAus derbeispiel.py.importsrc.darlehenpy.darlehenasdarlehen# Die Ausgabe kann man schöner machen ;)# RahmenbedingungenP=100000i=4.1n=10S=5000print(f"Darlehensumme:{P}€\nZinssatz (p.a.):{i}%\nLaufzeit:{n}Jahre\nSondertilung (p.a.):{S}\n")# Berechnung basierend auf einer MonatsrateM=500print(f"Monatsrate:{M}€")t0,R,gesamtaufwand,jahr,monat=darlehen.berechne_mit_monatsrate(P,i,M,n,S)print(f"Anfängliche Tilgungsrate:{t0}%\nRestschuld nach{n}Jahren:{R}€\nGesamtaufwand:{gesamtaufwand}€\nAbbezahlt im{jahr}. Jahr und{monat}. Monat\n")# Berechnung basierend auf der anfänglichen Tilgungsratet0=5.5print(f"Anfängliche Tilgungsrate:{t0}%")M,R,gesamtaufwand,jahr,monat=darlehen.berechne_mit_tilgungsrate(P,i,t0,n,S)print(f"Monatsrate:{M}€\nRestschuld nach{n}Jahren:{R}€\nGesamtaufwand:{gesamtaufwand}€\nAbbezahlt im{jahr}. Jahr und{monat}. Monat")Ausgabe:❯ python test.py
Darlehensumme: 100000 €
Zinssatz (p.a.): 4.1 %
Laufzeit: 10 Jahre
Sondertilung (p.a.): 5000

Monatsrate: 500 €
Anfängliche Tilgungsrate: 1.9 %
Restschuld nach 10 Jahren: 16033.91 €
Gesamtaufwand: 126033.91 €
Abbezahlt im None. Jahr und None. Monat

Anfängliche Tilgungsrate: 5.5 %
Monatsrate: 800.0 €
Restschuld nach 10 Jahren: 0.0 €
Gesamtaufwand: 118474.63 €
Abbezahlt im 9. Jahr und 3. MonatMan kann sich damit natürlich viele Werte auf einmal berechnen lassen und vergleichen. Z.B. mit einer CSV mit folgenden Spalten als Input:P,i,M,n,S,bzw.P,i,t0,n,S,TestsEine Testmatrix mit Werten ermittelt aus demHypothekenrechnertestet die berechneten Ergebnisse.Es kann keine Gewährleistung für die von diesem Paket berechneten Ergebnisse übernommen werden
Package: darlog-py23
darlog-py23A tiny compatibility module for cross-Python2/3 code.
It's not a replacement for neithersixnor__future__modules but is more of an extension to them.Defines the very basic stuff:Python version booleansPY2,PY3,PY310- simple flags indicating whether you're running under Python 2, 3 or 3.10+.Stringsstr_typesA tuple containing all the string types - ready to be passed toisinstance():Python 2 -(str, unicode)Python 3 -(str, )unicodeType alias:Python 2 -unicodePython 3 -strto_least_str()Converts the given value to a string:Python 2: tries to turn to astr,unicodeif fails.Python 3: just an alias forstr().str_format()Formats a string and doesn't throw an error if any of the given arguments is unicode under Python 2. The resulting string is simply turned to unicode, too.DataClasses@attrsdecoratorTries to useattr.sand if it's not found, falls back to built-in decorator from Py3.10 and, finally to 3.7 implementation if available.If none of those is found, applies the included dataclass implementation, the simplest possible one (@dataclass_fallback, see below) - as the last resort, just to avoid exceptions.@dataclassdecoratorSimilar to@attrs, but tries built-in@dataclassfirst.I'd recommend using@attrsanyway, but here it is.Tries to use the built-in decorator from Py3.10, falls back to 3.7 implementation, then toattr.s. And, finally, to the included@dataclass_fallback.@dataclass_fallbackdecoratorThe minimal implementation ofdataclassworking in any Python version above 2.7. Implements onlyinit,reprandeqfeatures.It doesn't do any "attribute isFieldinstance" stuff or any othergetattr/setattrmagic.This is what both@dataclassand@attrsfall back to as the last resort. I don't know why would you need it explicitly, though - but here it is.
Package: da-rnn
Tensorflow 2 DA-RNNA Tensorflow 2 (Keras) implementation of theDual-Stage Attention-Based Recurrent Neural Network for Time Series PredictionPaper:https://arxiv.org/abs/1704.02971InstallFor Tensorflow 2pipinstallda-rnn[keras]For PyTorchpipinstallda-rnn[torch]UsageFor Tensorflow 2fromda_rnn.kerasimportDARNNmodel=DARNN(T=10,m=128)# Trainmodel.fit(train_ds,validation_data=val_ds,epochs=100,verbose=1)# Predicty_hat=model(inputs)For PyTorch (with poutyne)importtorchfrompoutyneimportModelfromda_rnn.torchimportDARNNdarnn=DARNN(n=50,T=10,m=128)model=Model(darnn)# Trainmodel.fit(train_ds,validation_data=val_ds,epochs=100,verbose=1)# Predictwithtorch.no_grad():y_hat=model(inputs)Python Docstring NotationsIn docstrings of the methods of this project, we have the following notation convention:variable_{subscript}__{superscript}For example:y_T__imeans, thei-th prediction value at timeT.alpha_t__kmeans, the attention weight measuring the importance of thek-th input feature (driving series) at timet.DARNN(T, m, p, y_dim=1)DARNN(n, T, m, p, y_dim=1)The naming of the following (hyper)parameters is consistent with the paper, excepty_dimwhich is not mentioned in the paper.n(torch only)intinput size, the number of features of a single driving seriesTintthe length (time steps) of the windowmintthe number of the encoder hidden statespintthe number of the decoder hidden statesy_dimint=1the prediction dimention. Defaults to1.Return the DA-RNN model instance.Data ProcessingEach feature item of the dataset should be of shape(batch_size, T, length_of_driving_series + y_dim)And each label item of the dataset should be of shape(batch_size, y_dim)DevelopmentInstall dependencies:makeinstallRun notebook:cdnotebook
jupyterlabTODOno hardcoding (1for now) for prediction dimentionalityLicenseMIT
Package: darpy
Distribute Archived PythonInstall withpip install darpydarpyisn’t better than shell scripting. Itisshell scripting. No
illusions, no lies, no false abstractions.Why?Pre-baking a virtualenv and shipping it around is full of woes. (e.g.-relocatableonly kind of works, but virtualenv may have abspaths in it)Want to be able to bundle dependencies of an application so that you can
have them openly specified inrequirements.txt, but reproducibly deploy
the same exact dependenciesHow?Usetar,pip download,pip install, to make python archives which
can unpack and install without network access.Works best if youdarpy packanddarpy unpackon the same platform
version, python version, and architecture.darpy packmay fetch arch or
platform-specific binary packages based on the platform where it runs.UsagePack it UpIf you have a package in dir$HOME/myprojectdarpy pack --src "$HOME/myproject"If you want to use arequirements.txtoutside ofsetup.pydarpy pack --requirements "$HOME/myproject/requirements.txt"or use bothdarpy pack --src "$HOME/myproject" --requirements "$HOME/myproject/requirements.txt"Unpack ItWorks best if done on the same platformUnpack into current virtualenv withdarpy unpack darpy-pack.tgzUnpack into target virtualenv withdarpy unpack darpy-pack.tgz --virtualenv "$HOME/myvirtualenv"
Package: darshan
Python utilities to interact withDarshanlog records of HPC applications.FeaturesJob summary tool for generating HTML reports of I/O activity in a Darshan logDarshan Report interface for common interactive analysis tasksLow-level CFFI bindings for efficient access to Darshan log filesGeneric plotting capabilities (matplotlib) for Darshan log dataUsageFor examples and Jupyter notebooks to get started with PyDarshan make sure
to check out theexamplessubdirectory.InstallationTo install in most cases the following will work:pip install darshanTestingTargets for various tests are included in the makefile. To run the normal
test suite use:make testOr to test against a different version of Python using Tox:make test-allCoverage tests can be performed using:make coverageConformance to PEPs can be tested using flake8 via:make lintDocumentationDocumentation for the Python bindings is generated separately from the
darshan-util C library in the interest of using Sphinx. After installing the
development requirements the documentation can be built using make as follows:pip install -r requirements_dev.txt
make docsFile Listdarshan::core darshan python module codedevel::scripts for building Python wheeldocs::markdown documentation used by sphinx to auto-generate HTML RTD style docexamples::Jupyter notebooks showing PyDarshan usage with log filestests::PyDarshan-specific test casesrequirements.txt::pip requirement file for minimum set of dependenciesrequirements_dev.txt::pip requirement file for dependencies needed to run development toolssetup.py::python file for building/generating PyDarshan packagesetup.cfg::input for setup.pyMANIFEST.in::input files for setup.py packagetox.ini::input for tox which runs the automated testing