Saravanan666/pypi-org huggingface dataset:
Package: rostspace
RostSpaceRostSpace visualizes embeddings in 3D and 2D space and colors them by groups, provided throug a CSV file. Dimensionality reduction can be performed with UMAP, PCA or t-SNE. Additional features for biologists are implemented, to display molecule structures by providing PDB files.InstallationRostSpace can be installed withpip:# install it with pippipinstallrostspaceGetting startedAfter installation, RostSpace can be run using therostspacecommand.The required arguments are:-o      Path to the output directory where generated files are stored
--hdf   Path to HDF5-file containing the per protein embeddings as key-value pair
--csv   Path to the .csv-file containing the metadataOptional arguments are:--pdb   Path to the directory that holds the .pdb files
--fasta Path to the .fasta-file
-v      Verbose -- prints internal process to the terminalDownload example dataExample data can be downloaded fromhere.Run RostSpaceRostSpace can be run by providing arguments on the command line, by giving it a YAML file, or a combination of both.Giving arguments on the command line:rostspace-odata/KLK--hdfdata/KLK/KLK_esm2.h5--csvdata/KLK/KLK.csvCreating a YAML file:Pla2g2.yamlo:data/Pla2g2hdf:data/Pla2g2/emb_esm2.h5csv:data/Pla2g2/Pla2g2.csvrostspace-confconf/Pla2g2.yamlUsing a YAML file and giving extra arguments:rostspace-confconf/Pla2g2.yaml--pdbdata/Pla2g2/colabfold/pdbFor more information to the arguments runrostspace--help
Package: ros-type-tokens
ROS Type TokensThis is a small Python library that providestype tokens(objects that represent a type) forRobot Operating Systembuilt-in types and message types.This library was initially developed as a utility of theHAROS framework, and is now distributed on its own.What Is In The BoxThis repository contains a Python package, and the respective source code, to create (manually or automatically) type tokens for the various ROS data types.
Type tokens contain attributes not only of the type itself but also of any related subtypes.
For example:fromrostypesimportHEADERHEADER.type_name# 'std_msgs/Header'HEADER.is_builtin# TrueHEADER.is_primitive# FalseHEADER.is_message# TrueHEADER.constants# {}HEADER.fields# {'seq': UINT32, 'stamp': TIME, 'frame_id': STRING}assertHEADER.fields['seq'].is_numberassertHEADER.fields['stamp'].is_timeassertHEADER.fields['frame_id'].is_stringInstallingTo install this package, make sure that you have Python 2.7 or greater.
Simply run the command:pip install ros-type-tokensBugs, Questions and SupportPlease use theissue tracker.ContributingSeeCONTRIBUTING.AcknowledgmentUntil March 2021, this work was financed by the ERDF – European Regional Development Fund through the Operational Programme for Competitiveness and Internationalisation - COMPETE 2020 Programme and by National Funds through the Portuguese funding agency, FCT - Fundação para a Ciência e a Tecnologia within project PTDC/CCI-INF/29583/2017 (POCI-01-0145-FEDER-029583).
Package: rosu-pp-py
rosu-pp-pyDifficulty and performance calculation for allosu!modes.This is a python binding to the Rust libraryrosu-ppwhich was bootstrapped throughPyO3.
Since all the heavy lifting is done by Rust, rosu-pp-py comes with a very fast performance.
Check out rosu-pp'sREADMEfor more info.Exposed typesThe library exposes the following classes:Calculator: Contains various parameters to calculate strains or map, difficulty, or performance attributesBeatmap: Contains a parsed beatmapBeatmapAttributes: Contains various attributes about the map itselfDifficultyAttributes: Contains various attributes about the difficulty based on the modePerformanceAttributes: Contains various attributes about the performance and difficulty based on the modeStrains: Contains strain values for each skill based on the modeAdditionally, the following error types are exposed:ParseError: Failed to parse a beatmapKwargsError: Invalid kwargs were providedHow to use rosu-pp-pyThe first step is to create a newBeatmapinstance by providing appropriate kwargs.
Either of the kwargspath,content, orbytesmustbe given. The kwargsar,cs,hp, andodare optional.
With the settersset_ar,set_cs,set_hp, andset_odyou can specify custom attributes.map=Beatmap(path="/path/to/file.osu",ar=9.87)map.set_od(1.23)withopen("/path/to/file.osu","rb")asfile:map=Beatmap(bytes=file.read())withopen("/path/to/file.osu")asfile:map=Beatmap(content=file.read())Next, you need to create an instance ofCalculatorby providing the appropriate kwargs again.
Any of the following kwargs are allowed:mode,mods,acc,n_geki,n_katu,n300,n100,n50,n_misses,combo,passed_objects,clock_rate, anddifficulty.
Each of these also have a setter method e.g.set_n_misses.calc=Calculator(mode=2,acc=98.76)calc.set_mods(8+64)# HDDTThe last step is to call any of the methodsmap_attributes,difficulty,performance, orstrainson the calculator and provide them aBeatmap.Examplefromrosu_pp_pyimportBeatmap,Calculatormap=Beatmap(path="./maps/100.osu")calc=Calculator(mods=8)# Calculate an SS on HDmax_perf=calc.performance(map)# The mods are still set to HDcalc.set_acc(99.11)calc.set_n_misses(1)calc.set_combo(200)# A good way to speed up the calculation is to provide# the difficulty attributes of a previous calculation# so that they don't need to be recalculated.# **Note** that this should only be done if neither# the map, mode, mods, nor passed objects amount changed.calc.set_difficulty(max_perf.difficulty)curr_perf=calc.performance(map)print(f'PP:{curr_perf.pp}/{max_perf.pp}| Stars:{max_perf.difficulty.stars}')map_attrs=calc.map_attributes(map)print(f'BPM:{map_attrs.bpm}')strains=calc.strains(map)print(f'Maximum aim strain:{max(strains.aim)}')Installing rosu-pp-pyInstalling rosu-pp-py requires asupported version of Python and Rust.OncePythonandRustand ready to go, you can install the project with pip:$pipinstallrosu-pp-pyor$ pip install git+https://github.com/MaxOhn/rosu-pp-pyLearn Morerosu-pp documentationRust documentation.PyO3 documentation.Python documentation.
Package: ros-web-gui
Aboutros_web_gui is a package for visualizing the available ROS nodes, topics, parameters and service
calls in a web browser. It provides much of the functionality that is also available with
the ROS command line tools and rqt_graph, but with a graphical user interface. When running
the ros_web_gui, a flask-based webserver will be started that can be accessed on port 5000.InstallationFirst, you should install ros on your machine. It is heavily recommened to use Ubuntu 20.04
or higher as ros-noetic is the first version with support for python3.After installing ROS, you can install ros_web_gui via pip:pip install ros_web_guiWhen using the package from Github, you need the python packages pygraphviz, pyyaml and flask. So you can set up a conda env or virtual environment withconda install flask pydot pyyaml rosdepORpip install flask pydot pyyaml rosdepAfter this, you should be ready to use the ros_web_gui.RunningWhen ros_web_gui was installed via pip, you can simply typeros_web_guiin the terminal.
When you checked out the repository you can runscripts/run_flask.sh. Then, go to your browser and openhttp://localhost:5000.For trying out ros_web_gui, you can also run thescripts/run_ros.shscript which will
start a roscore together with a simple publisher and a subscriber for testing purposes.
Package: rot
Info:This is the README file for the River.Author:Kwpolska <kwpolska@kwpolska.tk>Date:2013-01-20Version:0.1.0What is this?This is a library for CLI in Python.  It is meant to be simple and
human-friendly.  Originally pkgbuilder.ui.COPYRIGHTCopyright © 2011-2013, Kwpolska.
All rights reserved.Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:Redistributions of source code must retain the above copyright
notice, this list of conditions, and the following disclaimer.Redistributions in binary form must reproduce the above copyright
notice, this list of conditions, and the following disclaimer in the
documentation and/or other materials provided with the distribution.Neither the name of the author of this software nor the names of
contributors to this software may be used to endorse or promote
products derived from this software without specific prior written
consent.THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
“AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Package: rotary-controller-python
Rotary Controller PythonThis project is a Kivy based user interface developed for the Raspberry PI for the control of rotary tables and
similar devices on manual milling machines, tool grinders and similar equipment.This software is designed to operate with an RS485 connected control board which is responsible for the precise
timing required to control stepper motors as well as the acquisition of high speed encoder signals.Links for the hardware and firmware needed to complete the project are provided below.This software is tested on Raspberry PI 4 and 3B and it is recommended to run it from the console using the
configuration and libraries suggested by the Kivy project maintainers.When running this kivy app from a desktop environment, a significant performance loss is evident.Prebuilt images will be provided eventually so that installation friction can be minimized.This is still currently under heavy development, further features and pluggable boards will eventually be provided
to offer further functionality to the system.Getting startedThis software can be executed from any Python compatible operating system, it has been successfully tested on
Windows, Linux and OSX. The recommended way to setup your development environment is to usepyenvfor the
configuration of a suitable python version in your machine and for the creation of a dedicated virtual envionment.There are thousands of guides online for the method described above, so for now I'm not gonna write down specific
instructions about it.Once a compatible version of Python is installed with pyenv and a suitable virtual environment has been created,
it will be sufficient to install the requirements found in the requirements file.To run the application simply invoke from your favorite terminalpython ./main.pyWhen running the software from a raspberry pi a few preparatory steps shall be followed to ensure proper
operation of the touchscreen, keyboard, etc. etc.Instructions will eventually be placed here for completeness to assist in the configuration of raspbian.#TODO: Put here instructions for raspbian
Package: rotarypi
RotaryPiPython library to read the rotary dial of an old telephone with a Raspberry Pi.Targets Python>=3.9on a Raspberry Pi.This library was developed and tested on a PTT 50 wall-mounted telephone and a PTT 70 desktop telephone (both from Switzerland), but it should work with a wide variety of rotary dials since the basic principle is pretty strait forward and probably very similar on various models.DocumentationRead the full documentation onreadthedocs.
Package: rotate-logger
Python Rotate Native LoggerMaintaineremailandriyunantoreza@gmail.comRequirement:Python 3.xxHow it work?Initialize once this functionnative_logger.configure_rotating_logger('generator')Param..Default valuelogger_namemandatoryname of logger, so you can access it from anywhere with specific logger namedebugoptionaldebug used for debugging purpose, if you want write logger.info on file, you can enable debugFalsebackup_countoptionalhow many backup count that you want14houroptionalhour (0-23) when log change to next file rotate3intervaloptionalinterval day you want to backup1Use everywhereRemember name of logger that you initialize, in this case I initialize using namegeneratorand get the loggergenerator_logger = logging.getLogger('generator')
generator_logger.warning('This is warning logger')Check your log in log folderNote:1. Make sure you have permission to create folder log
 2. debug.info is not write on file, set debug to True if you want it
 3. Have fun!
