Saravanan666/pypi-org huggingface dataset:
Package: rt.ploneversions
rt.ploneversionsRetrieve information from dist.plone.org to safely
and easily pin your egg versions.MotivationIt is a common practice, for Plone buildouts,
to extend online configuration files
that declare known good working versions.
Those external resources can, in turn,
extend other remote resources.This means that your buildout relies on the assumption
that the all those external resources are available.
If they are not buildout will fail:
a network problem can really turn out in a catastrophe!This already happened. Luckily there are workarounds to solve this issue:https://devblog.4teamwork.ch/blog/2013/06/06/download-dot-zope-dot-org-is-down-how-to-fix-buildout/Another (minor) issue with this approach is that
you have to wait for the resources to be fetched
before starting.Some other times, you may not want to include network resources,
e.g. because your customer network will not easily allow you
to fetch them.Given that I don’t want to cross my finger
and wait for those resources to be retrieved on the net,
I started including all those externals
known good working versions in a file.It is tedious to do it by hand,
because you have to fetch and merge some files in the correct order,
so I wrote theploneversionsscript.I hope you will enjoy it!InstallationThe latest version of this package supports only Python 3.
If you need to use this package on Python2 please use the 0.9.2 version.You can installrt.ploneversionswith pip or easy_install:pip install rt.ploneversionsUsageLaunch theploneversionsscript
passing a valid Plone version.Example output (with some ellipses):$ ploneversions 4.3-latest
## https://download.zope.org/zopetoolkit/index/1.0.8/zopeapp-versions.cfg
zope.app.applicationcontrol = 3.5.10
...
zope.rdb = 3.5.0

## https://download.zope.org/zopetoolkit/index/1.0.8/ztk-versions.cfg
zope.annotation = 3.5.0
...
zope.kgs = 1.2.0

## https://download.zope.org/Zope2/index/2.13.21/versions.cfg
Zope2 = 2.13.21
...
zope.testbrowser = 3.11.1

