Saravanan666/pypi-org huggingface dataset:
Package: rpapy
RPAPY - Open Source Tool for Robotic Process AutomatitionMedium|Linkedin|Youtube|TelegramRPAPYis a open source easy tool for automating boring stuffs on any screen with robotframework, pyautogui, pywinauto and others."CreatingautomationsforGUIhas never been morefunthan now."Get startedWindowsThe easiest way to install RPAPY is by usingpip installDownload and installPython 3.7Install the latest version RPAPY on your machine:pip install rpapyHowever, it is advisable to use a virtual environment for an isolated installation of all requirements, this avoids conflicts with the python interpreter installed on the host machine:pip install virtualenv
mkdir <your-project-name>
cd <your-project-name>
virtualenv create rpapy-env
activate rpapy-ev
pip install rpapyThe construction of the project structure is accomplished by executing the following command in the terminal:rpapyThe hotkeys menu to be used will be displayed after executing the above command.***TURN ON AGENTPY***
        ****************HOTKEYS MENU****************
        <CTRL>+<ALT>+P: Capture image or ocr
        <CTRL>+<ALT>+R: Change file name
        <CTRL>+<ALT>+B: Switch between backends
        <CTRL>+I:       Inspect UI element
        <CTRL>+<CMD>+C: View current configuration
        <CTRL>+<CMD>+E: Load sample implementation
        <CTRL>+<CMD>+X: Turn off agent
        ********************************************To run the sample implementation, perform the following steps:Configure the .env file in the root directory of the project.###VARIAVEIS DE AMBIENTE PYTHON-DOTENV

#RESOURCES_DIR_NAME=resources
#RESOURCES_KEYWORDS_FILE_NAME=keywords.robot
#IMAGES_DIR_NAME=images
#IMAGES_ERROR_DIR_NAME=images_error
#TASKS_DIR_NAME=tasks
MAX_WAIT_MANUTENCAO=5
VERIFICAR_MODO=True
#ARQUIVO_TEMPORARIO_ATIVO=False
#NOME_ARQUIVO_TEMPORARIO=temp.txtRun the following command on the terminal:robot -d log tasksIn the dialog box, which will be displayed, choose the option YES and make changes to the images as required by RPAPY.After the update cycle of the UI images in which the actions will be performed by the robot, interrupt the execution.Repet the command on the terminal:robot -d log tasksselect the option no in the dialog box to choose the maintenance mode off.CreditsUnder the hood, RPAPY is built on some of the greatest open source libraries. Within RPAPY, the following libraries are currently included:KeyringMouseNumpyOpencvPythonPillowPyAutoGUIPynputPyperclipPySide6PySimpleGUIPytesseractPythonDotenvPwinautoRobotFrameworkWin10toast
Package: rparse
# rparse [![Build Status](https://travis-ci.org/dveselov/rparse.svg?branch=master)](https://travis-ci.org/dveselov/rparse)Python `requirements.txt` parser.# Installation```bash$ pip install rparse```# Usage```pythonimport rparserequirements = """flask == 0.10.1pip >= 6.0.0, < 6.0.7"""for requirement in rparse.parse(requirements):print(requirement.name, requirement.specs)```Output will be looks like this:```python("flask", [("==", "0.10.1")])("pip", [(">=", "6.0.0"), ("<", "6.0.7")])````rparse` also have simple command line interface that can be used like this:```bash$ cat requirements.txtflask==0.10.1raven[flask]>=1.0$ rparse.py requirements.txtPackage: flaskVersion Specifier: [('==', '0.10.1')]Extras: NoneComment: None----------------------------------------------------------------Package: ravenVersion Specifier: [('>=', '1.0')]Extras: ['flask']Comment: None----------------------------------------------------------------```
Package: rpa-sap
RPA_SAPPython module delivers some actions to automate SAPGUI operations (Sap Scripting)
The module is compatibile with the Robocorp.InstallationTo install the package run:pip install rpa-sapExampleOpen new SAPGUI sessionfrom rpa_sap import SapGui

sapgui = SapGui()

