Saravanan666/pypi-org huggingface dataset:
Package: rez-pip
rez-pipModern rez-pip implementation. Very WIP.TODOsInstall packages without using pipSpecify Python version to useBetter logs and CLI experienceUse loggingProgress bars for download?Confirm that Python 2 is supportedIt is not...Confirm that the theory works as expectedWindows supportHook into rezInstall each package in a different--targetCreate rez packageCopy distribution files to rez package.Make it available as a rez plugin/sub-commandDiscover Python package using rez and use that when available. I think it's still fine to support non-rezified Python interpreters though.Only download+convert package if it's not already in the rez repositories.etcAccept multiple package names as inputAccept requirements files as inputAccept wheel files as inputProperly support platform tags (wheels tags) so that GLIBC is respected, min macOS is also supported.Correctly handle Requires-Python metadata.Review all TODOs in the code.What whould we do withrez.systemandrez.vendor.version?Gather a list of problematic packages from GitHub and test against them.Go through GitHub issues and summarize what needs to be covered by the new rez-pip.Support abi3 wheels (to avoid having to re-install C extensions for every python version).https://docs.python.org/3/c-api/stable.htmlhttps://peps.python.org/pep-0425/Basically a tag like 'cp36-abi3-manylinux_2_24_x86_64' means
that it is compatible with Python 3.6+ and doesn't need to be
recompiled for newer python versions.TipsFor now, it can be run like this:rez-pip2 pytestBy default, rez packages will be released. You can choose a different path by passing the--install-pathargument to rez-pip2.Packages to test againstpytestPySide, PySIde2, PySide6PyQt4, PyQt5psycopg2-binaryipythonnumpyprotobufclickPygments (https://github.com/AcademySoftwareFoundation/rez/issues/1430)google_api_core (https://github.com/AcademySoftwareFoundation/rez/issues/1414)sphinxnetworkx[default] (https://github.com/AcademySoftwareFoundation/rez/issues/1409)black (https://github.com/AcademySoftwareFoundation/rez/issues/1341)pylint (https://github.com/AcademySoftwareFoundation/rez/issues/1024)ampq (https://github.com/AcademySoftwareFoundation/rez/issues/906)cmd2 (https://github.com/AcademySoftwareFoundation/rez/issues/895)astroid (https://github.com/AcademySoftwareFoundation/rez/issues/876)Qt.py (https://github.com/AcademySoftwareFoundation/rez/issues/503)PillowBeautifulSoup4python-dateutil (https://github.com/AcademySoftwareFoundation/rez/issues/390)
Package: rezq
rezQDescriçãorezQ is a Python library designed to help ensure data quality in Delta Lake. It provides functions to add constraints to data, remove existing constraints, and separate a DataFrame based on those constraints.InstalaçãoYou can install rezQ using pip:pipinstallrezqAdd constraintTo add a constraint to a delta table:fromrezqimportadd_constraint
fromdeltaimportDeltaTabledelta_table=DeltaTable.forPath(spark,'my_table_path')add_constraint(spark_session=spark,delta_table=delta_table,constraint_name='age_higher_than_20',constraint_code='age > 20')Add constraintsTo add multiple a constraints to a delta table:fromrezqimportadd_constraints
fromdeltaimportDeltaTabledelta_table=DeltaTable.forPath(spark,'my_table_path')add_constraints(spark_session=spark,delta_table=mock_delta_table,constraints={"name_is_not_null":"name is not null","age_higher_than_20":"age > 20"})Remove constraintTo remove a constraint to a delta table:fromrezqimport,remove_constraint
fromdeltaimportDeltaTabledelta_table=DeltaTable.forPath(spark,'my_table_path')remove_constraint(spark_session=spark,delta_table=delta_table,constraint_name='age_higher_than_20')Get constraintsTo get delta table constraints:fromrezqimport,remove_constraint
fromdeltaimportDeltaTabledelta_table=DeltaTable.forPath(spark,'my_table_path')constraint=get_constraints(delta_table)Get cleaned and quarantineTo return the cleaned_df (An DataFrame of the valid rows according to constraints)
and quarantine_df (An DataFrame of the invalid rows according to constraints.):fromrezqimportget_cleaned_and_quarantinedelta_table=DeltaTable.forPath(spark,'mybucket')cleaned_df,quarantine_df=get_cleaned_and_quarantine(delta_table=delta_table,merge_df=df)You can use the cleaned_df to create a new delta, append or merge to an existent one
and use quarantine_df to get metrics about data quality and decide later what to do
with this rows
Package: rez-tools
rez_toolsA suite tool command line forrez.This tool requires you to installrezin advance.InstallingYou can install via pip.pip install rez_toolsor through clone from Github.git clone https://github.com/loonghao/rez-tools.gitInstall package.cd rez_toolspython setup.py installQuickStartrez_toolswill find all tools viareztoolsconfig:tool_paths.> set REZ_TOOL_CONFIG=C:\Users\hao.long\PycharmProjects\rez_tools\examples\reztoolsconfig.py
> rtrtwill dynamically generate a command line and bind it to the rt namespace
based on the content defined in the found.rtfile.typertwill list all tools found. like the below.Usage: rt [OPTIONS] PLUGIN [PLUGIN OPTIONS]

Options:
  -h, --help  Show this message and exit.

Plugin Commands:
  conan_python2  A rez plugin - conan_python2.
  conan_python3  A rez plugin - conan_python3.
  python         Python3.

Tool Options:
  rez_tools run other tools with their own options and argument patterns,
  however, all tool has the following hidden options:

  --ignore-cmd  Ignore standard tool command when running the command,Remember
                to provide an argument which will be used as the command to
                run.Examples: rt conan --ignore-cmd python

  --print       Print plugin details and exit.Define the suite description ofrez-toolThe file format is .rt, the syntax isyamlThe following fields are now supported:KeyrequireddescriptionnamenoThe name of the tool, which will finally be registered in the command line.commandyesThe complete command line to be executed.requiresyesThe name of the rez package that the command line execution environment depends onExamples:maya.rtcommand:mayarequires:-maya-2020-maya_usd-maya_mtoarun command linert mayacmake_gui.rtcommand:cmke-guirequeres:-cmakerun command linert cmake_guipython-2.rtname:python_2command:pythonrequeres:-python-2.7-pyside-pyyamlrun command linert python_2
Package: rezume
Rezume is a Python library to validate and easily create aYAMLbased resume file that isJSON Resumecompatible according to
thedefined schema.InstallationInstall fromPypiby running this command:pipinstallrezumeDependenciesRezume requires Python 3.6+ and depends mainly onpydanticfor data validation andpyyamlfor processing YAML data.UsageYou can userezumeas a Python package as shown below:fromrezumeimportRezumeError,Rezume# sample (invalid) rezume data to validaterezume_data={name:'John Doe'}# check the validity of sample dataifRezume.is_valid(rezume_data):print('Validated successfully!')else:print('Invalid rezume')# alternatively, if we prefer catching exceptionstry:Rezume.validate(rezume_data)print('Validated successfully!')exceptRezumeErrorasex:print(f'Invalid rezume:{ex}')To validate a rezume file instead:frompathlibimportPathfromrezumeimportRezumeError,Rezume# path to sample file to validaterezume_file=Path('/path/to/sample/rezume-file.yml')# useRezume.is_valid(rezume_file)# returns boolean# orRezume.validate(rezume_file)# throws exception if invalidFurthermore, you can programmatically process a Rezume:importjsonfrompathlibimportPathfromrezumeimportRezumeError,Rezume# load and modify a standard JSON resumerezume=Rezume()json_file=Path('/path/to/json/resume-file.json')withjson_file.open('r')asfp:data=json.load(fp)rezume.load_data(data)# throws exception if invalidrezume.basics.name='John Doe (Verified)'print(rezume.dump_data())# or programmatically modify a YAML rezume fileyaml_file=Path('/path/to/yaml/rezume-file.yml')try:rezume=Rezume()rezume.load(yaml_file)# throws exception if invalidexceptRezumeError:print('Unable to process rezume file')else:rezume.basics.label='Pythonista'print(rezume.dump_data())In addition,rezumecan be used as a command line tool to create or validate
a YAML-based rezume file. Here is the output ofrezume--helpUsage:rezume[OPTIONS]COMMAND[ARGS]...Options:--install-completionInstallcompletionforthecurrentshell.--show-completionShowcompletionforthecurrentshell,tocopyitorcustomizetheinstallation.--helpShowthismessageandexit.Commands:initInitializesanewrezume.ymlfileserveServesarezumeforlocalviewingapplyingavailablethemestestValidatescorrectnessofarezume.ymlfileLicenseThis project is licensed under theBSD license
Package: rezun-plotbitrate
PlotBitrateFFProbe Bitrate GraphThis project contains a script for plotting the bitrate of an audio or video
stream over time. To get the frame bitrate data ffprobe is used from the
ffmpeg package. The ffprobe data is streamed to python as xml frame metadata
and optionaly sorted by frame type. Matplotlib is used to plot the overall bitrate
or each frame type on the same graph with lines for the peak and mean bitrates.
The resulting bitrate graph can be saved as an image.Possible outputs are:Image types (png, svg, pdf, ...)Raw frame data (csv, xml)Requirements:Python >= 3.5FFMpeg >= 1.2 with the ffprobe commandMatplotlib python 3 library (install:python3 -m pip install -U --user matplotlib)Installationpip install rezun-plotbitrateUsefull OptionsThe raw frame data can be stored in an xml file with the option-f xml_raw,
which the graph can be plotted from.
This is useful if the graph is should be shown multiple times with different options,
as the source file doesn't need to be scanned again.The option--downscale(or-d) is usefull if the video is very long and an overview
of the bitrate fluctuation is sufficient and zooming in is not necessary.
This behavior resembles that of the tool "Bitrate Viewer".
With this option, videos will be shown as a downscaled graph, meaning not every second is being displayed.
Multiple seconds will be grouped together and the max value will be drawn.
This downscaling is not applied when viewing individual frame types as this woud lead to wrong graphs.
This behavior cann be adjusted with the--max-display-valuesoption.
The default value is 700, meaning that at most 700 individual seconds/bars are drawn.Usage ExamplesShow video stream bitrate in a window with progress.plotbitrate input.mkvShow downscaled video stream bitrate in a window.plotbitrate -d input.mkvShow video stream bitrate for each frame type in a window.plotbitrate -t input.mkvSave video stream bitrate to an SVG file.plotbitrate -o output.svg input.mkvShow audio stream bitrate in a window.plotbitrate -s audio input.mkvSave raw ffproble frame data as xml file.plotbitrate -f xml_raw -o frames.xml input.mkvShow bitrate graph from raw xml.plotbitrate frames.xml
Package: rezup-api
rezupA cross-platformRezproduction tooling managerRead The DocsWhy use rezupEasier to setup/update Rez venvEasier to install custom Rez extensions (plugins)Easier to provide different Rez venv setup for different purposeInstallThis installs therezupfull package, command line tool and the api package.$pipinstallrezupToupgrade, you only need to upgrade the api package. So to avoid re-creating console-script.$pipinstall-Urezup-apiQuick startSimply callingrezupin terminal will suffice.$rezupThe command above is a shorthand forrezup use .main, which means to enter a Rez venv container named.main. Usually you mustrezup adda new container before you can use it. But default container.mainwill automatically be created if it's not existing yet, for the first time.So, what will & should happen after callingrezup?A most basic recipe will be written into user home directory (~/rezup.toml)Default container.mainwill be created with that recipeWait for it...Bam! A vanilla Rez environment is presented (In subprocess)Tryrez --versionor anyrezcommandOnce you're done, simply typeexitto escape.As you may have seen, Rez venv is in the container and is deployed with a recipe file. Please visitContainer-Recipepage for more detail about how you can auth and create a richer container by the recipe.And for other rezup commands, please runrezup --helporrezup [COMMAND] --helpfor each command's usage.$rezup--helpOr, visitCommandpage.
Package: rf95modem
rf95modem-pyPython library to send and receive data over LoRa PHY via a serial connection to arf95modem.This library was tested against the rf95modem commit8f163aa, slightly after version 0.7.3.InstallThis library is available on PyPI asrf95modem.pip install --upgrade rf95modemLibraryThe primary focus of this library is to send and receive data via LoRa's physical layer, LoRa PHY, with the help of arf95modem.Therefore therf95modem.reader.Rf95Reader.allows direct interaction with a connected rf95modem, including configuration changes, sending, and receiving raw LoRa PHY messages.
ThisRf95Readerextendsserial.threaded.LineReaderfrompySerial.The following short code example demonstrates how to use this library.importserialimportserial.threadedimportsysimporttimeimportthreadingimportrf95modemif__name__=="__main__":ser=serial.serial_for_url("/dev/ttyUSB0",baudrate=115200,timeout=1)withserial.threaded.ReaderThread(ser,rf95modem.Rf95Reader)asrf95:rf95.rx_handlers.append(lambdarx:print(rx))rf95.mode(rf95modem.ModemMode.MEDIUM_RANGE)rf95.frequency(868.1)print(rf95.status_fetch())try:rf95.gps_mode(True)print(rf95.gps_fetch())exceptrf95modem.Rf95UnknownCommandException:print("Seems like there is no GPS support")rf95.transmit(b"hello world")threading.Event().wait()Documentationpip install --upgrade pdoc3

cd src
pdoc --http 127.0.0.1:8080 rf95modem
xdg-open http://127.0.0.1:8080/Build a ReleaseBump theproject.versionin thepyproject.tomlfile.python3 -m build
Package: rfactor
R-factorThe R-factor is a measure used in erosion and (overland) sediment
modelling to quantify the effect of rainfall on soil erosion. It is
typically defined in the context of the RUSLE equation, in which gross
erosion for an agricultural parcel is estimated.Specifically, the R-factor is a measure for the total erosivity of a
number of rainfall events within a defined timeframe (year, month,
number of days). The factor is computed by calculating the erosivity for
every rainfall event in a timeseries, and taking the sum of the
erosivity of all events in one year. These yearly values can be used to
compute an average value, the R-factor, presenting the rainfall
erosivity for a given period. An in-depth explanation of the formula's
is given here <rfactor>.The implemented formula's in this code are developed in a context of
rainfall in Belgium (Verstraeten et al., 2006). Yet, the current Python
implementation allows for an easy integration of alternative functions
and relations. An in-depth analysis of the application of this code on
Flanders can be found in inthis
report.NoteIn the earlier versions (<0.1.0) of the R-factor package, Matlab was
used for the core computations. Since version 0.1.0, a faster Python
implementation is provided. Using the version 0.0.x will provide other
results compared to version >0.1.0, as explained in thepackage documentation.Get startedThis package makes use ofPython(and a limited number of dependencies
such as Pandas and Numpy). To install:pip install rfactorMake sure to check out the installation instructions and follow the example in
theGet started sectionof thepackage documentation.Rainfall and erosivity dataAny 10 minute ezqolurion input rainfall should work, but input rainfall data for the initial project
were provided by the Flemish Environment Agency (VMM) and the Royal Meteorological Institute (RMI).
The data from the Flemish Environment Agency (VMM) are available viawaterinfo. The input rainfall data from the
Royal Meteorological Institute (RMI) are not shared in this project.
Please contact the RMI if you would like to obtain the a copy of the RMI
rainfall input data.The erosivity data calculated with the rainfall input data are provided
by the partners of this project, and are used as test data for analysing
the R-factor for Flanders.CodeThe open-source code can be found onGitHub.DocumentationThe documentation can be found on theR-factor documentation
page.LicenseThis project is licensed under the GNU Lesser Public License v3.0, seeLICENSEfor more information.ContactWe encourage user to submit question, suggestions and bug reports via
the issues platform on GitHub. In case of other questions, one can mail
tocn-ws@omgeving.vlaanderen.bePowered byNoteThis project has been set up using PyScaffold 3.2.3. For details and
usage information on PyScaffold seehttps://pyscaffold.org/.
Package: rfacts
rfactsa very simple wrapper around requests/aiohttp for uselessfacts.jsph.plprovides 1 object that implements 2 methods, and 5 attributes.thefactclassmethodsgetandageteach take one argument, and return afactinstance:language- Type[str] - the language for the fact to be fetched, can beenordeeach instance offacthas the following attributes:id- Type[str] - the id of the factsource- Type[str] - the source for the factpermalink- Type[str] - the permanent link to this facttext- Type[str] - the text of the fact itselflanguage- Type[str] - the language of the fact_raw- Type[dict] - the raw json returned from the apiexamples:from rfacts import fact

def main() -> None:
    x = fact.get()
    print(x.text)

if __name__ == "__main__":
    main()from rfacts import fact
import asyncio

async def main() -> None:
    x = await fact.aget()
    print(x.text)

if __name__ == "__main__":
    asyncio.run(main())
Package: rfa-eagle-api
Unofficial client for Eagle-200 from Rainforest AutomationProvides the ability to query the local API interface of the Eagle-200Example 1. Query and print all variables from deviceimport eagle

client = eagle.LocalApi(host='<device ip>', username='<Cloud ID>', password='<Install Code>')
devices = client.device_list()
for device in devices:
    device = client.device_query(device.hardware_address)
    print(device.get_all_variables())Example 2. Use Meter wrapper class for simplified access to electricity meter dataimport eagle

client = eagle.LocalApi(host='<device ip>', username='<Cloud ID>', password='<Install Code>')
meters = eagle.Meter.get_meters(client)
for meter in meters:
    meter.update()
    print("Demand:", meter.instantaneous_demand)Links:Rainforest Automationhttps://rainforestautomation.com/Eagle-200https://rainforestautomation.com/rfa-z114-eagle-200-2/Developer Resources:https://rainforestautomation.com/support/developer/Local API documentation:http://rainforestautomation.com/wp-content/uploads/2017/02/EAGLE-200-Local-API-Manual-v1.0.pdf
Package: rfapi
Python 2/3 library for using the Recorded Future APIRecorded Future’s API enables you to build analytic applications and
perform analysis which is aware of events happening around the globe
24x7. You can perform queries and receive results from the Recorded
Future Temporal Analytics Engine across a vast set of events,
entities, and time points spanning from the far past into the future.SeeGitHub sourcefor further details and example usage.To install with pip runpip install rfapi
Package: rf-api-client
RedForester API clientAsynchronous client for RedForester API.PyPI packageDevelopmentInstall all requirementspipinstall-e.[dev]Lintflake8 --max-line-length=120 examples rf_api_client testsRun testsSetup environment variables:rf_api_client_usernamerf_api_client_passwordrf_api_client_base_url (optional)And run withpytest
Package: rf-appiumextensionlibrary
AppiumExtensionLibraryAuthors:Shiela Buitizon | email:shiela.buitizon@mnltechnology.comJoshua Kim Rivera | email:joshua.rivera@mnltechnology.comCompany:Spiralworks Technologies Inc.Contents:IntroductionInstallationUsageGenerating Local DocumentationDependenciesIntroductionApppiumExtensionLibraryis an extension of theAppiumLibrarybyserhatbolsu.InstallationOption 1Install this project using pypi, run:pipinstallrf-appiumextensionlibraryOption 2With recent version ofpip, it is possible to install directly from GitHub repository. To Install latest source
from the master branch, use this command:pipinstallgit+https://github.com/MainSystemDev/rf-appiumextensionlibrary.gitPlease note that using installation option 2 will take some time, becausepipwill
clone theAppiumExtensionLibraryproject to a temporary directory and then
perform the installation.UsageTo use AppiumExtensionLibrary in Robot Framework test(s), the library needs to
first be imported using theLibrarysetting as any other library.*** Settings ***DocumentationSimple example using AppiumExtensionLibraryLibraryAppiumExtensionLibrary*** Variables ***${sample_variable}*** Test Cases ***Test Case Sample One${url}Get URLLog To Console${url}Keyword DocumentationView the latest keyworddocumentation herefor more information about this library.Generating Local DocumentationTo Generate the keyword Documentation, simply run:python-mrobot.libdocAppiumExtensionLibrarydocumentation.htmlWhere: documentation.html is the output file.
Note that the library must first be installed before generating a documentation.
Package: rf-azure-sync
Robot Framework Azure SyncOverviewTheRobot Framework Azure Syncpackage provides synchronization capabilities for Azure-related tasks. It includes scripts to retrieve data from Azure Test Cases(rf_azure_sync_get.py), to update Azure Test Cases(rf_azure_sync_patch.py), and to run Robot Framework tests with specific tags.InstallationTo installrf_azure_sync, you can usepip. Open a terminal and run:pipinstallrf-azure-syncUsing the project source codeAlternatively, you can download the project source code from the repository and use it directly. You will need to have Python installed on your system.Clone the repository:gitclonehttps://github.com/fabiorisantosquispe/rf_azure_sync.gitNavigate to the project directory:cdrf_azure_syncUse the provided scriptssync_utils.py: Contains utility functions for synchronization.rf_azure_sync_get.py: Script to get data from Azure Test Cases.rf_azure_sync_patch.py: Script to patch data to Azure Test Cases.rf_azure_sync.py: Main script for synchronization and running Robot Framework tests.UsageUsing the installed packageIf you installed the package via pip, you can use the following commands:#Run synchronize_get and synchronize_patchrf_azure_sync#Just run sync_getrf_azure_syncget#Run sync_patch onlyrf_azure_syncpatchUsing the project source codeIf you are using the project source code directly, you can execute the scripts using Python:# Run synchronize_get and synchronize_patchpythonrf_azure_sync.py# Just run sync_getpythonrf_azure_sync.pyget# Run sync_patch onlypythonrf_azure_sync.pypatchConfigurationThe package requires a configuration file'sync_config.json'with Azure-related settings. If the file is not found, it will be created interactively.Example'sync_config.json':{"path":"tests","credentials":{"personal_access_token":"your_azure_personal_access_token","organization_name":"your_organization_name","project_name":"your_project_name"},"tag_config":{"test_case":"TC","user_story":"US","bug":"Bug","title":"Title","TestedBy-Reverse":"","IterationPath":"","AutomationStatus":"","ignore_sync":"","System.Tags":"","Priority":""},"constants":{"System.AreaPath":"","System.TeamProject":"","settings_section":"","test_cases_section":""}}
Package: rfb-logger-tool
System logger moduleModule used for system logger tool.  It will record log events and write them out
in a file with different information such as the file where the log is and the line.
The purpose of this module is to have a logger in common for all the files your app may need.
There are different log levels entries and the minimum log level can be configured
in a log_config.yaml
This file should be located in the folder where the main file is going to be launched.
There is a template for the log_config.yaml
The different log level entries are from less important to most:
DEBUG, INFO, WARNING, ERROR, CRITICAL--- #YAML FILE START
__main__: "DEBUG" 

##### sys #####
sys_shd: "CRITICAL"
sys_conf: "WARNING"
sys_log: "INFO"

file_handlers: {
  # "log_can" : [ drv.drv_can, drv.drv_epc ],
}Co-authors:Roberto Aldea,Javier Sanz,Marius Crisan