## https://dists.plone.org/release/4.3-latest/versions.cfg
docutils = 0.9.1
...
zc.relation = 1.0You may want to redirect this output to a file, e.g.:$ ploneversions 4.3-latest > versions.cfgand add this file to your buildout.You can check the available Plone versions herehttps://dist.plone.org/release.AuthorsThis product was developed by RedTurtle Technology team.Changelog for rt.ploneversions1.0.0 (2020-03-10)Better error message when we cannot read the versions.cfg from dist.plone.orgPython 3 support. If you need to use this package on Python2 please use the 0.9.2 version.
[ale-rt]0.9.2 (2019-10-26)Use https URLs
[ale-rt]0.9.1 (2013-10-06)Suggest usage
[ale-rt]0.9.0 (2013-10-01)Initial release
[ale-rt]
Package: rtplot
rtplotAuthor: Nabeel Sherazi,sherazi.n@husky.neu.eduHave you ever noticed how if you want to plot a data stream in real time using matplotlib, it's uhhhhhh absolutely impossible? Like something about FuncAnimation and threading and basically all of this stuff -- IT'S SO FRICKING HARD TO JUST PLOT A DATA STREAM IN REAL TIME.Well I Googled about this for like six hours and found literally not a single library that would just let me looking at a frickin stream of numbers in real time. So I said okay fine I'll just frickin write it myself and then put it out there so no one ever has to struggle with this again.Presenting: rtplot --  it's real time plotting, but it's actually easy!!! For once!!!Literally just import it. Start a plot. Push data to the plot whenever you want. Or don't. It literally doesn't matter. rtplot can do real-time XY plots and real time timeseries (single variable) data. It's so sweet. It can do multiple plots too. Like 20 timeseries at once. At 60 fps. Seriously.UsageLook at this.fromrtplotimportTimeSeriesplot=TimeSeries(seconds_to_show=10)plot.start()whileTrue:new_data=read_sensor_data()plot.update(new_data)plot.quit()BRUH!!!!!fromrtplotimportXYplot=XY(seconds_to_show=3)# Or not! Leave blank to show all dataplot.start()whileTrue:xy1=robot1.position()xy2=robot2.position()plot.update([xy1,xy2])plot.quit()Supports context managers, custom linestyles, static background drawings, shortcuts, and more too!!! It's so fricking BATTERIES INCLUDED.# Context managerwithrtplot.XY()asplot:xy=datastream.read()plot.update(x,y)# Staticsplot1=rtplot.TimeSeries(seconds_to_show=10,linestyle='r-')plot1.add_static("vline",x=5)# Shortcuts for common linestylesimportrtplot.shortcuts.shapeasshape_shortcutsplot1.add_static("rectangle",**shape_shortcuts.blue_dotted_stroke)# By the way, this is safe since EVERY PLOT IS IN ITS OWN THREAD!!!plot1.start()plot2=rtplot.XY(seconds_to_show=10,linestyle=["r-","b:"])# Let rtplot know in advance there should be two linesplot2.start()Basically this stuff goes off man.InstallEither download this repo or just runpip install rtplotNatively Python 3 unlike some of the solutions I found!!!! Only external dependencies numpy and matplotlib.
One day I'll write some real docs for this but for now the source code is really small so if you don't get how to use something just look at the source code. I think I commented it pretty well. Also see the examples.DEUCES
Package: rtpPayload-ttml
rtpPayload_ttmlThis python library provides a means to decode, encode, and interact with TTML RTP payloads as defined inRFC 8759. It is designed for use with an RTP library such asRTP. It only encodes/decodes the payload bitstreams. It DOES NOT provide a means to render or edit TTML documents. It also doesn't provide any network functionality. To send these payloads over UDP, check outrtpTTML.InstallationpipinstallrtpPayload-ttmlExample usagefromrtpimportRTP,PayloadType,ExtensionfromrtpPayload_ttmlimportRTPPayload_TTMLfromcopyimportdeepcopybaseRTP=RTP(marker=True,payloadType=PayloadType.DYNAMIC_96,extension=Extension(startBits=getExtStartBits(),headerExtension=getExtBody()),csrcList=getCSRCList())thisRTPBitstream=baseRTP.toBytearray()whileruning:nextRTP=deepcopy(baseRTP)nextRTP.sequenceNumber+=1nextRTP.timestamp=getNextTimestamp()nextRTP.payload=RTPPayload_TTML(userDataWords=getNextDoc())transmit(nextRTP)fromrtpimportRTPfromrtpPayload_ttmlimportRTPPayload_TTMLdecodedPayload=RTPPayload_TTML.fromBytearray(RTP().fromBytearray(getNextPacket()).payload)document=decodedPayload.userDataWordsrender(document)ContributingWe desire that contributors of pull requests have signed, and submitted via email, aContributor Licence Agreement (CLA), which is based on the Apache CLA.The purpose of this agreement is to clearly define the terms under which intellectual property has been contributed to the BBC and thereby allow us to defend the project should there be a legal dispute regarding the software at some future time.If you haven't signed and emailed the agreement yet then the project owners will contact you using the contact info with the pull request.LicenseSeeLICENSE.AuthorsJames SandfordFor further information, contactcloudfit-opensource@rd.bbc.co.uk
Package: rtpplayapi
RTPPlay-APIRTP is the portuguese public broadcaster (Rádio e Televisão de Portugal). Their platform, RTPPlay gives free access to on demand and live tv content.This python package usesrtpplay'smobile api to fetch their content. As opposed to web scraping, this is not expected to break too often.This package is in no way official nor endorsed by RTP.InstallationpipinstallrtpplayapiUsagefromrtpplayapiimportRTPPlayAPIrtppapi=RTPPlayAPI()print(rtppapi.search("offline"))EndpointsNOTE:Some endpoints are missing, feel free to PR.get_live_tv_channelsget_live_radio_channelsget_slideshowget_collectionget_channel_epgget_channelget_programget_episodelist_episodeslist_programssearchLook at the docstrings on rtpplayapi/api.py for example responses and parameter description.
Package: rtpt
Remaining-Time-To-Process (RTPT)RTPT class to rename your processes giving information on who is launching the process, and the remaining time for it.InstallationUsing pippip install rtptFrom sourcegit clone
python setup.py installExample.. code:: pythonfromrtpt.rtptimportRTPTimportrandomimporttime# Create RTPT objectrtpt=RTPT(name_initials='QD',experiment_name='TestingRTPT',max_iterations=10)# Start the RTPT trackingrtpt.start()# Loop over all iterationsforepochinrange(10):time.sleep(4)# Perform a single experiment iterationloss=random.random()# Update the RTPT (subtitle is optional)rtpt.step(subtitle=f"loss={loss:2.2f}")
Package: rtpTTML
rtpTTMLA library for transmitting/receiving TTML documents over RTP as perRFC 8759.What rtpTTML does/doesn't doThis library is very minimal. It takes documents as strings, encodes them as an RTP payload, and sends them over UDP. It's doesn't currently implement any of the RTP control mechanisms, SDP, FEC, document validation, document rendering etc. PRs welcome if you want to add these features!This library makes use ofRTPandrtpPayload_ttmlfor encoding/decoding the payload bitstreams.InstallationpipinstallrtpTTMLExample usageThere are fully functional transmitter and receiver examples in theexamples directory. The bare minimum usage is as follows.fromrtpTTMLimportTTMLReceiverdefprocessDoc(doc,timestamp):print("{}\n".format(doc))port=12345client=TTMLReceiver(port,processDoc)client.run()fromtimeimportsleepfromdatetimeimportdatetimefromrtpTTMLimportTTMLTransmitteraddress="127.0.0.1"port=12345withTTMLTransmitter(address,port)astx:whileTrue:docStr=generateDoc(tx.nextSeqNum)nowTime=datetime.now()tx.sendDoc(docStr,nowTime)sleep(1)DebuggingIf you are looking to debug RTP TTML packets on the wire, you might be interested in the wireshark disector availablehere.ContributingWe desire that contributors of pull requests have signed, and submitted via email, aContributor Licence Agreement (CLA), which is based on the Apache CLA.The purpose of this agreement is to clearly define the terms under which intellectual property has been contributed to the BBC and thereby allow us to defend the project should there be a legal dispute regarding the software at some future time.If you haven't signed and emailed the agreement yet then the project owners will contact you using the contact info with the pull request.LicenseSeeLICENSE.AuthorsJames SandfordFor further information, contactcloudfit-opensource@rd.bbc.co.uk
Package: rtpy
rtpyPython wrapper for theJFrog Artifactory REST APIDocumentationhttps://rtpy.rtfd.ioInstallation$pipinstallrtpyUsageimportrtpy# instantiate a rtpy.Rtpy objectsettings={}settings["af_url"]="http://..."settings["api_key"]="123QWA..."# settings["username"] = "my_username"# settings["password"] = "my_password"af=rtpy.Rtpy(settings)# use a methodr=af.system_and_configuration.system_health_ping()print(r)# OKRunning the testsRequirements :Dependencies : see [tool.poetry.dependencies] and [tool.poetry.dev-dependencies] inpyproject.tomlArtifactory instance (with a valid license) runningNEVER run the tests on a production instance!LaunchSet the following environment variables:AF_TEST_URLAF_TEST_USERNAMEAF_TEST_PASSWORDThe user must have admin privileges (it's API key will be revoked during the tests)Clone the repository and launch the tests using the command :$python-mpytest-v
Package: rtquery
AbstractRequirementsUsageExtra functionalityAbstractSimplifies query interface forRequest Tracker’s rest-api libRT Library.
Main query interface has been take fromDjango FrameworkprojectRequirementsPython 3.4+RT Library(it’s not dependency itself, but it uses in examples)Usageimportrtclient=rt.Rt('http://localhost/rt/REST/1.0/',basic_auth=('user','password'))assertclient.login()#: rt filtering does not support `in` operation, so interface looks similar#: to django querying, but it sticks to its limits.query=Q(Subject__contains='[improvements]')|Q(Subject__contains='[enhancements]')query&=Q(Queue='development',Status='sprint',Owner='User',Priority__gt=80)result=client.search(Queue=rt.ALL_QUEUES,raw_query=query.resolve())print(result)[{"id":"ticket/471147","Queue":"development","Owner":"User","Creator":"User","Subject":"[improvements] Implement Requests Tracker simple querying","Status":"sprint","Priority":"99","InitialPriority":"40","FinalPriority":"40","Requestors":["user@example.org.fake"],"Created":"Thu Nov 02 19:26:40 2017","Starts":"Not set","Started":"Thu Nov 02 19:27:12 2017","Due":"Not set","Resolved":"Not set","Told":"Not set","LastUpdated":"Thu Nov 09 17:20:33 2017","TimeEstimated":"180 minutes","TimeWorked":"0","TimeLeft":"0","CF.{Tags}":"extra","CF.{Code Review}":"","CF.{Difficulty}":""}]Extra functionalityIn addition to existentrtquery.Qyou can also try to useutils.querybuilder which is simple dsl to makeQobjects from user input (argument parser for example)fromrtquery.utilsimportqueryqset=query("Queue = development & Status = sprint & Owner ~ user")result=client.search(Queue=rt.ALL_QUEUES,raw_query=query.resolve())# ...
Package: rt-range
OxTS RT-Range data parsing utilityThis simple parser is capable of parsing RT-Range Ethernet packets (NCOM and RCOM).REQUIRES PYTHON 3.10 OR NEWERInstallationUsepipto installpipinstallrt-rangeUsageBasic parsingfromrt_range.ethernetimportEthernetParserrt_packet:bytes=...# RT-Range Ethernet packet# Parsing with automatic packet type identificationparsed:dict[str,...]=EthernetParser.parse_rt_ethernet(rt_packet)The packet type will be determined automatically.
RaisesValueErrorif the bytestring is not a valid RT-Range packet.
RaisesNotImplementedErrorif the parser for detected type is not implemented.Specifying packet typefromrt_range.ethernetimportEthernetParser,PacketTypencom_data:list[bytes]=...# RT-Range Ethernet packets list# Parsing with specified typeparsed:list[dict[str,...]]=[EthernetParser.parse_rt_ethernet(packet,PacketType.NCOM)forpacketinncom_data]This forces the parser to use the specified packet type
regardless of the packet contents. Use this only if you are sure about the packet content
asit may lead to parsing errors or unexpected values in the parsing result.RaisesNotImplementedErrorif the parser for detected type is not implemented.Using Pandasimportpandasaspdfromrt_range.ethernetimportEthernetParser,PacketTyperange_data:list[bytes]=...# RT-Range Ethernet packets list# Parsing and converting to DataFrameparsed=pd.DataFrame([EthernetParser.parse_rt_ethernet(packet,PacketType.RCOM_extended_range)forpacketinrange_data])The returned list of dictionaries can be easily converted to the Pandas Dataframe
for further processing.Short documentationClassEthernetParserPackage:rt_range.ethernet.eth_parserImport:from rt_range.ethernet import EthernetParserPurpose: RT-Range NCOM and RCOM packets parsingMembers:Class methodis_implemented(cls, packet_type: PacketType)ReturnsTrueif the parser for the specified packet type is implemented,FalseotherwiseClass methodparse_rt_ethernet(cls, buffer: bytes, packet_type: PacketType | None = None)Parse bytes buffer todict[str, ...]EnumPacketTypePackage:rt_range.ethernet.eth_parserImport:from rt_range.ethernet import PacketTypePurpose: RT-Range packets types definitionsMembers:NCOMRCOM_laneRCOM_extended_rangeRCOM_wrapped_NCOMRCOM_trigger_timeRCOM_polygonRCOM_multiple_sensor_pointUnknownEnumSyncBytePackage:rt_range.ethernet.eth_parserImport:from rt_range.ethernet import SyncBytePurpose: Sync Byte definitions for distinguishing NCOM and RCOMMembers:NCOMRCOMClassPacketPackage:rt_range.ethernet.rt_packetImport:from rt_range.ethernet.rt_packet import PacketPurpose: RT-Range parseable PacketMembers:Methoddecode(self, buffer: bytes) -> tuple[np.array, Selector]Decodes bytes buffer withnp.dtypetonp.arrayMethodget(self, obj: np.array, name: str, selector: Selector)Decodes raw value using rules defined in packet structureMethodtranslate(self, obj: np.array, selector: Selector) -> dict[str, ...]Translatesnp.arrayinto a dictionaryMethodparse(self, buffer: bytes) -> dict[str, ...]Wrapper for decoding and translation
Package: rtrlib
rtrlib-pythonrtrlib-python is a cffi based python binding forrtrlib.Sphinx docs can be found in the docs directory and build withmake html.for usage examples see the tools directoryFeaturesFeatures supported so far:Prefix validationrtr_mgr callbacksInstall InstructionsRequirementspython 2.7 or python 3cffi>=1.4.0enum34sixand a c compiler at build time.If you are using virtualenv the Requirements are installed automatically during the install step, otherwise you have to use your platforms package management tool or just run pip install -r requirements.txt.Download and Installationgit clonehttps://github.com/rtrlib/python-binding.gitcdpython-bindingpython setup.py buildpython setup.py install
Package: rtrpy4
Contentfulprovides a content infrastructure for digital teams to power content in websites, apps, and devices. Unlike a CMS, Contentful was built to integrate with the modern software stack. It offers a central hub for structured content, powerful management and delivery APIs, and a customizable web app that enable developers and content creators to ship digital products faster.This library provides rendering capabilities for theRichTextfield type. It is recommended to be used alongside theContentful Delivery SDK <https://www.github.com/contentful/contentful.py>.
By default this library will serializeRichTextfields into it’s corresponding HTML representation. All behaviour can be overridden to serialize to different formats.InstallationInstall Contentful Rich Text Renderer from the Python Package Index:pip install rich_text_rendererUsageCreate a renderer:from rich_text_renderer import RichTextRenderer

