Saravanan666/pypi-org huggingface dataset:
Package: raconteur
# RacounteurAn auxiliary tool for simplifying speech generation on arbitrary texts## Usage### Generate speech for any textTo generate speech for an arbitrary text, use the following command:`sh python-mrr say 'Привет, мир' `Example of command forgenerating an audio book from a txt file:`sh python-mrr say-esilero-abaya-grx-b10000-tassets/player-one.txt`By default [RuTTS toolkit][1] is used, but you can specify other model using-e(–engine) cli argument:`sh python-mrr say 'Привет, мир'-ebark `Currently the following engines are supported:1. [rutts][1] - an economical model only for russian texts;
1. [bark][3] - multilingual model, requires a lot of gpu;
1. [salute][4] - adapter to the cloud service from sber, requires environment variableSALUTE_SPEECH_AUTHto be set;
1. [crt][5] - adapter to the cloud service from crt, requires environment variablesCRT_USERNAME,CRT_PASSWORD,CRT_DOMAINto be set;
1. [coqui][6] - multilingualxttsmodel, utilizes a moderate amount of gpu (much less than [bark][3], but works better), works very slowly (270.43189 seconds per anek in average on gtx 1650 vs 3-5 seconds for rutts),requires file `assets/female.wav`which can be downloaded from [here][6] and replaced with desired speaker’s voice recording).
1. [silero][8] - amazing models for speech generation, which produce audio with good quality in a reasonable amount of time without requiring a lot of resources.For a full list of available cli options see [__main__.py][2].### Convert anecdotes to voiceThe app natively supports one specific use-case: it allows to synthesize speech for anecdotes from [this kaggle dataset](https://www.kaggle.com/datasets/zeionara/anecdotes?select=anecdotes.tsv). The command is similar to the examples listed above, to useruttsmodel for reading aloud the first 10 anecdotes you can just type:`sh python-mrrhandle-aneks-n10 `Also you can use another model and specify input / output paths:`sh python-mrrhandle-aneks-ebark-s'assets/anecdotes.tsv'-d'assets/anecdotes'-n10 `For a full list of available cli options see [__main__.py][2].Also, see the [exemplary jupyter notebook](./example.ipynb) which is regularly updated.## InstallationTo create acondaenvironment with required dependencies run the following command:`sh conda env create-fenvironment.yml `Install the following dependencies manually:`sh sudoapt-getinstall libportaudio2 `Also you need to clone [unofficial mail ru cloud api package][7] for being able to seamlessly upload generated files to mail ru cloud:`sh pushd"/home/$USER"git clone git@github.com:zeionara/carma.git popd ln-s"/home/$USER/carma/cloud_mail_api"`## TestingTo run tests use the following statement:`sh python-munittest discover test `[1]:https://github.com/Tera2Space/RUTTS[2]:https://github.com/zeionara/raconteur/blob/master/rr/__main__.py[3]:https://github.com/suno-ai/bark[4]:https://developers.sber.ru/portal/products/smartspeech[5]:https://cloud.speechpro.com/home[6]:https://huggingface.co/spaces/coqui/xtts[7]:https://github.com/zeionara/carma[8]:https://github.com/snakers4/silero-models
Package: racp
READMESetupTo start using this project, first you should run the setup script. You can either runpipinstallracporpythonsetup.pyinstallat the project root directory. This allows you to importracpin python code.Our docs can be viewed onhttps://racp.readthedocs.io/en/latest/.If you want to build the docs locally, you need to installmkdocs. Run these commands:pipinstallmkdocsmkdocs-include-markdown-pluginmkdocstringsmkdocstrings-pythonIf you want to view the docs, runmkdocs buildat the project root directory. It will create./sitedirectory which containsindex.htmlfile. Open the file with your browser and read the docs.You can run the scripts inexampleto test installation.
Package: racpy
racpyRNASeq Age Calculation in PythonFree software: MIT licenseDocumentation:https://racpy.readthedocs.io.FeaturesThis is the Python verion of our proposed multi-tissue transcriptional age calculator.The RNAAgeCalc paper can be found herehttps://doi.org/10.1371/journal.pone.0237006.The Python package can be found herehttps://pypi.org/project/racpy.The Python package documentation can be found herehttps://racpy.readthedocs.io.An interactive Shiny App can be found herehttps://xuren2120.shinyapps.io/RNAAgeCalcshiny/.The Shiny App demo can be found herehttp://www.ams.sunysb.edu/~pfkuan/RNAAgeCalc/instructions.html.The R version can be found herehttps://bioconductor.org/packages/release/bioc/html/RNAAgeCalc.html.AuthorsXu Ren<xuren2120@gmail.com>Pei Fen Kuan<peifen.kuan@stonybrook.edu>CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.Dependencies scanned by PyUp.ioCitationRen, X., & Kuan, P. F. (2020). RNAAgeCalc: A multi-tissue transcriptional age calculator. PloS one, 15(8), e0237006.@article{ren2020rnaagecalc,title={RNAAgeCalc: A multi-tissue transcriptional age calculator},author={Ren, Xu and Kuan, Pei-Fen},journal={PLOS ONE},volume={15},number={8},pages={1-21},year={2020},publisher={Public Library of Science}}History0.1.6 (2020-09-20)Added citation0.1.5 (2020-06-24)Replaced “DESeq” with “DESeq2” throughout the package0.1.4 (2020-06-10)Updated requirements_dev.txt0.1.3 (2020-04-24)Included extra credits in README0.1.2 (2020-02-18)Bug fixes.0.1.0 (2020-02-09)Package created. First release on PyPI.
Package: rac-schemas
rac_schemasJSON schemas and validation helpers.RequirementsPython 3.4 or higherjsonschematox(for running tests)pre-commit(for running linters before committing)After installing pre-commit, install the git-hook scripts:$ pre-commit installInstallationThe recommended way to install this package is usingpip:pip install rac_schemasUsageThis library has one main public method,is_valid(), which takes a dict as the first argument and a schema filename as the second.from rac_schemas import is_valid

