Saravanan666/pypi-org huggingface dataset:
Package: rtdpy
rtdpyResidence Time Distribution modeling in Python.https://merck.github.io/rtdpyA simple exampleCreate a family of tanks in series (N-CSTRs) and analyze themimportmatplotlib.pyplotaspltimportrtdpyfornin[1,2,5,10,100]:a=rtdpy.Ncstr(tau=1,n=n,dt=.001,time_end=5)plt.plot(a.time,a.exitage,label="n={}".format(n))plt.legend()plt.xlabel('Time')plt.ylabel('Exit Age Function')plt.title('Impulse Responses')InstallationpipinstallrtdpyIssues/Requests/ContributionsSeeCONTRIBUTING.mdTestingTests are written usingpytest.numpyandscipymust also be installed in the environment if usingpytestdirectly.toxcan also be used to test against Python versions 3.5, 3.6, and 3.7. Seepytest documentationfor how to use and interpret pytest results.It is recommended to use a virtual environment for developing/testing.gitclonehttps://github.com/Merck/rtdpy.git# or use your forked repocdrtdpy
python3-mvenv.venvsource.venv/bin/activate
pipinstall-e.# will also install numpy and scipy dependenciespipinstallpytesttox# run all testspytest# run tests and style check for Python versions 3.5, 3.6, and 3.7, if available.toxAuthor: Matthew FlammEmail:matthew.flamm@merck.com
Package: rtd-redirects
Manage redirects in theReadTheDocsadmin, programmatically. Addressing thertfd/readthedocs.org#2904issue.InstallationRequiresPython 3.6and higher.$pipinstallrtd-redirectsUsage$rtd-redirectsproject-name./redirects.yml--username=honzajavorekUploads redirects defined in theredirects.ymlfile to ReadTheDocs redirects administration of theproject-nameproject.The tool uses ReadTheDocs’ HTML interface (there’s no official API for redirects), so you need to provide your username and password. HTTPS is used to transfer the credentials to ReadTheDocs.rtd-redirectstries to be idempotent, i.e. you can run it several times in row and it should always end with the same results. If there are any redirects with the same source path, the tool will replace them with whatever is defined in theredirects.ymlfile. Existing redirects which do not collide with contents ofredirects.ymlwon’t be affected.redirects.ymlOnlypage redirectsare supported at the moment. The format of the file is as follows:redirects:# we've migrated from MkDocs to Sphinx"/example/":"/example.html""/python/":"/python.html"# page removed in favor of section"/green.html":"/colors.html#green"# only for convenience"/praha.html":"/prague.html"WhyYAML? Because it’s easy to read by humans, easy to write by humans, and above all, it has support for comments. Redirects arecorrectionsand you should document why they’re necessary.Usage with ReadTheDocs PROIf you are using a commercial edition of the RTD (fromreadthedocs.cominstead ofreadthedocs.org), please specify--proflag in the command, like this$rtd-redirectsproject-name./redirects.yml--username=honzajavorek--proThere is also an opposite flag--freewhich is added by default, so can be omittedLicense: MIT© 2017-? Honza Javorekmail@honzajavorek.czThis work is licensed underMIT
license.
Package: rtd-tikz
This package contains binary files (executables and libraries) that are needed
forsphinxcontrib-tikzpackage but are missing from readthedocs.org. This
enables documentations created with Sphinx to use TikZ drawings at
readthedocs.org.To enable the TikZ support at readthedocs.org, addrtd-tikzto the
requirements file used by readthedocs.org. It will installsphinxcontrib-tikzas a dependency.GitHub repository:https://github.com/jluttine/tikz-in-readthedocsDocumentation:http://tikz-in-readthedocs.readthedocs.orgWARNING:You probably want to install this package into a virtual
environment, otherwise you may accidentally overwrite your system binaries if
you have them.NOTE:If you installrtd-tikz(i.e.,sphinxcontrib-tikz) into a virtualenvironment, you should installsphinxinto that virtual environment too. The
system installation won’t find the extensions that exist in the virtual
environment.Licensebin/pdftoppmLicense: GPLv2 or GPLv3Source:https://cgit.freedesktop.org/poppler/popplerbin/pnmcropCopyright (C) 1989 by Jef Poskanzer.License: GPLv2, MITSource:https://sourceforge.net/projects/netpbm/bin/pnmtopngCopyright (C) 1995-1997 by Alexander Lehmann and Willem van SchaikLicense: Open sourceSource:https://sourceforge.net/projects/netpbm/lib/libnetpbm.so.10License: GPLv2, MITSource:https://sourceforge.net/projects/netpbm/All other filesCopyright (C) 2012, 2016 by Jaakko LuttinenLicense: MIT
Package: rtea
rteaBring fast TEA cipher to Python. Powered by Rust.为 Python 带来快速的TEA密码实现依赖开发依赖一个能跑起来的 Rust，不知道最低是什么版本，但是用新的准没错你大概需要一个 Nightly 的 RustPython 3.7+requirements-dev.txt里的maturin运行依赖Python 3.7+构建假设环境已经存在满足条件的 Rust 和 Python新建一个虚拟环境并激活安装开发依赖pip install -r requirements-dev.txt运行maturin develop [--release]在rtea目录下生成二进制库文件，可直接引入或者运行maturin build [--release]在target/wheels下生成whl，在 Unix 系统上还可添加--strip以减少生成体积测试运行pytest同时运行单元测试与速度测试运行cargo test运行单元测试运行cargo bench运行速度测试预编译包从右侧 Release 页面获取使用 pip 直接从 PyPI 安装
Package: rte-api
Project Short Description (default ini)Project long description or extended summary goes in here (default ini)TestingThis project usespytestto run tests and also to test docstring examples.Install the test dependencies.$pipinstall-rrequirements_test.txtRun the tests.DevelopingThis project usesblackto format code andflake8for linting. We also supportpre-committo ensure these have been run. To configure your local environment please install these development dependencies and set up the commit hooks.$pipinstallblackflake8pre-commit$pre-commitinstallReleasingReleases are published automatically when a tag is pushed to GitHub.# Set next version numberexportRELEASE=x.x.x# Create tagsgitcommit--allow-empty-m"Release$RELEASE"gittag-a$RELEASE-m"Version$RELEASE"# Pushgitpushupstream--tags
Package: rteplayer-dl
RTE Player video downloaderHelpful python project to download videos from RTE Player.Uses a combination of a bookmarklet and a python script to download programmes
from RTE player for offline viewing.Free software: MIT licenseDocumentation:https://rteplayer-dl.readthedocs.io.Usage:https://rteplayer-dl.readthedocs.io/en/latest/usage.htmlKnown issuesProgrammes with run time greater than 1 hour are not watchable past the fist
hour due to audio and video stream no longer being in sync. The reason for
this is not yet known.Some downloaded videos contain multiple video tracks of different resolution.
From my experimentation the last video track is the highest resolution.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.0.1 (2019-05-13)First release on PyPI.0.0.4 (2019-05-13)Command line option added to specify which resolution to download.
Package: rterm
Rterm is Twitter / RSS reader client for CLI(Command Line Interface).
Rterm requires Python version 3.5 and above.ScreenshotGetting StartedTry it with:pip3 install rterm
rtermYou can clone the git repo:git clone https://github.com/rainygirl/rterm
cd rterm
python3 setup.py install
rtermYou may need to get your own Twitter consumer key (API key) and consumer secret key. Go tohttps://dev.twitter.com/apps/newand copy to terminal.RSS feedsYou can add/modify RSS feeds on src/config.pyShortcut keys[H], [?] : Help[Up], [Down], [W], [S], [J], [K] : Select from list[Shift]+[Up], [Shift]+[Down], [PgUp], [PgDn] : Quickly select from list[Space] : Open attached image or URL[O] : Open canonical link[:] : Select by typing a number from list[Tab], [Shift]+[Tab] : Change the category tab[Q], [Ctrl]+[C] : QuitContributingFeel free to fork & contribute!LicenseRterm is released under the MIT license.CreditsLee JunHaeng aka rainygirl.
Package: rtex
Async Python Client to The RTEX API ServerInstallationpipinstallrtexUsageThe API surface of Rtex is spartan so this is basically the whole thing.importasynciofromrtex.clientimportAsyncRtexClientasyncdefamain():asyncwithAsyncRtexClient()asrtex:res=rtex.create_render("\(x^2 + x - 1\)")ifres.status=="success":withopen("equation.png")asoutput_fd:awaitres.save_render(res.filename,output_fd)defmain():asyncio.run(amain())if__name__=="__main__":main()No Thoughts, Just Renderasyncdefamain():asyncwithAsyncRtexClient()asrtex:buf=awaitrtex.render_math("e^x + 1")# `buf` now contains the bytes of the PNGDo I look like I know what a Jay-Peg is?asyncdefamain():asyncwithAsyncRtexClient()asrtex:# The render methods accept a format parameter.# Supported values are "png", "jpg" and "pdf"buf=awaitrtex.render_math("e^x + 1",format="jpg")Self-HosterSet the environment variableRTEX_API_HOSTor do the following.asyncdefamain():asyncwithAsyncRtexClient(api_host="https://myserver.ru")asrtex:buf=awaitrtex.render_math("e^x + 1")I Can Tell By The Pixelsqualityin Rtex speak is an abstract notion of compression for the given
format where100is the least compressed and0is the most. At the time of
writing the default is85.densityin Rtex speak is how much to sample the rendered PDF when generating
an image. This has no effect on the"pdf"format. At the time of writing the
default is200.asyncdefamain():asyncwithAsyncRtexClient(api_host="https://myserver.ru")asrtex:needs_more_jpeg=awaitrtex.render_math("e^x + 1",density=50,quality=1)
Package: rtf
# Remote Tensorflow Execution (RTF)Bring the power of the Tensorflow Python API to any language, using gRPC.This repository contains the code of the RTF server and client generator.**WARNING**: experimental, unstable, WIP.## ServerThe gRPC server implements the server-side protocol. It accepts the requests of function definitions and executes them.The execution is left to the Python interpreter and the output is streamed back to the client.### UsageThe server waits for messages and sends back the responses.#### RequirementsCompile the proto definition is required, however the `setup.py` script takes care of everything. There are 2 options1. `pip install -e .` to work in edit mode, with the compiled protobufs2. `pip install .` to install the package (it compiles the proto too)3. (future) `pip install rtf` | `pip install rtf-gpu`#### 1. Start the gRPC server```python -m rtf.server```## Client stub generationTo generate the stub of a client in `DEST_DIR` use the `rtf.generate` module.```python -m rtf.generate  --dest_dir DEST_DIR --module tensorflow --target Go```Right now the only generator that is going to be developed is Go.
Package: rt-factory
===============================rt_factory===============================.. image:: https://img.shields.io/pypi/v/rt_factory.svg:target: https://pypi.python.org/pypi/rt_factory.. image:: https://img.shields.io/travis/ptillemans/rt_factory.svg:target: https://travis-ci.org/ptillemans/rt_factory.. image:: https://readthedocs.org/projects/rt-factory/badge/?version=latest:target: https://rt-factory.readthedocs.io/en/latest/?badge=latest:alt: Documentation Status.. image:: https://pyup.io/repos/github/melexis/rt_factory/shield.svg:target: https://pyup.io/repos/github/melexis/rt_factory/:alt: UpdatesPythonic wrapper for the artifactory API* Free software: Apache Software License 2.0* Documentation: https://rt-factory.readthedocs.io.Features--------* TODOInstallation------------on OSX you need to have the openssl headers and libraries installed and added tothe include and library search paths in order to compile the *cryptography*package... code:: sh$ brew install openssl$ export LDFLAGS="-L/usr/local/opt/openssl/lib"$ export CPPFLAGS="-I/usr/local/opt/openssl/include"$ export PKG_CONFIG_PATH="/usr/local/opt/openssl/lib/pkgconfig"For linux you need to install *libssl-dev* on debian based systems or *openssl-devel*on RPM based systems.Once these dependencies are installed, just pip install the dev requirements... code:: sh$ pip install -r requirements_dev.txtCredits---------This package was created with Cookiecutter_ and the `audreyr/cookiecutter-pypackage`_ project template... _Cookiecutter: https://github.com/audreyr/cookiecutter.. _`audreyr/cookiecutter-pypackage`: https://github.com/audreyr/cookiecutter-pypackage=======History=======0.1.0 (2017-03-27)------------------* First release on PyPI.
Package: rtfcre
rtfcrertfcreis a Python library for reading and writing steno dictionaries in theRTF/CRE(Rich Text Format with Court Reporting Extensions) format. The library provides
an API similar to that of thejsonmodule for reading and writing dictionaries.rtfcrealso comes with a little command-line utility that you can use to
convert your dictionaries between Plover's native JSON format and RTF. SeeCLIfor more information.FeaturesSpeed: The parsing logic is written in Rust using parser combinators,
making it much faster than practically any pure-Python implementation.Comments: Rather than just exposing translations,rtfcrealso reads the
comments embedded in each entry ({\*\cxcomment like this}).Unicode: Full Unicode support -- while the dictionary files are not
encoded in UTF-8, Unicode characters in translations are still fully
supported. Translations can be in any language and they will seamlessly be
converted to escapes when writing.Plover support: Translations are converted automatically to Plover's
native syntax (e.g. fingerspelling is represented with{&a}rather than{\cxfing a}) and converted back when writing.InstallationTo install the library:pip install rtfcreIf you just want to use this with Plover, install theplover-better-rtfplugin
instead, since that plugin uses this library under the hood.If you want the command-line utility, go to theReleasespage and download the
binary for your system.UsageLibraryTo read an RTF dictionary:importrtfcre# Reading directly from a file (make sure to open binary)withopen("dict.rtf","rb")asfile:dic=rtfcre.load(file)# Reading from a stringrtf=r"""{\rtf1\ansi{\*\cxrev100}\cxdict{\*\cxsystem KittyCAT}{\*\cxs KAT}cat{\*\cxs KOU}cow}""".lstrip()dic=rtfcre.loads(rtf)To write the RTF dictionary:# Writing to a file (make sure to open binary)withopen("dict.rtf","wb")asfile:dic.dump(file)# Writing to a stringrtf=dic.dumps()The dictionary object itself also supports the standarddictAPI:dic["KAT"]="cat""KAT"indic# Truedic["KAT"]# "cat"deldic["KAT"]dic["TKOG"]# KeyErrordic["TKOG"]="dog"dic["TKOG"]# "dog"as well as a reverse lookup API for mapping from translations to steno strokes:dic.reverse_lookup("cat")# ["KAT"]To access comments:dic.lookup("TKOG")# ("dog", None)dic.add_comment("TKOG","TK means D")dic.lookup("TKOG")# ("dog", "TK means D")dic.remove_comment("TKOG")CLITo convert an existing Plover JSON dictionary to RTF:rtfcre path/to/input.json path/to/output.rtfTo convert an existing RTF dictionary back to Plover JSON:rtfcre path/to/input.rtf path/to/output.json
Package: rtfd
Build, read your exclusive and fuck docs.InstallationProduction Version$pipinstall-UrtfdDevelopment Version$pipinstall-Ugit+https://github.com/staugur/rtfd.git@masterQuickstartrtfd init -b your_data_dir –other-optionsrtfd project -a create –url git-url –other-options your-docs-projectrtfd build your-docs-projectMore options with--help/-hoption.DocumentationMore please see thedetailed documentation
Package: rt.filenotindexed
Disable the Plone feature on indexing contents of File content types.Use caseYou are developing in a Plone environment with a production Data.fs (and blobs) that containsa lotof
File contents and then you need to perform some actions like “Update catalog” or “Clean and Rebuild”.It will be really slow, but probably the indexed files are not the reason why you are performing the action.Or: you really don’t want that Plone index contents fo your files.How it worksThis products is an hack that will monkey-patch the default Plone file content type (whatever it is) disabling the
feature that search inside file binary content.This is automatically enabled in development mode while it’s disabled in production mode.On production mode you can force the indexing to stop working, adding theDISABLE_FILE_INDEXINGenvironment var:[instance]
...

