Saravanan666/pypi-org huggingface dataset:
Package: run-in-gui
Run in GUI (run-in-gui)============================| Donate to support this free software ||:------------------------------------:|| <img width="164" height="164" title="" alt="" src="doc/bitcoin.png" /> || [1DmVQkuY1zjP6ZiPi1QJgSowHtR8afBDMS](bitcoin:1DmVQkuY1zjP6ZiPi1QJgSowHtR8afBDMS) |This project contains two programs that assist you in executing programsin a separate desktop session (defined by the environment variables of anyprogram executing in that session), and then switching to the session inreal-time as the program executes.  It's useful to start GUI programs fromcron that need a graphical display and/or audio access.Why is this useful?  Because of the way that Linux has evolved, nowadaysit's very hard to get certain computer programs to do things that weretrivial in the past.  For example: getting your music player to play a listof songs to wake you up -- unless you're running the program straight fromthe GUI, it won't actually work; either the program just won't run, or theaudio will be corked.Caveat: this program still requires you to be logged in.Tools included in this set--------------------------This package contains several tools:1. `run-in-env-of`: a tool that runs the command of your choice in theenvironment of the PID of your choice.  If run as root, it can`setuid()` to the user and group of that PID.2. `run-in-gui`: a tool that sorts out a desktop session you're runningthen uses run-in-env-of to execute the command on your choice underthat desktop session.  Prior to the execution of that program, itswitches to the selected desktop session, to enable hardware accessto devices that would otherwise be blocked (e.g. audio).What you need to have before using this package-----------------------------------------------* Python 2.7 on your local machine* `loginctl` fully operational* `/proc` mountedInstallation------------You will need to install this package on your local machine.You can install this package directly from PyPI using pip::pip install run-in-guiIf you are on an RPM-based distribution, build an RPM from the source packageand install the resulting RPM::python setup.py bdist_rpmOtherwise, just use the standard Python installation system::python setup.py installYou can also run it directly from the unpacked source directory::export PYTHONPATH="$PWD"/src./<program> <parameters>Usage-----Say, for example, you want to run Amarok from a crontab, but you want Amarokto start on your logged-in desktop session.  No problem: you can stick thisinto your crontab:20 4 * * * /usr/local/run-in-gui/bin/run-in-gui amarok -p Toke\ up.m3uAs you can see, at exactly 4:20 AM, Amarok will be executed in your desktopsession, and will start playing the playlist `Toke up.m3u` in your homedirectory.You can also do the exact same thing from an `at` job:echo /path/to/run-in-gui amarok -p Matanga.m3u | at 5:45If, for some reason, the program won't start, check your mail folder in`/var/mail/$USERNAME`, where cron traditionally deposits crontab output.
Package: run-in-subdirectory
run-in-subdirectoryA command-line utility for running commands in a subdirectory (e.g., linters on a monorepo) with a set ofpre-commithooksUsagepre-commitUserun-in-subdirectoryhook to run command in a subdirectory passed as the first argument:repos:-repo:https://github.com/egormkn/run-in-subdirectoryrev:mainhooks:-id:run-in-subdirectoryalias:prettiername:Format code with Prettierargs:["client","npx--no--prettier-w-u"]types:[text]files:^client/Use one ofrun-in-...-level-subdirectoryhooks to automatically extractfirst,secondorthird-level subdirectory from the file path passed as the last positional argument.Note that you should setfiles,typesandexcludeproperties so that the hook only runs for files in that subdirectory.repos:-repo:https://github.com/egormkn/run-in-subdirectoryrev:mainhooks:-id:run-in-first-level-subdirectoryalias:prettiername:Format code with Prettierargs:["npx--no--prettier-w-u"]types:[text]files:^client/command-linerun-in-subdirectorycan also be used as a command-line utility:pipinstallrun-in-subdirectoryusage: run-in-subdirectory [-h] [-v] (-l LEVEL | -d DIRECTORY) executable [args ...]

Runs the command in a subdirectory and fixes paths in arguments.

positional arguments:
  executable            Executable to run
  args                  Sequence of program arguments

options:
  -h, --help            show this help message and exit
  -v, --verbose         Print information about a command to be called
  -l LEVEL, --level LEVEL
                        Subdirectory level (0 for top-level directory)
  -d DIRECTORY, --directory DIRECTORY
                        Subdirectory within which the subprocess will be executed

example:
  When this program is executed with the following command:
    run-in-subdirectory -d client/ npx --no eslint client/src/index.ts
  Then the command will be executed:
    npx --no eslint src/index.ts
  and the current working directory will be set to client/
