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