sapgui.open_new_session(connection_string, user_id, password, client, language)DependenciesPython packages: pandas >= 1.4.4, pywin32 >= 303
Package: rpass
rpasssimple command line app for generating strong random passwords. It also shows all the passwords you generated.InstallationUsing Pip$pipinstallrpassManual$gitclonehttps://github.com/surajkarki66/rpass$cdrpass$pythonsetup.pyinstallUsage$rpass[Options]Options-h, --helpDisplay help-vDisplay version-l, --length LENGTHPasswords should contain LENGTH characters. Defaults to 12.-ns, --no-symbolsDon't use symbols-nd, --no-digitsDon't use digits--upperUse only upper case letters--lowerUse only lower case lettersHelp$rpass--helpExamplesBelow are some examples of rpass usage.Generate password:$rpassYour password is 9CI=OydGufZmSaved! to clipboardGenerate password with eight characters:$rpass-l8Your password is TgRt6ZU?Saved! to clipboardGenerate password with all upper case letters:$rpass--upperYour password is 8#ZS"=]FG#qWSaved! to clipboardGenerate password without symbols and save:$rpass-ns-sYour password is D3PDbbePwcYESaved! to clipboardSaved! to file
Package: rpatterson.listfile
Support list operations over lines of file-like objects.All operations avoid iterating except when necessary.  Operations that
force iteration over the whole file include len() and using negative
indexes.  In order to avoid excess seeking, all list operations may
change the position of the underlying file object.Start with a file-like object.>>> import cStringIO
>>> file_ = cStringIO.StringIO("""\
... foo
... bar
... baz
... qux
... """)Wrap the file-like object in a listfile instance.>>> from rpatterson import listfile
>>> wrapped = listfile.ListFile(file_)Lines can be accessed by index.>>> wrapped[0]
'foo\n'
>>> wrapped[2]
'baz\n'Negative indexes are supported as well.>>> wrapped[-1]
'qux\n'
>>> wrapped[-3]
'bar\n'The length returns the number of lines.>>> len(wrapped)
4An index beyond the end of the file raises IndexError.>>> wrapped[4]
Traceback (most recent call last):
IndexError: list index out of rangeRetrieving a slice returns a new wrapper around the same file object.>>> slice_ = wrapped[1:3]
>>> len(slice_)
2
>>> slice_[0]
'bar\n'
>>> slice_[1]
'baz\n'>>> slice_ = wrapped[1:][0:2]
>>> len(slice_)
2
>>> slice_[0]
'bar\n'
>>> slice_[1]
'baz\n'Slice stepping is also supported.>>> slice_ = wrapped[1::2]
>>> len(slice_)
2
>>> slice_[0]
'bar\n'
>>> slice_[1]
'qux\n'The wrappers are also iterators suitable for writelines().>>> list(slice_)
['bar\n', 'qux\n']
>>> out = cStringIO.StringIO()
>>> out.writelines(slice_)
>>> out.getvalue()
'bar\nqux\n'Changelog0.1 - 2009-05-27Initial release
Package: rpatterson.stripdupes
InstallationAll you need iseasy_install:$ easy_install rpatterson.stripdupesUsageSee the stripdupes console script’s help message.>>> import subprocess
>>> popen = subprocess.Popen(
...     [stripdupes_script, '--help'],
...     stdout=subprocess.PIPE, stderr=subprocess.PIPE)
>>> print popen.stdout.read()
Usage: stripdupes [options]
Strip duplicated sequences of lines.
Options:
  -h, --help  show this help message and exit
  -m NUM, --min=NUM  Minimum length of duplicated sequence.  If
                     NUM is less than one, use a proportion of the
                     total number of lines, otherwise NUM is a
                     number of lines. [default: 0.01]
  -p REGEXP, --pattern=REGEXP
                        Regular expression pattern used to
                        normalize strings in sequences of strings.
                        The default matches all whitespace. Use an
                        empty string to disable. [default: '\s+']
  -r STRING, --repl=STRING
                        String to replace matches of pattern with
                        for normalizing strings in sequences of
                        strings. [default: ' ']When given input files whose combined contents include sequences of