renderer = RichTextRenderer()Render your document:renderer.render(document)Using different renderersThere are many cases in which HTML serialization is not what you want.
Therefore, all renderers are overridable when creating arich_text_renderer.RichTextRenderer <rich_text_renderer.RichTextRenderer>.Also, if you’re planning to embed entries within your rich text, overriding the'embedded-entry-block'option is a must,
as by default it only does<div>str(entry)</div>.You can override the configuration like follows:renderer = RichTextRenderer({
    'embedded-entry-block': MyEntryBlockRenderer
})WhereMyEntryBlockRendererrequires to have arender(self, node)method and needs to return a string, also it requires to be initialized with adictcontaining mappings for all renderers.An example entry renderer, assuming our entry has 2 fields callednameanddescriptioncould be:from rich_text_renderer.base_node_renderer import BaseNodeRenderer

# BaseNodeRenderer implements the `__init__` method required.
class MyEntryBlockRenderer(BaseNodeRenderer):
    def render(self, node):
        entry = node['data']['target']

        return "<div class='my-entry'><h3>{0}</h3><p><small>{1}</p></small></div>".format(
            entry.name,
            entry.description
        )Dealing with unknown node typesBy default, this library will treat all unknown node types as errors and will raise an exception letting the user know which node mapping is missing.
