Saravanan666/pypi-org huggingface dataset:
Package: rstfmt
Not to be confused withrustfmt.Descriptionrstfmt is a tool for automatically formattingreStructuredTextfiles in
a consistent way.LikeBlackandgofmt, the motivation is to provide a format that is
reasonable and minimally configurable to prevent teams from wasting time
on style discussions (or individuals on manually doing formatting, for
that matter).Currently, rstfmt is in an early stage of development. Not all reST
constructs are covered and the interface or formatting may change at any
time without warning.To get a feel for the output of rstfmt, seethe sample file.Usage# Install directly from the repository.pipinstallgit+https://github.com/dzhu/rstfmt# Install from PyPI.pipinstallrstfmt# Read a file from stdin and write the formatted version to stdout.rstfmt# Don't edit any files; exit with a nonzero status code if any files are not formatted.rstfmt--check<file>...# Print diffs for all files that are not formatted (implies --check).rstfmt--diff<file>...# Format the given files in place.rstfmt<file>...# Format all files with the `rst` or `txt` extension inside a directory.rstfmt<directory>...rstfmt--exttxt<directory>...# Wrap paragraphs to the given line length (default 72).rstfmt-w<width>Like Black’sblackd, there is also a daemon that provides formatting
via HTTP requests to avoid the cost of starting and importing everything
on every run.# Install.pipinstall'git+https://github.com/dzhu/rstfmt#egg=rstfmt[d]'pipinstall'rstfmt[d]'# Start the daemon (binds to localhost:5219 by default).rstfmtd--bind-host=<host>--bind-port=<port># Print the formatted version of a file.curlhttp://locahost:5219--data-binary@<file># Specify the line length (default 72).curl-H'X-Line-Length: 72'http://locahost:5219--data-binary@<file># Mimic the standalone tool: read from stdin, write to stdout, exit with
# a nonzero status code if there are errors.curl-fsShttp://locahost:5219--data-binary@/dev/stdinWith editorsThe default behavior of reading from stdin and writing to stdout should
integrate well with other systems, such as on-save hooks in editors. For
example, here’s a configuration forreformatter.el, including both
standalone and daemon modes:;; Run the standalone tool.(reformatter-definerstfmt:program"rstfmt")(add-hook'rst-mode-hook#'rstfmt-on-save-mode);; Query the daemon.(reformatter-defineclient-rstfmt:program"curl":args'("-fsS""http://localhost:5219""--data-binary""@/dev/stdin"))(add-hook'rst-mode-hook#'client-rstfmt-on-save-mode)
Package: rstgen
Warning: This repository has moved tohttps://gitlab.com/lino-framework/rstgenSome utilities for generating chunks ofreStructuredText.It also contains a series of Sphinx extensions (in therstgen.sphinxconfpackage).Documentation:https://atelier.lino-framework.org/rstgenSource code:https://gitlab.com/lino-framework/rstgenChangelog:https://atelier.lino-framework.org/changes
Package: rstgo
rstgo is a package for parsing go diagrams of the style used at theSensei’s Libraryand rendering them using reStructuredText.  It was
designed for embedding dynamically generated images of go games into reST
documents, particularly for pelican blogs or sphinx documentation.The code lives athttp://bitbucket.org/cliff/rstgo.  Bug reports, feature
requests, and contributions are all welcome.  If you find the code useful,
hop on bitbucket and send me a quick message letting me know.To use with sphinx, add ‘rstgo.rst’ to your list of extensions.To use with pelican or another docutils-based system, add the following to
your pelican configuration file:from rstgo import rst
rst.setup_docutils()To use rstgo in standalone rst files, you can use the includedrst2html+go.pyscript, which should get installed onto your PATH.You can even use rstgo programmatically with go diagrams outside of
reStructuredText documents.  Just pass a file-like object containing only
the text of the diagram to a GoDiagramParser, and then render the image file
using a GoDiagram:from StringIO import StringIO
from rstgo import parsers
from rstgo import board

diagram_text = StringIO("""\
    $$ -------
    $$ |. 1 .|
    $$ |X . O|
    $$ |b a 2|
    $$ -------
""")
parser = parsers.GoDiagramParser()
parser.parse(diagram_text)
diagram = board.GoDiagram.load_from_parser(parser)
diagram.render()
diagram.show()
diagram.save('diagram.png', 'PNG')Changelog0.2.2 – 2012/11/29Updated setup.py to install pillow instead of PIL, because PIL does not understand basic
packaging.0.2.1 – 2012/11/29Fixed bug causing misrendering of basic stones in certain circumstancesFixed example code in this README file0.2.0 – 2011/12/04Implemented parsing of multi-digit numbers–not supported by sensei’s
library.Renamedsetup_pelican()tosetup_docutils(), because that’s what it does.Deprecatedsetup_pelican().Parser now creates amarked_coordinatesdict, which allows multiple
instances of the same annotation.Boards now render non-alphanumeric annotations.Addedrstgo.__version__information.0.1.7 – 2011/11/06Fixed an error in refactored parser that caused the first line of the board
to be processed twice.Added documentation for rendering diagrams in plain python.RenamedGoDiagram.load_diagram_from_parser()method toGoDiagram.load_from_parser()Implemented rendering of 0 as a stone marked “10”.0.1.6 – 2011/11/05Sequence moves can now start with either black or white.Refactored parser a little bit.0.1.5 – 2011/11/05Implemented rendering of sequence moves and letter annotations.  Currently,
sequence moves have to start with black0.1.4 – 2011/11/04Fixed a bug where:alt:argument was unintentionally required.0.1.3 – 2011/11/03Fixed pathing and extension loading for usage with Sphinx.0.1.2 – 2011/10/27Added release notes toREADME.txt0.1.1 – 2011/10/27Added intro text toREADME.txt0.1.0 – 2011/10/27Initial releaseTo DoDiagrams should render captions and metadata.
Package: rstl
rstlA Python port of R's stl function. Translated rather literally from the original R/Fortran source and vectorized with NumPy.For more information seethe R manual.Compatible with Python 2 and 3.Installationpip install --user rstlUsageImport the STL class and call its constructor.importnumpyasnpfromrstlimportSTLts=np.arange(144)freq=12stl=STL(ts,freq,"periodic")trend=stl.trendDocumentationThe code itself is mostly uncommented due to it being a literal translation.classSTL(ts,freq,s_window,s_degree=0,t_window=None,t_degree=1,l_window=None,l_degree=None,s_jump=None,t_jump=None,l_jump=None,robust=False,inner=None,outer=None):Note that a value of None means that the default R value will be used.
(These could not be specified in the signature because Python does not allow referencing other parameters).Args:ts: The time series (numpy array).freq: The frequency of the time series.s_window: Either the character string "periodic" or the span (in lags) of the loess window for seasonal extraction, which should be odd and at least 7, according to Cleveland et al.Optional args:s_degree, t_window, t_degree, l_window, l_degree, s_jump, t_jump, l_jump, robust, inner and outer. Seethe R manualfor their meanings and defaults.Attributes:trend: The trend component of the time series (numpy array).seasonal: The seasonal component of the time series (numpy array).remainder: The remainder of the time series not explained by trend and seasonal components (numpy array).weights: The final robust weights (all one if fitting is not done robustly) (numpy array).s_window, s_degree, t_window, t_degree, l_window, l_degree, s_jump, t_jump, l_jump, inner and outer. Note that these may have been altered by the program.PerformanceAccording to tests a runtime increase of factor ~3-5 should be expected.Copyright and LicensePython port Copyright 2018 Eric Rauch.Original source Copyright 2014 B.D. Ripley; Fortran code by Cleveland et al (1990) from ‘netlib’.Licensed under the GPLv3.
Package: rst.linker
rst.linkerprovides a routine for adding links and performing
other custom replacements to reStructuredText files as a Sphinx
extension.UsageIn your sphinxconffile, includerst.linkeras an extension
and then add alink_filesconfiguration section describing
the substitutions to make. For an example, seerst.linker’s own
conf.pyor read the source to learn more about the the linkers provided.
Package: rstmarcutree
=================================Installing and using RstMarcuTree=================================Introduction============This library helps you to process a Rhetorical Structure Theory Discourse TreeIt returns a RSTTree representing the tree composed by RSTNode.The tree is enriched with attribute like promotion set described by Daniel Marcu in paper:* Building up rhetorical structure tree 1996* Discourse trees are good indicators of importance in test 1999Installation============RstMarcuTree has support for python 2.7dependencies: discoursegraphs$ pip2.7 install rstmarcutreeUsage=====The library process a file containing a rst tree in .dis format.You can use online discourse dependency parser like feng hirst 2014 parser to producea discourse tree of a text.Vanessa Wei Feng and Graeme Hirst, 2014.A Linear-Time Bottom-Up Discourse Parser with Constraints and Post-Editing.Vanessa Wei Feng and Graeme Hirst, 2014.Two-pass Discourse Segmentation with Pairing and Global Features.You can use:https://github.com/NLPbox/rst-converter-serviceto easily convert the file in .dis output:having ./test_rst.dis file path in python2.7 console or script you can just just:>>> from rstmarcutree import load_tree>>>>>> rst_tree = load_tree('./test_rst.dis')>>>>>> root = rst_tree.get_node_by_index(0)>>>>>> root_satellite = root.get_satellite()To get the saliency score of terminal nodes between 0 and 1:>>> edus = tree.get_edus()>>> for edu in edus:>>>     print edu.get_saliency_score()Test====If you directly clone the repository, supposed you have already installedrstmarcutree, you can test it with:$ cd tests$ python test_marcu_classes.py$ python test_saliency_score.pyContact========For help or if you find any bug write to christian.colonna@studio.unibo.it
Package: rstms-ehandler
rstms-ehandlerwell-behaved CLI exception handlerFree software: MIT licenseDocumentation:https://rstms-ehandler.readthedocs.io.CreditsThis package was created with Cookiecutter andrstms/cookiecutter-python-cli, a fork of theaudreyr/cookiecutter-pypackageproject template.audreyr/cookiecutteraudreyr/cookiecutter-pypackagerstms/cookiecutter-python-cli
Package: rstms-pymod
rstms-pymodpython module management toolFree software: MIT licenseDocumentation:https://rstms-pymod.readthedocs.io.CreditsThis package was created with Cookiecutter andrstms/cookiecutter-python-cli, a fork of theaudreyr/cookiecutter-pypackageproject template.audreyr/cookiecutteraudreyr/cookiecutter-pypackagerstms/cookiecutter-python-cli
Package: rstms-tq
rstms-tqTOML jq frontend/wrapperFree software: MIT licenseDocumentation:https://tq.readthedocs.io.CreditsThis package was created with Cookiecutter andrstms/cookiecutter-python-cli, a fork of theaudreyr/cookiecutter-pypackageproject template.audreyr/cookiecutteraudreyr/cookiecutter-pypackagerstms/cookiecutter-python-cli
Package: rstobj
Welcome torstobjDocumentationrstobjis a library that construct Restructured Text markup or directives from Python Code.rstobjis based onjinja2.The idea behind rstobj:RestructuredText is super powerful, way more powerful than markdown. But have you ever think ofcustomize YOUR OWN markup or directive and do some magic?Have you think of automatically generate customized document from your code or tabulate data?Sphinx Docis the ultimate doc build tool. Withrstobj, you caneasily create your own markup / directive, and hide complex workflow behind a single markup / directive, then use it when you need it. Here’s some ideas:Use..include-all-image::to automatically scan image file under a directory, create.. image::directive and organize everything in a table.Separate comment and value of the config file, automatically create an document for a config file.…I have aBlog Postto share how to create a sphinx doc extension in 50 lines and customize your own directive (Sorry, its written in Chinese).Example:importrstobj# or from rstobj import *header=rstobj.markup.Header(title="Section1",header_level=1,auto_label=True)rst_header=header.render()print(rst_header)ltable=rstobj.directives.ListTable(data=[["id","name"],[1,"Alice"],[2,"Bob"]],title="Users",header=True,)rst=ltable.render()print(rst_ltable)Output:.. _section1:

Section1
========

.. list-table:: Users
    :header-rows: 1
    :stub-columns: 0

    * - id
      - name
    * - 1
      - Alice
    * - 2
      - BobI recommend to use this in your jinja2 template, content ofoutut.rst:{{ header.render() }}
{{ ltable.render() }}And userstobjwithsphinx-jinjalibraryhttps://pypi.org/project/sphinx-jinja/in sphinx doc project.Supported directives:.. image::..list-table::.. contents::..code-block::.. include::Supported markup:Header:.. _ref-label:

Title
=====URL:`Text<Target>`_Reference::ref:`Text<Target>`If you need more features, please submit an issue tohttps://github.com/MacHu-GWU/rstobj-project/issuesInstallrstobjis released on PyPI, so all you need is:$pipinstallrstobjTo upgrade to latest version:$pipinstall--upgraderstobj
Package: rstoolbox
Therstoolboxis a python library aimed to the analysis and management of big populations of protein or nucleotide decoys.Although inspired by the output of the protein design toolROSETTA, the library aims to be of a wider applicability, and can be
easily set up to retrieve data from other design tools.It is particularly aimed towards two distinct user profiles:Protein designers comfortable with light scripting to process their data. Ideally, used to work withIpython, for which this library has a particular affinity.Developers that develop new protein design tools/protocols/approaches and wish to benchmark their innovations with previously existing methods.See a working example notebook at:Despite its name, the librarydoes not require a local installation of ROSETTA, files can be imported from whatever cluster service the user has access to. That said, some functions can or need to exploitROSETTA. Those functions are few and their requirements are
clearly highlighted on theirdocumentation.Start using therstoolboxis as easy as installing it via pip:pipinstallrstoolboxA completedocumentationwith detailed explanation for each function is available.
Package: rst-package-refs
NoteThis is experimental package.reStructuredText’s custom roles and role builder kit for package registries of any languages.Installationpip install rst-package-refsUsageCommand line test$echo':npm:`react`'|python-mrst_package_refs<document source="<stdin>">
    <paragraph>
        <reference refuri="https://www.npmjs.com/package/react">
            reactWith Sphinxextensions=["rst_package_refs.sphinx",]This uses:npm:`react`.Set up for local developmentPre-requirementsRyepre-commitGitSet upgit clone https://github.com/attakei/rst-package-refs.git
cd /path/to/rst-package-refs
rye run setup
Package: rstparse
rstparse Packagerstparse - expand and analyze RST (reStructureText) documents with auto*-directivesDESCRIPTIONThis manual page documentsrstparse, a Python module for parsing RST
(reStructureText) documents.Many documents of Python and its standard libraries, as well as a vast number
of third party modules are written as RST (reStructureText) markup documents.
RST documents are easier to handle since, similarly to other markup document
formats such as Markdown, it is mostly a plain text file with several
additional notations.Since RST documents are plain text files, you can easily browse those
documents using your favorite tools like pagers (e.g.,more,less, andlv) and also you can search for topics that you are interested in using
common tools such asgrep.However, a significant portion of RST files useautodirectives (e.g.,
autosummary, automodule, autoclass, and autofunction), which ask the RST
parser to include the contents from somewhere outside the RST document.  For
instance, if an RST file contains a line,.. autosummary: good_functhe description ofgood_funcis not contained in this file.autosummarymeans the description must be inserted here.  It is an RST parser's
responsibility to identify where the description ofgood_funcis stored.rstparsemodule parses an RST file and expands all auto*-directives.EXAMPLEimportrstparsefile='foo.rst'rst=rstparse.Parser()withopen(file)asf:rst.read(f)rst.parse()forlineinrst.lines:print(line)INSTALLATIONpip3installrstparserAVAILABILITYThe latest version ofrstparsermodule is available at PyPI
(https://pypi.org/project/rstparser/) .SEE ALSOreStructuredText Markup Specificationhttps://docutils.readthedocs.io/en/sphinx-docs/ref/rst/restructuredtext.htmlreStructuredText Directiveshttps://docutils.readthedocs.io/en/sphinx-docs/ref/rst/directives.htmlAUTHORHiroyuki Ohsaki <ohsaki[atmark]lsnl.jp>
Package: rst-pypi-ref
reStructuredText custom role to refer PyPI packages.DescriptionThis is python package to provide features to refer to PyPI in docutils (and more).Included features:reStructuredText roleSphinx extensionInstallationpip install rst-pypi-refUsageWhen you write:pypi:`rst-pypi-ref`into reStructuredText source,
this appends ref to PyPI URL forrst-pypi-ref.Supporting syntaxPackage name only::pypi:`rst-pypi-ref`Explicit version::pypi:`rst-pypi-ref==0.2.0`Change display text::pypi:`PyPILink<rst-pypi-ref>`There package name in between<and>.Simple usage$echo':pypi:`rst-pypi-ref`'|python-mrst_pypi_ref.cli<document source="<stdin>">
    <paragraph>
        <reference refuri="https://pypi.org/project/rst-pypi-ref">
            rst-pypi-refWith Sphinxextensions=["rst_pypi_ref.sphinx",]For other docutils appIn entrypoint (before parse reST source), Callrst_pypi_ref.core.bootstrap.fromrst_pypi_ref.coreimportbootstrapbootstrap()ContibutingSeeCONTIBUTING note.
Package: rstr-client
rstr-clientA lightweightpythonAPI client for therstrblob store.InstallationYou can install therstr-clientlibrary withpippip install rstr-clientUsagefromrstrimportRstr# Initialise the rstr client with the URL to your rstr server# and your API Token.# NOTE: these can be specified as environment variables# >>> export RSTR_URL="https://my-rstr.rs"# >>> export RSTR_TOKEN="MY_API_TOKEN"url="https://my-rstr.rs"token="MY_API_TOKEN"withRstr(url=url,token=token)asrstr:# Add a file to the blob storerefs=rstr.add(["/path/to/my/file.txt"])# You will get a list of references to your blobs# e.g. ["f29bc64a9d3732b4b9035125fdb3285f5b6455778edca72414671e0ca3b2e0de"]# You can then use the reference to retrieve your blobref=refs[0]blob=rstr.get(ref)print(blob)# Blob(f29bc64a9d)print(blob.metadata)# BlobMetadata('file.txt', 'text/plain', 20 bytes)# You can access the binary content of the blob with:# content = blob.content# The blob can be permanently deleted from the blob store with:withRstr(url=url,token=token)asrstr:rstr.delete(ref)LicenseCopyright (c) 2021 giuppeprstr-clientis made available under theMIT License
Package: rstserv
This python script is a simple http server that shows a reStructured text file.Requirepython (> 2.4)docutilsmarkdown (optional)Setup$ pip install rstservUsage$ rstserv [-p port] [file]Run the script with your rst file, and accesshttp://localhost:8080.Command-line Options-pport number (default: 8080)LicenseThis program is distributred under the MIT license.
Package: rSTSF
Randomized-Supervised Time Series Forest (r-STSF)The r-STSF is a Python package for fast, accurate, and explainable time series classification. It implements the methodology described in:Cabello, N., Naghizade, E., Qi, J., et al. Fast, accurate and explainable time series classification through randomization. Data Min Knowl Disc (2023).https://doi.org/10.1007/s10618-023-00978-wAn arXiv version of the paper is available here:Fast, Accurate and Interpretable Time Series Classification Through Randomizationby Nestor Cabello, Elham Naghizade, Jianzhong Qi, and Lars Kulik.InstallationTo install r-STSF, use pip:pipinstallrSTSFEnsure you have Python 3.6 or newer installed.Quick StartTo use r-STSF in your Python projects, import the rstsf classifier and initialize it as follows:fromrSTSFimportrstsfclassifier=rstsf()Example UsageBelow is a simple example demonstrating how to train and predict with the r-STSF classifier:# Assuming X_train, y_train, X_test are prepared data arraysclassifier.fit(X_train,y_train)predictions=classifier.predict(X_test)For more detailed examples, including how to prepare your data, refer to the Jupyter notebooks provided in the GitHub repository:r-STSF Usage Exampler-STSF Explainability DemoFeaturesFast and Accurate: Achieves state-of-the-art classification accuracy efficiently, suitable for large datasets or long time series.Explainability: Offers insights into classification decisions, aiding understanding and trust in predictions.Flexible: Utilizes multiple time series representations and aggregation functions to capture diverse patterns.Licenser-STSF is licensed under the MIT License - see the LICENSE file for details.CitationIf you use r-STSF in your research, please cite the following paper:@article{rSTSF2023,
  title={Fast, accurate and explainable time series classification through randomization},
  author={Cabello, Nestor and Naghizade, Elham and Qi, Jianzhong and Kulik, Lars},
  journal={Data Mining and Knowledge Discovery},
  year={2023},
  publisher={Springer}
}
Package: rst_simplespreadsheet
Register a simplespreadsheet directive to do calculations in a table.Installpip install rst_simplespreadsheet  # or
easy_install rst_simplespreadsheetUsageUse it as an extension to rst2pdf:rst2pdf -e rst_simplespreadsheet ...SyntaxFormulae are pieces of text enclosed in ={…}. Only one formula
per cell is supported.The simplest formula is a number, like this:={4}This define the cell value to 4. A cell has value 0 (zero) unless it
contains a formula.You can reference the value of other cells using alphanumerical
identifiers. Columns are identified using letters, from a to z then
from aa to az, ba to bz and so on. Rows are identified using
numbers. The first row is 1 and header rows are not numbered (thus not
referenceable).For example, the formula to calculate the product of cells a1 and a2 is:={a1 * a2}There are two special characters, # and @, used to reference the current
row and the current column, respectively.For example, to calculate the product of cells b and f on the current row:={b# * f#}and to calculate the sum of rows 1 and 2 in the current column:={@1 + @2}FunctionsThe spreadsheet can calculate cell values using Python
functions. These functions have to be defined and registered in the
SpreadSheet class first.For now, only the functionsumis defined:={sum("a1:a20")}ExamplesYou can do a simple table with totals like this one:QtyRatePrice21 $2 $43 $12 $15 $5 $37 $21 $Total40 $with this code:.. simplespreadsheet::
    +------+--------+-------------------+
    | Qty  | Price  |  Total            |
    +======+========+===================+
    | ={2} | ={1} $ | ={a# * b#} $      |
    +------+--------+-------------------+
    | ={4} | ={3} $ | ={a# * b#} $      |
    +------+--------+-------------------+
    | ={1} | ={5} $ | ={a# * b#} $      |
    +------+--------+-------------------+
    | ={3} | ={7} $ | ={a# * b#} $      |
    +------+--------+-------------------+
    | *Total*       | ={sum("c1:c4")} $ |
    +------+--------+-------------------+Adding more functionsFor now, the only available function is sum(). You can easily add new
functions by adding them to SpreadSheet.tools. Please share your
improvements by forking the project on github:https://github.com/patrickfournier/simplespreadsheet