Saravanan666/pypi-org huggingface dataset:
Package: diretriz-vigilancia
Diretrizes VigilânciaDiretriz Nacional do Plano de Amostragem da Vigilância da Qualidade da Água para Consumo Humanoque"visa orientar a elaboração e a implementação dos planos de amostragem da vigilância da qualidade da água para consumo humano, abordando o quantitativo mínimo de amostras, a frequência de amostragem, os parâmetros a serem analisados, bem como as orientações para a seleção dos pontos de coleta".As diretrizes trazem informações sobre o número de amostras que devem ser realizadas.pipinstalldiretriz-vigilancia--upgradeTODO.........
Package: dir-exec
Installation$[sudo]pipinstalldir-exec$[sudo]npmi-gdir-execExamples$find~/git/gists-typed-mindepth1-maxdepth1-print0|xargs-0dir-execcommandexecute functionfunc(){...}export-ffunc
find~/git/gists-typed-mindepth1-maxdepth1-print0|xargs-0dir-execfuncreadme42.com
Package: dirganize
dirganizeDeclutter you folders and get peace of mind.
A command-line tool to organize files into category directories.InstallationpipinstalldirganizeUsageDirganize has an ultra simple command-line interface.
Just move into the directory you want to organize, and rundirganize.You can also specify which folder to organize by using thepathoption.dirganize--path~/DownloadsIf no path is specified, dirganize works on the current directory.ConfigurationBy defaultdirganizedetermines the destination folder for a particular file by
guessing its type from its extension.
Theguess_typefunction of python's inbuilt modulemimetypesis used for this purpose.NOTEDotfiles are not affected by dirganize.You can put a.dirganize.ymlfile ( inside the folder you want to dirganize )
to provide a custom configuration.# .dirganize.yml# folder: [ext1,ext2, ...]Animations:[gif]Binaries:[bin,dat]Basically you have the folder name,
mapped to the list of file types to put in that folder.Dirganize will first try to determine the destination directory from the.dirganize.yml.
When the yaml configuration file is absent or
the folder for an encountered file type is not defined in the configuration,dirganizewill fallback to the default technique.
Package: dirgh
dirghWithdirghyou can easily download a directory from GitHub programmatically from Python or using the CLI.CLIusage:dirgh[-h]-rREPO[-oOWNER][-dDIRECTORY][-tTARGET][--refREF][-R][-O][-aAUTH]DownloadsingledirectoriesfromGitHub.
GitHubratelimitsare60requests/hourwhenunauthenticatedand5,000/hourwhenusingatoken.Eachsubfolderrequiresextrarequests.