lines longer than the threshold that are duplicated elsewhere in the
input files, the output file will be written without those repeated
sequences.>>> input = """\
... foo
... foo
... bar
... baz
... qux
... quux
... foo
... bar
... baz
... qux
... bah
... blah1
... quux
... blah
... quux
... fin
... """>>> import cStringIO
>>> from rpatterson import stripdupes
>>> for line in stripdupes.strip(
...     cStringIO.StringIO(input).readlines()): print line,
foo
bar
baz
qux
quux
bah
blah1
blah
fin>>> input = """\
... blah
... quux
... bah
... foo
... foo\t
... bar
... baz
... qux
... quux
... foo
... bar
... baz
... qux
... fin
... fin
... fin
... null
... fin
... """>>> for line in stripdupes.strip(
...     cStringIO.StringIO(input).readlines()): print line,
blah
quux
bah
foo
bar
baz
qux
fin
nullEnsure that odd sequences can be handled.>>> list(stripdupes.strip([]))
[]
>>> list(stripdupes.strip(['foo']))
['foo']A duplicated sequence is not stripped if it is 1% or less of the
length of the sequence.>>> seq = range(149)+[0]
>>> len(seq)
150
>>> seq[0] == seq[149]
True
>>> len(list(stripdupes.strip(seq, pattern=None)))
150>>> seq = range(148)+[0]
>>> len(seq)
149
>>> seq[0] == seq[148]
True
>>> len(list(stripdupes.strip(seq, pattern=None)))
148Changelog0.1 - 2009-05-27Initial release
Package: rpa-web-core
RPA Web CoreCore packages for web basedRobot Process AutomationTasksThe problemCascading resource import structure for Robot FrameworkResourceshttps://rasjani.github.io/2020/01/05/bundle-resources.htmlhttps://github.com/rasjani/robotframework-importresourcehttps://github.com/rasjani/robotframework-importresource-testdataGet in touch with meI am always looking for Jobs ... :sunglasses:GithubMy WebsiteTwitter HandleLinkedInStackoverflowSpread Love :hearts: and not :no_entry_sign: hatred
Package: rpbot
RPBotRPBot is a Python script to serializeRobot Frameworkoutput files into
a ReportPortal. This way the futureRobot Frameworkrelated tools and
plugins will have a unified storage for the test run results.RPBot is a fork of DbBot-SQLAlchemy project that is using SQLAlchemy in order
to store test run results in any of the major supported database systems.RequirementsRPBot is tested onPython3.5+Robot Framework4.0+It may (though it is not guaranteed) work with older versions of dependencies.How it worksThe script takes one or moreoutput.xmlfiles as input, and stores
the respective results into a ReportPortalInstallationThis tool is installed with pip with command:$pipinstallrpbotAlternatively you can download thesource distribution, extract it and
install using:$pythonsetup.pyinstallUsage$python-mrpbot.run<options><rp_group_options><output.xml>options-d, --dry-run: do everything except store results into ReportPortal.-v, --verbose: be verbose. WARN, INFO, and DEBUG available.rp_group_options--RP_UUID: ReportPortal UUID. (required)--RP_ENDPOINT: ReportPortal URL. (required)--RP_LAUNCH: ReportPortal launch name. (required)--RP_PROJECT: ReportPortal project name. (required)--RP_LAUNCH_DOC: ReportPortal launch description.--RP_LAUNCH_ATTRIBUTES : ReportPortal launch attributes. Space-separated list of tags/attributes. ex) "CUSTOMER:KDI PKG_VER:SVR20C"--RP_TEST_ATTRIBUTES: ReportPortal test attributes. Space-separated list of tags/attributes.output.xml: Output XML file of robot frameworkLicenseRpBot is released under theApache License, Version 2.0.See LICENSE.TXT for details.
Package: rpbp
Ribosome profiling with Bayesian predictions (Rp-Bp)Ribosome profiling (Ribo-seq) is an RNA-sequencing-based readout of RNA translation. Isolation and deep-sequencing of ribosome-protected RNA fragments (ribosome footprints) provides a genome-wide snapshot of the translatome at sub-codon resolution.Rp-Bpis an unsupervised Bayesian approach to predict translated open reading frames (ORFs) from ribosome profiles.Rp-Bpcan be used for ORF discovery, or simply to estimate periodicity in a set of Ribo-seq samples. When used for ORF discovery,Rp-Bpautomatically classifies ORFs into different biotypes or categories, relative to their host transcript.Rp-Bpcomes with twointeractive dashboardsorweb applications, one for read and periodicity quality control, the other to facilitate Ribo-seq ORFs discovery.DocumentationConsult theuser guidefor instructions on how to install the package, or to use Docker/Singularity containers with the package pre-installed. Detailed usage instructions and tutorials are available.How to report issuesFor bugs, issues, or feature requests, use thebug tracker. Follow the instructions and guidelines given in the templates.How to citeBrandon Malone, Ilian Atanassov, Florian Aeschimann, Xinping Li, Helge Großhans, Christoph Dieterich.Bayesian prediction of RNA translation from ribosome profiling,Nucleic Acids Research, Volume 45, Issue 6, 7 April 2017, Pages 2960-2972.LicenseThe MIT License (MIT). Copyright (c) 2016 dieterich-lab.
Package: rpc
Rpc gives you a consistent API for RPC protocols that doesn’t suck!Because you too can have nice things>>> from rpc import thrifty
>>> import Service
>>> with thrifty.client("localhost:45678", Service) as c:
...     print c.ping()Check out the documentation:http://www.deadpansincerity.com/docs/rpcHistory0.1.3 (2012-04-28)Fixed dependency bugs from 0.1.10.1.1 (2012-04-28)Added rpctl - support for creating well-behaved Unix Daemons for servers.Fixed bugs with protocol in JSON RPC client initialization0.1 (2012-04-07)Added XML RPC supportThrift, JSON RPC and JSONP functional
Package: rpc4django
PrerequisitesRPC4Django has been tested on Mac OS, Linux and Windows.Python2.7, 3.3+Django1.8+DefusedXMLDocutils(optional)Installationpip install rpc4django[reST]ConfigurationFirst, you need to add new url pattern to your rooturls.pyfile.
You can replacer'^RPC2$'with anything you like.# urls.py

