home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_2810 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  17.6 KB  |  763 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (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.             
  488.             try:
  489.                 
  490.                 try:
  491.                     self._set_cloexec_flag(errpipe_write)
  492.                     gc_was_enabled = gc.isenabled()
  493.                     gc.disable()
  494.                     
  495.                     try:
  496.                         self.pid = os.fork()
  497.                     except:
  498.                         if gc_was_enabled:
  499.                             gc.enable()
  500.                         
  501.                         raise 
  502.  
  503.                     self._child_created = True
  504.                     if self.pid == 0:
  505.                         
  506.                         try:
  507.                             if p2cwrite is not None:
  508.                                 os.close(p2cwrite)
  509.                             
  510.                             if c2pread is not None:
  511.                                 os.close(c2pread)
  512.                             
  513.                             if errread is not None:
  514.                                 os.close(errread)
  515.                             
  516.                             os.close(errpipe_read)
  517.                             if p2cread is not None:
  518.                                 os.dup2(p2cread, 0)
  519.                             
  520.                             if c2pwrite is not None:
  521.                                 os.dup2(c2pwrite, 1)
  522.                             
  523.                             if errwrite is not None:
  524.                                 os.dup2(errwrite, 2)
  525.                             
  526.                             if p2cread is not None and p2cread not in (0,):
  527.                                 os.close(p2cread)
  528.                             
  529.                             if c2pwrite is not None and c2pwrite not in (p2cread, 1):
  530.                                 os.close(c2pwrite)
  531.                             
  532.                             if errwrite is not None and errwrite not in (p2cread, c2pwrite, 2):
  533.                                 os.close(errwrite)
  534.                             
  535.                             if close_fds:
  536.                                 self._close_fds(but = errpipe_write)
  537.                             
  538.                             if cwd is not None:
  539.                                 os.chdir(cwd)
  540.                             
  541.                             if preexec_fn:
  542.                                 preexec_fn()
  543.                             
  544.                             if env is None:
  545.                                 os.execvp(executable, args)
  546.                             else:
  547.                                 os.execvpe(executable, args, env)
  548.                         except:
  549.                             (exc_type, exc_value, tb) = sys.exc_info()
  550.                             exc_lines = traceback.format_exception(exc_type, exc_value, tb)
  551.                             exc_value.child_traceback = ''.join(exc_lines)
  552.                             os.write(errpipe_write, pickle.dumps(exc_value))
  553.  
  554.                         os._exit(255)
  555.                     
  556.                     if gc_was_enabled:
  557.                         gc.enable()
  558.                 finally:
  559.                     os.close(errpipe_write)
  560.  
  561.                 if p2cread is not None and p2cwrite is not None:
  562.                     os.close(p2cread)
  563.                 
  564.                 if c2pwrite is not None and c2pread is not None:
  565.                     os.close(c2pwrite)
  566.                 
  567.                 if errwrite is not None and errread is not None:
  568.                     os.close(errwrite)
  569.                 
  570.                 data = os.read(errpipe_read, 1048576)
  571.             finally:
  572.                 os.close(errpipe_read)
  573.  
  574.             if data != '':
  575.                 os.waitpid(self.pid, 0)
  576.                 child_exception = pickle.loads(data)
  577.                 for fd in (p2cwrite, c2pread, errread):
  578.                     if fd is not None:
  579.                         os.close(fd)
  580.                         continue
  581.                 
  582.                 raise child_exception
  583.             data != ''
  584.  
  585.         
  586.         def _handle_exitstatus(self, sts):
  587.             if os.WIFSIGNALED(sts):
  588.                 self.returncode = -os.WTERMSIG(sts)
  589.             elif os.WIFEXITED(sts):
  590.                 self.returncode = os.WEXITSTATUS(sts)
  591.             else:
  592.                 raise RuntimeError('Unknown child exit status!')
  593.             return os.WIFSIGNALED(sts)
  594.  
  595.         
  596.         def _internal_poll(self, _deadstate = None):
  597.             if self.returncode is None:
  598.                 
  599.                 try:
  600.                     (pid, sts) = os.waitpid(self.pid, os.WNOHANG)
  601.                     if pid == self.pid:
  602.                         self._handle_exitstatus(sts)
  603.                 except os.error:
  604.                     if _deadstate is not None:
  605.                         self.returncode = _deadstate
  606.                     
  607.                 except:
  608.                     _deadstate is not None
  609.                 
  610.  
  611.             None<EXCEPTION MATCH>os.error
  612.             return self.returncode
  613.  
  614.         
  615.         def wait(self):
  616.             if self.returncode is None:
  617.                 (pid, sts) = os.waitpid(self.pid, 0)
  618.                 self._handle_exitstatus(sts)
  619.             
  620.             return self.returncode
  621.  
  622.         
  623.         def _communicate(self, input):
  624.             read_set = []
  625.             write_set = []
  626.             stdout = None
  627.             stderr = None
  628.             if self.stdin:
  629.                 self.stdin.flush()
  630.                 if input:
  631.                     write_set.append(self.stdin)
  632.                 else:
  633.                     self.stdin.close()
  634.             
  635.             if self.stdout:
  636.                 read_set.append(self.stdout)
  637.                 stdout = []
  638.             
  639.             if self.stderr:
  640.                 read_set.append(self.stderr)
  641.                 stderr = []
  642.             
  643.             input_offset = 0
  644.             while read_set or write_set:
  645.                 
  646.                 try:
  647.                     (rlist, wlist, xlist) = select.select(read_set, write_set, [])
  648.                 except select.error:
  649.                     e = None
  650.                     if e.args[0] == errno.EINTR:
  651.                         continue
  652.                     
  653.                     raise 
  654.  
  655.                 if self.stdin in wlist:
  656.                     chunk = input[input_offset:input_offset + 512]
  657.                     bytes_written = os.write(self.stdin.fileno(), chunk)
  658.                     input_offset += bytes_written
  659.                     if input_offset >= len(input):
  660.                         self.stdin.close()
  661.                         write_set.remove(self.stdin)
  662.                     
  663.                 
  664.                 if self.stdout in rlist:
  665.                     data = os.read(self.stdout.fileno(), 1024)
  666.                     if data == '':
  667.                         self.stdout.close()
  668.                         read_set.remove(self.stdout)
  669.                     
  670.                     stdout.append(data)
  671.                 
  672.                 if self.stderr in rlist:
  673.                     data = os.read(self.stderr.fileno(), 1024)
  674.                     if data == '':
  675.                         self.stderr.close()
  676.                         read_set.remove(self.stderr)
  677.                     
  678.                     stderr.append(data)
  679.                     continue
  680.             if stdout is not None:
  681.                 stdout = ''.join(stdout)
  682.             
  683.             if stderr is not None:
  684.                 stderr = ''.join(stderr)
  685.             
  686.             if self.universal_newlines and hasattr(file, 'newlines'):
  687.                 if stdout:
  688.                     stdout = self._translate_newlines(stdout)
  689.                 
  690.                 if stderr:
  691.                     stderr = self._translate_newlines(stderr)
  692.                 
  693.             
  694.             self.wait()
  695.             return (stdout, stderr)
  696.  
  697.         
  698.         def send_signal(self, sig):
  699.             os.kill(self.pid, sig)
  700.  
  701.         
  702.         def terminate(self):
  703.             self.send_signal(signal.SIGTERM)
  704.  
  705.         
  706.         def kill(self):
  707.             self.send_signal(signal.SIGKILL)
  708.  
  709.  
  710.  
  711. def _demo_posix():
  712.     plist = Popen([
  713.         'ps'], stdout = PIPE).communicate()[0]
  714.     print 'Process list:'
  715.     print plist
  716.     if os.getuid() == 0:
  717.         p = Popen([
  718.             'id'], preexec_fn = (lambda : os.setuid(100)))
  719.         p.wait()
  720.     
  721.     print "Looking for 'hda'..."
  722.     p1 = Popen([
  723.         'dmesg'], stdout = PIPE)
  724.     p2 = Popen([
  725.         'grep',
  726.         'hda'], stdin = p1.stdout, stdout = PIPE)
  727.     print repr(p2.communicate()[0])
  728.     print 
  729.     print 'Trying a weird file...'
  730.     
  731.     try:
  732.         print Popen([
  733.             '/this/path/does/not/exist']).communicate()
  734.     except OSError:
  735.         e = None
  736.         if e.errno == errno.ENOENT:
  737.             print "The file didn't exist.  I thought so..."
  738.             print 'Child traceback:'
  739.             print e.child_traceback
  740.         else:
  741.             print 'Error', e.errno
  742.     except:
  743.         e.errno == errno.ENOENT
  744.  
  745.     print >>sys.stderr, 'Gosh.  No error.'
  746.  
  747.  
  748. def _demo_windows():
  749.     print "Looking for 'PROMPT' in set output..."
  750.     p1 = Popen('set', stdout = PIPE, shell = True)
  751.     p2 = Popen('find "PROMPT"', stdin = p1.stdout, stdout = PIPE)
  752.     print repr(p2.communicate()[0])
  753.     print 'Executing calc...'
  754.     p = Popen('calc')
  755.     p.wait()
  756.  
  757. if __name__ == '__main__':
  758.     if mswindows:
  759.         _demo_windows()
  760.     else:
  761.         _demo_posix()
  762.  
  763.