Saravanan666/pypi-org huggingface dataset:
Package: redengine
RedEnginePowering your Python AppsWhat is it?Red Engine is a modern scheduling framework for Python
applications. It is simple, clean and extensive. It is
the engine that sets your Python programs alive.The library is minimal on the surface but extensive
and customizable underneath. The syntax very clean:fromredengineimportRedEngineapp=RedEngine()@app.task('daily')defdo_daily():...if__name__=='__main__':app.run()Compared to alternatives, Red Engine has perhaps the most elegant syntax and is the most productive. It offers more features than Crontab or APScheduler but is much
easier to work with than Airflow. It does not make assumptions of your project.Read more from the documentations:Red Engine, documentationsInstallationInstall Red Engine fromPyPI:pipinstallredengineMore Examples?Scheduling:@app.task("every 10 seconds")defdo_continuously():...@app.task("daily after 07:00")defdo_daily_after_seven():...@app.task("hourly & time of day between 22:00 and 06:00")defdo_hourly_at_night():...@app.task("(weekly on Monday | weekly on Saturday) & time of day after 10:00")defdo_twice_a_week_after_ten():...Pipelining tasks:fromredengine.argsimportReturn@app.task("daily after 07:00")defdo_first():...return'Hello World'@app.task("after task 'do_first'")defdo_second(arg=Return('do_first')):# arg contains the value of the task do_first's return...return'Hello Python'Parallelizing tasks:@app.task("daily",execution="main")defdo_unparallel():...@app.task("daily",execution="thread")defdo_on_separate_thread():...@app.task("daily",execution="process")defdo_on_separate_process():...AuthorMikael Koli-Miksus-koli.mikael@gmail.com
Package: rede-payments
SDK PythonSDK de integração eRedeUtilizandoAutorizando uma transaçãofromeredeimport*store=Store("PV","TOKEN",Environment.sandbox())transaction=Transaction(12345,"Reference")transaction.credit_card("5448280000000007","123","12","2020","Fulano de Tal")transaction.set_additional(3456,12)try:transaction=eRede(store).create(transaction)iftransaction.returnCode=="00":print("Transação aprovada com sucesso. O tid é:{}".format(transaction.tid))exceptRedeErrorase:print("Opz[{}]:{}".format(e.code,e))Por padrão, a transação é capturada automaticamente; caso seja necessário apenas autorizar a transação, o métodoTransaction.capture_transaction(False)deverá ser chamado com o parâmetroFalse:fromeredeimport*store=Store("PV","TOKEN",Environment.sandbox())transaction=Transaction(12345,"Reference")transaction.credit_card("5448280000000007","123","12","2020","Fulano de Tal").capture_transaction(False)try:transaction=eRede(store).create(transaction)iftransaction.returnCode=="00":print("Transação aprovada com sucesso. O tid é:{}".format(transaction.tid))exceptRedeErrorase:print("Opz[{}]:{}".format(e.code,e))Autorizando uma transação com MCC dinâmicofromeredeimport*store=Store("PV","TOKEN",Environment.sandbox())transaction=Transaction(12345,"Reference")transaction.credit_card("5448280000000007","123","12","2020","Fulano de Tal")transaction.mcc("LOJADOZE","22349202212",SubMerchant("1234","Sao Paulo","Brasil"))try:transaction=eRede(store).create(transaction)iftransaction.returnCode=="00":print("Transação aprovada com sucesso. O tid é:{}".format(transaction.tid))exceptRedeErrorase:print("Opz[{}]:{}".format(e.code,e))Autorizando uma transação com identificação de plataformafromeredeimport*store=Store("PV","TOKEN",Environment.sandbox())transaction=Transaction(12345,"Reference")transaction.credit_card("5448280000000007","123","12","2020","Fulano de Tal")transaction.set_additional(1234,12)try:transaction=eRede(store).create(transaction)iftransaction.returnCode=="00":print("Transação aprovada com sucesso. O tid é:{}".format(transaction.tid))exceptRedeErrorase:print("Opz[{}]:{}".format(e.code,e))Autorizando uma transação IATAfromeredeimport*store=Store("PV","TOKEN",Environment.sandbox())transaction=Transaction(12345,"Reference")transaction.credit_card("5448280000000007","123","12","2020","Fulano de Tal")transaction.set_iata("code123","250")try:transaction=eRede(store).create(transaction)iftransaction.returnCode=="00":print("Transação aprovada com sucesso. O tid é:{}".format(transaction.tid))exceptRedeErrorase:print("Opz[{}]:{}".format(e.code,e))
Package: redesign
Namespace for Redesigning Psychiatry packagesThis project represents the implicit namespaceredesignin the names of
packages from theRedesigning Psychiatryprogramme (such asredesign.health).Note that this project is not a dependency of such packages. It exists merely
to indicate that an explicit module namedredesignwould cause a namespace
conflict with these packages. Installing this package will add aredesign.infomodule that attaches a docstring to theredesignnamespace
when imported.
Package: redevelop-elyra
redevelop_elyraA JupyterLab extension.RequirementsJupyterLab >= 3.0InstallTo install the extension, execute:pipinstallredevelop_elyraUninstallTo remove the extension, execute:pipuninstallredevelop_elyraContributingDevelopment installNote: You will need NodeJS to build the extension package.Thejlpmcommand is JupyterLab's pinned version ofyarnthat is installed with JupyterLab. You may useyarnornpmin lieu ofjlpmbelow.# Clone the repo to your local environment# Change directory to the redevelop_elyra directory# Install package in development modepipinstall-e"."# Link your development version of the extension with JupyterLabjupyterlabextensiondevelop.--overwrite# Rebuild extension Typescript source after making changesjlpmbuildYou can watch the source directory and run JupyterLab at the same time in different terminals to watch for changes in the extension's source and automatically rebuild the extension.# Watch the source directory in one terminal, automatically rebuilding when neededjlpmwatch# Run JupyterLab in another terminaljupyterlabWith the watch command running, every saved change will immediately be built locally and available in your running JupyterLab. Refresh JupyterLab to load the change in your browser (you may need to wait several seconds for the extension to be rebuilt).By default, thejlpm buildcommand generates the source maps for this extension to make it easier to debug using the browser dev tools. To also generate source maps for the JupyterLab core extensions, you can run the following command:jupyterlabbuild--minimize=FalseDevelopment uninstallpipuninstallredevelop_elyraIn development mode, you will also need to remove the symlink created byjupyter labextension developcommand. To find its location, you can runjupyter labextension listto figure out where thelabextensionsfolder is located. Then you can remove the symlink namedredevelop-elyrawithin that folder.Testing the extensionFrontend testsThis extension is usingJestfor JavaScript code testing.To execute them, execute:jlpm
jlpmtestIntegration testsThis extension usesPlaywrightfor the integration tests (aka user level tests).
More precisely, the JupyterLab helperGalatais used to handle testing the extension in JupyterLab.More information are provided within theui-testsREADME.Packaging the extensionSeeRELEASE
Package: redexpect
RedExpectRedExpect makes automating remote machines over SSH very easy to do and is very fast in doing exactly what you ask of it.
Based on ssh2-python (which provides libssh2 bindings for python) and made into an easy to use SSH library via RedSSH.
If you're familiar with using expect but would like the easy of use and accessibilty of python, then look no further!InstallingRedExpect can be installed via pip withpip install redexpector the latest commit, which may not be the most stable, from git withpip install git://git@bitbucket.org/Red_M/RedExpect.gitDocumentation99% of questions around how to do something should be answered in the documentation.
If something is not there please raise an issue so it can be added to the documentation.Now with autodocs!Why not use [other software]?I've found other automation libraries or solutions lacking, such as:Compatibility with remote servers (odd servers causes the library to be unable to connect).Feature set is limited (eg, no tunneling).Focuses on only connecting to Linux servers.Requires an agent to be installed, a state file to be present or a master "server".Poor performance.TO DOUnit testsMore examples
Package: redeye-grablib
GrabLibA library for retrieving files from HTTP servers.Installationpip install redeye-grablibUsage>>> import grablib
>>> import asyncio
>>>
>>> grabber = grablib.GrabLib()
>>> asyncio.run(grabber.get("https://picsum.photos/20/30"))
{
  'url': 'https://picsum.photos/20/30',
  'sha256': '91aa5c45c2d5709e46631caa743bec9461a4e97df87d60038c126078876add02',
  'data': b'[image binary]'
}
Package: red-fab-deploy
# red-fab-deploy: django deployment toolred-fab-deploy is a collection of Fabric scripts for deploying and
managing projects created with red-start. License is MIT.This project is specifically targeted at deploying websites built using
the red-start project creation tool. Basically this means you must be using
git and follow the same folder and file layout as found in that tool.This project was inspired bydjango-fab-deploy <http://packages.python.org/django-fab-deploy>andcuisine <https://github.com/ff0000/cuisine/>.These tools are being geared towards deploying on Joyent but can be extended to be used on other providers.## InstallationIMPORTANT: red-fab-deploy will only work if you install the following packages:$ pip install fabricTo use the joyent provider you will need smartdc$ pip install smartdc## Deployment and Setup### FabfileThe first thing you need to do is set up your fabfile. This file should import * from fab_deploy. As well as specify which provider this setup is for. You do this by import * from that package. For example:from fab_deploy.joyent import *### Server ConfigsIn your projects deploy folder there should be a file named servers.ini. This file keeps track of the different types of servers and any relationships between them. As you add servers using this tool the file will be updated. You also configure firewalls using this file by specifing which ports should be open to which other roles.Fabric roles are also setup based on the information in this file. So adding -R app-server for example will run your specifed command on all servers in that section of the config file.Your git remotes will also be scanned so that you can refer to remote servers by their git names. So if you have a git remote named web1 -H web1 will be a valid host.### Overriding behaviorIn many cases you will want to customize the behavior of a certain task. For this reason most tasks are implemented as classes. You can inherit from the task that you want to customize, make your changes and then in your fabfile override that task name with your new class.### TasksTo list the tasks run fab –list. Running fab -d task_name will print the full docstring for the given task.
Package: red-fill
RED-fillRED-fill is part of the Curious Containers project.
It enables researchers to implement RED variables resolution
by using a keyring or interactive user input.AcknowledgementsThe Curious Containers software is developed atCBMI(HTW Berlin - University of Applied Sciences). The work is supported by the German Federal Ministry of Economic Affairs and Energy (ZIM project BeCRF, grant number KF3470401BZ4), the German Federal Ministry of Education and Research (project deep.TEACHING, grant number 01IS17056 and project deep.HEALTH, grant number 13FH770IX6) and HTW Berlin Booster.
Package: redfin
Python-RedfinA wrapper around redfin's unofficial API. Anything on the redfin site can be accessed through this module without screen scraping.Installation$ python3 -m pip install redfinUsagefromredfinimportRedfinclient=Redfin()address='4544 Radnor St, Detroit Michigan'response=client.search(address)url=response['payload']['exactMatch']['url']initial_info=client.initial_info(url)property_id=initial_info['payload']['propertyId']listing_id=initial_info['payload']['listingId']mls_data=client.below_the_fold(property_id,listing_id)DocumentationSee the file for all functions, pop open requests on redfin to see which one you want.
Package: redfin-scraper
Redfin ScraperDescriptionA scalable Python library that leverages Redfin's unofficial Stringray API to quickly scrape real estate data.One-Time SetupZip Code DatabaseA database of zip codes is required to search for City, State valuesIt is strongly recommended to download thisfreeversion in .csv formatThe ConfigParameters for the RedfinScraper class can be controlled using an optionalconfig.jsonfileSample ConfigGetting StartedInstallationpip3 install -U redfin-scraperImport Modulefrom redfin_scraper import RedfinScraperInitialize Modulescraper = RedfinScraper()Using The ScraperRequired Setupscraper.setup(zip_database_path:str, multiprocessing:bool=False)zip_database_path: Binary path to the zip_code_database.csvmultiprocessing: Allow for multiprocessingActivating The Scraperscraper.scrape(city_states:list[str]=None, zip_codes:list[str], sold:bool=False, sale_period:str=None, lat_tuner:float=1.5, lon_tuner:float=1.5)city_states: List of strings representing US cities formatted as "City, State"zip_codes: List of strings representing US zip codessold: Select whether to scrape for-sale data (default) or sold datasale_period: Must be selected whenever sold is True (1mo, 3mo, 6mo, 1yr, 3yr, 5yr)lat_tuner: Represents # of standard deviations beyond the local latitude average that a zip code may exist withinlon_tuner: Represents # of standard deviations beyond the local longitude average that a zip code may exist withinAccessing Prior Scrapesscraper.get_data(id:str)id: IDs are indexed at 1 and increase in the format "D00#"AppendixWarningsMultiprocessing can result in the consumption of all available CPU resources for an extended period of timeUnethical use of this library can result in Redfin taking disciplinary action against your IP addressRecommendationsRequests for large amounts of data (# of zip codes > 2,000) should be split into separate requestsThepackage.logfile can be used to investigate unexpected results
Package: redfish-advantech
# redfish_advantech## Build package
- cd to the directory of setup.py
- Confirm the version number in setup.py and src/redfish_advantech/__init__.pypython setup.py sdist build
twine upload dist/*## Uninstall the redfish_advantech
pip uninstall redfish_advantech -y## Install the redfish_advantech
pip install redfish_advantechorpip install redfish_advantech==x.y.z
- where the x.y.z is the version number## Test (Change to the directory which has logging.conf)
- Make sure the python is version 3.x
- Make sure the logging.conf is exist in the same directory as test sample code
- Add “-v”, “-vv” or “-vvv” for more logcd examples
python advantech.py
python acl_bmc.py
python acl_bmc_cm.py
Package: redfish-protocol-validator
Redfish Protocol ValidatorCopyright 2020-2022 DMTF. All rights reserved.AboutThe Redfish Protocol Validator tests the HTTP protocol behavior of a Redfish service to validate that it conforms to the Redfish Specification.InstallationFrom PyPI:pip install redfish_protocol_validatorFrom GitHub:git clone https://github.com/DMTF/Redfish-Protocol-Validator.git
cd Redfish-Protocol-Validator
python setup.py sdist
pip install dist/redfish_protocol_validator-x.x.x.tar.gzRequirementsThe Redfish Protocol Validator requires Python3.Required external packages:aenum
colorama
pyasn1
pyasn1-modules
requests
sseclient-py
urllib3If installing from GitHub, you may install the external packages by running:pip install -r requirements.txtUsageusage: rf_protocol_validator.py [-h] [--version] --user USER --password
                                PASSWORD --rhost RHOST [--log-level LOG_LEVEL]
                                [--report-dir REPORT_DIR]
                                [--report-type {html,tsv,both}]
                                [--avoid-http-redirect]
                                [--no-cert-check | --ca-bundle CA_BUNDLE]

Validate the protocol conformance of a Redfish service

required arguments:
  --user USER, -u USER  the username for authentication
  --password PASSWORD, -p PASSWORD
                        the password for authentication
  --rhost RHOST, -r RHOST
                        address of the Redfish service (with scheme)

optional arguments:
  -h, --help            show this help message and exit
  --version             show program's version number and exit
  --log-level {DEBUG,INFO,WARNING,ERROR,CRITICAL}
                        the logging level (default: WARNING)
  --report-dir REPORT_DIR
                        the directory for generated report files (default:
                        "reports")
  --report-type {html,tsv,both}
                        the type of report to generate: html, tsv, or both
                        (default: both)
  --avoid-http-redirect
                        avoid attempts to generate HTTP redirects for services
                        that do not support HTTP
  --no-cert-check       disable verification of host SSL certificates
  --ca-bundle CA_BUNDLE
                        the file or directory containing trusted CAsExample:rf_protocol_validator -r https://192.168.1.100 -u USERNAME -p PASSWORDUnit TestsThe Redfish Protocol Validator unit tests are executed using thetoxpackage.You may installtoxby running:pip install toxRunning the unit tests:toxRelease ProcessGo to the "Actions" pageSelect the "Release and Publish" workflowClick "Run workflow"Fill out the formClick "Run workflow"
Package: redflag
redflag🚩redflagaims to be an automatic safety net for machine learning datasets. The vision is to accept input of a PandasDataFrameor NumPyndarrayrepresenting the inputXand targetyin a machine learning task.redflagwill provide an analysis of each feature, and of the target, including aspects such as class imbalance, leakage, outliers, anomalous data patterns, threats to the IID assumption, and so on. The goal is to complement other projects likepandas-profilingandgreatexpectations.InstallationYou can install this package withpip:python -m pip install redflagAlternatively, you can use thecondapackage manager, pointed at theconda-forgechannel:conda install -c conda-forge redflagFor developers, there is apipoption for installingdevdependencies. Usepip install "redflag[dev]"to install all testing and documentation packages.Example withsklearnThe most useful components ofredflagare probably thescikit-learn"detectors". These sit in your pipeline, look at your training and validation data, and emit warnings if something looks like it might cause a problem. For example, we can get alerted to an imbalanced target vectorylike so:importredflagasrffromsklearn.datasetsimportmake_classificationX,y=make_classification(weights=[0.1])_=rf.ImbalanceDetector().fit(X,y)This raises a warning:🚩Thelabelsareimbalancedbymorethanthethreshold(0.780>0.400).Seeself.minority_classes_fortheminorityclasses.For maximum effect, put this and other detectors in your pipeline, or use the pre-buildrf.pipelinewhich contains several useful alerts.Seethe documentation, and specifically the notebookUsingredflagwithsklearn.ipynbfor other examples.Example of function callredflagis also a collection of functions. Most of the useful ones take one or more columns of data (usually a 1D or 2D NumPy array) and run a single test. For example, we can do some outlier detection. Theget_outliers()function returns the indices of data points that are considered outliers:>>>importredflagasrf>>>data=3*[-3,-2,-2,-1,0,0,0,1,2,2,3]>>>rf.get_outliers(data)array([],dtype=int64)That is, there are no outliers. But let's add a clear outlier: a new data record with a value of 100. The function returns the index position(s) of the outlier point(s):>>>rf.get_outliers(data+[100])array([33])Seethe documentation, and specifically the notebookBasic_usage.ipynbfor several other basic examples.DocumentationThe documentation is online.ContributingPlease seeCONTRIBUTING.md. There is also a sectionin the documentationaboutDevelopment.
Package: redflask
A Restful_Api service framework based on Flask, which implements routing separation without relying on Flask’s blueprint. It provides a common interface between HTTP request types and file transfer types.A simpler asynchronous task distribution scheme is provided. The most commonly used user password verification module and token verification module are provided. The server’s automatic configuration scheme is integrated with Gunicorn+Gevent. Database useSqlalchemy and Redis. Provides a solution for Flask as a Https service. The Flask cross domain problem is solved.
Package: redflyingbaron
Quick & dirty doc=================There isn't that much here yet, I'm mostly playing arround.In \*sh shell:.. code:: bashpython redflyingbaron.py [list of python files]In (I)Python shell:.. code:: python# assuming that you have run: python redflyingbaron.py redflyingbaron.py ./test_redflyingbaron.py# for now, red is an overloaded OrderedDict that contains file paths as keys# and the corresponding RedBaron instances as values.red      # display the current filesred[0]   # access by indexred["./test_redflyingbaron.py"]  # access by path (look at how this file is given in the cli; yes, it's a lame example)red["test_redflyingbaron.py"]    # access by filenamered["test_redflyingbaron"]       # access by filename without extensionred[1:]  # accept slicesred["f:./test_redflyingbaron.py"]  # custom slicing query, returns files that match this requestred["f:redflyingbaron.py"]         # think of using it on a django project and askingred["f:redflyingbaron"]            # all "models" filesred[re.compile(r'[^_]+')]  # can use a regex (^ and $ are put arround the regex)red["re:[^_]+"]            # regex for the lazyred[lambda key, value: "red" in key]  # can use a callablered.find("stuff")      # return the first matched stuffred.find_all("stuff")  # return all the matched stuff of all the filesred("stuff")           # samered.display()  # display the content of the files, useful with a slicered[0].save()  # save modifications to diskred.save()     # same but for all files of red (can be combined with slices)red[0].reload()  # reread the content of the filered.reload()     # same but for all files of red (can be combined with slices)red.add("/path/to/file", "/path/to/another/file", "again.py")  # add more filesTodo====Next-----  .undo() .redo() (needs modifications of RedBaron to display hooks)-  .set\_automatic\_save() (or some better/other api) -> save at everymodification (needs modifications of RedBaron to display hooks)-  overload **del** so it behaves like **getitem**-  allow to use globs in red[query]Futur------  .edit(editor=None) (find editor in $EDITOR of env) launch a texteditor on a tmp file containing the currently selected stuff, whenediting is done, parse the result and replace the node on which.edit() was done with the result (should be in RedBaron instead?)-  session management: automatically save redflyingbaron instance +undo/redo + files content (not sure on this one) somewhere in .json,allow to list those and go back into a session-  RedBaron wrapper to abstract the filesystem (use this to allow pythonfiles to be anywhere http://docs.pyfilesystem.org/en/latest/)-  Add more filesystem abstraction, allow some kind of syntaxe like"sftp://" "fuse://" on the Cli api-  history should be a tree like in vim/emacsChangelog=========0.1.1 (2015-02-14)----------------- Convert README to rst for pypi- add some classifiers0.1 (2015-02-14)----------------- First release