Saravanan666/pypi-org huggingface dataset:
Package: rsbcli
RSBA RAM saving cli to run web applicationsWhats New: Now you can download files from RSB and has some preset websites to open. If you click a download link, it downloads in the background but doesn't say anythingInstallationLinuxFor Debian based OSPaste this in your terminalcd ~/Downloads;wget https://raw.githubusercontent.com/AvanindraC/RSB/master/install.sh; sudo bash install.shFor all Linux distros and Macpip3 install rsbcliWindowspip install rsbcliHow to useWindowsOpen powershell and typersbTo open a website regularly:Typersb open (Enter your url)To open a preset websiteTypersb open_pre (keyword)To see the preset keywordsTypersb presetsLinux/MacOpen the terminal and typersbTo open a website regularly:Typersb open (Enter your url)To open a preset websiteTypersb open_pre (keyword)To see the preset keywordsTypersb presets### Softwares usedDeveloper ToolsVisual Studio Code -https://github.com/Microsoft/vscodePython 3.9.1Special Thanks tohttps://github.com/arghyagod-coder
Package: rsbox
rsbox: Utility Toolbox(Github|PyPI|Documentation)A toolbox of utility functionsIcommonly use when programming in Python. Includes mostly machine learning utilities.The full API consists of importable functions from modules located insrc/rsbox/. Functions are documented via docstrings under the function header. An HTML front-end documentation for the API is availablehere.Installation$ pip install rsboxExamplesHere are some highlighted functions:importrsboxfromrsboximportml,miscml.print_model_size(pytorch_net)current_time_in_string=misc.timestamp()dataset=ml.image_dir_to_data(dirpath="./data",extension='png')img_np_array=ml.get_img(url='https://stanford.edu/~rsikand/assets/images/seal.png')ml.plot(img_np_array)ModulesThe modules are located insrc/rsbox/ml.py: machine learning programming utilities.misc.py: misc. utilities.
Package: rsbp
I made a reusable blog application using Django.It is really simple.It does tagging, rss, ckeditor rich text entry with image uploads, slugged urls
and that’s about it.No comments, no social integration, no trackbacks.It is pretty customisable though because I’m be using it for two very
different blogs.InstallAll within a Django project:Add toINSTALLED_APPS:INSTALLED_APPS = (
    ...
    'ckeditor',
    'rsbp',
)Configure ckeditor:from rsbp.ck_settings import RSBP_CKEDITOR_CONFIG
CKEDITOR_UPLOAD_PATH = os.path.join(MEDIA_ROOT, 'uploads')
CKEDITOR_CONFIGS = {
    'rsbp': RSBP_CKEDITOR_CONFIG,
}CustomiseProbably the first things you’ll want to do are:Tweak the templates a bit, you’ll probably want to start withtemplates/rsbp/includes/footer.htmlTweak the default settings:RSBP_IMAGE_UPLOAD_DIRWill be appended to your media directory, default: “uploads”RSBP_POSTS_PER_PAGEHow many posts show per page, default: 5RSBP_FEED_TITLEThe title of your rss feed, default: “Blog”RSBP_FEED_LINKThe default link for the rss feed, default: “/”RSBP_FEED_DESCRIPTIONThe description of your blog for the rss feed, default: “”RSBP_FEED_MAX_ITEMSThe number of items to publish at any time on your rss feed, default: 10After that you can go crazy and add:Custom Post TypesYou can add them like this:models.py:from rsbp.models import Post
from django import models

class EventPost(Post):

    when = models.DateTimeField()
    description = models.TextField(blank=True, null=True)

    def feed_title(self):
        return "{0} at {1}".format(self.title, self.when.strftime('%x %X'))

    def feed_description(self):
        return self.description

EventPost.register_type()admin.py:from django.contrib import admin
from rsbp.admin import PostAdmin
from .models import EventPost

admin.site.register(EventPost, PostAdmin)templates/rsbp/event_post.html:<h2><a href="{% url 'post' post.id post.slug %}">{{ post }}</a></h2>
<div class="rsbp-event">
  {{ post.description|safe }}
