os

Module os |
[hide private]
[frames] | no frames]

# Source Code for Module os

      1  r"""OS routines for Mac, NT, or Posix depending on what system we're on.
      2
      3  This exports:
      4    - all functions from posix, nt, os2, or ce, e.g. unlink, stat, etc.
      5    - os.path is one of the modules posixpath, or ntpath
      6    - os.name is 'posix', 'nt', 'os2', 'ce' or 'riscos'
      7    - os.curdir is a string representing the current directory ('.' or ':')
      8    - os.pardir is a string representing the parent directory ('..' or '::')
      9    - os.sep is the (or a most common) pathname separator ('/' or ':' or '\\')
     10    - os.extsep is the extension separator ('.' or '/')
     11    - os.altsep is the alternate pathname separator (None or '/')
     12    - os.pathsep is the component separator used in $PATH etc
     13    - os.linesep is the line separator in text files ('\r' or '\n' or '\r\n')
     14    - os.defpath is the default search path for executables
     15    - os.devnull is the file path of the null device ('/dev/null', etc.)
     16
     17  Programs that import and use 'os' stand a better chance of being
     18  portable between different platforms.  Of course, they must then
     19  only use functions that are defined by all platforms (e.g., unlink
     20  and opendir), and leave all pathname manipulation to os.path
     21  (e.g., split and join).
     22  """
     23
     24  #'
     25
     26  import sys, errno
     27
     28  _names = sys.builtin_module_names
     29
     30  # Note:  more names are added to __all__ later.
     31  __all__ = ["altsep", "curdir", "pardir", "sep", "extsep", "pathsep", "linesep",
     32             "defpath", "name", "path", "devnull",
     33             "SEEK_SET", "SEEK_CUR", "SEEK_END"]
     34
     35 -def _get_exports_list(module):
     36      try:
     37          return list(module.__all__)
     38      except AttributeError:
     39          return [n for n in dir(module) if n[0] != '_']
     40
     41  if 'posix' in _names:
     42      name = 'posix'
     43      linesep = '\n'
     44      from posix import *
     45      try:
     46          from posix import _exit
     47      except ImportError:
     48          pass
     49      import posixpath as path
     50
     51      import posix
     52      __all__.extend(_get_exports_list(posix))
     53      del posix
     54
     55  elif 'nt' in _names:
     56      name = 'nt'
     57      linesep = '\r\n'
     58      from nt import *
     59      try:
     60          from nt import _exit
     61      except ImportError:
     62          pass
     63      import ntpath as path
     64
     65      import nt
     66      __all__.extend(_get_exports_list(nt))
     67      del nt
     68
     69  elif 'os2' in _names:
     70      name = 'os2'
     71      linesep = '\r\n'
     72      from os2 import *
     73      try:
     74          from os2 import _exit
     75      except ImportError:
     76          pass
     77      if sys.version.find('EMX GCC') == -1:
     78          import ntpath as path
     79      else:
     80          import os2emxpath as path
     81          from _emx_link import link
     82
     83      import os2
     84      __all__.extend(_get_exports_list(os2))
     85      del os2
     86
     87  elif 'ce' in _names:
     88      name = 'ce'
     89      linesep = '\r\n'
     90      from ce import *
     91      try:
     92          from ce import _exit
     93      except ImportError:
     94          pass
     95      # We can use the standard Windows path.
     96      import ntpath as path
     97
     98      import ce
     99      __all__.extend(_get_exports_list(ce))
    100      del ce
    101
    102  elif 'riscos' in _names:
    103      name = 'riscos'
    104      linesep = '\n'
    105      from riscos import *
    106      try:
    107          from riscos import _exit
    108      except ImportError:
    109          pass
    110      import riscospath as path
    111
    112      import riscos
    113      __all__.extend(_get_exports_list(riscos))
    114      del riscos
    115
    116  else:
    117      raise ImportError, 'no os specific module found'
    118
    119  sys.modules['os.path'] = path
    120  from os.path import (curdir, pardir, sep, pathsep, defpath, extsep, altsep,
    121      devnull)
    122
    123  del _names
    124
    125  # Python uses fixed values for the SEEK_ constants; they are mapped
    126  # to native constants if necessary in posixmodule.c
    127  SEEK_SET = 0
    128  SEEK_CUR = 1
    129  SEEK_END = 2
    130
    131  #'
    132
    133  # Super directory utilities.
    134  # (Inspired by Eric Raymond; the doc strings are mostly his)
    135
    136 -def makedirs(name, mode=0777):
    137      """makedirs(path [, mode=0777])
    138
    139      Super-mkdir; create a leaf directory and all intermediate ones.
    140      Works like mkdir, except that any intermediate path segment (not
    141      just the rightmost) will be created if it does not exist.  This is
    142      recursive.
    143
    144      """
    145      head, tail = path.split(name)
    146      if not tail:
    147          head, tail = path.split(head)
    148      if head and tail and not path.exists(head):
    149          try:
    150              makedirs(head, mode)
    151          except OSError, e:
    152              # be happy if someone already created the path
    153              if e.errno != errno.EEXIST:
    154                  raise
    155          if tail == curdir:           # xxx/newdir/. exists if xxx/newdir exists
    156              return
    157      mkdir(name, mode)
    158
    159 -def removedirs(name):
    160      """removedirs(path)
    161
    162      Super-rmdir; remove a leaf directory and all empty intermediate
    163      ones.  Works like rmdir except that, if the leaf directory is
    164      successfully removed, directories corresponding to rightmost path
    165      segments will be pruned away until either the whole path is
    166      consumed or an error occurs.  Errors during this latter phase are
    167      ignored -- they generally mean that a directory was not empty.
    168
    169      """
    170      rmdir(name)
    171      head, tail = path.split(name)
    172      if not tail:
    173          head, tail = path.split(head)
    174      while head and tail:
    175          try:
    176              rmdir(head)
    177          except error:
    178              break
    179          head, tail = path.split(head)
    180
    181 -def renames(old, new):
    182      """renames(old, new)
    183
    184      Super-rename; create directories as necessary and delete any left
    185      empty.  Works like rename, except creation of any intermediate
    186      directories needed to make the new pathname good is attempted
    187      first.  After the rename, directories corresponding to rightmost
    188      path segments of the old name will be pruned way until either the
    189      whole path is consumed or a nonempty directory is found.
    190
    191      Note: this function can fail with the new directory structure made
    192      if you lack permissions needed to unlink the leaf directory or
    193      file.
    194
    195      """
    196      head, tail = path.split(new)
    197      if head and tail and not path.exists(head):
    198          makedirs(head)
    199      rename(old, new)
    200      head, tail = path.split(old)
    201      if head and tail:
    202          try:
    203              removedirs(head)
    204          except error:
    205              pass
    206
    207  __all__.extend(["makedirs", "removedirs", "renames"])
    208
    209 -def walk(top, topdown=True, onerror=None, followlinks=False):
    210      """Directory tree generator.
    211
    212      For each directory in the directory tree rooted at top (including top
    213      itself, but excluding '.' and '..'), yields a 3-tuple
    214
    215          dirpath, dirnames, filenames
    216
    217      dirpath is a string, the path to the directory.  dirnames is a list of
    218      the names of the subdirectories in dirpath (excluding '.' and '..').
    219      filenames is a list of the names of the non-directory files in dirpath.
    220      Note that the names in the lists are just names, with no path components.
    221      To get a full path (which begins with top) to a file or directory in
    222      dirpath, do os.path.join(dirpath, name).
    223
    224      If optional arg 'topdown' is true or not specified, the triple for a
    225      directory is generated before the triples for any of its subdirectories
    226      (directories are generated top down).  If topdown is false, the triple
    227      for a directory is generated after the triples for all of its
    228      subdirectories (directories are generated bottom up).
    229
    230      When topdown is true, the caller can modify the dirnames list in-place
    231      (e.g., via del or slice assignment), and walk will only recurse into the
    232      subdirectories whose names remain in dirnames; this can be used to prune
    233      the search, or to impose a specific order of visiting.  Modifying
    234      dirnames when topdown is false is ineffective, since the directories in
    235      dirnames have already been generated by the time dirnames itself is
    236      generated.
    237
    238      By default errors from the os.listdir() call are ignored.  If
    239      optional arg 'onerror' is specified, it should be a function; it
    240      will be called with one argument, an os.error instance.  It can
    241      report the error to continue with the walk, or raise the exception
    242      to abort the walk.  Note that the filename is available as the
    243      filename attribute of the exception object.
    244
    245      By default, os.walk does not follow symbolic links to subdirectories on
    246      systems that support them.  In order to get this functionality, set the
    247      optional argument 'followlinks' to true.
    248
    249      Caution:  if you pass a relative pathname for top, don't change the
    250      current working directory between resumptions of walk.  walk never
    251      changes the current directory, and assumes that the client doesn't
    252      either.
    253
    254      Example:
    255
    256      import os
    257      from os.path import join, getsize
    258      for root, dirs, files in os.walk('python/Lib/email'):
    259          print root, "consumes",
    260          print sum([getsize(join(root, name)) for name in files]),
    261          print "bytes in", len(files), "non-directory files"
    262          if 'CVS' in dirs:
    263              dirs.remove('CVS')  # don't visit CVS directories
    264      """
    265
    266      from os.path import join, isdir, islink
    267
    268      # We may not have read permission for top, in which case we can't
    269      # get a list of the files the directory contains.  os.path.walk
    270      # always suppressed the exception then, rather than blow up for a
    271      # minor reason when (say) a thousand readable directories are still
    272      # left to visit.  That logic is copied here.
    273      try:
    274          # Note that listdir and error are globals in this module due
    275          # to earlier import-*.
    276          names = listdir(top)
    277      except error, err:
    278          if onerror is not None:
    279              onerror(err)
    280          return
    281
    282      dirs, nondirs = [], []
    283      for name in names:
    284          if isdir(join(top, name)):
    285              dirs.append(name)
    286          else:
    287              nondirs.append(name)
    288
    289      if topdown:
    290          yield top, dirs, nondirs
    291      for name in dirs:
    292          path = join(top, name)
    293          if followlinks or not islink(path):
    294              for x in walk(path, topdown, onerror, followlinks):
    295                  yield x
    296      if not topdown:
    297          yield top, dirs, nondirs
    298
    299  __all__.append("walk")
    300
    301  # Make sure os.environ exists, at least
    302  try:
    303      environ
    304  except NameError:
    305      environ = {}
    306
    307 -def execl(file, *args):
    308      """execl(file, *args)
    309
    310      Execute the executable file with argument list args, replacing the
    311      current process. """
    312      execv(file, args)
    313
    314 -def execle(file, *args):
    315      """execle(file, *args, env)
    316
    317      Execute the executable file with argument list args and
    318      environment env, replacing the current process. """
    319      env = args[-1]
    320      execve(file, args[:-1], env)
    321
    322 -def execlp(file, *args):
    323      """execlp(file, *args)
    324
    325      Execute the executable file (which is searched for along $PATH)
    326      with argument list args, replacing the current process. """
    327      execvp(file, args)
    328
    329 -def execlpe(file, *args):
    330      """execlpe(file, *args, env)
    331
    332      Execute the executable file (which is searched for along $PATH)
    333      with argument list args and environment env, replacing the current
    334      process. """
    335      env = args[-1]
    336      execvpe(file, args[:-1], env)
    337
    338 -def execvp(file, args):
    339      """execvp(file, args)
    340
    341      Execute the executable file (which is searched for along $PATH)
    342      with argument list args, replacing the current process.
    343      args may be a list or tuple of strings. """
    344      _execvpe(file, args)
    345
    346 -def execvpe(file, args, env):
    347      """execvpe(file, args, env)
    348
    349      Execute the executable file (which is searched for along $PATH)
    350      with argument list args and environment env , replacing the
    351      current process.
    352      args may be a list or tuple of strings. """
    353      _execvpe(file, args, env)
    354
    355  __all__.extend(["execl","execle","execlp","execlpe","execvp","execvpe"])
    356
    357 -def _execvpe(file, args, env=None):
    358      if env is not None:
    359          func = execve
    360          argrest = (args, env)
    361      else:
    362          func = execv
    363          argrest = (args,)
    364          env = environ
    365
    366      head, tail = path.split(file)
    367      if head:
    368          func(file, *argrest)
    369          return
    370      if 'PATH' in env:
    371          envpath = env['PATH']
    372      else:
    373          envpath = defpath
    374      PATH = envpath.split(pathsep)
    375      saved_exc = None
    376      saved_tb = None
    377      for dir in PATH:
    378          fullname = path.join(dir, file)
    379          try:
    380              func(fullname, *argrest)
    381          except error, e:
    382              tb = sys.exc_info()[2]
    383              if (e.errno != errno.ENOENT and e.errno != errno.ENOTDIR
    384                  and saved_exc is None):
    385                  saved_exc = e
    386                  saved_tb = tb
    387      if saved_exc:
    388          raise error, saved_exc, saved_tb
    389      raise error, e, tb
    390
    391  # Change environ to automatically call putenv() if it exists
    392  try:
    393      # This will fail if there's no putenv
    394      putenv
    395  except NameError:
    396      pass
    397  else:
    398      import UserDict
    399
    400      # Fake unsetenv() for Windows
    401      # not sure about os2 here but
    402      # I'm guessing they are the same.
    403
    404      if name in ('os2', 'nt'):
    405 -        def unsetenv(key):
    406              putenv(key, "")
    407
    408      if name == "riscos":
    409          # On RISC OS, all env access goes through getenv and putenv
    410          from riscosenviron import _Environ
    411      elif name in ('os2', 'nt'):  # Where Env Var Names Must Be UPPERCASE
    412          # But we store them as upper case
    413 -        class _Environ(UserDict.IterableUserDict):
    414 -            def __init__(self, environ):
    415                  UserDict.UserDict.__init__(self)
    416                  data = self.data
    417                  for k, v in environ.items():
    418                      data[k.upper()] = v
    419 -            def __setitem__(self, key, item):
    420                  putenv(key, item)
    421                  self.data[key.upper()] = item
    422 -            def __getitem__(self, key):
    423                  return self.data[key.upper()]
    424              try:
    425                  unsetenv
    426              except NameError:
    427 -                def __delitem__(self, key):
    428                      del self.data[key.upper()]
    429              else:
    430 -                def __delitem__(self, key):
    431                      unsetenv(key)
    432                      del self.data[key.upper()]
    433 -                def clear(self):
    434                      for key in self.data.keys():
    435                          unsetenv(key)
    436                          del self.data[key]
    437 -                def pop(self, key, *args):
    438                      unsetenv(key)
    439                      return self.data.pop(key.upper(), *args)
    440 -            def has_key(self, key):
    441                  return key.upper() in self.data
    442 -            def __contains__(self, key):
    443                  return key.upper() in self.data
    444 -            def get(self, key, failobj=None):
    445                  return self.data.get(key.upper(), failobj)
    446 -            def update(self, dict=None, **kwargs):
    447                  if dict:
    448                      try:
    449                          keys = dict.keys()
    450                      except AttributeError:
    451                          # List of (key, value)
    452                          for k, v in dict:
    453                              self[k] = v
    454                      else:
    455                          # got keys
    456                          # cannot use items(), since mappings
    457                          # may not have them.
    458                          for k in keys:
    459                              self[k] = dict[k]
    460                  if kwargs:
    461                      self.update(kwargs)
    462 -            def copy(self):
    463                  return dict(self)
    464
    465      else:  # Where Env Var Names Can Be Mixed Case
    466 -        class _Environ(UserDict.IterableUserDict):
    467 -            def __init__(self, environ):
    468                  UserDict.UserDict.__init__(self)
    469                  self.data = environ
    470 -            def __setitem__(self, key, item):
    471                  putenv(key, item)
    472                  self.data[key] = item
    473 -            def update(self,  dict=None, **kwargs):
    474                  if dict:
    475                      try:
    476                          keys = dict.keys()
    477                      except AttributeError:
    478                          # List of (key, value)
    479                          for k, v in dict:
    480                              self[k] = v
    481                      else:
    482                          # got keys
    483                          # cannot use items(), since mappings
    484                          # may not have them.
    485                          for k in keys:
    486                              self[k] = dict[k]
    487                  if kwargs:
    488                      self.update(kwargs)
    489              try:
    490                  unsetenv
    491              except NameError:
    492                  pass
    493              else:
    494 -                def __delitem__(self, key):
    495                      unsetenv(key)
    496                      del self.data[key]
    497 -                def clear(self):
    498                      for key in self.data.keys():
    499                          unsetenv(key)
    500                          del self.data[key]
    501 -                def pop(self, key, *args):
    502                      unsetenv(key)
    503                      return self.data.pop(key, *args)
    504 -            def copy(self):
    505                  return dict(self)
    506
    507
    508      environ = _Environ(environ)
    509
    510 -def getenv(key, default=None):
    511      """Get an environment variable, return None if it doesn't exist.
    512      The optional second argument can specify an alternate default."""
    513      return environ.get(key, default)
    514  __all__.append("getenv")
    515
    516 -def _exists(name):
    517      try:
    518          eval(name)
    519          return True
    520      except NameError:
    521          return False
    522
    523  # Supply spawn*() (probably only for Unix)
    524  if _exists("fork") and not _exists("spawnv") and _exists("execv"):
    525
    526      P_WAIT = 0
    527      P_NOWAIT = P_NOWAITO = 1
    528
    529      # XXX Should we support P_DETACH?  I suppose it could fork()**2
    530      # and close the std I/O streams.  Also, P_OVERLAY is the same
    531      # as execv*()?
    532
    533 -    def _spawnvef(mode, file, args, env, func):
    534          # Internal helper; func is the exec*() function to use
    535          pid = fork()
    536          if not pid:
    537              # Child
    538              try:
    539                  if env is None:
    540                      func(file, args)
    541                  else:
    542                      func(file, args, env)
    543              except:
    544                  _exit(127)
    545          else:
    546              # Parent
    547              if mode == P_NOWAIT:
    548                  return pid # Caller is responsible for waiting!
    549              while 1:
    550                  wpid, sts = waitpid(pid, 0)
    551                  if WIFSTOPPED(sts):
    552                      continue
    553                  elif WIFSIGNALED(sts):
    554                      return -WTERMSIG(sts)
    555                  elif WIFEXITED(sts):
    556                      return WEXITSTATUS(sts)
    557                  else:
    558                      raise error, "Not stopped, signaled or exited???"
    559
    560 -    def spawnv(mode, file, args):
    561          """spawnv(mode, file, args) -> integer
    562
    563  Execute file with arguments from args in a subprocess.
    564  If mode == P_NOWAIT return the pid of the process.
    565  If mode == P_WAIT return the process's exit code if it exits normally;
    566  otherwise return -SIG, where SIG is the signal that killed it. """
    567          return _spawnvef(mode, file, args, None, execv)
    568
    569 -    def spawnve(mode, file, args, env):
    570          """spawnve(mode, file, args, env) -> integer
    571
    572  Execute file with arguments from args in a subprocess with the
    573  specified environment.
    574  If mode == P_NOWAIT return the pid of the process.
    575  If mode == P_WAIT return the process's exit code if it exits normally;
    576  otherwise return -SIG, where SIG is the signal that killed it. """
    577          return _spawnvef(mode, file, args, env, execve)
    578
    579      # Note: spawnvp[e] is't currently supported on Windows
    580
    581 -    def spawnvp(mode, file, args):
    582          """spawnvp(mode, file, args) -> integer
    583
    584  Execute file (which is looked for along $PATH) with arguments from
    585  args in a subprocess.
    586  If mode == P_NOWAIT return the pid of the process.
    587  If mode == P_WAIT return the process's exit code if it exits normally;
    588  otherwise return -SIG, where SIG is the signal that killed it. """
    589          return _spawnvef(mode, file, args, None, execvp)
    590
    591 -    def spawnvpe(mode, file, args, env):
    592          """spawnvpe(mode, file, args, env) -> integer
    593
    594  Execute file (which is looked for along $PATH) with arguments from
    595  args in a subprocess with the supplied environment.
    596  If mode == P_NOWAIT return the pid of the process.
    597  If mode == P_WAIT return the process's exit code if it exits normally;
    598  otherwise return -SIG, where SIG is the signal that killed it. """
    599          return _spawnvef(mode, file, args, env, execvpe)
    600
    601  if _exists("spawnv"):
    602      # These aren't supplied by the basic Windows code
    603      # but can be easily implemented in Python
    604
    605 -    def spawnl(mode, file, *args):
    606          """spawnl(mode, file, *args) -> integer
    607
    608  Execute file with arguments from args in a subprocess.
    609  If mode == P_NOWAIT return the pid of the process.
    610  If mode == P_WAIT return the process's exit code if it exits normally;
    611  otherwise return -SIG, where SIG is the signal that killed it. """
    612          return spawnv(mode, file, args)
    613
    614 -    def spawnle(mode, file, *args):
    615          """spawnle(mode, file, *args, env) -> integer
    616
    617  Execute file with arguments from args in a subprocess with the
    618  supplied environment.
    619  If mode == P_NOWAIT return the pid of the process.
    620  If mode == P_WAIT return the process's exit code if it exits normally;
    621  otherwise return -SIG, where SIG is the signal that killed it. """
    622          env = args[-1]
    623          return spawnve(mode, file, args[:-1], env)
    624
    625
    626      __all__.extend(["spawnv", "spawnve", "spawnl", "spawnle",])
    627
    628
    629  if _exists("spawnvp"):
    630      # At the moment, Windows doesn't implement spawnvp[e],
    631      # so it won't have spawnlp[e] either.
    632 -    def spawnlp(mode, file, *args):
    633          """spawnlp(mode, file, *args) -> integer
    634
    635  Execute file (which is looked for along $PATH) with arguments from
    636  args in a subprocess with the supplied environment.
    637  If mode == P_NOWAIT return the pid of the process.
    638  If mode == P_WAIT return the process's exit code if it exits normally;
    639  otherwise return -SIG, where SIG is the signal that killed it. """
    640          return spawnvp(mode, file, args)
    641
    642 -    def spawnlpe(mode, file, *args):
    643          """spawnlpe(mode, file, *args, env) -> integer
    644
    645  Execute file (which is looked for along $PATH) with arguments from
    646  args in a subprocess with the supplied environment.
    647  If mode == P_NOWAIT return the pid of the process.
    648  If mode == P_WAIT return the process's exit code if it exits normally;
    649  otherwise return -SIG, where SIG is the signal that killed it. """
    650          env = args[-1]
    651          return spawnvpe(mode, file, args[:-1], env)
    652
    653
    654      __all__.extend(["spawnvp", "spawnvpe", "spawnlp", "spawnlpe",])
    655
    656
    657  # Supply popen2 etc. (for Unix)
    658  if _exists("fork"):
    659      if not _exists("popen2"):
    660 -        def popen2(cmd, mode="t", bufsize=-1):
    661              """Execute the shell command 'cmd' in a sub-process.  On UNIX, 'cmd'
    662              may be a sequence, in which case arguments will be passed directly to
    663              the program without shell intervention (as with os.spawnv()).  If 'cmd'
    664              is a string it will be passed to the shell (as with os.system()). If
    665              'bufsize' is specified, it sets the buffer size for the I/O pipes.  The
    666              file objects (child_stdin, child_stdout) are returned."""
    667              import warnings
    668              msg = "os.popen2 is deprecated.  Use the subprocess module."
    669              warnings.warn(msg, DeprecationWarning, stacklevel=2)
    670
    671              import subprocess
    672              PIPE = subprocess.PIPE
    673              p = subprocess.Popen(cmd, shell=isinstance(cmd, basestring),
    674                                   bufsize=bufsize, stdin=PIPE, stdout=PIPE,
    675                                   close_fds=True)
    676              return p.stdin, p.stdout
    677          __all__.append("popen2")
    678
    679      if not _exists("popen3"):
    680 -        def popen3(cmd, mode="t", bufsize=-1):
    681              """Execute the shell command 'cmd' in a sub-process.  On UNIX, 'cmd'
    682              may be a sequence, in which case arguments will be passed directly to
    683              the program without shell intervention (as with os.spawnv()).  If 'cmd'
    684              is a string it will be passed to the shell (as with os.system()). If
    685              'bufsize' is specified, it sets the buffer size for the I/O pipes.  The
    686              file objects (child_stdin, child_stdout, child_stderr) are returned."""
    687              import warnings
    688              msg = "os.popen3 is deprecated.  Use the subprocess module."
    689              warnings.warn(msg, DeprecationWarning, stacklevel=2)
    690
    691              import subprocess
    692              PIPE = subprocess.PIPE
    693              p = subprocess.Popen(cmd, shell=isinstance(cmd, basestring),
    694                                   bufsize=bufsize, stdin=PIPE, stdout=PIPE,
    695                                   stderr=PIPE, close_fds=True)
    696              return p.stdin, p.stdout, p.stderr
    697          __all__.append("popen3")
    698
    699      if not _exists("popen4"):
    700 -        def popen4(cmd, mode="t", bufsize=-1):
    701              """Execute the shell command 'cmd' in a sub-process.  On UNIX, 'cmd'
    702              may be a sequence, in which case arguments will be passed directly to
    703              the program without shell intervention (as with os.spawnv()).  If 'cmd'
    704              is a string it will be passed to the shell (as with os.system()). If
    705              'bufsize' is specified, it sets the buffer size for the I/O pipes.  The
    706              file objects (child_stdin, child_stdout_stderr) are returned."""
    707              import warnings
    708              msg = "os.popen4 is deprecated.  Use the subprocess module."
    709              warnings.warn(msg, DeprecationWarning, stacklevel=2)
    710
    711              import subprocess
    712              PIPE = subprocess.PIPE
    713              p = subprocess.Popen(cmd, shell=isinstance(cmd, basestring),
    714                                   bufsize=bufsize, stdin=PIPE, stdout=PIPE,
    715                                   stderr=subprocess.STDOUT, close_fds=True)
    716              return p.stdin, p.stdout
    717          __all__.append("popen4")
    718
    719  import copy_reg as _copy_reg
    720
    721 -def _make_stat_result(tup, dict):
    722      return stat_result(tup, dict)
    723
    724 -def _pickle_stat_result(sr):
    725      (type, args) = sr.__reduce__()
    726      return (_make_stat_result, args)
    727
    728  try:
    729      _copy_reg.pickle(stat_result, _pickle_stat_result, _make_stat_result)
    730  except NameError: # stat_result may not exist
    731      pass
    732
    733 -def _make_statvfs_result(tup, dict):
    734      return statvfs_result(tup, dict)
    735
    736 -def _pickle_statvfs_result(sr):
    737      (type, args) = sr.__reduce__()
    738      return (_make_statvfs_result, args)
    739
    740  try:
    741      _copy_reg.pickle(statvfs_result, _pickle_statvfs_result,
    742                       _make_statvfs_result)
    743  except NameError: # statvfs_result may not exist
    744      pass
    745
    746  if not _exists("urandom"):
    747 -    def urandom(n):
    748          """urandom(n) -> str
    749
    750          Return a string of n random bytes suitable for cryptographic use.
    751
    752          """
    753          try:
    754              _urandomfd = open("/dev/urandom", O_RDONLY)
    755          except (OSError, IOError):
    756              raise NotImplementedError("/dev/urandom (or equivalent) not found")
    757          try:
    758              bs = b""
    759              while n - len(bs) >= 1:
    760                  bs += read(_urandomfd, n - len(bs))
    761          finally:
    762              close(_urandomfd)
    763          return bs
    764