data = {"key": "value" ... }
is_valid(data, "object.json")rac_schemaswill attempt to add an appropriate extension to schema filenames in cases where it is either missing or incorrect. For example, if eitherschemaandschema.orgas schema filenames,rac_schemaswill attempt to openschema.json.Invalid data will raise ajsonschema.exceptions.ValidationError, and an invalid schema filename will raise aFileNotFoundError.Available schemasAll schemas are located in theschemas/subdirectory of therac_schemas/directory.Testsrac_schemascomes with unit tests as well as linting. The easiest way to make sure all tests pass is to runtoxfrom the root of the repository. This will execute all tests, and will also runautopep8andflake8linters against the codebase.DocumentationAutomatically generated HTML documentation in thedocs/directory based upon.jsonfiles in theschemas/subdirectory of therac_schemas/directory.A simplified overview of the data model is below:RequirementsPython 3.4 or higherjson-schema-for-humansUsageRunninggenerate_docs.pywill iterate over theschemas/subdirectory and write updated docs files to thedocs/directory.LicenseCode is released under an MIT license. SeeLICENSE.md.
Package: rac-schema-validator
rac_schema_validatorValidators for RAC JSONSchemas.RequirementsPython 3.9 or higherjsonschematox(for running tests)pre-commit(for running linters before committing)InstallationThe recommended way to install this package is usingpip:pip install rac_schema_validatorAfter installing pre-commit, install the git-hook scripts:$ pre-commit installUsageThis library has one main public method,is_valid(), which takes two required
arguments:the data to be validatedthe JSONSchema to validate againstand a third optional argument:a base schema to resolve references against (seeofficial docs)from rac_schema_validator import is_valid

