ó
|
M\¬Qc @ s` d Z d d l Z e j d k Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d e
|
f d YZ e rÒ d d l Z d d l Z d d l Z d f d YZ d f d YZ nE d d l Z e e d
|
Z d d l Z d d l Z e e d d Z d d d d d d d g Z e rd d l m Z m Z m Z m Z m Z m Z m Z m Z e j! d d d d d d d d g n y e j" d Z# Wn d Z# n Xg Z$ d Z% d Z& d Z' d Z( d! Z) d" Z* d# Z+ d$ Z, d% Z- d e. f d& YZ/ d' Z0 d( Z1 e2 d) k r\e rRe1 n e0 n d S(* s0 subprocess - Subprocesses with accessible I/O streams
|
|
This module allows you to spawn processes, connect to their
|
input/output/error pipes, and obtain their return codes. This module
|
intends to replace several other, older modules and functions, like:
|
|
os.system
|
os.spawn*
|
os.popen*
|
popen2.*
|
commands.*
|
|
Information about how the subprocess module can be used to replace these
|
modules and functions can be found below.
|
|
|
|
Using the subprocess module
|
===========================
|
This module defines one class called Popen:
|
|
class Popen(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):
|
|
|
Arguments are:
|
|
args should be a string, or a sequence of program arguments. The
|
program to execute is normally the first item in the args sequence or
|
string, but can be explicitly set by using the executable argument.
|
|
On UNIX, with shell=False (default): In this case, the Popen class
|
uses os.execvp() to execute the child program. args should normally
|
be a sequence. A string will be treated as a sequence with the string
|
as the only item (the program to execute).
|
|
On UNIX, with shell=True: If args is a string, it specifies the
|
command string to execute through the shell. If args is a sequence,
|
the first item specifies the command string, and any additional items
|
will be treated as additional shell arguments.
|
|
On Windows: the Popen class uses CreateProcess() to execute the child
|
program, which operates on strings. If args is a sequence, it will be
|
converted to a string using the list2cmdline method. Please note that
|
not all MS Windows applications interpret the command line the same
|
way: The list2cmdline is designed for applications using the same
|
rules as the MS C runtime.
|
|
bufsize, if given, has the same meaning as the corresponding argument
|
to the built-in open() function: 0 means unbuffered, 1 means line
|
buffered, any other positive value means use a buffer of
|
(approximately) that size. A negative bufsize means to use the system
|
default, which usually means fully buffered. The default value for
|
bufsize is 0 (unbuffered).
|
|
stdin, stdout and stderr specify the executed programs' standard
|
input, standard output and standard error file handles, respectively.
|
Valid values are PIPE, an existing file descriptor (a positive
|
integer), an existing file object, and None. PIPE indicates that a
|
new pipe to the child should be created. With None, no redirection
|
will occur; the child's file handles will be inherited from the
|
parent. Additionally, stderr can be STDOUT, which indicates that the
|
stderr data from the applications should be captured into the same
|
file handle as for stdout.
|
|
If preexec_fn is set to a callable object, this object will be called
|
in the child process just before the child is executed.
|
|
If close_fds is true, all file descriptors except 0, 1 and 2 will be
|
closed before the child process is executed.
|
|
if shell is true, the specified command will be executed through the
|
shell.
|
|
If cwd is not None, the current directory will be changed to cwd
|
before the child is executed.
|
|
If env is not None, it defines the environment variables for the new
|
process.
|
|
If universal_newlines is true, the file objects stdout and stderr are
|
opened as a text files, but lines may be terminated by any of '\n',
|
the Unix end-of-line convention, '\r', the Macintosh convention or
|
'\r\n', the Windows convention. All of these external representations
|
are seen as '\n' by the Python program. Note: This feature is only
|
available if Python is built with universal newline support (the
|
default). Also, the newlines attribute of the file objects stdout,
|
stdin and stderr are not updated by the communicate() method.
|
|
The startupinfo and creationflags, if given, will be passed to the
|
underlying CreateProcess() function. They can specify things such as
|
appearance of the main window and priority for the new process.
|
(Windows only)
|
|
|
This module also defines some shortcut functions:
|
|
call(*popenargs, **kwargs):
|
Run command with arguments. Wait for command to complete, then
|
return the returncode attribute.
|
|
The arguments are the same as for the Popen constructor. Example:
|
|
retcode = call(["ls", "-l"])
|
|
check_call(*popenargs, **kwargs):
|
Run command with arguments. Wait for command to complete. If the
|
exit code was zero then return, otherwise raise
|
CalledProcessError. The CalledProcessError object will have the
|
return code in the returncode attribute.
|
|
The arguments are the same as for the Popen constructor. Example:
|
|
check_call(["ls", "-l"])
|
|
check_output(*popenargs, **kwargs):
|
Run command with arguments and return its output as a byte string.
|
|
If the exit code was non-zero it raises a CalledProcessError. The
|
CalledProcessError object will have the return code in the returncode
|
attribute and output in the output attribute.
|
|
The arguments are the same as for the Popen constructor. Example:
|
|
output = check_output(["ls", "-l", "/dev/null"])
|
|
|
Exceptions
|
----------
|
Exceptions raised in the child process, before the new program has
|
started to execute, will be re-raised in the parent. Additionally,
|
the exception object will have one extra attribute called
|
'child_traceback', which is a string containing traceback information
|
from the childs point of view.
|
|
The most common exception raised is OSError. This occurs, for
|
example, when trying to execute a non-existent file. Applications
|
should prepare for OSErrors.
|
|
A ValueError will be raised if Popen is called with invalid arguments.
|
|
check_call() and check_output() will raise CalledProcessError, if the
|
called process returns a non-zero return code.
|
|
|
Security
|
--------
|
Unlike some other popen functions, this implementation will never call
|
/bin/sh implicitly. This means that all characters, including shell
|
metacharacters, can safely be passed to child processes.
|
|
|
Popen objects
|
=============
|
Instances of the Popen class have the following methods:
|
|
poll()
|
Check if child process has terminated. Returns returncode
|
attribute.
|
|
wait()
|
Wait for child process to terminate. Returns returncode attribute.
|
|
communicate(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).
|
|
Note: The data read is buffered in memory, so do not use this
|
method if the data size is large or unlimited.
|
|
The following attributes are also available:
|
|
stdin
|
If the stdin argument is PIPE, this attribute is a file object
|
that provides input to the child process. Otherwise, it is None.
|
|
stdout
|
If the stdout argument is PIPE, this attribute is a file object
|
that provides output from the child process. Otherwise, it is
|
None.
|
|
stderr
|
If the stderr argument is PIPE, this attribute is file object that
|
provides error output from the child process. Otherwise, it is
|
None.
|
|
pid
|
The process ID of the child process.
|
|
returncode
|
The child return code. A None value indicates that the process
|
hasn't terminated yet. A negative value -N indicates that the
|
child was terminated by signal N (UNIX only).
|
|
|
Replacing older functions with the subprocess module
|
====================================================
|
In this section, "a ==> b" means that b can be used as a replacement
|
for a.
|
|
Note: All functions in this section fail (more or less) silently if
|
the executed program cannot be found; this module raises an OSError
|
exception.
|
|
In the following examples, we assume that the subprocess module is
|
imported with "from subprocess import *".
|
|
|
Replacing /bin/sh shell backquote
|
---------------------------------
|
output=`mycmd myarg`
|
==>
|
output = Popen(["mycmd", "myarg"], stdout=PIPE).communicate()[0]
|
|
|
Replacing shell pipe line
|
-------------------------
|
output=`dmesg | grep hda`
|
==>
|
p1 = Popen(["dmesg"], stdout=PIPE)
|
p2 = Popen(["grep", "hda"], stdin=p1.stdout, stdout=PIPE)
|
output = p2.communicate()[0]
|
|
|
Replacing os.system()
|
---------------------
|
sts = os.system("mycmd" + " myarg")
|
==>
|
p = Popen("mycmd" + " myarg", shell=True)
|
pid, sts = os.waitpid(p.pid, 0)
|
|
Note:
|
|
* Calling the program through the shell is usually not required.
|
|
* It's easier to look at the returncode attribute than the
|
exitstatus.
|
|
A more real-world example would look like this:
|
|
try:
|
retcode = call("mycmd" + " myarg", shell=True)
|
if retcode < 0:
|
print >>sys.stderr, "Child was terminated by signal", -retcode
|
else:
|
print >>sys.stderr, "Child returned", retcode
|
except OSError, e:
|
print >>sys.stderr, "Execution failed:", e
|
|
|
Replacing os.spawn*
|
-------------------
|
P_NOWAIT example:
|
|
pid = os.spawnlp(os.P_NOWAIT, "/bin/mycmd", "mycmd", "myarg")
|
==>
|
pid = Popen(["/bin/mycmd", "myarg"]).pid
|
|
|
P_WAIT example:
|
|
retcode = os.spawnlp(os.P_WAIT, "/bin/mycmd", "mycmd", "myarg")
|
==>
|
retcode = call(["/bin/mycmd", "myarg"])
|
|
|
Vector example:
|
|
os.spawnvp(os.P_NOWAIT, path, args)
|
==>
|
Popen([path] + args[1:])
|
|
|
Environment example:
|
|
os.spawnlpe(os.P_NOWAIT, "/bin/mycmd", "mycmd", "myarg", env)
|
==>
|
Popen(["/bin/mycmd", "myarg"], env={"PATH": "/usr/bin"})
|
|
|
Replacing os.popen*
|
-------------------
|
pipe = os.popen("cmd", mode='r', bufsize)
|
==>
|
pipe = Popen("cmd", shell=True, bufsize=bufsize, stdout=PIPE).stdout
|
|
pipe = os.popen("cmd", mode='w', bufsize)
|
==>
|
pipe = Popen("cmd", shell=True, bufsize=bufsize, stdin=PIPE).stdin
|
|
|
(child_stdin, child_stdout) = os.popen2("cmd", mode, bufsize)
|
==>
|
p = Popen("cmd", shell=True, bufsize=bufsize,
|
stdin=PIPE, stdout=PIPE, close_fds=True)
|
(child_stdin, child_stdout) = (p.stdin, p.stdout)
|
|
|
(child_stdin,
|
child_stdout,
|
child_stderr) = os.popen3("cmd", mode, bufsize)
|
==>
|
p = Popen("cmd", shell=True, bufsize=bufsize,
|
stdin=PIPE, stdout=PIPE, stderr=PIPE, close_fds=True)
|
(child_stdin,
|
child_stdout,
|
child_stderr) = (p.stdin, p.stdout, p.stderr)
|
|
|
(child_stdin, child_stdout_and_stderr) = os.popen4("cmd", mode,
|
bufsize)
|
==>
|
p = Popen("cmd", shell=True, bufsize=bufsize,
|
stdin=PIPE, stdout=PIPE, stderr=STDOUT, close_fds=True)
|
(child_stdin, child_stdout_and_stderr) = (p.stdin, p.stdout)
|
|
On Unix, os.popen2, os.popen3 and os.popen4 also accept a sequence as
|
the command to execute, in which case arguments will be passed
|
directly to the program without shell intervention. This usage can be
|
replaced as follows:
|
|
(child_stdin, child_stdout) = os.popen2(["/bin/ls", "-l"], mode,
|
bufsize)
|
==>
|
p = Popen(["/bin/ls", "-l"], bufsize=bufsize, stdin=PIPE, stdout=PIPE)
|
(child_stdin, child_stdout) = (p.stdin, p.stdout)
|
|
Return code handling translates as follows:
|
|
pipe = os.popen("cmd", 'w')
|
...
|
rc = pipe.close()
|
if rc is not None and rc % 256:
|
print "There were some errors"
|
==>
|
process = Popen("cmd", 'w', shell=True, stdin=PIPE)
|
...
|
process.stdin.close()
|
if process.wait() != 0:
|
print "There were some errors"
|
|
|
Replacing popen2.*
|
------------------
|
(child_stdout, child_stdin) = popen2.popen2("somestring", bufsize, mode)
|
==>
|
p = Popen(["somestring"], shell=True, bufsize=bufsize
|
stdin=PIPE, stdout=PIPE, close_fds=True)
|
(child_stdout, child_stdin) = (p.stdout, p.stdin)
|
|
On Unix, popen2 also accepts a sequence as the command to execute, in
|
which case arguments will be passed directly to the program without
|
shell intervention. This usage can be replaced as follows:
|
|
(child_stdout, child_stdin) = popen2.popen2(["mycmd", "myarg"], bufsize,
|
mode)
|
==>
|
p = Popen(["mycmd", "myarg"], bufsize=bufsize,
|
stdin=PIPE, stdout=PIPE, close_fds=True)
|
(child_stdout, child_stdin) = (p.stdout, p.stdin)
|
|
The popen2.Popen3 and popen2.Popen4 basically works as subprocess.Popen,
|
except that:
|
|
* subprocess.Popen raises an exception if the execution fails
|
* the capturestderr argument is replaced with the stderr argument.
|
* stdin=PIPE and stdout=PIPE must be specified.
|
* popen2 closes all filedescriptors by default, but you have to specify
|
close_fds=True with subprocess.Popen.
|
iÿÿÿÿNt win32t CalledProcessErrorc B s# e Z d Z d d Z d Z RS( sý This exception is raised when a process run by check_call() or
|
check_output() returns a non-zero exit status.
|
The exit status will be stored in the returncode attribute;
|
check_output() will also store the output in the output attribute.
|
c C s | | _ | | _ | | _ d S( N( t
|
returncodet cmdt output( t selfR R R ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyt __init__ s c C s d | j | j f S( Ns- Command '%s' returned non-zero exit status %d( R R ( R ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyt __str__ s N( t __name__t
|
__module__t __doc__t NoneR R ( ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyR s t STARTUPINFOc B s& e Z d Z d Z d Z d Z d Z RS( i N( R R t dwFlagsR t hStdInputt
|
hStdOutputt hStdErrort wShowWindow( ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyR ¤ s
|
t
|
pywintypesc B s e Z e Z RS( ( R R t IOErrort error( ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyR ª s t pollt PIPE_BUFi t Popent PIPEt STDOUTt callt
|
check_callt check_output( t CREATE_NEW_CONSOLEt CREATE_NEW_PROCESS_GROUPt STD_INPUT_HANDLEt STD_OUTPUT_HANDLEt STD_ERROR_HANDLEt SW_HIDEt STARTF_USESTDHANDLESt STARTF_USESHOWWINDOWR R R R R! R" R# R$ t SC_OPEN_MAXi c C s_ xX t D]O } | j d t j } | d k r y t j | WqW t k
|
rS qW Xq q Wd S( Nt
|
_deadstate( t _activet _internal_pollt syst maxintR t removet
|
ValueError( t instt res( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyt _cleanupÌ s iþÿÿÿc G sV xO t rQ y | | SWq t t f k
|
rM } | j t j k rG q n q Xq Wd S( N( t Truet OSErrorR t errnot EINTR( t funct argst e( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyt _eintr_retry_callÛ s c C sÎ i
|
d d 6d d 6d d 6d d 6d d
|
6d d 6d d 6d d 6d d 6d d 6} g } xP | j D]B \ } } t t j | } | d k r_ | j d | | q_ q_ Wx" t j D] } | j d | q¯ W| S( sn Return a list of command-line arguments reproducing the current
|
settings in sys.flags and sys.warnoptions.t dt debugt Ot optimizet Bt dont_write_bytecodet st no_user_sitet St no_sitet Et ignore_environmentt vt verboset bt bytes_warningt Rt hash_randomizationt 3t py3k_warningi t -s -W( t itemst getattrR) t flagst appendt warnoptions( t flag_opt_mapR5 t flagt optRD ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyt _args_from_interpreter_flagsé s&
|
c O s t | | j S( sÓ Run command with arguments. Wait for command to complete, then
|
return the returncode attribute.
|
|
The arguments are the same as for the Popen constructor. Example:
|
|
retcode = call(["ls", "-l"])
|
( R t wait( t popenargst kwargs( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyR s c O sS t | | } | rO | j d } | d k r= | d } n t | | n d S( sS Run command with arguments. Wait for command to complete. If
|
the exit code was zero then return, otherwise raise
|
CalledProcessError. The CalledProcessError object will have the
|
return code in the returncode attribute.
|
|
The arguments are the same as for the Popen constructor. Example:
|
|
check_call(["ls", "-l"])
|
R5 i N( R t getR R ( RW RX t retcodeR ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyR s
|
c O s d | k r t d n t d t | | } | j \ } } | j } | r | j d } | d k r| | d } n t | | d | n | S( s Run command with arguments and return its output as a byte string.
|
|
If the exit code was non-zero it raises a CalledProcessError. The
|
CalledProcessError object will have the return code in the returncode
|
attribute and output in the output attribute.
|
|
The arguments are the same as for the Popen constructor. Example:
|
|
>>> check_output(["ls", "-l", "/dev/null"])
|
'crw-rw-rw- 1 root root 1, 3 Oct 18 2007 /dev/null\n'
|
|
The stdout argument is not allowed as it is used internally.
|
To capture standard error in the result, use stderr=STDOUT.
|
|
>>> check_output(["/bin/sh", "-c",
|
... "ls -l non_existent_file ; exit 0"],
|
... stderr=STDOUT)
|
'ls: non_existent_file: No such file or directory\n'
|
t stdouts3 stdout argument not allowed, it will be overridden.R5 i R N( R, R R t communicateR RY R R ( RW RX t processR t
|
unused_errRZ R ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyR " s c C sG g } t } x+| D]#} g } | r5 | j d n d | k pQ d | k pQ | } | rj | j d n x | D] } | d k r | j | qq | d k rÐ | j d t | d g } | j d qq | rì | j | g } n | j | qq W| r| j | n | r | j | | j d q q Wd j | S( s
|
Translate a sequence of arguments into a command line
|
string, using the same rules as the MS C runtime:
|
|
1) Arguments are delimited by white space, which is either a
|
space or a tab.
|
|
2) A string surrounded by double quotation marks is
|
interpreted as a single argument, regardless of white space
|
contained within. A quoted string can be embedded in an
|
argument.
|
|
3) A double quotation mark preceded by a backslash is
|
interpreted as a literal double quotation mark.
|
|
4) Backslashes are interpreted literally, unless they
|
immediately precede a double quotation mark.
|
|
5) If backslashes immediately precede a double quotation mark,
|
every pair of backslashes is interpreted as a literal
|
backslash. If the number of backslashes is odd, the last
|
backslash escapes the next double quotation mark as
|
described in rule 3.
|
t s t "s \i s \"t ( t FalseRP t lent extendt join( t seqt resultt needquotet argt bs_buft c( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyt list2cmdlineC s4 c B s e Z d d d d d d e e d d e d d d Z d Z e j e d Z d d Z
|
d Z e rä d Z d Z d Z d Z d e j e j e j d
|
Z d Z d Z d Z d Z d Z e Z n´ d Z e d Z d Z d Z d Z e j! e j" e j# e j$ d Z% d e j& e j' e j( e) j* d Z d Z d Z d Z+ d Z, d Z d Z d Z RS( i c C sr t t | _ t | t t f s4 t d n t r | d
|
k rU t d n | rÇ | d
|
k s | d
|
k s | d
|
k rÇ t d qÇ n6 | d
|
k r¬ t d n | d k rÇ t d n d
|
| _
|
d
|
| _ d
|
| _ d
|
| _ d
|
| _ | | _ | j | | | \ } } } } } } y> | j | | | | |
|
| | | | | | | | | | | WnÔ t k
|
r8t j \ } } } g } | t k r¯| j | | f n | t k rÑ| j | | f n | t k ró| j | | f n x3 | D]+ } y t j | Wqút k
|
r$qúXqúW| | | n Xt r·| d
|
k rft j | j d } n | d
|
k rt j | j d } n | d
|
k r·t j | j d } q·n | d
|
k rÞt j | d | | _
|
n | d
|
k r&| r t j | d | | _ q&t j | d | | _ n | d
|
k rn| rSt j | d | | _ qnt j | d | | _ n d
|
S( s Create new Popen instance.s bufsize must be an integers0 preexec_fn is not supported on Windows platformssS close_fds is not supported on Windows platforms if you redirect stdin/stdout/stderrs2 startupinfo is only supported on Windows platformsi s4 creationflags is only supported on Windows platformst wbt rUt rbN( R/ Rb t _child_createdt
|
isinstancet intt longt TypeErrort mswindowsR R, t stdinR[ t stderrt pidR t universal_newlinest _get_handlest _execute_childt ExceptionR) t exc_infoR Rd t ost closet EnvironmentErrort msvcrtt open_osfhandlet Detacht fdopen( R R5 t bufsizet
|
executableRv R[ Rw t
|
preexec_fnt close_fdst shellt cwdt envRy t startupinfot creationflagst p2creadt p2cwritet c2preadt c2pwritet errreadt errwritet exc_typet exc_valuet exc_tracet to_closet fd( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyR sx ' c C s( | j d d } | j d d } | S( Ns
|
s
|
s ( t replace( R t data( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyt _translate_newlinesó s c C sU t | d t s d S| j d | | j d k rQ | d k rQ | j | n d S( NRp R& ( RN Rb R( R R RP ( R t _maxintR' ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyt __del__ù s
|
c C s | j | j | j g j d d k rd } d } | j r© | r y | j j | Wq t k
|
r } | j t j k r | j t j k r q q Xn | j j
|
nV | j rÔ t | j j } | j j
|
n+ | j rÿ t | j j } | j j
|
n | j | | f S| j | S( sf 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).i N( Rv R[ Rw t countR t writeR R2 t EPIPEt EINVALR R7 t readRV t _communicate( R t inputR[ Rw R6 ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyR\ s( ' $
|
|
c C s
|
| j S( N( R( ( R ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyR ) s c C s | d k r( | d k r( | d k r( d Sd \ } } d \ } } d \ } } | d k r t j t j } | d k rñ t j d d \ } }
|
qñ n] | t k r» t j d d \ } } n6 t | t rÜ t j | } n t j | j
|
} | j | } | d k rHt j t j } | d k r¥t j d d \ }
|
} q¥n] | t k rot j d d \ } } n6 t | t rt j | } n t j | j
|
} | j | } | d k rüt j t j } | d k rnt j d d \ }
|
} qnnr | t k r#t j d d \ } } nK | t k r8| } n6 t | t rYt j | } n t j | j
|
} | j | } | | | | | | f S( s| Construct and return tuple with IO objects:
|
p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite
|
i N( NNNNNN( NN( NN( NN( R t _subprocesst GetStdHandleR t
|
CreatePipeR Rq Rr R t get_osfhandlet filenot _make_inheritableR R! R ( R Rv R[ Rw R R R R R R t _( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyRz 1 sP $ c C s+ t j t j | t j d d t j S( s2 Return a duplicate of handle, which is inheritablei i ( R¥ t DuplicateHandlet GetCurrentProcesst DUPLICATE_SAME_ACCESS( R t handle( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyRª j s c C s t j j t j j t j d d } t j j | s t j j t j j t j d } t j j | s t d q n | S( s, Find and return absolut path to w9xpopen.exei s w9xpopen.exesZ Cannot locate w9xpopen.exe, which is needed for Popen to work with your shell or platform.(
|
R~ t pathRe t dirnameR¥ t GetModuleFileNamet existsR) t exec_prefixt RuntimeError( R t w9xpopen( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyt _find_w9xpopenq s c C s
|
t | t j s! t | } n | d k r9 t } n d | | | f k r~ | j t j O_ | | _ | | _
|
| | _ n |
|
r(| j t j O_ t j | _ t j j d d } d j | | } t j d k sù t j j | j d k r(| j } d | | f } | t j O} q(n zj y> t j | | d d t | | | | | \ } } } } Wn% t j k
|
r} t | j n XWd | d k r®| j n | d k rÇ| j n | d k rà| j n Xt | _! | | _" | | _# | j d S( s$ Execute program (MS Windows version)t COMSPECs cmd.exes
|
{} /c "{}"I s command.coms "%s" %sN($ Rq t typest StringTypesRl R R R R¥ R# R R R R$ R" R R~ t environRY t formatt
|
GetVersionR° t basenamet lowerR· R t CreateProcessRr R R t WindowsErrorR5 t CloseR0 Rp t _handleRx ( R R5 R R R R R Ry R R R R R R R R R t comspecR¶ t hpt htRx t tidR6 ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyR{ sP
|
c C sF | j d k r? | | j d | k r? | | j | _ q? n | j S( sÎ Check if child process has terminated. Returns returncode
|
attribute.
|
|
This method is called by __del__, so it can only refer to objects
|
in its local scope.
|
|
i N( R R RÃ ( R R& t _WaitForSingleObjectt _WAIT_OBJECT_0t _GetExitCodeProcess( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyR( Ï s c C sD | j d k r= t j | j t j t j | j | _ n | j S( sO Wait for child process to terminate. Returns returncode
|
attribute.N( R R R¥ t WaitForSingleObjectRÃ t INFINITEt GetExitCodeProcess( R ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyRV à s
|
|
c C s | j | j d S( N( RP R¢ ( R t fht buffer( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyt _readerthreadê s c C sÍ d } d } | j rY g } t j d | j d | j | f } | j t | j n | j r¦ g } t j d | j d | j | f } | j t | j n | j r| d k r y | j j
|
| Wq t k
|
rü } | j t j k rý qý q Xn | j j n | j r&| j n | j r<| j n | d k rU| d } n | d k rn| d } n | j r¹t t d r¹| r| j | } n | r¹| j | } q¹n | j | | f S( Nt targetR5 i t newlines( R R[ t threadingt ThreadRÐ t setDaemonR0 t startRw Rv R R R2 R R Re Ry t hasattrt fileR RV ( R R¤ R[ Rw t stdout_threadt stderr_threadR6 ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyR£ î sJ
|
c C s
| t j k r | j ne | t j k rD t j | j t j n= | t j k rl t j | j t j n t d j | d S( s) Send a signal to the process
|
s Unsupported signal: {}N(
|
t signalt SIGTERMt terminatet CTRL_C_EVENTR~ t killRx t CTRL_BREAK_EVENTR, R¼ ( R t sig( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyt send_signal s c C sv y t j | j d WnX t k
|
rq } | j d k r> n t j | j } | t j k re n | | _ n Xd S( s# Terminates the process
|
i i N( R¥ t TerminateProcessRÃ R1 t winerrorRÍ t STILL_ACTIVER ( R R6 t rc( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyRÝ , s c
|
C sK d \ } } d \ } } d \ } } | d k r3 nE | t k rT | j \ } } n$ t | t rl | } n | j } | d k r nE | t k r¨ | j \ } } n$ t | t rÀ | } n | j } | d k rÛ nZ | t k rü | j \ } } n9 | t k r| } n$ t | t r)| } n | j } | | | | | | f S( s| Construct and return tuple with IO objects:
|
p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite
|
N( NN( NN( NN( R R t pipe_cloexecRq Rr R© R (
|
R Rv R[ Rw R R R R R R ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyRz A s: c C s~ y t j } Wn t k
|
r& d } n Xt j | t j } | r_ t j | t j | | B n t j | t j | | @ d S( Ni ( t fcntlt
|
FD_CLOEXECt AttributeErrort F_GETFDt F_SETFD( R R t cloexect cloexec_flagt old( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyt _set_cloexec_flagn s
|
c C s6 t j \ } } | j | | j | | | f S( s# Create a pipe with FDs set CLOEXEC.( R~ t pipeRð ( R t rt w( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyRç { s c C s t t d r6 t j d | t j | d t nG xD t d t D]3 } | | k r^ qF n y t j | WqF qF XqF Wd S( Nt
|
closerangei i ( R× R~ Rô t MAXFDt xrangeR ( R t butt i( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyt
|
_close_fds s c s= t | t j r | g } n t | } |
|
rV d d g | } | rV | | d <qV n | d
|
k ro | d } n j \ } } z;zt j } t j y t j
|
_ Wn | rÉ t j n n Xt _ j d k r y²| d
|
k rt j | n | d
|
k r#t j | n | d
|
k r?t j | n t j | | d k rjt j | } n | d k s| d k rt j | } n f d } | | d | | d | | d d
|
h } xL | | | g D]; } | | k rã| d k rãt j | | j | qãqãW| r; j d | n | d
|
k rWt j | n | rg| n | d
|
k rt j | | n t j | | | Wn\ t j \ } } } t j | | | } d j | | _ t j | t j | n Xt j d n | r t j n Wd
|
t j | X| d
|
k rV| d
|
k rVt j | n | d
|
k r~| d
|
k r~t j | n | d
|
k r¦| d
|
k r¦t j | n t t j! | d } Wd
|
t j | X| d k r9y t t j" j d Wn+ t# k
|
r } | j$ t$ j% k r! q!n Xt j& | } | n d
|
S( s Execute program (POSIX version)s /bin/shs -ci i c sB | | k r j | t n | d k r> t j | | n d S( N( Rð Rb R R~ t dup2( t aRF ( R ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyt _dup2Ð s i R÷ Ra iÿ Ni (' Rq R¹ Rº t listR Rç t gct isenabledt disableR~ t forkRx t enableR0 Rp R t dupt addRù t chdirt execvpt execvpeR) R} t tracebackt format_exceptionRe t child_tracebackR t picklet dumpst _exitR7 R¢ t waitpidR1 R2 t ECHILDt loads( R R5 R R R R R Ry R R R R R R R R R t errpipe_readt errpipe_writet gc_was_enabledRü t closedR R R t tbt exc_linesR R6 t child_exception( ( R sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyR{ s
|
|
|
c C sM | | r | | | _ n* | | r= | | | _ n t d d S( Ns Unknown child exit status!( R Rµ ( R t stst _WIFSIGNALEDt _WTERMSIGt
|
_WIFEXITEDt _WEXITSTATUS( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyt _handle_exitstatus s
|
c C s | j d k r y; | | j | \ } } | | j k rI | j | n Wq | k
|
r } | d k rt | | _ n | j | k r d | _ q q Xn | j S( sõ Check if child process has terminated. Returns returncode
|
attribute.
|
|
This method is called by __del__, so it cannot reference anything
|
outside of the local scope (nor can any methods it calls).
|
|
i N( R R Rx R R2 ( R R& t _waitpidt _WNOHANGt _os_errort _ECHILDRx R R6 ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyR( - s c C s x | j d k r y" t t j | j d \ } } Wn: t k
|
rp } | j t j k r^ n | j } d } n X| | j k r | j | q q W| j S( sO Wait for child process to terminate. Returns returncode
|
attribute.i N(
|
R R R7 R~ R Rx R1 R2 R R ( R Rx R R6 ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyRV H s "
|
c C sý | j r/ | j j | s/ | j j q/ n t rM | j | \ } } n | j | \ } } | d k r d j | } n | d k r d j | } n | j ré t t
|
d ré | rÎ | j | } n | ré | j | } qé n | j | | f S( NRa RÒ ( Rv t flushR t _has_pollt _communicate_with_pollt _communicate_with_selectR Re Ry R× RØ R RV ( R R¤ R[ Rw ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyR£ ] s$
|
c s> d } d } i i } t j f d } f d } | j rm | rm | | j t j n t j t j B} | j r° | | j | g | | j j <} n | j rã | | j | g | | j j <} n d } xH r3y j } Wn5 t j
|
k
|
r9}
|
|
|
j d t j k r3qì n n Xxó | D]ë \ } } | t j @rß| | | t !} y | t j | | 7} Wn5 t k
|
r¼}
|
|
|
j t j k r¶| | qÜ q,X| t | k r,| | q,qA| | @r"t j | d } | s| | n | | j | qA| | qAWqì W| | f S( Nc s* j | j | | | j <d S( N( t registerR© ( t file_objt eventmask( t fd2filet poller( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyt register_and_append
s c s, j | | j j | d S( N( t
|
unregisterR t pop( R ( R) R* ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyt close_unregister_and_remove s i i ( R t selectR Rv t POLLOUTt POLLINt POLLPRIR[ R© Rw R R5 R2 R3 t _PIPE_BUFR~ R R1 R Rc R¢ RP ( R R¤ R[ Rw t fd2outputR+ R. t select_POLLIN_POLLPRIt input_offsett readyR6 R t modet chunkR ( ( R) R* sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyR$ ~ sT
|
c C s g } g } d } d } | j r: | r: | j | j n | j r\ | j | j g } n | j r~ | j | j g } n d } xÿ| s | r
y" t j | | g \ } } } Wn5 t j k
|
rì }
|
|
|
j d t j k ræ q n n X| j | k r¶| | | t
|
!} y t j | j j | } WnH t k
|
rv}
|
|
|
j t j k rp| j j | j | j q³ q¶X| | 7} | t | k r¶| j j | j | j q¶n | j | k r t j | j j d } | d k r | j j | j | j n | j | n | j | k r t j | j j d } | d k rr| j j | j | j n | j | q q W| | f S( Ni i Ra ( R Rv RP R[ Rw R/ R R5 R2 R3 R3 R~ R R© R1 R R R+ Rc R¢ ( R R¤ t read_sett write_setR[ Rw R6 t rlistt wlistt xlistR6 R9 t bytes_writtenR ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyR% » s\ "
|
c C s t j | j | d S( s) Send a signal to the process
|
N( R~ Rß Rx ( R Rá ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyRâ ô s c C s | j t j d S( s/ Terminate the process with SIGTERM
|
N( Râ RÛ RÜ ( R ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyRÝ ù s c C s | j t j d S( s* Kill the process with SIGKILL
|
N( Râ RÛ t SIGKILL( R ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyRß þ s N(- R R R Rb R R R) R* R' R R\ R Ru Rz Rª R· R{ R¥ RË t WAIT_OBJECT_0RÍ R( RV RÐ R£ Râ RÝ Rß R0 Rð Rç Rù R~ t WIFSIGNALEDt WTERMSIGt WIFEXITEDt WEXITSTATUSR R t WNOHANGR R2 R R$ R% ( ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyR sR e " 9 M
|
2 - ! = 9 c C s( t d g d t j d } d GH| GHt j d k r` t d g d d } | j n d GHt d g d t } t d
|
d g d | j d t } t | j d GHHd GHy t d g j GHWnF t k
|
r} | j t j
|
k rd GHd GH| j GHq$d G| j GHn Xt j d IJd S( Nt psR[ i s Process list:t idR c S s t j d S( Nid ( R~ t setuid( ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyt <lambda> s s Looking for 'hda'...t dmesgt grept hdaRv s Trying a weird file...s /this/path/does/not/exists' The file didn't exist. I thought so...s Child traceback:t Errors Gosh. No error.( R R R\ R~ t getuidRV R[ t reprR1 R2 t ENOENTR
|
R) Rw ( t plistt pt p1t p2R6 ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyt _demo_posix s* ! c C sl d GHt d d t d t } t d d | j d t } t | j d GHd GHt d } | j d S(
|
Ns% Looking for 'PROMPT' in set output...t setR[ R s find "PROMPT"Rv i s Executing calc...t calc( R R R0 R[ RP R\ RV ( RT RU RS ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyt _demo_windows- s t __main__(3 R
|
R) t platformRu R~ R¹ R Rþ RÛ R2 R| R RÓ R R¥ R R R/ R× R# Rè R RN R3 t __all__R R R R R! R" R# R$ Rd t sysconfRõ R' R/ R R R7 RU R R R Rl t objectR RV RY R ( ( ( sR /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/subprocess.pyt <module>
sh :
|
! Fÿ ÿ ÿ ~ )
|
|