Package: rotate-matrix
ROTATE MATRIX:Install:Install it using:pip install rotate-matrixRotate any matrix/multi-dimentional array of any type, either clockwise or anti-clockwise instantly.Contains two functions:1)  clockwise(): Takes l as parameter which is of type list, and pases the clockwised rotated version list l.import rotate_matrix
        l = [[1,2,4,3],[7,8,5,6],[8,6,5,4]]
        print(rotate_matrix.clockwise(l))Output:[(3, 6, 4), (4, 5, 5), (2, 8, 6), (1, 7, 8)]2) anti-clockwise(): Takes l as parameter which is of type list, and passes the anti-clockwise rotated version of list l.import rotate_matrix
        l = [[1,2,4,3],[7,8,5,6],[8,6,5,4]]
        print(rotate_matrix.anti_clockwise(l))Output:[(8, 7, 1), (6, 8, 2), (5, 5, 4), (4, 6, 3)]
Package: rotate-screen
Platforms SupportedWindows is currently the only platform supported.InstallationClone the repo, download as a zip file, or use the following command...pipinstallrotate-screenDocumentationThe package comes with some functions to get available displays in the form of <rotatescreen Display> objects. You can then use the <rotatescreen Display> object methods to change the orientation of the display.Here are a few of the available package functions...FunctionReturnsrotatescreen.get_displays()Returns a list of <rotatescreen Display> objects for each available display.rotatescreen.get_secondary_displays()Returns a list of <rotatescreen Display> objects for every display apart from the primary display.rotatescreen.get_primary_display()Returns a <rotatescreen Display> object for the primary display.Here are the available methods (no return value) for a <rotatescreen Display> object...ProcedureArgumentsResult.rotate_to(pos)pos (int): Degrees to rotate the screen to. Must be one of 0, 90, 180, 270.Rotates the screen to desired..set_landscape()Rotates the screen to landscape..set_landscape_flipped()Rotates the screen to upside down landscape..set_portrait()Rotates the screen to portrait..set_portrait_flipped()Rotates the screen to upside down portrait.Here are the available attributes for a <rotatescreen Display> object...AttributeReturns.current_orientationReturns (int) the current orientation of the display, will be one of 0, 90, 180, 270..is_primaryReturns (bool) if the display is the primary monitor..infoReturns (dict) monitor info..deviceReturns monitor device info..device_descriptionReturns (str) visable name for display device.Example:This is a simple example that implements the 'Ctrl+Alt+Arrow' keyboard shortcut for rotating the display. This is because some graphics cards don't come with this capability by default.This example requires the keyboard module...pipinstallkeyboardHere is the code! It adds hotkeys to rotate the primary display in the desired direction upon the user entering Ctrl, Alt and an arrow key. It then waits until the script is exited.importrotatescreenimportkeyboardscreen=rotatescreen.get_primary_display()keyboard.add_hotkey('ctrl+alt+up',screen.set_landscape,suppress=True)keyboard.add_hotkey('ctrl+alt+right',screen.set_portrait_flipped,suppress=True)keyboard.add_hotkey('ctrl+alt+down',screen.set_landscape_flipped,suppress=True)keyboard.add_hotkey('ctrl+alt+left',screen.set_portrait,suppress=True)keyboard.wait()Example:This was a little joke script to show off some more of the modules functionality, due to the way windows rotates the display this is a pretty horrific looking, but entertaining. :)importrotatescreenimporttimescreen=rotatescreen.get_primary_display()start_pos=screen.current_orientationforiinrange(1,5):pos=abs((start_pos-i*90)%360)screen.rotate_to(pos)time.sleep(1.5)
Package: rotating-free-proxies
rotating-free-proxiesAvoid being banned by webpages when you crawl them. This is an extension to the amazingscrapy-rotating-proxieslibrary. The main target of this library is to get proxies dynamically when the spider is running. This library automatically fetches freely available lists of proxies fromfree-proxy-list.net.Installationpip install rotating-free-proxiesUsageAfter installing you need to do just add following two variables in settings.py of your Scrapy projectROTATING_PROXY_LIST_PATH = '/my/path/proxies.txt' # Path that this library uses to store list of proxies
NUMBER_OF_PROXIES_TO_FETCH = 5 # Controls how many proxies to use