data = {"key": "value" ... }
schema = { ... }
is_valid(data, schema)Invalid data will raise arac_schema_validator.exceptions.ValidationError, and
an invalid schema will raise ajsonschema.exceptions.SchemaError.Testsrac_schema_validatorcomes with unit tests as well as linting. The easiest way
to make sure all tests pass is to runtoxfrom the root of the repository.
This will execute all tests, and will also runautopep8andflake8linters
against the codebase.LicenseCode is released under an MIT license. SeeLICENSE.md.
Package: rad2f5
rad2f5This is a simple script to convert Radware Appdirector configurations to F5 configuration. This was written in Python v2.7 but is expected to work on v3.Install using pip:pip install rad2f5UsageUsage: rad2f5 <filename> [partition]Output is to stdout and shows statistics about the number of objects and then F5-syntax configuration.
This F5 configuration can be loaded onto an F5 device usingtmsh load sys config merge file/var/tmp/<filename>verify.
Fix any issues and load withtmsh load sys config merge file/var/tmp/<filename>The certificates and keys will be output into the current directory, these should be uploaded to the BIG-IP in the /var/tmp
directory and run the script check_certs.sh to ensure the certs and keys are correct, then run load_certs to load the certificates and keys.See an example athttps://devcentral.f5.com/codeshare/radware-config-translation-1130Contact me at DevCentral if you would like any configuration added or for bug fixes.
Package: radar
Random date generation.PrerequisitesPython 2.6.8+, 2.7.+, 3.3.+InstallationInstall latest stable version from PyPI:$ pip install radaror install the latest stable version from bitbucket:$ pip install -e hg+https://bitbucket.org/barseghyanartur/radar@stable#egg=radaror install the latest stable version from github:$ pip install -e git+http://github.org/barseghyanartur/radar@stable#egg=radarUsage and examplesBasic usage>>> import radar
>>> radar.random_datetime()
datetime.datetime(2013, 5, 24, 16, 54, 52)Specify date rangeYou may passdatetime.datetimeordatetime.dateobjects:>>> import datetime
>>> import radar
>>> radar.random_date(
>>>     start = datetime.datetime(year=2000, month=5, day=24),
>>>     stop = datetime.datetime(year=2013, month=5, day=24)
>>> )
datetime.date(2012, 12, 31)You may also pass strings:>>> radar.random_datetime(start='2012-05-24T00:00:00', stop='2013-05-24T23:59:59')
datetime.datetime(2013, 4, 18, 17, 54, 6)Generate random time>>> radar.random_time(start='2012-01-01T00:00:00', stop='2012-01-01T23:59:59')
datetime.time(11, 33, 59)Advanced usageWhen strings are passed, by defaultradarusespython-dateutilpackage to parse dates. Date parser of thedateutilpackage is quite heavy, althogh is extremely smart. As an alternative,radarcomes with own parserradar.utils.parse, which is much lighter (about 5 times faster compared todateutil).Using built-in parser:>>> radar.random_datetime(start='2012-05-24T00:00:00', stop='2013-05-24T23:59:59', parse=radar.utils.parse)
datetime.datetime(2012, 11, 10, 15, 43, 40)Built-in parser parses the dates using formats specified inradar.defaults.FORMATS:>>> start = radar.utils.parse('2012-01-01')
datetime.datetime(2012, 1, 1, 0, 0)
>>> stop = radar.utils.parse('2013-01-01')
datetime.datetime(2013, 1, 1, 0, 0)If you want to add more formats, define your own formats and feed them to built-in parser:>>> MY_FORMATS = (
>>>     ("%d-%m-%YT%H:%M:%S", True),
>>>     ("%d-%m-%Y", False)
>>> )
>>>
>>> def my_parse(timestamp):
>>>     return radar.utils.parse(timestamp, formats=MY_FORMATS)
>>>
>>> radar.random_datetime(start='24-05-2012T00:00:00', stop='24-05-2013T23:59:59', parse=my_parse)
datetime.datetime(2012, 11, 10, 15, 43, 40)General notesIf you expect to have really weird date formats when generating random dates from strings, you might want to consider
installing wonderfulpython-dateutilpackage.When generating thousands of objects (usingdateutilor built-in parser), you’re advised to pass date ranges asdatetime.datetimeordatetime.dateobjects, rather than passing strings (parsing costs time).A good example:>>> start = radar.utils.parse('2000-01-01')
>>> stop = radar.utils.parse('2013-12-31')
>>> for i in xrange(1000000):
>>>     radar.random_datetime(start=start, stop=stop)Seehttps://bitbucket.org/barseghyanartur/radar/src(example) directory for benchmarks and more examples.LicenseGPL 2.0/LGPL 2.1SupportFor any issues contact me at the e-mail given in theAuthorsection.AuthorArtur Barseghyan <artur.barseghyan@gmail.com>
Package: radar5
The radar5 module is a numerical solver for delay differential equations. It is a wrapper around an original FORTRAN code, that uses a colocation method on Radau nodes for an efficient integration of stiff problems. Please note that all the capabilities of the FORTRAN code are not wrapped yet. The original FORTRAN code is the work of Nicola Guglielmi and Ernst Hairer, and can be found on:http://www.unige.ch/~hairer/software.html
Package: radarboxplot
Radar-BoxplotThis package provides the implementation of the radar-boxplot, a charting technique create and developed by the author (Caio Hamamura).It merges the concepts of both radar chart and the boxplot chart, allowing to compare multivariate data for multiple classes/clusters at a time. It provides a intuitive understanding over the data by creating radar polygons which can be compared in terms of shape and thickness, giving a meaningful insight towards identifying high inner variation and similar classes/clusters.By interpreting the radar-boxplot, it is possible to predict classification confusion over classes and understand why and what could be done to achieve a better result.
Package: radar-chart
Radar Chart PackageThis is a simple radar chart package to quickly use and visualiseradar chartsusing a single function.fromradar_chart.radar_chartimportradar_chartimportmatplotlib.pyplotaspltimportnumpyasnpfromrandomimportrandomlabels='ATK STR DEF MAG RNG'.split()values=[random()*100foriinlabels]radar_chart(values,labels,line_color='red',fill_color='red')plt.show()labels=[str(i)+":00"foriinrange(1,13)][::-1]values=[random()*1000foriinrange(len(labels))]radar_chart(values,labels,y_ticks=False,rotate=90)plt.show()Parameters:stats: sequence of scalarcat_labels: sequence of string, defaultNone. Labels for each value instratsline_color: string, default#1E88E5. Defines the line color that joins the plotted values.fill_color: string, default#1E88E5. Defines the fill color of the plot area.marker: string, defaultNone. Marker style e.g.+,x,o.marker_alpha: float between 0-1, default1. Sets the transparency of the marker (0: Transparent, 1: Opaque).fill_alpha: float between 0-1, default1. Sets the transparency of the fill of the plot area (0: Transparent, 1: Opaque).rotate: float, default'Degrees'. Default setting does nothing. Accepts degrees (which is converted to radians) and rotates the plot clockwise.reverse_rotationbool, defaultFalse. Direction of the plot is reversed ifTrue.y_tickssequence of scalar/string or bool, defaultTrue. Default will set y-tick labels according tostatsvalues. No y-tick labels ifFalse. Sets sequence as y-tick labels if sequence.x_tickssequence of scalar/string or bool, defaultTrue. Default will set y-tick labels according tocat_labelsvalues. No y-tick labels ifFalse. Sets sequence as x-tick labels if sequence.gridlinebool, defaultTrue. Removes gridlines ifFalsegridline_colorstring, default'#888888'. Defines the color of the gridlines.gridline_widthfloat, default0.3. Defines the width of the gridlines.
Package: radariq
Python SDKOverviewThis module provides an easy to use Python wrapper for the RadarIQ-M1_ sensor which works
for both Python 2 & 3. This SDK has been tested with Windows, OSX, Raspberry Pi and Linux.The RadarIQ-M1 sensor is an easy-to-use radar sensor for detecting objects and measuring distance and speed.
All the difficult parts of working with radar are done by the sensor and a simple API and SDK provide an easy
path to integration.The RadarIQ Python SDK is released under the MIT software license, see LICENSE for more details.InstallationInstall the RadarIQ SDK using pippip install radariqThe SDK can be used from Python scriptsfrom radariq import RadarIQUsagefrom radariq import RadarIQ, MODE_POINT_CLOUD

 riq = RadarIQ()
 riq.set_mode(MODE_POINT_CLOUD)
 riq.set_units('m', 'm/s')
 riq.set_frame_rate(5)
 riq.set_distance_filter(0, 10)
 riq.set_angle_filter(-45, 45)
 riq.start()

 for row in riq.get_data():
     print(row)ExamplesExamples are in the examples directory.
