Saravanan666/pypi-org huggingface dataset:
Package: remote-kernel
Remote Kernel v1.1Remote kernel is a pure-python package that sets up an ssh
connection with port forwarding to a remote host, and starts
up an IPyKernel on that host. This allows a locally running
instance of Jupyter or Spyder to easily run code on a remote
server. Moreover, this can be installed as a jupyter 'kernel',
allowing you to use this just as easily as you would use a
local kernel!InstallationTo install remote_kernel, run:pip install remote-kernelUsageRemote kernel is intended to spawn kernels on remote servers
for use in both Jupyter notebooks and Spyder.JupyterInstall the remote kernel:python -m remote_kernel install -t <ssh_host> [Options]To obtain a list of options for the installation, run:python -m remote_kernel install --helpSpyderTo use the remote kernel in spyder, a kernel needs to be
manually started and then connected to from spyder.To start the remote kernel:python -m remote_kernel -t <ssh_host> [Options]Again, options can be listed using:python -m remote_kernel --helpAlternatively, it is possible to start the remote kernel
from a kernel spec file (i.e. what jupyter uses to start kernels):python -m remote_kernel from-spec <kernel-name>Here,<kernel-name>is the name of directory containing thekernel.jsonkernel spec file. If the name is relative, remote_kernel
looks for it relative to the current directory, as well as in the jupyter
kernel directories, where jupyter kernels are installed as directories with
the kernel name.If successfull, this will print a message like this:remote_kernel.start I: Remote Kernel started. To connect another client to this kernel, use:
    --existing kernel-<user>@<host>.jsonCopy this name (or just the<user>@<hostpart) and use it
