Saravanan666/pypi-org huggingface dataset:
Package: rt.categorysupport
Plugin that add a new “Taxonomies” field to content-types.FeaturesFixed list of available taxonomiesView for folder contents to show a list of contained objects’ taxonomiesAvailable taxonomiesThere is a control panel (@@taxonomy-settings) where you can set available taxonomies that users can choose.ExamplesThis add-on can be seen in action at the following sites:Emilia-Romagna SocialeTranslationsThis product has been translated intoItalianInstallationInstall rt.categorysupport by adding it to your buildout:[buildout]

...

eggs =
    rt.categorysupportand then runningbin/buildoutContributeIssue Tracker:https://github.com/PloneGov-IT/rt.categorysupport/issuesSource Code:https://github.com/PloneGov-IT/rt.categorysupportLicenseThe project is licensed under the GPLv2.ContributorsFilippo Campi,sviluppoplone@redturtle.itChangelog1.1.0 (2020-01-03)Do not wake up objects in taxonomies view.
[cekk]1.0.1 (2019-01-09)Revert to old rer.sitesearch persistent fields.
[cekk]1.0.0 (2019-01-09)Remove dependency to rer.sitesearch persistent fields.
[cekk]More italian translations changes (#16825)
[arsenico13]1.0a2 (2018-12-13)Added some italian translations.
[arsenico13]Fix path in search link.
[cekk]Some minor fixes to taxonomies view.
[eikichi18]1.0a1 (2018-10-11)Initial release.
[eikichi18]
Package: rtcat-sphinx-theme
ContentsStay in syncInstallationVia packageVia git or downloadEditingSet up your environmentRealTimeCat Sphinx theme is a fork of the excellentsphinx_rtd_theme. See the documentation there for general information.Stay in syncIn order to always stay in sync with the upstreamsphinx_rtd_theme, this repository contains two remotes:upstreamandorigin.
See Github’ssyncing a forkarticle for more information.InstallationVia packageDownload the package or add it to yourrequirements.txtfile:$pipinstallrtcat_sphinx_themeIn yourconf.pyfile:importrtcat_sphinx_themehtml_theme="rtcat_sphinx_theme"html_theme_path=[rtcat_sphinx_theme.get_html_theme_path()]Via git or downloadSymlink or submodule/subtree theRTCat/rtcat_sphinx_themerepository into your documentation atdocs/_themes/rtcat_sphinx_themethen add the following two settings to your Sphinx
conf.py file:html_theme="rtcat_sphinx_theme"html_theme_path=["_themes/rtcat_sphinx_theme",]EditingThe rtcat_sphinx_theme is primarily asassproject that requires a few other sass libraries. I’m
usingbowerto manage these dependencies andsassto build the css. The good news is
I have a very nice set ofgruntoperations that will not only load these dependencies, but watch
for changes, rebuild the sphinx demo docs and build a distributable version of the theme.
The bad news is this means you’ll need to set up your environment similar to that
of a front-end developer (vs. that of a python developer). That means installing node and ruby.Set up your environmentInstallsphinxinto a virtual environment.virtualenv ve
source ve/bin/activate
pip install sphinxInstall sassgem install sassInstall node, bower and grunt.// Install bower and grunt
npm install -g bower grunt-cli

// Now that everything is installed, let's install the theme dependecies.
npm installNow that our environment is set up, make sure you’re in your virtual environment, go to
this repository in your terminal and run grunt:gruntThis default task will do the followingvery cool things that make it worth the trouble.It’ll install and update any bower dependencies.It’ll run sphinx and build new docs.It’ll watch for changes to the sass files and build css from the changes.It’ll rebuild the sphinx docs anytime it notices a change to .rst, .html, .js
or .css files.
Package: rtc-cafe-signaller-python
RTCCafe Signaller PythonA collection of implementations of the RTCCafe Signalling Server for various python server implementations.Installationpip install rtc-cafe-signallerSetupFor all server implementations, simply pass your server instance into one of the supplied wrappers.Flask-SocketIOimport os

import flask
from flask_socketio import SocketIO
from rtc_cafe_signaller.wrappers import flask_socketio_wrapper

def validate_rtc_cafe_messages(sid, messageType, data):
  ...

app = flask.Flask(__name__)
socketio = SocketIO(app, message_queue=os.environ.get("REDIS_URL"), engineio_logger=True)
flask_socketio_wrapper.wrap(socketio, validate_rtc_cafe_messages)
Package: rtcg
rtcgRun-time code generation for python. If a method requires special parameter sequence or names, it might be better to create a small dynamic wrapper.This library will not create function at run-time. It is not intended to create functions. This is considered as rather unsecure. It will merely generate a trampoline function using named arguments, nothing more.LicensingThis library is published under BSD-3-Clause license.VersioningThis library follows semantic versioning 2.0. Any breaking change will produce a new major release. Versions below 1.0 are considered to have a unstable interface.
Package: rtchange
rtchange    [![Build Status](https://travis-ci.org/hyusuk/rtchange.svg?branch=master)](https://travis-ci.org/hyusuk/rtchange)========An implementation of real-time change-point detection in time series.(See [this paper](http://dl.acm.org/citation.cfm?id=2022866))## Sample<img src="images/changepoint_jumping_means.png" width="600px">## DependenciesThe required dependencies to use rtchange are- Python >= 3.3- NumPy## Installtion```$ pip install -U rtchange```## Example```python>>> from rtchange import Finder>>> f = Finder()>>> # `score` method returns the iterator of score of the samples.>>> scores = f.score([0, 0, 0, 0])<generator object Finder.score at 0x7faa143c4620>>>> print(list(scores))[0.0, 0.3938543257165724, 0.42281301105991476, 0.4718002708508469]>>> print(list(f.score([1, 1])))[1.0910027829221285, 1.2528868802573792]>>> # You can also use `score_one` method for the one sample.>>> f.score_one(2)1.4303444070633553```## Testing```$ virtualenv venv$ source ./venv/bin/activate$ pip install -U pip$ pip install -e .[testing]$ make test```
Package: rt-client
The RT Client is a python library for interfacing with RT’s REST API. The
client usespython-requestsand talks to theV2API.In the future we also intend to add a CLI which will use the library and offer
a nice way of interacting with RT from the commandline based on the features
the V2 API gives us.Getting Startedfromrt_client.clientimportClientrt=Client(username="jsmith",password="supersecret",endpoint="https://rt.acme.org/",)tickets=rt.ticket.search("Queue='urgent'")
Package: rtcmdecoder
rtcmdecoderAssignmentThis package was made as a final project for the course SE426 given by Professor Alain Muls. This package gives the user the ability to decode MSM7 and Ephemeris messages from all major GNSS:GPSGLONASSGalileoBeidouSBASQZSSThis package pardes the proprietary GPS/GNSS differential correction messages designed by the Radio Technical Commission for Maritime Services. The datafields used in this package are described extensively inthe RTCM standard.InstallationInstallation of the package can be done through the PyPi service through your terminal:pip install rtcmdecoderOr installation can be done in a virtual environment:python3 -m pip install --user --upgrade virtualenvpython3 -m virtualenv venvsource venv/bin/activate(env)python3 -m pip install rtcmdecoderIf you wish to use the tools for personal development, the repository can be cloned in its entirety:git clone https://github.com/P3tzl/Project-SE426.gitInputWe have implemented three different types of inputs that can be parsed by this package. The input parsing heavily relies on thepyrtcm package by semuconsulting.For every type of input, you need to specify:The output directoryThe mode (decode MSM7, ephemeris or both)Depending on the selected mode, the output directory will contain files for MSM7 data, ephemeris or both. These will be clearly labeled and categorized by GNSS.FileThe most straightforward way to decode your data is to store it as raw bytes in a txt file (as output from another NTRIP client). An example of how to decode all the saved MSM7 and ephemeris messages:rtcmdecoder-itfile-i<input_file>-mboth-o<my_output_directory>StreamYou can also connect your favorite receiver to your computer via USB and decode the data directly from a serial port. Note that during tests, we have only used the mosaic X5. Our program will identify the port you have connected your receiver to (if you have a succesful connection of course). The only thing you need to configure is the baudrate to make it correspond to the outgoing data from the receiver.rtcmdecoder-itstream-m<MSM7/ephemeris/both>-o<my_output_directory>-bd<baudrate_receiver>Connecting to the stream may sometimes not be as plug and play, depending on the receiver. Enable debugging mode by adding-dif you encounter any problems.ServerThe final option is connecting directly to a NTRIP server of your choice:rtcmdecoder-itserver-mboth-o<my_output_directory>-s<server_address>-p<server_port>-u<username>-pw<password>-mp<mountpoint>-lt<listening_time>-fs<max_filesize>We have implemented a circular buffer mechanism here that will overwrite existing data as well. The maximum size of the files is given with the flag-fsin MB.
Package: rtcom
RealTimeCommunicationReal Time Communication Library for home robotics and automation.The aim of this library is to provide a quick and easy way to prototype “Intranet of Things” devices.It was first developed for a hobby robotics project in order to have a interface between the robot and a PC,
without having to worry about networking, IP addresses, hostnames, web servers or callbacks.Free software: MIT licenseDocumentation:https://rtcom.readthedocs.io.FeaturesReal-time UDP broadcast based synchronisation of all rtcom nodes.Automatic discovery of devices. (No DNS or Avahi required)Possibility of unicast, without having to worry about IP addresses, DNS or Avahi.Get started with just a few lines of code.CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2020-10-24)First release on PyPI.
Package: rt.commands
rt.commandsdeployment commands for RT (mainly fabric scripts)Your fabfileTo use rt.commands import it in your fabfile and
set some environment variables.For example, you can start from this template:# this is necessary to make the fabric commands available
from fabric.api import env
from rt.commands import *
from rt.commands.project import *
from rt.commands.buildout_components import *

# This is the main python version
env.python_version = '2.7'

# This is the buildout script to use
env.buildout_cfg = 'buildout.cfg'

# And some hosts
env.staging_user = 'plone'
env.staging_host = 'staging.example.com'
env.staging_dir = '/opt/www.demo.example.com'
env.production_user = 'plone'
env.production_host = 'example.com'
env.production_dir = '/opt/www.example.com'rt.commandsproduction:Pushes into the env.hosts the production serverstaging:Pushes into the env.hosts the production serverrt.commands.buildout_componentssync_var:Requiresstagingorproductionbefore.
Sync component’s buildout var folder
It accepts the component parameter (default=plone)
You can pass .. to get the var at the buildout rootrt.commands.components.ploneSpecial functions to sync plone.
Given this fabfile:# -*- coding: utf-8 -*-
from fabric.api import env
from rt.commands import production, staging
from rt.commands.components.plone import sync_blobstorage, sync_filestorage

env.staging_user = 'redturtle'
env.staging_host = 'somehost.redturtle.it'
env.staging_dir = '/opt/somedir'You can invoke:fab staging sync_blobstorage
fab staging sync_filestorageIn order to have those folders syncedChangelog0.1.5 (2014-07-17)added sync_filestorage and sync_blobstorage functions for plone componentstarted writing some documentationsync_var now handles ‘..’added _isuptodate function
[ale-rt]0.1.4 (2013-10-10)Nothing changed yet.0.1.3 (2013-09-18)Initial work
Package: rtconfig
rtconfigA simple Python lib for manage remote server configuration.Configuration remote unified management center.When the configuration changes, pushed to client in real time.Installingpip install rtconfigServer deployYou can start server directly by single process.python -m rtconfig.serverCommand options:--host: str, server host--port: str, server port--auto-reload: bool, if auto reload--store-type: str, rtconfig server store type--broker-url: str, rtconfig server broker url--login-disable: bool, rtconfig server disable login--config: str, rtconfig server config file pathClient connectCreate a new python moduleconf.py, then write code like this:from rtconfig import RtConfigClient
client = RtConfigClient('demo',ws_url='ws://127.0.0.1:8089',config_module=globals())So, you can use real time configuration like this:conf.config_nameConfigurationYou can createservice.pypython config file, And add file path to params--config=services.py.Configuration options:config nametypedefaultdescriptionDEBUGboolfalsedebug modeMAX_CONNECTIONint1024max client connectionsSTORE_TYPEstringjson_filedata store typeBROKER_URLstringdata store broker urlLOGIN_DISABLEDboolfalseserver disable loginOPEN_CLIENT_AUTH_TOKENboolfalsedata store broker urlConfig data store method broker urljson_fileBROKER_URL = "~/rtconfig" (默认可不填)redisBROKER_URL = "redis://127.0.0.1:6379/0"mongodbBROKER_URL = "mongodb://127.0.0.1:27017/demo?connect=false"Notesrtconfignot support multiprocess deploy now.
Package: rtcpxr-collector
rtcpxr_collectorA python library for Collecting RTCP-XR (RFC 3611) SIP quality packetsPredecessorMuch thank to the project at:https://github.com/pbertera/vq-collectorThe core concepts and processing core were taken from there.
Most code has been refactored and stripped down.Basic usageThis is meant to be part of a larger project (hence a library.)
I highly suggest you configure your phones to send to your collector
with the "name" set to the mac address of the handset. This is the only way to uniquely identify a handset (that I've found at least.)To run the code with all the defaults:#!/usr/bin/python3

from rtcpxr_collector import vqcollector
vqs = vqcollector.CollectorServer()
vqs.listen()Generally you will use a custom handler, so here's an example:#!/usr/bin/python3
import datetime
from rtcpxr_collector import vqcollector

def logHandler(r):
    print("%s %s %s CQ:%s LQ:%s Local:%s Remote:%s"%(datetime.datetime.now(), 
                                             r['Handset']['MAC'],
                                             r['CallID'],
                                             r['QualityEst']['MOSCQ'],
                                             r['QualityEst']['MOSLQ'],
                                             "%s %s"%(r['LocalID']['name'],r['LocalID']['desc']),
                                             "%s %s"%(r['RemoteID']['name'],r['RemoteID']['desc']) ))
    return True

vqs = vqcollector.CollectorServer(handler=logHandler)
vqs.listen()Maybe you want to run on a non-stadard IP or port:#!/usr/bin/python3

from rtcpxr_collector import vqcollector
vqs = vqcollector.CollectorServer(local_ip=10.10.10.15, port=5061)
vqs.listen()All the optionsThe CollectorServer object opens a SIP socket to receive RTCP-XR packets,
parses them, then sends the data to a handler.

Attributes:
    local_ip (ipV4 address): [None] Local IPV4 address to bind to (None: Autodetect)
    port (int)             : [5060] Local Port to bind to
    reply_to_socket (bool) : [False] Should we reply to the address from the socket, or the SIP Header
    debug (bool)           : [False] Print Debugging information
    handler (func)         : [None] Handler function for recieved data (None: pprint res data)
    timeout (int)          : [10] Select Timeout in seconds
    timeout_handler (func) : [None] Handler for select timeout event

Handler Function:
    Takes 1 arg that is the parsed data structure.
    Returns: Send Response Packet? True or False
Package: rtcqs
Introductionrtcqs is a Python utility to analyze your system and detect possible
bottlenecks that could have a negative impact on the performance of your
system when working with Linux audio. It is heavily inspired by raboof’s
excellentrealtimeconfigquickscanscript.FeaturesBasically the same as realtimeconfigquickscan:Root checkAudio group checkCPU frequency checkHigh resolution timers checkPreempt RT checkrtprio checkSwappiness checkFilesystem checkAdditional features:Spectre/Meltdown mitigations checkBasic IRQ check of sound cards and USB portsPower management checktkinter GUIQt GUI (beta)InstallationGUIIf you want to use the GUI you will have to install thepython3-tkpackage or similar for your distro.Home directoryMake surepipis installed, on Ubuntu this would be thepython3-pippackage. Withpipinstalled you can install rtcqs with the following
command.pip install --upgrade rtcqsYou can now run rtcqs by simply runningrtcqsin a terminal. The GUI can
be run with withrtcqs_gui.Virtual EnvironmentMake sure the virtual environment module is installed, on Ubuntu this would
bepython3-venv. Then create a virtual environment in a directory of
choice and install rtcqs in there.mkdir -p ~/path/to/rtcqs
cd ~/path/to/rtcqs
python3 -m venv venv &&
. venv/bin/activate &&
pip install --upgrade rtcqsYou can now run rtcqs by simply runningrtcqsin a terminal. The GUI can
be run with withrtcqs_gui. Next time you’d like to run the script or the
GUI load the virtual environment again and run eitherrtcqsorrtcqs_gui.. venv/bin/activate
rtcqs
rtcqs_guiOverviewWhen running the GUI it will immediately show the results of the checks. All
checks have their own tab. Each tab title consists of a symbol that shows the
check result and the name of the check. A ✔ means the check was successful
while a ✘ means rtcqs encountered an issue. This way you can quickly spot
which checks have issues.Clicking ‘Cancel’ will close rtcqs. Clicking ‘About’ will bring up a popup
window which displays the version and a short description.rtcqs main window (tkinter version)rtcqs about window (tkinter version)Future plansExtend filesystem checkDisk scheduler checkContactTo contact me send me a mail or if it’s a technical issue or question, use
this project’s issue tracker.ThanksMany thanks of course to the original author of realtimeconfigquickscan,
Arnout Engelen a.k.a. raboof.
Package: rtd-ae
Learning topology-preserving data representations (ICLR 2023)This repository contains code base for the paper which introduces a novel method for global structure preserving dimensionality rediction based on Topological Data Analysis (TDA), specifically Representation Topology Divergence (RTD).DescriptionThe proposed method aims to provide topological similarity between the data manifold and its latent representation via enforcing the similarity in topological features (clusters, loops, 2D voids, etc.) and their localization. The core of the method is the minimization of the Representation Topology Divergence (RTD) between original high-dimensional data and low-dimensional representation in latent space. RTD minimization provides closeness in topological features with strong theoretical guarantees. We develop a scheme for RTD differentiation and apply it as a loss term for the autoencoder. The proposed method “RTD-AE” better preserves the global structure and topology of the data manifold than state-of-the-art competitors as measured by linear correlation, triplet distance ranking accuracy, and Wasserstein distance between persistence barcodes.DependenciesThe code base requires Python 3.8.X and installation of packages listed inrequirements.txt.UsageFor reproducing experiments and training RTD-AE, please refer toAE training.ipynbnotebook.
For training benchmark models such as UMAP and t-SNE, please refer toTSNE and UMAP.ipynbnotebook.
For visualization purposes, please refer toVisualization and metrics.ipynb.Cite us@inproceedings{trofimov2023learning,
title={Learning topology-preserving data representations},
author={Ilya Trofimov and Daniil Cherniavskii and Eduard Tulchinskii and Nikita Balabin and Serguei Barannikov and Evgeny Burnaev},
booktitle={International Conference on Learning Representations},
year={2023},
url={https://openreview.net/forum?id=lIu-ixf-Tzf}
}
Package: rtdip-sdk
What is the RTDIP SDK?​​Real Time Data Ingestion Platform (RTDIP) SDKis a python software development kit built to provide users, data scientists and developers with the ability to interact with components of the Real Time Data Ingestion Platform, including:Building, Executing and Deploying Ingestion PipelinesExecution of queries on RTDIP dataAuthentication to securely interact with environments and dataSeeRTDIP Documentationfor more information on how to use the SDK.LicensingDistributed under the Apache 2.0 License. SeeLICENSE.mdfor more information.Need help?For reference documentation, pre-requisites, getting started, tutorials and examples visitRTDIP Documentation.File an issue viaGithub Issues.Check previous questions and answers or ask new ones on our slack channel#real-time-data-ingestion-platformCommunityChat with other community members by joining the#real-time-data-ingestion-platformSlack channel.Click here to join our slack community
Package: rtd-phylogeny
RTD PhylogenyMolecular phylogeny analysis using Return time distribution (RTD) based alignment-free sequence analysis methodAuthorPandurang Kolekar, PhD Bioinformaticshttp://orcid.org/0000-0003-0044-0076E-mail:pandurang.kolekar@gmail.comWebsite:http://biosakshat.wixsite.com/pandurang-kolekarIntroductionReturn time distribution (RTD) is a method for alignment-free phylogenetic analysis using nucleotide / protein sequences. The method first computes the RTDs of k-mers and summarize them using the parameters of RTDs viz. mean and standard deviation for each of the sequences. Thus, each sequence is converted into a numeric vector of the size2*4k. The pair wise distance between numeric vectors of sequences is calculated using Euclidean distance function. The pairwise distance matrix, thus obtained is given as an input to Neighbor-joining clustering algorithm to reconstruct phyogenetic tree.The statistical details of the method are described inKolekar et al. 2012RequirementsTested on Python 3.7
Please refer to requirements.txt fileInstallationpipinstallrtd-phylogenyQuick Startpython-mrtd_phylogeny--help
python-mrtd_phylogeny--version
python-mrtd_phylogeny--fastaFile<input_file>--seqTypeN--kmerSize3Web ServerThe web server for RTD-based phylogeny is available fromhttp://bioinfo.unipune.ac.in/RTD/.Perl ExecutablesThe standalone Perl executables for RTD Phylogeny program are available fromhttp://bioinfo.unipune.ac.in/RTD/download.html.Citation InformationIf you find this program useful please cite it as following,Kolekar P., Kale M., Kulkarni-Kale U., Alignment-free distance measure based on return time
distribution for sequence analysis: Applications to clustering, molecular phylogeny and subtyping,
Molecular Phylogenetics and Evolution, (2012) 65(2): 510-522PubMed ID:22820020FeedbackPlease do feel free to give your comments / suggestions about this package by any of the following mode.Report an issue on this GitHub repositoryhereE-mail us atrtd.phylogeny@gmail.comFill the feedback form for the RTD Phylogeny server: AvailablehereYour feedback is highly valuable!