DOWNLOADER_MIDDLEWARES = {
    'rotating_free_proxies.middlewares.RotatingProxyMiddleware': 610,
    'rotating_free_proxies.middlewares.BanDetectionMiddleware': 620,
}For further details on using this library, refer to the originalreadme.Thank you!CHANGES0.1.1 (2020-05-28)Fixes bug when user does not create file to store proxies.
Adds settings to control number of proxies to use0.1.0 (2020-05-01)Initial release
Package: rotation-forest
Implementation of the Algorithm: J. J. Rodriguez, L. I. Kuncheva and C. J. Alonso, “Rotation Forest: A New Classifier Ensemble Method,” in IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. 28, no. 10, pp. 1619-1630, Oct. 2006.
doi: 10.1109/TPAMI.2006.211
Package: rotation-ip
Ip_rotatorip_rotator helps to hides your ip address in http request.This library searches every free proxy server that is available and set proxy in the request library.This library will allow the user to bypass IP-based rate-limits for sites and services.Installationpip install ip-rotatorip_rotator officially supports Python 3.7+.UsageDefaultimportip_rotatorproxy=ip_rotator.Proxy(https=False)# To access https url set (https = True)response=proxy.session.get('http://api.ipify.org/?format=json')# https requestTo Change Ipproxy.changeIp()# to change ip
Package: rot-codec
rot-codecrot5, rot13, rot18, rot47 codecs.ROT5、ROT13、ROT18、ROT47 编码是一种简单的码元位置顺序替换暗码。此类编码具有可逆性，可以自我解密，主要用于应对快速浏览，或者是机器的读取，而不让其理解其意。ROT5 是 rotate by 5 places 的简写，意思是旋转5个位置，其它皆同。下面分别说说它们的编码方式。ROT5：只对数字进行编码，用当前数字往前数的第5个数字替换当前数字，例如当前为0，编码后变成5，当前为1，编码后变成6，以此类推顺序循环。ROT13：只对字母进行编码，用当前字母往前数的第13个字母替换当前字母，例如当前为A，编码后变成N，当前为B，编码后变成O，以此类推顺序循环。ROT18：这是一个异类，本来没有，它是将ROT5和ROT13组合在一起，为了好称呼，将其命名为ROT18。ROT47：对数字、字母、常用符号进行编码，按照它们的ASCII值进行位置替换，用当前字符ASCII值往前数的第47位对应字符替换当前字符，例如当前为小写字母z，编码后变成大写字母K，当前为数字0，编码后变成符号_。用于ROT47编码的字符其ASCII值范围是33－126，具体可参考ASCII编码。Installpip install rot-codecInstall Commandsrot-codecRegister To System Codecsrot5rot13  # override the system default rot13rot18rot47rot-codec Command Line ToolCommand HelpE:\rot-codec>rot-codec --help
Usage: rot-codec [OPTIONS] [MESSAGE]

