os

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

736

Source Code for Module os