from rpc4django.views import serve_rpc_request

urlpatterns = (
    # rpc4django will need to be in your Python path
    url(r'^RPC2$', serve_rpc_request),
)Second, add RPC4Django to the list of installed applications in yoursettings.py.# settings.py

INSTALLED_APPS = (
    'rpc4django',
)Lastly, you need to let RPC4Django know which methods to make available.
RPC4Django recursively imports all the apps inINSTALLED_APPSand makes any methods importable via__init__.pywith the@rpcmethoddecorator available as RPC methods. You can always write
your RPC methods in another module and simply import it in__init__.py.# testapp/__init__.py

from rpc4django import rpcmethod

# The doc string supports reST if docutils is installed
@rpcmethod(name='mynamespace.add', signature=['int', 'int', 'int'])
def add(a, b):
    '''Adds two numbers together
    >>> add(1, 2)
    3
    '''

    return a+b
Package: rpca
AccAltProj for robust PCAPort of the AccAltProj algorithm for robust PCA to python.This is a python port of theAccAltProj algorithm for robust PCA, described in thispaper.This implementation followssklearn'sfit&transformAPI.📦 InstallationRequires python 3In a terminal:pipinstallrpcaAs always, it is usually a good idea to use avirtual environment.
Package: rpc-Ariam27
RPCA simple implementation of RPC (Remote Procedural Call) in python.Examples:#server implementationfromrpcimportServerserver=Server("localhost",3000)@server.register("add")defadd(num1,num2):returnnum1+num2@server.register("concat")defconcat(str1,str2):returnstr1+str2@server.register("uppercase")defuppercase(string):returnstring.upper()server.run()#client implementationfromrpcimportClientclient=Client("localhost",3000)client.connect()print(client.execute("/"))#prints: ["add", "concat", "uppercase"]print(client.execute("add",1,2))#prints: 3print(client.execute("concat","a","b"))#prints: abprint(client.execute("uppercase","example"))#prints: EXAMPLEclient.close()#closes the socket connectionLinks:Github
Package: rpcc
rpccrpccis a Python command line tool that allows developers to easily define and work with remote procedure calls (
RPCs) compatible with theMercuryframework.Inspired by Google'sProtocol Buffers,rpccallows developers to easily define RPCs using a language- and platform- neutral language, that will then be used to
generate all the necessary C/C++ boilerplate code required to actually implement them.DocumentationDocumentation for the compiler can be foundhere.
Package: rpc-call
Note:The main idea of the project is based on RabbitMQ RPC, so RabbitMQ must be installed. Please keep it mind.Get startedSimple RPC client using FastAPIclient.pyimportasynciofromfastapiimportFastAPI,Depends,statusfromrpc_call.async_clientimportRPCClientfromrpc_call.typesimportTask,TaskResultapp=FastAPI()asyncdefrpc_connection()->RPCClient:returnawaitRPCClient(amqp_dsn="amqp://<client>:<passwd>@<host>:<port>/<vhost>",queue_name="<RabbitMQQueueName>").connect()@app.post("/RPCEndpoint",response_model=TaskResult)asyncdefread_users(task:Task,rpc_conn:RPCClient=Depends(rpc_connection))->TaskResult:task_result=awaitrpc_conn.call(task)returntask_result$uvicornclient:app--host0.0.0.0--port8000--reloadSimple RPC serverserver.pyfromrpc_call.serverimportRPCServerclassCallbackHandler:deftest_func(self,arg:str)->str:returnf"test_func('{arg}') call result"if__name__=="__main__":RPCServer(amqp_dsn="amqp://<client>:<passwd>@<host>:<port>/<vhost>",queue_name="<RabbitMQQueueName>",callback_handler=CallbackHandler)$pythonserver.pyUsagecurl-X'POST'\'http://127.0.0.1:8000/RPCEndpoint'\-H'accept: application/json'\-H'Content-Type: application/json'\-d'{"procedure": "test_func","kwargs": {"arg": "Hello world!"}}'And the response will be:{"status_code":200,"result":{"test_func":"test_func('Hello world!') call result"}}So now, with this elegant and simple library, you can call your code remotely! 👏
Good luck! 😉
Package: rpc-cli
RPC to CLIWrapper forPython OpenRPCto expose the
methods of an RPC Server through a CLI.InstallRPC CLI is on PyPI and can be installed with:pipinstallrpc-cliOr withPoetrypoetryaddrpc-cliExampleGiven the following in a filedemo.py.fromopenrpcimportRPCServerfrompydanticimportBaseModelfromrpc_cliimportclirpc=RPCServer()classVector3(BaseModel):x:floaty:floatz:float@rpc.method()defget_distance(a:Vector3,b:Vector3)->Vector3:"""Get distance between two points."""returnVector3(x=a.x-b.x,y=a.y-b.y,z=a.z-b.z)@rpc.method()defdivide(a:int,b:int)->float:"""Divide two integers."""returna/b@rpc.method()defsummation(numbers:list[int|float])->int|float:"""Summ all numbers in a list."""returnsum(numbers)if__name__=="__main__":cli(rpc).run()You now have a CLI.Using the CLIMethods can be called as such, notice arrays and object parameters are passed as JSON
strings.pythondemo.pyget_distance'{"x": 1, "y": 1, "z": 1}''{"x": 1, "y": 1, "z": 1}'pythondemo.pydivide62pythondemo.pysummation'[1, 2, 3]'Auto CompletionsThis library usescleo, auto completions can be
made by following the instructions in thecleo docs.Support The Developer
Package: rpcdataloader
RPC DataloaderThis library implements a variant of the PyTorch Dataloader using remote workers.
It allows to distribute workers over remote servers rather than the one running the main script.To use it, start one or several worker daemons on remote computers.
The machines running the data loaders will dispatch requests for items to the workers and await the returned values.Though similar totorch.rpc, this library uses its own implementation of RPC (Remote Procedure Call) which is simpler (no initialization) and does not conflict with the one from pytorch.InstallationpipinstallrpcdataloaderUsageTo use the RPC dataloader, start a few workers either from the command line:python-mrpcdataloader.launch--host=0.0.0.0--port=6543or by callingrpcdataloader.run_workerdirectly from a python script.Then instantiate a remote dataset and dataloader:dataset=rpcdataloader.RPCDataset(workers=['node01:6543','node02:5432'],dataset=torchvision.datasets.ImageFolder,root=args.data_path+"/train",transform=train_transform,)dataloader=rpcdataloader.RPCDataloader(datasetbatch_size=2,shuffle=True,pin_memory=True)forminibatchindataloader:...Further readingAPI documentationResNet50 training on ImageNet datasetSlurm integration using heterogeneous jobs
Package: rpc_exceptions
Simple, transparent, name-spaced exceptions across JSON-RPC services.InstallingThe rpc_exceptions project lives ongithub, and is available viapip.Installing v0.1 From Pipsudo pip install rpc_exceptions==0.1Installing v0.1 From Sourcecurl https://github.com/axialmarket/rpc_exceptions/achive/version_0.1.tar.gz | tar vzxf -
cd rpc_exceptions
sudo python setup.py installExamplesDefine a base exception with an api_name, exceptions for that API, and instantiateRPCExceptionHandlerwith those exceptions:from rpc_exceptions import RPCExceptionHandler, WrappedRPCError