Package: runish
A Unicode name finder and characters explainer.Simple to use:$ runish umbrella
☂  UMBRELLA
☔ UMBRELLA WITH RAIN DROPS
⛱  UMBRELLA ON GROUND
🌂 CLOSED UMBRELLA
🏖 BEACH WITH UMBRELLA

$ runish ☂
UMBRELLAIn that simple use case it tries to guess what are you asking for (one letter -> explain; more -> find).You can also be explicit passing-e/--explainor-f/--findto select the behaviour mode:$ runish -e bœuf
b  LATIN SMALL LETTER B
œ  LATIN SMALL LIGATURE OE
u  LATIN SMALL LETTER U
f  LATIN SMALL LETTER F
Package: runit-cli
Runit CLIThe Runit Command Line Interface (CLI) Tools can be used to test, manage, and deploy your Runit project from the command line.Create new runit projectRun a local web server for your runit projectpublish code and assets to your runit-server domainInteract with data in your runit-server databaseSupported LanguagesInstallationPython PackageYou can install the Runit CLI using pip (Python package manager). Note that you will need to installPython.
To download and install the runit CLI run the following command:pipinstallrunitThis will provide you with the globally accessiblerunitcommand.Install from sourcegitclonehttps://github.com/theonlyamos/runit.gitcdrunit
pipinstall.UsageRun the below command to print out usage message.runit--helpCreate New ProjectRun the following in the command line to create a new runit project.Supported languages include:Python,Javascript,PHPrunitnew<project-name>--language<langugage>Runrunit new --helpfor all optionsRun project locallyAccess functions on local server*
Running the commandrunitin a project directory spins up a local webserver which can be used to access the funtions in project.cd<project-directory>
runitPoint your browser to the address provided followed by the function name to access that function.http://localhost:5000/will be the default address.
Visitinghttp://localhost:5000/hello_worldwill run thehello_worldfunction in the project.Run function and print output to shellOutput function result to shell. Required arguments include:--function <function_name>: Function name to call--shell: sets shell output to true
[Optional]--arguments|-x: Arguments for the function if required. Can be called multiple times for multiple argumentscd<project-directory>
runit--function<hello_world>--shellPublishing ProjectBefore you can publish any of your projects, you must setup the backend for your runit. You must also be logged in.Setup Backend DetailsThe backend must be runningrunit-server.
Runrunit setup --helpfor help message.Follow the prompts to complete the setup after running the below comman.runitsetupAccount Loginrunitlogin--helprunitlogin--email<email@example.org>--password<supersecretpass>orFollow the commands after running below commandrunitloginDeploy/Publish Projectcd<project-directory>
runitpublishLicenseFree Software, Hell Yeah!
Package: runit-server
runit-server-ServerThe runit-server Command Line Interface (CLI) Tools can be used to test, manage, and deploy your runit-server project from the command line.Create new runit-server projectRun a local web server for your runit-server projectpublish code and assets to your runit-server-server domainInteract with data in your runit-server-server databaseSupported LanguagesInstallationPython PackageYou can install the runit-server package using pip (Python package manager). Note that you will need to installPython.
To download and install the Runit-Server package run the following command:pipinstallrunit-serverThis will provide you with the globally accessiblerunit-servercommand.Install from sourcegitclonehttps://github.com/theonlyamos/runit-server.gitcdrunit-server
pipinstall.UsageRun the below command to print out usage message.runit-server--helpSetup ServerRunrunit-server setup --helpfor help message.Follow the prompts to complete the setup after running the below command.runit-serversetupRun ServerRun the command below to start the webserverrunit-serverLicenseFree Software, Hell Yeah!
Package: runium
RuniumRunium is a Python library that makes it easy to write non-blocking,
asynchronous tasks.You can add new tasks as you please, choose when and how to execute them asThreadsorProcessesand attach callbacks to be executed as soon as the
task is finished running. Run those tasks once or periodically or schedule to
run them at a specific time.The purpose of Runium is to do these simple, easy and clean with minimum to
no changes to your code. Just one line of code is all it takes.Documentationhttps://runium.readthedocs.io/en/latest/main.htmlPypi:https://pypi.org/project/runium/FeaturesConcurrency: Run a task once or many times in its own Thread or Process.Repetition: Run tasks periodically on even time intervals. Optionally for a certain amount of times.Scheduling: Run tasks at a certain date and time.Callbacks: Runium tasks can accept callback functions which are executed when the task is finished running.Simplicity and Readability: Do all the above in a single line of code that is easy to read.InstallationRunium is distributed on PyPI. The best way to install it is with pip:$pipinstallruniumQuickstartfromrunium.coreimportRunium# Initialize Runiumrn=Runium()# Or you may want to run your tasks in Processesrn=Runium(mode='multiprocessing')# Create a taskasync_task=rn.new_task(task)# Attach callbacks (Check the documentation for callbacks)async_task.on_finished(callback)# or you can be more flexible...async_task.on_success(s_callback).on_error(e_callback)# Run it. This will return a future object.future=async_task.run()# Or if you want to run it multiple timesfuture=async_task.run(times=3)# Or maybe run it 3 times every 1 hourfuture=async_task.run(every='1 hour',times=3)# Or tell Runium to start the task in a specific timefuture=async_task.run(start_in='5 hours')# Then you can wait for the result.future.result()# Of course you can do all these in one line :)rn.new_task(task).run(every='1 second',times=3).result()
Package: runjenkins
runjenkinsSimple tool for running a list of jenkins jobsTool for running jenkins jobs from cli, based on yaml configs. The ideas
is that you have a single creds file, then put a config file in each
repo/workspace. Then add it to your commit
hook/alias/function/script/whatever so that you can run jobs on commit.I know the obvious way to run jobs on commit is to open a PR, and use
branch source or GHPRB. However when developing JJB jobs, I often want
to run a job that runs JJB, then the job that was created, and possibly
some other test jobs. This tool lets me automate that.Example Creds File:---
 url:  https://myjenkins.example.com/
 user: foo
 password: bahExample Conf File:---
