Saravanan666/pypi-org huggingface dataset:
Package: path_pipe_conf_tools
This is probably not very interesting unless you work in the pathogen
informatics team at the Wellcome Trust Sanger Institute and almost
certainly not it you don’t usethe vr-pipe
pipeline.Given a config directory, this script finds all of the*_pipeline.conffiles in the directory and its immediate children.
It parses these files and outputs their contents in json. This is either
saved to a file or stdout.This is used in collaboration withjsontoemailand acronjob to send updates / reminders to the pathogen informatics
team.Usage$ list-pathogen-pipeline-jobs -h
usage: list-pathogen-pipeline-jobs [-h] [--output_file OUTPUT_FILE] config_dir

Outputs details of all of the pathogen jobs in the pipeline

positional arguments:
  config_dir            Config directory to be searched for job trackers (also
                        searches child dircectories)

optional arguments:
  -h, --help            show this help message and exit
  --output_file OUTPUT_FILE, -o OUTPUT_FILE
                        File to output results to (defaults to stdout)Example output{
  "created_at": "2015-03-24T15:26:17.246253",
  "jobs": [
    {
      "approval_required": true,
      "config_file": "/parent_dir/assembly_jobs/job_1.conf",
      "job_type": "__Assembly__",
      "pipeline_tracker": "/parent_dir/assembly_job_tracker.conf"
    },
    {
      "approval_required": true,
      "config_file": "/parent_dir/assembly_jobs/job_2.conf",
      "job_type": "__Assembly__",
      "pipeline_tracker": "/parent_dir/assembly_job_tracker.conf"
    },
    {
      "approval_required": false,
      "config_file": "/parent_dir/assembly_jobs/job_3.conf",
      "job_type": "__Assembly__",
      "pipeline_tracker": "/parent_dir/assembly_job_tracker.conf"
    },
    {
      "approval_required": true,
      "config_file": "/parent_dir/annotation_jobs/job_1.conf",
      "job_type": "__Annotation__",
      "pipeline_tracker": "/parent_dir/annotation_job_tracker.conf"
    },
    {
      "approval_required": false,
      "config_file": "/parent_dir/mapping_jobs/job_1.conf",
      "job_type": "__Mapping__",
      "pipeline_tracker": "/parent_dir/mapping_job_tracker.conf"
    },
    {
      "approval_required": false,
      "config_file": "/parent_dir/mapping_jobs/job_2.conf",
      "job_type": "__Mapping__",
      "pipeline_tracker": "/parent_dir/mapping_job_tracker.conf"
    }
  ]
}Testing./run_tests.shDependenciesTests require:mockpath_pipe_conf_tools has been tested on Ubuntu 12.04 with python
2.7.3
Package: path-planning-kholysa
A* Path Planning PackageOverviewThis is a simple package to plan a path for a quadcopter. It exposes 2 methodsSet barriersGet PathInstallationRequires:Python 3.6pippython venvLinux & windows & MacOS environmentsCreate a python virtual environment somewhere in your documents. Run the Instructions below OR follow this guidehttps://docs.python.org/3/tutorial/venv.htmla) Run this commandpython3 -m venv venvNameto create a python3 virtual environment.b) Run this command cdvenvNameto move into the virtual environement.c)i. (Linux only, required)Run this command source `myenv\Scripts\activate` to source the virtual environment's python installation. Your terminal should now show your venvName before each line.

