Operation   : Linux premium131.web-hosting.com 4.18.0-553.44.1.lve.el8.x86_64 #1 SMP Thu Mar 13 14:29:12 UTC 2025 x86_64
Software     : Apache
Server IP    : 162.0.232.56 | Your IP: 216.73.216.111
Domains      : 1034 Domain(s)
Permission   : [ 0755 ]

�
��f�
c@sdZd
dl
Z
e
jdkZd
dlZd
dlZd
dlZd
dlZd
dlZd
dl	Z	d
dl
Z
d
dlZd
dlZyd
dlm
Z
Wn"ek
r�


d
dlmZ
Yn
XGdd�de�ZGdd	�d	e�ZGd
d�de�Zer[
d
dlZd
dlZd
dlZGdd
�d
�ZGdd�d�ZnBd
dlZeed�Zd
dlZejZeedd�Z ddddddddd	dg
Z!er?d
dlm"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)
e!j*dddd d!d"d#d$g�

Gd%d&�d&e+�Z,nyej-d'�
Z.Wn


d(Z.Yn
XgZ/d)d*�Z0d;Z1d<Z2d=Z3d.d/�Z4d0d1�Z5d2dd3d�
Z7d4d�Z8d2dd5d�
Z9d6d7�Z:d8d�Z;d9d�Z<e=�Z>Gd:d�de=�Z?dS(>u�-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 older modules and functions:

os.system
os.spawn*

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=-1, executable=None,
            stdin=None, stdout=None, stderr=None,
            preexec_fn=None, close_fds=True, shell=False,
            cwd=None, env=None, universal_newlines=False,
            startupinfo=None, creationflags=0,
            restore_signals=True, start_new_session=False, pass_fds=()):


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 POSIX, 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 POSIX, 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 will be supplied as the corresponding argument to the io.open()
function when creating the stdin/stdout/stderr pipe file objects:
0 means unbuffered (read & write are one system call and can return short),
1 means line buffered, any other positive value means use a buffer of
approximately that size.  A negative bufsize, the default, means the system
default of io.DEFAULT_BUFFER_SIZE will be used.

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.

On POSIX, if preexec_fn is set to a callable object, this object will be
called in the child process just before the child is executed.  The use
of preexec_fn is not thread safe, using it in the presence of threads
could lead to a deadlock in the child process before the new executable
is executed.

If close_fds is true, all file descriptors except 0, 1 and 2 will be
closed before the child process is executed.  The default for close_fds
varies by platform:  Always true on POSIX.  True when stdin/stdout/stderr
are None on Windows, false otherwise.

pass_fds is an optional sequence of file descriptors to keep open between the
parent and child.  Providing any pass_fds implicitly sets close_fds to true.

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.

On POSIX, if restore_signals is True all signals that Python sets to
SIG_IGN are restored to SIG_DFL in the child process before the exec.
Currently this includes the SIGPIPE, SIGXFZ and SIGXFSZ signals.  This
parameter does nothing on Windows.

On POSIX, if start_new_session is True, the setsid() system call will be made
in the child process prior to executing the command.

If env is not None, it defines the environment variables for the new
process.

If universal_newlines is false, the file objects stdin, stdout and stderr
are opened as binary files, and no line ending conversion is done.

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 old Macintosh convention or
'\r\n', the Windows convention.  All of these external representations
are seen as '\n' by the Python program.  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 = subprocess.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:

    >>> subprocess.check_call(["ls", "-l"])
    0

getstatusoutput(cmd):
    Return (status, output) of executing cmd in a shell.

    Execute the string 'cmd' in a shell with os.popen() and return a 2-tuple
    (status, output).  cmd is actually run as '{ cmd ; } 2>&1', so that the
    returned output will contain output or error messages. A trailing newline
    is stripped from the output. The exit status for the command can be
    interpreted according to the rules for the C function wait().  Example:

    >>> subprocess.getstatusoutput('ls /bin/ls')
    (0, '/bin/ls')
    >>> subprocess.getstatusoutput('cat /bin/junk')
    (256, 'cat: /bin/junk: No such file or directory')
    >>> subprocess.getstatusoutput('/bin/junk')
    (256, 'sh: /bin/junk: not found')

getoutput(cmd):
    Return output (stdout or stderr) of executing cmd in a shell.

    Like getstatusoutput(), except the exit status is ignored and the return
    value is a string containing the command's output.  Example:

    >>> subprocess.getoutput('ls /bin/ls')
    '/bin/ls'

check_output(*popenargs, **kwargs):
    Run command with arguments and return its output.

    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 = subprocess.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 child's 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.

Exceptions defined within this module inherit from SubprocessError.
check_call() and check_output() will raise CalledProcessError if the
called process returns a non-zero return code.  TimeoutExpired
be raised if a timeout was specified and expired.


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 (POSIX 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("Child was terminated by signal", -retcode, file=sys.stderr)
    else:
        print("Child returned", retcode, file=sys.stderr)
except OSError as e:
    print("Execution failed:", e, file=sys.stderr)


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"})
iNuwin32(
u	monotonic(
utimec


Bs|EeZ
dZd
S(uSubprocessErrorN(u__name__u
__module__u__qualname__(
u
__locals__((u//opt/alt/python33/lib64/python3.3/subprocess.pyuSubprocessErrorh
suSubprocessErrorc

Bs5|EeZ
dZd
Zddd�
Zdd�ZdS(uCalledProcessErroru�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.
    cCs|
|_||_
||_dS(
N(u
returncodeucmduoutput(uselfu
returncodeucmduoutput((u//opt/alt/python33/lib64/python3.3/subprocess.pyu__init__q
s
	
	
uCalledProcessError.__init__c

Csd
|j|j
fS(Nu-Command '%s' returned non-zero exit status %d(ucmdu
returncode(
uself((u//opt/alt/python33/lib64/python3.3/subprocess.pyu__str__u
s
uCalledProcessError.__str__N(u__name__u
__module__u__qualname__u__doc__uNoneu__init__u__str__(
u
__locals__((u//opt/alt/python33/lib64/python3.3/subprocess.pyuCalledProcessErrork
s
uCalledProcessErrorc

Bs5|EeZ
dZd
Zddd�
Zdd�ZdS(uTimeoutExpiredu]This exception is raised when the timeout expires while waiting for a
    child process.
    cCs|
|_||_
||_dS(
N(ucmdutimeoutuoutput(uselfucmdutimeoutuoutput((u//opt/alt/python33/lib64/python3.3/subprocess.pyu__init__}
s
	
	
uTimeoutExpired.__init__c

Csd
|j|j
fS(Nu'Command '%s' timed out after %s seconds(ucmdutimeout(
uself((u//opt/alt/python33/lib64/python3.3/subprocess.pyu__str__�
s

uTimeoutExpired.__str__N(u__name__u
__module__u__qualname__u__doc__uNoneu__init__u__str__(
u
__locals__((u//opt/alt/python33/lib64/python3.3/subprocess.pyuTimeoutExpiredy
s
uTimeoutExpiredc


Bs2|EeZ
dZd
ZdZdZdZd
ZdS(uSTARTUPINFOiN(	u__name__u
__module__u__qualname__udwFlagsuNoneu	hStdInputu
hStdOutputu	hStdErroruwShowWindow(
u
__locals__((u//opt/alt/python33/lib64/python3.3/subprocess.pyuSTARTUPINFO�
s





uSTARTUPINFOc


Bs|EeZ
dZeZd
S(u
pywintypesN(u__name__u
__module__u__qualname__uIOErroruerror(
u
__locals__((u//opt/alt/python33/lib64/python3.3/subprocess.pyu
pywintypes�
s
u
pywintypesupolluPIPE_BUFiuPopenuPIPEuSTDOUTucallu
check_callugetstatusoutputu	getoutputucheck_outputuDEVNULL(uCREATE_NEW_CONSOLEuCREATE_NEW_PROCESS_GROUPuSTD_INPUT_HANDLEuSTD_OUTPUT_HANDLEuSTD_ERROR_HANDLEuSW_HIDEuSTARTF_USESTDHANDLESuSTARTF_USESHOWWINDOWuCREATE_NEW_CONSOLEuCREATE_NEW_PROCESS_GROUPuSTD_INPUT_HANDLEuSTD_OUTPUT_HANDLEuSTD_ERROR_HANDLEuSW_HIDEuSTARTF_USESTDHANDLESuSTARTF_USESHOWWINDOWc

BsP|EeZ
dZdZejd
d�
Zdd�Zdd�Z	eZ
e	ZdS(	uHandlecCs#|jsd
|_|
|�

ndS(NT(ucloseduTrue(uselfuCloseHandle((u//opt/alt/python33/lib64/python3.3/subprocess.pyuClose�
s
	
	
uHandle.Closec

Cs,|jsd|_t|�
Std
�
�
dS(Nualready closedT(ucloseduTrueuintu
ValueError(
uself((u//opt/alt/python33/lib64/python3.3/subprocess.pyuDetach�
s
	
	


u
Handle.Detachc

Csd
t|�
S(Nu
Handle(%d)(
uint(
uself((u//opt/alt/python33/lib64/python3.3/subprocess.pyu__repr__�
s
uHandle.__repr__NF(u__name__u
__module__u__qualname__uFalseuclosedu_winapiuCloseHandleuCloseuDetachu__repr__u__del__u__str__(
u
__locals__((u//opt/alt/python33/lib64/python3.3/subprocess.pyuHandle�
s

uHandleuSC_OPEN_MAXi
cCsixbtdd�D]P}|j
d
tj�
}
|
dk	rytj|�

Wqatk
r]


YqaXqqWdS(Nu
_deadstate(u_activeu_internal_pollusysumaxsizeuNoneuremoveu
ValueError(uinstures((u//opt/alt/python33/lib64/python3.3/subprocess.pyu_cleanup�
s






u_cleanupi
iic
Gs0x)y||
�SWqtk
r(


wYqXqdS(
N(
uInterruptedError(ufuncuargs((u//opt/alt/python33/lib64/python3.3/subprocess.pyu_eintr_retry_call�
s






u_eintr_retry_callcCs�i
d
d6dd6dd6dd6d	d
6dd6d
d6dd6dd6dd6}g}
xP|j�D]B\}}t
tj|�}|dkr_|
jd||�

q_q_Wx"tjD]}|
jd|�

q�W|
S(unReturn a list of command-line arguments reproducing the current
    settings in sys.flags and sys.warnoptions.u
dudebugu
Ouoptimizeu
Budont_write_bytecodeu
suno_user_siteu
Suno_siteu
Euignore_environmentu
vuverboseu
bu
bytes_warningu
ququietu
Ruhash_randomizationiu
-u-W(uitemsugetattrusysuflagsuappenduwarnoptions(uflag_opt_mapuargsuflaguoptu
v((u//opt/alt/python33/lib64/python3.3/subprocess.pyu_args_from_interpreter_flags�
s&
















u_args_from_interpreter_flagsutimeoutc
OsRt|
|��=}y|j
d
|�
SWn


|j�
|j
�
�Yn
XWdQXdS(u�Run command with arguments.  Wait for command to complete or
    timeout, then return the returncode attribute.

    The arguments are the same as for the Popen constructor.  Example:

    retcode = call(["ls", "-l"])
    utimeoutN(uPopenuwaitukill(utimeoutu	popenargsukwargsu
p((u//opt/alt/python33/lib64/python3.3/subprocess.pyucalls







cOsSt||
�}|rO|
j
d
�
}|dkr=|d}nt||��
ndS(uO
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 call function.  Example:

    check_call(["ls", "-l"])
    uargsiN(ucallugetuNoneuCalledProcessError(u	popenargsukwargsuretcodeucmd((u//opt/alt/python33/lib64/python3.3/subprocess.pyu
check_calls







c
Os�d
|krtd�
�
nt
d
t|
|�
��}y|jd|�
\}}Wndtk
r�


|j�
|j�\}}t|j|d|�
�
Yn


|j�
|j�
�Yn
X|j�}|r�t	||jd|�
�
nWdQX|S(uVRun command with arguments and return its output.

    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"])
    b'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)
    b'ls: non_existent_file: No such file or directory\n'

    If universal_newlines=True is passed, the return value will be a
    string rather than bytes.
    ustdoutu3stdout argument not allowed, it will be overridden.utimeoutuoutputN(
u
ValueErroruPopenuPIPEucommunicateuTimeoutExpiredukilluargsuwaitupolluCalledProcessError(utimeoutu	popenargsukwargsuprocessuoutputu
unused_erruretcode((u//opt/alt/python33/lib64/python3.3/subprocess.pyucheck_output's"


















!
c
CsG
g}
d}x+
|D]#
}g}|
r5|
j
d
�

nd
|kpQd|kpQ|}|rj|
j
d�

nx�|D]�}|dkr�|j
|�

qq|dkr�|
j
dt|�
d�

g}|
j
d�

qq|r�|
j|�

g}n|
j
|�

qqW|r
|
j|�

n|r|
j|�

|
j
d�

qqWdj|
�
S(	u�
    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.
    u
 u
	u
"u
\iu\"uF(uFalseuappendulenuextendujoin(usequresultu	needquoteuargubs_bufu
c((u//opt/alt/python33/lib64/python3.3/subprocess.pyulist2cmdlineQs4














	




ulist2cmdlinec
Cs�y(t|d
ddddt�
}
d}Wn7tk
ra
}
z|j}
|j}WYdd}~Xn
X|
d	d�dkr�|
dd
�}
n||
fS(u�Return (status, output) of executing cmd in a shell.

    Execute the string 'cmd' in a shell with os.popen() and return a 2-tuple
    (status, output).  cmd is actually run as '{ cmd ; } 2>&1', so that the
    returned output will contain output or error messages.  A trailing newline
    is stripped from the output.  The exit status for the command can be
    interpreted according to the rules for the C function wait().  Example:

    >>> import subprocess
    >>> subprocess.getstatusoutput('ls /bin/ls')
    (0, '/bin/ls')
    >>> subprocess.getstatusoutput('cat /bin/junk')
    (256, 'cat: /bin/junk: No such file or directory')
    >>> subprocess.getstatusoutput('/bin/junk')
    (256, 'sh: /bin/junk: not found')
    ushelluuniversal_newlinesustderriNi
u

Ti����i����(ucheck_outputuTrueuSTDOUTuCalledProcessErroruoutputu
returncode(ucmdudataustatusuex((u//opt/alt/python33/lib64/python3.3/subprocess.pyugetstatusoutput�s




	



c

Cst|�
d
S(u%
Return output (stdout or stderr) of executing cmd in a shell.

    Like getstatusoutput(), except the exit status is ignored and the return
    value is a string containing the command's output.  Example:

    >>> import subprocess
    >>> subprocess.getoutput('ls /bin/ls')
    '/bin/ls'
    i
(
ugetstatusoutput(
ucmd((u//opt/alt/python33/lib64/python3.3/subprocess.pyu	getoutput�s
c

BsQ|EeZ
dZdAZdBd@d@d@d@d@edAd@d@dAd@ddCdAfdd�Zdd�Z	dd�Z
d	d
�Zej
dd�
Zd
d�Zd@d@dd�Zdd�Zdd�Zdd�Zerl
dd�Zdd�Zdd�Zdd�Zd@ejejejdd �Zd@d@d!d"�Zd#d$�Zd%d&�Z d'd(�Z!d)d*�Z"e"Z#n�d+d�Zd,d-�Z$d.d�Ze%j&e%j'e%j(e%j)d/d0�Z*d@e%j+e%j,e%j-e.j/d1d �Zd2d3�Z0d@d@d4d"�Zd5d&�Z d6d7�Z1d8d9�Z2d:d;�Z3d<d(�Z!d=d*�Z"d>d?�Z#d@S(DuPopeni
icCsjt�
d
|_d|_|d
kr.d}nt|t�sLtd�
�
ntr�|d
k	rmt	d�
�
n|d
k	p�|d
k	p�|d
k	}|t
kr�|r�d}q�d}qD
|rD
|rD
t	d�
�
qD
nq|t
kr�d}n|r
|r
tj
dt�
d}n|
d
k	r)
t	d�
�
n|dkrD
t	d�
�
n|
|_d
|_d
|_d
|_d
|_d
|_||_|j|||�\}}}}}}tr(|dkr�
tj|j�d�}n|dkr�
tj|j�d�}n|dkr(tj|j�d�}q(n|dkrstj|d	|�|_|rstj|jd
d�

|_qsn|dkr�tj|d|�|_|r�tj|j�
|_q�n|dkr�tj|d|�|_|r�tj|j�
|_q�nd|_yD|j|
|||||
||
||	||||||||�
Wn



xLtd
|j|j|jf�D])}y|j �
Wqrt!k
r�


YqrXqrW|js^g}|t"kr�|j#|�

n|t"kr�|j#|�

n|t"kr|j#|�

nt$|d�r$|j#|j%�

nx7|D],}yt&j |�

Wq+t!k
rV


Yq+Xq+Wn�Yn
Xd
S(uCreate new Popen instance.i
ubufsize must be an integeru0preexec_fn is not supported on Windows platformsuSclose_fds is not supported on Windows platforms if you redirect stdin/stdout/stderrupass_fds overriding close_fds.u2startupinfo is only supported on Windows platformsiu4creationflags is only supported on Windows platformsuwbu
write_throughurbu_devnullNFi����Ti����i����i����i����i����i����('u_cleanupuNoneu_inputuFalseu_communication_startedu
isinstanceuintu	TypeErroru	mswindowsu
ValueErroru_PLATFORM_DEFAULT_CLOSE_FDSuTrueuwarningsuwarnuRuntimeWarninguargsustdinustdoutustderrupidu
returncodeuuniversal_newlinesu_get_handlesumsvcrtuopen_osfhandleuDetachuiouopenu
TextIOWrapperu_closed_child_pipe_fdsu_execute_childufilterucloseuEnvironmentErroruPIPEuappenduhasattru_devnulluos(uselfuargsubufsizeu
executableustdinustdoutustderru
preexec_fnu	close_fdsushellucwduenvuuniversal_newlinesustartupinfou
creationflagsurestore_signalsustart_new_sessionupass_fdsu
any_stdio_setup2creadup2cwriteuc2preaduc2pwriteuerrreaduerrwriteu
futo_closeufd((u//opt/alt/python33/lib64/python3.3/subprocess.pyu__init__�s�	
	

	







		



	



	


	
	
	
	
	
	
	'








!







	


	
	




(




		















uPopen.__init__cCs+|
j|�
}
|
j
d
d�j
dd�S(Nu
u

u

(udecodeureplace(uselfudatauencoding((u//opt/alt/python33/lib64/python3.3/subprocess.pyu_translate_newlinesOs

uPopen._translate_newlinesc


Cs|S(
N((
uself((u//opt/alt/python33/lib64/python3.3/subprocess.pyu	__enter__Ss
uPopen.__enter__c
CsY|jr|jj
�
n|jr2|jj
�
n|jrK|jj
�
n|j�
dS(
N(ustdoutucloseustderrustdinuwait(uselfutypeuvalueu	traceback((u//opt/alt/python33/lib64/python3.3/subprocess.pyu__exit__Vs
	

	

	
uPopen.__exit__cCsL|js
dS|j
d
|
�

|jdkrHtdk	rHtj|�

ndS(Nu
_deadstate(u_child_createdu_internal_pollu
returncodeuNoneu_activeuappend(uselfu_maxsize((u//opt/alt/python33/lib64/python3.3/subprocess.pyu__del__`s

	
u
Popen.__del__c

Cs4t|d
�s-t
jt
jt
j�|_n|jS(Nu_devnull(uhasattruosuopenudevnulluO_RDWRu_devnull(
uself((u//opt/alt/python33/lib64/python3.3/subprocess.pyu_get_devnulljs


uPopen._get_devnullcCs�
|jr|
rt
d
�
�
n|dkrR
|jrR
|j|j|jgjd�
dkrR
d}d}|jr�|
r�y|jj|
�

Wq�tk
r�
}
z/|j	t	j
kr�|j	t	jkr��nWYdd}~Xq�Xn|jj�
nV|jr
t
|jj�
}|jj�
n+|jrE
t
|jj�
}|jj�
n|j�
ni|dk	rn
t�|}nd}z|j|
||�\}}Wdd|_X|jd|j|�
�
}||fS(uc
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
        bytes to be sent to the child process, or None, if no data
        should be sent to the child.

        communicate() returns a tuple (stdout, stderr).u.Cannot send input after starting communicationiNutimeoutT(u_communication_startedu
ValueErroruNoneustdinustdoutustderrucountuwriteuIOErroruerrnouEPIPEuEINVALucloseu_eintr_retry_callureaduwaitu_timeu_communicateuTrueu_remaining_time(uselfuinpututimeoutustdoutustderru
euendtimeusts((u//opt/alt/python33/lib64/python3.3/subprocess.pyucommunicateos:	

'


	




$


	


	






uPopen.communicatec


Cs
|j�S(
N(
u_internal_poll(
uself((u//opt/alt/python33/lib64/python3.3/subprocess.pyupoll�s
u
Popen.pollcCs|
d
krd
S|
t
�Sd
S(u5Convenience for _communicate when computing timeouts.N(uNoneu_time(uselfuendtime((u//opt/alt/python33/lib64/python3.3/subprocess.pyu_remaining_time�s
uPopen._remaining_timecCs8|
d
krd
St
�|
kr4t|j|��
nd
S(u2Convenience for checking if a timeout has expired.N(uNoneu_timeuTimeoutExpireduargs(uselfuendtimeuorig_timeout((u//opt/alt/python33/lib64/python3.3/subprocess.pyu_check_timeout�s


uPopen._check_timeoutcCs�|
dkr(|dkr(|dkr(d
Sd
\}}d\}}d\}}	|
dkr�t
jt
j�
}|dkrG
t
jdd�\}}
t|�
}t
j|
�

qG
n�|
tkr�t
jdd�\}}t|�
t|�
}}nZ|
tkr
t	j
|j��
}n6t|
t
�r2
t	j
|
�
}nt	j
|
j��
}|j|�
}|dkr�
t
jt
j�
}|dkrQt
jdd�\}
}t|�
}t
j|
�

qQn�|tkr�
t
jdd�\}}t|�
t|�
}}nZ|tkrt	j
|j��
}n6t|t
�r<t	j
|�
}nt	j
|j��
}|j|�
}|dkr�t
jt
j�
}	|	dkrpt
jdd�\}
}	t|	�
}	t
j|
�

qpn�|tkr
t
jdd�\}}	t|�
t|	�
}}	no|tkr|}	nZ|tkr:t	j
|j��
}	n6t|t
�r[t	j
|�
}	nt	j
|j��
}	|j|	�
}	||||||	fS(u|Construct and return tuple with IO objects:
            p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite
            i
iNi����i����i����i����i����i����(i����i����i����i����i����i����i����i����(i����i����i����i����(i����i����i����i����(i����i����(uNoneu_winapiuGetStdHandleuSTD_INPUT_HANDLEu
CreatePipeuHandleuCloseHandleuPIPEuDEVNULLumsvcrtu
get_osfhandleu_get_devnullu
isinstanceuintufilenou_make_inheritableuSTD_OUTPUT_HANDLEuSTD_ERROR_HANDLEuSTDOUT(uselfustdinustdoutustderrup2creadup2cwriteuc2preaduc2pwriteuerrreaduerrwriteu
_((u//opt/alt/python33/lib64/python3.3/subprocess.pyu_get_handles�sn$






































	






uPopen._get_handlescCs7tj
tj�|
tj�d
dtj�}t|�
S(u2Return a duplicate of handle, which is inheritableii
(u_winapiuDuplicateHandleuGetCurrentProcessuDUPLICATE_SAME_ACCESSuHandle(uselfuhandleu
h((u//opt/alt/python33/lib64/python3.3/subprocess.pyu_make_inheritable
s




uPopen._make_inheritablec
Cs�tj
jtj
jtjd
�
�
d�}
tj
j|
�
s�tj
jtj
jtj�
d�}
tj
j|
�
s�t	d�
�
q�n|
S(u,Find and return absolut path to w9xpopen.exeiuw9xpopen.exeuZCannot locate w9xpopen.exe, which is needed for Popen to work with your shell or platform.(
uosupathujoinudirnameu_winapiuGetModuleFileNameuexistsusysubase_exec_prefixuRuntimeError(uselfuw9xpopen((u//opt/alt/python33/lib64/python3.3/subprocess.pyu_find_w9xpopen
s	

	

	

uPopen._find_w9xpopencCsDt|
t
�st|
�
}
n|dkr6t�}nd
|||fkr{|jtjO_||_||_	||_
n|
r%
|jtjO_tj|_
tjjdd�}dj||
�}
tj�dks�tjj|�
j�dkr%
|j�}d||
f}
|	tjO}	q%
nz|y>tj||
ddt|�
|	|||�	\}}}}Wn7tjk
r�

}
zt|j��
WYdd}~Xn
XWd|dkr�
|j�
n|dkr�
|j�
n|d
kr�
|j�
nt|d	�rtj |j!�

nXd|_#t$|�
|_%||_&tj'|�

dS(u$Execute program (MS Windows version)i
uCOMSPECucmd.exeu
{} /c "{}"lucommand.comu"%s" %sNu_devnulli����i����i����i����T((u
isinstanceustrulist2cmdlineuNoneuSTARTUPINFOudwFlagsu_winapiuSTARTF_USESTDHANDLESu	hStdInputu
hStdOutputu	hStdErroruSTARTF_USESHOWWINDOWuSW_HIDEuwShowWindowuosuenvironugetuformatu
GetVersionupathubasenameuloweru_find_w9xpopenuCREATE_NEW_CONSOLEu
CreateProcessuintu
pywintypesuerroruWindowsErroruargsuCloseuhasattrucloseu_devnulluTrueu_child_createduHandleu_handleupiduCloseHandle(uselfuargsu
executableu
preexec_fnu	close_fdsupass_fdsucwduenvustartupinfou
creationflagsushellup2creadup2cwriteuc2preaduc2pwriteuerrreaduerrwriteuunused_restore_signalsuunused_start_new_sessionucomspecuw9xpopenuhpuhtupidutidu
e((u//opt/alt/python33/lib64/python3.3/subprocess.pyu_execute_childsR




	
	















&









	

	
uPopen._execute_childcCsF|jdkr?||jd
�|kr?||j�
|_q?n|jS(u�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.

            iN(u
returncodeuNoneu_handle(uselfu
_deadstateu_WaitForSingleObjectu_WAIT_OBJECT_0u_GetExitCodeProcess((u//opt/alt/python33/lib64/python3.3/subprocess.pyu_internal_pollms


uPopen._internal_pollcCs�|dk	r|j
|�
}
n|
dkr6tj}nt|
d
�
}|jdkr�tj|j|�}|tjkr�t	|j
|
��
ntj|j�
|_n|jS(uOWait for child process to terminate.  Returns returncode
            attribute.i�N(uNoneu_remaining_timeu_winapiuINFINITEuintu
returncodeuWaitForSingleObjectu_handleuWAIT_TIMEOUTuTimeoutExpireduargsuGetExitCodeProcess(uselfutimeoutuendtimeutimeout_millisuresult((u//opt/alt/python33/lib64/python3.3/subprocess.pyuwait~s





	



u
Popen.waitcCs!|j|
j
��

|
j�
dS(
N(uappendureaduclose(uselfufhubuffer((u//opt/alt/python33/lib64/python3.3/subprocess.pyu
_readerthread�s

uPopen._readerthreadcCs�|jrht
|d
�rhg|_tjd|jd|j|jf�|_d|j_|jj	�
n|j
r�t
|d�r�g|_tjd|jd|j
|jf�|_d|j_|jj	�
n|j
rs
|
dk	rc
y|j
j|
�

Wqc
tk
r_

}
zD|jtjkr#
n*|jtjkrJ
|j�dk	rJ
n�WYdd}~Xqc
Xn|j
j�
n|jdk	r�
|jj|j|�
�

|jj�r�
t|j|��
q�
n|j
dk	r|jj|j|�
�

|jj�rt|j|��
qnd}d}|jr?|j}|jj�
n|j
ra|j}|j
j�
n|dk	rz|d}n|dk	r�|d}n||fS(Nu_stdout_buffutargetuargsu_stderr_buffiT(ustdoutuhasattru_stdout_buffu	threadinguThreadu
_readerthreadu
stdout_threaduTrueudaemonustartustderru_stderr_buffu
stderr_threadustdinuNoneuwriteuIOErroruerrnouEPIPEuEINVALupollucloseujoinu_remaining_timeuis_aliveuTimeoutExpireduargs(uselfuinputuendtimeuorig_timeoutu
eustdoutustderr((u//opt/alt/python33/lib64/python3.3/subprocess.pyu_communicate�sZ
	




	


	
















	
	

	
	





uPopen._communicatecCs�|
tj
kr|j�
ne|
tjkrDtj|jtj�
n=|
tjkrltj|jtj�
ntd
j	|
�
�
�
dS(u)Send a signal to the process
            uUnsupported signal: {}N(
usignaluSIGTERMu	terminateuCTRL_C_EVENTuosukillupiduCTRL_BREAK_EVENTu
ValueErroruformat(uselfusig((u//opt/alt/python33/lib64/python3.3/subprocess.pyusend_signal�s





uPopen.send_signalc
Cs`ytj
|jd
�
WnBtk
r[


tj|j�
}
|
tjkrN�n|
|_Yn
XdS(u#Terminates the process
            i
N(u_winapiuTerminateProcessu_handleuPermissionErroruGetExitCodeProcessuSTILL_ACTIVEu
returncode(uselfurc((u//opt/alt/python33/lib64/python3.3/subprocess.pyu	terminate�s





uPopen.terminatec
Cs�
d\}}d\}}d
\}}	|
dkr3n]|
t
krQt�\}}n?|
tkrl|j�}n$t|
t�r�|
}n|
j�}|dkr�n]|t
kr�t�\}}n?|tkr�|j�}n$t|t�r�|}n|j�}|dkr
nr|t
kr)
t�\}}	nT|tkr>
|}	n?|tkrY
|j�}	n$t|t�rq
|}	n|j�}	||||||	fS(u|Construct and return tuple with IO objects:
            p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite
            i
i����i����(i����i����i����i����(i����i����i����i����(i����i����N(	uNoneuPIPEu_create_pipeuDEVNULLu_get_devnullu
isinstanceuintufilenouSTDOUT(
uselfustdinustdoutustderrup2creadup2cwriteuc2preaduc2pwriteuerrreaduerrwrite((u//opt/alt/python33/lib64/python3.3/subprocess.pyu_get_handles�sF








	






	




	



	

cCsid
}x=t|
�
D]/}||krt
j||�
|d}qqW|tk
ret
j|t�
ndS(Nii
(usorteduosu
closerangeuMAXFD(uselfufds_to_keepustart_fdufd((u//opt/alt/python33/lib64/python3.3/subprocess.pyu
_close_fds)s






uPopen._close_fdsc%/s�t|
t
tf�r!|
g
}
nt|
�
}
|
rYd
dg|
}
�rY�|
d<qYn�dkrr|
d�n�}t�\}}zvzC
|dk	r
g}xk|j�D]T\}}tj|�
}d|kr�t	d�
�
n|j
|dtj|�
�

q�Wnd}tj��
�tjj��
r:
�f
}n(t
�f
dd�tj|�
D�
�
}t|�
}|j|�

tj|
||t|�
|||||
||||||||�|_d|_Wdtj|�

Xt|d	d�}|dkr$|dkr$||kr$tj|�

n|dkrX|
dkrX||krXtj|�

n|dkr�|dkr�||kr�tj|�

n|dk	r�tj|�

nd|_t�}x?ttj|d�}||7}|s�t|�
dkr�Pq�q�Wdtj|�

X|r�yttj|jd�
Wn=tk
rm
}
z|j t j!kr[�nWYdd}~Xn
Xy|j"dd
�\}} }!Wn.t	k
r�


d}d} dt#|�
}!Yn
Xtt$|j%d�
t&�}"|!j%dd�
}!t'|"t�r�| r�t(| d�}#|!dk}$|$r*d}!n|#dkr�tj)|#�
}!|#t j*kr�|$rq|!dt#|�
7}!q�|!dt#|�
7}!q�n|"|#|!��
n|"|!�
�
ndS(uExecute program (POSIX version)u/bin/shu-cis
=u!illegal environment variable namec
3s-|]#}
tj
jtj|
�
��V
qdS(
N(uosupathujoinufsencode(u.0udir(
u
executable(u//opt/alt/python33/lib64/python3.3/subprocess.pyu	<genexpr>ds
u'Popen._execute_child.<locals>.<genexpr>Nu_devnulli
iP�s
:isRuntimeErrors
0sBad exception data from child: uasciiuerrorsu
surrogatepassiunoexecuu: Ti����i����i����i����i����i����(+u
isinstanceustrubytesulistuNoneu_create_pipeuitemsuosufsencodeu
ValueErroruappendupathudirnameutupleu
get_exec_pathusetuaddu_posixsubprocessu	fork_execusortedupiduTrueu_child_createducloseugetattru_closed_child_pipe_fdsu	bytearrayu_eintr_retry_callureadulenuwaitpiduOSErroruerrnouECHILDusplitureprubuiltinsudecodeuRuntimeErroru
issubclassuintustrerroruENOENT(%uselfuargsu
executableu
preexec_fnu	close_fdsupass_fdsucwduenvustartupinfou
creationflagsushellup2creadup2cwriteuc2preaduc2pwriteuerrreaduerrwriteurestore_signalsustart_new_sessionuorig_executableuerrpipe_readu
errpipe_writeuenv_listu
ku
vuexecutable_listufds_to_keepu
devnull_fduerrpipe_dataupartu
euexception_nameu	hex_errnouerr_msguchild_exception_typeu	errno_numuchild_exec_never_called((
u
executableu//opt/alt/python33/lib64/python3.3/subprocess.pyu_execute_child3s�	














%

















$

$

$


		




















	





	





cCsM||
�
r||
�
|_n*||
�
r=||
�
|_nt
d
�
�
dS(NuUnknown child exit status!(u
returncodeuRuntimeError(uselfustsu_WIFSIGNALEDu	_WTERMSIGu
_WIFEXITEDu_WEXITSTATUS((u//opt/alt/python33/lib64/python3.3/subprocess.pyu_handle_exitstatus�s



uPopen._handle_exitstatusc	Cs�|jdkr�y;||j|�\}}||jkrI|j|�

nWq�|k
r�
}
z8|
dk	rw|
|_n|j|kr�d
|_nWYdd}~Xq�Xn|jS(u�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).

            iN(u
returncodeuNoneupidu_handle_exitstatusuerrno(	uselfu
_deadstateu_waitpidu_WNOHANGu	_os_erroru_ECHILDupidustsu
e((u//opt/alt/python33/lib64/python3.3/subprocess.pyu_internal_poll�s	







"
cCs{y"tt
j|j|
�\}}WnLtk
rp
}
z,|jtjkrO�n|j}d
}WYdd}~Xn
X||fS(Ni(u_eintr_retry_calluosuwaitpidupiduOSErroruerrnouECHILD(uselfu
wait_flagsupidustsu
e((u//opt/alt/python33/lib64/python3.3/subprocess.pyu	_try_wait�s

"


	

uPopen._try_waitcCsb
|jdk	r|jS|dk	s.|
dk	rk|dkrJt�|
}qk|
dkrk|j|�
}
qkn|dk	r
d
}x�|jtj�
\}}||jkr�|j|�

Pn|j|�
}|dk
r�t	|j
|
��
nt|d|d�}tj
|�

q�nJxG|jdkrZ
|jd�
\}}||jkr
|j|�

q
q
W|jS(uOWait for child process to terminate.  Returns returncode
            attribute.g����Mb@?iig�������?N(u
returncodeuNoneu_timeu_remaining_timeu	_try_waituosuWNOHANGupidu_handle_exitstatusuTimeoutExpireduargsuminutimeusleep(uselfutimeoutuendtimeudelayupidustsu	remaining((u//opt/alt/python33/lib64/python3.3/subprocess.pyuwait�s0

















cCs1
|jr9|j
r9|jj�
|
s9|jj�
q9ntr]|j|
||�\}}n|j|
||�\}}|jd
|j|�
�

|dk	r�dj
|�
}n|dk	r�dj
|�
}n|jr'
|dk	r�|j||j
j�}n|dk	r'
|j||jj�}q'
n||fS(Nutimeouts(ustdinu_communication_starteduflushucloseu	_has_pollu_communicate_with_pollu_communicate_with_selectuwaitu_remaining_timeuNoneujoinuuniversal_newlinesu_translate_newlinesustdoutuencodingustderr(uselfuinputuendtimeuorig_timeoutustdoutustderr((u//opt/alt/python33/lib64/python3.3/subprocess.pyu_communicates,









	

	


	
cCsd|jr`|j
dkr`d
|_|
|_
|jr`|
dk	r`|j
j|jj�
|_
q`ndS(Ni(ustdinu_inputuNoneu
_input_offsetuuniversal_newlinesuencodeuencoding(uselfuinput((u//opt/alt/python33/lib64/python3.3/subprocess.pyu_save_input2s

	
	

uPopen._save_inputc!sSd}d}�
j
s!i�
_ntj����
fd
d�}��
fdd�}�
jr||
r||�
jtj�
n�
j
s�i�
_�
jr�g�
j�
jj	�<n�
j
r�g�
j�
j
j	�<q�ntjtjB}�
jr
|�
j|�
�
j�
jj	�}n�
j
rI
|�
j
|�
�
j�
j
j	�}n�
j
|
�

�
jrq
t�
j�
}	nx�
�
jrH�
j|�
}
|
dk	r�
|
dkr�
t�
j|��
ny�j|
�
}WnGtjk
r
}
z$|jdtjkrwt
n�WYdd}~Xn
X�
j||�
x
|D]
\}
}|tj@r�|	�
j�
jt�}y�
jtj|
|�7_WnGtk
r�
}
z'|jtjkr�||
�

n�WYdd}~XqAX�
jt�
j�
krA||
�

qAq-||@r7tj|
d�}|s ||
�

n�
j|
j|�

q-||
�

q-Wqt
W||fS(Ncs-�j|j
�|
�
|�
j|j
�<dS(
N(uregisterufilenou_fd2file(ufile_obju	eventmask(upolleruself(u//opt/alt/python33/lib64/python3.3/subprocess.pyuregister_and_appendEs

u9Popen._communicate_with_poll.<locals>.register_and_appendc

s2�j|�

�
j
|j�
�
j
j|�

dS(
N(u
unregisteru_fd2fileucloseupop(
ufd(upolleruself(u//opt/alt/python33/lib64/python3.3/subprocess.pyuclose_unregister_and_removeIs



uAPopen._communicate_with_poll.<locals>.close_unregister_and_removeii�( uNoneu_communication_startedu_fd2fileuselectupollustdinuPOLLOUTu
_fd2outputustdoutufilenoustderruPOLLINuPOLLPRIu_save_inputu_inputu
memoryviewu_remaining_timeuTimeoutExpireduargsuerroruerrnouEINTRu_check_timeoutu
_input_offsetu	_PIPE_BUFuosuwriteuOSErroruEPIPEulenureaduappend(uselfuinputuendtimeuorig_timeoutustdoutustderruregister_and_appenduclose_unregister_and_removeuselect_POLLIN_POLLPRIu
input_viewutimeoutureadyu
eufdumodeuchunkudata((upolleruselfu//opt/alt/python33/lib64/python3.3/subprocess.pyu_communicate_with_poll=sn

	


	
	
	

	

	


	


	













	














uPopen._communicate_with_pollc$Cs�|js�g|_
g|_|jr@|
r@|jj|j�

n|jr_|j
j|j�

n|jr�|j
j|j�

q�n|j|
�

d}d}|jr�|js�g|_	n|j	}n|jr�|js�g|_
n|j
}nx�|j
s
|jr�|j|�
}|dk	r?
|d
kr?
t|j
|��
ny+tj|j
|jg|�\}}}	WnGtjk
r�

}

z$|
j
d
tjkr�
w�n�WYdd}
~
Xn
X|p�
|p�
|	s�
t|j
|��
n|j||�
|j|kr�|j|j|jt�}ytj|jj�|�}Wn]tk
r�
}

z=|
jtjkr�|jj�
|jj|j�

n�WYdd}
~
Xq�X|j|7_|jt|j�
kr�|jj�
|jj|j�

q�n|j|krFtj|jj�d�}
|
s6|jj�
|j
j|j�

n|j|
�

n|j|kr�tj|jj�d�}
|
s�|jj�
|j
j|j�

n|j|
�

q�q�W||fS(Nii(u_communication_startedu	_read_setu
_write_setustdinuappendustdoutustderru_save_inputuNoneu_stdout_buffu_stderr_buffu_remaining_timeuTimeoutExpireduargsuselectuerroruerrnouEINTRu_check_timeoutu_inputu
_input_offsetu	_PIPE_BUFuosuwriteufilenouOSErroruEPIPEucloseuremoveulenuread(uselfuinputuendtimeuorig_timeoutustdoutustderrutimeouturlistuwlistuxlistu
euchunku
bytes_writtenudata((u//opt/alt/python33/lib64/python3.3/subprocess.pyu_communicate_with_select�sz
	
	
	


	

	


	
	


	
	




































uPopen._communicate_with_selectcCstj
|j|
�
d
S(u)Send a signal to the process
            N(uosukillupid(uselfusig((u//opt/alt/python33/lib64/python3.3/subprocess.pyusend_signal�sc

Cs|jt
j�

d
S(u/Terminate the process with SIGTERM
            N(usend_signalusignaluSIGTERM(
uself((u//opt/alt/python33/lib64/python3.3/subprocess.pyu	terminate�sc

Cs|jt
j�

d
S(u*Kill the process with SIGKILL
            N(usend_signalusignaluSIGKILL(
uself((u//opt/alt/python33/lib64/python3.3/subprocess.pyukill�su
Popen.killNFi����T(4u__name__u
__module__u__qualname__uFalseu_child_createduNoneu_PLATFORM_DEFAULT_CLOSE_FDSuTrueu__init__u_translate_newlinesu	__enter__u__exit__usysumaxsizeu__del__u_get_devnullucommunicateupollu_remaining_timeu_check_timeoutu	mswindowsu_get_handlesu_make_inheritableu_find_w9xpopenu_execute_childu_winapiuWaitForSingleObjectu
WAIT_OBJECT_0uGetExitCodeProcessu_internal_polluwaitu
_readerthreadu_communicateusend_signalu	terminateukillu
_close_fdsuosuWIFSIGNALEDuWTERMSIGu	WIFEXITEDuWEXITSTATUSu_handle_exitstatusuwaitpiduWNOHANGuerroruerrnouECHILDu	_try_waitu_save_inputu_communicate_with_pollu_communicate_with_select(
u
__locals__((u//opt/alt/python33/lib64/python3.3/subprocess.pyuPopen�sb
	




�

2H	R


B
	3
}

	
'$RRi����i����i����(@u__doc__usysuplatformu	mswindowsuiouosutimeu	tracebackugcusignalubuiltinsuwarningsuerrnou	monotonicu_timeuImportErroru	ExceptionuSubprocessErroruCalledProcessErroruTimeoutExpiredu	threadingumsvcrtu_winapiuSTARTUPINFOu
pywintypesuselectuhasattru	_has_pollu_posixsubprocessucloexec_pipeu_create_pipeugetattru	_PIPE_BUFu__all__uCREATE_NEW_CONSOLEuCREATE_NEW_PROCESS_GROUPuSTD_INPUT_HANDLEuSTD_OUTPUT_HANDLEuSTD_ERROR_HANDLEuSW_HIDEuSTARTF_USESTDHANDLESuSTARTF_USESHOWWINDOWuextenduintuHandleusysconfuMAXFDu_activeu_cleanupuPIPEuSTDOUTuDEVNULLu_eintr_retry_callu_args_from_interpreter_flagsuNoneucallu
check_callucheck_outputulist2cmdlineugetstatusoutputu	getoutputuobjectu_PLATFORM_DEFAULT_CLOSE_FDSuPopen(((u//opt/alt/python33/lib64/python3.3/subprocess.pyu<module>T
sr




















	

:








*I