Saravanan666/pypi-org huggingface dataset:
Package: rasc
rascFor trashing your home directory (or.configor.local/share, for that
matter).UsageRasc can be used to handle config or other key-value data that can be
serialized into JSON or Pythondict.  For config storage, one can use
directly or write a subclass ofstorage.Configuration.  For more generic
data, one can usestorage.Storageinstead.Besidesjson, one can use different key-value formats by passingload_func,dump_funcandextinto the storage class to replacejson.loadandjson.dump.  For example, one can usetomllib.loadandtomli_w.dump, or write custom load/dump functions for SQLite.Additionally, a simple CLI command parser is also included inclifor
demonstration purpose (with commandsrasc-demoandrasc-strict),
but can also be used directly for your project.  Its usage can be seen inrasc/__init__.pyin the source code.CopyingThis project is licensed under GPL version 3 only.  The license can be found inLICENSES/GPL-3.0-only.txt.
Package: rascal
Rascal: RANSAC Assisted Spectral CALibrationRascal is a library for automated spectrometer wavelength calibration. It has been designed primarily for astrophysics applications, but should be usable with spectra captured from any similar spectrometer.Given a set of peaks located in your spectrum, Rascal will attempt to determine a model for your spectrometer to convert between pixels and wavelengths.Unlike other calibration methods, rascal does not require you to manually select lines in your spectrum. Ideally you should know  approximate parameters about your system, namely:What arc lamp was used (e.g. Xe, Hg, Ar, CuNeAr)What the dispersion of your spectrometer is (i.e. angstroms/pixel)The spectral range of your system, and the starting wavelengthYou don't need to know the dispersion and start wavelength exactly. Often this information is provided by the observatory, but if you don't know it, you can take a rough guess. The closer you are to the actual system settings, the more likely it is that Rascal will be able to solve the calibration. Blind calibration, where no parameters are known, is possible but challenging currently. If you don't know the lamp, you can try iterating over the various combinations of sources. Generally when you do get a correct fit, with most astronomical instruments the errors will be extremely low.More background information can be referred to thisarXiv article.Dependenciespython >= 3.7numpy>=1.16,<1.24scipy>=1.3.3pynverse>=0.1.4matplotlib>=3.0.3tqdm>=4.48.0Optional Dependenciesplotly>= 4.0InstallationInstructions can be foundhere.Reporting issues/feature requestsPlease use theissue trackerto report any issues or support questions.Getting startedThequickstart guidewill show you how to reduce the example dataset.Contributing Code/DocumentationIf you are interested in contributing code to the project, thank you! For those unfamiliar with the process of contributing to an open-source project, you may want to read through Github’s own short informational section on how to submit acontributionor send me a message.Style -- we now use black for formatting, you can easily set this up using a pre-commit hook.pip install pre-commit
pre-commit installDisclaimerWe duplicate some of the relevant metadata, but we do not process the raw metadata. Some of the metadata this software creates contain full path to the files in your system, which most likely includes a user name on your machine. Please be advised it is your responsibility to be compliant with the privacy law(s) that you are oblidged to follow, and it is your responsibility to remove any metadata that may reveal personal information and/or provide information that can reveal any computing vulunerability.
Package: rascal-ties
# Reconstruction by AnalogS of ClimatologicAL time series (RASCAL)
RASCAL is a python library desinged to reconstruct time series of climatological data, based on the Analog Method (AM), to use them for climate studies. The AM is a statistical downscalling method, based on the assumption that large-scale atmospheric conditions tend to produce similar local weather patterns, and therefore is possible to predict local conditions finding analog days, with similar large-scale patterns, in the historical record.
The objective of RASCAL is to generate complete time series, based on limited observational data, that can reproduce the climatic characteristics of the region to study better than the reanalysis products.### Requirements
To run this library renalaysis and observational data is required. the reanalysis data should cover the whole period to be reconstructed, and should have at least one predictor variable.The observational data temporal cover must overlap with the reanalysis data.The choice of the predictor variable is flexible. However, if you want to reconstruct a long time series, it’s important to consider that the connection between the predictor and the predicted variable should be very robust. This is because certain relationships may change in a changing climate scenario.To run RASCAL, these other python libraries are required:
- numpy
- pandas
- dask
- xarray
- scipy
- tqdm
- sklearn
- cartopy
- seaborn### References
Pending of publication. González-Cervera, A., Durán, L. (2024), RASCAL v1.0.0: An Open Source Tool for Climatological Time Series Reconstruction and Extension, Journal, DOI
Package: rasgoql
RasgoQLRasgoQL is a light-weight data transformation package to bridge the gap between dbt and pandas. It allow users to construct, print & run SQL queries using a familiar python syntax. Under the covers it sends all processing to your data warehouse, allowing efficient transformation of massive datasets.RasgoQL does these things well:Pulls existing DataWarehouse tables into pandas DataFrames for analysisConstructs SQL queries using a syntax that feels like pandasCreates views in your DataWarehouse to save transformed dataExports runnable sql in .sql files or dbt-compliant yml filesOffers dozens of free SQL transforms to useComing Soon: allows users to create & add custom transformsDocumentation is available at:https://docs.rasgoql.comWays RasgoQL can helpIf you use pandas to build features, but you are working on a massive set of data that won't fit in your machine's memory. RasgoQL can help!If your organization uses dbt of another SQL tool to run production data flows, but you prefer to build features in pandas. RasgoQL can help!If you know pandas, but not SQL and want to learn how queries will translate. RasgoQL can help!Package Dependenciesjinja2pandaspyyamlpython-dotenvrasgotransforms[snowflake]snowflake-connector-pythonsnowflake-connector-python[pandas][bigquery]google-auth-oauthlibgoogle-cloud-bigquery[postgres]psycopg2SQLAlchemypsycopg2-binary # Linux[redshift]redshift_connectorSQLAlchemysqlalchemy-redshiftMajor Version Releasesv1.0.0 (Feb 23, 2022)Added support for BigQueryAdded support for SnowflakeAdded import dataset from pandas workflowAdded export to dbt workflowv1.1.0 (Mar 8, 2022)Added support for Postgresv1.2.0 (Mar 24, 2022)Added a parameter to allow batch returning of Pandas DataFrames fromto_df()andquery_into_df()methodsv1.3.0 (Mar 25, 2022)Added support for MySQLv1.4.0 (April 8, 2022)Added failure and execution telemetry for methods in Transform and Dataset classesv1.5.0 (April 9, 2022)Added support for Amazon RedshiftSeeChangelogfor full minor version release notesAbout UsRasgoQL is maintained byRasgo. Rasgo's enterprise feature store integrates with your data warehouse to help users build features faster, collaborate with team members, and serve features to models in production.Built for Data Scientists, by Data Scientists
Package: rasgotransforms
Rasgo TransformsRasgo Transforms provide jinja SQL templates that can be applied to your data using rasgoQL, a pandas-like python package.Transforms are equivalent to SQL functions that accept a table or view from your eixsting DataWarehouse and return a SQL string to transform itRasgo has built a starter library of transforms for you to use or forkComing Soon:Users will be able to create their own Transforms and add them to a private namespace or contribute to the open-source libraryRunning TransformsRasgo Transforms can be applied via:your Rasgo Feature Store account (pyrasgo- Account required)the Rasgo open-source package (rasgoql- totally free).Package DependenciespyyamlAbout UsRasgo Transforms are maintained byRasgo. Rasgo's enterprise feature store integrates with your data warehouse to help users build features faster, collaborate with team members, and serve features to models in production.Built for Data Scientists, by Data Scientists
Package: rashi
RashiDeveloped by Crian69 (c) 2021
A simple package that scrapes outrashi falsfromhttps://www.hamropatro.com/rashifalInstalling The PackagepipinstallrashiExamples of How To UseGetting The Required Rashi FalfromrashiimportZodiacs,Length,getRashiFalhoro=getRashiFal(Zodiacs.Meen,Length.Weekly)#Gets The Rashi Fal As NamedTuple -> Rashi(rashi:str, date: str)print(horo.rashi)#the actual rashiprint(horo.date)#the date till which the rashi is valid# Other CodeAll the available Zodiacs types are:MeshMithunSinghaTulaDhanuKumbhaBrishKarkatKanyaBrischikMakarMeenAll the available Length types are:DailyWeeklyMonthlyYearly
Package: rask_cronpoke
## Repository ##https://gitlab.com/vikingmakt/rask_cronpoke## Example ##from rask.rmq import RMQ
from rask_cronpoke import Cronpokedef minute_callback(date):#called each minutedef hour_callback(date):#called each hourrmq = RMQ(‘amqp://localhost’)
c = Cronpoke(rmq)
c.add_cb_minute(minute_callback)
c.add_cb_hour(hour_callback)
Package: rasl
Align linearly correlated images, possibly having gross corruption or occlusions.Detailed description and installation instructions, along with
example code and data, are here:https://github.com/welch/raslraslis a python implementation of the batch image alignment technique
described in:Peng, A. Ganesh, J. Wright, W. Xu, Y. Ma, “Robust Alignment by
Sparse and Low-rank Decomposition for Linearly Correlated Images”,
IEEE Transactions on Pattern Analysis and Machine Intelligence (PAMI) 2011The paper describes a technique for aligning images of objects varying
in illumination and projection, possibly with occlusions (such as
facial images at varying angles, some including eyeglasses or
hair). RASL seeks transformations or deformations that will best
superimpose a batch of images, with pixel accuracy where possible. It
solves this problem by decomposing the image matrix into a dense
low-rank component (analogous to “eigenfaces” in face-recognition
literature) combined with a sparse error matrix representing any
occlusions. The decomposition is accomplished with a robust form of
PCA via Principal Components Pursuit.Dependenciesnumpy, scipy, scikit-image
Package: rasm
rasmThis is an 8-bit AVR assembler I wrote for myself.Installationpip3 install rasmUsageSee the help from the command:rasm --helpDevelopmentThis tool is written in Python 3. To run the tests you also needavr-objdump,colordiff, andxxd. On Debian or Ubuntu, these can
be installed like this:sudo apt install python3, python3-pip, python3-setuptools, python3-wheel, binutils-avt, colordiff, xxdInstall the package in editable mode:pip3 install -e .To run the test suite, just invoke:./run_tests.sh
Package: rasmipy
Reduce Arabic strings to their rasm, i.e. remove vocalization and other
diacritics.Usage>>>fromrasmipyimportrasmify>>>rasmify('الفَاتِحَة')'الڡاٮحه'InstallationFrom the Python Package Index:$ pip install ramsipyFrom the sources:$ python setup.py installWith the optional REST interface:$ pip install ramsipy[rest-api]REST APITo run a REST service:$ rasmify-rest-serviceOr in a Docker container (with the HTTP port mapped to 8000):$ docker run –rm -p 8000:80 telota/rasmifyExample GET request:$ curlhttp://localhost:8000/?text=ءَاتَيۡنَاExample POST request:$ curl -H “Content-Type: text/plain” -d ‘ءَاتَيۡنَا’ -X POSThttp://localhost:8000/There are two environment variables that can be used to configure the service:PORTdefines the port that the server listens, defaults to8000.MAX_GET_PARAMETER_LENGTHdefines the allowed maximum length of GET requests,
defaults to1024.ResourcesAbout the rasm writing script:https://en.wikipedia.org/wiki/RasmCode repository:https://github.com/telota/rasmipyOn the Python Package Index:https://pypi.python.org/pypi/rasmipyOn the Docker Hub:https://hub.docker.com/r/telota/rasmifyPHP implementation:https://packagist.org/packages/telota/rasmifyJavascript implementation:https://github.com/telota/rasmify.jsJavascript web demo:https://telota.github.io/rasmify.js/demo/ContributingIn order to run the tests, you need to install pytest and related packages,
preferably in a virtual environment:$pipinstall-rrequirements-dev.txtInstallrasmipyin an editable mode:$pythonsetup.pydevelopBefore committing changes, you should run the tests:# in the project's root directory$pytest
Package: raspador
Library to extract data from semi-structured text documents.It’s best suited for data-processing in files that do not have a formal
structure and are in plain text (or that are easy to convert). Structured files
like XML, CSV and HTML doesn’t fit a good use case for Raspador, and have
excellent alternatives to get data extracted, likelxml,html5lib,BeautifulSoup, andPyQuery.The extractors are defined through classes as models, something similar to the
Django ORM. Each field searches for a pattern specified by the regular
expression, and captured groups are converted automatically to primitives.The parser is implemented as a generator, where each item found can be consumed
before the end of the analysis, featuring a pipeline.The analysis is forward-only, which makes it extremely quick, and thus any
iterator that returns a string can be analyzed, including infinite streams.InstallRaspador works on CPython 2.6+, CPython 3.2+ and PyPy. To install it, use:pip install raspadoror easy install:easy_install raspadorFrom sourceDownload and install from source:git clone https://github.com/fgmacedo/raspador.git
cd raspador
python setup.py installDependenciesThere are no external dependencies.NotePython 2.6With Python 2.6, you must installordereddict.You can install it with pip:pip install ordereddictTestsTo automate tests with all supported Python versions at once, we usetox.Run all tests with:$toxTests depend on several third party libraries, but these are installed by tox
on each Python’s virtualenv:nose==1.3.0
coverage==3.6
flake8==2.0ExamplesExtract data from logsfrom__future__importprint_functionimportjsonfromraspadorimportParser,StringFieldout="""
PART:/dev/sda1 UUID:423k34-3423lk423-sdfsd-43 TYPE:ext4
PART:/dev/sda2 UUID:74928389-852893-sdfdf-g8 TYPE:ext4
PART:/dev/sda3 UUID:sdkj9d93-sdf9df-3kr3l-d8 TYPE:swap
"""classLogParser(Parser):begin=r'^PART.*'end=r'^PART.*'PART=StringField(r'PART:([^\s]+)')UUID=StringField(r'UUID:([^\s]+)')TYPE=StringField(r'TYPE:([^\s]+)')a=LogParser()# res is a generatorres=a.parse(iter(out.splitlines()))out_as_json=json.dumps(list(res),indent=2)print(out_as_json)# Output:"""
[
  {
    "PART": "/dev/sda1",
    "TYPE": "ext4",
    "UUID": "423k34-3423lk423-sdfsd-43"
  },
  {
    "PART": "/dev/sda2",
    "TYPE": "ext4",
    "UUID": "74928389-852893-sdfdf-g8"
  },
  {
    "PART": "/dev/sda3",
    "TYPE": "swap",
    "UUID": "sdkj9d93-sdf9df-3kr3l-d8"
  }
]
"""
Package: raspberry-epaper
Raspberry e-paper utilityA tool to easily use waveshare's e-paper module with Raspberry Pi.Installpipinstallraspberry-epaperUsageprintDisplay the image file.# For example, when using 7.5inch e-Paper HAT$epaperprint--device="epd7in5"picture.pngRandomly display the image file in a directory.$epaperprint--device="epd7in5"directoryDisplay a text file.$epaperprint--device="epd7in5"sentence.txtOverlay the QR code on the image.$epaperprint--device="epd7in5"--qr="information about the picture"picture.pngShow help.$epaperprint--helpmodulesShow available e-paper modules.$epapermodulesversionShow version.$epaperversionLicenseThis software is released under the MIT License, see LICENSE.
Fonts are licensed under the SIL Open Font License, Version 1.1.
Package: raspberry-i2c-tb6612fng
RaspberryPi Grove TB6612FNG Motor Shield LibraryThis is an open source port of the official Grove Motor Shield TB6612FNG library for Arduino to Python3 on RaspberryPI.This is a port ofGrove Arduino LibraryforGrove I2C Motor Driver on TB6612FNG.FeaturesLibrary is identical to the official GroveIt depends only on built in libraries****library requires I2C to be activated on the RaspberryPI board running Linux buildRequirementsRaspberryPi linux imagePython 3.6+smbuslibrarytimelibrarymathlibraryThis library also includes a experimental python easing functions:Contains 6 easing functions for smooth start of motorsEasing functions currently can only be used on a single motor at onceContaining IN and OUT functionsHow to useBasic usage of this library is very simple. First make sure you are running the latest released version ofpip.This library requires you to add an additionalindex-urltopip.confin order to install it. You can do this by editing your config file withsudo nano /etc/pip.confand inserting this line just after the[global]section:index-url=https://pypi.python.org/Now you can install the package as usual, for python3 use something for example:python3 -m pip install raspberry-i2c-tb6612fngNext, after successful instalation you can import this library and start using it in your project like this:# import default libraries that are used in this exampleimporttime# import the libraryfromraspberry_i2c_tb6612fngimportMotorDriverTB6612FNG,TB6612FNGMotors# create an instance of the driver, connected to i2cdriver=MotorDriverTB6612FNG()# drive both motors forwarddriver.dc_motor_run(TB6612FNGMotors.MOTOR_CHA,200)driver.dc_motor_run(TB6612FNGMotors.MOTOR_CHB,200)# pause for a secondtime.sleep(1)# stop the motorsdriver.dc_motor_break(TB6612FNGMotors.MOTOR_CHA)driver.dc_motor_break(TB6612FNGMotors.MOTOR_CHB)DocumentationIf you would like to read about all functions available, please refer to this projects Wiki page on GitHub.
Package: raspberrylink
raspberry-linkA handsfree audio program for use with a Raspberry Pi in a car to add bluetooth audio to a "legacy" stereo.
Allows connecting a phone to a raspberry pi, which will then output audio to the 3.5mm jack or a USB sound card.
Supports control over a REST API.For installation information visit thewiki pageas there are additional steps other than just installing the .deb file or installing from PyPiFeaturesBluetooth Audio Support (Add handsfree support to an old car with only an AUX IN port)A2DP profile audioHFP (Hands-free-profile) support, recieve and make calls over the car speakers using Ofono (microphone required)Media/Call controls, track information and device information available real-time over a REST APISome Notices:Bluetooth not auto-connecting, devices not able to connect, etc:If you're using the Raspberry Pi 3 or Zero W they have some problems using the on-board bluetooth module. I've still not figured out entirely what is going wrong, but using a USB bluetooth dongle solves these issues. I believe the Pi 4 is fine, but I haven't tested it.Bluetooth Audio Support is spotty when using built-in wifiThe Raspberry Pi 3 variants and Zero W suffer from issues while using both the integrated wifi and bluetooth at the same time. A workaround is to use a separate wifi or bluetooth dongle instead. That is recommended for this project.Bluealsa needs to be compiled and installed from source, as it needs to be compiled with options to enable ofono and AAC. This is detailed on the wiki page.
Package: raspberrypi
raspberrypiA Raspberry Pi Toolkit.Other features will be developed in the future.Thanks for raspberrypi.org!Release Note0.1.9: Fixed eth's bug.0.1.5: Add notice.0.1.3: Fixed windows bug.0.1.2: Sniffing online devices.How to useScan Raspberry Pi Devices$raspberrypidevice=>Device1:{"ip":"10.xxx.xx.xxx","mac":"dc:a6:xx:xx:xx:xx","net":"en0"}
Package: raspberrypi-control
Raspberry Pi controllerFeatureConnect in ssh to the Raspberry PiModule and Global call are supportedThe function can be run on the Raspberry Pi  by calling@raspberry_control.raspberry_command()and get the resultGet Output of a function that was run on the raspberryReal-time outputRun command on the Raspberry Pi withraspberry_control.run_command("command here")You can do@raspberrypi.timeout(time,default)that will make the function stop after the time specified and stop if it's not finishExampleimport raspberrypi_control # import package for raspberrypi controlling over ssh  
import os # Put import here they are take and install to the raspberrypi file.  
import time  
  
rp = raspberrypi_control # rp is for RaspBerryPi  
  
i = 1234567890  
  
  
@rp.raspberry_command() # run code and you're raspberrypi. If the raspberrypi was not find it's will be run in local.  
def test():  
    print("Hello RaspBerryPi")  
    return "finished"  
  
  
@rp.raspberry_command() # run code and you're raspberrypi. If the raspberrypi was not find it's will be run in local  
def other():  
    global i  
    print("Hello RaspBerryPi h")  
    th = 0  
    print(i)  
    os.system("echo Hello World")  
    while True:  
        th = th + 1  
        if th == 30:  
            time.sleep(0.1)  
            break  
    return th  
  
  
if __name__ == "__main__": # put all you're code to run at start here. Because if not the code will be run 2 time  
    rp.raspberrypi().set_raspberry_info("username here", "password here") # set login info here
    rp.raspberrypi().set_preparation("192.168.0.10", 8, 1) # config locator for the raspberrypi  
    rp.raspberrypi().local("192.168.0.10") # set the start ip set in the line in the top  
    rp.config("main") # file name if this file (no .py)  
    rp.run_command("Hello World",True) # true is for if console ouput is print or no
    print(test())  
    print(other()) # you can get the output afterHow to install the packageDopip install raspberry-controlSupported for python 3.10 and higher*
*note not tested for lower versionBug reportGithub - Issues
Package: raspberrypi-esp32-i2c
Raspberry_Pi_Master_for_ESP32_I2C_SLAVEuseRaspberry pi as MASTERof aESP32 SLAVEoni2c busTo use ESP32 as slave on i2c bus you have to use ESP32_I2C_Slave c++ library:platformio lib_deps = ESP32 I2C Slavehttps://github.com/gutierrezps/ESP32_I2C_Slavebecause the esp32-arduino framework not allowed you to use ESP32 as i2c slave.The ESP32 I2C Slave library do the job on 2 ESP32 or Arduino + ESP32 but not with python master on raspberry pi.So i convert parts of this library to python classes.To use these classes you must need to install:pip install adafruit-blinkapip install adafruit-extended-busFollow examples to read data from master RPI to slave ESP32:example-readexample-writeto install it use pip:pip install raspberrypi-esp32-i2c
Package: raspberry-pi-lcd
This module makes it easier to get started using an Adafruit 16x2 LCD with your Raspberry Pi.DependenciesThis module depends on the following apt packages:python-smbusi2c-toolspython-devpython-rpi.gpioYour /etc/modules file should have the following lines in it:i2c-bcm2708
i2c-devThis module is only designed to be useful on Raspberry Pi systems running Raspbian that have an Adafruit 16x2 LCD screen correctly installed.UsageOnce you have pip installed raspberry-pi-lcd, you can import lcd into your program. The lcd module exposes the following methods:message(text)Displays text on the LCD
Package: raspberrypi-mqtt-light-sensor
# Light Sensor MQTT
This repsository contains a simple light sensor for the raspberry pi.
Because the pi does not have any analog inputs the scripts measures how long it takes to charge a capacitor until the pi recognizes the voltage as logical one.The script will takes n measurements, averages them and publishes the result via MQTT.
In my setup the MQTT data will be read by home assistant and is used to control the lights.Requires python3 to run.## Installationpip install raspberrypi-mqtt-light-sensor