| | |
- __builtin__.object
-
- subprocess.Popen
- subprocess2.simple.Simple
- exceptions.Exception(exceptions.BaseException)
-
- subprocess.CalledProcessError
- subprocess2.simple.SimpleCommandFailure
class Popen(__builtin__.object) |
| | |
Methods defined here:
- __del__(self, _maxint=2147483647)
- __init__(self, args, bufsize=0, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=False, shell=False, cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0)
- Create new Popen instance.
- communicate(self, input=None)
- Interact with process: Send data to stdin. Read data from
stdout and stderr, until end-of-file is reached. Wait for
process to terminate. The optional input argument should be a
string to be sent to the child process, or None, if no data
should be sent to the child.
communicate() returns a tuple (stdout, stderr).
- kill(self)
- Kill the process with SIGKILL
- pipe_cloexec(self)
- Create a pipe with FDs set CLOEXEC.
- poll(self)
- runInBackground(self, pollInterval=0.1, encoding=False)
- runInBackground - Create a background thread which will manage this process, automatically read from streams, and perform any cleanups
The object returned is a "BackgroundTaskInfo" object, and represents the state of the process. It is updated automatically as the program runs,
and if stdout or stderr are streams, they are automatically read from and populated into this object.
@see BackgroundTaskInfo for more info or https://htmlpreview.github.io/?https://raw.githubusercontent.com/kata198/python-subprocess2/master/doc/subprocess2.BackgroundTask.html
@param pollInterval - Amount of idle time between polling
@param encoding - Default False. If provided, data will be decoded using the value of this field as the codec name (e.x. "utf-8"). Otherwise, data will be stored as bytes.
- send_signal(self, sig)
- Send a signal to the process
- terminate(self)
- Terminate the process with SIGTERM
- wait(self)
- Wait for child process to terminate. Returns returncode
attribute.
- waitOrTerminate(self, timeoutSeconds, pollInterval=0.05, terminateToKillSeconds=1.5)
- waitOrTerminate - Wait up to a certain number of seconds for the process to end.
If the process is running after the timeout has been exceeded, a SIGTERM will be sent.
Optionally, an additional SIGKILL can be sent after some configurable interval. See #terminateToKillSeconds doc below
@param timeoutSeconds <float> - Number of seconds to wait
@param pollInterval <float> (default .05)- Number of seconds between each poll
@param terminateToKillSeconds <float/None> (default 1.5) - If application does not end before #timeoutSeconds , terminate() will be called.
* If this is set to None, an additional #pollInterval sleep will occur after calling .terminate, to allow the application to cleanup. returnCode will be return of app if finished, or None if did not complete.
* If this is set to 0, no terminate signal will be sent, but directly to kill. Because the application cannot trap this, returnCode will be None.
* If this is set to > 0, that number of seconds maximum will be given between .terminate and .kill. If the application does not terminate before KILL, returnCode will be None.
Windows Note -- On windows SIGTERM and SIGKILL are the same thing.
@return dict { 'returnCode' : <int or None> , 'actionTaken' : <int mask of SUBPROCESS2_PROCESS_*> }
Returns a dict representing results:
"returnCode" matches return of application, or None per #terminateToKillSeconds doc above.
"actionTaken" is a mask of the SUBPROCESS2_PROCESS_* variables. If app completed normally, it will be SUBPROCESS2_PROCESS_COMPLETED, otherwise some mask of SUBPROCESS2_PROCESS_TERMINATED and/or SUBPROCESS2_PROCESS_KILLED
- waitUpTo(self, timeoutSeconds, pollInterval=0.05)
- Popen.waitUpTo - Wait up to a certain number of seconds for the process to end.
@param timeoutSeconds <float> - Number of seconds to wait
@param pollInterval <float> (default .05) - Number of seconds in between each poll
@return - Returncode of application, or None if did not terminate.
Data descriptors defined here:
- __dict__
- dictionary for instance variables (if defined)
- __weakref__
- list of weak references to the object (if defined)
|
class Simple(__builtin__.object) |
| |
Simple - Simple and quick commands to run a subprocess and get the results.
Static Methods:
runGetOutput - Simply runs a command and returns the program's output. Optionally raises SimpleCommandFailure on failure. @see #runGetOutput for more details.
runGetResults - Runs a command and based on paramaters returns a dict containing: returnCode, stdout, stderr. @see #runGetResults for more details.
|
| |
Static methods defined here:
- runGetOutput(cmd, raiseOnFailure=False, encoding='ascii')
- runGetOutput - Simply runs a command and returns the output as a string. Use #runGetResults if you need something more complex.
@param cmd <str/list> - String of command and arguments, or list of command and arguments
If cmd is a string, the command will be executed as if ran exactly as written in a shell. This mode supports shell-isms like '&&' and '|'
If cmd is a list, the first element will be the executable, and further elements are arguments that will be passed to that executable.
@param raiseOnFailure <True/False> - Default False, if True a non-zero return from the command (failure) will raise a SimpleCommandFailure, which contains all gathered output and return code. @see #SimpleCommandFailure
@param encoding <None/str> - Default sys.getdefaultencoding(), the program's output will automatically be decoded using the provided codec (e.x. "utf-8" or "ascii").
If None or False-ish, data will not be decoded (i.e. in python3 will be "bytes" type)
If unsure, leave this as it's default value, or provide "utf-8"
@return <str> - String of data output by the executed program. This combines stdout and stderr into one string. If you need them separate, use #runGetResults
@raises SimpleCommandFailure -
* If command cannot be executed (like program not found, insufficient permissions, etc)
* If #raiseOnFailure is set to True, and the program returns non-zero
- runGetResults(cmd, stdout=True, stderr=True, encoding='ascii')
- runGetResults - Simple method to run a command and return the results of the execution as a dict.
@param cmd <str/list> - String of command and arguments, or list of command and arguments
If cmd is a string, the command will be executed as if ran exactly as written in a shell. This mode supports shell-isms like '&&' and '|'
If cmd is a list, the first element will be the executable, and further elements are arguments that will be passed to that executable.
@param stdout <True/False> - Default True, Whether to gather and include program's stdout data in results.
If False, that data the program prints to stdout will just be output to the current tty and not recorded.
If True, it will NOT be output to the tty, and will be recorded under the key "stdout" in the return dict.
@param stderr <True/False or "stdout"/subprocess.STDOUT> - Default True, Whether to gather and include program's stderr data in results, or to combine with "stdout" data.
If False, the data the program prints to stderr will just be output to the current tty and not recorded
If True, it will NOT be output to the tty, and will be recorded under the key "stderr" in the return dict.
If "stdout" or subprocess.STDOUT - stderr data will be blended with stdout data. This requires that stdout=True.
@param encoding <None/str> - Default sys.getdefaultencoding(), the program's output will automatically be decoded using the provided codec (e.x. "utf-8" or "ascii").
If None or False-ish, data will not be decoded (i.e. in python3 will be "bytes" type)
If unsure, leave this as it's default value, or provide "utf-8"
@return <dict> - Dict of results. Has following keys:
'returnCode' - <int> - Always present, included the integer return-code from the command.
'stdout' <unciode/str/bytes (depending on #encoding)> - Present if stdout=True, contains data output by program to stdout, or stdout+stderr if stderr param is "stdout"/subprocess.STDOUT
'stderr' <unicode/str/bytes (depending on #encoding)> - Present if stderr=True, contains data output by program to stderr.
@raises - SimpleCommandFailure if it cannot launch the given command, for reasons such as: cannot find the executable, or no permission to execute, etc
Data descriptors defined here:
- __dict__
- dictionary for instance variables (if defined)
- __weakref__
- list of weak references to the object (if defined)
Data and other attributes defined here:
- SimpleCommandFailure = <class 'subprocess2.simple.SimpleCommandFailure'>
- SimpleCommandFailure - An exception representing a failure in execution of a command using the subprocess2.Simple interfaces.
Contains the following properties:
* msg <str> - The exception message itself
* returnCode <int> - The return code of the execution
* stdout <None/str> - Any collected stdout data, or "None" if none was collected.
* stderr <None/str> - Any collected stderr data, or "None" if none was collected.
|
class SimpleCommandFailure(exceptions.Exception) |
| |
SimpleCommandFailure - An exception representing a failure in execution of a command using the subprocess2.Simple interfaces.
Contains the following properties:
* msg <str> - The exception message itself
* returnCode <int> - The return code of the execution
* stdout <None/str> - Any collected stdout data, or "None" if none was collected.
* stderr <None/str> - Any collected stderr data, or "None" if none was collected.
|
| |
- Method resolution order:
- SimpleCommandFailure
- exceptions.Exception
- exceptions.BaseException
- __builtin__.object
Methods defined here:
- __init__(self, msg, returnCode, stdout=None, stderr=None)
Data descriptors defined here:
- __weakref__
- list of weak references to the object (if defined)
Data and other attributes inherited from exceptions.Exception:
- __new__ = <built-in method __new__ of type object>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
Methods inherited from exceptions.BaseException:
- __delattr__(...)
- x.__delattr__('name') <==> del x.name
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __getslice__(...)
- x.__getslice__(i, j) <==> x[i:j]
Use of negative indices is not supported.
- __reduce__(...)
- __repr__(...)
- x.__repr__() <==> repr(x)
- __setattr__(...)
- x.__setattr__('name', value) <==> x.name = value
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __unicode__(...)
Data descriptors inherited from exceptions.BaseException:
- __dict__
- args
- message
| |