Saravanan666/pypi-org huggingface dataset:
Package: repulsiveruby
RepulsiveRubyOverviewThis is a game I made with Python and Pygame in 2011.All sounds and images are created by me.Play the gameInstall with pipFirst install the game withpip:pip install repulsiverubyThen start the game:python -m repulsiverubyRun source codeDownload the code from GitHub andcdinto it:git clone git@github.com:wq2012/RepulsiveRuby.git

cd RepulsiveRubyStart the game with:python repulsiveruby
Package: repurpose
This package provides routines for the conversion of image formats to time
series and vice versa. It is part of thepoets projectand works best with the readers and writers
supported there. The main use case is for data that is sampled irregularly in
space or time. If you have data that is sampled in regular intervals then there
are alternatives to this package which might be better for your use case. SeeAlternativesfor more detail.The readers and writers have to conform to the API specifications of the base
classes defined inpygeobaseto work
without adpation.CitationIf you use the software in a publication then please cite it using the Zenodo DOI.
Be aware that this badge links to the latest package version.Please select your specific version athttps://doi.org/10.5281/zenodo.593577to get the DOI of that version.
You should normally always use the DOI for the specific version of your record in citations.
This is to ensure that other researchers can access the exact research artefact you used for reproducibility.You can find additional information regarding DOI versioning athttp://help.zenodo.org/#versioningInstallationThis package depends on the following libraries that can be installed via
conda or mambaconda install -c conda-forge numpy netCDF4 pyresampleAfterwards you can install this package and its pip dependecies via:pip install repurposeModulesIt includes two main modules:img2tsfor image/swath to time series conversion, including support for
spatial resampling.ts2imgfor time series to image conversion, including support for temporal
resampling. This module is very experimental at the moment.resamplefor spatial resampling of (regular or irregular) gridded data to different resolutions.AlternativesIf you have data that can be represented as a 3D datacube then these projects
might be better suited to your needs.PyReshaperis a package that works
with NetCDF input and output and converts time slices into a time series
representation.Climate Data Operators (CDO)can work with
several input formats, stack them and change the chunking to allow time series
optimized access. It assumes regular sampling in space and time as far as we
know.netCDF Operators (NCO)are similar
to CDO with a stronger focus on netCDF.ContributeWe are happy if you want to contribute. Please raise an issue explaining what
is missing or if you find a bug. We will also gladly accept pull requests
against our master branch for new features or bug fixes.Development setupFor Development we recommend acondaenvironmentGuidelinesIf you want to contribute please follow these steps:Fork the repurpose repository to your accountmake a new feature branch from the repurpose master branchAdd your featurePlease include tests for your contributions in one of the test directories.
We use py.test so a simple function called test_my_feature is enoughsubmit a pull request to our master branchNoteThis project has been set up using PyScaffold 2.4.4. For details and usage
information on PyScaffold seehttp://pyscaffold.readthedocs.org/.
Package: repustate
This is a Python client to the Repustate API. You must first get an API
key fromRepustate.comHere’s a simple example of how to use the Python client:>>> import repustate
>>> client = repustate.Client(api_key='YOUR_API_KEY')
>>> client.sentiment(text='I want the sentiment for this lovely text')
{"status":"OK", "score":0.3782}You can use the Repustate API to perform text analytics in multiple
languages including:ArabicChineseEnglishFrenchGermanItalianPolishPortugueseRussianSpanishMore coming soon …
Package: repvgg-pytorch
Repvgg-packaged 🎁A Python-packaged version of RepVGG: Making VGG-style ConvNets Great Again 🚀. The main contribution of this repo is to provide an easy-to-use backbone for RepVGG, which can be effortlessly used for downstream computer vision tasksThis project is based on the excellent original RepVGG implementation by authors Ding, Xiaohan et al. 🌟:GitHub repository (code)PaperInstall$pipinstallrepvgg-pytorchRepVGGUsage for Trainingimporttorchfromrepvgg_pytorchimportget_RepVGG_func_by_namefromrepvgg_pytorchimportrepvgg_model_convertrepvgg_name="RepVGG-A0-backbone"model_builder=get_RepVGG_func_by_name(repvgg_name)model=model_builder(deploy=False)x=torch.randn((1,3,512,512))out=model(x)# (1, 512, 64, 64]# Save the converted model for deploymentdeploy_model=repvgg_model_convert(model,save_path='RepVGG_deploy.pth')Usage for Deploymentimporttorchfromrepvgg_pytorchimportget_RepVGG_func_by_namerepvgg_name="RepVGG-A0-backbone"model_builder=get_RepVGG_func_by_name(repvgg_name)model=model_builder(deploy=True)model.eval()model.load_state_dict(torch.load('RepVGG_deploy.pth'))x=torch.randn((1,3,512,512))out=model(x)# (1, 512, 64, 64)RepVGG PlusUsage for Trainingimporttorchfromrepvgg_pytorch.repvggimportget_RepVGG_func_by_namefromrepvgg_pytorchimportrepvgg_model_convertrepvgg_name="RepVGG-A0-backbone"model_builder=get_RepVGG_func_by_name(repvgg_name)model=model_builder(deploy=False)x=torch.randn((1,3,512,512))out=model(x)# (1, 512, 64, 64]# Save the converted model for deploymentdeploy_model=repvgg_model_convert(model,save_path='RepVGGplus_deploy.pth')Usage for Deploymentimporttorchfromrepvgg_pytorch.repvggimportget_RepVGG_func_by_namerepvgg_name="RepVGG-A0-backbone"model_builder=get_RepVGG_func_by_name(repvgg_name)model=model_builder(deploy=True)model.eval()model.load_state_dict(torch.load('RepVGGplus_deploy.pth'))x=torch.randn((1,3,512,512))out=model(x)# (1, 320, 64, 64)References@inproceedings{ding2021repvgg,
title={Repvgg: Making vgg-style convnets great again},
author={Ding, Xiaohan and Zhang, Xiangyu and Ma, Ningning and Han, Jungong and Ding, Guiguang and Sun, Jian},
booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
pages={13733--13742},
year={2021}
}
Package: repyability
RePyabilityReliability Engineering ToolsThis is a series of tools created to make an open source set of methods to be used by reliability engineers to make it more accessible for students right through to practicing professionals.InstallRePyability can be installed via pip using the PyPIrepositorypipinstallrepyabilityTestingRun the testing suite by simply executing:pytestor use coverage to get a coverage report:coveragerun-mpytest# Run pytest under coverage's watchcoveragereport# Print coverage reportcoveragehtml# Make a html coverage report (really useful), open htmlcov/index.htmlPre-commitTL;DRPip installpre-commit(it's inrequirements.txtanyways)Runpre-commit installwhich sets up the git hook scriptsIf you'd like, runpre-commit run --all-filesto run the hooks on all filesWhen you go to commit, it will only proceed after all the hooks succeedWhy?To ensure the good code quality and consistency it is recommended that when contributing to this
repository to use the provided.pre-commit-config.yamlconfiguration for the Python packagepre-commit(https://pre-commit.com). Upon making a commit, it checks that imports
and requirements are sorted, syntax is up-to-date, code is formatted, linted, and statically type-checked,
all with the same tools and configurations as one another.
Package: repyexe
Reverse Python Exe (repyexe)DescriptionReverse Engineer Windows executable file compiled using Python.Usage$ repyexe <exe_files and pyc_files>from repyexe.decompile import decompile_exe

decompile_exe("samples/khaki.exe")The version of Python used must be the same minor version as the one used to compile the file. If a different one is chosen, the script will exit with a message telling you which version to use. Use pyenv or something similar to switch your Python version.For CX_Freeze files, the Python code is not located within the exe file but in pyc files in lib\library.zip, which needs to be manually extracted (using tools like uncompyle6).BackgroundThis script aims to automate the reverse engineering of malware for analysis as much as possible.Most of the Python executable files are compiled using Py2exe, PyInstaller or CX_Freeze. While this script aims to decompile any exe file, it is currently limited to only those compiled using these 3 libraries. A warning will be shown for exe files that do not match the signatures of files compiled using these libraries.This script can also bypass the following deobsfucation techniques (only enabled on Py2exe):NOP, ROT_TWO, ROT_THREE, LOAD_CONST & POP_TOPEXTENDED_ARGSupported FilesPython <= 3.7Limited support for Python 3.8Tested on files listed intested.mdPython 2 using Py2exePython 3 using Py2exePython 2 using Py2exe with obsfucationPython 3 using Py2exe with obsfucationPython 2 using PyInstallerPython 3 using PyInstallerPython 2 using PyInstaller --onefilePython 3 using PyInstaller --onefilePython 3 using CX_FreezeKnown IssuesSomeJUMPinstructions toEXTENDED_ARGinstructions result in an error in uncompyle6's ifelsestmt.py file. Make the followingchangesto the file.TODOAlso support folders created by the 3 libraries (which would also automate the reverse engineering of files created by CX_Freeze)Requirementsuncompyle6pefileCreditsRepo:PyInstaller Extractorby Extreme CodersRepo:bytecode_graphby Joshua Homan, MandiantArticle:Deobsfuscating Python Bytecodeby Joshua Homan, Mandiant
Package: repypi
RePyPIImagine, you just got hired to fix a legacy Python project. But the previous project maintainer did not bother to add versions to requirements.txt. If you know when was that project made, you can userepypito populaterequirements.txtwith what was newest at the time!repypiwill not touch any requirement lines that it fails to parse or that already have a version spec.InstallYou may install usingpip install repypiorpipx install repypiUsageExamplerequirements.txt# This is a comment
numpy
tensorflow
pandasRePyPI can modify requirements.txt to contain newest packages on 01/01/2018repypi-rrequirements.txt-d"01/01/2018"With the resulting file being:# This is a comment
numpy==1.14.0rc1
tensorflow==1.4.1
pandas==0.22.0Other examples# Get newest version of wget nowrepypi-pwget# wget==3.2# Get newest version of wget at 1st of January 2015repypi-pwget-d"01/01/2015"# wget==2.2
Package: repyrer
python-require (repyrer)Provides nodejs-style requiring of modules for pythonThis module allows imports of python modules using syntax similar to the node.jsrequirefunction. In particular, it takes string arguments comprised of (optionally) a
UNIX-style directory path and a module name, and returns a reference to the
loaded module. Specifying no directory path will have the module import
attempted first in the current working directory, then on the python path
variable (sys.path), allowing both local-to-the-folder imports and standard
library imports (as well as anything else you've configured intosys.path).
If an (absolute) directory path is included (i.e. a leading/in the directory path),
the module will first be attempted to be loaded from that directory first,
then the rest of thesys.pathas a fallback. If a relative directory path
is provided (likelib/module_nameor../other_lib/module_name) the current
working directory is used to resolve the relative path.NOTE: the leading./characters on a directory path (as in./lib/module_name) indicate that the directory path should be resolved
relative to the current file NOT the current working directory. For example,
suppose you have the following file structure:top_folder
|-----main.py
|-----lib
  |-----A.py
  |-----sub_lib
    |-----B.pySupposemain.pyimportsA.pyas a module, andA.pyin tern importsB.pyas a module. Inside ofA.py, it should useB = repyre('./sublib/B'),
NOTB = repyre('sublib/B')since the latter will fail whenmain.pyimportsA.py(because the current working directory will betop_folderNOTlib). However,main.pyis free to importA.pyasA = repyre('lib/A')orA = repyre('./lib/A')providedmain.pywill only ever be run directly
as a script fromtop_folder.Example UsageYou can userepyrerexactly as you wouldimportto access the standard library,
and anything else you might havepipinstalled:>>>fromrepyrerimportrepyre>>>os=repyre('os')# import standard library>>>np=repyre('numpy')# import other libraries installed with pip, etc.>>>plt=repyre('matplotlib.pyplot')# import sub-modules using '.' notationYou can also specify a directory path (relative to the current working directory, or absolute)
preceding the module name to access local libraries, suppose you have a file structure like:folder
|----CWD
  |----main.py
  |----adjacent_file.py
  |----my_dev_lib
    |-----module_A.py
|----my_other_lib
  |-----module_B.pyThen, in the python shell>>>adjacent=repyre('adjacent_file')# import other files relative to the CWD>>>A=repyre('my_dev_lib/module_A')# import modules from a relative directory path (relative to CWD)>>>B=repyre('../my_other_lib/module_B')# can use '..' in directory pathsAnd in a script likemain.py:fromrepyrerimportrepyreadjacent=repyre('adjacent_file')# only works if script is run in this folderadjacent=repyre('./adjacent_file')# safe to run from anywhere
Package: repyt
repytAutomatically re-run Python commands when files change.Installationpip install repytUsagerepyt [-h] [--command COMMAND] [args]Where:COMMAND             Any command to execute in the shell, as a string. This
                    doesn't even have to be a Python command!
args                Arguments as you would normally pass to the `python`
                    command.
-h or --help        Show this help message and exit.ExampleUse it just like you would use thepythoncommand:repyt hello_world.pyIncluding args is totally fine:repyt hello_world.py --world="Earth"This is equivalent to:repyt -c 'python hello_world.py --world="Earth"'The command arg doesn’t even have to be a Python command:repyt -c 'echo "Yo Adrian! I did it!"'Descriptionrepyt detects changes in the current directory and sub-directories, and re-runs
your Python script, application, or any other command when files are changed by
you or your editor.It kindly ignores hidden files and a bunch of other stuff that probably isn’t
important.You should use it just like you use thepythoncommand, if possible.ContactOn PyPI:http://pypi.python.org/pypi/repyt/Souce:https://github.com/di/repytIssues:https://github.com/di/repyt/issues
Package: repython
repython========repython is a utility to run a command and then restart it basedon filesystem changes. It's useful for quickly testing changes to arunning program. For instance, Django uses a similar but moresophisticated method to reload its source code when it detectsa change.repython uses the pyinotify library to make monitoring for changesefficient compared to just polling the filesystem.Installation------------Dependencies:* [pyinotify](https://github.com/seb-m/pyinotify)* [twiggy](http://hg.wearpants.org/twiggy/)You can install the repython module using:$ python setup.py installrepython is also available from the Cheeseshop:$ pip install repythonOr using setuptools:$ easy_install repythonUsage-----Basic example:$ python -m repython "python example.py"This would open the command in a subprocess and recursively monitorthe current working directory for any changed files matching the *.pyfilename pattern (default behavior).repython is not limited to running Python programs, so a command likethis should work as well:$ python -m repython "ruby example.rb" -p "*.rb" "*.txt"The `-p` or `--pattern` arguments determine which file changestrigger restarting the run command.The `-d` or `--directory` arguments allow monitoring other directoriesthan the current working directory. It can be used like this:$ python -m repython "python example.py" -d . ~/exampleThis command would make repython recursively monitor (i.e., includingsubdirectories) both the working directory and the`~/example` directory.The `-v` or `--verbose` argument can be used to get more detailedoutput from repython, and the `-q` or `--quiet` argument can be usedto suppress repython output.For more details please see:$ python -m repython --helpKnown issues------------[Python issue #9338](http://bugs.python.org/issue9338) causes theargument order to be wrong in the generated usage instructions(shown when using the `--help` argument). The `command` argument shouldcome before the optional arguments for the tool to work.
Package: req
Simple python module for loading and dumping structures in req format, a very
simple {string: (string|list(string))} format.Parses a structure like this:Foo|Bar
Baz_1|alpha
Baz_2|beta
Baz_3|gammainto:{'Foo':'Bar','Baz':['alpha','beta','gamma',],}The load and dump methods will maintain the encoding given and will not correct
on errors.  If you pass a utf-8 filehandle to load, you’ll get unicode output.
If you pass a bytestring filehandle to load, you’ll get bytestring output.
loads is the same, but with either a unicode or bytestring input.  dump will try
to do the same, and dumps will attempt to determine the type.  All dicts and
arrays are expected to be entirely homogeneous (either entirely composed of
unicode strings or entirely composed of byte strings).  To not enforce this in
the client side is undefined, and may be an explicit error in the future.
Another undefined action is to embed newlines in any strings.The only truly ambiguous case is dumps when given an empty dict.  In this case,
dumps will return an empty str object, which is unicode on Python 3 and bytes on
Python 2.For structures parsed into lists, the logic is as such:Any underscore and non-negative integer ending a key will automatically coerce
into an list.The actual values of the integers aren’t important.  They will be ordered
based on their decimal order.  Holes and starting index aren’t bothered with.If a field has an integer index given, but also has a non-indexed field of the
same name, the non-indexed field will be given top precedence (essentially an
index of -1)Output of lists is 1-indexed by default, but this may be changed via a kwarg.
If you need holes for whatever reason, you should pre-process the arrays into
regular dict mappings.This format is order-independent by default, but you may use an OrderedDict or
something to maintain order on reading and writing.  This does mean that dumping
and loading an object (or vice versa) aren’t guaranteed to yield the exact same
representation, but doing any 3 alternating operations in a row usually should.
Package: req2toml
Req2TomlAdding the dependencies fromrequirements.txttopyproject.tomlandpoetry.lockwith one command 😉Install$pipinstallreq2tomlUsagesThe entrypoint of the converter isreq2lockOptions-f[required]  The  path to therequirements.txt--install[optional] By default, it will only update the lock, add this flag to install the dependencies at the same time.--dev[optional] By default, the flag is disable, pass--devto add packages to dev section.-v: Enable verbose mode to print out the debug logs# Only update the poetry.lock$req2lock-frequirements.txt# Install$req2lock-frequirements.txt--install# To dev$req2lock-frequirements_test.txt--install--devContributingPR is always welcome <3
Package: reqcheck
Compare installed Python package versions with PyPI. Display the current
version, latest version and age for each installed package.Example output:Package    Current Version    Latest Version    Behind                             Age
---------  -----------------  ----------------  ---------------------------------  -------------------------------
certifi    2020.12.5          2020.12.5         latest                             ~ 53 days (2020-12-05)
chardet    3.0.4              4.0.0             -1 version (~ 3 years 186 days)    ~ 3 years 235 days (2017-06-08)
idna       2.5                3.1               -7 versions (~ 3 years 304 days)   ~ 3 years 328 days (2017-03-07)
requests   2.17.3             2.25.1            -15 versions (~ 3 years 201 days)  ~ 3 years 244 days (2017-05-29)
urllib3    1.21.1             1.26.3            -22 versions (~ 3 years 270 days)  ~ 3 years 272 days (2017-05-02)InstallationTo install reqcheck, simply use pip:$ pip install reqcheckUsageYou can check requirements directly using stdin:$ pip freeze | reqcheckYou can check requirements in a virtualenv:$ reqcheck -v /path/to/venvYou can check requirements on the command line:$ reqcheck requests==2.10.0 mock==2.0.0Set constraints that will cause the command to exit with an error status (for continuous integration):$ reqcheck --max-versions-behind 3 --max-days-behind 120 --max-age 365Display usage help:$ reqcheck --helpContributingCheck the pull requests to ensure that your feature hasn’t been
requested alreadyFork the repository and make your changes in a separate branchAdd unit tests for your changesSubmit a pull requestContact the maintainer
Package: reqchecker
reqcheckerCompare python package requirements across packages by reading the specified requirements files.InstallClone this repository:$ git clone https://github.com/robertson-mark/reqcheckerInstall:$ python setup.py installUsagereqchecker gathers requirements by using a.jsonfile formatted as:{
  "default": {
    "source": {"package": "path",
               "package": "path"}
            },

  "my-home": {
    "source": {"package": "path",
               "package": "path"}
            },

  "my-github": {
    "github": {"package": "branch",
               "package": "branch",
               "package": "branch"},
    "credentials": "<path_to_credentials.json>"
            }
}Adefaultfield is required, additional sections, in this casemy-localandmy-githubcan be added and called from the command line.sourcecan be ‘local’ or ‘github’If ‘local’, must supply ‘path’ to repositoryIf ‘github’, must also include ‘credentials’ and path to a credentials.json fileThe credentials.json file looks like:{
  "user": "github_user",
  "token": "github_token"
}To use by calling the"defaults"section:$ reqcheckerTo change the section to read from the saved settings in"my-home":$ reqchecker --section my-homeThe user can also overwrite sections by including –packages and –locations with themy-homeoption, and –packages and –branches with thegithuboption.To call using a different .json than is in this repository:$ reqcheckert --file <file>History0.1.0 (2019-12-12)0.2.0 (2019-12-16)Check local and GitHub sources for package versions in requirements.txt filesBasic .json formatting checkInclude terminal output for mismatched package versions
Package: reqcheq
ReqCheqUse this module to automatically verify and install referenced modules you are using in your project. It's a script made to easy the process of first running a program in a fresh environment.InstalationpipinstallreqcheqUsageimportreqcheqMake arequirements.txtnext to your main file, from which you are going to import reqcheq.
Each line is an item. It can have 1 or 2 words.1st word: import name of the module. If install name is equal to import name, you can leave only this single word. (if youimport flask, you should just addflaskto your requirements.txt)2nd word: install name of the module. If your module is imported by a different name than it is installed you add the install name after the 1st word. (if youimport dotenv, you should adddotenv python-dotenvto your requirements.txt)ReqCheq will then automatically try to import given modules and if it fails, will try to install it with pip (windows) or pip3 (linux).