Saravanan666/pypi-org huggingface dataset:
Package: pep517
WarningThe core of this package has been renamed topyproject-hooks. Please use that
package (low level) orbuild(higher level) in place ofpep517.PEP 517specifies a standard
API for systems which build Python packages.PEP 660extends it with a build
mode that leads to editable installs.This package contains wrappers around the hooks specified by PEP 517 and
PEP 660. It provides:A mechanism to call the hooks in a subprocess, so they are isolated from
the current process.Fallbacks for the optional hooks, so that frontends can call the hooks without
checking which are defined.Run the tests withpytestortox.Usage—you are responsible for ensuring build requirements are available:importosimporttomlifrompep517.wrappersimportPep517HookCallersrc='path/to/source'# Folder containing 'pyproject.toml'withopen(os.path.join(src,'pyproject.toml'),'rb')asf:build_sys=tomli.load(f)['build-system']print(build_sys['requires'])# List of static requirements# The caller is responsible for installing these and running the hooks in# an environment where they are available.hooks=Pep517HookCaller(src,build_backend=build_sys['build-backend'],backend_path=build_sys.get('backend-path'),)config_options={}# Optional parameters for backend# List of dynamic requirements:print(hooks.get_requires_for_build_wheel(config_options))# Again, the caller is responsible for installing these build requirementsdestination='also/a/folder'whl_filename=hooks.build_wheel(destination,config_options)assertos.path.isfile(os.path.join(destination,whl_filename))Deprecated high-levelFor now,pep517also contains higher-level functions which install the build
dependencies into a temporary environment and build a wheel/sdist using them.
This is a rough implementation, e.g. it does not do proper build isolation.
ThePyPA build projectis recommended as an
alternative, although it’s still quite young in October 2020.
This layer of functionality inpep517is now deprecated, but won’t be
removed for some time, as there is code relying on it.High level usage, with build requirements handled:importosfrompep517.envbuildimportbuild_wheel,build_sdistsrc='path/to/source'# Folder containing 'pyproject.toml'destination='also/a/folder'whl_filename=build_wheel(src,destination)assertos.path.isfile(os.path.join(destination,whl_filename))targz_filename=build_sdist(src,destination)assertos.path.isfile(os.path.join(destination,targz_filename))To test the build backend for a project, run in a system shell:python3-mpep517.checkpath/to/source# source dir containing pyproject.tomlTo build a backend into source and/or binary distributions, run in a shell:python-mpep517.buildpath/to/source# source dir containing pyproject.tomlAll of this high-level functionality is deprecated.
Package: pep543
This module contains the draft copy of the proposedtlsmodule fromPEP 543, the draft specification for the Unified TLS API for Python. This
module is used to centralize development of the API and to flesh out any
difficulties that may be encountered before the module makes it into the
standard library. Once the module is present in the standard library, this
module will become a formal “backport” of the module to support several other
Python versions.This module is under active development, and is not yet complete. Please
consider very carefully before you rely on it. On the other hand, please by all
means try it out and contribute feedback.LicenseThis module is made available under the MIT license. SeeLICENSEfor more
details.
Package: pep562
PEP 562OverviewA backport of PEP 562. Allows controlling a module's__dir__and__getattr__. Useful for deprecating attributes.
Works for Python 2.7+. And while it works on Python 3.7, it is recommended to use the official Python 3.7 implementation
where applicable.This module can be installed and used as a dependency, or if desired, it is easy to vendor as the license is quite
permissible, and the code is contained in a single file.Once Python 3.6 is end of life, this module will be irrelevant and will no longer receive active support.InstallInstallation is done withpip:pip install pep562VendoringSimply copy the filepep562/__init__.pyto your project and rename topep562.  Import and use as needed.UsageHere is a simple example where we deprecate the attributeversionfor the more standardized__version__.frompep562importpep562importwarnings__version__=(1,0,0)__all__=("__version__",)__deprecated__={"version":("__version__",__version__)}PY37=sys.version_info>=(3,7)def__getattr__(name):"""Get attribute."""deprecated=__deprecated__.get(name)ifdeprecated:stacklevel=3ifPY37else4warnings.warn("'{}' is deprecated. Use '{}' instead.".format(name,deprecated[0]),category=DeprecationWarning,stacklevel=stacklevel)returndeprecated[1]raiseAttributeError("module '{}' has no attribute '{}'".format(__name__,name))def__dir__():"""Module directory."""returnsorted(list(__all__)+list(__deprecated__.keys()))pep562(__name__)LicenseMIT LicenseCopyright (c) 2018 - 2021 Isaac Museisaacmuse@gmail.comPermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: pep567
PEP 567 BackportThis package implements a backport of Python 3.7contextvarsmodule (see PEP 567) for Python 3.6.Important:at this moment this package does not provide an
asyncio event loop with PEP 567 support yet.  Stay tuned for updates.Documentation:https://docs.python.org/3.7/library/contextvars.htmlUsage:try:importcontextvarsexceptImportError:importpep567ascontextvarsmy_var=contextvars.ContextVar('my_var')# ...LicenseApache 2.0.
Package: pep610
pep610A Python library for parsing theDirect URL Origin structurefrom installed packages.PEP 610initially specified how the Direct URL Origin of installed distributions should be recorded, but the up-to-date,canonical specificationis maintained on thePyPA specs page.Table of ContentsInstallationUsageLicenseInstallationpip install pep610UsageYou can usepep610.read_from_distributionto parse theDirect URL Origin structurefrom aDistributionobject:fromimportlibimportmetadataimportpep610dist=metadata.distribution("pep610")if((data:=pep610.read_from_distribution(dist))andisinstance(data,pep610.DirData)anddata.dir_info.is_editable()):print("Editable installation, a.k.a. in development mode")else:print("Not an editable installation")Or, in Python 3.10+ using pattern matching:fromimportlibimportmetadataimportpep610dist=metadata.distribution("pep610")matchdata:=pep610.read_from_distribution(dist):casepep610.DirData(url,pep610.DirInfo(editable=True)):print("Editable installation, a.k.a. in development mode")case_:print("Not an editable installation")DevelopmentThis project usesHatch.TestingRun the unit tests:hatchrunall:covCompute the coverage report:hatchruncoverage:reportLintingRun the linters:hatchenvrun--force-continue--env=lintallDocumentationBuild the documentation:hatchrundocs:buildLicensepep610is distributed under the terms of theApache License 2.0.
Package: pep621
pep621DEPRECATED! The project was renamed topyproject-metadata.Dataclass for PEP 621 metadata with support forcore metadatagenerationThis project does not implement the parsing ofpyproject.tomlcontaining PEP 621 metadata.Instead, given a Python data structure representing PEP 621 metadata (already
parsed), it will validate this input and generate a PEP 643-compliant metadata
file (e.g.PKG-INFO).UsageAfterinstallingpep621,
you can use it as a library in your scripts and programs:frompep621importStandardMetadataparsed_pyproject={...}# you can use parsers like `tomli` to obtain this dictmetadata=StandardMetadata.from_pyproject(parsed_pyproject)print(metadata.entrypoints)# same fields as defined in PEP 621pkg_info=metadata.as_rfc822()print(str(pkg_info))# core metadata
Package: pep8ify
Pep8ify is a library that modifies python source code to conform topep8.InstallationThis library currently works with python 2.7, 3.2, and 3.3.To install pep8ify, simply:$ pip install pep8ifyUsageTo print a diff of changes that pep8ify will make against a particular source
file or directory:$ pep8ify source_folderTo have those changes written to the files:$ pep8ify -w source_folderBy default, this will create backup files for each file that will be changed.
You can add the-noption to not create the backups. Please do not do this
if you are not using a version control system. Although this code is
well-tested, there are most likely bugs still.For more options about running particular fixers, read thelib2to3 documentation. This
library is built on top of that one.FixesA list of the available fixers can be found with the following:$ pep8ify -l
Available transformations for the -f/--fix option:
blank_lines
compound_statements
extraneous_whitespace
imports_on_separate_lines
indentation
maximum_line_length
missing_newline
missing_whitespace
tabs
trailing_blank_lines
trailing_whitespace
whitespace_around_operator
whitespace_before_inline_comment
whitespace_before_parametersAll of these are set to run by default except for ‘maximum_line_length’.
To run all fixes including ‘maximum_line_length’, run:$ pep8ify -f all -f maximum_line_length example.py
Package: pep8-naming
Check your code againstPEP 8naming conventions.This module provides a plugin forflake8, the Python code checker.(It replaces the pluginflint-namingfor theflintchecker.)InstallationYou can install, upgrade, uninstallpep8-namingwith these commands:$ pip install pep8-naming
$ pip install --upgrade pep8-naming
$ pip uninstall pep8-namingPlugin for Flake8When bothflake8andpep8-namingare installed, the plugin is
available inflake8:$ flake8 --version
4.0.1 (mccabe: 0.6.1, naming: 0.13.0, pycodestyle: 2.8.0, pyflakes: 2.4.0) CPython 3.8.10 on LinuxBy default the plugin is enabled.Error CodesThese error codes are emitted:codesample messageN801class names should use CapWords convention (class names)N802function name should be lowercase (function names)N803argument name should be lowercase (function arguments)N804first argument of a classmethod should be named ‘cls’
(function arguments)N805first argument of a method should be named ‘self’
(function arguments)N806variable in function should be lowercaseN807function name should not start and end with ‘__’N811constant imported as non constant (constants)N812lowercase imported as non-lowercaseN813camelcase imported as lowercaseN814camelcase imported as constant
(distinct fromN817for selective enforcement)N815mixedCase variable in class scope
(constants,method names)N816mixedCase variable in global scope (constants)N817camelcase imported as acronym
(distinct fromN814for selective enforcement)N818error suffix in exception names (exceptions)OptionsThe following flake8 options are added:--ignore-namesIgnore errors for specific names or glob patterns.Currently, this option can only be used for N802, N803, N804, N805, N806, N815, and N816 errors.Default:setUp,tearDown,setUpClass,tearDownClass,setUpModule,tearDownModule,asyncSetUp,asyncTearDown,setUpTestData,failureException,longMessage,maxDiff.--classmethod-decoratorsList of method decorators pep8-naming plugin should consider class method.Used to prevent false N804 errors.Default:classmethod.--staticmethod-decoratorsList of method decorators pep8-naming plugin should consider static method.Used to prevent false N805 errors.Default:staticmethod.
Package: pe-parser
PE ParserPE Parser is a Python (3.6+) library and a set of command-line tools for preprocessing Portable Executable (PE) files. The
goal of the library is to provide an intermediate representation of the PE files that allow for easy manipulation and
feature engineering. The main features include:Preprocessing of Portable Executable files in hexadecimal format or its assembly language source code.Extraction of well-known features for malware detection and classification.Tools to visualize malware as grayscale images or its structural entropy representation.For more information, check the documentation hosted onRead the docs.InstallThe easiest way to install PE Parser is to clone the repository as follows:git clone https://github.com/danielgibert/pe_parser.git
cd pe_parser
pip install -e .LicensePE Parser is free software made available under the MIT License. For details see theLICENSEfile.ContactIf you have any trouble please contactdaniel.gibertlla@gmail.com
Package: pepbox
pepbox======.. raw:: html<p>T cell activation that leads to a productive T-cell reaction against apathogen agent is linked to its T cell receptor (TCR) specificity. Theability of the TCR to distinguish between structurally unrelated tosimilar peptides defines the T cell specificity. The affinity drives thespecifcity. A T cell that binds to peptide-MHC complex with enoughaffinity will increase the magnitude of the immune response (i.e. T cellexpansion). Therefore, expansion is a powerful feature to measure TCRsspecifity. This application has the goal to quantify if T cellclonotypes (i.e. group of T cells sharing the same TCR) aresignificantly expanded by comparing their respective frequency beforeand after contact with a peptide. To improve performance of peptidespecific clonotypes selection, irrelevant peptide stimulated cultured Tcells or/and medium cultured T cells can be provided as negativecontrols. A list of reference TCRs known to be specific to the relevantpeptide (e.g. obtained from tetramer staining, IFNg capture) are used todefine optimal expansion thresholds for selecting positively andnegatively expanded T cells.. raw:: html</p>.Parameters==========usage:------pepbox.py [-h] [-merge] [-expansion] [-analyze] [-reproducibility][-aacdr3] [-genes_cdr3_aacln] [-optimize] [-timepoints] [-geneusage][-detailed] [-input_folder INPUT_FOLDER] [-output_folder OUTPUT_FOLDER][-workdir WORKDIR] [-nolog] [-compress] [-v] [–version] [-debug]optional arguments:--------------------  -h, –help show this help message and exit-  -merge Merge Adaptive Biotechnologies TCR sequencing txt file(default: False)-  -expansion Calculate expansion p-values using a Fisher exact test(default: False)-  -analyze Produce basic statistics summary tables and figures(default: False)-  -reproducibility Creating heatmap of reproducibility (default: False)-  -aacdr3 Define the clonotype at the amino acid cdr3 level (default:False)-  -genes_cdr3_aacln Define the clonotype at the amino acid cdr3 and V,J gene level (default: False)-  -optimize Creating negative control vs relevant peptide stimulatedclonotype p-value plot (default: False)-  -timepoints Analyzes samples from different time points (default:False)-  -geneusage Provide gene usage statistics (default: False)-  -detailed Provide more details-  -input_folder INPUT_FOLDER Input folder (default: current directory)-  -output_folder OUTPUT_FOLDER Output folder (default: currentdirectory)-  -workdir WORKDIR Folder where input and output files should be(default: current directory)-  -compress Compress output folder (default: False)-  -nolog Disable default log file (default: False)-  -v Turns on verbosity (more details)-  –version show program’s version number and exit-  -debug Debug using small input size to test specific cases.# Usage.. code:: python# Merge Adaptive Biotechnologies TCR sequencing txt formatted filespython pepbox.py -merge -workdir myworkdir# Common pipelinepython pepbox.py -merge -expansion -analyze -optimize -workdir myworkdir
Package: pepdata
Formerly a repository for diverse peptide datasets, now only contains
theImmune Epitope Databaseand a variety of
amino acid property matrices. This package will probably be eventually
split and the IEDB portions placed into something namedpyiedb.Amino Acid PropertiesTheamino_acidmodule contains a variety of physical/chemical
properties for both single amino residues and interactions between pairs
of residues.Single residue feature tables are parsed intoStringTransformerobjects, which can be treated as dictionaries or will vectorize a string
when you call their methodtransform_string.Examples of single residue features: -hydropathy-volume-polarity-pK_side_chain-prct_exposed_residues-hydrophilicity-accessible_surface_area-refractivity-local_flexibility-accessible_surface_area_folded-alpha_helix_score(Chou-Fasman) -beta_sheet_score(Chou-Fasman)
-turn_score(Chou-Fasman)Pairwise interaction tables are parsed into nested dictionaries, so that
the interaction between amino acidsxandycan be determined
fromd[x][y].Pairwise interaction dictionaries: -strand_vs_coil(and its
transposecoil_vs_strand) -helix_vs_strand(and its transposestrand_vs_helix) -helix_vs_coil(and its transposecoil_vs_helix) -blosum30-blosum50-blosum62There is also a function to parse the coefficients of thePMBEC
similarity matrix,
though this currently lives in the separatepmbecmodule.
Package: pepdocs
PepDocsRead PEPs in your consoleInstalling PepDocsPepDocs is available atPyPI. You can install it using Pip:$ python -m pip install pepdocsUsing PepDocsTo read a PEP in your console, use thepepcommand line command:$ pep 8Usepep --helpto see available options.You can also call PepDocs from your own scripts. In that case, usepepdocs.get():import pepdocs
pep8 = pepdocs.get(8)Installing From SourceYou can always download thelatest version of PepDocs from GitHub. PepDocs usesFlitas a setup tool.To install PepDocs from the downloaded source, run Flit:$ python -m flit install --deps productionIf you want to change and play with the PepDocs source code, you should install it in editable mode:$ python -m flit install --symlink
Package: pepe
pepe—a portable multi-language file preprocessor================================================There are tons of template systems. This is just a basic preprocessor.Pepe is usable both as a command line app and as a Python module.Pepe syntax is hidden within comments (whatever the syntax for commentsin the target file type), so that the file can still have valid syntax.Pepe syntax mimics that of the C preprocessor, but its behavior differs.Who is it for?--------------Pepe is targeted at **build systems** that deal with many types of files.Languages for which it works include:* C++* Python,* Perl* Tcl* XML* JavaScript* CSS* IDL* TeX* Fortran* PHP* Java* Shell scripts (Bash, CSH, etc.)* C#History-------Pepe began as a fork of Trent Mick's preprocess_ which has been used forbuild-time code differentiation in the Komodo_ build system, whichincludes source code in Python, JavaScript, XML, CSS, Perl, and C/C++.How it works------------All preprocessor statements are on their own line. A preprocessor statementis a comment (as appropriate for the language of the file being preprocessed).This way the preprocessor statements do not make an unpreprocessed filesyntactically incorrect.For example::pepe -D FEATURES=macros,scc code.pywill yield this transformation::...                                     ...# #if "macros" in FEATURESdef do_work_with_macros():              def do_work_with_macros():pass                                    pass# #elsedef do_work_without_macros():pass# #endif...                                     ...or, with a JavaScript file::...                                     ...// #if "macros" in FEATURESfunction do_work_with_macros() {        function do_work_with_macros() {}                                       }// #elsefunction do_work_without_macros() {}// #endif...                                     ...The ``#if`` expression (``"macros" in FEATURES`` in the example) is Pythoncode, so it has Python's full comparison richness.  A number ofpreprocessor statements are implemented::#define VAR [VALUE]#undef VAR#ifdef VAR#ifndef VAR#if EXPRESSION#elif EXPRESSION#else#endif#error ERROR_STRING#include "FILE"As well, pepe will do inline substitution of defined variables.Although, this is currently turned off by default because substitution occursin program strings, which is not ideal. When a future version ofpepe can lex languages being preprocessed it will NOT substituteinto program strings and substitution will be turned ON by default.Install Notes-------------Installing Pepe is easy::$ pip install pepeGetting Started---------------Using as a shell command::$ pepe --helpPepe can also be used as a module. Please see the documentation_for more information... _preprocess: http://code.google.com/p/preprocess/.. _Komodo: http://www.activestate.com/Komodo.. _documentation: http://packages.python.org/pepe/
Package: pepe-granular
Photoelastic Python EnvironmentPhoto-
elastic
Python
EnvironmentThis is a collection of tools for working with photoelastic particle images, including common analysis methods like particle tracking and community analysis.FeaturesCommon analysis techniques (G2, D2min, etc.)Particle trackingMasking and other preprocessing toolsSynthetic photoelastic response generationForce solving (as in PeGS [1a, 1b])InstallationThe library is available on PyPi:pip install pepe-granularIt can also be installed from the Github repository:git clone https://github.com/Jfeatherstone/pepe
cd pepe
pip install .DocumentationAvailablehere.RequirementsPython 3.11 is the recommended version to use, with the following packages:numpymatplotliblmfitscikit-learnopencvPillownumbatqdmThese can all be installed (alongside their dependencies) viapip:git clone https://github.com/jfeatherstone/pepe
cd pepe
pip install -r requirements.txtUsageThewikianddocumentationcontain information about how to use the toolbox. Test notebooks can be
found in the repo'snotebooksdirectory, and unit tests can be found in thepepe.testdirectory.Some of the test notebooks make use of the Matlab API to compare against Jonathan Kollmer's code [1a], but this is not required to use any functions in the library itself. Installing the Matlab API requires a local installation of Matlab proper; seeherefor more information.Further Reading and References[1] Daniels, K. E., Kollmer, J. E., & Puckett, J. G. (2017). Photoelastic force measurements in granular materials. Review of Scientific Instruments, 88(5), 051808.https://doi.org/10.1063/1.4983049[1a] Jonathan Kollmer's implementation in Matlab:https://github.com/jekollmer/PEGS[1b] Olivier Lantsoght's implementation in Python:https://git.immc.ucl.ac.be/olantsoght/pegs_py[2] Abed Zadeh, A., Barés, J., Brzinski, T. A., Daniels, K. E., Dijksman, J., Docquier, N., Everitt, H. O., Kollmer, J. E., Lantsoght, O., Wang, D., Workamp, M., Zhao, Y., & Zheng, H. (2019). Enlightening force chains: A review of photoelasticimetry in granular matter. Granular Matter, 21(4), 83.https://doi.org/10.1007/s10035-019-0942-2[3] Photoelastic methods wiki.https://git-xen.lmgc.univ-montp2.fr/PhotoElasticity/Main/-/wikis/homeorhttps://photoelasticity.net/