ROT5、ROT13、ROT18、ROT47
编码是一种简单的码元位置顺序替换暗码。此类编码具有可逆性，可以自我解密，主要用于应对快速浏览，或者是机器的读取，而不让其理解其意。

ROT5 是 rotate by 5 places 的简写，意思是旋转5个位置，其它皆同。下面分别说说它们的编码方式。

ROT5：只对数字进行编码，用当前数字往前数的第5个数字替换当前数字，例如当前为0，编码后变成5，当前为1，编码后变成6，以此类推顺序循环。

ROT13：只对字母进行编码，用当前字母往前数的第13个字母替换当前字母，例如当前为A，编码后变成N，当前为B，编码后变成O，以此类推顺序循环。

ROT18：这是一个异类，本来没有，它是将ROT5和ROT13组合在一起，为了好称呼，将其命名为ROT18。

ROT47：对数字、字母、常用符号进行编码，按照它们的ASCII值进行位置替换，用当前字符ASCII值往前数的第47位对应字符替换当前字符，例如当前
为小写字母z，编码后变成大写字母K，当前为数字0，编码后变成符号_。用于ROT47编码的字符其ASCII值范围是33－126，具体可参考ASCII编
码。

备注：MESSAGE为提供时，则从STDIN中读取。

Options:
-m, --method [rot5|rot13|rot18|rot47]
-d, --decode
-e, --encoding TEXT             Message encoding.
--help                          Show this message and exit.UsageE:\rot-codec>rot-codec hello
uryyb

