Saravanan666/pypi-org huggingface dataset:
Package: remotedict
REMOTE DICTRemoteDictis a Python library intended to host a dictionary in a cloud backend.
Currently it is supported Azure Blob Storage.USAGE - AZUREGrab aCONNECTION_STRINGfrom your azure blob storage, then import theAzureDictionaryas follows:>>>fromremotedict.azureimportAzureDictionary>>>remote_dict=AzureDictionary(CONNECTION_STRING,container_name="mycontainer",folder_name="myfolder")>>>remote_dictAzureBlobStorage.Container:"mycontainer";Folder:"myfolder";Numelements:0>>>remote_dict["foo"]="bar">>>remote_dict["foo"]barremote_dictis an object that behaves like a python dictionary. However, it contains extensive functionality useful to dealing with large data and concurrency.HOW IT WORKSOnceremote_dictis instantiated, it can be used to store any kind of data:remote_dict['example']="hello"remote_dict['example2']=b"binary data of any size"remote_dict['example3']=42remote_dict['example4']={"this":{"is":b"a subdictionary","that":"holds","any":True,"data":42}}remote_dict['example5']=["even","lists","or","numpy","and","pandas"]remote_dict['example6']=np.random.randn(10,3,1)remote_dict['example7']=pd.DataFrame([1,2,3,4])It allows to shorten the assignments and readings in atomic operations:remote_dict[['example','example2','example3']]="hello",b"binary data",42Each entry is stored as an LZ4-compressed binary in a single file inside the specified container and folder during instantiation ofremote_dict.
There are no soft limits in the size a value can have.INDEXESInRemoteDict, there is a concept ofIndexwhich allows to retrieve all the keys instantly without iterating the backend for elements.This index functionality is achieved by using a file as an indexer, ensuring that concurrency can't break it by using cloud leases on the file.For this reason, the folder "Index" in the cloud container is reserved and handled automatically byRemoteDict.Rather than downloading the index file each time an index check is required, the class only checks theetagof the file (which is faster than downloading it). If theetagdoes not match the localetag, the index is redownloaded ensuring to be always up-to-date.The index is apd.Seriesobject that can be accessed as follows:>>>remote_dict.indexexampleexample/exampleexample2example/example2example3example/example3example4example/example4example5example/example5example6example/example6example7example/example7Name:name,dtype:objectCONCURRENT ACCESSConcurrent readings are allowed by nature, however, concurrent writes are a bit more complex.RemoteDictdeals with concurrency by allowing to acquire leases on custom elements.Example to lock an element:>>>remote_dict.lock_item("example",duration=15)# duration in secondsOnce the element is locked, no otherremote_dict(anywhere, even different machines) can lock or write to this item again unless the item is manually unlocked or the duration expires.
If another element tries to lock it,remote_dictwill wait for it to be released (default behaviour) or raise an exception ifwait=False.It can only be written by this object as long as the lease is conceived.To unlock the element:>>>remote_dict.unlock_item("example")
Package: remote-env
Goal:Generate protobuf files in python and C++ to be used for remote access to RL environment.Supported version:protoc 3.12.2grpc 1.30.0To build python APIpython -m grpc_tools.protoc -I=. --python_out=. --grpc_python_out=. ./env.protoTo build C++ API/bigdisk/lax/rl/grpc/.local/bin/protoc -I=. --cpp_out=. --grpc_out=. --plugin=protoc-gen-grpc=$(which grpc_cpp_plugin) ./env.protomv ./env.pb.h grpc_client/include/mv ./env.pb.cc grpc_client/src/mv ./env.grpc.pb.h grpc_client/include/mv ./env.grpc.pb.cc grpc_client/How to use?Run server.py to start a gym server on nvidia05 and then you can either use client.py
or client.cpp to make calls to the server.Example: start a server on nvidia05:
/bigdisk/lax/renaza/projects/anaconda3/bin/python server.py--host 10.122.32.31 --port 10020Note: this particular python package satisfies the required packages, that is why we suggest testers to use it until we create a grpc package.
Package: remote-env-test
Goal:Generate protobuf files in python and C++ to be used for remote access to RL environment.Supported version:protoc 3.12.2grpc 1.30.0To build python APIpython -m grpc_tools.protoc -I=. --python_out=. --grpc_python_out=. ./env.protoTo build C++ API/bigdisk/lax/rl/grpc/.local/bin/protoc -I=. --cpp_out=. --grpc_out=. --plugin=protoc-gen-grpc=$(which grpc_cpp_plugin) ./env.protomv ./env.pb.h grpc_client/include/mv ./env.pb.cc grpc_client/src/mv ./env.grpc.pb.h grpc_client/include/mv ./env.grpc.pb.cc grpc_client/How to use?Run server.py to start a gym server on nvidia05 and then you can either use client.py
or client.cpp to make calls to the server.Example: start a server on nvidia05:
/bigdisk/lax/renaza/projects/anaconda3/bin/python server.py--host 10.122.32.31 --port 10020Note: this particular python package satisfies the required packages, that is why we suggest testers to use it until we create a grpc package.
Package: remote-execute
remote-executeExecute remote code fetched from a URLExample 1:remote_code_urls = [
    'https://example.com/code1.py',
    'https://example.com/code2.py',
    'https://example.com/code3.py',
]