Package: radarpipeline
RADAR PipelineAn open-source python feature generation and visualization package use with RADAR project data.WikiPlease visit theRADAR Pipeline Wikito learn more about RADAR Pipeline. Also see theRADAR-base Analytics Cataloguefor available pipelines for processing RADAR-base data.Wiki resources:HomeInstallationContributor GuideMock PipelineConfigurationData IngestionSetupPipeline Core TopicsCreating Citable Analytics PipelinesHow to runNoteIf you are using Windows, please install Spark and set environment variables as mentionedherebefore going through the installation below. You'll need to set the environment variables givenhere.Clone the repository (with all the submodules):$gitclone--recurse-submoduleshttps://github.com/RADAR-base/radarpipeline.gitChange the directory toradarpipeline:$cdradarpipelineCheckout the development branch:$gitcheckoutdevCreate avirtual environmentand activate it. The instructions here usevirtualenvbut feel free to use any python virtual environment manager of your choice.Install the virtualenv package:$python-mpipinstall--uservirtualenvCreate a python virtual environment:$python-mvirtualenvenvActivate the virtual environment:On Windows, run:$.\env\Scripts\activateOn Linux or MacOS, run:$source./env/bin/activateInstall the dependencies:$python-mpipinstall-rrequirements.txtInstall the module as a python package by running the command$python-mpipinstall-e.To verify the installations, run the following command in the project root directory to run the pipeline:$python.The pipeline would do a mock run and ingest the data in themock-datadirectory. You can see some outputs in the CLI and if the project is installed correctly, the mock pipeline would run without errors and save the data to theoutputdirectory.LicenseThis project is licensed under theApache License, Version 2.0.Citation & AcknowledgmentPlease use citationor or seeCITATION.cffPushkar patelhas done a great amount of work under Google Summer of Code 2022. His work report can be foundhere. We would like to thank Pushkar for all his contribution and GSoC for giving us this opportunity.
Package: radar-python
radar-pythonPython library for theRadar APIDocsPyPiThe Radar Python library provides convenient access to Radar's APIs from
your python applications or command line.InstallationYou don't need this source code unless you want to modify the package. If you just want to use the package, just run:pipinstallradar-pythonRequirementsPython 3.4+UsageThe radar client needs to be initialized with your project’s secret key which is available in yourRadar Dashboard.importosfromradarimportRadarClient# initialize clientradar=RadarClient(os.environ["RADAR_SECRET_KEY"])# get a geofence by idgeofence=radar.geofences.get(id='123')# list geofencesradar.geofences.list()Full Endpoint List:Users:radar.users.list
radar.users.get(id='1')
radar.users.delete(id='1')Geofencesradar.geofences.list()
radar.geofences.get(id=’123’)
radar.geofences.get(tag=’store’, externalId=’123’)
radar.geofences.list_users(id='123')
radar.geofences.create({ 'type': 'circle', ... })
radar.geofences.delete(id='123')
radar.geofences.delete(tag=’store’, externalId=’123’)Eventsradar.events.list()
radar.events.get(id='123')
radar.events.delete(id='123')
radar.events.verify(id='123', 'accept')Contextradar.context.get(coordinates=(40.7041895, -73.9867797))Geocodingradar.geocode.forward(query=’20 jay st brooklyn’)
radar.geocode.reverse(coordinates=(40.7041895, -73.9867797))
radar.geocode.ip(ip=’107.77.199.117’)Searchradar.search.users(near=[lat,long])
radar.search.geofences(near=[lat,long])
radar.search.places(near=[lat,long])
radar.search.autocomplete(query=’20 jay st’, near=[lat, long])Routingradar.route.distance(origin=[lat,lng], destination=[lat,lng], modes=’car’, units=’metric’)
Package: radb
RA is a simple relational algebra interpreter written in Python 3.  It
is built on top of an SQL-based relational database system.  It
implements relational algebra queries by translating them into SQL and
executing them on the underlying database system throughSQLAlchemy.  RA is packaged withSQLite, so you can use RA as a standalone
relational-algebra database system.  Alternatively, you can use RA as
a relational-algebra front-end to connect to other database servers
from various vendors.You can follow theprojecton
GitHub, or read its documentationhere.
Package: radbelt
radbelt: An Astropy-friendly wrapper for the AE-8/AP-8 Van Allen belt modelThis is small Python library to model the fluxes of charged particles trapped
in the Van Allen belt. It provides a fast, simple, and convenient Python
interface to theInternational Geomagnetic Reference Field (IGRF)model and
NASA's AE-8/AP-8 models of electron and proton fluxes, which are both
implemented in Fortran. The package is integrated with theAstropyecosystem
for easy conversion of coordinate systems, time scales, and units. With this
package, it is easy and fast to determine the flux of particles above any given
energy, at any position, at any time.Acknowledging radbeltThis package is wraps the following Fortran codes, which have been retrieved
from NASA Goddard Space Flight Center's (GSFC)Community Coordinated Modeling
Center (CCMC):https://ccmc.gsfc.nasa.gov/models/modelinfo.php?model=IGRFhttps://ccmc.gsfc.nasa.gov/models/modelinfo.php?model=AE-8/AP-8%20RADBELTWhen publishing results derived from this Python package, please cite the
following articles:Vette, J.I., Lucero, A.B., Wright, J.A., et al. 1966, "Models of the Trapped Radiation Environment." NASA SP-3024.Sawyer, D.M. & Vette, J.I. 1976, "AP-8 trapped proton environment for solar maximum and solar minimum." NASA WDC-A-R&S 76-06, NASA-TM-X-72605.Vette, J.I. 1991, "The AE-8 trapped electron model environment." NSSDC/WDC-A-R&S 91-24.Thébault, E., Finlay, C.C., Beggan, C.D., et al. 2015, "International Geomagnetic Reference Field: the 12th generation." Earth, Planets, and Space, 67, 79.To install$ pip install .Example>>>fromradbeltimportget_flux>>>fromastropyimportunitsasu>>>fromastropy.coordinatesimportEarthLocation>>>fromastropy.timeimportTime>>>coords=EarthLocation(-45*u.deg,-30*u.deg,500*u.km)>>>time=Time('2021-03-01')>>>energy=20*u.MeV>>>get_flux(coords,time,energy,'p','max')# doctest: +FLOAT_CMP<Quantity 2642.50268555 1 / (s cm2)>Known issuesThe CCMC IGRF code has spatially varying errors of a few percent, which will
result in a striped pattern in the resulting particle flux.
Package: radcalnet
Python package for easy access to the measurements published byRadCalNet.RadCalNet is aCEOSinitiative, providing relevant measurements and estimated reflectance
factors, based on data from multiple calibration sites around the world.
The data is provided in a textual format with publishedspecs. Available as afull archive(zip file), or as smaller daily downloads.This package provides functions for parsing these files and extracting measurements as
PandasDataFrameobjects ready for analysis.Installation:pip install radcalnetUsage:plot site measurements over time: