Saravanan666/pypi-org huggingface dataset:
Package: readme-patcher
readme_patcherGenerate README files from templates. Allow input from functions calls and cli
output.cdyour-projectvimREADME_template.rstpoetryadd--groupdevreadme-patcherpoetryshellreadme-patcher# README.rstGlobal objectspy_project{{py_project.repository}}github{{github.name}}{{github.full_name}}{{github.description}}badge{{badge.pypi}}{{badge.github_workflow('tests''Tests')}}{{badge.readthedocs}}Functionscli: Combined output (stdout and stderr) of command line interfaces (scripts / binaries){{cli('awk --help')}}func: return values of Python functions{{func('os.getcwd')}}read: read text files{{read('code/example.py')|code('python')}}Filterscode{{'print("example")'|code('python')}}.. code-block:: python

    print("example")literal{{func('os.getcwd')|literal}}::

    /home/repos/projectheading{{'heading 1'|heading(1)}}{{'heading 2'|heading(2)}}{{'heading 3'|heading(3)}}{{'heading 4'|heading(4)}}heading 1
=========

heading 2
---------

heading 3
^^^^^^^^^

heading 4
"""""""""Examples{%forcommandin['dns-ipv6-prefix.py','extract-pdftext.py','find-dupes-by-size.py','list-files.py','mac-to-eui64.py','pdf-compress.py','image-into-pdf.py']%}``{{command}}``{{cli('{} --help'.format(command))|literal}}{%endfor%}Configuration[[tool.readme_patcher.file]]src="README_template.rst"dest="README.rst"variables={cwd="func:os.getcwd",fortune="cli:fortune --help"}
Package: readme-preview
readme-previewA Jupyter notebook extension to render README.md markdown files in the folder view.
it loads the github style preview of README.md file if it exist in the current directory.install python packagepip install readme-previewInstall the notebook extensionjupyter nbextension install --py readme-previewemable the extensionjupyter nbextension enable --py readme-previewReferenceshttps://github.com/showdownjs/showdownused for converting markdown to HTML for preview
Package: readme-renderer
Readme Renderer is a library that will safely render arbitraryREADMEfiles into HTML. It is designed to be used inWarehouseto
render thelong_descriptionfor packages. It can handle Markdown,
reStructuredText (.rst), and plain text.Check Description LocallyTo locally check whether your long descriptions will render on PyPI, first
build your distributions, and then use thetwine checkcommand.Code of ConductEveryone interacting in the readme_renderer project’s codebases, issue trackers,
chat rooms, and mailing lists is expected to follow thePSF Code of Conduct.Copyright © 2014, [The Python Packaging Authority].
Package: readme-section
Installation$pipinstallreadme-sectionProsauto headingsnative,minimalistic,fast- only markdown files and shell scriptHow it worksmake README sections filesmake a shell script to build the README.md fileExamplesREADME.md.sh#!/usr/bin/env bash[-esetup.py]&&echo"badges ..."&&cat<<EOF### Installationpip install nameEOFreadme-section".readme/pros.md"readme-section".readme/how.md""How it works"readme-section".readme/examples.md"readme-section".readme/links.md"# optional. empty if file not exists$bash-lREADME.md.sh>README.mdbadges ...### Installationpip install name### Featuresfeatures.md content ...### How it workshow.md content ...
Package: readme-template-cli
README TemplateA template project / CLI tool for creating a README and other files for Python projects on GitHub.This project contains templates you can use to write your ownREADME,CONTRIBUTINGandPULL_REQUEST_TEMPLATEfiles.It also includes a CLI tool for using these files in your own projects.Supportspiporpoetryfor dependency management.Installpipinstallreadme-template-cliUsagereadme[-h][--test][--force]FlagDescription-h,--helpShow this help message and exit.--testRun in test mode - files created have .test extension. This does not update filename references inside the templates.--forceForce overwrite existing files.Run locallyInstall dependenciesIf usingpip:pipinstall-rrequirements.txtIf usingpoetry:poetryinstall--withoutdevUsageRun the program from the command line (from the project root) like this:If usingpip:python3readme_generator/src/generator.pyIf usingpoetry:poetryrunreadmeContributingFor information on how to set up your dev environment and contribute, seehere.LicenseMIT
Package: readmetester
Parse, test, and assert RST code-blocksInstallation$pipinstallreadmetesterUsagereadmetester[-h][--version][README.rst]If a README.rst file is present in the current working directory it will be used if no arguments are provided$readmetesterREADME.rstDocumentingPython code begins with">>>"Continuation lines begin with"..."NoteThe length of these strings is 4 including the whitespace at the endExpected output can be quoted or unquoted..code-block::python>>>n=[..."zero",..."one",..."two",...]>>>forc,iinenumerate(n):...print(c,i)0zero1one2twoStyles can be configured in a pyproject.toml file[tool.readmetester]style="monokai"
Package: readmint
readmintA simple, yet effective way of adding some dynamic properties to you md.Table of ContentsInstallationLicenseInstallationpip install readmintUsing it (shell)Using it (api)# import the render functionIn[1]:fromreadmint.lib.rendererimportrender_text,render_fileimporttextwrapprint("hello world")# render text just rendera passed textIn[2]:render_text(textwrap.dedent("""dummy text==========And this is a code block```readmint[python@local]1+1```"""))Out[2]:# dummy textAndthisisacodeblock```pythonIn[1]:1+1Out[1]:2## License

`readmint` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
Package: readmrz
readmrzreadmrzdetects the machine readable zone on ID cards and extracts the text in that zone.This zone contains the name, surname, date of birth, etc. of the person to whom the identity card was issued.
It has universal standards in new generation identity cards and passports.In conclusion,readmrzis a tool to read mrz code on identity cards and passports.InstallPlease installtesseractbefore installing the package,On macOS,$brewinstalltesseractOn Ubuntu,$sudoapt-getinstall-ytesseract-ocrOn Windows,$chocoinstalltesseractThen you can install the latest release,$pipinstallreadmrzUsage>>>importjson>>>fromreadmrzimportMrzDetector,MrzReader>>>detector=MrzDetector()>>>reader=MrzReader()>>>image=detector.read('/path/to/file')>>>cropped=detector.crop_area(image)>>>result=reader.process(cropped)>>>print(json.dumps(result)){"surname":"STEARNE","name":"JOHN TIMOTHY KELLY","country":"CAN","nationality":"CAN","birth_date":"580702","expiry_date":"240904","sex":"M","document_type":"P","document_number":"GA302922","optional_data":"","birth_date_hash":"0","expiry_date_hash":"3","document_number_hash":"0","final_hash":"2"}or using url,>>>importjson>>>fromreadmrzimportMrzDetector,MrzReader>>>detector=MrzDetector()>>>reader=MrzReader()>>>image=detector.read_from_url('/url/to/image')>>>cropped=detector.crop_area(image)>>>result=reader.process(cropped)>>>print(json.dumps(result)){"surname":"STEARNE","name":"JOHN TIMOTHY KELLY","country":"CAN","nationality":"CAN","birth_date":"580702","expiry_date":"240904","sex":"M","document_type":"P","document_number":"GA302922","optional_data":"","birth_date_hash":"0","expiry_date_hash":"3","document_number_hash":"0","final_hash":"2"}The result is returned as a dict so it's easy to access the fields. You can also use command-line,$readmrz-f/path/to/fileor using url,$readmrz-u/url/to/imageExamplePlease check to thenotebookto see the results step by step.ContributionPlease check to the pylint and flake8 steps in workflow before contribution.
Package: readonly
readonlyis a simple package to make any given module attributes into read only mode.🛠️ Requirementsreadonlyrequires Python 3.9 or above.To install Python 3.9, I recommend usingpyenv.# install pyenvgitclonehttps://github.com/pyenv/pyenv~/.pyenv# setup pyenv (you should also put these three lines in .bashrc or similar)
# if you are using zshcat<< EOF >> ~/.zshrc
# pyenv config
export PATH="${HOME}/.pyenv/bin:${PATH}"
export PYENV_ROOT="${HOME}/.pyenv"
eval "$(pyenv init -)"
EOF# or if you using the default bash shell, do this instead:cat<< EOF >> ~/.bashrc
# pyenv config
export PATH="${HOME}/.pyenv/bin:${PATH}"
export PYENV_ROOT="${HOME}/.pyenv"
eval "$(pyenv init -)"
EOF# Close and open a new shell session
# install Python 3.9.10pyenvinstall3.9.10# make it available globallypyenvglobalsystem3.9.10To manage the Python 3.9 virtualenv, I recommend usingpoetry.# install poetrycurl-sSLhttps://install.python-poetry.org|python3-poetry--versionPoetryversion1.1.13# Having the python executable in your PATH, you can use it:poetryenvuse3.9.10# However, you are most likely to get the following issue:Creatingvirtualenvreadonly-dxc671ba-py3.9in~/.cache/pypoetry/virtualenvsModuleNotFoundErrorNomodulenamed'virtualenv.seed.via_app_data'at<frozenimportlib._bootstrap>:973in_find_and_load_unlocked# To resolve it, you need to reinstall virtualenv through pipsudoaptremove--purgepython3-virtualenvvirtualenvpython3-mpipinstall-Uvirtualenv# Now, you can just use the minor Python version in this case:poetryenvuse3.9.10Usingvirtualenv:~/.cache/pypoetry/virtualenvs/readonly-dxc671ba-py3.9🚨 InstallationWithpip:python3.9 -m pip install readonly🚸 Usage>>>fromreadonlyimportreadonly>>>importmath>>>math=readonly(math)# raises AttributeError>>>math.pi=3.0🎉 CreditsThe following projects were used to build and testreadonly.pythonpoetrypytestflake8coveragerstcheckmypypytestcovtoxisortblackprecommit👋 ContributeIf you are looking for a way to contribute to the project, please refer to theGuideline.📝 LicenseThis program and the accompanying materials are made available under the terms and conditions of theGNU GENERAL PUBLIC LICENSE.
Package: read-only-attributes
Read Only AttributesInfo:This package makes class attributes read only.Motivation:We can make read only attributes using@property. But this can be verbose.Worse, the intent is not clear as in these attributes are meant to be read-only.Like as belowclass MyClass:
        @property
        def x(self):
            return 'immutable 1'
        @property
        def y(self):
            return 'immutable 2'
        @property
        def z(self):
            return 'immutable 3'
        @property
        def w(self):
            return 'immutable 'The above can be written like so which is much less verbose and lot more explicit:@read_only_attributes('x','y','z','w')
class MyClass:
    def __init__(self, x, y, z, w):
        self.x = x 
        self.y = y 
        self.z = z 
        self.w = wOnce the instance attributes are assigned in the_init_, they cannot be changed. Trying to change them will raise anAttributeError.Installation:pipenv install read-only-propertiesUsage:import class decorator @read_only_attributes and use like so:from roa import read_only_attributes

@read_only_attributes('x', 'y')
class MyClass:
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = zThat's it. There us no need to use@property.'x' and 'y' are now readonly attributes. If we try to change them,AttributeErrorexception will be raised.Since 'z' is not in decorator argument list,self.zis a mutable instance attribute.
Package: read-only-class-attributes
Read only Python Class AttributesThis package provides a decorator to make read only attributes on a given
Python classInstallpipinstallread_only_class_attributesUsagefromread_only_class_attributedimportread_only#example for all read only attributes@read_only('*')class_CONSTANTS:pi=3.14159G=6.67430e-11CONSTANTS=_CONSTANTS()#example for some read only attributes@read_only('pi','G')class_PLANETCONSTANTS:pi=3.14159G=6.67430e-11g=9.18#can changeplanet='Earth'#can changePLANETCONSTANTS=_PLANETCONSTANTS()
Package: read-only-property
Python Read Only Property=========================Background:-----------> Generally, Python programs should be written with the assumption that> all users are consenting adults, and thus are responsible for using things> correctly themsel0aves.[Silas Ray][1] in Stackoverflow. Thus, generally speaking, Python doesn't hidemuch. There is no notion of `private` vs. `public` in Python, hence everythingis writable.But what if you or users of your code forget?What if you really can't assume everyone is ?Do we give up on having read only properties in Python?Short introduction:-------------------This module allows you to make class attribute read only, with needing touse `@property` or `__getattr__`.Why not use `@property`?Because it's verbose, and you need to create a function which returnssomething.```class MyClass:@propertydef a(self):return 1```The above can be shortened:```@read_only_properties('a')class MyClass(object):def __init__(self, a, b, c):self.readonly = a```Once assigned in the constructor, you can't change it.Usage:------This package installs a single Python module `rop.py`, containing a singledecorator `read_only_properties`. To use it, simply import the decorator anddecorate your classes.```from rop import read_only_properties@read_only_properties('b')class Foo:def __init__(self, a, b):self.aself.b```Moving from @property:----------------------If you have a class with many attributes that you want torefactor to properties:```class AClassWithManyAttributes:def __init__(a, b, c, d, e ...)self.a = aself.b = bself.c = c```             ....The above class would be very verbose (an IDE will save you a lot oftyping, but it won't make the code shorter:```class AClassWithManyAttributes:'''refactored to properties'''def __init__(a, b, c, d, e ...)self._a = aself._b = bself._c = c@propertydef a(self):return self._a@propertydef b(self):return self._b@propertydef b(self):return self._c# you get this ... it's long```Now imagine you can simply do that:```@read_only_properties('a', 'b', 'c')class AClassWithManyAttributes:def __init__(a, b, c, d, e)self.a = aself.b = bself.c = cself.d = dself.e = e```This makes the attributes `a, b, c` read only, trying to re-assign a valueto any of them will raise an exception, other class attribute stay unaffected.The code for this module originated from the[author's answer in stackoverflow][2].[1]: http://stackoverflow.com/a/14594174/492620[2]: http://stackoverflow.com/a/35906068/492620
Package: readonlystorage
Readonly StorageA simple read-only wrapper around a regularZODBstorage.importZODB# Let's set a read-write DemoStoragerw_storage=ZODB.DemoStorage.DemoStorage()rw_db=ZODB.DB(rw_storage)# And now, let's set a ReadOnlyStorage around it.ro_storage=readonlystorage.ReadOnlyStorage(rw_storage)ro_db=ZODB.DB(ro_storage)# Now, add some datarw_conn=rw_db.open()rw_conn.root()["foo"]="bar"rw_conn.transaction_manager.commit()rw_conn.close()# Read the dataro_conn=ro_db.open()assert"bar"==ro_conn.root()["foo"]ro_conn.root()["foo"]="anything"ro_conn.transaction_manager.commit()# This one would emit a ZODB.POSException.ReadOnlyError!ro_conn.close()
Package: read-overlap
Screen assembliesPipeline that screens for presence of genes of interest (GOI) in bacterial assemblies. Generates multiple CSVs and plots that describe which genes are present and how variable their sequence is. Can use DNA or protein query sequences (GOIs) and DNA contigs/fastas or protein fastas as database (db) to search in.Getting StartedYou need one fasta file with all GOIs as the query and a folder with db contigs/fastas. Db files can only have one '.' in the name (i.e., sample_1.fa NOT sample.1.fa)PrerequisitesRequiredPython 3 and scypi/Biopython
Command line blastOptionalClustal Omega,
RAXML and or IQtreeInstallingDownload the screen_assembly3.py script and place it in your PATH:git clonehttps://github.com/shimbalama/screen_assembly.gitMake sure its executable (chmod +x screen_assembly/screen_assembly3.py)Export PATH="your_path:$PATH" (the command pwd will give you your PATH)Best to permanently add it to you path by adding it to .bash_profile (mac) or .profile (unix)Download lab_modules.py:git clonehttps://github.com/shimbalama/common_modules.gitMake sure its executable (chmod +x common_modules/lab_modules.py)Export PYTHONPATH="your_path:$PYTHONPATH"Best to permanently add it to you path by adding it to .bash_profile (mac) or .profile (unix)Place the common_modules folder next to the screen_assembly folder (as thats where it looks by default). OR use a text editor to set this line in screen_assembly3.py to point at the dir you put lab_modules.py in:  sys.path.append('../common_modules') becomes sys.path.append('your_path/common_modules')Check for updatesgit pullRunning the testsOnce screen_assembly3.py is in your PATH type screen_assembly3.py -h . If you have all dependencies then the help menu will display. Otherwise read the erorr and install whichever dependency is missing.Running the programPlease see the WIKIAuthorsLiam McIntyre-Initial work-https://github.com/shimbalama/LicenseThis project is licensed under the MIT License - see the LICENSEhttps://github.com/shimbalama/screen_assembly/blob/master/LICENSEfile for detailsAcknowledgmentsMark Davies lab and Jake for testing
Package: readpaf
readpafreadpaf is a fast parser forminimap2PAF
(Pairwise mAppingFormat) files. It is written in pure python with
no required dependencies unless apandasDataFrame
is required.InstallationMinimal  install:pipinstallreadpafWith optionalpandasdependency:pipinstallreadpaf[pandas]Direct downloadAs readpaf is a self contained module it can be installed by downloading just 
the module. The latest version is available from:https://raw.githubusercontent.com/alexomics/read-paf/main/readpaf.pyor a specific version can be downloaded from a release/tag like so:https://raw.githubusercontent.com/alexomics/read-paf/v0.0.5/readpaf.pyPyPIis the recommended install method.Usagereadpaf only has one user function,parse_pafthat accepts of file-like object; this
is any object in python that has a file-oriented API (sys.stdin,stdoutfrom subprocess,io.StringIO, open files fromgziporopen).The following script demonstrates how minimap2 output can be piped into readpaffromreadpafimportparse_paffromsysimportstdinforrecordinparse_paf(stdin):print(record.query_name,record.target_name)readpaf can also generate a pandas DataFrame:fromreadpafimportparse_pafwithopen("test.paf","r")ashandle:df=parse_paf(handle,dataframe=True)Functionsreadpaf has a single user functionparse_pafparse_paf(file_like=file_handle,fields=list,na_values=list,na_rep=numeric,dataframe=bool)Parameters:file_like:A file like object, such assys.stdin, a file handle from open or io.StringIO objectsfields:A list of 13 field names to use for the PAF file, default:"query_name","query_length","query_start","query_end","strand","target_name","target_length","target_start","target_end","residue_matches","alignment_block_length","mapping_quality","tags"These are based on thePAF specification.na_values:A list of values to interpret as NaN. This is only applied to numeric fields, default:["*"]na_rep:Value to use when a NaN value specified inna_valuesis found. This should ideally be0to match minimap2's output default:0dataframe:bool, if True, return a pandas.DataFrame with the tags expanded into separate SeriesIf used as an iterator, then each object returned is a named tuple representing a single line in the PAF file.
Each named tuple has field names as specified by thefieldsparameter.
The SAM-like tags are converted into their specified types and stored in a dictionary with the tag name as the key and the value a named tuple with fieldsname,type, andvalue.
Whenprintorstrare called onPAFrecord (named tuple) a formated PAF string is returned, which is useful for writing records to a file.
ThePAFrecord also has a methodblast_identitywhich calculates theblast identityfor that record.If used to generate a pandas DataFrame, then each row represents a line in the PAF file and the SAM-like tags
are expanded into individual series.
Package: read-pdz
Welcome to read_pdzThe X-Ray Fluorescence (XRF) data files that are produced by Bruker hand
held XRF spectrometers are saved as.pdzfiles. Unfortunately these
files are formatted as binary code.Over the last decades my lab, the Rijkserfgoedlaboratorium in Amsterdam,
has used various types of Bruker hand held X-Ray Fluorescence (XRF)
spectrometers. Measurement data is saved into.pdzfiles.
Unfortunately these files use a proprietary non standard binary file
format. Even worse, over time the.pdzfile format has changed several
times. This situation restricts access to the data to a limited number
of researchers who can run the required Bruker software. Furthermore, it
is likely that we will loose the ability to read the data at some point
in the future.In order to make optimal use of the XRF spectral data files in
collaborative research projects now and to make sure that we can still
read the data in the future we need to: 1) (at least partly) understand
the file format, and 2) develop open software tools available to all
researchers for reading and converting these data files.To support open heritage scienceread_pdzpackage is currently being
developed under the MIT open source software license.
Package: readpe
ReadPEA cross platform tool to work with PE files from the command line.InstallationUsingpip$ pip install readpeFromsource$ git clone https://github.com/N1ght-W0lf/readpe
$ cd readpe
$ python setup.py installUsageusage: readpe <pefile> <options>

Display information about the contents of PE files

positional arguments:
  pefile                 PE file path

optional arguments:
  -H, --all-headers      Display all PE headers
  -d, --dos-header       Display the PE DOS header
  -h, --file-header      Display the PE File header
  -o, --optional-header  Display the PE Optional header
  -D, --dirs             Display the PE Data Directories
  -i, --imports          Display imported functions
  -e, --exports          Display exported functions
  -s, --sections         Display all sections headers
  -r, --resources        Display all resources
  -x, --extract          Extract resources
  -t TYPE, --type TYPE   Resource type to dump
  -n NAME, --name NAME   Resource name to dump
  --help                 Display this help

Example: readpe test.exe -d -h -oLicenseCopyright (c) 2020 N1ght-W0lf - Released under MIT License