execute_remote_code(remote_code_urls)Example 2:remote_code_urls = [
    'https://example.com/code1.py',
    'https://example.com/code2.py',
    'https://example.com/code3.py',
]
auth_tokens = [
    'your_auth_token_1',
    None, # No token for the 2nd URL
    'your_auth_token_3',
]
user_agents = [
    'your_user_agent_1',
    'your_user_agent_2',
    None, # No user agent for the 3rd URL
]

execute_remote_code(remote_code_urls, auth_tokens, user_agents)
Package: remoteframe
RemotelibVarious wrappers for subprocess, ssh, fabric.REX: Remote execute:REX(
target,
user = None,
pass_ = None,
port = None,
audit_file = None,
silent = True
)REX.rex("cmd", audit=True, bg=False, logfilename="deploy1.log")Remotely execute the command specified by cmd. If bg=True, runs with nohup
and returns immediately. If audit = True, writes the stdout of the command
to the specified logfilename on the remote server.REX.rex_push(local_path, remote_path): scp from the user over the active REX connectionREX.rex_pull(remote_path, local_path): scp a file towards the user over an active REX connectionSSHTunnel(object)importimportssh_tunneltun=ssh_tunnel.SSHTunnel(<remote-site>[local_port(4444),remote_port(3306),remoteinterface("localhost"),remote_user=<current_user>,spin=(True,False),foreground=(True,False),immediate=(True,False))RemoteDB(SSHTunnel):-- Execute MySQL queries over a forwarded SSH connectionremote_db = ssh_tunnel.RemoteDB(
    db_hostname, db_user=<current_user>, db_pass=<None>, db_port=4444, database=<None>, **SSHTunnel(*, **)
    )Tunnels(object):-- Registry for SSH Tunnels; also allows iteration (for example, to kill the connection.) Allows iteration.
-- To register a tunnel, use the register()
Package: remotefreebox
Python library for the Freebox network-based input API (rudp, foil). The code is based from the C implementation available athttps://github.com/fbx/.The documentation of the protocol is available here:http://dev.freebox.fr/sdk/## UsageUse the class FreeboxController, that automatically look for the network for a freebox.
Then, use the press method to simulate a key press.from remotefreebox.freeboxcontroller import FreeboxControllerfbx = FreeboxController()
fbx.press(“Chan+”)
Package: remote-fs
A tool to manage mounting your remote filesystems using smbfs and ssfs.Installpip installremote-fsUsageUsage: remote-fs [OPTIONS] COMMAND [ARGS]...

Options:
  --smbfs  mounts via mount_smbfs (darwin only)
  --sshfs  mounts via sshfs
  --help   Show this message and exit.

Commands:
  ls
  mount
  unmountlsCan listconfigsfor saved configs andmountsfor currently mounted configs.Usage: remote-fs ls [OPTIONS] RESOURCE

Options:
  --help  Show this message and exit.mountWhen--sshfsis set, the default value for the--optionparam isreconnect,ServerAliveInterval=15,ServerAliveCountMax=3.Usage: remote-fs mount [OPTIONS] MOUNT_POINT

Options:
  --load
  --name TEXT
  --remote TEXT      full hostname string, e.g. user@hostname:dir
  --hostname TEXT
  --user TEXT
  --dir TEXT
  -o, --option TEXT
  --help             Show this message and exit.unmountRunsumountusing the mount point in the passed config.Usage: remote-fs unmount [OPTIONS] NAME

Options:
  --help  Show this message and exit.
Package: remote-functions
remote-functionsRemote-functions provides type enforced remotely run Python functions. Using remote-functions,
developers can run Python functions from any device with any programming language.Key FeaturesFast: Built on top ofFastAPI.Easy: Designed to be easy to use and learn.Type Checking: Built-in type checking for function arguments.RequirementsPython 3.8+Installation$pipinstallremote-functionsExampleServer sideCreate a fileserver.pywith:fromremote_functionsimportremote,start@remote(enforce_types=True)defadd(a:int,b:int):returna+bif__name__=='__main__':start()Client sideCreate a fileclient.pywith:fromremote_functionsimportExecutorapi_url="http://127.0.0.1:8000"ex=Executor(api_url)resp=ex.execute("add",a=2,b=3)ifresp.exit_code==0:# function executed successfullyprint(resp.response)# 5elifresp.exit_code==1:# function arguments were malformedprint(resp.response)elifresp.exit_code==2:# function had an exception during executionprint(resp.response)# gives us the full traceback for easy debuggingAdd authenticationIf you want to protect your application from unauthorized access,
you can enable key based authentication.To enable authentication change yourserver.pyfile to:fromremote_functionsimportremote,start,Settingssettings=Settings()settings.authorization="super_secret_key"@remote(enforce_types=True,settings=settings)defadd(a:int,b:int):returna+bif__name__=='__main__':start()Then inclient.pyadd theauthorizationargumentfromremote_functionsimportExecutorapi_url="http://127.0.0.1:8000"ex=Executor(api_url,authorization="super_secret_key")resp=ex.execute("add",a=2,b=3)ifresp.exit_code==0:# function executed successfullyprint(resp.response)# 5elifresp.exit_code==1:# function arguments were malformedprint(resp.response)elifresp.exit_code==2:# function had an exception during executionprint(resp.response)# gives us the full traceback for easy debuggingRun itFirst start the server with:$pythonserver.pyThen run client.py to test your remote function$pythonclient.pyDeploy in productionTo deploy your application for production you just have to slightly modify your server.py file by changing
thehostandportfromremote_functionsimportremote,start@remote(enforce_types=True)defadd(a:int,b:int):returna+bif__name__=='__main__':start(host="0.0.0.0",port=80)LicenseThis project is licensed under the terms of the MIT license.
Package: remote-graphcast
Remote GraphcastRungraphcaston arunpodGPU server. Output is saved tos3. Shouldn't cost more than $0.6 USD for a 10 day forcast.Order of operationsYour input is validatedA secure runpod GPU pod is spun up on your runpod accountGraphcast is installed into that gpu and forecasts of your chosen length are generated for each timestamp, this takes around 10 minutes for a 10 day forcastThese forecasts are saved to your chosen s3 bucket, roughly6.5GB for 10 daysof forecastThe runpod pod is terminatedThe program exitsRequirementspython 3.8+ and pipcds.climatecredentialsanAWSs3 bucket, free tier should be fineS3 credentials to go with the bucketRunpodcredentialsInstallationpip install remote-graphcastExample Codefromremote_graphcastimportremote_castremote_cast(aws_access_key_id='YOUR_AWS_ACCESS_KEY_ID',aws_secret_access_key='YOUR_AWS_SECRET_ACCESS_KEY',aws_bucket='YOUR_AWS_BUCKET_NAME',cds_url='https://cds.climate.copernicus.eu/api/v2',# this is probably your CDS URLcds_key='YOUR_CDS_KEY',forcast_list="[{'start': '2023122518', 'hours_to_forcast': 48}]",# dates to forcast from, note the weird quasi-JSON format, of this string, use single quotes instead of double quotes# select a date in the future and it will raise an error without spinning up anythingrunpod_key='YOUR_RUNPOD_KEY',gpu_type_id="NVIDIA A100-SXM4-80GB",# graphcast needs at least 61GB GPU ram (unless you want to quantize)container_disk_in_gb=50,# you'll need around 40GB per 10 day forcast + a healthy 10GB buffer)# internally this function will keep polling the pod it spins up and the s3 bucket until it sees that all forcasts# are complete, then it will returnWarningIn order to make predictions graphcast must request ERA5 reanalysis data from the European Center for Medium Range Weather Forcasts (ECMWF). Usually the download completes in < 2 minutes. However, if their servers are busy your request will beput in a queue. You can view all your open requestshere. Until your request is granted is granted, the graphcast runpod server will be waiting idly (costing you money). This process has taken me > 1 hour in the past.You can also check your progress by viewing the runpod logs.
Package: remote-i2c
Remote I2CA SMBus class-compatible TCP proxy allowing you to host or connect to a Remote I2C
session with minimal effort.My use case for writing this module is to allow me to work with I2C on a Raspberry Pi
that is on my network, without having to install anything that takes up too much memory
or processing power. I serve this thin SMBus server module on the Pi, then I can develop
as I please on my computer and interact with the I2C bus as if it was on my own machine.Important NotesThis module was developed:quicklywithout testsfor the purpose of developmentIt is NOT:a replacement for an actual local I2C connection (particularlyfor real-time comms)guaranteed to be free of bugssuitable for production use (unless you're happy to take your chances)InstallInstall with pip:pipinstallremote-i2cExampleOn the I2C Host (e.g., Raspberry Pi)Ensure that I2C is enabled! (sudo raspi-config)Ensure that the user you're operating under has permission to access the I2C hardware! (e.g., part of the i2c group)Run the remote-i2c module directly with the python interpreter from the command line:python3-mremote_i2cAlternatively, run the module from a python script:#!/usr/bin/env python3# Import the RemoteI2CServer classfromremote_i2cimportRemoteI2CServer# Create the server (see docstring for additional args)server=RemoteI2CServer()# Start the server (blocks forever!)server.serve()On the I2C Client (e.g., Desktop/Laptop)#!/usr/bin/env python3# Import the RemoteI2CClient classfromremote_i2cimportRemoteI2CClient# Connect to the I2C Host (see docstring for additional args)remote_i2c_host='192.168.1.2'bus=RemoteI2CClient(remote_i2c_host)bus.connect()# Perform I2C operations as you normally would with SMBus2addr=0x67reg=0xf2value=bus.read_byte_data(addr,reg)bus.write_byte_data(addr,reg,value+1%0xff)# Disconnect when you're done, if you feel the needbus.disconnect()AuthorDaniel 'Vector' Kerr (vector@vector.id.au|https://vector.id.au)LicenseCopyright © 2019 Daniel 'Vector' Kerr (vector@vector.id.au)Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Package: remote-inria
RemI->Documentation<-RemoteInriaCode here, run there !A CLI tool for remotely interacting with Inria computing resources.What is remi ?remi is a tool aiming at easing the workflow of Inria researchers when it comes to performing
computations remotely.
More precisely,remiis configured for each project you might want to
use it for.Once your preferences are set, you can run your code either on your desktop at Inria or on one the
cluster nodes.If you are tired of messing up with 4-lineoarsubcommands or if you find yourselfcommitting
andpushing your code each time you want to test it remotely, this tool is for you !Note:Even though this tool has been made to work from a personal computer different from your
Inria desktop, it also totally works when running directly from the Inria desktop.Most of theremifeatures are still relevant in this case.Presentation / tutorial video:https://odysee.com/@GaetanLepage:6/remote-inria:6Main featuresSynchronization:remicreates a remote clone of your project on the Inria storage space
(under\scratch) and lets you synchronize it easily.Remote execution:The core idea behindremiis to provide an easy way to execute code on
remote computers (regular Inria desktops or cluster servers).Clusters and singularity support:Thecomplexway to request computing resources is
integrated inremito minimize overhead. Singularity container management is also embedded
(build and use).Jupyter notebook support:This tool lets you run a jupyter notebook server on your Inria
workstation and connect to it locally on the browser.ContributingAny help to the improvement ofremiis more than welcome.You may write an issue to warn me of any bug or desired feature bywriting an
issue.AcknowledgementThis project was inspired fromLabML Remote.The latter does not supportsshthrough a bastion because it uses theparamikolibrary. RemI, on the other hand, uses traditional calls tosshcommand.The main motivation to start a separate project was to design a tool specifically with the Inria
computing needs in mind (use of Inria clusters, natively using the available resources etc).
Package: remoteio
remoteioA Raspberry Pi GPIO remote control based on gpiozerohttps://github.com/gpiozero/gpiozeroInstall remote server as deamonUse this all-in-one command to install remoteio as deamon on port8509.
If remoteio is already installed, this command will update all files.bash -c "$(wget -qLO - https://github.com/schech1/remoteio/raw/master/install.sh)"Install using pippip install remoteioWhen using pip, the server needs to be set up manually.
See the examples below.Server usageStart a remote server on port1234.
If no port is specified default port8509will be usedfrom remoteio import run_server

if __name__ == "__main__":
    run_server(port=1234)Client usagefrom remoteio import RemoteServer

if __name__ == "__main__":
    server_ip = "192.168.1.38"
    server_port = 1234

    remote_server = RemoteServer(server_ip, server_port)
    remote_pin = remote_server.pin(7, 'b')
    remote_pin.on(time_ms=2000) # Time until switch off
    remote_pin.blink() # Blink LED
    remote_pin.pulse() # Pulse LED
    remote_pin.off()
    remote_server.close()Use Board numberingremote_pin = remote_server.pin(7, 'b') # Use physical board numberingUse GPIO numberingremote_pin = remote_server.pin(4, 'g') # Use GPIO numbering (e.g. GPIO4)
Package: remoteit
remoteitSuper basic multiprocessing/multithreading with aconcurrent.futurestype interface.InstallpipinstallremoteitUsageimporttimeimportremoteit@remoteit.remotedefdo_something(x):time.sleep(1)returnx*2@remoteit.threadeddefdo_something_else(x):time.sleep(1)returnx*2# simple - just call and get resultsfuture=do_something(5)future2=do_something_else(6)assertfuture.result()==10assertfuture2.result()==12# concurrent processes - run multiple together# get results in orderfutures=[do_something(i)foriinrange(4)]assertlist(remoteit.results(futures))==[0,2,4,6]# get results as soon as they finishfutures=[do_something(i)foriinrange(4)]assertset(remoteit.as_completed(futures))=={0,2,4,6}Description & MotivationThe difference between this andconcurrent.futuresis that:it's a single worker processit forks a new process every time.The reason that I made this and didn't just useconcurrent.futuresis because I was getting an error when trying to submit a job that referenced a Queue object about how certain objects can only be shared through inheritance.So I was back to usingmultiprocessing.Process, but passing and raising remote exceptions is a total pain and is something that I find myself solving and resolving. So I decided that this would be the last time that I wanted to think about how that messaging needs to happen.This package is basically a thin wrapper aroundmultiprocessing.Processandthreading.Threadthat will send the result back and raise any exceptions from the remote worker. Super simple!Notes & CaveatsFutureobjects should only be used by a single process.currently, I handle multiple concurrent futures+results by generating a random id and having the id returned along side the result.then if another future pulls a result off that doesn't match its result_id, it will put it in a results dictionary which is checked by other futures for their result_ids.but the problem is that dictionaries aren't shared between processes so if you're reading items from the result queue in 2 different processes, then it'll cause a deadlock because one process may pop another processes result from the queue and the future will never see its result.if anyone has any ideas on ways to fix this without too much overhead, post an issue!!Missing Interfacefut.cancel()- cancelling a task. we don't handle a cancelled resultfut.result(timeout)- we don't have result timeout atm.fut.add_done_callback()- we don't have a monitoring thread that will run the result. better off just callingfuture.result()for now
Package: remotejoystick
中文版Remote joysticks can be connected to local computers now.So some interesting games without online version can be played through screen sharing.This version turns remote joysticks into local keyboard. With a ordinary server, delay is about 100ms.Also, this program provide local joystick to keyboard function.InstallYou may install this program through the following script:pipinstallremotejoystickUsageThis program provides two basic functions: local j2k & remote joystick connection.More detailed help info is also available:remotejoystick -hremote joystick connectionFirst, you need to have an touchable public net ip, assume it is114.114.114.114.Install this program on the server of the ip (three platfroms supported), and run this cmd:remotejoystick -ep 2333.This will use 2333 port for this program.Then run this cmd on the joystick pc:remotejoystick -sd 114.114.114.114 -p 2333. (-j option is for more than one joystick)Finally, use this cmd on game pc:remotejoystick -rd 114.114.114.114 -p 2333. (order of the last two cmd does not matter)local joystick to keyboardUse this cmd to turn joystick to keyboard locally:remotejoystick –local.Future featuresVisual versionSimulate as joystick signal locally (help wanted! If you have any idea please contact me.)AuthorAuthor:LittleCoderEmail:i7meavnktqegm1b@qq.comSuggestion:Issue #1