examples:
dirgh-rtiauth-otiptenbrink-ddeployment--refcf51bff1a79b280388ba65f18998717b2fa5e1e3
dirgh-rtiptenbrink/tiauth-ddeployment-R-t'C:\Users\dirgher'\Coolprojects/dürghé'(You can use both forward and backwardslashes, even interchangeably)dirgh -r tiptenbrink/tiauth -R -t './dürghé'optional arguments:-h, --help            show this help message and exit-r REPO, --repo REPO  repository on GitHub using the format <owner>/<repository> or just <repository> if owner is also specified. If both are specified, owner is ignored.-o OWNER, --owner OWNERrepository owner on GitHub, can be an organization or user. Only necessary when not provided in the --repo option.-d DIRECTORY, --directory DIRECTORYinitial directory path in the format <subfolder1>/<subfolder2> etc. Defaults to root directory.-t TARGET, --target TARGEToutput directory. If requesting a directory, this will overwrite the directory name. By default, the content will be placed in './dirgh/1673538759'.--refREFcommitreference,canbeinanybranch.(default:HEAD)-R,--recursiverecursivelyenterallsubfolderstogetallfiles.-O,--overwriteOverwritetargetdirectory.-aAUTH,--authAUTHuserauthenticationtoken,OAuthorpersonalaccesstoken.Notrequiredbutincreasesratelimits.
Package: dirhashcalc
Directory Hash CalculatorThis project is a super simple Python library which can be used in both command line and library ways.To install it:$pipinstalldirhashcalcCommandline UsageTo use it in commandline:$dirhashcalcpath/to/dir
8907645cfe42941cf7dbc656d59ccc4f02ec2a16493c097e04ce2547ad1e5484You can also pass mlutiple arguments:$dirhashcalcfirstsecond
first:8907645cfe42941cf7dbc656d59ccc4f02ec2a16493c097e04ce2547ad1e5484
second:9f29e53d60a5a8e92da03e41678374ac584c2c94a24898c0c719736412723c4dAlso there are some options that you can use:$dirhashcalc--version# shows version of the tool# verbose output (prints name of each file when calculating hash of it)$dirhashcalcsome/dir-v
$dirhashcalcsome/dir--verbose# super verbose output (prints file names and hash of each one of them)$dirhashcalcsome/dir-vv
$dirhashcalcsome/dir--super-verboseLibrary UsageYou can use this project in your own projects to calculate directory hash.fromdirhashcalcimportDirHashCalculatordir_sha256=DirHashCalculator('path/to/dir').calc()ClassDirHashCalculatorhas more methods. To see them and use it in any other way that you want, see content ofdir_hash.pyin the project and read description of each method in docstring.LicenseThis project is licensed underMIT License.
Package: dirhunt
DirhuntDirhunt is a web crawler optimize forsearch and analyze directories. This tool can find interesting things if the
server has the“index of”mode enabled. Dirhunt is also useful if the directory listing is not enabled. It detects
directories withfalse 404 errors, directories where anempty index filehas been created to hide things and
much more.$dirhunthttp://website.com/Dirhunt does not use brute force. But neither is it just acrawler. This tool is faster than others because it
minimizes requests to the server. Generally, this tool takesbetween 5-30 seconds, depending on the website and
the server.Read more abouthow to useDirhuntin the documentation.FeaturesProcessone or multiple sitesat a time.Process‘Index Of’pages and report interesting files.Detectredirectors.Detectblank index filecreated on directory to hide things.Process some html files in search of new directories.404 error pages and detectfake 404 errors.Filter results byflags.Analyze results at end. It alsoprocesses date & sizeof the Index Pages.Get new directories usingrobots.txt,VirusTotal,Google,CommonCrawl(NEW!),SSL Certificate(NEW!),Crt.sh(NEW!) &Wayback(NEW!).Delaybetween requests.One or multipleproxiesoption. It can also search forfree proxies.Save the resultsto a JSON fileResumethe aborted scansInstallIf you have Pip installed on your system, you can use it to install the latest Dirhunt stable version:$ sudo pip3 install dirhuntPython 2.7 & 3.7-3.12 are supported but Python 3.x is recommended. Usepip2on install for Python2.There are otherinstallation methodsavailable.DisclaimerThis software must not be used on third-party servers without permission. Dirhunt has been created to be used by audit
teams with the consent of the owners of the website analyzed. The author is not responsible for the use of this tool
outside the law.This software is under the MIT license. The author does not provide any warranty. But issues and pull requests are
welcome.
Package: dirichletcal
Dirichlet Calibration Python implementationThis is a Python implementation of the Dirichlet Calibration presented inBeyond temperature scaling: Obtaining well-calibrated multi-class probabilities
with Dirichlet calibrationat NeurIPS 2019.Installation# Clone the repository
git clone git@github.com:dirichletcal/dirichlet_python.git
# Go into the folder
cd dirichlet_python
# Create a new virtual environment with Python3
python3.8 -m venv venv
# Load the generated virtual environment
source venv/bin/activate
# Upgrade pip
pip install --upgrade pip
# Install all the dependencies
pip install -r requirements.txt
pip install --upgrade jaxlibUnittestpython -m unittest discover dirichletcalCiteIf you use this code in a publication please cite the following paper@inproceedings{kull2019dircal,
  title={Beyond temperature scaling: Obtaining well-calibrated multi-class probabilities with Dirichlet calibration},
  author={Kull, Meelis and Nieto, Miquel Perello and K{\"a}ngsepp, Markus and Silva Filho, Telmo and Song, Hao and Flach, Peter},
  booktitle={Advances in Neural Information Processing Systems},
  pages={12295--12305},
  year={2019}
}ExamplesYou can find some examples on how to use this package in the folderexamplesPypiTo push a new version to Pypi first build the packagepython3.8 setup.py sdistAnd then upload to Pypi with twinetwine upload dist/*It may require user and password if these are not set in your home directory a
file.pypirc[pypi]
username = __token__
password = pypi-yourtoken
Package: dirichletprocess
dirichlet=========[![image](https://img.shields.io/travis/tdhopper/dirichlet.svg)](https://travis-ci.org/tdhopper/dirichlet)[![image](https://img.shields.io/pypi/v/dirichlet.svg)](https://pypi.python.org/pypi/dirichlet)Construct a [Dirichlet Process](https://github.com/tdhopper/notes-on-dirichlet-processes) from any random sampler.```In [1]: from dp import DirichletProcessIn [2]: from random import normalvariateIn [3]: from collections import CounterIn [4]: dp =  DirichletProcess(lambda: normalvariate(0, 1), alpha=1)In [7]: Counter(dp() for _ in range(1000))Out[7]: Counter({-0.029073686274754998: 679, 0.7332646430104509: 301, 0.23296111210571477: 12, -0.7042044460111074: 4, -2.2504937687943922: 4})```Install with `pip install dirichletprocess` or `conda install -c tdhopper dirichletprocess`.History=======0.2.0 (2015-08-13)==================-  Basic functionality added.
Package: dirigible
Dirigible=========Dirigible is a minimal python package the provides two shortcuts for workingwith config files:1) it can transparently read config files encrypted with Ansible Vault, and2) shortcuts for finding and loading configs files in common locations, like~/.{{appname}} or /etc/{{appname}}, or looking in a location specified byan environment variable "${{appname|upper}}_CONFIG_DIR" if defined.Examples++++++++Load a basic, unencrypted config file fromfrom os.path import join, abspath, dirnameimport digibleclass MyConfig(dirigible.Config):appname = 'testapp'defaults = join(dirname(abspath(__file__)), 'defaults')@CachedAttrdef cfg(self):return self.load_config_filename('myapp.cfg')
Package: dirimport
dirimport: convenient library importerInstallpython -m venv your-dircd your-dir./bin/pip install dirimportInstall (devel)git clonehttps://github.com/wtnb75/dirimport.gitcd dirimportpython -m venv ../bin/pip install -r requirements.txtUseimport dirimportmod = dirimport.importall("/path/to/dirname")import rulesfile.py ->from .file import *subpkg/ ->from . import subpkgdo it recursivelythen, all symbols will be accessible after import.example:layoutsymbol1 in dir1/file1.pysymbol2 in dir1/file2.pysymbol3 in dir1/pkg/file1.pyimportimport dir1with generatedinit.pyordir1 = dirimport.importall("dir1")withoutinit.pyresultsymbol1 ->dir1.symbol1symbol2 ->dir1.symbol2symbol3 ->dir1.pkg.symbol2CLI tools# ./bin/dirimport
Usage: dirimport [OPTIONS] COMMAND [ARGS]...

Options:
  --help  Show this message and exit.

Commands:
  diff
  eval
  generatediff__init__.py./bin/dirimport diff your-library-dirimport and evaluate expression./bin/dirimport eval your-library-dir 'expression'generate__init__.py./bin/dirimport generate your-library-direxamplesex1Linkspypicoveragelocal pypi repo
Package: dirindex
Installpip install dirindexdirindex --helpor ... docker run ghcr.io/wtnb75/dirindex --helpUsage# dirindex --help
Usage: dirindex [OPTIONS] COMMAND [ARGS]...

Options:
  --version  Show the version and exit.
  --help     Show this message and exit.

Commands:
  make
  read-resourcemake directory index# dirindex make --help
Usage: dirindex make [OPTIONS] DIRECTORY

Options:
  --verbose / --no-verbose
  --template TEXT
  --dry / --no-dry              [default: False]
  --recursive / --no-recursive  [default: False]
  --single / --no-single        [default: False]
  --pattern TEXT                [default: *]
  --hide TEXT
  --filename TEXT               [default: index.html]
  --help                        Show this message and exit.create Apache style directory indexdirindex make --template apache /path/to/directoryopen /path/to/directory/index.htmlbuilt-in stylestemplateJinja2arguments... dirindex make --dry --template /dev/null /path/to/directory --filename - --verboseLinkspypicoveragelocal pypi repo
Package: dirlib
dirlibdirlibis a minimum library for getting a directory that is used by putting on configuration files. This is inspired by Golang standard library function calledos.UserConfigDir(). Currently, Windows, Unix and macOS are supported.Installationpip install dirlibHow to useimportdirlib# On Windowsprint(dirlib.user_config_dir())#=> %AppData% or %UserProfile%# On Unixprint(dirlib.user_config_dir())#=> $XDG_CONFIG_HOME or $HOME/.config# On macOSprint(dirlib.user_config_dir())#=> $HOME/Libary/Application Supportuser_config_dir()can pass the two arguments. The first one is an application name. Here is an example on Windows.importdirlibapp_name="mysupercooltool"print(dirlib.user_config_dir(app_name))#=> C:\Users\chihiro\AppData\Roaming\mysupercooltool
Package: dirlisting
dirlistingCreate a directory tree listing from a text file for use in documentation.There are plenty of good tools out there to produce directory tree listings from an
existing directory structure. This tool handles the situation when you don't have and
don't want to create a directory structure for the sole purpose of producing a directory
tree listing for a document or email.Read the documentation on ReadTheDocs!Installation$pipinstalldirlistingUsagedirlistingcan be used to create a directory tree listing that looks like those
created with thetreecommand, but from a text file instead of walking an actual
directory tree.From codeReading a filefromdirlisting.dirlistingimportDirlistingwithopen("input.yaml")asf:listing=Dirlisting(f)listing.print()From a stringfrom dirlisting.dirlisting import Dirlisting
input = """
- topdir:
  - subdir1:
    - file1.txt
    - file2.txt
"""
Dirlisting(input).print()From the command lineJust usedirlisting <filename>.dirlisting [OPTIONS] FILE

  Create a directory listing given an input FILE.

Options:
  --version              Show the version and exit.
  -s, --sort             Sort the directory entries.
  -d, --dirsfirst        List directories before files.
  -o, --output FILENAME  Output to this file.
  --help                 Show this message and exit.File formatThe input file is ayamlfile. Each of the entries is treated as
part of a sequence and starts with a-. The files are final strings and the file name
comes after the dash (- filename). The directories are mappings and the directory name
is followed by a colon (- dirname:). A listing would look like the following.:::::{grid} 2
::::{grid-item-card} YAML File-topdir:-emptydir:-file1.txt-file2.txt-subdir:-file3.txt::::
::::{grid-item-card} Outputtopdir
├── emptydir
├── file1.txt
├── file2.txt
└── subdir
    └── file3.txt::::
:::::When using the output option to save to a file, the file will be saved with "utf-8"
encoding. On a Mac or Linux machine this works seamlessly. There can be problems with
the console on Windows, but most modern editors can open the file with "utf-8" encoding.ContributingInterested in contributing? Check out the contributing guidelines. Please note that this
project is released with a Code of Conduct. By contributing to this project, you agree
to abide by its terms.Licensedirlistingwas created by Stephan Poole. It is licensed under the terms of the MIT
license.Creditsdirlistingwas created withcookiecutterand thepy-pkgs-cookiecuttertemplate.
Package: dirmaker
dirmaker is a simple, opinionated static site generator for publishing directory websites (eg:Indic.page,env.wikiIt takes entries from a YAML file and generates a categorised, paginated directory website.Installpip3 install dirmakerBuild a site# Generate an example site in the `example` directory.dirmaker--newcdexample# Edit config.yml and add data to data.yml# Customize static files and the template if necessary.# Build the static site into a directory called `site`.dirmaker--buildLicensed under the MIT license.
Package: dirmarks
DirmarksDirmarks is a directory bookmarking tool that allows you to easily manage, navigate, and switch between directories using bookmarks. This tool can save you time and make working with the command line more efficient.InstallationInstall the Markdirs package using pip:pip install dirmarksShell Function SetupTo enable the dir command for changing directories using bookmarks, add the following shell function to your .profile, .bashrc, or .zshrc file, depending on your shell:#!/bin/bash
dir() {
if [ "$#" -eq 0 ]; then
    dirmarks list
    exit $?
fi
OPT=$1;
shift;
case $OPT in
        -l)
        dirmarks list
        ;;
        -h)
        dirmarks help
        ;;
        -d)
        dirmarks delete $1
        ;;
        -m)
        dirmarks add $1 $PWD
        ;;
        -u)
        dirmarks update $1 $2
        ;;
        -a)
        dirmarks add $1 $2
        ;;
        -p)
        GO=`dirmarks get $1`;
        if [ "X$GO" != "X" ]; then
                echo $GO;
        fi
        ;;
        *)
        GO=`dirmarks get $OPT`;
        if [ "X$GO" != "X" ]; then
                cd $GO;
        fi
        ;;
esac
}Or add a file .functions in your home directory and source it in .bashrcecho "source ~/.functions" >> ~/.bashrcSetup dirmarks for all usersmkdir -p /etc/bash.functions 
cp data/marks.function /etc/bsh.fucntionsAppend the following line in /etc/bash.bashrcif [ -d /etc/bash.functions ]; then
        for i in /etc/bash.functions/*;do 
                source $i
        done
fiUsage:dir -h   ------------------ prints this help
dir -l	------------------ list marks
dir <[0-9]+> -------------- dir to mark[x] where is x is the index
dir <name> ---------------- dir to mark where key=<shortname>
dir -a <name> <path> ------ add new mark
dir -d <name>|[0-9]+ ------ delete mark
dir -u <name> <path> ------ update mark
dir -m <name> ------------- add mark for PWD
dir -p <name> ------------- prints markUsage examplemajam@dirose:~$ dir -l
0 => meirm:/net/xen/mnt/sdb1/meirm
1 => edonkey:/net/xen/mnt/sdb1/majam/aMule/Incoming
2 => init:/etc/init.d
3 => majam:/net/xen/mnt/sdb1/majam

majam@dirose:~$ dir 1
majam@dirose:/net/xen/mnt/sdb1/majam/aMule/Incoming$ 

majam@dirose:/etc/init.d$ dir majam
majam@dirose:/net/xen/mnt/sdb1/majam$ 

majam@dirose:~$ dir -d 2
majam@dirose:~$
Package: diro-py
Examplefromdiroimportparse,Diceif__name__=="__main__":d=parse("3D6k1+1*(10+1)*2")d.roll()print(f"{d}={d.detail_expr()}={d.calc()}")# 3D6K1+1*(10+1)*2=6+1*(10+1)*2=28d=parse("D100b2")d.roll()print(f"{d}={d.detail_expr()}={d.calc()}")# D100B2=32B2B1=12dice=Dice(face=6,count=3,kq=2)result=dice.roll()print(f"{dice}={result.detail()}={result()}")# 3D6K2=1+4+1=5diro=parse("1/0")print(diro.calc())# Err! ZeroDivisionError: division by zero
Package: dirs-and-dict
dirs_and_dictA lightweight solution to creating folder structures from dicts, in PythonOpen source available onGitHubandPyPI.InstallationInstall from pip:py -m pip install dirs_and_dictUpdate to the latest version from pip:py -m pip install --upgrade dirs_and_dictUninstall from pip:py -m pip uninstall dirs_and_dictBuilding from sourcesRun this command from the package directory on your filesystem:py -m buildDevelopment diaryDEVDIARY.mdCommunityOpen a new issuefor
support.
Package: dirscan
A recursive directory traverser, which can be used to traverse one or
multiple directories in parallel. It resembles the python function
os.walk(), but with the ability to walk multiple directories
simulaneously, making it suitable for comparing directory trees.A cmd-line tool, dirscan, provides directory scanning and comparing
functions from the command-line.Home for the project:https://github.com/sveinse/dirscanCopyright 2010-2018, Svein Seldal <sveinse@seldal.com>This application is licensed under GNU GPL version 3
<http://gnu.org/licenses/gpl.html>. This is free software: you are
free to change and redistribute it. There is NO WARRANTY, to the
extent permitted by law.
Package: dirschema
dirschemaA directory structure and metadata linter based on JSON Schema.JSON Schemais great for validating (files containing) JSON
objects that e.g. contain metadata, but these are only the smallest pieces in the
organization of a whole directory structure, e.g. of some dataset of project.
When working on datasets of a certain kind, they might contain various types of data,
each different file requiring different accompanying metadata, based on its file type
and/or location.DirSchemacombines JSON Schemas and regexes into a solution to enforce structural
dependencies and metadata requirements in directories and directory-like archives.
With it you can for example check that:only files of a certain type are in a location (e.g. onlyjpgfiles in directoryimg)for each data file there exists a metadata file (e.g.test.jpghastest.jpg_meta.json)each metadata file is valid according to some JSON SchemaIf validating these kinds of constraints looks appealing to you, this tool is for you!Dirschema features:Built-in support for schemas and metadata stored as JSON or YAMLBuilt-in support for checking contents of ZIP and HDF5 archivesExtensible validation interface for advanced needs beyond JSON SchemaBoth a Python library and a CLI tool to perform the validationInstallationpip install dirschemaGetting StartedThedirschematool needs as input:a DirSchema YAML file (containing a specification), anda path to a directory or file (e.g. zip file) that should be checked.You can run it like this:dirschema my_dirschema.yaml DIRECTORY_OR_ARCHIVE_PATHIf the validation was successful, there will be no output.
Otherwise, the tool will output a list of errors (e.g. invalid metadata, missing files, etc.).You can also usedirschemafrom other Python code as a library:fromdirschema.validateimportDSValidatorDSValidator("/path/to/dirschema").validate("/dataset/path")Similarly, the method will return an error dict, which will be empty if the validation succeeded.You can find more information on using and contributing to this repository in thedocumentation.How to CiteIf you want to cite this project in your scientific work,
please use thecitation filein therepository.AcknowledgementsWe kindly thank allauthors and contributors.This project was developed at the Institute for Materials Data Science and Informatics
(IAS-9) of the Jülich Research Center and funded by the Helmholtz Metadata Collaboration
(HMC), an incubator-platform of the Helmholtz Association within the framework of the
Information and Data Science strategic initiative.