Lib/os.py

   1 """OS routines for Mac, DOS, NT, or Posix depending on what system we're on.
   2
   3 This exports:
   4   - all functions from posix, nt, dos, os2, mac, or ce, e.g. unlink, stat, etc.
   5   - os.path is one of the modules posixpath, ntpath, macpath, or dospath
   6   - os.name is 'posix', 'nt', 'dos', 'os2', 'mac', or 'ce'
   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.altsep is the alternate pathname separator (None or '/')
  11   - os.pathsep is the component separator used in $PATH etc
  12   - os.linesep is the line separator in text files ('\r' or '\n' or '\r\n')
  13   - os.defpath is the default search path for executables
  14
  15 Programs that import and use 'os' stand a better chance of being
  16 portable between different platforms.  Of course, they must then
  17 only use functions that are defined by all platforms (e.g., unlink
  18 and opendir), and leave all pathname manipulation to os.path
  19 (e.g., split and join).
  20 """
  21
  22 import sys
  23
  24 _names = sys.builtin_module_names
  25
  26 altsep = None
  27
  28 if 'posix' in _names:
  29     name = 'posix'
  30     linesep = '\n'
  31     curdir = '.'; pardir = '..'; sep = '/'; pathsep = ':'
  32     defpath = ':/bin:/usr/bin'
  33     from posix import *
  34     try:
  35         from posix import _exit
  36     except ImportError:
  37         pass
  38     import posixpath
  39     path = posixpath
  40     del posixpath
  41 elif 'nt' in _names:
  42     name = 'nt'
  43     linesep = '\r\n'
  44     curdir = '.'; pardir = '..'; sep = '\\'; pathsep = ';'
  45     defpath = '.;C:\\bin'
  46     from nt import *
  47     for i in ['_exit']:
  48         try:
  49             exec "from nt import " + i
  50         except ImportError:
  51             pass
  52     import ntpath
  53     path = ntpath
  54     del ntpath
  55 elif 'dos' in _names:
  56     name = 'dos'
  57     linesep = '\r\n'
  58     curdir = '.'; pardir = '..'; sep = '\\'; pathsep = ';'
  59     defpath = '.;C:\\bin'
  60     from dos import *
  61     try:
  62         from dos import _exit
  63     except ImportError:
  64         pass
  65     import dospath
  66     path = dospath
  67     del dospath
  68 elif 'os2' in _names:
  69     name = 'os2'
  70     linesep = '\r\n'
  71     curdir = '.'; pardir = '..'; sep = '\\'; pathsep = ';'
  72     defpath = '.;C:\\bin'
  73     from os2 import *
  74     try:
  75         from os2 import _exit
  76     except ImportError:
  77         pass
  78     import ntpath
  79     path = ntpath
  80     del ntpath
  81 elif 'mac' in _names:
  82     name = 'mac'
  83     linesep = '\r'
  84     curdir = ':'; pardir = '::'; sep = ':'; pathsep = '\n'
  85     defpath = ':'
  86     from mac import *
  87     try:
  88         from mac import _exit
  89     except ImportError:
  90         pass
  91     import macpath
  92     path = macpath
  93     del macpath
  94 elif 'ce' in _names:
  95     name = 'ce'
  96     linesep = '\r\n'
  97     curdir = '.'; pardir = '..'; sep = '\\'; pathsep = ';'
  98     defpath = '\\Windows'
  99     from ce import *
 100     for i in ['_exit']:
 101         try:
 102             exec "from ce import " + i
 103         except ImportError:
 104             pass
 105     # We can use the standard Windows path.
 106     import ntpath
 107     path = ntpath
 108     del ntpath
 109 else:
 110     raise ImportError, 'no os specific module found'
 111
 112 del _names
 113
 114 sys.modules['os.path'] = path
 115
 116 # Super directory utilities.
 117 # (Inspired by Eric Raymond; the doc strings are mostly his)
 118
 119 def makedirs(name, mode=0777):
 120     """makedirs(path [, mode=0777]) -> None
 121
 122     Super-mkdir; create a leaf directory and all intermediate ones.
 123     Works like mkdir, except that any intermediate path segment (not
 124     just the rightmost) will be created if it does not exist.  This is
 125     recursive.
 126
 127     """
 128     head, tail = path.split(name)
 129     if not tail:
 130         head, tail = path.split(head)
 131     if head and tail and not path.exists(head):
 132         makedirs(head, mode)
 133     mkdir(name, mode)
 134
 135 def removedirs(name):
 136     """removedirs(path) -> None
 137
 138     Super-rmdir; remove a leaf directory and empty all intermediate
 139     ones.  Works like rmdir except that, if the leaf directory is
 140     successfully removed, directories corresponding to rightmost path
 141     segments will be pruned way until either the whole path is
 142     consumed or an error occurs.  Errors during this latter phase are
 143     ignored -- they generally mean that a directory was not empty.
 144
 145     """
 146     rmdir(name)
 147     head, tail = path.split(name)
 148     if not tail:
 149         head, tail = path.split(head)
 150     while head and tail:
 151         try:
 152             rmdir(head)
 153         except error:
 154             break
 155         head, tail = path.split(head)
 156
 157 def renames(old, new):
 158     """renames(old, new) -> None
 159
 160     Super-rename; create directories as necessary and delete any left
 161     empty.  Works like rename, except creation of any intermediate
 162     directories needed to make the new pathname good is attempted
 163     first.  After the rename, directories corresponding to rightmost
 164     path segments of the old name will be pruned way until either the
 165     whole path is consumed or a nonempty directory is found.
 166
 167     Note: this function can fail with the new directory structure made
 168     if you lack permissions needed to unlink the leaf directory or
 169     file.
 170
 171     """
 172     head, tail = path.split(new)
 173     if head and tail and not path.exists(head):
 174         makedirs(head)
 175     rename(old, new)
 176     head, tail = path.split(old)
 177     if head and tail:
 178         try:
 179             removedirs(head)
 180         except error:
 181             pass
 182
 183 # Make sure os.environ exists, at least
 184 try:
 185     environ
 186 except NameError:
 187     environ = {}
 188
 189 def execl(file, *args):
 190     """execl(file, *args)
 191
 192     Execute the executable file with argument list args, replacing the
 193     current process. """
 194     execv(file, args)
 195
 196 def execle(file, *args):
 197     """execle(file, *args, env)
 198
 199     Execute the executable file with argument list args and
 200     environment env, replacing the current process. """
 201     env = args[-1]
 202     execve(file, args[:-1], env)
 203
 204 def execlp(file, *args):
 205     """execlp(file, *args)
 206
 207     Execute the executable file (which is searched for along $PATH)
 208     with argument list args, replacing the current process. """
 209     execvp(file, args)
 210
 211 def execlpe(file, *args):
 212     """execlpe(file, *args, env)
 213
 214     Execute the executable file (which is searched for along $PATH)
 215     with argument list args and environment env, replacing the current
 216     process. """
 217     env = args[-1]
 218     execvpe(file, args[:-1], env)
 219
 220 def execvp(file, args):
 221     """execp(file, args)
 222
 223     Execute the executable file (which is searched for along $PATH)
 224     with argument list args, replacing the current process.
 225     args may be a list or tuple of strings. """
 226     _execvpe(file, args)
 227
 228 def execvpe(file, args, env):
 229     """execv(file, args, env)
 230
 231     Execute the executable file (which is searched for along $PATH)
 232     with argument list args and environment env , replacing the
 233     current process.
 234     args may be a list or tuple of strings. """
 235     _execvpe(file, args, env)
 236
 237 _notfound = None
 238 def _execvpe(file, args, env=None):
 239     if env is not None:
 240         func = execve
 241         argrest = (args, env)
 242     else:
 243         func = execv
 244         argrest = (args,)
 245         env = environ
 246     global _notfound
 247     head, tail = path.split(file)
 248     if head:
 249         apply(func, (file,) + argrest)
 250         return
 251     if env.has_key('PATH'):
 252         envpath = env['PATH']
 253     else:
 254         envpath = defpath
 255     PATH = envpath.split(pathsep)
 256     if not _notfound:
 257         import tempfile
 258         # Exec a file that is guaranteed not to exist
 259         try: execv(tempfile.mktemp(), ('blah',))
 260         except error, _notfound: pass
 261     exc, arg = error, _notfound
 262     for dir in PATH:
 263         fullname = path.join(dir, file)
 264         try:
 265             apply(func, (fullname,) + argrest)
 266         except error, (errno, msg):
 267             if errno != arg[0]:
 268                 exc, arg = error, (errno, msg)
 269     raise exc, arg
 270
 271 # Change environ to automatically call putenv() if it exists
 272 try:
 273     # This will fail if there's no putenv
 274     putenv
 275 except NameError:
 276     pass
 277 else:
 278     import UserDict
 279
 280     if name in ('os2', 'nt', 'dos'):  # Where Env Var Names Must Be UPPERCASE
 281         # But we store them as upper case
 282         class _Environ(UserDict.UserDict):
 283             def __init__(self, environ):
 284                 UserDict.UserDict.__init__(self)
 285                 data = self.data
 286                 for k, v in environ.items():
 287                     data[k.upper()] = v
 288             def __setitem__(self, key, item):
 289                 putenv(key, item)
 290                 self.data[key.upper()] = item
 291             def __getitem__(self, key):
 292                 return self.data[key.upper()]
 293             def __delitem__(self, key):
 294                 del self.data[key.upper()]
 295             def has_key(self, key):
 296                 return self.data.has_key(key.upper())
 297             def get(self, key, failobj=None):
 298                 return self.data.get(key.upper(), failobj)
 299             def update(self, dict):
 300                 for k, v in dict.items():
 301                     self[k] = v
 302
 303     else:  # Where Env Var Names Can Be Mixed Case
 304         class _Environ(UserDict.UserDict):
 305             def __init__(self, environ):
 306                 UserDict.UserDict.__init__(self)
 307                 self.data = environ
 308             def __setitem__(self, key, item):
 309                 putenv(key, item)
 310                 self.data[key] = item
 311             def update(self, dict):
 312                 for k, v in dict.items():
 313                     self[k] = v
 314
 315     environ = _Environ(environ)
 316
 317 def getenv(key, default=None):
 318     """Get an environment variable, return None if it doesn't exist.
 319
 320     The optional second argument can specify an alternative default."""
 321     return environ.get(key, default)
 322
 323 def _exists(name):
 324     try:
 325         eval(name)
 326         return 1
 327     except NameError:
 328         return 0
 329
 330 # Supply spawn*() (probably only for Unix)
 331 if _exists("fork") and not _exists("spawnv") and _exists("execv"):
 332
 333     P_WAIT = 0
 334     P_NOWAIT = P_NOWAITO = 1
 335
 336     # XXX Should we support P_DETACH?  I suppose it could fork()**2
 337     # and close the std I/O streams.  Also, P_OVERLAY is the same
 338     # as execv*()?
 339
 340     def _spawnvef(mode, file, args, env, func):
 341         # Internal helper; func is the exec*() function to use
 342         pid = fork()
 343         if not pid:
 344             # Child
 345             try:
 346                 if env is None:
 347                     func(file, args)
 348                 else:
 349                     func(file, args, env)
 350             except:
 351                 _exit(127)
 352         else:
 353             # Parent
 354             if mode == P_NOWAIT:
 355                 return pid # Caller is responsible for waiting!
 356             while 1:
 357                 wpid, sts = waitpid(pid, 0)
 358                 if WIFSTOPPED(sts):
 359                     continue
 360                 elif WIFSIGNALED(sts):
 361                     return -WTERMSIG(sts)
 362                 elif WIFEXITED(sts):
 363                     return WEXITSTATUS(sts)
 364                 else:
 365                     raise error, "Not stopped, signaled or exited???"
 366
 367     def spawnv(mode, file, args):
 368         """spawnv(mode, file, args) -> integer
 369
 370 Execute file with arguments from args in a subprocess.
 371 If mode == P_NOWAIT return the pid of the process.
 372 If mode == P_WAIT return the process's exit code if it exits normally;
 373 otherwise return -SIG, where SIG is the signal that killed it. """
 374         return _spawnvef(mode, file, args, None, execv)
 375
 376     def spawnve(mode, file, args, env):
 377         """spawnve(mode, file, args, env) -> integer
 378
 379 Execute file with arguments from args in a subprocess with the
 380 specified environment.
 381 If mode == P_NOWAIT return the pid of the process.
 382 If mode == P_WAIT return the process's exit code if it exits normally;
 383 otherwise return -SIG, where SIG is the signal that killed it. """
 384         return _spawnvef(mode, file, args, env, execve)
 385
 386     # Note: spawnvp[e] is't currently supported on Windows
 387
 388     def spawnvp(mode, file, args):
 389         """spawnvp(mode, file, args) -> integer
 390
 391 Execute file (which is looked for along $PATH) with arguments from
 392 args in a subprocess.
 393 If mode == P_NOWAIT return the pid of the process.
 394 If mode == P_WAIT return the process's exit code if it exits normally;
 395 otherwise return -SIG, where SIG is the signal that killed it. """
 396         return _spawnvef(mode, file, args, None, execvp)
 397
 398     def spawnvpe(mode, file, args, env):
 399         """spawnvpe(mode, file, args, env) -> integer
 400
 401 Execute file (which is looked for along $PATH) with arguments from
 402 args in a subprocess with the supplied environment.
 403 If mode == P_NOWAIT return the pid of the process.
 404 If mode == P_WAIT return the process's exit code if it exits normally;
 405 otherwise return -SIG, where SIG is the signal that killed it. """
 406         return _spawnvef(mode, file, args, env, execvpe)
 407
 408 if _exists("spawnv"):
 409     # These aren't supplied by the basic Windows code
 410     # but can be easily implemented in Python
 411
 412     def spawnl(mode, file, *args):
 413         """spawnl(mode, file, *args) -> integer
 414
 415 Execute file with arguments from args in a subprocess.
 416 If mode == P_NOWAIT return the pid of the process.
 417 If mode == P_WAIT return the process's exit code if it exits normally;
 418 otherwise return -SIG, where SIG is the signal that killed it. """
 419         return spawnv(mode, file, args)
 420
 421     def spawnle(mode, file, *args):
 422         """spawnle(mode, file, *args, env) -> integer
 423
 424 Execute file with arguments from args in a subprocess with the
 425 supplied environment.
 426 If mode == P_NOWAIT return the pid of the process.
 427 If mode == P_WAIT return the process's exit code if it exits normally;
 428 otherwise return -SIG, where SIG is the signal that killed it. """
 429         env = args[-1]
 430         return spawnve(mode, file, args[:-1], env)
 431
 432 if _exists("spawnvp"):
 433     # At the moment, Windows doesn't implement spawnvp[e],
 434     # so it won't have spawnlp[e] either.
 435     def spawnlp(mode, file, *args):
 436         """spawnlp(mode, file, *args, env) -> integer
 437
 438 Execute file (which is looked for along $PATH) with arguments from
 439 args in a subprocess with the supplied environment.
 440 If mode == P_NOWAIT return the pid of the process.
 441 If mode == P_WAIT return the process's exit code if it exits normally;
 442 otherwise return -SIG, where SIG is the signal that killed it. """
 443         return spawnvp(mode, file, args)
 444
 445     def spawnlpe(mode, file, *args):
 446         """spawnlpe(mode, file, *args, env) -> integer
 447
 448 Execute file (which is looked for along $PATH) with arguments from
 449 args in a subprocess with the supplied environment.
 450 If mode == P_NOWAIT return the pid of the process.
 451 If mode == P_WAIT return the process's exit code if it exits normally;
 452 otherwise return -SIG, where SIG is the signal that killed it. """
 453         env = args[-1]
 454         return spawnvpe(mode, file, args[:-1], env)
 455
 456