home *** CD-ROM | disk | FTP | other *** search
/ PC World 2001 April / PCWorld_2001-04_cd.bin / Software / TemaCD / webclean / !!!python!!! / BeOpen-Python-2.0.exe / OS.PY < prev    next >
Encoding:
Python Source  |  2000-09-28  |  15.4 KB  |  476 lines
  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 alternate 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.  
  457. # Supply popen2 etc. (for Unix)
  458. if _exists("fork"):
  459.     if not _exists("popen2"):
  460.         def popen2(cmd, mode="t", bufsize=-1):
  461.             import popen2
  462.             stdout, stdin = popen2.popen2(cmd, bufsize)
  463.             return stdin, stdout
  464.  
  465.     if not _exists("popen3"):
  466.         def popen3(cmd, mode="t", bufsize=-1):
  467.             import popen2
  468.             stdout, stdin, stderr = popen2.popen3(cmd, bufsize)
  469.             return stdin, stdout, stderr
  470.  
  471.     if not _exists("popen4"):
  472.         def popen4(cmd, mode="t", bufsize=-1):
  473.             import popen2
  474.             stdout, stdin = popen2.popen4(cmd, bufsize)
  475.             return stdin, stdout
  476.