</div>
<div class="rsbp-meta">
  {% include rsbp/includes/default_meta.html" %}
</div>Changelog0.0.1 (2013-05-31)Add tests for publishing logicAdd tests for absent or half-present slugsSlug bugfixesCKEditor now strips attributes from pasted text by default (this can be
overridden)0.0.0 (2013-05-30)Initial release
Package: rs-bytepiece
rs-bytepieceInstallpipinstallrs_bytepieceUsagefromrs_bytepieceimportTokenizertokenizer=Tokenizer()# a custom modeltokenizer=Tokenizer("/path/to/model")ids=tokenizer.encode("今天天气不错")text=tokenizer.decode(ids)PerformanceThe performance is a bit faster than the original implementation. I've tested (on my M2 16G) the《鲁迅全集》which has 625890 chars. The time unit is millisecond.lengthjiebaaho_pyaho_cyaho_rs10017062.121404.37564.31112.94100017104.381424.6573.32113.181000017432.581429.0574.93110.0310000017228.171401.01574.5110.4462589017305.951419.79567.78108.54
Package: rs-chardet
rs-chardetThis is a thin wrapper utilizingchardet-ngfor character encoding detection.BenchmarkingResultsLibraryVersionRate (call(s)/s)chardetv5.1.00.20407073211428026rs_chardetv0.1.125.446704726774133cchardetv2.1.18917.8711484593837Benchmark System Information:benchmark-pyHetzner CPX31 (4vCPU, 8GB Ram) in the US
Package: rsconnect-jupyter
rsconnect-jupyterrsconnect-jupyteris a
plugin forJupyter Notebookthat enables
publishing notebooks toPosit
Connect.RequirementsPython 3.7.0 and higherJupyter Notebook 5.xpipwheelPosit Connectv1.7.0
or higher, configured with Python support.DocumentationSee the documentationon GitHubor ondocs.rstudio.com.
Package: rsc-on-this-day
Displays Royal Society of Chemistry “On This Day” facts.Displays Royal Society of Chemistry “On This Day” facts in your terminal.DocsTestsPyPIActivityQAOtherInstallationrsc_on_this_daycan be installed from PyPI.To install withpip:$python-mpipinstallrsc_on_this_dayOnce installed,rsc_on_this_daycan be run by typing:$ rsc_on_this_dayIfrsc_on_this_dayis not installed in a directory in$PATH, you may need to add~/.local/bin/to your$PATH.Adding to~/.bashrcrsc_on_this_daycan be run every time you open a terminal by addingrsc_on_this_dayto your~/.bashrcfile. For example:$ echo "rsc_on_this_day" >> ~/.bashrc
Package: rsc-py
RSCPy: PowerPoint Remote Show Control LibraryRSCPyis a Python library designed to remotely control PowerPoint presentations using the Remote Show Control add-in. This library enables the sending of commands to control PowerPoint presentations over network connections using both UDP and TCP protocols.FeaturesOpen and close PowerPoint presentationsStart and stop presentationsNavigate through slides (next, previous, go to specific slide)Set the desktop background to the current slide (experimental feature)Find PowerPoint files within a specified directoryInstallationTo installRSCPy, simply use pip:pip install rsc_pyRequirementsPython 3.6 or higherPowerPoint with theRemote Show Controladd-in installedUsageHere's a quick start to control PowerPoint presentations:fromrsc_pyimportRSCPyimporttime# Initialize the controller with the IP address of the PowerPoint PCcontroller=RSCPy('192.168.1.1',protocol='TCP')# Open a presentationcontroller.open_presentation('path/to/presentation.pptx')# Start the presentation and waitcontroller.run_presentation()time.sleep(3)# Go to the next slide and waitcontroller.next_slide()time.sleep(3)# Close the presentationcontroller.close_presentation('path/to/presentation.pptx')Supported Commandsopen_presentation(filename): Opens a specified presentation.close_presentation(filename=None): Closes the specified or all presentations.run_presentation(filename=None): Starts the presentation.run_current(): Starts the presentation from the current slide.stop_presentation(filename=None): Stops the presentation.prev_slide(): Moves to the previous slide.next_slide(): Moves to the next slide.go_to_slide(slide): Moves to a specified slide.set_background(): Sets the desktop background to the current slide (will not work on Automatic in PPT 2013+).find_files(path): Finds PowerPoint files in the specified path.ContributingContributions to RSCPy are welcome! Feel free to fork the repository, make your changes, and submit a pull request.LicenseThis project is licensed under the MIT License - see theLICENSEfile for details.
Package: rscTestModule
{rtf1ansiansicpg1252cocoartf1671cocoasubrtf600
{fonttblf0fswissfcharset0 Helvetica;}
{colortbl;red255green255blue255;}
{*expandedcolortbl;;}
paperw11900paperh16840margl1440margr1440vieww10800viewh8400viewkind0
pardtx566tx1133tx1700tx2267tx2834tx3401tx3968tx4535tx5102tx5669tx6236tx6803pardirnaturalpartightenfactor0f0fs24 cf0 Package name - Func_groww_rscDescription - Contains function used by python scripts for Groww by Rohit Singh Chauhan}
Package: rsc-test-module
{rtf1ansiansicpg1252cocoartf1671cocoasubrtf600
{fonttblf0fswissfcharset0 Helvetica;}
{colortbl;red255green255blue255;}
{*expandedcolortbl;;}
paperw11900paperh16840margl1440margr1440vieww10800viewh8400viewkind0
pardtx566tx1133tx1700tx2267tx2834tx3401tx3968tx4535tx5102tx5669tx6236tx6803pardirnaturalpartightenfactor0f0fs24 cf0 Package name - Func_groww_rscDescription - Contains function used by python scripts for Groww by Rohit Singh Chauhan}{rtf1ansiansicpg1252cocoartf1671cocoasubrtf600
{fonttblf0fswissfcharset0 Helvetica;}
{colortbl;red255green255blue255;}
{*expandedcolortbl;;}
paperw11900paperh16840margl1440margr1440vieww10800viewh8400viewkind0
pardtx566tx1133tx1700tx2267tx2834tx3401tx3968tx4535tx5102tx5669tx6236tx6803pardirnaturalpartightenfactor0f0fs24 cf0 Change Log ==========0.0.1 ( 24/04/2021)'97'97'97'97'97'97'97'97'97'97'97'97'97'97- First Release}
Package: rsc-test-module-1
{rtf1ansiansicpg1252cocoartf1671cocoasubrtf600
{fonttblf0fswissfcharset0 Helvetica;}
{colortbl;red255green255blue255;}
{*expandedcolortbl;;}
paperw11900paperh16840margl1440margr1440vieww10800viewh8400viewkind0
pardtx566tx1133tx1700tx2267tx2834tx3401tx3968tx4535tx5102tx5669tx6236tx6803pardirnaturalpartightenfactor0f0fs24 cf0 Package name - Func_groww_rscDescription - Contains function used by python scripts for Groww by Rohit Singh Chauhan}
Package: rs-datasets
Welcome to rs_datasetsThis tool allows you download, unpack and read
recommender systems datasets intopandas.DataFrameas easy asdata = Dataset().Installationpip install rs_datasetsDocumentationPlease seedocumentationto this project to
see available datasets and examples of use.Example of usefromrs_datasetsimportMovieLensml=MovieLens()ml.info()ratings
   user_id  item_id  rating  timestamp
0        1        1     4.0  964982703
1        1        3     4.0  964981247
2        1        6     4.0  964982224
items
   item_id  ...                                       genres
0        1  ...  Adventure|Animation|Children|Comedy|Fantasy
1        2  ...                   Adventure|Children|Fantasy
2        3  ...                               Comedy|Romance
[3 rows x 3 columns]
tags
   user_id  item_id              tag   timestamp
0        2    60756            funny  1445714994
1        2    60756  Highly quotable  1445714996
2        2    60756     will ferrell  1445714992
links
   item_id  imdb_id  tmdb_id
0        1   114709    862.0
1        2   113497   8844.0
2        3   113228  15602.0Loaded DataFrames are available as class attributes.NoteThis package relies ondatatableto read files.
There are some known issues with reading some of the datasets, which should be solved with the release ofdatatable==1.1.0,
but they are quite slow on releases. If you experience problems with reading datasets, you may try to downgrade datatable
to 0.11 or 0.9. Or you can install a dev build1.1.0a2102or newer froms3.
Find your python version, copy link for whl and dopip install link. Sorry for the inconvenience.
Package: rsdb
rsdbObject–relational mapping forRiskSpectrum PSAmodel database.Installation# PyPIpipinstallrsdbUsagefromrsdb.connectionimportConnectorimportrsdb.ormserver=Connector(ip='<ip>',port=1433)# Show available modelsprint(server.GetAvailableModels())# Get SqlAlchemy session factorySession=server.GetModelSession('<model_name>')withSession()assession:event_trees=session.execute(select(rsdb.ormEventTrees)).scalars().all()foretinevent_trees:print(et.ID)func_events=et.FunctionEventsforeventinfunc_events:print(f'\tfe:{e.ID}')initiating_event=et.InitiatingEventprint(f'\tie:{ie.ID}')
Package: rs-distances
Rust Functions for Metric Space AnalysisThis repository contains a set of functions implemented in Rust for the purpose of metric space analysis. These functions aim to provide superior performance by taking advantage of Rust's efficient memory management and computational capabilities.Nature and precision of temporal coding in visual cortex: a metric-space analysis. Victor & Purpura (1996)Metric space analysis of spike trains: theory, algorithms and application. Victor & Purpura (1997)For a full walkthrough of cost-based metrics, see Jonathon Victor'swebsite:InstallationThis package is bundled with themetricspacerepository.
It can also be installed separately using the following command:pipinstallrs-distancesNote: Be sure to activate your virtual environment with Python 3.7 or higher before installing this package via pip.PerformanceThe functions provided in this package are written in Rust and compiled into a shared library that can be utilized within Python. This approach is intended to boost the computational efficiency of metric space analysis operations.Below is a comparative performance table of the spike-train iterator function implemented in Matlab, Python, and Rust. It should be noted that the Matlab version is not optimized using MEX (which would be comparable to Python's numba @jit), and the translations from Matlab to Python to Rust are not exact 1:1.Spike-train iteratorMatlabPythonRustraw function30.235s64.992s2.028swith numba @jit30.235s25.119s2.028swith @jit + parralel24.050s18.067s0.945sAdvantages of Rust ImplementationArray manipulations, particularly those performed within computationally intensive tasks, are highly sensitive to memory allocation and cleanup. Rust, with its ownership model and automatic memory management, excels in this area. Rust automatically reclaims the memory when an object (like an array or a slice) goes out of scope. This is a stark contrast to languages like Python, where a garbage collector is relied upon to perform memory cleanup. This difference provides Rust implementations with a distinct edge in performance, which is reflected in the comparative analysis shown above.With these Rust implementations, you can achieve the high-level expressiveness of Python while benefiting from the superior performance and efficiency of Rust.
Package: rsdiv
Rsdiv: Reranking for Multi-objective Optimized Recommender Systemsrsdivprovides the measurements and improvements for themulti-objective/diversifyingtasks.Some of its features include:various implementations ofdiversifying/ensemblereranking modules.various implementations of corerecommender algorithms.evaluations for recommender systems from aquantitative/visualview.easy-to-usebenchmarksfor comparing and further analysis.automatedhyperparameteroptimization.InstallationYou can simply install the pre-build binaries with:pipinstallrsdivMore installation options can be foundhere.Basic UsagePrepare for a benchmark datasetEvaluate the results in various aspectsTrain and test a recommenderReranking for diversity improvementTODOMore diversifying algorithmsimplement the Bounded Greedy Selection Strategy, BGS diversify algorithmimplement the Determinantal Point Process, DPP diversify algorithmHyperparameter optimizationcompatible withOptuna.Ensemble rankingsupport the ensemble ranking modulesFor developersContributions welcome! Please contact us.During your development stage, make sure you havepre-commitinstalled in your local environment:pipinstallpre-commit
pre-commitinstall
Package: rsd-lib
Extended Sushy library for Rack Scale DesignThis library extends the existing Sushy library to include functionality
for Intel RackScale Design enabled hardware. Capabilities include logical
node composition and decomposition, remote storage discovery and composition,
and NVMe over PCIe drive attaching and detaching to logical nodes.It supports the API interface of RSD version 2.1, 2.2 and 2.3 now. Part of RSD
2.4 API have been supported, and the rest of them are still under
implementation.Free software: Apache licenseDocumentation:https://opendev.org/x/rsd-lib/src/branch/master/doc/source/reference/usage.rstSource:https://opendev.org/x/rsd-libBugs:https://launchpad.net/python-rsdclient
Package: rs-drift
rs_drifthttps://github.com/UVoggenberger/rs_drift/tree/mainThis is a simple package to calculate the drift of radiosondes.The uncertainty of upper air observations depends not only on the measurements themselves but also on the availability and quality of metadata.
It is well known that weather balloons drift with the wind during ascent and thus can travel large distances, in some cases more than 400 km.
For a long time, for most balloon ascents, the information regarding the position was not recorded or was not transferred to the data distribution networks.To reconstruct the trajectories or the drift of those radiosondes, this package will use a methode based on wind information.
Input data must contain temperate, pressure and also wind components in the form of eastward (u) and northward wind (v).Example Notebook:https://github.com/UVoggenberger/rs_drift/blob/main/rs_drift_example.ipynb
Package: rse
Research Software EncyclopediaThe Research Software Encyclopedia (rse) is software to query and otherwise interact
with a database of research software, and a research software taxonomy.
It is intended for research software engineers to be able to better qualify
and quantify the work that they do. The rse uses the following resources:rseng/rseng: serves the taxonomy and criteriarseng/software: is a static (flat file) "database" that is updated automatically.Unlike traditional software databases, the rse and supporting tools are completely
hosted and automated without need to manage a server.
The rse works by way of regularly scraping known research software databases,
and then adding entries torseng/software.
Users are then (also automatically) prompted to answer questions about criteria
and taxonomy via social media and chat (not developed yet).  Non-traditional
use cases for the rse are generating a static web-site of your own research
software! Seethe tutorialssection of the
criteria and taxonomy site to get started.Read thedocumentationto get started with interacting with the
research software encyclopedia.LicenseFree software: MPL 2.0 License
Package: rsession
rsession is yet another Redis-backed Django session store.There are a few available within a short Google but it was
not clear which should be used and differences between them
made me decide to roll my own.This session store is a copy of Django’s own database
session store with each method modified to suit Redis.Installation of rsession is easily accomplished with pip:$ pip install rsessionTo use, install Redis and amend your Django settings as follows, substituting
appropriate values if your Redis server is not a default installation
on localhost:RSESSION = {
    'HOST'     : 'localhost',
    'PORT'     : 6379,
    'DB'       : 0,
    'PASSWORD' : '',
    'PREFIX'   : 'RSESSION',
}

SESSION_ENGINE = "rsession.rsession"
# 14 days is default expiry for Django. Setting included
# here to remind the user that the session length is modifiable
# and probably should be for your application
SESSION_COOKIE_AGE = 60 * 60 * 24 * 14 # 14 days in seconds
SESSION_SAVE_EVERY_REQUEST = True
SESSION_EXPIRE_AT_BROWSER_CLOSE = FalseFinally, whilst not essential, you can removedjango.contrib.sessionsfrom
your installed apps as this is only required if using
Django database-backed sessions.Your work is now done. Django sessions will be stored in Redis under the keyRSESSION:<sessionkey>(unless you change the prefix in settings as above)
and these will be purgedSESSION_COOKIE_AGEseconds after the last use.If you have comments and would like to get in touch, please mail
rsession at zorinholdings.comMatthew
May 2011
Package: rs-file-reader
RS file readerThis is a simple libraray for reading and processing binary files generated by Rhode and Schwarz oscilloscopes.
This library is based on guessing what the content of .bin and Wfm.bin files might mean. It works well for my needs but might fail for many other use cases.UsageIn the most simple case, you have a .bin file with a single acquisition with a limited number of samples. In this case, processing the data is easy.fromrs_file_readerimportRS_Filers_file=RS_File('my_file.bin')file_content=rs_file.getAsDf()file_contentnow contains a pandas DataFrame which you can easily process.You migth have used the oscilloscope's history function, e.g. in fast segmentation mode of because you were requesting averaging. In this case, the file might contain multiple acquisitions.
If you call getAsDf without parameters you will get all acquistions, one after another. To separate acquisitions, you need to provide an acquisition parameter.
E.g. in the following we iterate over all acquistitions:rs_file=RS_File('my_file.bin')acquisitions=rs_file.no_acquisitionsforacqinacquisitions:content_one_acq=rs_file.getAsDf(acquisition=acq)print(content_one_acq)One of the great features of R&S oscilloscopes is their large memory depth. However, this poses some challenges to processing the generated data. One way to deal with large amounts of data is to process the raw ADC data.
For this purposeRS_Fileprovides the methodgetRawwhich will return the data in the format saved by the oscilloscope without further processing.
Note that the oscilloscope will only save raw adc data, if you enabled that feature. If saving raw adc data is disabled,getRawwill return floating point numbers as the were saved by the oscilloscope.
Note, that again you can access single acquisitions via the acquisition parameter:rs_file=RS_File('my_file.bin')foracqinacquisitions:content_one_acq=rs_file.getRaw(acquisition=acq)print(content_one_acq)If you have very large files, inspecting them is an issue.RS_analysisprovides some functions for inspection. E.g. a 2D histogram can be useful:fromrs_file_readerimportRS_File,RS_analysisfrommatplotlibimportpyplotaspltrs_file=RS_File('my_file.bin')rs_analysis=RS_analysis(rs_file)histogram,extent=rs_analysis.get_2d_histo(source)dx=extent[1]-extent[0]dy=extent[3]-extent[2]aspect=dx/dy*0.5plt.imshow(np.flip(histogram,1).transpose(),aspect=aspect,cmap='gist_stern',extent=extent)plt.tight_layout()plt.show()There is also a small gui for inspection.fromrs_file_readerimportplot_guiplot_gui()If you have rs_file_reader installed as a package you can also open the gui from the terminal via:python3-mrs_file_readerRS_FileandRS_analysiscontain some more functionality. For now documention is availbale in the source code only. Hopefully, I'll soon be able to post a link to sphinx generated documentation.DevelopmentUnit tests are contained in the tests folder. If you make changes, make sure they pass.