ii. (Windows only, required)Run this command source `bin/activate` to source the virtual environment's python installation. Your terminal should now show your venvName before each line.Install the requried pip packages. Run the Instructions belowa) (Linux only, optional)Run this commandwhich pip. Make sure the output points to a file that is in your venv.b) Run this commandpip install matplotlib numpyto install the required packages.How to use in CopterMove scriptStepsTest the script
a) Run the script
b) Make sure that the output on the graph looks goodPackage into a library and upload to the "Pypi" library repository; full documentation is herehttps://packaging.python.org/tutorials/packaging-projects/a)python3 setup.py sdist bdist_wheelb)pip install twinec) Increment the version number insetup.pyc)twine upload dist/*Install this library in the CopterMove script
a) Step3)a)herehttps://github.com/kholysa/CopterMove#linux-and-macos-environments
Package: pathquery
PathQuery is a tool to declaratively define file searches that returns a list
ofpath.pyPath objects.ExampleSearch for all files recursively except in the node_modules folder and change its perms:frompathqueryimportpathqueryforpathinpathquery("yourdir").ext("js")-pathquery("yourdir/node_modules"):path.chmod(0755)InstallTo use:$ pip install pathqueryAPIPath properties can be inspected as part of the query:pathquery("yourdir").is_dir()pathquery("yourdir").is_not_dir()pathquery("yourdir").is_symlink()pathquery("yourdir").is_not_symlink()Queries are also chainable:forpathinpathquery("yourdir").ext("pyc").is_symlink()-pathq("yourdir/node_modules"):path.remove()
Package: pathscan
FSSwill recursively scan the given directory for matching files and yield results as a generator. You may provide a list of include/exclude rules for files and/or directories.The searching is done asynchronously from another process. This way, the searching and whatever you’re doing with the results may potentially run in parallel.UsageAs LibraryExample:importfss.constantsimportfss.config.logimportfss.orchestratorroot_path='/etc'filter_rules=[(fss.constants.FT_DIR,fss.constants.FILTER_INCLUDE,'init'),(fss.constants.FT_FILE,fss.constants.FILTER_INCLUDE,'net*'),(fss.constants.FT_FILE,fss.constants.FILTER_EXCLUDE,'networking.conf'),]o=fss.orchestrator.Orchestrator(root_path,filter_rules)for(entry_type,entry_filepath)ino.recurse():ifentry_type==fss.constants.FT_DIR:print("Directory: [%s]"%(entry_filepath,))else:# entry_type == fss.constants.FT_FILE:print("File: [%s]"%(entry_filepath,))Output:Directory: [/etc/init]
File: [/etc/networks]
File: [/etc/netconfig]
File: [/etc/init/network-interface-container.conf]
File: [/etc/init/networking.conf]
File: [/etc/init/network-interface-security.conf]
File: [/etc/init/network-interface.conf]Notice that even though we only include directories named “init” we’ll still see matching files from the root-path.As ScriptYou can also useFSSfrom the command-line. You’ll get a printout of the results that you can consume and parse.Example:$ pathscan -i "i*.h" -id php /usr/include
F /usr/include/iconv.h
F /usr/include/ifaddrs.h
F /usr/include/inttypes.h
F /usr/include/iso646.h
D /usr/include/phpRequirementsPython 3.4InstallationPyPI:$ sudo pip3 install pathscan
Package: pathschema
Path SchemapipinstallpathschemaCheck out the online demo!How to usefrompathschemaimportvalidateschema='YOUR SCHEMA HERE'path_to_validate='./path'withopen('path/to/schema.pathschema','r')asf:schema=f.read()result=validate(path_to_validate,schema)if(result.has_error()):print('Invalid')else:print('Valid')SyntaxSymbolDescriptionExample/Slashes at the end of the name marks this path as a folderroot/""Quotes adds regex validation to the file name"file[0-9]{3}"""/Quotes with a slash adds regex validation to the folder name"folder[0-9]{3}"/*Unix style pattern matching for files*.txt*/Unix style pattern matching for folderslog_*/...Allows any (and nested) files and folder...+A+at the start makes the file or folder required+required_file.txt-A-at the start makes the file or folder forbidden-forbidden_folder/#Write a comment# cool commentCommand linepathschema can be used directly in the command line.python-mpathschema./.pathschemapath/to/dir/to/validateArgument details:usage: __main__.py [-h] [--errors-only] schema directory

Validate a directory against a schema

positional arguments:
  schema         Path to schema file
  directory      Path to directory to validate

options:
  -h, --help     show this help message and exit
  --errors-only  Only show errorsDevelopmentInstallingpython-mpipinstall-r./requirements.txt
python-mbuild
python-mpipinstall-e.Running testspython-munittestdiscover-v-s./tests-ptest_*.pyCommand line without installingpython./pathschema/./tests/experimentations/test_schema.pathschema./tests/experimentations/test_directory_okExample Schema DefinitionExample:assets/
	textures/
		*.gif
		*.png
	materials/
		"(trans|solid)_.+\.mat"
	+README.mdOnly allows.mp4or.flvin thevideosfoldervideos/
	*.mp4
	*.flvThis structure would be valid.videos/
	robots.mp4
	planets.flv
	my-mix-tape.flvThis structure would be invalid.(.pngand.jpgis not allowed)videos/
	office.png
	robots.jpgAny files and folder allowed in theassetsfolderassets/
	...Any files and directories would be valid in theassetsfolder.assets/
	banner.png
	backgrounds/
		bg_black.png
		bg_white.pngMust have aREADME.mdfileexample/
	*/
		*
		+README.mdThis structure would be valid.example/
	things/
		file.txt
		README.md
	morethings/
		README.mdThis structure would be invalid. (MissingREADME.md)example/
	things/
		file.txt
	morethings/