environment-vars =
    DISABLE_FILE_INDEXING TrueIn the same way you can keep the indexing active while in development mode:[instance]
...

environment-vars =
    DISABLE_FILE_INDEXING FalseWarningKeep an eye open to this product if it will be pushed to a production environment and you are using it only for
development purpose.While it will disabled in production mode, it will be enabled if you run a debug/emergency instance.CompatibilityPlone 3 (with or without blob support)Plone 4 (with default file implementation or with plone.app.contenttypes)Plone 5AuthorsThis product was developed by RedTurtle Technology team.Changelog0.2.0 (2015-09-02)Added support for plone.app.contenttypes
[keul]0.1.0 (2014-05-07)Initial release
Package: rtfm
This package contains script to mirror RFC index and full text to local
directory, and to create a full text search based on whoosh module to
search the contents of RFCs.ConfigurationThe code reads two different configuration paths, home directory configuration
overriding the system wide configuration:/etc/rfcmirror.conf
$HOME/.rfcmirror.confThe configuration file can contain following settings:pager = Pager program used to read RFC, defaults to more
cachedir = Path to local RFC cache, defaults to /var/db/rfc
index_url = URL to RFC index, defaulthttp://www.ietf.org/download/rfc-index.txtindex_name = RFC index filename, default rfc-index.txt
rfc_base_url = Base download URL for RFC downloads, default ttp://www.ietf.org/rfc/
skipped = Defaults to RFCs to skip, default 8,9,51,418,530,598Usually it’s enough to simply add cachedir if you want to run the program with
files in your home directory.Commandsrfc-cache-update -uv
- Imports and parses the rfc-index.txt
- Downloads any missing and not skipped RFC texts
- Updates whoosh cache with the contents of the rfcrfc <number>
- Shows RFC with given numberrfc <text>
- Shows RFCs matching the text in rfc description
rfc -b <text>
- Shows RFCs matching the text in rfc description and body
Package: rtfparse
rtfparseRTF Parser. So far it can only de-encapsulate HTML content from an RTF, but it properly parses the RTF structure and allows you to write your own custom RTF renderers. The HTML de-encapsulator provided withrtfparseis just one such custom renderer which liberates the HTML content from its RTF encapsulation and saves it in a given html file.rtfparse can also decompressed RTF from MS Outlook.msgfiles and parse that.InstallationInstall rtfparse from your local repository with pip:pip install rtfparseInstallation creates an executable filertfparsein your python scripts folder which should be in your$PATH.Usage From Command LineUse thertfparseexecutable from the command line. Readrtfparse --help.rtfparse writes logs into~/rtfparse/into these files:rtfparse.debug.log
rtfparse.info.log
rtfparse.errors.logExample: De-encapsulate HTML from an uncompressed RTF filertfparse --rtf-file "path/to/rtf_file.rtf" --de-encapsulate-html --output-file "path/to/extracted.html"Example: De-encapsulate HTML from MS Outlook email fileThanks toextract_msgandcompressed_rtf, rtfparse internally uses them:rtfparse --msg-file "path/to/email.msg" --de-encapsulate-html --output-file "path/to/extracted.html"Example: Only decompress the RTF from MS Outlook email filertfparse --msg-file "path/to/email.msg" --output-file "path/to/extracted.rtf"Example: De-encapsulate HTML from MS Outlook email file and save (and later embed) the attachmentsWhen extracting the RTF from the.msgfile, you can save the attachments (which includes images embedded in the email text) in a directory:rtfparse --msg-file "path/to/email.msg" --output-file "path/to/extracted.rtf" --attachments-dir "path/to/dir"Inrtfparseversion 1.x you will be able to embed these images in the de-encapsulated HTML. This functionality will be provided by the packageembedimg.rtfparse --msg-file "path/to/email.msg" --output-file "path/to/extracted.rtf" --attachments-dir "path/to/dir" --embed-imgIn the current version the option--embed-imgdoes nothing.Programatic usage in python modulefrom pathlib import Path
from rtfparse.parser import Rtf_Parser
from rtfparse.renderers.de_encapsulate_html import De_encapsulate_HTML

