Saravanan666/pypi-org huggingface dataset:
Package: reproducibly
reproducibly.pyIntroduction / Reproducibly build Python packages.This project is a convenient wrapper aroundbuildandcibuildwheelthat sets
metadata like file modification times, user and group IDs and names, and file
permissions predictably. The code can be used from PyPI or as a singlefilewithinline script metadata.UsageCommand to run from PyPI and view help:pipx run reproducibly --helpCommand to run from a local file and view help:pipx run ./reproducibly.py --helpOutput:usage: repoducibly.py [-h] [--version] input [input ...] output

Reproducibly build Python packages

features:

- Builds a source distribution (sdist) from a git repository
- Builds a wheel from a sdist
- Resets metadata like user and group names and ids to predictable values
- By default uses the last commit date and time from git
- Respects SOURCE_DATE_EPOCH when building a sdist
- Single file script with inline script metadata or PyPI package

positional arguments:
  input       Input git repository or source distribution
  output      Output directory

options:
  -h, --help  show this help message and exit
  --version   show program's version number and exitDevelopmentThis project usesNox.Builds are run every day to check for reproducibility:To set up a development environment use:nox --session=devTo run unit tests and integration tests:nox
Package: reproj
reprojReproject shapely featuresReproj is a minimalistic package designed to do one thing: reproject shapely features with a single call. GeoPandas has a simpleto_crsmethod for GeoDataFrames which we aim to mirror in ease of use for standalone shapely features. To be honest, this isn't difficult to do using pyproj and shapely with a couple of lines of code, but we decided to make it even easier.Without reproj, you would use the following:importpyprojimportshapely.opsnew_transformer=pyproj.Transformer.from_crs(4326,32630)utm_shape=shapely.ops.transform(new_transformer.transform,wgs84_shape)With reproj, all you need is:fromreprojimportreprojutm_shape=reproj(wgs84_shape,4326,32630)To see other practical ways of usingreprojfor your application, check out theexamples.InstallationUsing pipThe latest version of reproj isavailable on PyPi, and can be installed with Pip:pipinstallreprojIf you'd like to install the latest development (alpha) release, there may be a newer version onTestPyPi:pipinstall-ihttps://test.pypi.org/simple/reprojFrom sourceTo install this package from source, first clone this repository, then use pip to install:gitclonegit@github.com:sgoodm/python-reproj.gitcdpython-reproj
pipinstall.ContributeNew issues are always welcome, and if you'd like to make a change, fork the repo and submit a pull request.Testing and CoverageWe use Pytest and Coveralls to run unit tests and track code coverage of tests. If you submit code, please make sure it passes existing tests and adds relevant testing coverage for new features.You can run tests and coverage checks locally, or you can fork the repository and utilize GitHub actions and Coveralls. To use GitHub actions and Coveralls, you'll need to add your forked repo to your own Coverall accounts and add your Coveralls token to your repository as a GitHub Secret (see below).To run tests and coverage checks locally, you can use the following commands:pipinstallpytestcoverage
coveragerun-mpytest./
coveragehtmlGitHub SecretsThere are three GitHub Secrets required to enable all of our GitHub Actions:COVERALLS_REPO_TOKEN - this is the API token for Coveralls, used for publishing code coverage reportsTEST_PYPI_API_TOKEN - this is the API token for TestPyPi, needed for publishing alpha releasesPYPI_API_TOKEN - this is the API token for PyPi, needed for publishing releasesNote: contributors do not need PyPi tokens; if you create a new release in a forked repo it will trigger a GitHub action that will attempt to publish to PyPi and fail.
Package: reproject
AboutThereprojectpackage is a Python package to reproject astronomical
images using various techniques via a uniform interface. Byreprojection, we mean the re-gridding of images from one world
coordinate system to another (for example changing the pixel resolution,
orientation, coordinate system). Currently, we have implemented
reprojection of celestial images by interpolation (likeSWARP), by the adaptive and
anti-aliased algorithm ofDeForest (2004), and by finding the
exact overlap between pixels on the celestial sphere (likeMontage). It can also reproject to/from
HEALPIX projections by relying on theastropy-healpixpackage.For more information, including on how to install the package, seehttps://reproject.readthedocs.io
Package: repromancy
:mage: repromancy :zombie:repromancyutilizes dark magic to make better reprs, especially when
dynamically creatingclassesandfunctions.What?In certain circumstances Python can give ugly reprs. For example, if we had a
packagespamthat had a submodulehamthat defined theHamclass. The
repr is:<class'spam.ham.Ham'>All good, but let's say we actually importHamdirectly in thespampackage, such that it is accessible asspam.Ham. In fact, this is the
interface we advertise to users, but when they do reprs on theirHamsthey
get this extrahammodule that they don't really care about! What we would
like to see is:<class'spam.Ham'>Since that is how we define our public API, the underlying modules aren't
really relevant.repromancyfixes this, and more.at a price...How?repromancy.castis used to perform the dark magic required to fix your
reprs. For a module, it's as simple as adding the following to thebottomof your module:if__debug__:importrepromancyrepromancy.cast(repromancy.CallingModule)delrepromancyThis will perform repromancy on everything within current module namespace.
Note that cast is recursive, it will follow everything it can, but will only
modify things in the same package as what wascaston.repromancy.castcan be used on most python objects (not builtins).Dynamic Classes and FunctionsLet's say we have afunctioncalledfactory, that returns a newly
createdclass(or it could be anotherfunction, but we'll use aclassin this example):>>>deffactory():...classClass:...pass...returnClass...>>>factory()<class'__main__.factory.<locals>.Class'>The default repr is not terribly useful, especially because all *classesgenerated by the factory will have the same repr unless explicitly defined
by the factory function itself. Let's say that in our module we call this
factory multiple times and give the results local names, thencast repromancyon the module:>>>ClassA=factory()>>>ClassB=factory()>>>importrepromancy>>>repromancy.cast(repromancy.CallingModule)>>>ClassA<class'__main__.ClassA'>>>>ClassB<class'__main__.ClassB'>repromancymakes the reprs more clear.:goat: Dark magic? :biohazard:repromancy, as its name implies, make use of some questionable methods to
get the results it does. Specifically, it monkey patches some cpython builtin
types, altering their __repr__ methods. This is aglobalchange to
the python interpreter which affects all modules and subinterpreters. As such,
it is recommended to only perform repromancy when __debug__ is defined.The specific changes are as follows:Instances oftypewill not display theirpackagein their repr if the
fully qualified name starts with '<' (another repr)functionsinclude the module in which they were defined in their repr, this is
to be consistent withobjectandtypereprsmethodsshow the repr for theirfunction, rather than just the name
Package: reproschema
Reproschema Python library and Command Line Interface (CLI)Installationreproschema requires Python 3.7+.pip install reproschemaCLI usageThis package installsreproschemaa CLI.$ reproschema
Usage: reproschema [OPTIONS] COMMAND [ARGS]...

  A client to support interactions with ReproSchema

  To see help for a specific command, run

  reproschema COMMAND --help     e.g. reproschema validate --help

Options:
  --version
  -l, --log-level [DEBUG|INFO|WARNING|ERROR|CRITICAL]
                                  Log level name  [default: INFO]
  --help                          Show this message and exit.

Commands:
  convert
  create
  serve
  validateDeveloper installationInstall repo in developer mode:git clone https://github.com/ReproNim/reproschema-py.git
cd reproschema-py
pip install -e .[dev]It is also useful to install pre-commit, which takes care of styling when
committing code. When pre-commit is used you may have to run git commit twice,
since pre-commit may make additional changes to your code for styling and will
not commit these changes by default:pre-commit install
Package: reprounzip
ReproZipis a tool aimed at simplifying the process of creating reproducible experiments from command-line executions, a frequently-used common denominator in computational science. It tracks operating system calls and creates a bundle that contains all the binaries, files and dependencies required to run a given command on the author’s computational environment (packing step).  A reviewer can then extract the experiment in his environment to reproduce the results (unpacking step).reprounzipThis is the component responsible for the unpacking step on Linux distributions.Please refer toreprozip,reprounzip-vagrant, andreprounzip-dockerfor other components and plugins.A GUI is available atreprounzip-qt.Additional InformationFor more detailed information, please refer to ourwebsite, as well as to ourdocumentation.ReproZip is currently being developed atNYU. The team includes:Fernando ChirigatiJuliana FreireRemi RampinDennis ShashaVicky Rampin
Package: reprounzip-docker
ReproZipis a tool aimed at simplifying the process of creating reproducible experiments from command-line executions, a frequently-used common denominator in computational science. It tracks operating system calls and creates a bundle that contains all the binaries, files and dependencies required to run a given command on the author’s computational environment (packing step).  A reviewer can then extract the experiment in his environment to reproduce the results (unpacking step).reprounzip-dockerThis is the component responsible for the unpacking step on different environments (Linux, Windows, and Mac OS X) by using aDockercontainer.  Please refer toreprozip,reprounzip, andreprounzip-vagrantfor other components and plugins.Additional InformationFor more detailed information, please refer to ourwebsite, as well as to ourdocumentation.ReproZip is currently being developed atNYU. The team includes:Fernando ChirigatiJuliana FreireRemi RampinDennis ShashaVicky Rampin
Package: reprounzip-qt
ReproZipis a tool aimed at simplifying the process of creating reproducible experiments from command-line executions, a frequently-used common denominator in computational science. It tracks operating system calls and creates a bundle that contains all the binaries, files and dependencies required to run a given command on the author’s computational environment (packing step).  A reviewer can then extract the experiment in his environment to reproduce the results (unpacking step).reprounzip-qtThis is a graphical user interface for the reprounzip package, allowing to unpack and run packed applications without having to use the command-line interface.Please refer toreprozipandreprounzipfor more information.Additional InformationFor more detailed information, please refer to ourwebsite, as well as to ourdocumentation.ReproZip is currently being developed atNYU. The team includes:Fernando ChirigatiJuliana FreireRemi RampinDennis ShashaVicky Rampin
Package: reprounzip-vagrant
ReproZipis a tool aimed at simplifying the process of creating reproducible experiments from command-line executions, a frequently-used common denominator in computational science. It tracks operating system calls and creates a bundle that contains all the binaries, files and dependencies required to run a given command on the author’s computational environment (packing step).  A reviewer can then extract the experiment in his environment to reproduce the results (unpacking step).reprounzip-vagrantThis is the component responsible for the unpacking step on different environments (Linux, Windows, and Mac OS X) by using aVagrantvirtual machine.Please refer toreprozip,reprounzip, andreprounzip-dockerfor other components and plugins.Additional InformationFor more detailed information, please refer to ourwebsite, as well as to ourdocumentation.ReproZip is currently being developed atNYU. The team includes:Fernando ChirigatiJuliana FreireRemi RampinDennis ShashaVicky Rampin
Package: reprounzip-vistrails
ReproZipis a tool aimed at simplifying the process of creating reproducible experiments from command-line executions, a frequently-used common denominator in computational science. It tracks operating system calls and creates a bundle that contains all the binaries, files and dependencies required to run a given command on the author’s computational environment (packing step).  A reviewer can then extract the experiment in his environment to reproduce the results (unpacking step).reprounzip-vistrailsThis is a plugin that creates VisTrails workflows from unpacked experiments. See theVisTrails websitefor more information about VisTrails.Please refer toreprozipandreprounzipfor other components.Additional InformationFor more detailed information, please refer to ourwebsite, as well as to ourdocumentation.ReproZip is currently being developed atNYU. The team includes:Fernando ChirigatiJuliana FreireRemi RampinDennis ShashaVicky Rampin
Package: reprozip
ReproZipis a tool aimed at simplifying the process of creating reproducible experiments from command-line executions, a frequently-used common denominator in computational science. It tracks operating system calls and creates a bundle that contains all the binaries, files and dependencies required to run a given command on the author’s computational environment (packing step).  A reviewer can then extract the experiment in his environment to reproduce the results (unpacking step).reprozipThis is the component responsible for the packing step on Linux distributions.Please refer toreprounzip,reprounzip-vagrant, andreprounzip-dockerfor other components and plugins.Additional InformationFor more detailed information, please refer to ourwebsite, as well as to ourdocumentation.ReproZip is currently being developed atNYU. The team includes:Fernando ChirigatiJuliana FreireRemi RampinDennis ShashaVicky Rampin
Package: reprozip-jupyter
ReproZipis a tool aimed at simplifying the process of creating reproducible experiments from command-line executions, a frequently-used common denominator in computational science. It tracks operating system calls and creates a bundle that contains all the binaries, files and dependencies required to run a given command on the author’s computational environment (packing step).  A reviewer can then extract the experiment in his environment to reproduce the results (unpacking step).reprozip-jupyterThis package provides tracing and reproduction of Jupyter notebooks, allowing one to pack all the libraries and data used in their notebook to allow anyone to re-run it easily.You can use it from the command-line:# Trace & pack
$ reprozip-jupyter trace mynotebook.ipynb
$ reprozip pack notebook_environment.rpz

# Unpack and reproduce
$ reprounzip docker setup notebook_environment.rpz /tmp/notebook
$ reprozip-jupyter run /tmp/notebookOr you can pack directly from the Jupyter notebook interface, if you enable the extension:$ jupyter nbextension install --py reprozip_jupyter --user
$ jupyter nbextension enable --py reprozip_jupyter --user
$ jupyter serverextension enable --py reprozip_jupyter --userPlease refer toreprozipandreprounzipfor more information.Additional InformationFor more detailed information, please refer to ourwebsite, as well as to ourdocumentation.ReproZip is currently being developed atNYU. The team includes:Fernando ChirigatiJuliana FreireRemi RampinDennis ShashaVicky Rampin
Package: repr-rw
FRANÇAISCette bibliothèque écrit la représentation d'objets Python dans un fichier
texte et lit le fichier pour recréer les objets. Une représentation d'objet
est une chaîne de caractères renvoyée par la fonctionrepr.ContenuLa fonctionwrite_reprsécrit la représentation d'objets Python dans un
fichier texte. Chaque ligne du fichier est une représentation d'objet. Si le
fichier spécifié existe déjà, cette fonction l'écrase.La fonctionread_reprslit les fichiers texte qui contiennent des
représentations d'objet Python dans le but de recréer ces objets. Chaque ligne
doit être une représentation d'objet. Les lignes vides sont ignorées.Consultez la documentation des fonctions et les démos dans le dépôt de code pour
plus d'informations.DémosLe scriptdemo_write.pymontre comment utiliser la fonctionwrite_reprs. Il
faut l'exécuter en premier, car il produit un fichier dontdemo_read.pya
besoin.Le scriptdemo_read.pymontre comment utiliser la fonctionread_reprs. Il
faut l'exécuter aprèsdemo_write.py, car il ne fonctionne pas sans le fichier
produit par cet autre script.ENGLISHThis library writes Python object representations in a text file and reads the
file to recreate the objects. An object representation is a string returned by
functionrepr.ContentFunctionwrite_reprswrites the representation of Python objects in a text
file. Each line in the file is an object representation. If the specified file
already exists, this function overwrites it.Functionread_reprsreads text files that contain the representation of
Python objetcs in order to recreate those objects. Each line must be an object
representation. Empty lines are ignored.Consult the functions' documentation and the demos in the code repository for
the complete information.DemosScriptdemo_write.pyshows how to use functionwrite_reprs. It must be
executed first because it makes a file thatdemo_read.pyneeds.Scriptdemo_read.pyshows how to use functionread_reprs. It must be
executed afterdemo_write.pybecause it cannont work withoud the file made by
that other script.
Package: reprshed
A toolshed for writing great__repr__methods quickly and easily.Replace boilerplate like this:@reprlib.recursive_repr('<...>')def__repr__(self):returnf'{type(self).__name__}({self._foo!r}, bar={self._bar!r})'with just this:def__repr__(self):returnreprshed.pure(self,self._foo,bar=self._bar)VersioningThis library’s version numbers follow theSemVer 2.0.0
specification.Installationpip install reprshedUsageImport:importreprshedFor a “pure” class (a class whose exact state can be recreated purely
by passing the right constructor arguments), usereprshed.pure.For an “impure” class (a class whose exact state is not reproducible),
usereprshed.impure.Examples!>>>classMyClass:...def__init__(self,foo,bar,qux):...self._foo=foo...self._bar=bar...self._qux=qux...def__repr__(self):...returnreprshed.pure(self,self._foo,self._bar,self._qux)The first argument toreprshed.puremust beself, becausereprsheduses that to get the class name. All other arguments
are formatted as arguments to that class constructor:>>>MyClass('foo','bar',qux='qux')MyClass('foo','bar','qux')Formatting therepras constructor keyword arguments is easy too:>>>classMyClass:...def__init__(self,foo,bar):...self._foo=foo...self._bar=bar...def__repr__(self):...returnreprshed.pure(self,foo=self._foo,bar=self._bar)...>>>MyClass(1,bar='qux')MyClass(foo=1,bar='qux')You also get recursion protection automatically on all
common Python implementations:>>>classMyClass:...def__init__(self,number,foo):...self.number=number...self.foo=foo...def__repr__(self):...returnreprshed.pure(self,self.number,foo=self.foo)...>>>my_instance=MyClass(1,'whatever')>>>my_instanceMyClass(1,foo='whatever')>>>my_instance.foo=my_instance>>>my_instanceMyClass(1,foo=<...>)>>>my_instance.foo=MyClass(2,[None,my_instance,3,'4'])>>>my_instanceMyClass(1,foo=MyClass(2,foo=[None,<...>,3,'4']))Usingreprshed.impureis the same, only the output format changes:>>>classMyClass:...def__repr__(self):...returnreprshed.impure(self,1234,'foo',bar=0,qux='qux')...>>>MyClass()<MyClass1234'foo'bar=0qux='qux'>If you need to take more manual control, you can usereprshed.raw:>>>classMyClass:...def__repr__(self):...returnreprshed.impure(self,foo=5,bar=reprshed.raw('qux()'))...>>>MyClass()<MyClassfoo=5bar=qux()>By passingreprshed.rawas a positional argument, you can get
arbitrary formatting inside thereprif you really need to:>>>classMyClass:...def__repr__(self):...returnreprshed.impure(self,reprshed.raw('a b () c,{d,e}'))...>>>MyClass()<MyClassab()c,{d,e}>You can even usereprshed.rawto override the class name:>>>classMyClass:...def__repr__(self):...returnreprshed.impure(reprshed.raw('fake name'))...>>>MyClass()<fakename>
Package: repr-utils
REPR-UTILA toolkit to quickly display elements in tools likejupyterby building uponipython rich display.Contains simple objects that will automatically be converted to the right format based on the context.InstallationRunpip install repr-utilsExamplesLook atthe examples notebookSupports:Plain TextHTMLMarkdownLatexCurrent objects:HeaderTableListsRelevant links:pypigithubContributions are appreciated.
Package: repsci
Installing.pip install repsciImport the logging library.import repsciCreate an experiment. A unique directory will be created with the experiment
name, a timestamp, and the current git hash.exp_name = "hello_world"
exp = repsci.Experiment(exp_name)Get the logger and write a log message.log = exp.get_logger()
log.debug("Hello, World!")Create an output file in the unique output directory.filename = exp.get_filename('output.csv')
with open(filename, "wb") as f:
    f.write("Hello, World\n")The state of python's random number generator is stored inrandom_state.binin pickle format. This state can be used to reproduce the output of randomized
scripts.The Experiment constructor also has some optional parameters:note: a string of notes to store in anotes.txtfile in the output directory.config: a configparser object, which will exported to the output directory.output_dir: the subdirectory of the current directory to place experiment directories in.suffix: a string to append to the end of the trial's directory.Create an experiment from a previous experiment's unique directory.exp_name = "hello_world"
timestamp = "2020-09-09 152600"
exp = repsci.Experiment(exp_name, reproduce=timestamp)Get the config from the prevous experiment.config = exp.get_config()
Package: repsci-elplatt
Import the logging library.import repsciCreate an experiment. A unique directory will be created with the experiment
name, a timestamp, and the current git hash.exp_name = "hello_world"
exp = repsci.Experiment(exp_name)Get the logger and write a log message.log = exp.get_logger()
log.debug("Hello, World!")Create an output file in the unique output directory.filename = exp.get_filename('output.csv')
with open(filename, "wb") as f:
    f.write("Hello, World\n")The state of python's random number generator is stored inrandom_state.binin pickle format. This state can be used to reproduce the output of randomized
scripts.The Experiment constructor also has some optional parameters:config: a configparser object, which will exported to the output directory.output_dir: the subdirectory of the current directory to place experiment directories in.suffix: a string to append to the end of the trial's directory.
Package: reps-new
Release Engineering Project StandardThis repository:Defines the standard tools and workflows that Mozilla Release Engineering
endeavours to use across its projects.Implements areps-newbinary that can be used to bootstrap new projects based
on the defined standard.Project StandardPlease seeSTANDARD.mdfor
the REPS definition.UsageThereps-newtool can be used to bootstrap new projects that conform to this
standard. It is recommended to install and run it withpipx(so the most up to date version is always
used):pipxrunreps-newand fill out the prompts. By default, thepythonproject template is used.
You may optionally specify a different template to use with the-t/--templateflag:pipxrunreps-new-tbaseAvailable templates can be found in thetemplates directory.