- myjob:
    myparamkey: myparamvalue
- mynextjob:
    parama: 1
    paramb: false
- parallel group: # <-- name arbitrary, parallel detected by val=list
                        rather than dict
  - myparalleljob:
      param: val
  - otherparalleljob:
      param: val
Package: run-js
run-jsGoal: The Easiest Way to Run JavaScript in PythonfeaturesStatelessAsync JS FunctionsNo Intermediary FilesFunctional ProgrammingCommonJS and ES6 ModulesAutomatic JSON ConversionClear Installation Promptsinstallpipinstallrun-jsusage# import the package from JavaScript into Pythonfromjsimportlodash# access a function as an attributeresult=lodash.uniq([1,2,2,3,3,3])# result is [1, 2, 3]Frequently Asked Questionswhat if my JavaScript package has a dash in the name?Python doesn't allow-in import statements, sojsis also a dictionary.importjsfastMin=js['fast-min']result=fastMin([1,2,2,3,3,3])//resultis1do I need to understand JavaScript packaging?If you try to run a JavaScript package and it isn't installed, run-js will automatically
provide you a prompt to install it.  You don't have to learn NPM'spackage.json format.do I need to install NodeJS?Yes, you currently must install NodeJS on your system before using run-js.  The NPM CLI is also required, but usually comes with the NodeJS installation.  If you are using MacOS, you can install it withbrew install node.  We will try to add friendly prompts to install NodeJS in the future.  (It's a little complicated because of all the different platforms to support.)limitationsonly json-serializable inputrun-js currently only supports running functions that accept JSON-serializable input.
In other words, you can only call a function that accepts numbers, string, arrays, and simple objects.
You can't pass functions or sets as a parameter. (We may try to fix this in the future, but only if it can be done securely.)statelessFor security reasons, run-js doesn't keep a JavaScript process running in the background.  Therefore,
you can't chain JavaScript function calls.more examplesimportjs# calculate statisticsjs['calc-stats']([291,1723,74,741,93,84,19]){"min":1,"max":100,"mean":66.25,"median":70,"mode":95,"modes":[90,100],"sum":328350,"histogram":{...}}# run-length decodingjs['fast-rle/decode']([5,3,1,8,2,0])[3,3,3,3,3,8,0,0]# reprojecting geospatial bounding boxesjs["reproject-bbox"]({"bbox":[-122.51,40.97,-122.34,41.11],"from":4326,"to":3857})[-13637750.817083945,5007917.677222896,-13618826.503649088,5028580.202823918]# clipping hyperrectangle (multi-dimensional rectangle) from imagery datajs['xdim'].clip({"data":[0,123,123,255,...],"layout":"[row,column,band]","sizes":{"band":4,"row":768,"column":1024},"rect":{"band":[2,2],"row":[20,219],"column":[47,211]}})[213,542,521,481,...]necessary disclaimerUse at your own risk.thanksThis project was partially inspired by the awesome Python package calledsh.supportEmail the library author atdaniel.j.dufour@gmail.comor post an issue athttps://github.com/DanielJDufour/run-js/issues
Package: run-lambda
run_lambdais a Python package for running PythonAWS Lambdafunctions locally. It offers a
Python module for automated testing of Lambda functions, as well as a
command-line interface for ad-hoc local invocations.Doesn’t something like this already exist?Not exactly. There are other programs for locally running Python Lambda
functions. However, all of the other utilities (that I know of) only provide
a command-line tool. A command-line tool is great for quick manual invocations.
However, if you want to create robust, automated tests for your Lambda functions,
a Python module that you can import and call is more appropriate.run_lambdais unique because it offers both a simple command-line tool for
manual invocations, and an importable Python module for automated tests.Featuresrun_lambdasupportsAn interface for examining the result (return value, exception, timeout) of
a function callA full implementation of AWS Context objectsFunction calls with or without a timeoutResource usage profiling (memory and run-time)Convenient mocking of objects and services inside Lambda functionsInstallationThe easiest way to install is viapip:$ pip install run_lambdaYou can also download the source fromGithub.DocumentationDocumentation for the package can be found onRead the Docs.
Package: runlog
# RunlogManagable detaied per-run logs for recurring jobs."Why did X happen the last time the Foo job ran for user Bar?""Job Y blew up when it ran yesterday. Where and why did it fail?"Runlog provides a Python standard library logging-based, Redis-backedway to store and access logs for the last N interesting runs of a job.It's very simple to add detailed logging to code that runs insideyour recurring jobs without cluttering up your normal log files withnoisy, interleaving output.It is very easy to add this logging to your code. An unambitious,CLI allows you to list jobs, list previous and ongoing runs and to outputtheir logs. (Pipe them to your favorite unix utilities and enjoy.)## Logging a JobJob logging is done with normal log calls and a job-logging contextmanager.```pythonimport loggingfrom runlog import RunLoggerrl = RunLogger(redis_config={'host': 'localhost'},max_logs=10)rl.debug("You will never see this.")with rl.runlog('recurring-job-32') as logger:logger.setLevel(logging.DEBUG)rl.debug("You will see this in the log of a run of this job.")rl.error("You don't see this either.")```Caveat: you will actually see all log messages if you add handlersto the root logger. But if that is the case you are drinking fromthe firehose and it's probably what you want to happen anyway.## Finding The OutputAssuming you have a `.runlog.conf` that looks like this```ini[runlog]max-logs: 10[runlog-redis]host: localhost```... you can find the logs for your job like this:```bash$ runlog list-jobsrecurring-job-32$ runlog list-runs recurring-job-32recurring-job-32 2014-04-16-04:35:23.562999recurring-job-32 2014-04-15-04:33:11.463847...$ runlog logs recurring-job-32 2014-04-15-04:33:11.463847 2014-04-16-04:35:23.562999[ ... LOGS OF THE TWO RUNS SPECIFIED ... ]```Coming soon: range queries over log messages.## Handling ErrorsIf something blows up inside the job-loggging context manager,the traceback will be added to the log for the current run andthe exception will be re-raise. Errors will not be swallowed.## Throwing Away Boring LogsIf your job turns out of be a no-op or is in some other way boringto you, you can raise a `CancelLog` and just forget the whole thing.```with rl.runlog('job-127') as logger:things_processed = run_job(127)if things_processed == []:raise CancelLog()  # This run is forgotten.```CancelLog will be swallowed, but only _inside_ the context manager.## Managing DataSet up a dedicated Redis instance. Cap the memory. Throw away logsthat are not interesting. Look at data growth and adjust `max_logs`or be more picky about which jobs you log. Archive really interestingthings and/or some random samples into some kind of cold storage.
Package: runm
RunM is an opinionated version ofsubprocess, making it just that little
bit more convenient to run shell commands from within Python code.It is reasonably straightforward:` import runmrunm.run("echoit works") #=> returns 'it works\n'runm.run("echo1 2 5 |cat") #=> returns '1 2 5\n' `When a command that fails is run e.g.`runm.run("cat/not_a_file") `an exception is raised just likesubprocess. However, the error message
generated includes STDERR and STDOUT, which is more convenient for debugging.Installationcommandeer can be installed by unzipping the source code in one directory and using this command:sudo python setup.py installYou can also install it directly from the Python Package Index with this command:sudo pip install runmLicenceSee file LICENCE.txt in this folderContributeRunM is an open-source software. Everyone is welcome to contribute !
Package: runman
Run ManagerMange runs (mostly of stochastic simulations)FeaturesRegister a world, functions to be called on each timestep, and functions that perform loggingQuick Startimportrunmancounter=[]defstep(timestep):counter.append(timestep)deflog():print(counter[-1])returncounter[-1]run=runman.Run(assets=[counter,],stepfns=[step,],logfns=[log,],loginterval=2)run.run(10)InstallationClone and install orpip install git+https://github.com/AllenCellModeling/runman.gitDocumentationFor full package documentation please visitAllenCellModeling.github.io/runman.Available under the Allen Institute Software License
Package: runmanager
thelabscript suite» runmanagerGraphical and remote interface to parameterized experimentsrunmanageris an intuitive graphical interface for controllinglabscript suiteexperiments.Experiment parameters are defined and modified in runmanager and referenced in the labscript experiment logic (Python scripts). runmanager provides a potent framework for parameter space exploration; parameters can be raw Python expressions, with multiple iterable parameters scanned over via an outer product and/or in unison.runmanager can be run on any host with network access to the hardware supervisorblacs, and includes a remote programming interface for automation.Installationrunmanager is distributed as a Python package onPyPIandAnaconda Cloud, and should be installed with other components of thelabscript suite. Please see theinstallation guidefor details.
Package: run-matlab
run_matlabCommand Line MATLAB Function Caller with Automatic MATLAB Compiler Runtime (MCR) InstallationInstallationpip3installrun_matlabUsagerun_matlab<command>[options]Commands:installInstallationoftheMATLABcompilerruntime(MCR)runRunningtheMATLABfunctionafterinstallation
Runrun_matlab<command>-hforhelponaspecificcommand.

run_matlab:CommandLineMATLABFunctionCallerwithAutomaticMATLABCompiler
Runtime(MCR)Installation

positionalarguments:commandSubcommandtorun

optionalarguments:-h,--helpshowthishelpmessageandexit--versionshowprogram'sversionnumberandexitInitialization of MATLAB Compiler Runtime (MCR)run_matlabinstall[-h][-dINSTALLATION_DIR][-vMATLAB_VERSION][-rRUNTIME_VERSION]InstallationoftheMATLABcompilerruntime(MCR)optionalarguments:-h,--helpshowthishelpmessageandexit-dINSTALLATION_DIRDirectorywhereintheMATLABcompilerruntime(MCR)willbeinstalled.(default:$HOME/run_matlab)-vMATLAB_VERSIONMATLABversion.(default:R2013b)-rRUNTIME_VERSIONMATLABCompilerRuntimeversion.(default:8.2)MATLAB_VERSIONRUNTIME_VERSIONR2013b8.2R2014a8.3R2014b8.4R2015a8.5R2015b9.0R2016b9.1R2017a9.2R2017b9.3R2018a9.4R2018b9.5R2019a9.6R2019b9.7R2020a9.8R2020b9.9Execution of MATLAB Functionsrun_matlabrun[-h][-dINSTALLATION_DIR][-vMATLAB_VERSION][-rRUNTIME_VERSION]function_dirfunction_name[function_args[function_args...]]RunningtheMATLABfunctionafterinstallation

positionalarguments:function_dirDirectorywhereinthestandaloneMATLABfunctionislocated.function_nameNameofthestandaloneMATLABfunction.function_argsArgumentsforthestandaloneMATLABfunction.(default:None)optionalarguments:-h,--helpshowthishelpmessageandexit-dINSTALLATION_DIRDirectorywhereintheMATLABcompilerruntime(MCR)wasinstalled.(default:$HOME/run_matlab)-vMATLAB_VERSIONMATLABversion.(default:R2013b)-rRUNTIME_VERSIONMATLABCompilerRuntimeversion.(default:8.2)
Package: runmetal
runmetal: call Apple Metal Framework from Python (or YAML-recipe)numpy array -> GPU buffer -> compute -> copy result into numpy arrayrequirementsmacOSXcode (or CommandLineTools)Metal FrameworkPython 3.xinstall(python)brew install pyenvpyenv install 3.7.1(venv)python -m venv ../bin/pip install -r requirements.txt./bin/python setup.py install./bin/runmetal run example/xxx.yamlexamples(YAML)picalculate π by monte carlonumpy.random.random()-> copy numpy to GPU buffer-> compute sqrt(xx+yy) < 1.0-> copy GPU buffer to numpy bool8 arraynumpy.sum(result == True)/len(result)*4runmetal run example/pi.yamlrandrandom number generator (LCG)examples(python)TBD