source_path = Path(r"path/to/your/rtf/document.rtf")
target_path = Path(r"path/to/your/html/de_encapsulated.html")


parser = Rtf_Parser(rtf_path=source_path)
parsed = parser.parse_file()

renderer = De_encapsulate_HTML()

with open(target_path, mode="w", encoding="utf-8") as html_file:
    renderer.render(parsed, html_file)RTF Specification LinksIf you find a working official Microsoft link to the RTF specification and add it here, you'll be remembered fondly.Swissmains Link to RTF Spec 1.9.1Webarchive Link to RTF Spec 1.9.1RTF Extensions, MS-OXRTFEX
Package: rt.friendlyzcatalog
IntroductionThe ZCatalog tool (and the Plone CatalogTool version) has a very old user interface
with some limitation, and also some annoying behavior.Although using ZMI catalog UI for complex task is not good, sometimes you need it.NoteThis is a really experimental package.You at your how riskNew featuresPage sizeThe “Catalog”view display the whole catalog (or selection result) using a batching
of 20 items.
You can now use an higher value.Command “Quick Update Catalog”In the “Advanced” view you can now use the new “Quick Update Catalog” button.
It willnotclear the catalog before reindexing, and it will skip indexing on
“slow” index (right not: onlyZCTextIndex) is skipped.So: after this call you catalogcancontain old data in text indexes, but the reindex
will be a lot quicker (expecially on sites where you indexes file contents).Obviously, if you nead a good cleanup, just use the default “Update catalog”Safer unindexSometimes a catalog index enter in a broken state where it have no reference about an
indexed object. TheuncatalogObjectcan fail just because a single index has no reference
about an object.The change will swallow this kind of errors (a log entry will be displayed) but the unindex
operation will goes on.Zope and Plone versionsTested on Plone 4.3 (and ZCatalog version distributed with it).Why you don’t provide those changes to Zope core?That’s a long story and sad story.AuthorsThis product was developed by RedTurtle Technology team.Changelog0.1.0a1 (2014-09-15)Initial release
Package: rtf-tokenize
RTF TokenizeA simple RTF tokenizer.API:# Init:fromrtf_tokenizeimportRtfTokenizertokenizer=RtfTokenizer(rtf_string)# Get next token (return `None` on end of string):token=tokenizer.next_token()# Rewind a token (next call to `next_token` will return it):tokenizer.rewind_token(token)# Current location (last tokenized, irrespective of rewound tokens):position=tokenizer.lnum,tokenizer.cnumRelease history1.0.0first public release
Package: rtfunicode
This module implements an encoder for unicode to RTF 1.5 command sequences; it
can be used to generate valid RTF output with international characters.Importing this module adds a newrtfunicodecodec, allowing you to encode
unicode strings to valid RTF bytecode sequences:>>> import rtfunicode
>>> u'RTF and unicode mix just fine! \u263A'.encode('rtfunicode')
'RTF and unicode mix just fine! \\u9786?'The RTF command code for a unicode character isuN?, where N is a signed
16-bit integer and the ? is a placeholder character for older RTF readers. This
module sets the latter to the ‘?’ literal for simlicity’s sake.RequirementsPython 3.3-3.8DevelopmentThe project code is hosted onGitHub, feel free to report issues,
fork the code and issue pull requests.LicenseBSD (simplified), see: LICENSE.txtAuthorMartijn Pieters <mj@zopatista.com>2.0 (2020-02-03)Removed Python 2 compatibility.1.4 (2016-06-13)Add a MANIFEST.in template to make sure CHANGES.rst is included in the
distribution.1.3 (2016-06-06)Removed limitations section from README as these were removed in 1.1.1.2 (2016-06-06)Correct LICENSE.txt file.1.1 (2016-06-06)Support surrogate pairs by using math text-run groups.Drop support for Python 3.1 and 3.2; 3.3 - 3.5 are now officially supported.1.0 (2012-06-06)Initial release.