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