home *** CD-ROM | disk | FTP | other *** search
/ Chip 2004 December / CHIP_CD_2004-12.iso / bonus / oo / OOo_1.1.3_ru_RU_infra_WinIntel_install.exe / $PLUGINSDIR / f_0372 / python-core-2.2.2 / lib / os.py < prev    next >
Text File  |  2004-10-09  |  18KB  |  613 lines
  1. r"""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', '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.  
  16. Programs that import and use 'os' stand a better chance of being
  17. portable between different platforms.  Of course, they must then
  18. only use functions that are defined by all platforms (e.g., unlink
  19. and opendir), and leave all pathname manipulation to os.path
  20. (e.g., split and join).
  21. """
  22.  
  23. #'
  24.  
  25. import sys
  26.  
  27. _names = sys.builtin_module_names
  28.  
  29. altsep = None
  30.  
  31. __all__ = ["altsep", "curdir", "pardir", "sep", "pathsep", "linesep",
  32.            "defpath", "name"]
  33.  
  34. def _get_exports_list(module):
  35.     try:
  36.         return list(module.__all__)
  37.     except AttributeError:
  38.         return [n for n in dir(module) if n[0] != '_']
  39.  
  40. if 'posix' in _names:
  41.     name = 'posix'
  42.     linesep = '\n'
  43.     curdir = '.'; pardir = '..'; sep = '/'; pathsep = ':'
  44.     defpath = ':/bin:/usr/bin'
  45.     from posix import *
  46.     try:
  47.         from posix import _exit
  48.     except ImportError:
  49.         pass
  50.     import posixpath
  51.     path = posixpath
  52.     del posixpath
  53.  
  54.     import posix
  55.     __all__.extend(_get_exports_list(posix))
  56.     del posix
  57.  
  58. elif 'nt' in _names:
  59.     name = 'nt'
  60.     linesep = '\r\n'
  61.     curdir = '.'; pardir = '..'; sep = '\\'; pathsep = ';'
  62.     defpath = '.;C:\\bin'
  63.     from nt import *
  64.     for i in ['_exit']:
  65.         try:
  66.             exec "from nt import " + i
  67.         except ImportError:
  68.             pass
  69.     import ntpath
  70.     path = ntpath
  71.     del ntpath
  72.  
  73.     import nt
  74.     __all__.extend(_get_exports_list(nt))
  75.     del nt
  76.  
  77. elif 'dos' in _names:
  78.     name = 'dos'
  79.     linesep = '\r\n'
  80.     curdir = '.'; pardir = '..'; sep = '\\'; pathsep = ';'
  81.     defpath = '.;C:\\bin'
  82.     from dos import *
  83.     try:
  84.         from dos import _exit
  85.     except ImportError:
  86.         pass
  87.     import dospath
  88.     path = dospath
  89.     del dospath
  90.  
  91.     import dos
  92.     __all__.extend(_get_exports_list(dos))
  93.     del dos
  94.  
  95. elif 'os2' in _names:
  96.     name = 'os2'
  97.     linesep = '\r\n'
  98.     curdir = '.'; pardir = '..'; sep = '\\'; pathsep = ';'
  99.     defpath = '.;C:\\bin'
  100.     from os2 import *
  101.     try:
  102.         from os2 import _exit
  103.     except ImportError:
  104.         pass
  105.     import ntpath
  106.     path = ntpath
  107.     del ntpath
  108.  
  109.     import os2
  110.     __all__.extend(_get_exports_list(os2))
  111.     del os2
  112.  
  113. elif 'mac' in _names:
  114.     name = 'mac'
  115.     linesep = '\r'
  116.     curdir = ':'; pardir = '::'; sep = ':'; pathsep = '\n'
  117.     defpath = ':'
  118.     from mac import *
  119.     try:
  120.         from mac import _exit
  121.     except ImportError:
  122.         pass
  123.     import macpath
  124.     path = macpath
  125.     del macpath
  126.  
  127.     import mac
  128.     __all__.extend(_get_exports_list(mac))
  129.     del mac
  130.  
  131. elif 'ce' in _names:
  132.     name = 'ce'
  133.     linesep = '\r\n'
  134.     curdir = '.'; pardir = '..'; sep = '\\'; pathsep = ';'
  135.     defpath = '\\Windows'
  136.     from ce import *
  137.     for i in ['_exit']:
  138.         try:
  139.             exec "from ce import " + i
  140.         except ImportError:
  141.             pass
  142.     # We can use the standard Windows path.
  143.     import ntpath
  144.     path = ntpath
  145.     del ntpath
  146.  
  147.     import ce
  148.     __all__.extend(_get_exports_list(ce))
  149.     del ce
  150.  
  151. elif 'riscos' in _names:
  152.     name = 'riscos'
  153.     linesep = '\n'
  154.     curdir = '@'; pardir = '^'; sep = '.'; pathsep = ','
  155.     defpath = '<Run$Dir>'
  156.     from riscos import *
  157.     try:
  158.         from riscos import _exit
  159.     except ImportError:
  160.         pass
  161.     import riscospath
  162.     path = riscospath
  163.     del riscospath
  164.  
  165.     import riscos
  166.     __all__.extend(_get_exports_list(riscos))
  167.     del riscos
  168.  
  169. else:
  170.     raise ImportError, 'no os specific module found'
  171.  
  172.  
  173. if sep=='.':
  174.     extsep = '/'
  175. else:
  176.     extsep = '.'
  177.  
  178. __all__.append("path")
  179.  
  180. del _names
  181.  
  182. sys.modules['os.path'] = path
  183.  
  184. #'
  185.  
  186. # Super directory utilities.
  187. # (Inspired by Eric Raymond; the doc strings are mostly his)
  188.  
  189. def makedirs(name, mode=0777):
  190.     """makedirs(path [, mode=0777]) -> None
  191.  
  192.     Super-mkdir; create a leaf directory and all intermediate ones.
  193.     Works like mkdir, except that any intermediate path segment (not
  194.     just the rightmost) will be created if it does not exist.  This is
  195.     recursive.
  196.  
  197.     """
  198.     head, tail = path.split(name)
  199.     if not tail:
  200.         head, tail = path.split(head)
  201.     if head and tail and not path.exists(head):
  202.         makedirs(head, mode)
  203.     mkdir(name, mode)
  204.  
  205. def removedirs(name):
  206.     """removedirs(path) -> None
  207.  
  208.     Super-rmdir; remove a leaf directory and empty all intermediate
  209.     ones.  Works like rmdir except that, if the leaf directory is
  210.     successfully removed, directories corresponding to rightmost path
  211.     segments will be pruned way until either the whole path is
  212.     consumed or an error occurs.  Errors during this latter phase are
  213.     ignored -- they generally mean that a directory was not empty.
  214.  
  215.     """
  216.     rmdir(name)
  217.     head, tail = path.split(name)
  218.     if not tail:
  219.         head, tail = path.split(head)
  220.     while head and tail:
  221.         try:
  222.             rmdir(head)
  223.         except error:
  224.             break
  225.         head, tail = path.split(head)
  226.  
  227. def renames(old, new):
  228.     """renames(old, new) -> None
  229.  
  230.     Super-rename; create directories as necessary and delete any left
  231.     empty.  Works like rename, except creation of any intermediate
  232.     directories needed to make the new pathname good is attempted
  233.     first.  After the rename, directories corresponding to rightmost
  234.     path segments of the old name will be pruned way until either the
  235.     whole path is consumed or a nonempty directory is found.
  236.  
  237.     Note: this function can fail with the new directory structure made
  238.     if you lack permissions needed to unlink the leaf directory or
  239.     file.
  240.  
  241.     """
  242.     head, tail = path.split(new)
  243.     if head and tail and not path.exists(head):
  244.         makedirs(head)
  245.     rename(old, new)
  246.     head, tail = path.split(old)
  247.     if head and tail:
  248.         try:
  249.             removedirs(head)
  250.         except error:
  251.             pass
  252.  
  253. __all__.extend(["makedirs", "removedirs", "renames"])
  254.  
  255. # Make sure os.environ exists, at least
  256. try:
  257.     environ
  258. except NameError:
  259.     environ = {}
  260.  
  261. def execl(file, *args):
  262.     """execl(file, *args)
  263.  
  264.     Execute the executable file with argument list args, replacing the
  265.     current process. """
  266.     execv(file, args)
  267.  
  268. def execle(file, *args):
  269.     """execle(file, *args, env)
  270.  
  271.     Execute the executable file with argument list args and
  272.     environment env, replacing the current process. """
  273.     env = args[-1]
  274.     execve(file, args[:-1], env)
  275.  
  276. def execlp(file, *args):
  277.     """execlp(file, *args)
  278.  
  279.     Execute the executable file (which is searched for along $PATH)
  280.     with argument list args, replacing the current process. """
  281.     execvp(file, args)
  282.  
  283. def execlpe(file, *args):
  284.     """execlpe(file, *args, env)
  285.  
  286.     Execute the executable file (which is searched for along $PATH)
  287.     with argument list args and environment env, replacing the current
  288.     process. """
  289.     env = args[-1]
  290.     execvpe(file, args[:-1], env)
  291.  
  292. def execvp(file, args):
  293.     """execp(file, args)
  294.  
  295.     Execute the executable file (which is searched for along $PATH)
  296.     with argument list args, replacing the current process.
  297.     args may be a list or tuple of strings. """
  298.     _execvpe(file, args)
  299.  
  300. def execvpe(file, args, env):
  301.     """execvpe(file, args, env)
  302.  
  303.     Execute the executable file (which is searched for along $PATH)
  304.     with argument list args and environment env , replacing the
  305.     current process.
  306.     args may be a list or tuple of strings. """
  307.     _execvpe(file, args, env)
  308.  
  309. __all__.extend(["execl","execle","execlp","execlpe","execvp","execvpe"])
  310.  
  311. def _execvpe(file, args, env=None):
  312.     from errno import ENOENT, ENOTDIR
  313.  
  314.     if env is not None:
  315.         func = execve
  316.         argrest = (args, env)
  317.     else:
  318.         func = execv
  319.         argrest = (args,)
  320.         env = environ
  321.  
  322.     head, tail = path.split(file)
  323.     if head:
  324.         apply(func, (file,) + argrest)
  325.         return
  326.     if env.has_key('PATH'):
  327.         envpath = env['PATH']
  328.     else:
  329.         envpath = defpath
  330.     PATH = envpath.split(pathsep)
  331.     saved_exc = None
  332.     saved_tb = None
  333.     for dir in PATH:
  334.         fullname = path.join(dir, file)
  335.         try:
  336.             apply(func, (fullname,) + argrest)
  337.         except error, e:
  338.             tb = sys.exc_info()[2]
  339.             if (e.errno != ENOENT and e.errno != ENOTDIR
  340.                 and saved_exc is None):
  341.                 saved_exc = e
  342.                 saved_tb = tb
  343.     if saved_exc:
  344.         raise error, saved_exc, saved_tb
  345.     raise error, e, tb
  346.  
  347. # Change environ to automatically call putenv() if it exists
  348. try:
  349.     # This will fail if there's no putenv
  350.     putenv
  351. except NameError:
  352.     pass
  353. else:
  354.     import UserDict
  355.  
  356.     # Fake unsetenv() for Windows
  357.     # not sure about os2 and dos here but
  358.     # I'm guessing they are the same.
  359.  
  360.     if name in ('os2', 'nt', 'dos'):
  361.         def unsetenv(key):
  362.             putenv(key, "")
  363.  
  364.     if name == "riscos":
  365.         # On RISC OS, all env access goes through getenv and putenv
  366.         from riscosenviron import _Environ
  367.     elif name in ('os2', 'nt', 'dos'):  # Where Env Var Names Must Be UPPERCASE
  368.         # But we store them as upper case
  369.         class _Environ(UserDict.IterableUserDict):
  370.             def __init__(self, environ):
  371.                 UserDict.UserDict.__init__(self)
  372.                 data = self.data
  373.                 for k, v in environ.items():
  374.                     data[k.upper()] = v
  375.             def __setitem__(self, key, item):
  376.                 putenv(key, item)
  377.                 self.data[key.upper()] = item
  378.             def __getitem__(self, key):
  379.                 return self.data[key.upper()]
  380.             try:
  381.                 unsetenv
  382.             except NameError:
  383.                 def __delitem__(self, key):
  384.                     del self.data[key.upper()]
  385.             else:
  386.                 def __delitem__(self, key):
  387.                     unsetenv(key)
  388.                     del self.data[key.upper()]
  389.             def has_key(self, key):
  390.                 return self.data.has_key(key.upper())
  391.             def get(self, key, failobj=None):
  392.                 return self.data.get(key.upper(), failobj)
  393.             def update(self, dict):
  394.                 for k, v in dict.items():
  395.                     self[k] = v
  396.  
  397.     else:  # Where Env Var Names Can Be Mixed Case
  398.         class _Environ(UserDict.IterableUserDict):
  399.             def __init__(self, environ):
  400.                 UserDict.UserDict.__init__(self)
  401.                 self.data = environ
  402.             def __setitem__(self, key, item):
  403.                 putenv(key, item)
  404.                 self.data[key] = item
  405.             def update(self, dict):
  406.                 for k, v in dict.items():
  407.                     self[k] = v
  408.             try:
  409.                 unsetenv
  410.             except NameError:
  411.                 pass
  412.             else:
  413.                 def __delitem__(self, key):
  414.                     unsetenv(key)
  415.                     del self.data[key]
  416.  
  417.  
  418.     environ = _Environ(environ)
  419.  
  420.     def getenv(key, default=None):
  421.         """Get an environment variable, return None if it doesn't exist.
  422.         The optional second argument can specify an alternate default."""
  423.         return environ.get(key, default)
  424.     __all__.append("getenv")
  425.  
  426. def _exists(name):
  427.     try:
  428.         eval(name)
  429.         return 1
  430.     except NameError:
  431.         return 0
  432.  
  433. # Supply spawn*() (probably only for Unix)
  434. if _exists("fork") and not _exists("spawnv") and _exists("execv"):
  435.  
  436.     P_WAIT = 0
  437.     P_NOWAIT = P_NOWAITO = 1
  438.  
  439.     # XXX Should we support P_DETACH?  I suppose it could fork()**2
  440.     # and close the std I/O streams.  Also, P_OVERLAY is the same
  441.     # as execv*()?
  442.  
  443.     def _spawnvef(mode, file, args, env, func):
  444.         # Internal helper; func is the exec*() function to use
  445.         pid = fork()
  446.         if not pid:
  447.             # Child
  448.             try:
  449.                 if env is None:
  450.                     func(file, args)
  451.                 else:
  452.                     func(file, args, env)
  453.             except:
  454.                 _exit(127)
  455.         else:
  456.             # Parent
  457.             if mode == P_NOWAIT:
  458.                 return pid # Caller is responsible for waiting!
  459.             while 1:
  460.                 wpid, sts = waitpid(pid, 0)
  461.                 if WIFSTOPPED(sts):
  462.                     continue
  463.                 elif WIFSIGNALED(sts):
  464.                     return -WTERMSIG(sts)
  465.                 elif WIFEXITED(sts):
  466.                     return WEXITSTATUS(sts)
  467.                 else:
  468.                     raise error, "Not stopped, signaled or exited???"
  469.  
  470.     def spawnv(mode, file, args):
  471.         """spawnv(mode, file, args) -> integer
  472.  
  473. Execute file with arguments from args in a subprocess.
  474. If mode == P_NOWAIT return the pid of the process.
  475. If mode == P_WAIT return the process's exit code if it exits normally;
  476. otherwise return -SIG, where SIG is the signal that killed it. """
  477.         return _spawnvef(mode, file, args, None, execv)
  478.  
  479.     def spawnve(mode, file, args, env):
  480.         """spawnve(mode, file, args, env) -> integer
  481.  
  482. Execute file with arguments from args in a subprocess with the
  483. specified environment.
  484. If mode == P_NOWAIT return the pid of the process.
  485. If mode == P_WAIT return the process's exit code if it exits normally;
  486. otherwise return -SIG, where SIG is the signal that killed it. """
  487.         return _spawnvef(mode, file, args, env, execve)
  488.  
  489.     # Note: spawnvp[e] is't currently supported on Windows
  490.  
  491.     def spawnvp(mode, file, args):
  492.         """spawnvp(mode, file, args) -> integer
  493.  
  494. Execute file (which is looked for along $PATH) with arguments from
  495. args in a subprocess.
  496. If mode == P_NOWAIT return the pid of the process.
  497. If mode == P_WAIT return the process's exit code if it exits normally;
  498. otherwise return -SIG, where SIG is the signal that killed it. """
  499.         return _spawnvef(mode, file, args, None, execvp)
  500.  
  501.     def spawnvpe(mode, file, args, env):
  502.         """spawnvpe(mode, file, args, env) -> integer
  503.  
  504. Execute file (which is looked for along $PATH) with arguments from
  505. args in a subprocess with the supplied environment.
  506. If mode == P_NOWAIT return the pid of the process.
  507. If mode == P_WAIT return the process's exit code if it exits normally;
  508. otherwise return -SIG, where SIG is the signal that killed it. """
  509.         return _spawnvef(mode, file, args, env, execvpe)
  510.  
  511. if _exists("spawnv"):
  512.     # These aren't supplied by the basic Windows code
  513.     # but can be easily implemented in Python
  514.  
  515.     def spawnl(mode, file, *args):
  516.         """spawnl(mode, file, *args) -> integer
  517.  
  518. Execute file with arguments from args in a subprocess.
  519. If mode == P_NOWAIT return the pid of the process.
  520. If mode == P_WAIT return the process's exit code if it exits normally;
  521. otherwise return -SIG, where SIG is the signal that killed it. """
  522.         return spawnv(mode, file, args)
  523.  
  524.     def spawnle(mode, file, *args):
  525.         """spawnle(mode, file, *args, env) -> integer
  526.  
  527. Execute file with arguments from args in a subprocess with the
  528. supplied environment.
  529. If mode == P_NOWAIT return the pid of the process.
  530. If mode == P_WAIT return the process's exit code if it exits normally;
  531. otherwise return -SIG, where SIG is the signal that killed it. """
  532.         env = args[-1]
  533.         return spawnve(mode, file, args[:-1], env)
  534.  
  535. if _exists("spawnvp"):
  536.     # At the moment, Windows doesn't implement spawnvp[e],
  537.     # so it won't have spawnlp[e] either.
  538.     def spawnlp(mode, file, *args):
  539.         """spawnlp(mode, file, *args, env) -> integer
  540.  
  541. Execute file (which is looked for along $PATH) with arguments from
  542. args in a subprocess with the supplied environment.
  543. If mode == P_NOWAIT return the pid of the process.
  544. If mode == P_WAIT return the process's exit code if it exits normally;
  545. otherwise return -SIG, where SIG is the signal that killed it. """
  546.         return spawnvp(mode, file, args)
  547.  
  548.     def spawnlpe(mode, file, *args):
  549.         """spawnlpe(mode, file, *args, env) -> integer
  550.  
  551. Execute file (which is looked for along $PATH) with arguments from
  552. args in a subprocess with the supplied environment.
  553. If mode == P_NOWAIT return the pid of the process.
  554. If mode == P_WAIT return the process's exit code if it exits normally;
  555. otherwise return -SIG, where SIG is the signal that killed it. """
  556.         env = args[-1]
  557.         return spawnvpe(mode, file, args[:-1], env)
  558.  
  559.  
  560.     __all__.extend(["spawnlp","spawnlpe","spawnv", "spawnve","spawnvp",
  561.                     "spawnvpe","spawnl","spawnle",])
  562.  
  563.  
  564. # Supply popen2 etc. (for Unix)
  565. if _exists("fork"):
  566.     if not _exists("popen2"):
  567.         def popen2(cmd, mode="t", bufsize=-1):
  568.             import popen2
  569.             stdout, stdin = popen2.popen2(cmd, bufsize)
  570.             return stdin, stdout
  571.         __all__.append("popen2")
  572.  
  573.     if not _exists("popen3"):
  574.         def popen3(cmd, mode="t", bufsize=-1):
  575.             import popen2
  576.             stdout, stdin, stderr = popen2.popen3(cmd, bufsize)
  577.             return stdin, stdout, stderr
  578.         __all__.append("popen3")
  579.  
  580.     if not _exists("popen4"):
  581.         def popen4(cmd, mode="t", bufsize=-1):
  582.             import popen2
  583.             stdout, stdin = popen2.popen4(cmd, bufsize)
  584.             return stdin, stdout
  585.         __all__.append("popen4")
  586.  
  587. import copy_reg as _copy_reg
  588.  
  589. def _make_stat_result(tup, dict):
  590.     return stat_result(tup, dict)
  591.  
  592. def _pickle_stat_result(sr):
  593.     (type, args) = sr.__reduce__()
  594.     return (_make_stat_result, args)
  595.  
  596. try:
  597.     _copy_reg.pickle(stat_result, _pickle_stat_result, _make_stat_result)
  598. except NameError: # stat_result may not exist
  599.     pass
  600.  
  601. def _make_statvfs_result(tup, dict):
  602.     return statvfs_result(tup, dict)
  603.  
  604. def _pickle_statvfs_result(sr):
  605.     (type, args) = sr.__reduce__()
  606.     return (_make_statvfs_result, args)
  607.  
  608. try:
  609.     _copy_reg.pickle(statvfs_result, _pickle_statvfs_result,
  610.                      _make_statvfs_result)
  611. except NameError: # statvfs_result may not exist
  612.     pass
  613.