Mercurial > repos > bcclaywell > argo_navis

comparison venv/lib/python2.7/os.py @ 0:d67268158946 draft

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
planemo upload commit a3f181f5f126803c654b3a66dd4e83a48f7e203b
author bcclaywell
date Mon, 12 Oct 2015 17:43:33 -0400
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:d67268158946
1 r"""OS routines for NT or Posix depending on what system we're on.
2
3 This exports:
4 - all functions from posix, nt, os2, or ce, e.g. unlink, stat, etc.
5 - os.path is one of the modules posixpath, or ntpath
6 - os.name is 'posix', 'nt', 'os2', 'ce' or 'riscos'
7 - os.curdir is a string representing the current directory ('.' or ':')
8 - os.pardir is a string representing the parent directory ('..' or '::')
9 - os.sep is the (or a most common) pathname separator ('/' or ':' or '\\')
10 - os.extsep is the extension separator ('.' or '/')
11 - os.altsep is the alternate pathname separator (None or '/')
12 - os.pathsep is the component separator used in $PATH etc
13 - os.linesep is the line separator in text files ('\r' or '\n' or '\r\n')
14 - os.defpath is the default search path for executables
15 - os.devnull is the file path of the null device ('/dev/null', etc.)
16
17 Programs that import and use 'os' stand a better chance of being
18 portable between different platforms. Of course, they must then
19 only use functions that are defined by all platforms (e.g., unlink
20 and opendir), and leave all pathname manipulation to os.path
21 (e.g., split and join).
22 """
23
24 #'
25
26 import sys, errno
27
28 _names = sys.builtin_module_names
29
30 # Note: more names are added to __all__ later.
31 __all__ = ["altsep", "curdir", "pardir", "sep", "extsep", "pathsep", "linesep",
32 "defpath", "name", "path", "devnull",
33 "SEEK_SET", "SEEK_CUR", "SEEK_END"]
34
35 def _get_exports_list(module):
36 try:
37 return list(module.__all__)
38 except AttributeError:
39 return [n for n in dir(module) if n[0] != '_']
40
41 if 'posix' in _names:
42 name = 'posix'
43 linesep = '\n'
44 from posix import *
45 try:
46 from posix import _exit
47 except ImportError:
48 pass
49 import posixpath as path
50
51 import posix
52 __all__.extend(_get_exports_list(posix))
53 del posix
54
55 elif 'nt' in _names:
56 name = 'nt'
57 linesep = '\r\n'
58 from nt import *
59 try:
60 from nt import _exit
61 except ImportError:
62 pass
63 import ntpath as path
64
65 import nt
66 __all__.extend(_get_exports_list(nt))
67 del nt
68
69 elif 'os2' in _names:
70 name = 'os2'
71 linesep = '\r\n'
72 from os2 import *
73 try:
74 from os2 import _exit
75 except ImportError:
76 pass
77 if sys.version.find('EMX GCC') == -1:
78 import ntpath as path
79 else:
80 import os2emxpath as path
81 from _emx_link import link
82
83 import os2
84 __all__.extend(_get_exports_list(os2))
85 del os2
86
87 elif 'ce' in _names:
88 name = 'ce'
89 linesep = '\r\n'
90 from ce import *
91 try:
92 from ce import _exit
93 except ImportError:
94 pass
95 # We can use the standard Windows path.
96 import ntpath as path
97
98 import ce
99 __all__.extend(_get_exports_list(ce))
100 del ce
101
102 elif 'riscos' in _names:
103 name = 'riscos'
104 linesep = '\n'
105 from riscos import *
106 try:
107 from riscos import _exit
108 except ImportError:
109 pass
110 import riscospath as path
111
112 import riscos
113 __all__.extend(_get_exports_list(riscos))
114 del riscos
115
116 else:
117 raise ImportError, 'no os specific module found'
118
119 sys.modules['os.path'] = path
120 from os.path import (curdir, pardir, sep, pathsep, defpath, extsep, altsep,
121 devnull)
122
123 del _names
124
125 # Python uses fixed values for the SEEK_ constants; they are mapped
126 # to native constants if necessary in posixmodule.c
127 SEEK_SET = 0
128 SEEK_CUR = 1
129 SEEK_END = 2
130
131 #'
132
133 # Super directory utilities.
134 # (Inspired by Eric Raymond; the doc strings are mostly his)
135
136 def makedirs(name, mode=0777):
137 """makedirs(path [, mode=0777])
138
139 Super-mkdir; create a leaf directory and all intermediate ones.
140 Works like mkdir, except that any intermediate path segment (not
141 just the rightmost) will be created if it does not exist. This is
142 recursive.
143
144 """
145 head, tail = path.split(name)
146 if not tail:
147 head, tail = path.split(head)
148 if head and tail and not path.exists(head):
149 try:
150 makedirs(head, mode)
151 except OSError, e:
152 # be happy if someone already created the path
153 if e.errno != errno.EEXIST:
154 raise
155 if tail == curdir: # xxx/newdir/. exists if xxx/newdir exists
156 return
157 mkdir(name, mode)
158
159 def removedirs(name):
160 """removedirs(path)
161
162 Super-rmdir; remove a leaf directory and all empty intermediate
163 ones. Works like rmdir except that, if the leaf directory is
164 successfully removed, directories corresponding to rightmost path
165 segments will be pruned away until either the whole path is
166 consumed or an error occurs. Errors during this latter phase are
167 ignored -- they generally mean that a directory was not empty.
168
169 """
170 rmdir(name)
171 head, tail = path.split(name)
172 if not tail:
173 head, tail = path.split(head)
174 while head and tail:
175 try:
176 rmdir(head)
177 except error:
178 break
179 head, tail = path.split(head)
180
181 def renames(old, new):
182 """renames(old, new)
183
184 Super-rename; create directories as necessary and delete any left
185 empty. Works like rename, except creation of any intermediate
186 directories needed to make the new pathname good is attempted
187 first. After the rename, directories corresponding to rightmost
188 path segments of the old name will be pruned until either the
189 whole path is consumed or a nonempty directory is found.
190
191 Note: this function can fail with the new directory structure made
192 if you lack permissions needed to unlink the leaf directory or
193 file.
194
195 """
196 head, tail = path.split(new)
197 if head and tail and not path.exists(head):
198 makedirs(head)
199 rename(old, new)
200 head, tail = path.split(old)
201 if head and tail:
202 try:
203 removedirs(head)
204 except error:
205 pass
206
207 __all__.extend(["makedirs", "removedirs", "renames"])
208
209 def walk(top, topdown=True, onerror=None, followlinks=False):
210 """Directory tree generator.
211
212 For each directory in the directory tree rooted at top (including top
213 itself, but excluding '.' and '..'), yields a 3-tuple
214
215 dirpath, dirnames, filenames
216
217 dirpath is a string, the path to the directory. dirnames is a list of
218 the names of the subdirectories in dirpath (excluding '.' and '..').
219 filenames is a list of the names of the non-directory files in dirpath.
220 Note that the names in the lists are just names, with no path components.
221 To get a full path (which begins with top) to a file or directory in
222 dirpath, do os.path.join(dirpath, name).
223
224 If optional arg 'topdown' is true or not specified, the triple for a
225 directory is generated before the triples for any of its subdirectories
226 (directories are generated top down). If topdown is false, the triple
227 for a directory is generated after the triples for all of its
228 subdirectories (directories are generated bottom up).
229
230 When topdown is true, the caller can modify the dirnames list in-place
231 (e.g., via del or slice assignment), and walk will only recurse into the
232 subdirectories whose names remain in dirnames; this can be used to prune the
233 search, or to impose a specific order of visiting. Modifying dirnames when
234 topdown is false is ineffective, since the directories in dirnames have
235 already been generated by the time dirnames itself is generated. No matter
236 the value of topdown, the list of subdirectories is retrieved before the
237 tuples for the directory and its subdirectories are generated.
238
239 By default errors from the os.listdir() call are ignored. If
240 optional arg 'onerror' is specified, it should be a function; it
241 will be called with one argument, an os.error instance. It can
242 report the error to continue with the walk, or raise the exception
243 to abort the walk. Note that the filename is available as the
244 filename attribute of the exception object.
245
246 By default, os.walk does not follow symbolic links to subdirectories on
247 systems that support them. In order to get this functionality, set the
248 optional argument 'followlinks' to true.
249
250 Caution: if you pass a relative pathname for top, don't change the
251 current working directory between resumptions of walk. walk never
252 changes the current directory, and assumes that the client doesn't
253 either.
254
255 Example:
256
257 import os
258 from os.path import join, getsize
259 for root, dirs, files in os.walk('python/Lib/email'):
260 print root, "consumes",
261 print sum([getsize(join(root, name)) for name in files]),
262 print "bytes in", len(files), "non-directory files"
263 if 'CVS' in dirs:
264 dirs.remove('CVS') # don't visit CVS directories
265
266 """
267
268 islink, join, isdir = path.islink, path.join, path.isdir
269
270 # We may not have read permission for top, in which case we can't
271 # get a list of the files the directory contains. os.path.walk
272 # always suppressed the exception then, rather than blow up for a
273 # minor reason when (say) a thousand readable directories are still
274 # left to visit. That logic is copied here.
275 try:
276 # Note that listdir and error are globals in this module due
277 # to earlier import-*.
278 names = listdir(top)
279 except error, err:
280 if onerror is not None:
281 onerror(err)
282 return
283
284 dirs, nondirs = [], []
285 for name in names:
286 if isdir(join(top, name)):
287 dirs.append(name)
288 else:
289 nondirs.append(name)
290
291 if topdown:
292 yield top, dirs, nondirs
293 for name in dirs:
294 new_path = join(top, name)
295 if followlinks or not islink(new_path):
296 for x in walk(new_path, topdown, onerror, followlinks):
297 yield x
298 if not topdown:
299 yield top, dirs, nondirs
300
301 __all__.append("walk")
302
303 # Make sure os.environ exists, at least
304 try:
305 environ
306 except NameError:
307 environ = {}
308
309 def execl(file, *args):
310 """execl(file, *args)
311
312 Execute the executable file with argument list args, replacing the
313 current process. """
314 execv(file, args)
315
316 def execle(file, *args):
317 """execle(file, *args, env)
318
319 Execute the executable file with argument list args and
320 environment env, replacing the current process. """
321 env = args[-1]
322 execve(file, args[:-1], env)
323
324 def execlp(file, *args):
325 """execlp(file, *args)
326
327 Execute the executable file (which is searched for along $PATH)
328 with argument list args, replacing the current process. """
329 execvp(file, args)
330
331 def execlpe(file, *args):
332 """execlpe(file, *args, env)
333
334 Execute the executable file (which is searched for along $PATH)
335 with argument list args and environment env, replacing the current
336 process. """
337 env = args[-1]
338 execvpe(file, args[:-1], env)
339
340 def execvp(file, args):
341 """execvp(file, args)
342
343 Execute the executable file (which is searched for along $PATH)
344 with argument list args, replacing the current process.
345 args may be a list or tuple of strings. """
346 _execvpe(file, args)
347
348 def execvpe(file, args, env):
349 """execvpe(file, args, env)
350
351 Execute the executable file (which is searched for along $PATH)
352 with argument list args and environment env , replacing the
353 current process.
354 args may be a list or tuple of strings. """
355 _execvpe(file, args, env)
356
357 __all__.extend(["execl","execle","execlp","execlpe","execvp","execvpe"])
358
359 def _execvpe(file, args, env=None):
360 if env is not None:
361 func = execve
362 argrest = (args, env)
363 else:
364 func = execv
365 argrest = (args,)
366 env = environ
367
368 head, tail = path.split(file)
369 if head:
370 func(file, *argrest)
371 return
372 if 'PATH' in env:
373 envpath = env['PATH']
374 else:
375 envpath = defpath
376 PATH = envpath.split(pathsep)
377 saved_exc = None
378 saved_tb = None
379 for dir in PATH:
380 fullname = path.join(dir, file)
381 try:
382 func(fullname, *argrest)
383 except error, e:
384 tb = sys.exc_info()[2]
385 if (e.errno != errno.ENOENT and e.errno != errno.ENOTDIR
386 and saved_exc is None):
387 saved_exc = e
388 saved_tb = tb
389 if saved_exc:
390 raise error, saved_exc, saved_tb
391 raise error, e, tb
392
393 # Change environ to automatically call putenv() if it exists
394 try:
395 # This will fail if there's no putenv
396 putenv
397 except NameError:
398 pass
399 else:
400 import UserDict
401
402 # Fake unsetenv() for Windows
403 # not sure about os2 here but
404 # I'm guessing they are the same.
405
406 if name in ('os2', 'nt'):
407 def unsetenv(key):
408 putenv(key, "")
409
410 if name == "riscos":
411 # On RISC OS, all env access goes through getenv and putenv
412 from riscosenviron import _Environ
413 elif name in ('os2', 'nt'): # Where Env Var Names Must Be UPPERCASE
414 # But we store them as upper case
415 class _Environ(UserDict.IterableUserDict):
416 def __init__(self, environ):
417 UserDict.UserDict.__init__(self)
418 data = self.data
419 for k, v in environ.items():
420 data[k.upper()] = v
421 def __setitem__(self, key, item):
422 putenv(key, item)
423 self.data[key.upper()] = item
424 def __getitem__(self, key):
425 return self.data[key.upper()]
426 try:
427 unsetenv
428 except NameError:
429 def __delitem__(self, key):
430 del self.data[key.upper()]
431 else:
432 def __delitem__(self, key):
433 unsetenv(key)
434 del self.data[key.upper()]
435 def clear(self):
436 for key in self.data.keys():
437 unsetenv(key)
438 del self.data[key]
439 def pop(self, key, *args):
440 unsetenv(key)
441 return self.data.pop(key.upper(), *args)
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 clear(self):
500 for key in self.data.keys():
501 unsetenv(key)
502 del self.data[key]
503 def pop(self, key, *args):
504 unsetenv(key)
505 return self.data.pop(key, *args)
506 def copy(self):
507 return dict(self)
508
509
510 environ = _Environ(environ)
511
512 def getenv(key, default=None):
513 """Get an environment variable, return None if it doesn't exist.
514 The optional second argument can specify an alternate default."""
515 return environ.get(key, default)
516 __all__.append("getenv")
517
518 def _exists(name):
519 return name in globals()
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 warnings
666 msg = "os.popen2 is deprecated. Use the subprocess module."
667 warnings.warn(msg, DeprecationWarning, stacklevel=2)
668
669 import subprocess
670 PIPE = subprocess.PIPE
671 p = subprocess.Popen(cmd, shell=isinstance(cmd, basestring),
672 bufsize=bufsize, stdin=PIPE, stdout=PIPE,
673 close_fds=True)
674 return p.stdin, p.stdout
675 __all__.append("popen2")
676
677 if not _exists("popen3"):
678 def popen3(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, child_stderr) are returned."""
685 import warnings
686 msg = "os.popen3 is deprecated. Use the subprocess module."
687 warnings.warn(msg, DeprecationWarning, stacklevel=2)
688
689 import subprocess
690 PIPE = subprocess.PIPE
691 p = subprocess.Popen(cmd, shell=isinstance(cmd, basestring),
692 bufsize=bufsize, stdin=PIPE, stdout=PIPE,
693 stderr=PIPE, close_fds=True)
694 return p.stdin, p.stdout, p.stderr
695 __all__.append("popen3")
696
697 if not _exists("popen4"):
698 def popen4(cmd, mode="t", bufsize=-1):
699 """Execute the shell command 'cmd' in a sub-process. On UNIX, 'cmd'
700 may be a sequence, in which case arguments will be passed directly to
701 the program without shell intervention (as with os.spawnv()). If 'cmd'
702 is a string it will be passed to the shell (as with os.system()). If
703 'bufsize' is specified, it sets the buffer size for the I/O pipes. The
704 file objects (child_stdin, child_stdout_stderr) are returned."""
705 import warnings
706 msg = "os.popen4 is deprecated. Use the subprocess module."
707 warnings.warn(msg, DeprecationWarning, stacklevel=2)
708
709 import subprocess
710 PIPE = subprocess.PIPE
711 p = subprocess.Popen(cmd, shell=isinstance(cmd, basestring),
712 bufsize=bufsize, stdin=PIPE, stdout=PIPE,
713 stderr=subprocess.STDOUT, close_fds=True)
714 return p.stdin, p.stdout
715 __all__.append("popen4")
716
717 import copy_reg as _copy_reg
718
719 def _make_stat_result(tup, dict):
720 return stat_result(tup, dict)
721
722 def _pickle_stat_result(sr):
723 (type, args) = sr.__reduce__()
724 return (_make_stat_result, args)
725
726 try:
727 _copy_reg.pickle(stat_result, _pickle_stat_result, _make_stat_result)
728 except NameError: # stat_result may not exist
729 pass
730
731 def _make_statvfs_result(tup, dict):
732 return statvfs_result(tup, dict)
733
734 def _pickle_statvfs_result(sr):
735 (type, args) = sr.__reduce__()
736 return (_make_statvfs_result, args)
737
738 try:
739 _copy_reg.pickle(statvfs_result, _pickle_statvfs_result,
740 _make_statvfs_result)
741 except NameError: # statvfs_result may not exist
742 pass