home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2012 January / maximum-cd-2012-01.iso / DiscContents / digsby_setup.exe / lib / subprocess.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-10-05  |  17.6 KB  |  756 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. import sys
  5. mswindows = sys.platform == 'win32'
  6. import os
  7. import types
  8. import traceback
  9. import gc
  10. import signal
  11.  
  12. class CalledProcessError(Exception):
  13.     
  14.     def __init__(self, returncode, cmd):
  15.         self.returncode = returncode
  16.         self.cmd = cmd
  17.  
  18.     
  19.     def __str__(self):
  20.         return "Command '%s' returned non-zero exit status %d" % (self.cmd, self.returncode)
  21.  
  22.  
  23. if mswindows:
  24.     import threading
  25.     import msvcrt
  26.     from _subprocess import *
  27.     
  28.     class STARTUPINFO:
  29.         dwFlags = 0
  30.         hStdInput = None
  31.         hStdOutput = None
  32.         hStdError = None
  33.         wShowWindow = 0
  34.  
  35.     
  36.     class pywintypes:
  37.         error = IOError
  38.  
  39. else:
  40.     import select
  41.     import errno
  42.     import fcntl
  43.     import pickle
  44. __all__ = [
  45.     'Popen',
  46.     'PIPE',
  47.     'STDOUT',
  48.     'call',
  49.     'check_call',
  50.     'CalledProcessError']
  51.  
  52. try:
  53.     MAXFD = os.sysconf('SC_OPEN_MAX')
  54. except:
  55.     MAXFD = 256
  56.  
  57. _active = []
  58.  
  59. def _cleanup():
  60.     for inst in _active[:]:
  61.         if inst._internal_poll(_deadstate = sys.maxint) >= 0:
  62.             
  63.             try:
  64.                 _active.remove(inst)
  65.             except ValueError:
  66.                 pass
  67.             except:
  68.                 None<EXCEPTION MATCH>ValueError
  69.             
  70.  
  71.         None<EXCEPTION MATCH>ValueError
  72.     
  73.  
  74. PIPE = -1
  75. STDOUT = -2
  76.  
  77. def call(*popenargs, **kwargs):
  78.     return Popen(*popenargs, **kwargs).wait()
  79.  
  80.  
  81. def check_call(*popenargs, **kwargs):
  82.     retcode = call(*popenargs, **kwargs)
  83.     cmd = kwargs.get('args')
  84.     if cmd is None:
  85.         cmd = popenargs[0]
  86.     
  87.     if retcode:
  88.         raise CalledProcessError(retcode, cmd)
  89.     retcode
  90.     return retcode
  91.  
  92.  
  93. def list2cmdline(seq):
  94.     result = []
  95.     needquote = False
  96.     for arg in seq:
  97.         bs_buf = []
  98.         if result:
  99.             result.append(' ')
  100.         
  101.         if not ' ' in arg and '\t' in arg and '|' in arg:
  102.             pass
  103.         needquote = not arg
  104.         if needquote:
  105.             result.append('"')
  106.         
  107.         for c in arg:
  108.             if c == '\\':
  109.                 bs_buf.append(c)
  110.                 continue
  111.             if c == '"':
  112.                 result.append('\\' * len(bs_buf) * 2)
  113.                 bs_buf = []
  114.                 result.append('\\"')
  115.                 continue
  116.             if bs_buf:
  117.                 result.extend(bs_buf)
  118.                 bs_buf = []
  119.             
  120.             result.append(c)
  121.         
  122.         if bs_buf:
  123.             result.extend(bs_buf)
  124.         
  125.         if needquote:
  126.             result.extend(bs_buf)
  127.             result.append('"')
  128.             continue
  129.     
  130.     return ''.join(result)
  131.  
  132.  
  133. class Popen(object):
  134.     
  135.     def __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):
  136.         _cleanup()
  137.         self._child_created = False
  138.         if not isinstance(bufsize, (int, long)):
  139.             raise TypeError('bufsize must be an integer')
  140.         isinstance(bufsize, (int, long))
  141.         if mswindows:
  142.             if preexec_fn is not None:
  143.                 raise ValueError('preexec_fn is not supported on Windows platforms')
  144.             preexec_fn is not None
  145.             if close_fds:
  146.                 if stdin is not None and stdout is not None or stderr is not None:
  147.                     raise ValueError('close_fds is not supported on Windows platforms if you redirect stdin/stdout/stderr')
  148.             stderr is not None
  149.         elif startupinfo is not None:
  150.             raise ValueError('startupinfo is only supported on Windows platforms')
  151.         
  152.         if creationflags != 0:
  153.             raise ValueError('creationflags is only supported on Windows platforms')
  154.         creationflags != 0
  155.         self.stdin = None
  156.         self.stdout = None
  157.         self.stderr = None
  158.         self.pid = None
  159.         self.returncode = None
  160.         self.universal_newlines = universal_newlines
  161.         (p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite) = self._get_handles(stdin, stdout, stderr)
  162.         self._execute_child(args, executable, preexec_fn, close_fds, cwd, env, universal_newlines, startupinfo, creationflags, shell, p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite)
  163.         if mswindows:
  164.             if p2cwrite is not None:
  165.                 p2cwrite = msvcrt.open_osfhandle(p2cwrite.Detach(), 0)
  166.             
  167.             if c2pread is not None:
  168.                 c2pread = msvcrt.open_osfhandle(c2pread.Detach(), 0)
  169.             
  170.             if errread is not None:
  171.                 errread = msvcrt.open_osfhandle(errread.Detach(), 0)
  172.             
  173.         
  174.         if p2cwrite is not None:
  175.             self.stdin = os.fdopen(p2cwrite, 'wb', bufsize)
  176.         
  177.         if c2pread is not None:
  178.             if universal_newlines:
  179.                 self.stdout = os.fdopen(c2pread, 'rU', bufsize)
  180.             else:
  181.                 self.stdout = os.fdopen(c2pread, 'rb', bufsize)
  182.         
  183.         if errread is not None:
  184.             if universal_newlines:
  185.                 self.stderr = os.fdopen(errread, 'rU', bufsize)
  186.             else:
  187.                 self.stderr = os.fdopen(errread, 'rb', bufsize)
  188.         
  189.  
  190.     
  191.     def _translate_newlines(self, data):
  192.         data = data.replace('\r\n', '\n')
  193.         data = data.replace('\r', '\n')
  194.         return data
  195.  
  196.     
  197.     def __del__(self, sys = sys):
  198.         if not self._child_created:
  199.             return None
  200.         self._internal_poll(_deadstate = sys.maxint)
  201.         if self.returncode is None and _active is not None:
  202.             _active.append(self)
  203.         
  204.  
  205.     
  206.     def communicate(self, input = None):
  207.         if [
  208.             self.stdin,
  209.             self.stdout,
  210.             self.stderr].count(None) >= 2:
  211.             stdout = None
  212.             stderr = None
  213.             if self.stdin:
  214.                 if input:
  215.                     self.stdin.write(input)
  216.                 
  217.                 self.stdin.close()
  218.             elif self.stdout:
  219.                 stdout = self.stdout.read()
  220.                 self.stdout.close()
  221.             elif self.stderr:
  222.                 stderr = self.stderr.read()
  223.                 self.stderr.close()
  224.             
  225.             self.wait()
  226.             return (stdout, stderr)
  227.         return self._communicate(input)
  228.  
  229.     
  230.     def poll(self):
  231.         return self._internal_poll()
  232.  
  233.     if mswindows:
  234.         
  235.         def _get_handles(self, stdin, stdout, stderr):
  236.             if stdin is None and stdout is None and stderr is None:
  237.                 return (None, None, None, None, None, None)
  238.             (p2cread, p2cwrite) = (None, None)
  239.             (c2pread, c2pwrite) = (None, None)
  240.             (errread, errwrite) = (None, None)
  241.             if stdin is None:
  242.                 p2cread = GetStdHandle(STD_INPUT_HANDLE)
  243.                 if p2cread is None:
  244.                     (p2cread, _) = CreatePipe(None, 0)
  245.                 
  246.             elif stdin == PIPE:
  247.                 (p2cread, p2cwrite) = CreatePipe(None, 0)
  248.             elif isinstance(stdin, int):
  249.                 p2cread = msvcrt.get_osfhandle(stdin)
  250.             else:
  251.                 p2cread = msvcrt.get_osfhandle(stdin.fileno())
  252.             p2cread = self._make_inheritable(p2cread)
  253.             if stdout is None:
  254.                 c2pwrite = GetStdHandle(STD_OUTPUT_HANDLE)
  255.                 if c2pwrite is None:
  256.                     (_, c2pwrite) = CreatePipe(None, 0)
  257.                 
  258.             elif stdout == PIPE:
  259.                 (c2pread, c2pwrite) = CreatePipe(None, 0)
  260.             elif isinstance(stdout, int):
  261.                 c2pwrite = msvcrt.get_osfhandle(stdout)
  262.             else:
  263.                 c2pwrite = msvcrt.get_osfhandle(stdout.fileno())
  264.             c2pwrite = self._make_inheritable(c2pwrite)
  265.             if stderr is None:
  266.                 errwrite = GetStdHandle(STD_ERROR_HANDLE)
  267.                 if errwrite is None:
  268.                     (_, errwrite) = CreatePipe(None, 0)
  269.                 
  270.             elif stderr == PIPE:
  271.                 (errread, errwrite) = CreatePipe(None, 0)
  272.             elif stderr == STDOUT:
  273.                 errwrite = c2pwrite
  274.             elif isinstance(stderr, int):
  275.                 errwrite = msvcrt.get_osfhandle(stderr)
  276.             else:
  277.                 errwrite = msvcrt.get_osfhandle(stderr.fileno())
  278.             errwrite = self._make_inheritable(errwrite)
  279.             return (p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite)
  280.  
  281.         
  282.         def _make_inheritable(self, handle):
  283.             return DuplicateHandle(GetCurrentProcess(), handle, GetCurrentProcess(), 0, 1, DUPLICATE_SAME_ACCESS)
  284.  
  285.         
  286.         def _find_w9xpopen(self):
  287.             w9xpopen = os.path.join(os.path.dirname(GetModuleFileName(0)), 'w9xpopen.exe')
  288.             if not os.path.exists(w9xpopen):
  289.                 w9xpopen = os.path.join(os.path.dirname(sys.exec_prefix), 'w9xpopen.exe')
  290.                 if not os.path.exists(w9xpopen):
  291.                     raise RuntimeError('Cannot locate w9xpopen.exe, which is needed for Popen to work with your shell or platform.')
  292.                 os.path.exists(w9xpopen)
  293.             
  294.             return w9xpopen
  295.  
  296.         
  297.         def _execute_child(self, args, executable, preexec_fn, close_fds, cwd, env, universal_newlines, startupinfo, creationflags, shell, p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite):
  298.             if not isinstance(args, types.StringTypes):
  299.                 args = list2cmdline(args)
  300.             
  301.             if startupinfo is None:
  302.                 startupinfo = STARTUPINFO()
  303.             
  304.             if None not in (p2cread, c2pwrite, errwrite):
  305.                 startupinfo.dwFlags |= STARTF_USESTDHANDLES
  306.                 startupinfo.hStdInput = p2cread
  307.                 startupinfo.hStdOutput = c2pwrite
  308.                 startupinfo.hStdError = errwrite
  309.             
  310.             if shell:
  311.                 startupinfo.dwFlags |= STARTF_USESHOWWINDOW
  312.                 startupinfo.wShowWindow = SW_HIDE
  313.                 comspec = os.environ.get('COMSPEC', 'cmd.exe')
  314.                 args = comspec + ' /c ' + args
  315.                 if GetVersion() >= 0x80000000L or os.path.basename(comspec).lower() == 'command.com':
  316.                     w9xpopen = self._find_w9xpopen()
  317.                     args = '"%s" %s' % (w9xpopen, args)
  318.                     creationflags |= CREATE_NEW_CONSOLE
  319.                 
  320.             
  321.             
  322.             try:
  323.                 (hp, ht, pid, tid) = CreateProcess(executable, args, None, None, int(not close_fds), creationflags, env, cwd, startupinfo)
  324.             except pywintypes.error:
  325.                 e = None
  326.                 raise WindowsError(*e.args)
  327.  
  328.             self._child_created = True
  329.             self._handle = hp
  330.             self.pid = pid
  331.             ht.Close()
  332.             if p2cread is not None:
  333.                 p2cread.Close()
  334.             
  335.             if c2pwrite is not None:
  336.                 c2pwrite.Close()
  337.             
  338.             if errwrite is not None:
  339.                 errwrite.Close()
  340.             
  341.  
  342.         
  343.         def _internal_poll(self, _deadstate = None):
  344.             if self.returncode is None:
  345.                 if WaitForSingleObject(self._handle, 0) == WAIT_OBJECT_0:
  346.                     self.returncode = GetExitCodeProcess(self._handle)
  347.                 
  348.             
  349.             return self.returncode
  350.  
  351.         
  352.         def wait(self):
  353.             if self.returncode is None:
  354.                 obj = WaitForSingleObject(self._handle, INFINITE)
  355.                 self.returncode = GetExitCodeProcess(self._handle)
  356.             
  357.             return self.returncode
  358.  
  359.         
  360.         def _readerthread(self, fh, buffer):
  361.             buffer.append(fh.read())
  362.  
  363.         
  364.         def _communicate(self, input):
  365.             stdout = None
  366.             stderr = None
  367.             if self.stdout:
  368.                 stdout = []
  369.                 stdout_thread = threading.Thread(target = self._readerthread, args = (self.stdout, stdout))
  370.                 stdout_thread.setDaemon(True)
  371.                 stdout_thread.start()
  372.             
  373.             if self.stderr:
  374.                 stderr = []
  375.                 stderr_thread = threading.Thread(target = self._readerthread, args = (self.stderr, stderr))
  376.                 stderr_thread.setDaemon(True)
  377.                 stderr_thread.start()
  378.             
  379.             if self.stdin:
  380.                 if input is not None:
  381.                     self.stdin.write(input)
  382.                 
  383.                 self.stdin.close()
  384.             
  385.             if self.stdout:
  386.                 stdout_thread.join()
  387.             
  388.             if self.stderr:
  389.                 stderr_thread.join()
  390.             
  391.             if stdout is not None:
  392.                 stdout = stdout[0]
  393.             
  394.             if stderr is not None:
  395.                 stderr = stderr[0]
  396.             
  397.             if self.universal_newlines and hasattr(file, 'newlines'):
  398.                 if stdout:
  399.                     stdout = self._translate_newlines(stdout)
  400.                 
  401.                 if stderr:
  402.                     stderr = self._translate_newlines(stderr)
  403.                 
  404.             
  405.             self.wait()
  406.             return (stdout, stderr)
  407.  
  408.         
  409.         def send_signal(self, sig):
  410.             if sig == signal.SIGTERM:
  411.                 self.terminate()
  412.             else:
  413.                 raise ValueError('Only SIGTERM is supported on Windows')
  414.             return sig == signal.SIGTERM
  415.  
  416.         
  417.         def terminate(self):
  418.             TerminateProcess(self._handle, 1)
  419.  
  420.         kill = terminate
  421.     else:
  422.         
  423.         def _get_handles(self, stdin, stdout, stderr):
  424.             (p2cread, p2cwrite) = (None, None)
  425.             (c2pread, c2pwrite) = (None, None)
  426.             (errread, errwrite) = (None, None)
  427.             if stdin is None:
  428.                 pass
  429.             elif stdin == PIPE:
  430.                 (p2cread, p2cwrite) = os.pipe()
  431.             elif isinstance(stdin, int):
  432.                 p2cread = stdin
  433.             else:
  434.                 p2cread = stdin.fileno()
  435.             if stdout is None:
  436.                 pass
  437.             elif stdout == PIPE:
  438.                 (c2pread, c2pwrite) = os.pipe()
  439.             elif isinstance(stdout, int):
  440.                 c2pwrite = stdout
  441.             else:
  442.                 c2pwrite = stdout.fileno()
  443.             if stderr is None:
  444.                 pass
  445.             elif stderr == PIPE:
  446.                 (errread, errwrite) = os.pipe()
  447.             elif stderr == STDOUT:
  448.                 errwrite = c2pwrite
  449.             elif isinstance(stderr, int):
  450.                 errwrite = stderr
  451.             else:
  452.                 errwrite = stderr.fileno()
  453.             return (p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite)
  454.  
  455.         
  456.         def _set_cloexec_flag(self, fd):
  457.             
  458.             try:
  459.                 cloexec_flag = fcntl.FD_CLOEXEC
  460.             except AttributeError:
  461.                 cloexec_flag = 1
  462.  
  463.             old = fcntl.fcntl(fd, fcntl.F_GETFD)
  464.             fcntl.fcntl(fd, fcntl.F_SETFD, old | cloexec_flag)
  465.  
  466.         
  467.         def _close_fds(self, but):
  468.             os.closerange(3, but)
  469.             os.closerange(but + 1, MAXFD)
  470.  
  471.         
  472.         def _execute_child(self, args, executable, preexec_fn, close_fds, cwd, env, universal_newlines, startupinfo, creationflags, shell, p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite):
  473.             if isinstance(args, types.StringTypes):
  474.                 args = [
  475.                     args]
  476.             else:
  477.                 args = list(args)
  478.             if shell:
  479.                 args = [
  480.                     '/bin/sh',
  481.                     '-c'] + args
  482.             
  483.             if executable is None:
  484.                 executable = args[0]
  485.             
  486.             (errpipe_read, errpipe_write) = os.pipe()
  487.             self._set_cloexec_flag(errpipe_write)
  488.             gc_was_enabled = gc.isenabled()
  489.             gc.disable()
  490.             
  491.             try:
  492.                 self.pid = os.fork()
  493.             except:
  494.                 if gc_was_enabled:
  495.                     gc.enable()
  496.                 
  497.                 raise 
  498.  
  499.             self._child_created = True
  500.             if self.pid == 0:
  501.                 
  502.                 try:
  503.                     if p2cwrite is not None:
  504.                         os.close(p2cwrite)
  505.                     
  506.                     if c2pread is not None:
  507.                         os.close(c2pread)
  508.                     
  509.                     if errread is not None:
  510.                         os.close(errread)
  511.                     
  512.                     os.close(errpipe_read)
  513.                     if p2cread is not None:
  514.                         os.dup2(p2cread, 0)
  515.                     
  516.                     if c2pwrite is not None:
  517.                         os.dup2(c2pwrite, 1)
  518.                     
  519.                     if errwrite is not None:
  520.                         os.dup2(errwrite, 2)
  521.                     
  522.                     if p2cread is not None and p2cread not in (0,):
  523.                         os.close(p2cread)
  524.                     
  525.                     if c2pwrite is not None and c2pwrite not in (p2cread, 1):
  526.                         os.close(c2pwrite)
  527.                     
  528.                     if errwrite is not None and errwrite not in (p2cread, c2pwrite, 2):
  529.                         os.close(errwrite)
  530.                     
  531.                     if close_fds:
  532.                         self._close_fds(but = errpipe_write)
  533.                     
  534.                     if cwd is not None:
  535.                         os.chdir(cwd)
  536.                     
  537.                     if preexec_fn:
  538.                         preexec_fn()
  539.                     
  540.                     if env is None:
  541.                         os.execvp(executable, args)
  542.                     else:
  543.                         os.execvpe(executable, args, env)
  544.                 except:
  545.                     (exc_type, exc_value, tb) = sys.exc_info()
  546.                     exc_lines = traceback.format_exception(exc_type, exc_value, tb)
  547.                     exc_value.child_traceback = ''.join(exc_lines)
  548.                     os.write(errpipe_write, pickle.dumps(exc_value))
  549.  
  550.                 os._exit(255)
  551.             
  552.             if gc_was_enabled:
  553.                 gc.enable()
  554.             
  555.             os.close(errpipe_write)
  556.             if p2cread is not None and p2cwrite is not None:
  557.                 os.close(p2cread)
  558.             
  559.             if c2pwrite is not None and c2pread is not None:
  560.                 os.close(c2pwrite)
  561.             
  562.             if errwrite is not None and errread is not None:
  563.                 os.close(errwrite)
  564.             
  565.             data = os.read(errpipe_read, 1048576)
  566.             os.close(errpipe_read)
  567.             if data != '':
  568.                 os.waitpid(self.pid, 0)
  569.                 child_exception = pickle.loads(data)
  570.                 for fd in (p2cwrite, c2pread, errread):
  571.                     if fd is not None:
  572.                         os.close(fd)
  573.                         continue
  574.                 
  575.                 raise child_exception
  576.             data != ''
  577.  
  578.         
  579.         def _handle_exitstatus(self, sts):
  580.             if os.WIFSIGNALED(sts):
  581.                 self.returncode = -os.WTERMSIG(sts)
  582.             elif os.WIFEXITED(sts):
  583.                 self.returncode = os.WEXITSTATUS(sts)
  584.             else:
  585.                 raise RuntimeError('Unknown child exit status!')
  586.             return os.WIFSIGNALED(sts)
  587.  
  588.         
  589.         def _internal_poll(self, _deadstate = None):
  590.             if self.returncode is None:
  591.                 
  592.                 try:
  593.                     (pid, sts) = os.waitpid(self.pid, os.WNOHANG)
  594.                     if pid == self.pid:
  595.                         self._handle_exitstatus(sts)
  596.                 except os.error:
  597.                     if _deadstate is not None:
  598.                         self.returncode = _deadstate
  599.                     
  600.                 except:
  601.                     _deadstate is not None
  602.                 
  603.  
  604.             None<EXCEPTION MATCH>os.error
  605.             return self.returncode
  606.  
  607.         
  608.         def wait(self):
  609.             if self.returncode is None:
  610.                 (pid, sts) = os.waitpid(self.pid, 0)
  611.                 self._handle_exitstatus(sts)
  612.             
  613.             return self.returncode
  614.  
  615.         
  616.         def _communicate(self, input):
  617.             read_set = []
  618.             write_set = []
  619.             stdout = None
  620.             stderr = None
  621.             if self.stdin:
  622.                 self.stdin.flush()
  623.                 if input:
  624.                     write_set.append(self.stdin)
  625.                 else:
  626.                     self.stdin.close()
  627.             
  628.             if self.stdout:
  629.                 read_set.append(self.stdout)
  630.                 stdout = []
  631.             
  632.             if self.stderr:
  633.                 read_set.append(self.stderr)
  634.                 stderr = []
  635.             
  636.             input_offset = 0
  637.             while read_set or write_set:
  638.                 
  639.                 try:
  640.                     (rlist, wlist, xlist) = select.select(read_set, write_set, [])
  641.                 except select.error:
  642.                     e = None
  643.                     if e.args[0] == errno.EINTR:
  644.                         continue
  645.                     
  646.                     raise 
  647.  
  648.                 if self.stdin in wlist:
  649.                     chunk = input[input_offset:input_offset + 512]
  650.                     bytes_written = os.write(self.stdin.fileno(), chunk)
  651.                     input_offset += bytes_written
  652.                     if input_offset >= len(input):
  653.                         self.stdin.close()
  654.                         write_set.remove(self.stdin)
  655.                     
  656.                 
  657.                 if self.stdout in rlist:
  658.                     data = os.read(self.stdout.fileno(), 1024)
  659.                     if data == '':
  660.                         self.stdout.close()
  661.                         read_set.remove(self.stdout)
  662.                     
  663.                     stdout.append(data)
  664.                 
  665.                 if self.stderr in rlist:
  666.                     data = os.read(self.stderr.fileno(), 1024)
  667.                     if data == '':
  668.                         self.stderr.close()
  669.                         read_set.remove(self.stderr)
  670.                     
  671.                     stderr.append(data)
  672.                     continue
  673.             if stdout is not None:
  674.                 stdout = ''.join(stdout)
  675.             
  676.             if stderr is not None:
  677.                 stderr = ''.join(stderr)
  678.             
  679.             if self.universal_newlines and hasattr(file, 'newlines'):
  680.                 if stdout:
  681.                     stdout = self._translate_newlines(stdout)
  682.                 
  683.                 if stderr:
  684.                     stderr = self._translate_newlines(stderr)
  685.                 
  686.             
  687.             self.wait()
  688.             return (stdout, stderr)
  689.  
  690.         
  691.         def send_signal(self, sig):
  692.             os.kill(self.pid, sig)
  693.  
  694.         
  695.         def terminate(self):
  696.             self.send_signal(signal.SIGTERM)
  697.  
  698.         
  699.         def kill(self):
  700.             self.send_signal(signal.SIGKILL)
  701.  
  702.  
  703.  
  704. def _demo_posix():
  705.     plist = Popen([
  706.         'ps'], stdout = PIPE).communicate()[0]
  707.     print 'Process list:'
  708.     print plist
  709.     if os.getuid() == 0:
  710.         p = Popen([
  711.             'id'], preexec_fn = (lambda : os.setuid(100)))
  712.         p.wait()
  713.     
  714.     print "Looking for 'hda'..."
  715.     p1 = Popen([
  716.         'dmesg'], stdout = PIPE)
  717.     p2 = Popen([
  718.         'grep',
  719.         'hda'], stdin = p1.stdout, stdout = PIPE)
  720.     print repr(p2.communicate()[0])
  721.     print 
  722.     print 'Trying a weird file...'
  723.     
  724.     try:
  725.         print Popen([
  726.             '/this/path/does/not/exist']).communicate()
  727.     except OSError:
  728.         e = None
  729.         if e.errno == errno.ENOENT:
  730.             print "The file didn't exist.  I thought so..."
  731.             print 'Child traceback:'
  732.             print e.child_traceback
  733.         else:
  734.             print 'Error', e.errno
  735.     except:
  736.         e.errno == errno.ENOENT
  737.  
  738.     print >>sys.stderr, 'Gosh.  No error.'
  739.  
  740.  
  741. def _demo_windows():
  742.     print "Looking for 'PROMPT' in set output..."
  743.     p1 = Popen('set', stdout = PIPE, shell = True)
  744.     p2 = Popen('find "PROMPT"', stdin = p1.stdout, stdout = PIPE)
  745.     print repr(p2.communicate()[0])
  746.     print 'Executing calc...'
  747.     p = Popen('calc')
  748.     p.wait()
  749.  
  750. if __name__ == '__main__':
  751.     if mswindows:
  752.         _demo_windows()
  753.     else:
  754.         _demo_posix()
  755.  
  756.