Lib/os.py

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