class TestError(WrappedRPCError):
    api_name = 'test'

class PEBCAKError(TestError):
    code = -1
    _default_message = 'Problem exists between chair and keyboard'

class FUBARError(TestError):
    code = -2
    _default_message = 'FUBARed'

error_handler = RPCExceptionHandler([ PEBCAKError, FUBARError ])Decorate exposed functions with the instantiated RPCExceptionHandler’s wrap_rpc_exception decorator:from wrapped_rpc.exceptions import error_handler, PEBCAKError, FUBARError
@error_handler.wrap_rpc_exception
def fail1(arg):
    raise PEBCAKError

@error_handler.wrap_rpc_exception
def fail2(arg):
    raise FUBARErrorCoerce error codes and messages to exceptions  the instantiated RPCExceptionHandler’s get_exception_instance method:#client using tinyrpc
from wrapped_rpc.exceptions import error_handler, PEBCAKError, FUBARError
from tinyrpc import RPCClient, RPCError
from tinyrpc.protocols.jsonrpc import JSONRPCProtocol
from tinyrpc.transports.http import HttpPostClientTransport

class WrappedRPCClient(RPCClient):
    def __init__(self, protocol, transport, api_name):
        self.protocol = protocol
        self.transport = transport
        self.api_name = api_name

    def _send_and_handle_reply(self, req):
        reply = self.transport.send_message(req.serialize())
        response = self.protocol.parse_reply(reply)
        if hasattr(response, 'error'):
            try:
                raise error_handler.get_exception_instance(
                         response._jsonrpc_error_code,
                         self.api_name, response.error)
            except KeyError:
                raise RPCError('Error calling remote procedure: %s' %\
                               response.error)
        return response

rpc_client = WrappedRPCClient(
    JSONRPCProtocol(),
    HttpPostClientTransport('http://localhost:1234'),
    'test'
)
server = rpc_client.get_proxy()

try:
    server.fail1('foo')
except PEBCAKError as e:
    print 'code: %s, message: %s' % (e.code, e.msg)

try:
    server.fail2('bar')
except FUBARError as e:
    print 'code: %s, message: %s' % (e.code, e.msg)LicenseBSD, SeeLICENSE.txt
Package: rpcgrid
# RPCGrid (development)Remote procedure call package for any protocol and any transport layer.## Features
+ async/await support
+ logging remote procedure call
+ server/client side remote procedure call
+ custom transport and protocols
+ block/non-block call
+ parallel rpc calls in async mode#### Protocol
+ JsonRPC protocol support#### Transport
+ Single/Multithreading remote procedure call
+ UDP/TCP socket remote procedure call
+ RabbitMQ remote procedure call