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):

   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     Caution:  if you pass a relative pathname for top, don't change the

   260     current working directory between resumptions of walk.  walk never

   261     changes the current directory, and assumes that the client doesn't

   262     either.

   263 

   264     Example:

   265 

   266     from os.path import join, getsize

   267     for root, dirs, files in walk('python/Lib/email'):

   268         print root, "consumes",

   269         print sum([getsize(join(root, name)) for name in files]),

   270         print "bytes in", len(files), "non-directory files"

   271         if 'CVS' in dirs:

   272             dirs.remove('CVS')  # don't visit CVS directories

   273     """

   274 

   275     from os.path import join, isdir, islink

   276 

   277     # We may not have read permission for top, in which case we can't

   278     # get a list of the files the directory contains.  os.path.walk

   279     # always suppressed the exception then, rather than blow up for a

   280     # minor reason when (say) a thousand readable directories are still

   281     # left to visit.  That logic is copied here.

   282     try:

   283         # Note that listdir and error are globals in this module due

   284         # to earlier import-*.

   285         names = listdir(top)

   286     except error, err:

   287         if onerror is not None:

   288             onerror(err)

   289         return

   290 

   291     dirs, nondirs = [], []

   292     for name in names:

   293         if isdir(join(top, name)):

   294             dirs.append(name)

   295         else:

   296             nondirs.append(name)

   297 

   298     if topdown:

   299         yield top, dirs, nondirs

   300     for name in dirs:

   301         path = join(top, name)

   302         if not islink(path):

   303             for x in walk(path, topdown, onerror):

   304                 yield x

   305     if not topdown:

   306         yield top, dirs, nondirs

   307 

   308 __all__.append("walk")

   309 

   310 # Make sure os.environ exists, at least

   311 try:

   312     environ

   313 except NameError:

   314     environ = {}

   315 

   316 def execl(file, *args):

   317     """execl(file, *args)

   318 

   319     Execute the executable file with argument list args, replacing the

   320     current process. """

   321     execv(file, args)

   322 

   323 def execle(file, *args):

   324     """execle(file, *args, env)

   325 

   326     Execute the executable file with argument list args and

   327     environment env, replacing the current process. """

   328     env = args[-1]

   329     execve(file, args[:-1], env)

   330 

   331 def execlp(file, *args):

   332     """execlp(file, *args)

   333 

   334     Execute the executable file (which is searched for along $PATH)

   335     with argument list args, replacing the current process. """

   336     execvp(file, args)

   337 

   338 def execlpe(file, *args):

   339     """execlpe(file, *args, env)

   340 

   341     Execute the executable file (which is searched for along $PATH)

   342     with argument list args and environment env, replacing the current

   343     process. """

   344     env = args[-1]

   345     execvpe(file, args[:-1], env)

   346 

   347 def execvp(file, args):

   348     """execp(file, args)

   349 

   350     Execute the executable file (which is searched for along $PATH)

   351     with argument list args, replacing the current process.

   352     args may be a list or tuple of strings. """

   353     _execvpe(file, args)

   354 

   355 def execvpe(file, args, env):

   356     """execvpe(file, args, env)

   357 

   358     Execute the executable file (which is searched for along $PATH)

   359     with argument list args and environment env , replacing the

   360     current process.

   361     args may be a list or tuple of strings. """

   362     _execvpe(file, args, env)

   363 

   364 __all__.extend(["execl","execle","execlp","execlpe","execvp","execvpe"])

   365 

   366 def _execvpe(file, args, env=None):

   367     if env is not None:

   368         func = execve

   369         argrest = (args, env)

   370     else:

   371         func = execv

   372         argrest = (args,)

   373         env = environ

   374 

   375     head, tail = path.split(file)

   376     if head:

   377         func(file, *argrest)

   378         return

   379     if 'PATH' in env:

   380         envpath = env['PATH']

   381     else:

   382         envpath = defpath

   383     PATH = envpath.split(pathsep)

   384     saved_exc = None

   385     saved_tb = None

   386     for dir in PATH:

   387         fullname = path.join(dir, file)

   388         try:

   389             func(fullname, *argrest)

   390         except error, e:

   391             tb = sys.exc_info()[2]

   392             if (e.errno != errno.ENOENT and e.errno != errno.ENOTDIR

   393                 and saved_exc is None):

   394                 saved_exc = e

   395                 saved_tb = tb

   396     if saved_exc:

   397         raise error, saved_exc, saved_tb

   398     raise error, e, tb

   399 

   400 # Change environ to automatically call putenv() if it exists

   401 try:

   402     # This will fail if there's no putenv

   403     putenv

   404 except NameError:

   405     pass

   406 else:

   407     import UserDict

   408 

   409     # Fake unsetenv() for Windows

   410     # not sure about os2 here but

   411     # I'm guessing they are the same.

   412 

   413     if name in ('os2', 'nt'):

   414         def unsetenv(key):

   415             putenv(key, "")

   416 

   417     if name == "riscos":

   418         # On RISC OS, all env access goes through getenv and putenv

   419         from riscosenviron import _Environ

   420     elif name in ('os2', 'nt'):  # Where Env Var Names Must Be UPPERCASE

   421         # But we store them as upper case

   422         class _Environ(UserDict.IterableUserDict):

   423             def __init__(self, environ):

   424                 UserDict.UserDict.__init__(self)

   425                 data = self.data

   426                 for k, v in environ.items():

   427                     data[k.upper()] = v

   428             def __setitem__(self, key, item):

   429                 putenv(key, item)

   430                 self.data[key.upper()] = item

   431             def __getitem__(self, key):

   432                 return self.data[key.upper()]

   433             try:

   434                 unsetenv

   435             except NameError:

   436                 def __delitem__(self, key):

   437                     del self.data[key.upper()]

   438             else:

   439                 def __delitem__(self, key):

   440                     unsetenv(key)

   441                     del self.data[key.upper()]

   442             def has_key(self, key):

   443                 return key.upper() in self.data

   444             def __contains__(self, key):

   445                 return key.upper() in self.data

   446             def get(self, key, failobj=None):

   447                 return self.data.get(key.upper(), failobj)

   448             def update(self, dict=None, **kwargs):

   449                 if dict:

   450                     try:

   451                         keys = dict.keys()

   452                     except AttributeError:

   453                         # List of (key, value)

   454                         for k, v in dict:

   455                             self[k] = v

   456                     else:

   457                         # got keys

   458                         # cannot use items(), since mappings

   459                         # may not have them.

   460                         for k in keys:

   461                             self[k] = dict[k]

   462                 if kwargs:

   463                     self.update(kwargs)

   464             def copy(self):

   465                 return dict(self)

   466 

   467     else:  # Where Env Var Names Can Be Mixed Case

   468         class _Environ(UserDict.IterableUserDict):

   469             def __init__(self, environ):

   470                 UserDict.UserDict.__init__(self)

   471                 self.data = environ

   472             def __setitem__(self, key, item):

   473                 putenv(key, item)

   474                 self.data[key] = item

   475             def update(self,  dict=None, **kwargs):

   476                 if dict:

   477                     try:

   478                         keys = dict.keys()

   479                     except AttributeError:

   480                         # List of (key, value)

   481                         for k, v in dict:

   482                             self[k] = v

   483                     else:

   484                         # got keys

   485                         # cannot use items(), since mappings

   486                         # may not have them.

   487                         for k in keys:

   488                             self[k] = dict[k]

   489                 if kwargs:

   490                     self.update(kwargs)

   491             try:

   492                 unsetenv

   493             except NameError:

   494                 pass

   495             else:

   496                 def __delitem__(self, key):

   497                     unsetenv(key)

   498                     del self.data[key]

   499             def copy(self):

   500                 return dict(self)

   501 

   502 

   503     environ = _Environ(environ)

   504 

   505 def getenv(key, default=None):

   506     """Get an environment variable, return None if it doesn't exist.

   507     The optional second argument can specify an alternate default."""

   508     return environ.get(key, default)

   509 __all__.append("getenv")

   510 

   511 def _exists(name):

   512     try:

   513         eval(name)

   514         return True

   515     except NameError:

   516         return False

   517 

   518 # Supply spawn*() (probably only for Unix)

   519 if _exists("fork") and not _exists("spawnv") and _exists("execv"):

   520 

   521     P_WAIT = 0

   522     P_NOWAIT = P_NOWAITO = 1

   523 

   524     # XXX Should we support P_DETACH?  I suppose it could fork()**2

   525     # and close the std I/O streams.  Also, P_OVERLAY is the same

   526     # as execv*()?

   527 

   528     def _spawnvef(mode, file, args, env, func):

   529         # Internal helper; func is the exec*() function to use

   530         pid = fork()

   531         if not pid:

   532             # Child

   533             try:

   534                 if env is None:

   535                     func(file, args)

   536                 else:

   537                     func(file, args, env)

   538             except:

   539                 _exit(127)

   540         else:

   541             # Parent

   542             if mode == P_NOWAIT:

   543                 return pid # Caller is responsible for waiting!

   544             while 1:

   545                 wpid, sts = waitpid(pid, 0)

   546                 if WIFSTOPPED(sts):

   547                     continue

   548                 elif WIFSIGNALED(sts):

   549                     return -WTERMSIG(sts)

   550                 elif WIFEXITED(sts):

   551                     return WEXITSTATUS(sts)

   552                 else:

   553                     raise error, "Not stopped, signaled or exited???"

   554 

   555     def spawnv(mode, file, args):

   556         """spawnv(mode, file, args) -> integer

   557 

   558 Execute file with arguments from args in a subprocess.

   559 If mode == P_NOWAIT return the pid of the process.

   560 If mode == P_WAIT return the process's exit code if it exits normally;

   561 otherwise return -SIG, where SIG is the signal that killed it. """

   562         return _spawnvef(mode, file, args, None, execv)

   563 

   564     def spawnve(mode, file, args, env):

   565         """spawnve(mode, file, args, env) -> integer

   566 

   567 Execute file with arguments from args in a subprocess with the

   568 specified environment.

   569 If mode == P_NOWAIT return the pid of the process.

   570 If mode == P_WAIT return the process's exit code if it exits normally;

   571 otherwise return -SIG, where SIG is the signal that killed it. """

   572         return _spawnvef(mode, file, args, env, execve)

   573 

   574     # Note: spawnvp[e] is't currently supported on Windows

   575 

   576     def spawnvp(mode, file, args):

   577         """spawnvp(mode, file, args) -> integer

   578 

   579 Execute file (which is looked for along $PATH) with arguments from

   580 args in a subprocess.

   581 If mode == P_NOWAIT return the pid of the process.

   582 If mode == P_WAIT return the process's exit code if it exits normally;

   583 otherwise return -SIG, where SIG is the signal that killed it. """

   584         return _spawnvef(mode, file, args, None, execvp)

   585 

   586     def spawnvpe(mode, file, args, env):

   587         """spawnvpe(mode, file, args, env) -> integer

   588 

   589 Execute file (which is looked for along $PATH) with arguments from

   590 args in a subprocess with the supplied environment.

   591 If mode == P_NOWAIT return the pid of the process.

   592 If mode == P_WAIT return the process's exit code if it exits normally;

   593 otherwise return -SIG, where SIG is the signal that killed it. """

   594         return _spawnvef(mode, file, args, env, execvpe)

   595 

   596 if _exists("spawnv"):

   597     # These aren't supplied by the basic Windows code

   598     # but can be easily implemented in Python

   599 

   600     def spawnl(mode, file, *args):

   601         """spawnl(mode, file, *args) -> integer

   602 

   603 Execute file with arguments from args in a subprocess.

   604 If mode == P_NOWAIT return the pid of the process.

   605 If mode == P_WAIT return the process's exit code if it exits normally;

   606 otherwise return -SIG, where SIG is the signal that killed it. """

   607         return spawnv(mode, file, args)

   608 

   609     def spawnle(mode, file, *args):

   610         """spawnle(mode, file, *args, env) -> integer

   611 

   612 Execute file with arguments from args in a subprocess with the

   613 supplied environment.

   614 If mode == P_NOWAIT return the pid of the process.

   615 If mode == P_WAIT return the process's exit code if it exits normally;

   616 otherwise return -SIG, where SIG is the signal that killed it. """

   617         env = args[-1]

   618         return spawnve(mode, file, args[:-1], env)

   619 

   620 

   621     __all__.extend(["spawnv", "spawnve", "spawnl", "spawnle",])

   622 

   623 

   624 if _exists("spawnvp"):

   625     # At the moment, Windows doesn't implement spawnvp[e],

   626     # so it won't have spawnlp[e] either.

   627     def spawnlp(mode, file, *args):

   628         """spawnlp(mode, file, *args) -> integer

   629 

   630 Execute file (which is looked for along $PATH) with arguments from

   631 args in a subprocess with the 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         return spawnvp(mode, file, args)

   636 

   637     def spawnlpe(mode, file, *args):

   638         """spawnlpe(mode, file, *args, env) -> integer

   639 

   640 Execute file (which is looked for along $PATH) with arguments from

   641 args in a subprocess with the supplied environment.

   642 If mode == P_NOWAIT return the pid of the process.

   643 If mode == P_WAIT return the process's exit code if it exits normally;

   644 otherwise return -SIG, where SIG is the signal that killed it. """

   645         env = args[-1]

   646         return spawnvpe(mode, file, args[:-1], env)

   647 

   648 

   649     __all__.extend(["spawnvp", "spawnvpe", "spawnlp", "spawnlpe",])

   650 

   651 

   652 # Supply popen2 etc. (for Unix)

   653 if _exists("fork"):

   654     if not _exists("popen2"):

   655         def popen2(cmd, mode="t", bufsize=-1):

   656             """Execute the shell command 'cmd' in a sub-process.  On UNIX, 'cmd'

   657             may be a sequence, in which case arguments will be passed directly to

   658             the program without shell intervention (as with os.spawnv()).  If 'cmd'

   659             is a string it will be passed to the shell (as with os.system()). If

   660             'bufsize' is specified, it sets the buffer size for the I/O pipes.  The

   661             file objects (child_stdin, child_stdout) are returned."""

   662             import popen2

   663             stdout, stdin = popen2.popen2(cmd, bufsize)

   664             return stdin, stdout

   665         __all__.append("popen2")

   666 

   667     if not _exists("popen3"):

   668         def popen3(cmd, mode="t", bufsize=-1):

   669             """Execute the shell command 'cmd' in a sub-process.  On UNIX, 'cmd'

   670             may be a sequence, in which case arguments will be passed directly to

   671             the program without shell intervention (as with os.spawnv()).  If 'cmd'

   672             is a string it will be passed to the shell (as with os.system()). If

   673             'bufsize' is specified, it sets the buffer size for the I/O pipes.  The

   674             file objects (child_stdin, child_stdout, child_stderr) are returned."""

   675             import popen2

   676             stdout, stdin, stderr = popen2.popen3(cmd, bufsize)

   677             return stdin, stdout, stderr

   678         __all__.append("popen3")

   679 

   680     if not _exists("popen4"):

   681         def popen4(cmd, mode="t", bufsize=-1):

   682             """Execute the shell command 'cmd' in a sub-process.  On UNIX, 'cmd'

   683             may be a sequence, in which case arguments will be passed directly to

   684             the program without shell intervention (as with os.spawnv()).  If 'cmd'

   685             is a string it will be passed to the shell (as with os.system()). If

   686             'bufsize' is specified, it sets the buffer size for the I/O pipes.  The

   687             file objects (child_stdin, child_stdout_stderr) are returned."""

   688             import popen2

   689             stdout, stdin = popen2.popen4(cmd, bufsize)

   690             return stdin, stdout

   691         __all__.append("popen4")

   692 

   693 import copy_reg as _copy_reg

   694 

   695 def _make_stat_result(tup, dict):

   696     return stat_result(tup, dict)

   697 

   698 def _pickle_stat_result(sr):

   699     (type, args) = sr.__reduce__()

   700     return (_make_stat_result, args)

   701 

   702 try:

   703     _copy_reg.pickle(stat_result, _pickle_stat_result, _make_stat_result)

   704 except NameError: # stat_result may not exist

   705     pass

   706 

   707 def _make_statvfs_result(tup, dict):

   708     return statvfs_result(tup, dict)

   709 

   710 def _pickle_statvfs_result(sr):

   711     (type, args) = sr.__reduce__()

   712     return (_make_statvfs_result, args)

   713 

   714 try:

   715     _copy_reg.pickle(statvfs_result, _pickle_statvfs_result,

   716                      _make_statvfs_result)

   717 except NameError: # statvfs_result may not exist

   718     pass

   719 

   720 if not _exists("urandom"):

   721     def urandom(n):

   722         """urandom(n) -> str

   723 

   724         Return a string of n random bytes suitable for cryptographic use.

   725 

   726         """

   727         try:

   728             _urandomfd = open("/dev/urandom", O_RDONLY)

   729         except (OSError, IOError):

   730             raise NotImplementedError("/dev/urandom (or equivalent) not found")

   731         bytes = ""

   732         while len(bytes) < n:

   733             bytes += read(_urandomfd, n - len(bytes))

   734         close(_urandomfd)

   735         return bytes