os.py revision 22b457e03bf5123c0a407e245567bee940de7cd5
1r"""OS routines for Mac, DOS, NT, or Posix depending on what system we're on. 2 3This 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 17Programs that import and use 'os' stand a better chance of being 18portable between different platforms. Of course, they must then 19only use functions that are defined by all platforms (e.g., unlink 20and opendir), and leave all pathname manipulation to os.path 21(e.g., split and join). 22""" 23 24#' 25 26import 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 35def _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 41if '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 55elif '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 69elif '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 87elif '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 101elif '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 116elif '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 130else: 131 raise ImportError, 'no os specific module found' 132 133sys.modules['os.path'] = path 134from os.path import (curdir, pardir, sep, pathsep, defpath, extsep, altsep, 135 devnull) 136 137del _names 138 139# Python uses fixed values for the SEEK_ constants; they are mapped 140# to native constants if necessary in posixmodule.c 141SEEK_SET = 0 142SEEK_CUR = 1 143SEEK_END = 2 144 145#' 146 147# Super directory utilities. 148# (Inspired by Eric Raymond; the doc strings are mostly his) 149 150def 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 168def removedirs(name): 169 """removedirs(path) 170 171 Super-rmdir; remove a leaf directory and empty all 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 190def 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 218def 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 306try: 307 environ 308except NameError: 309 environ = {} 310 311def 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 318def 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 326def 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 333def 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 342def 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 350def 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 361def _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 398try: 399 # This will fail if there's no putenv 400 putenv 401except NameError: 402 pass 403else: 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 copy(self): 446 return dict(self) 447 448 else: # Where Env Var Names Can Be Mixed Case 449 class _Environ(UserDict.IterableUserDict): 450 def __init__(self, environ): 451 UserDict.UserDict.__init__(self) 452 self.data = environ 453 def __setitem__(self, key, item): 454 putenv(key, item) 455 self.data[key] = item 456 try: 457 unsetenv 458 except NameError: 459 pass 460 else: 461 def __delitem__(self, key): 462 unsetenv(key) 463 del self.data[key] 464 def copy(self): 465 return dict(self) 466 467 468 environ = _Environ(environ) 469 470def getenv(key, default=None): 471 """Get an environment variable, return None if it doesn't exist. 472 The optional second argument can specify an alternate default.""" 473 return environ.get(key, default) 474__all__.append("getenv") 475 476def _exists(name): 477 try: 478 eval(name) 479 return True 480 except NameError: 481 return False 482 483# Supply spawn*() (probably only for Unix) 484if _exists("fork") and not _exists("spawnv") and _exists("execv"): 485 486 P_WAIT = 0 487 P_NOWAIT = P_NOWAITO = 1 488 489 # XXX Should we support P_DETACH? I suppose it could fork()**2 490 # and close the std I/O streams. Also, P_OVERLAY is the same 491 # as execv*()? 492 493 def _spawnvef(mode, file, args, env, func): 494 # Internal helper; func is the exec*() function to use 495 pid = fork() 496 if not pid: 497 # Child 498 try: 499 if env is None: 500 func(file, args) 501 else: 502 func(file, args, env) 503 except: 504 _exit(127) 505 else: 506 # Parent 507 if mode == P_NOWAIT: 508 return pid # Caller is responsible for waiting! 509 while 1: 510 wpid, sts = waitpid(pid, 0) 511 if WIFSTOPPED(sts): 512 continue 513 elif WIFSIGNALED(sts): 514 return -WTERMSIG(sts) 515 elif WIFEXITED(sts): 516 return WEXITSTATUS(sts) 517 else: 518 raise error, "Not stopped, signaled or exited???" 519 520 def spawnv(mode, file, args): 521 """spawnv(mode, file, args) -> integer 522 523Execute file with arguments from args in a subprocess. 524If mode == P_NOWAIT return the pid of the process. 525If mode == P_WAIT return the process's exit code if it exits normally; 526otherwise return -SIG, where SIG is the signal that killed it. """ 527 return _spawnvef(mode, file, args, None, execv) 528 529 def spawnve(mode, file, args, env): 530 """spawnve(mode, file, args, env) -> integer 531 532Execute file with arguments from args in a subprocess with the 533specified environment. 534If mode == P_NOWAIT return the pid of the process. 535If mode == P_WAIT return the process's exit code if it exits normally; 536otherwise return -SIG, where SIG is the signal that killed it. """ 537 return _spawnvef(mode, file, args, env, execve) 538 539 # Note: spawnvp[e] is't currently supported on Windows 540 541 def spawnvp(mode, file, args): 542 """spawnvp(mode, file, args) -> integer 543 544Execute file (which is looked for along $PATH) with arguments from 545args in a subprocess. 546If mode == P_NOWAIT return the pid of the process. 547If mode == P_WAIT return the process's exit code if it exits normally; 548otherwise return -SIG, where SIG is the signal that killed it. """ 549 return _spawnvef(mode, file, args, None, execvp) 550 551 def spawnvpe(mode, file, args, env): 552 """spawnvpe(mode, file, args, env) -> integer 553 554Execute file (which is looked for along $PATH) with arguments from 555args in a subprocess with the supplied environment. 556If mode == P_NOWAIT return the pid of the process. 557If mode == P_WAIT return the process's exit code if it exits normally; 558otherwise return -SIG, where SIG is the signal that killed it. """ 559 return _spawnvef(mode, file, args, env, execvpe) 560 561if _exists("spawnv"): 562 # These aren't supplied by the basic Windows code 563 # but can be easily implemented in Python 564 565 def spawnl(mode, file, *args): 566 """spawnl(mode, file, *args) -> integer 567 568Execute file with arguments from args in a subprocess. 569If mode == P_NOWAIT return the pid of the process. 570If mode == P_WAIT return the process's exit code if it exits normally; 571otherwise return -SIG, where SIG is the signal that killed it. """ 572 return spawnv(mode, file, args) 573 574 def spawnle(mode, file, *args): 575 """spawnle(mode, file, *args, env) -> integer 576 577Execute file with arguments from args in a subprocess with the 578supplied environment. 579If mode == P_NOWAIT return the pid of the process. 580If mode == P_WAIT return the process's exit code if it exits normally; 581otherwise return -SIG, where SIG is the signal that killed it. """ 582 env = args[-1] 583 return spawnve(mode, file, args[:-1], env) 584 585 586 __all__.extend(["spawnv", "spawnve", "spawnl", "spawnle",]) 587 588 589if _exists("spawnvp"): 590 # At the moment, Windows doesn't implement spawnvp[e], 591 # so it won't have spawnlp[e] either. 592 def spawnlp(mode, file, *args): 593 """spawnlp(mode, file, *args) -> integer 594 595Execute file (which is looked for along $PATH) with arguments from 596args in a subprocess with the supplied environment. 597If mode == P_NOWAIT return the pid of the process. 598If mode == P_WAIT return the process's exit code if it exits normally; 599otherwise return -SIG, where SIG is the signal that killed it. """ 600 return spawnvp(mode, file, args) 601 602 def spawnlpe(mode, file, *args): 603 """spawnlpe(mode, file, *args, env) -> integer 604 605Execute file (which is looked for along $PATH) with arguments from 606args in a subprocess with the supplied environment. 607If mode == P_NOWAIT return the pid of the process. 608If mode == P_WAIT return the process's exit code if it exits normally; 609otherwise return -SIG, where SIG is the signal that killed it. """ 610 env = args[-1] 611 return spawnvpe(mode, file, args[:-1], env) 612 613 614 __all__.extend(["spawnvp", "spawnvpe", "spawnlp", "spawnlpe",]) 615 616 617# Supply popen2 etc. (for Unix) 618if _exists("fork"): 619 if not _exists("popen2"): 620 def popen2(cmd, mode="t", bufsize=-1): 621 """Execute the shell command 'cmd' in a sub-process. On UNIX, 'cmd' 622 may be a sequence, in which case arguments will be passed directly to 623 the program without shell intervention (as with os.spawnv()). If 'cmd' 624 is a string it will be passed to the shell (as with os.system()). If 625 'bufsize' is specified, it sets the buffer size for the I/O pipes. The 626 file objects (child_stdin, child_stdout) are returned.""" 627 import popen2 628 stdout, stdin = popen2.popen2(cmd, bufsize) 629 return stdin, stdout 630 __all__.append("popen2") 631 632 if not _exists("popen3"): 633 def popen3(cmd, mode="t", bufsize=-1): 634 """Execute the shell command 'cmd' in a sub-process. On UNIX, 'cmd' 635 may be a sequence, in which case arguments will be passed directly to 636 the program without shell intervention (as with os.spawnv()). If 'cmd' 637 is a string it will be passed to the shell (as with os.system()). If 638 'bufsize' is specified, it sets the buffer size for the I/O pipes. The 639 file objects (child_stdin, child_stdout, child_stderr) are returned.""" 640 import popen2 641 stdout, stdin, stderr = popen2.popen3(cmd, bufsize) 642 return stdin, stdout, stderr 643 __all__.append("popen3") 644 645 if not _exists("popen4"): 646 def popen4(cmd, mode="t", bufsize=-1): 647 """Execute the shell command 'cmd' in a sub-process. On UNIX, 'cmd' 648 may be a sequence, in which case arguments will be passed directly to 649 the program without shell intervention (as with os.spawnv()). If 'cmd' 650 is a string it will be passed to the shell (as with os.system()). If 651 'bufsize' is specified, it sets the buffer size for the I/O pipes. The 652 file objects (child_stdin, child_stdout_stderr) are returned.""" 653 import popen2 654 stdout, stdin = popen2.popen4(cmd, bufsize) 655 return stdin, stdout 656 __all__.append("popen4") 657 658import copy_reg as _copy_reg 659 660def _make_stat_result(tup, dict): 661 return stat_result(tup, dict) 662 663def _pickle_stat_result(sr): 664 (type, args) = sr.__reduce__() 665 return (_make_stat_result, args) 666 667try: 668 _copy_reg.pickle(stat_result, _pickle_stat_result, _make_stat_result) 669except NameError: # stat_result may not exist 670 pass 671 672def _make_statvfs_result(tup, dict): 673 return statvfs_result(tup, dict) 674 675def _pickle_statvfs_result(sr): 676 (type, args) = sr.__reduce__() 677 return (_make_statvfs_result, args) 678 679try: 680 _copy_reg.pickle(statvfs_result, _pickle_statvfs_result, 681 _make_statvfs_result) 682except NameError: # statvfs_result may not exist 683 pass 684 685if not _exists("urandom"): 686 _urandomfd = None 687 def urandom(n): 688 """urandom(n) -> str 689 690 Return a string of n random bytes suitable for cryptographic use. 691 692 """ 693 global _urandomfd 694 if _urandomfd is None: 695 try: 696 _urandomfd = open("/dev/urandom", O_RDONLY) 697 except: 698 _urandomfd = NotImplementedError 699 if _urandomfd is NotImplementedError: 700 raise NotImplementedError("/dev/urandom (or equivalent) not found") 701 bytes = "" 702 while len(bytes) < n: 703 bytes += read(_urandomfd, n - len(bytes)) 704 return bytes 705