E:\rot-codec>rot-codec -d uryyb
hello
Package: rotest-progress
Adds a progress bar based on remote statistics where it can (meant to be used on Linux machines).This plugin is automatically enabled after installing it with pip,
just add either ‘progress’ or ‘full_progress’ to your list of output handlers
(using –outputs or in the json config file).full_progressShows a tree of the tests and blocks that are about to run, each  hierarchy with a progress bar.progressShows a single progress bar for the currently running component. Can be used with other printing output handlers.
Package: rotest-reportportal
What is it?A plugin to theRotesttesting
framework, that enables reporting the test results to the amazingReport Portalsystem.InstallationInstall it usingpip:$pipinstallrotest_reportportalConfigurationIn therotest.ymlconfiguration file (or any of the available configuration
formats, like.rotest.yaml) add the following entry:rotest:<rotest configuration>reportportal:endpoint:http://<reportportal_host>:<port>project:<project name>For example:rotest:...reportportal:endpoint:http://reportal:8080/project:SUPERADMIN_PERSONALIn addition to that, you need to define theROTEST_REPORTPORTAL_TOKENenvironment variable a user’s UUID. For example:$ export ROTEST_REPORTPORTAL_TOKEN="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"$# or, on Windows:$ set ROTEST_REPORTPORTAL_TOKEN="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"A couple of things about the UUID:You can obtain it from your user profile:http://{report_portal}:{port}/ui/#user-profileTests published with this UUID will identify the user that ran those tests.Unless you want everyone to be able to publish results for you, keep this
UUID a secret (no mentioning in the repository’s code or any public space).UsageYou can run tests and activate the result handler, in the following way:$python<some_test_file>-oreportportal
Package: rotki-releases
What is Releases?Releases is a Python (2.7, 3.4+) compatibleSphinx(1.8+) extension designed to help you keep a source control friendly, merge
friendly changelog file & turn it into useful, human readable HTML output.Specifically:The source format (kept in your Sphinx tree aschangelog.rst) is a
stream-like timeline that plays well with source control & only requires one
entry per change (even for changes that exist in multiple release lines).The output (when you have the extension installed and run your Sphinx build
command) is a traditional looking changelog page with a section for every
release; multi-release issues are copied automatically into each release.By default, feature and support issues are only displayed under feature
releases, and bugs are only displayed under bugfix releases. This can be
overridden on a per-issue basis.Some background on why this tool was created can be found inthis blog post.For more documentation, please seehttp://releases.readthedocs.io.NoteYou can install the development version viapip install-egit+https://github.com/bitprophet/releases/#egg=releases.
Package: rotnotes
Rename-Notes is a python script for students to help them organize their gathered notes and make them*Ready to read*. It optionally rotates the images in order to view them in portrait fashion.Usage:>>>import rotnotes
>>>rotnotes.rename(‘path_to_your_notes_directory’)or>>>rotnotes.rename(‘path_to_your_notes_directory’,True) #to rotate notes as wellTo begin using, just do:*pip install rotnotes*