If you wish to remove this behaviour then replace theNonekey of the mapping with aNullRendererthat returns an empty string, or something similar.An example would be like follows:class SilentNullRenderer(BaseNodeRenderer):
    def render(node):
        return ""

renderer = RichTextRenderer({
    None: SilentNullRenderer
})LicenseCopyright (c) 2018 Contentful GmbH. SeeLICENSEfor further details.ContributingFeel free to improve this tool by submitting a Pull Request.
Package: rtrsub
rtrsub - RTR SubstitutionA substitute for the RTR protocol: generate configuration blobs for your
routers instead of using the RTR protocol to interact with RPKI.Installationpip3 install rtrsubUseTemplates are in jinja2 format. Thanks to the template approach, you can adopt
this tool to any platform or routing policy configuration style.Review thebird.j2for an example.There are a number of variables available to the template, please review theJSON example.hanna:rtrsub job$ rtrsub -h
usage: rtrsub [-h] [-c CACHE] --afi AFI [-t TEMPLATE] [-o OUTPUT] [-v]

optional arguments:
  -h, --help   show this help message and exit
  -c CACHE     Location of the RPKI Cache in JSON format
               (default: https://console.rpki-client.org/vrps.json)
  --afi AFI    [ ipv4 | ipv6 | mixed ]
  -t TEMPLATE  Template file (default: STDIN)
  -o OUTPUT    Output file (default: STDOUT)
  -v           Display rtrsub version
hanna:rtrsub job$Vurt:rtrsub job$ rtrsub --afi ipv4 -t template-examples/bird.j2 -o example-output.conf
Vurt:rtrsub job$orVurt:rtrsub job$ rtrsub --afi ipv4 < template-examples/bird.j2 > example-output.conf
Vurt:rtrsub job$Copyright (c) 2016-2018 Job Snijdersjob@instituut.net
Package: rt.searchtitlegroups
IntroductionThis product allow to search in titles and ids of groups of Pone3.
To do this we have done some changes at Plone’s functionality.First of all we have fixed an error in the updateGroup procedure to save in the correct way the user in Zope.
To do this we have patched Products.PlonePAS like Plone4 does.
Connected to this we have modified the prefs_group_edit script.
The modify is necessary to keep updated the groups in Zope when the users modifies the groups by the Plone form.To modify the search functionality we have create a view that does two search into the groups:
one in the id and one in the title.
We go to use the new view for search into the manage of groups of Plone (plone control panel) and sharing tab.Changelog1.2 (2010-11-22)pypi release1.1 (2010-10-28)update some metadata and release1.0 (2010-05-06)Initial release
Package: rt-server-client
RT-server-clientUPDATE:According to new version 0.3.0 there are few breaking changes.
Be aware when upgrading.CHANGELOG 0.3.0:Removed Python 2.7 support,Python 3.x only is supportedBig redesign in SW installation. Use setup.py or pip to install--initoption for initializing custom Attributes in racktablessplit code into few different classesDescriptionThis is server discovery script for Racktables project.
It discover system, import or update infromation into racktables databaseScript support following infromationhostnametransfer comment field to server motd (message of the day)commend-edit utility for editing comments on racktables directly from serverservice tagsupermicro exeption for service tag (my supermicro servers has all same ST and Expres ST. I don't know why)for Dell servers: get warranty and support information from Dell website based on server ST.Physical and logical interfaces (eth,bond,bridges,venet and veth)IPv4 and IPv6 IP addresses, import and update in databaseDell iDrac IP address (require Dell-OMSA Installed)OS Dristribution and Release informationHW vendor and product typeHypervisor recognition (Xen 4.x)Hypervisor recognition (OpenVZ)Virtual server recognition (Xen 4.x)Virtual server recognition (OpenVZ)Link Virtual server with hypervisor as container in RacktablesRacktables logging - when change ip addresses or virtual link with hypervisorInterface Connection (LLDPD needed for this feature. System automaticly link server interfaces with switch ports in RackTables)For some description, screenshots and examples visithttps://www.cypherpunk.cz/automatic-server-audit-for-racktables-project/RequirementsRequiredracktables-api (install with pip >=0.2.7)Python >= 3.5.xlsb-release package(detection of Linux distribution and release)Optionalsmbios-utils (HW Vendor, Server model and Service-Tag)if you don't use smbios-utils, script generate random servicetag in /etcLLDPd (information about interface connection with switches and other devices)Dell OMSA (for information about iDRAC configuration)InstallationInstall it as normal python sw using pip or setup.py.PIP Installpip install rt-server-clientManual Installgit clone https://github.com/rvojcik/rt-server-client
cd ./rt-server-client
sudo python ./setup.py installConfigurationConfiguration file have to be located in/etc/rt-server-client/main.confwith content something like this:[mysqldb]
user=racktables
password=mysecretpass
db=racktables_db
host=192.168.1.1
port=3306When you have your configuration file you have to runinitializationof the project.
It requires number of custom attributes in racktables database. Initialization process
check if these attributes are available and map them to correct object types.Just runsystem-info -d --initNormaly script ends without any output. If something go wrong it returns some output of the error.Then you can run thesystem-infomanualy, from crontab or timer.