Package: pathsearch
pathsearchA script to search for a file in a list of directories.InstallYou can install this script from PyPi with your favorite package manager.
For example:pip install pathsearch
poetry add pathsearchOr you can install it from source:# clone the repositorygitclonehttps://github.com/mrlegohead0x45/pathsearch/# or if you have github clighrepoclonemrlegohead0x45/pathsearchcdpathsearch# install the packagepipinstall-e.# or you can just run it directlypythonpathsearch.pyUsage$ pathsearch -h
usage: pathsearch [-h] [-V] [-pe] [-v | -q] (-p PATH | -e VAR) file

Search for a file in a list of directories

positional arguments:
file                  File to search for on the specified path

options:
-h, --help            show this help message and exit
-V, --version         show program's version number and exit
-pe, --pathext        Look for file with extensions in environment variable PATHEXT (normally only set on Windows) (default: False)
-v, --verbose         Be verbose
-q, --quiet           Be quiet (only print found files)
-p PATH, --path PATH  Literal path to look in (e.g. /usr/bin:/bin:/usr/sbin:/sbin)
-e VAR, --env VAR     Environment variable to take path to search from (e.g. PATH or LD_LIBRARY_PATH)

Copyright (c) 2022 mrlegohead0x45. Licensed under the MIT License, which can be found in the source code of this program, or online at https://opensource.org/licenses/MIT. This program can be found online at
https://github.com/mrlegohead0x45/pathsearch and https://pypi.org/project/pathsearch/You can specify a literal path to look in with the-por--pathoption.
Or, you can specify an environment variable to take the path from with the-eor--envoption.
The-peor--pathextoption is generally only useful on Windows,
and will look for files with extensions in the PATHEXT environment variable, for example,pathsearch-pe-ePATH cmdwill look forcmd.exe,cmd.bat,cmd.cometc. in the path.
Seehttps://superuser.com/questions/1027078/what-is-the-default-value-of-the-pathext-environment-variable-for-windowsfor more information.LicenseThis project is licensed under the MIT license,
the text of which is available athttps://opensource.org/licenses/MITand in theLICENSE file.
Package: pathsimanalysis
PathSimAnalysisLatest releaseStatusCommunityCalculates the geometric similarity of molecular dynamics trajectories using path metrics such as the Hausdorff and Fréchet distances.PathSimAnalysis is bound by aCode of Conduct.Installation from packagesWith conda from conda-forgeEnsure that you havecondainstalled.You can installpathsimanalysis from the conda-forge channelwithconda install -c conda-forge pathsimanalysisor alternatively withmambaif you have it installed:mamba install -c conda-forge pathsimanalysisInstall from PyPIThe latest release of PathSimAnalysis is available onPyPIand can be installed with:pip install pathsimanalysisInstallation from sourceTo build PathSimAnalysis from source,
we highly recommend using virtual environments.
If possible, we strongly recommend that you useAnacondaas your package manager.
Below we provide instructions both forcondaand
forpip.With condaEnsure that you havecondainstalled.Create a virtual environment and activate it:conda create --name pathsimanalysis
conda activate pathsimanalysisInstall the development and documentation dependencies:conda env update --name pathsimanalysis --file devtools/conda-envs/test_env.yaml
conda env update --name pathsimanalysis --file docs/requirements.yamlBuild this package from source:pip install -e .If you want to update your dependencies (which can be risky!), run:conda update --allAnd when you are finished, you can exit the virtual environment with:conda deactivateWith pipTo build the package from source, run:pip install .If you want to create a development environment, install
the dependencies required for tests and docs with:pip install ".[test,doc]"CopyrightThe PathSimAnalysis source code is hosted athttps://github.com/MDAnalysis/pathsimanalysisand is available under the GNU General Public License, version 2 (see the fileLICENSE).Copyright (c) 2023, MDAnalysisAcknowledgementsProject based on theMDAnalysis Cookiecutterversion 0.1.
Please citeMDAnalysiswhen using PathSimAnalysis in published work.
Package: pathsjson
What is this?A JSON-based DSL for describing paths in your project.Why is this?My etl/data analysis projects are littered with code like,importosDATA_DIR="data"CLEAN_DIR=os.path.join(DATA_DIR,"clean")RAW_DIR=os.path.join(DATA_DIR,"raw")TARGET_HTML=os.path.join(RAW_DIR,"something.html")OUTPUT_FILE=os.path.join(CLEAN_DIR,"something.csv")withopen(TARGET_HTML)asfp:csv=process(fp)withopen(OUTPUT_FILE)asfp:write_csv(fp)It’s fine for one file, but when you have a whole ELT pipeline tucked
into aMakefile, the duplication leads to fragility and violates
DRY. It’s aREALLYcommon pattern in file-based processing. This
package and format lets you do create a.paths.jsonfile like,{"__ENV":{"VERSION":"0.0.1"},"DATA_DIR":["data","$$VERSION"],"CLEAN_DIR":["$DATA_DIR","clean"],"RAW_DIR":["$DATA_DIR","raw"],"SOMETHING_HTML":["$RAW_DIR","something.html"],"SOMETHING_CSV":["$RAW_DIR","something.csv"]}Then, from your python scripts,frompathsjson.automagicimportPATHSprint("Processing:",PATHS['SOMETHING_HTML'])withPATHS.resolve('SOMETHING_HTML').open()asfp:csv=process(fp)withPATHS.resolve('SOMETHING_CSV').open("w")asfp:write_csv(fp)InstallationpipinstallpathsjsonValidationThere is a.paths.jsonschema.
It’s validated withJSON-Schema.More detailsRead the docs:here.
Package: pathsolver
UsageTo Install this package. Use :pip install pathsolverTo launch the application :from pathsolver import solve

  maze = [[0, 0, 0, 0, 0, 0, 0, 0],
        [0, 0, 0, 0, 0, 0, 0, 0],
        [0, 0, 0, 0, 0, 0, 0, 0],
        [0, 0, 1, 1, 1, 1, 1, 0],
        [0, 1, 0, 0, 0, 0, 0, 0],
        [0, 0, 1, 0, 0, 0, 1, 0],
        [0, 0, 0, 0, 0, 0, 0, 0],
        [0, 0, 0, 0, 0, 0, 0, 0]]

  start = (5, 3)
  end = (2, 2)

  output, path = solve(maze, start, end)Credits: Nicholas-Swift (https://gist.github.com/Nicholas-Swift/003e1932ef2804bebef2710527008f44)Visit our GitHub Repository for more information: https://github.com/toshihiroryuu/PyPi--Package---pathsolver
Package: pathspider
More information can be found at the project homepage:https://pathspider.net/DocumentationFor information on how to get started, see thedocumentation.LicensePATHspider is released under the conditions of the GNU General Public
License version 2, or at your option, any later version.The full text of this license is available in the LICENSE file.AcknowledgementsCurrent development of PATHspider is supported by the European Union’s
Horizon 2020 project MAMI. This project has received funding from the
European Union’s Horizon 2020 research and innovation programme under
grant agreement No 688421. The opinions expressed and arguments employed
reflect only the authors’ view. The European Commission is not
responsible for any use that may be made of that information.
Package: pathstring
pathstring is a very small module that provides only one class
(pathstring.Path) which is a string with support for path operations.
Technically, it subclassesstrand delegates path related operations topathlib.Path.Differences from pathlib paths are:Paths are strings, no need to cast them to strings.No distinction between “pure” and “concrete” paths.No explicit distinction between Posix and Windows paths, but paths are
always “native” to their platform.Adds aPath.rmtree()method which invokesshutil.rmtree()on the path. Actually, since paths are strings,shutil.rmtree(path)will also work.Adds astrictparameter to thePath.relative_to()method
which, when set toFalse, will also navigate “up” in the hierarchy.No support for case-insensitive comparisons on Windows.NoPath.replace()method since it would cause confusion withstr.replace().Features are tested extensively againstpathlib documentationto guarantee
compatibility.LicenseCopyright (C) 2019 H. Turgut Uyar <uyar@tekir.org>pathstring is released under the BSD license. Read the includedLICENSE.txtfile for details.
Package: pathtool
Pathtool:  An efficient Python Path API===============================================================================:Author: Noah Gift:Version: $Revision: 0.1.0 $:Copyright: This document has been placed in the public domain.Summary---------Pathtool is an efficient API to walking a filesystem, and it aims to bevery simple, yet powerful.  By calling path you can pass it a path to afilesystem, apply an optional unix style pattern filter, and an optionalaction callback function.This allows you do to powerful things to a filesystem in one line of code!There is a record dictionary that contains useful key/value combinations suchas a unique_id hash, ctime, mtime, size, and extension.  These records can easilybe used to create custom action callbacks.  Additionally a future API will integratechainable actions... contents::Example Usage:------------------from pathtool import pathpath("/tmp", filter=".mp3")This would search the /tmp directory and return the path to all matches to the *.mp3pattern.  This is because it is using a default callback action that just prints outthe path to a match.  You can create your own callback and do things like create tararchives, delete files, move files, deduplicate files, compare sizes, etc.The API is subject to some small changes, so no promises for now.QUESTIONS:  noah dot gift at gmail.com------------------------------------------------------
Package: pathtools3
Pattern matching and various utilities for file systems paths.InstallingAs simple as:python3 -m pip install –upgrade –user pathtools3Or from sources:python3 -m pip install -e .TestingRequirements:python3 -m pip install pytest pytest-covAnd then:python3 -m pytestDeployingFor the maintainer, you will need to install wheel:python3 -m pip install wheelAnd the command to distribute the module is:python3 setup.py sdist bdist_wheel upload
Package: path-tracing
Path Tracing (WIP)A path tracing renderer in Python accelerated by OpenMP & CUDA.100,000 spp (1.5 min)50,000 spp (21 min)Getting StartedFirst of all, clone the repo recursively to your local environment.gitclone--recursivehttps://github.com/li-plus/path-tracing.git&&cdpath-tracingIf you miss the--recursiveargument, you could still fetch the submodules in this way.gitclonehttps://github.com/li-plus/path-tracing.git&&cdpath-tracing
gitsubmoduleupdate--initPython APIInstall the python package from source.sudoaptinstallgccg++cmakelibeigen3-devpython3-devpython3-pip
pipinstall.Run the Python example.cdexamples/python
python3main.py--devicecuda--num-samples1000--save-pathscene.png--scenecornell_boxC++ APIC++ API is not yet stable. Please consider using Python API instead for the time being.Install dependencies needed to build the C++ example.sudoaptinstallgccg++cmakelibeigen3-devlibopencv-devlibgflags-devBuild the path tracing library and the C++ example.mkdir-pbuild&&cdbuild
cmake..&&make-jRun the C++ example../bin/pt-devicecuda-num_samples1000-save_pathscene.png-scenecornell_boxDockerFor those who do not have root privilege, we offer an alternative to build & run path tracing within a docker container. For GPU support,nvidia-dockershould be further installed.Build a docker image with everything installed for development.dockerbuild./docker-tpt:latestStart a docker container, with project directory mapped to/opt/path-tracing.dockerrun-it--rm--runtimenvidia-v$PWD:/opt/path-tracing-w/opt/path-tracingpt:latestbashReferencessmallptscratchapixelRay Tracing in One WeekendSchlick's approximationCUDA Texture Funcions
Package: path-traveler
Travel any path and find some filespath-traveleris a simple package to walk and travel from any root path directory into all of its children directories and files coming in the journey and perform search operation to list down all available path(s) of the file(s).Use in python codeFollowing are some of the sample examples to show the use of thepath-travelerpackage. This package has a function namedtravellingwhich takes optional input 2 arguments.root_pathis the first argument used to set the root directory path andfindis the second argument used to search any file in the root directory and all of its children directories. The default isNonewhich searches all files fromroot_path. Let's take a look.>>> from path_traveler import travelling

>>> root_path = './sample'
    
>>> find = 'spec.json'

>>> journey = travelling(root_path=root_path, find=find)

>>> journey._fields
('root_path', 'cwd', 'absolute_paths', 'relative_paths', 'travel')

>>> root_path = journey.root_path

>>> current_working_directory = journey.cwd

>>> absolute_paths = journey.absolute_paths

>>> relative_paths = journey.relative_paths

>>> traveller = journey.travelUse in command line interface (CLI)path_traveler --helpUsage: path-traveler [OPTIONS]

Options:
  -P, --root_path TEXT            Any path from which you want to start
                                  travelling. If None is given then the root
                                  directory of this module will act as root
                                  path. The default is None.

  -F, --find TEXT                 Find any file name which you want to
                                  identify no matter whether is it present in
                                  any of the subdirectories. If None is given
                                  all find will be searching. The default is
                                  None.

  -A, --show_absolute_paths BOOLEAN
                                  Print absolute paths  [default: (False)]
  -R, --show_relative_paths BOOLEAN
                                  Print relative paths  [default: (False)]
  -E, --show_examples BOOLEAN     Print predefined examples  [default:
                                  (False)]

  --help                          Show this message and exit.For more information please visitGitHubLicenseMIT License
Package: pathtree
pathtreeInstallationpip install pathtreeExampleUse in ShellRun commandfind pathtree | python pathtreewill print this:pathtree
├── pathtree.py
├── __main__.py
├── __pycache__
│   ├── pathtree.cpython-36.pyc
│   └── __main__.cpython-36.pyc
└── __init__.pyUse ProgrammaticallyfrompathtreeimportTree# Inittree=Tree()# Add pathtree.add_path(<path>)# Print treeprint(tree.dump())LicenseThe MIT License.