toconnect to a local existing kernel in spyder.
Even though the kernel is running remotely, and we're using SSH,
connect to it as if it were running locally (i.e. don't check the SSH box).N.B. The convenience function with the id expansion also works using
the<user>@<host>part, even though it's not a number.N.B. By default, remote_kernel starts regular ipykernels on the remote
server, but this can be overridden using the-ccommand line option.Acknowledgements/RequirementsThis package relies heaviliy on the following packagesparamiko,
for setting up the ssh connection.sshtunnel,
for creating the forwarding tunnels for the kernel ports.
Package: remote-log
importremote_logremote_log("https://myserver.com/log/","log this my dear logging server")It sends a POST request to the server with the data you passed. If the system is offline, it stored the logs offline and sends all the data on the next call ofremote_log.This way you are always assured you will receive the data to be logged.It also sends basic system information. Any uniquely identifiable information is not sent as plain text. It is hashed on the system using SHA256 before being sent. This way the logging server can still uniquely identify a log request but have no traceability back to the system that sent it thus allowing you to take a PRIVACY FIRST approach to logging.The functionremote_logis non blocking and doesn't return anything. It's only purpose is to send logging data.
Package: remote-log-analysis
Remote Log AnalysisOverviewA log file is a sequence of bytes where some immutability guarantee exists for
already written data. New data can be appended to the end of a log file but bytes
which have already been written should not change while accessed via this framework. 
Such logs can be large and efficiently processing such logs in chunks can 
save on data transfer costs and time. Note that any static file can be considered a 
log file.The above definition is very general and opens the door to just about any file-like object
which can be accessed over the network. By this definition
a network stream itself can be considered a log file and a goal of this framework is to 
provide the groundwork to make such extensions possible. In general, The more structured 
the data, the more useful this framework is for skipping efficiently within
the log file but this framework can be useful for accessing just about any stream-like 
object over a network.Examples will be developed over time to showcase the possibilities.TestsTo run the tests do the following from the project root directory:poetry installpytest -s tests/To run the tests with coverage try this from the project root directory:pytest -s --cov=remote_log_analysis --cov-report=html tests/
Package: remote-logger
Remote LoggerInstallationpipinstallremote-loggerExamplesInitializing RemoteLogger with Sentryimportloggingfromremote_logger.clients.sentry_logger_clientimportSentryLoggerClientfromremote_logger.remote_logger_handlerimportRemoteLoggerHandlerLOGGER=logging.getLogger(__name__)dsn="https://<key>@sentry.io/<project>"sentry_client=SentryLoggerClient(dsn=dsn)sentry_handler=RemoteLoggerHandler(client=sentry_client)sentry_handler.setLevel(logging.ERROR)LOGGER.addHandler(sentry_handler)Initializing RemoteLogger with Stackdriverimportloggingfromremote_logger.clients.stackdriver_logger_clientimportStackdriverLoggerClientfromremote_logger.remote_logger_handlerimportRemoteLoggerHandlerLOGGER=logging.getLogger(__name__)# With service keyservice_key_path="/path/to/key.json"stackdriver_client=StackdriverLoggerClient(service_key_path=service_key_path)# Without service keystackdriver_client=StackdriverLoggerClient()stackdriver_handler=RemoteLoggerHandler(stackdriver_client)stackdriver_handler.setLevel(logging.ERROR)LOGGER.addHandler(stackdriver_handler)Sending events to RemoteLoggerdummy_group_id=99primary_metadata={"pkey1":"pvalue1","pkey2":"pvalue2","pkey3":"pvalue3",}secondary_metadata={"skey1":"svalue1","skey2":"svalue2","skey3":"svalue3",}LOGGER.error("Test Message",extra={"group_id":dummy_group_id,"primary_metadata":primary_metadata,"secondary_metadata":secondary_metadata,})
Package: remotely
Remotely is a simple and secure remote code execution api that supports both
asynchronous and blocking execution.Remotely can be used for:distributing tasks to other boxes in parallelrunning coding under other versions of pythonaccessing libraries not available on the current box
such as using win32com from linuxaccessing resources (files etc) on another boxYou start the remotely server on the box where you want to execute code.from remotely import create_remotely_server
server = create_remotely_server("YOUR_API_KEY", PORT)
server.serve_forever()
...And you use the remotely decorater for any function you want to run remotely.from remotely import remotely

@remotely("YOUR_API_KEY", SERVER, PORT)
def remote_code():
    # import required packages
    # do something here
    return result

# function will be executed on the remote server
remote_code()The asynchronous (non-blocking) version runs the function as a separate process
on the remote server and supports simple job management functions (join and kill).from remotely import RemoteClient
rc = RemoteClient("API_KEY", SERVER, PORT)
pid = rc.run(foo, arg1, arg2=key2)
output = rc.join(pid)
output = rc.kill(pid)Created by Kefei Zhou (kefei.zhou at gmail)Licensed under BSD 3-Clause, included as LICENSE in the source distribution.
Package: remotemanager
remotemanagerModular serialisation and management package for handling the running of functions on remote machinesBased off of the BigDFT RemoteRunner concept, remotemanager represents an improvement and expansion on the concepts based there.Primary usage is via aDataset, which connects to a remote machine viaURLYou can think of theDatasetas a "container" of sorts for a calculation, to which "runs" are attached. These runs are then executed on the remote machine described by the providedURLInstallationA quick install of the latest stable release can be done viapip install remotemanagerAlternatively, clone this repo and do a local install viacd remotemanager && pip install .HPCRemotemanager exists to facilitate running on High Performance Compute machines (supercomputers). Script generation is ideally done via theBaseComputermodule.Existing Computers can be found atthis repository. For creating a new machine class, see thedocumentation.DocumentationSee thedocumentationfor further information, tutorials and api documentation.
Package: remote-minerl-env
remote-minerl-envRemote environment for minerl competition environmentsTable of ContentsAboutInstallationWith pip (recommend)From sourceUsageExamplesThird party noticesLicenseAboutThis package allows to run the Minecraft Malmo instance for theminerlcontest
on any host and allows to access it from another host. The Minecraft instance on the selected host system is not closed
to ensure the fastest possible availability. This allows to test the agent code much faster and in case of an error in
the agent code you don't have to restart the Minecraft instance again. The host on which the Minecraft instance runs can
also be identical to that of the agent.In addition, the host on which the Malmo instance is running can be on a completely different network and can be
accessed without port forwarding. For this purpose a reverse proxy is used, which forwards the requests to this host via
an external and publicly accessible server.Installationremote-minerl-envrequires Python 3.6+ to be installed.With pip (recommend)Use the following command to installremote-minerl-envwith pip:pip install remote-minerl-envYou can also very easily update to a newer version:pip install remote-minerl-env -UFrom sourcegit clone https://github.com/infinityofspace/remote_minerl_env.git
cd remote_minerl_env
pip install .UsageAfter the installation, you can start the remote environment with the following command on the desired host on which you
want to run the Minecraft Malmo instance.remote-minerl-envAll available arguments:usage: remote-minerl-env [-e ENV_NAME] [-h HOST] [-p PORT] [--help]

optional arguments:
  -e ENV_NAME, --env-name ENV_NAME
                        ID of the minerl environment.
  -h HOST, --host HOST  Host address to bind to.
  -p PORT, --port PORT  Port to bind to.
  --ngrok NGROK_CONFIG_PATH TUNNEL_NAME
                        Use ngrok reverse proxy to expose the environment publicly
  --help                Show the help of the program.After you have started the remote instance you only need to make minimal adjustments to your existing agent code and
then you are done.You have to usefromremote_minerl_env.environments.clientimportRemoteClientEnvenv=RemoteClientEnv("<name of the env>")instead ofenv=gym.make("<name of the env>")That was all. The RemoteEnv also supports the functionsstep,resetand provides access to the
attributeaction_spaceof the original gym environment as class attribute.Without any additional arguments the instance is only accessible from localhost on port42424To expose the Minecraft instance publicly you can use the--ngrokparameter. This usesngrokto
make your local instance accessible from outside your local network:remote-minerl-env --ngrok /path/to/your/ngrok/config.yml <name-of-the-tunnel-to-use>The tunnel must be a tcp tunnel and the local mapped port should match the port from the instance, which can be
customized with the--portparameter (default port is42424).Third party noticesAll modules used by this project are listed below:NameLicenseminerlLICENSEsetuptoolsMITpyngrokMITFurthermore, this readme file contains embeddings ofShields.iobadges.LicenseMIT- Copyright (c) 2021 Marvin Heptner
Package: remoteobjects
remoteobjects are real subclassable Python objects on which you can build arich API library.remoteobjects provides easy coding and transfer between Python objects and aJSON REST API. You can define the resources in a RESTful API as `RemoteObject`classes and their properties. These objects then support using the basic HTTPverbs to request and submit data to the API.remoteobjects have:* programmable conversion between Python objects and your API's JSON resourceformat* full and correct HTTP support through the `httplib2` library, includingcaching and authentication* delayed evaluation of objects to avoid unnecessary requestsExample=======For example, you can build a simplified Twitter API library in the shell::>>> from remoteobjects import RemoteObject, fields, ListObject>>> class Tweeter(RemoteObject):...     name        = fields.Field()...     screen_name = fields.Field()...     location    = fields.Field()...>>> class Tweet(RemoteObject):...     text    = fields.Field()...     source  = fields.Field()...     tweeter = fields.Object(Tweeter, api_name='user')...>>> class Timeline(ListObject):...     entries = fields.List(fields.Object(Tweet))...>>> tweets = Timeline.get('http://twitter.com/statuses/public_timeline.json')>>> [t.tweeter.screen_name for t in tweets.entries[0:3]]['eddeaux', 'CurtisLilly', '8email8']For web APIs============`remoteobjects` is your Object RESTational Model for web APIs. You can defineeach type of resource as a `RemoteObject` subclass, with all the resource'smember data specified as `remoteobjects.field.Field` instances for lightweighttyping.As provided, `remoteobjects` works with JSON REST APIs. Such an API should bearranged as a series of resources available at URLs as JSON entities(generally objects). The API server should support editing through ``POST``and ``PUT`` requests, and return appropriate HTTP status codes for errors.The remoteobjects module is not *limited* to a particular kind of API. The`RemoteObject` interface is provided in `DataObject`, `HttpObject`, and`PromiseObject` layers you can reuse, extend, and override to tailor objectsto your target API.Dictionaries with methods=========================While you can use an HTTP module and plain JSON coding to convert APIresources into dictionaries, `remoteobjects` gives you real objects withencapsulated behavior instead of processing with external functions. A`RemoteObject` instance's behavior is clearly packaged in your `RemoteObject`subclass, where it is not only enforced through use of the object interfacebut extensible and replaceable through plain old subclassing.
Package: remote-params
pyRemoteParamsPython remote_params package lets you add (remote) GUI controlable parameters to your pyhton application.Installpipinstallremote_paramsRun testspythonsetup.pytestUsageperson1=Params()person1.string('name')person2=Params()person2.string('name')room=Params()room.group(person1)room.group(person2)params_osc_server=create_osc_server(room,port=8082)# orparams_websocket_server=WebsocketServer(Server(room),port=8083)
Package: remote-pdb-client
RemotePDB ClientA client for debugging code instrumented with the RemotePDB packageTheRemotePDB packageis a useful way to remotely debug code (i.e., code running in Docker). Normally, a user can simply wait for theset_trace()command to be executed, then telnet to the appropriate port. However, in applications such as Django, this necessitates manually disconnecting the telnet session before another breakpoint can be processed.With RemotePDB Client, the user can instantiate the client at any time, and it will pend until a debug connection becomes available. Likewise, after a PDBc(ontinue)command the client will disconnect internally and await the next available connection.You can useh(elp)within the debugger to see the usual remote commands.q(uit)/e(xit)will forward the given command and then exit the Client completely.A persistent history is available and is saved for re-use between client sessions.Thecl(ear)breakpoints command is disallowed if it has no arguments (clearing all breakpoints causes the remote process to pend on y/n input).If you are debugging code in a Docker container, remember to expose the internal port externally via yourdocker-composecommand or file (keeping in mind that the internal and external port numbers should be different).There is a limit to what you can debug with this - if you callset_trace()within code running in multiple threads/processes at the same time, only one will be connected to and the rest will pend or fail.To avoid problems withBdbQuitbeing raised by RemotePDB 2.0+ on remote disconnect, before exiting via Ctrl-C,exit, orquit we purposely send a "continue" command.DisclaimerDO NOT use RemotePDB Client to connect to untrusted hosts!
Package: remote-play-3ds
Remote Play 3DSRemote play your modded 3DS.This is one of demo applications ofQingpi, externally controlling system for the Nintendo 3DS.> python -m remote_play_3ds $PORT $INDEXSettingn3DS_viewdot by dot x1no filterOBSOBS-VirtualCamBuilt-in virtual camera behaves a bit buggy.Resize output (source size)Output size will be width: 400px, height: 499px.ja: 出力サイズ変更（ソースサイズ）
Package: remote-plot
Remote PlotDeveloping python code on a remote machine can get frustrating when you want to visualize your results.
Instead of relying on a remote screen / X11 forwarding / VNC, Remote Plot opens your plots in a local server.
It's a super simple library that replicates the API of matplotlib with a web renderer.
All you need to do is forward the port to your machine. If your using VS Code, it will take care of it for you.Getting startedInstallationpip install remote_plotPort forwardingIf you are using VSCode, once you run your first plot, it will automatically forward the port
and pop a dialog box that will let you open the plot in your web browser.If you are using SSH, you can forward the port using he following flag while connecting to the remote machine:ssh YOUR_USER_NAME@YOUR_MACHINE_IP -L 8000:localhost:8000Then, you can just openlocalhost:8000in a web browser once you run your first plot.Your first plotfrom remote_plot import plt

plt.plot([1, 2, 3], [4, 5, 6])A more advanced exampleHere's a more advnaced example taken from (the official matplotlib documentation)[https://matplotlib.org/stable/tutorials/introductory/pyplot.html#working-with-text]from remote_plot import plt
import numpy as np

mu, sigma = 100, 15
x = mu + sigma * np.random.randn(10000)

# the histogram of the data
n, bins, patches = plt.hist(x, 50, density=True, facecolor='g', alpha=0.75)


plt.xlabel('Smarts')
plt.ylabel('Probability')
plt.title('Histogram of IQ')
plt.text(60, .025, r'$\mu=100,\ \sigma=15$')
plt.axis([40, 160, 0, 0.03])
plt.grid(True)
plt.show()Check the (examples directory)[https://github.com/itaicaspi/remote_plot/examples] for more examples.APIRemote plot is intended to act as a drop-in replacement to matplotlib. Because of this, it replicates the matplotlib API, which you can findhere.By default, every call plot will automatically render the result (equivalent to callingplt.show()on matplotlib).
This can make things a bit slow, so if you prefer to turn it off, setplt.auto_show = False, and useplt.show()as usual.It also supports native image displaying that can display numpy array or pillow images.from PIL import Image
img = Image.open("PATH TO YOUR IMAGE")
plt.imshow_native(img)Changing the web server portfrom remote_plot import plt

plt.port = 8001LicenseMIT License. SeeLICENSEfor further details.
Package: remote-postgres
# RemotePostgresRemotePostgres is a way to easily access a remote Postgres database and perform queries, including SELECT and INSERT operationsSee below for examples of how to use```pythonfrom remote_postgres import RemotePostgresimport mysecretsdb = RemotePostgres(f'postgres://{mysecrets.pg_user}:{mysecrets.pg_password}@{mysecrets.pg_host}:{mysecrets.pg_port}/{mysecrets.pg_database}')``````pythondb.get_counts()```[{'tmp_1347844423': 0}, {'Employee': 0}, {'tmp_1170648801': 0}]```pythondb.con.cursor().execute("""CREATE TABLE "Shipper" ("Id" INTEGER, "CompanyName" TEXT, "Phone" TEXT)  """)``````pythonnew_records = [{'Id': 1, 'CompanyName': 'Speedy Express', 'Phone': '(503) 555-9831'},{'Id': 2, 'CompanyName': 'United Package', 'Phone': '(503) 555-3199'},{'Id': 3, 'CompanyName': 'Federal Shipping', 'Phone': '(503) 555-9931'},{'Id': 4, 'CompanyName': 'Speedy Express', 'Phone': '(503) 555-9831'},{'Id': 5, 'CompanyName': 'United Package', 'Phone': '(503) 555-3199'},{'Id': 6, 'CompanyName': 'Federal Shipping', 'Phone': '(503) 555-9931'}]``````pythondb.insert('Shipper', new_records)``````pythondb.select('SELECT * FROM "Shipper"')```[{'Id': 1, 'CompanyName': 'Speedy Express', 'Phone': '(503) 555-9831'},{'Id': 2, 'CompanyName': 'United Package', 'Phone': '(503) 555-3199'},{'Id': 3, 'CompanyName': 'Federal Shipping', 'Phone': '(503) 555-9931'},{'Id': 4, 'CompanyName': 'Speedy Express', 'Phone': '(503) 555-9831'},{'Id': 5, 'CompanyName': 'United Package', 'Phone': '(503) 555-3199'},{'Id': 6, 'CompanyName': 'Federal Shipping', 'Phone': '(503) 555-9931'}]```pythoncur = db.con.cursor()cur.execute("""DELETE FROM "Shipper" WHERE "Id" > 3""")db.con.commit()``````pythondb.generate_create_table('Shipper', new_records)```'CREATE TABLE "Shipper" ("Id" TEXT, "CompanyName" TEXT, "Phone" TEXT)'```pythondb.con.cursor().execute("""DROP TABLE "Shipper" """)db.con.commit()``````pythondel db    # Close the connection```
Package: remotepy
Remote PyRemote Py allows you to write python functions and run it on a server. It also provides you interfaces in multiple languages including JavaScript, CSharp and Python to call the remote python functions.It is a RPC mechanism built on top of Web Sockets allowing you to communicate both ways.Requirements:
Please make sure following packages are installed.
numpy
service_identity
twisted
autobahnInstallation instructions:
pip install numpy
pip install autobahn[twisted]More details coming soon ...
Package: remote-run-everything
remote_run_everthing统一解决各种语言远程调试jet家的什么python，java，clion的c/c++都带remote debug，但是第一要缴费版本，第二rust这种语言，缴费也没有。一种方法是使用gdbserver，这个具体可以google方法原理使用python脚本，在远程环境调用cmd，把结果打印到目前的ide，调用的时候运行python脚本就可以，如果配合虚拟机共享文件夹使用，那么就不需要上传下载文件。可能有人会问，为什么下载文件，这个主要是为了ide代码智能补全。以运行rust代码为例pip install remote_run_everythingremote_run_everythin github 地址fromremote_run_everythingimportConf,Local,Remotedeftest():c=Conf(host="192.168.177.130",user="root",pwd="a",remote_root="/mnt/myrust/ssl",local_root="D://myrust/ssl",)l=Local(c)# step1:代码文件同步：这个命令会把local_root下的子文件夹递归复制到remote_root对应的子文件夹,虚拟机共享文件夹不需要本步骤l.upload(c.local_root+"/src",exclude="node_modules")#orl.upload(c.local_root+"/src",exclude=["node_modules"])#orl.upload(c.local_root+"/src")# step2: 命令行：这个命令会在远程环境remot_root文件夹中执行cargo run，并把输出结果打印在屏幕。多个命令以列表形式传递# r.cmd(['cargo run'])# step3：代码智能补全文件下载： 这个命令会把remote_root的子文件夹复制到local_root对应子文件夹,虚拟机共享文件夹不需要本步骤，这一步的意义在于ide智能补全（编译代码在虚拟机，本地没有）。实际中，执行此步骤需要根据语言变更子文件夹,以rust为例，复制target即可l.download(c.remote_root+"/target")test()运维功能此外，__scripts__文件夹下含有python运维管理脚本，运行就会把__scripts__下所有运维脚本上传到远程根目录，然后运行相应的cmd命令即可。目前的脚本主要是杀进程的，根据关键字杀进程，根据端口号杀进程，未来会不断拓展。详细参见__scripts__目录脚本写法.c = Conf(
    host="192.168.177.130",
    user="root",
    pwd="a",
    remote_root="/mnt/myrust/ssl",
    local_root="D://myrust/ssl",
)
l = Local(c)
r = Remote(c)
#把__scripts__下所有运维脚本上传到远程根目录
l.upload_scripts()杀进程# 杀掉端口号8088的所有进程（gunicorn针对一个端口多个进程，全杀）
r.cmd(['cd __scripts__', 'python kill_ss.py 8088'])

# 杀掉包含关键词的所有进程（gunicorn多个进程，全杀）
r.cmd(['cd __scripts__','python kill_ps.py keyword1 keyword2'])芒果db备份恢复# 将mongodb数据库1,2下所有数据备份到远程根目录mongoback目录下，数据库名称是子目录名称
r.cmd(['source /home/anaconda3/bin/activate server',
      'python ./__scripts__/mongo_dump_restore.py dump mongodb://localhost:27017 mpy ruihe'
      ])

# 将备份文件拉回本地
l.download(c.remote_root+"/mongo_backup")

# 将mongodb数据库1,2下所有数据恢复
r.cmd(['source /home/anaconda3/bin/activate server','python ./__scripts__/mongo_dump_restore.py restore mongodb://localhost:27017 db1 db2'])gunicorn 重启serverstart=['source /home/anaconda3/bin/activate server',"gunicorn riskMis:app -w 4 -k uvicorn.workers.UvicornWorker -b 0.0.0.0:8887 --daemon"]
r.cmd(start)
Package: remotesense-learn
遥感影像机器学习工具包安装可以使用pip进行安装：pip install remotesense-learn本程序依赖的包有scikit-learn、numpy、rasterio等。使用读取数据fromrslearnimportImageFrameimg=ImageFrame.read("example_data/bhtmref.img")保存栅格文件聚类分析监督分类数据处理数据标准化图像滤波可视化波段预览波段直方图