o Ph@sdZddlZddlZddlZddlZddlZddlZdZdddde dej e dej d ej d ej e e dejd ej ffd ej d ejej fddZd!dej e d ej d eje fddZde de d ejd ej ffddZdZeddZeddZeddZeddZejeedd dS)"uB 🏃 runs: a better subprocess 🏃 --------------------------------------------------------------------- `runs` has improved versions of `call()`, `check_call()`, `check_output()`, and `run()` from Python's `subprocess` module that handle multiple commands and blocks of text, fix some defects, and add some features. import runs runs(''' ls df -k # or perhaps -h? echo 'Done and done' ''') --- `subprocess` is essential but: * You can only run one command at a time * Commands to subprocess must be either a sequence of strings or a string, depending on whether `shell=True` or not * Results are returned by default as bytes and not strings --- The `runs` functions let you run a block of text as a sequence of subprocess calls. `runs` provides call-compatible replacements for the functions `subprocess.call()`, `subprocess.check_call()`, `subprocess.check_output()`, and `subprocess.run()` Each replacement function takes a block of text, which is split into individual command lines, or a list of commands, and returns a list of values, one for each command. A block of text can contain line continuations, and comments, which are ignored. The replacement functions also add optional logging, error handling, and lazy evaluation, and use UTF-8 encoding by default. The module `runs` is callable - `runs()` is a synonym for `runs.run()`. EXAMPLES: # `runs()` or `runs.run()` writes to stdout and stderr just as if you'd run # the commands from the terminal import runs runs('echo "hello, world!"') # prints hello, world! # runs.check_output() returns a list, one string result for each command results = check_output(''' echo line one # Here's line one. echo 'line " two "' # and two! ''') assert results == ['line one', 'line " two "'] # Line continuations work too, either single or double runs(''' ls -cail # One command that takes many lines. g++ -DDEBUG -O0 -g -std=c++17 -pthread -I ./include -lm -lstdc++ \ -Wall -Wextra -Wno-strict-aliasing -Wpedantic \\ -MMD -MP -MF -c src/tests.cpp -o build/./src/tests.cpp.o echo DONE ''') NOTES: Exactly like `subprocess`, `runs` differs from the shell in a few ways, so you can't just paste your shell scripts in: * Redirection doesn't work. result = runs.check_output('echo foo > bar.txt') assert result == ['foo > bar.txt\n'] * Pipes don't work. result = runs.check_output('echo foo | wc') assert result == ['foo | wc \n'] * Environment variables are not expanded in command lines result = runs.check_output('echo $FOO', env={'FOO': 'bah!'}) assert result == ['$FOO\n'] Environment variables are exported to the subprocess, absolutely, but no environment variable expension happens on command lines. N)call check_call check_outputrunsplit_commandsF) on_exceptionechonamecommandsargsrr.kwargsreturnc os|durd}|dkr t}|rt|stt|}|dur!dd}t|s.tjt|tjd}tt|}|d}t ||D]6}t j |dd} |rRd d d | D} z || g|Ri|} Wnt yo|si||Yq=w| Vq=dS) NT$cWsdSN)xrrH/var/www/html/env_mimamsha/lib/python3.10/site-packages/runs/__init__.pysz_run..)fileshellcomments css|]}t|VqdSr)shlexquote).0crrr sz_run..)printcallable functoolspartialsysstderrgetattr subprocessgetrrsplitjoin Exception) r r rrr r functionrlinecmdresultrrr_runts4      r/linesc#sgdtjtffdd }t|tr|}|D]>}|o!|||drMdtj|dddd}| d | d krCt d  |ddq ||EdHq|EdHdS) Nr c3s*d}|r|VdSdS)Nr)r)stripclear)partswaitingrremits  zsplit_commands..emit\rTr#z+Comments cannot contain a line continuation) tIteratorstr isinstance splitlinesendswithr)rr(count ValueErrorappend)r0rr6r, no_commentsrr4rrs     rsummarycs|ddddddddtjtdtjdtdtdtjd td td td tjd tjtjttfffdd}|_tj |d|_ |S)NFutf8)iterateencodingrrmerge always_listr r rFrGrrrHrIr r c sf|j|||d|r|jtjdt|g|Ri|} |r!| St| } |s-t| dkr/| S| dS)N)rrGr)r$r)updater&STDOUTr/listlen) r rFrGrrrHrIr r itr.r rrwrappeds z_wrap..wrapped)r+rD) r:Sequencer<AnyboolUnionIterable__name___ARGSformat__doc__)r rDrQrrPr_wraps<  r[a {summary} See the help for `subprocess.{function}()` for more information. Arguments: commands: A string, which gets split into lines on line endings, or a list of strings. args: Positional arguments to `subprocess.{function}()` (but prefer keyword arguments!) on_exception: If `on_exception` is `False`, the default, exceptions from `subprocess.{function}()` are raised as usual. If `on_exception` is True, they are ignored. If `on_exception` is a callable, the line that caused the exception is passed to it. If `on_exception` is a string, the line causing the exception is printed, prefixed with that string. echo: If `echo` is `False`, the default, then commands are silently executed. If `echo` is `True`, commands are printed prefixed with `$` If `echo` is a string, commands are printed prefixed with that string If `echo` is callable, then each command is passed to it. merge: If True, stderr is set to be subprocess.STDOUT always_list: If True, the result is always a list. If False, the result is a list, unless the input is of length 1, when the first element is returned. iterate: If `iterate` is `False`, the default, then a list of results is returned. Otherwise an iterator of results which is returned, allowing for lazy evaluation. encoding: Like the argument to `subprocess.{function}()`, except the default is `'utf8'` kwargs: Named arguments passed on to `subprocess.{function}()` rznCall `subprocess.call()` on each command. Return a list of integer returncodes, one for each command executed.rzCall `subprocess.check_call()` on each command. If any command has a non-zero returncode, raise `subprocess.CallProcessError`. rzCall `subprocess.check_output()` on each command. If a command has a non-zero exit code, raise a `subprocess.CallProcessError`. Otherwise, return the results as a list of strings, one for each command.rzbCall `subprocess.run()` on each command. Return a list of `subprocess.CompletedProcess` instances.T)mutabler)rZr!rr&r#typingr:xmod__all__r<rRrSrUrTCallabler;r/rr[rXrrrrrWrrrrsZh  &+"6