home *** CD-ROM | disk | FTP | other *** search
/ Freelog 125 / Freelog_MarsAvril2015_No125.iso / Bureautique / LibreOffice / LibreOffice_4.3.5_Win_x86.msi / imp.py < prev    next >
Text File  |  2014-12-12  |  10KB  |  284 lines
  1. """This module provides the components needed to build your own __import__
  2. function.  Undocumented functions are obsolete.
  3.  
  4. In most cases it is preferred you consider using the importlib module's
  5. functionality over this module.
  6.  
  7. """
  8. # (Probably) need to stay in _imp
  9. from _imp import (lock_held, acquire_lock, release_lock,
  10.                   get_frozen_object, is_frozen_package,
  11.                   init_builtin, init_frozen, is_builtin, is_frozen,
  12.                   _fix_co_filename)
  13. try:
  14.     from _imp import load_dynamic
  15. except ImportError:
  16.     # Platform doesn't support dynamic loading.
  17.     load_dynamic = None
  18.  
  19. # Directly exposed by this module
  20. from importlib._bootstrap import new_module
  21. from importlib._bootstrap import cache_from_source, source_from_cache
  22.  
  23.  
  24. from importlib import _bootstrap
  25. from importlib import machinery
  26. import os
  27. import sys
  28. import tokenize
  29. import warnings
  30.  
  31.  
  32. # DEPRECATED
  33. SEARCH_ERROR = 0
  34. PY_SOURCE = 1
  35. PY_COMPILED = 2
  36. C_EXTENSION = 3
  37. PY_RESOURCE = 4
  38. PKG_DIRECTORY = 5
  39. C_BUILTIN = 6
  40. PY_FROZEN = 7
  41. PY_CODERESOURCE = 8
  42. IMP_HOOK = 9
  43.  
  44.  
  45. def get_magic():
  46.     """Return the magic number for .pyc or .pyo files."""
  47.     return _bootstrap._MAGIC_BYTES
  48.  
  49.  
  50. def get_tag():
  51.     """Return the magic tag for .pyc or .pyo files."""
  52.     return sys.implementation.cache_tag
  53.  
  54.  
  55. def get_suffixes():
  56.     warnings.warn('imp.get_suffixes() is deprecated; use the constants '
  57.                   'defined on importlib.machinery instead',
  58.                   DeprecationWarning, 2)
  59.     extensions = [(s, 'rb', C_EXTENSION) for s in machinery.EXTENSION_SUFFIXES]
  60.     source = [(s, 'U', PY_SOURCE) for s in machinery.SOURCE_SUFFIXES]
  61.     bytecode = [(s, 'rb', PY_COMPILED) for s in machinery.BYTECODE_SUFFIXES]
  62.  
  63.     return extensions + source + bytecode
  64.  
  65.  
  66. class NullImporter:
  67.  
  68.     """Null import object."""
  69.  
  70.     def __init__(self, path):
  71.         if path == '':
  72.             raise ImportError('empty pathname', path='')
  73.         elif os.path.isdir(path):
  74.             raise ImportError('existing directory', path=path)
  75.  
  76.     def find_module(self, fullname):
  77.         """Always returns None."""
  78.         return None
  79.  
  80.  
  81. class _HackedGetData:
  82.  
  83.     """Compatibiilty support for 'file' arguments of various load_*()
  84.     functions."""
  85.  
  86.     def __init__(self, fullname, path, file=None):
  87.         super().__init__(fullname, path)
  88.         self.file = file
  89.  
  90.     def get_data(self, path):
  91.         """Gross hack to contort loader to deal w/ load_*()'s bad API."""
  92.         if self.file and path == self.path:
  93.             if not self.file.closed:
  94.                 file = self.file
  95.             else:
  96.                 self.file = file = open(self.path, 'r')
  97.  
  98.             with file:
  99.                 # Technically should be returning bytes, but
  100.                 # SourceLoader.get_code() just passed what is returned to
  101.                 # compile() which can handle str. And converting to bytes would
  102.                 # require figuring out the encoding to decode to and
  103.                 # tokenize.detect_encoding() only accepts bytes.
  104.                 return file.read()
  105.         else:
  106.             return super().get_data(path)
  107.  
  108.  
  109. class _LoadSourceCompatibility(_HackedGetData, _bootstrap.SourceFileLoader):
  110.  
  111.     """Compatibility support for implementing load_source()."""
  112.  
  113.  
  114. def load_source(name, pathname, file=None):
  115.     msg = ('imp.load_source() is deprecated; use '
  116.            'importlib.machinery.SourceFileLoader(name, pathname).load_module()'
  117.            ' instead')
  118.     warnings.warn(msg, DeprecationWarning, 2)
  119.     _LoadSourceCompatibility(name, pathname, file).load_module(name)
  120.     module = sys.modules[name]
  121.     # To allow reloading to potentially work, use a non-hacked loader which
  122.     # won't rely on a now-closed file object.
  123.     module.__loader__ = _bootstrap.SourceFileLoader(name, pathname)
  124.     return module
  125.  
  126.  
  127. class _LoadCompiledCompatibility(_HackedGetData,
  128.         _bootstrap.SourcelessFileLoader):
  129.  
  130.     """Compatibility support for implementing load_compiled()."""
  131.  
  132.  
  133. def load_compiled(name, pathname, file=None):
  134.     msg = ('imp.load_compiled() is deprecated; use '
  135.            'importlib.machinery.SourcelessFileLoader(name, pathname).'
  136.            'load_module() instead ')
  137.     warnings.warn(msg, DeprecationWarning, 2)
  138.     _LoadCompiledCompatibility(name, pathname, file).load_module(name)
  139.     module = sys.modules[name]
  140.     # To allow reloading to potentially work, use a non-hacked loader which
  141.     # won't rely on a now-closed file object.
  142.     module.__loader__ = _bootstrap.SourcelessFileLoader(name, pathname)
  143.     return module
  144.  
  145.  
  146. def load_package(name, path):
  147.     msg = ('imp.load_package() is deprecated; use either '
  148.            'importlib.machinery.SourceFileLoader() or '
  149.            'importlib.machinery.SourcelessFileLoader() instead')
  150.     warnings.warn(msg, DeprecationWarning, 2)
  151.     if os.path.isdir(path):
  152.         extensions = (machinery.SOURCE_SUFFIXES[:] +
  153.                       machinery.BYTECODE_SUFFIXES[:])
  154.         for extension in extensions:
  155.             path = os.path.join(path, '__init__'+extension)
  156.             if os.path.exists(path):
  157.                 break
  158.         else:
  159.             raise ValueError('{!r} is not a package'.format(path))
  160.     return _bootstrap.SourceFileLoader(name, path).load_module(name)
  161.  
  162.  
  163. def load_module(name, file, filename, details):
  164.     """**DEPRECATED**
  165.  
  166.     Load a module, given information returned by find_module().
  167.  
  168.     The module name must include the full package name, if any.
  169.  
  170.     """
  171.     suffix, mode, type_ = details
  172.     with warnings.catch_warnings():
  173.         warnings.simplefilter('ignore')
  174.         if mode and (not mode.startswith(('r', 'U')) or '+' in mode):
  175.             raise ValueError('invalid file open mode {!r}'.format(mode))
  176.         elif file is None and type_ in {PY_SOURCE, PY_COMPILED}:
  177.             msg = 'file object required for import (type code {})'.format(type_)
  178.             raise ValueError(msg)
  179.         elif type_ == PY_SOURCE:
  180.             return load_source(name, filename, file)
  181.         elif type_ == PY_COMPILED:
  182.             return load_compiled(name, filename, file)
  183.         elif type_ == C_EXTENSION and load_dynamic is not None:
  184.             if file is None:
  185.                 with open(filename, 'rb') as opened_file:
  186.                     return load_dynamic(name, filename, opened_file)
  187.             else:
  188.                 return load_dynamic(name, filename, file)
  189.         elif type_ == PKG_DIRECTORY:
  190.             return load_package(name, filename)
  191.         elif type_ == C_BUILTIN:
  192.             return init_builtin(name)
  193.         elif type_ == PY_FROZEN:
  194.             return init_frozen(name)
  195.         else:
  196.             msg =  "Don't know how to import {} (type code {})".format(name, type_)
  197.             raise ImportError(msg, name=name)
  198.  
  199.  
  200. def find_module(name, path=None):
  201.     """**DEPRECATED**
  202.  
  203.     Search for a module.
  204.  
  205.     If path is omitted or None, search for a built-in, frozen or special
  206.     module and continue search in sys.path. The module name cannot
  207.     contain '.'; to search for a submodule of a package, pass the
  208.     submodule name and the package's __path__.
  209.  
  210.     """
  211.     if not isinstance(name, str):
  212.         raise TypeError("'name' must be a str, not {}".format(type(name)))
  213.     elif not isinstance(path, (type(None), list)):
  214.         # Backwards-compatibility
  215.         raise RuntimeError("'list' must be None or a list, "
  216.                            "not {}".format(type(name)))
  217.  
  218.     if path is None:
  219.         if is_builtin(name):
  220.             return None, None, ('', '', C_BUILTIN)
  221.         elif is_frozen(name):
  222.             return None, None, ('', '', PY_FROZEN)
  223.         else:
  224.             path = sys.path
  225.  
  226.     for entry in path:
  227.         package_directory = os.path.join(entry, name)
  228.         for suffix in ['.py', machinery.BYTECODE_SUFFIXES[0]]:
  229.             package_file_name = '__init__' + suffix
  230.             file_path = os.path.join(package_directory, package_file_name)
  231.             if os.path.isfile(file_path):
  232.                 return None, package_directory, ('', '', PKG_DIRECTORY)
  233.         with warnings.catch_warnings():
  234.             warnings.simplefilter('ignore')
  235.             for suffix, mode, type_ in get_suffixes():
  236.                 file_name = name + suffix
  237.                 file_path = os.path.join(entry, file_name)
  238.                 if os.path.isfile(file_path):
  239.                     break
  240.             else:
  241.                 continue
  242.             break  # Break out of outer loop when breaking out of inner loop.
  243.     else:
  244.         raise ImportError(_bootstrap._ERR_MSG.format(name), name=name)
  245.  
  246.     encoding = None
  247.     if mode == 'U':
  248.         with open(file_path, 'rb') as file:
  249.             encoding = tokenize.detect_encoding(file.readline)[0]
  250.     file = open(file_path, mode, encoding=encoding)
  251.     return file, file_path, (suffix, mode, type_)
  252.  
  253.  
  254. _RELOADING = {}
  255.  
  256. def reload(module):
  257.     """Reload the module and return it.
  258.  
  259.     The module must have been successfully imported before.
  260.  
  261.     """
  262.     if not module or type(module) != type(sys):
  263.         raise TypeError("reload() argument must be module")
  264.     name = module.__name__
  265.     if name not in sys.modules:
  266.         msg = "module {} not in sys.modules"
  267.         raise ImportError(msg.format(name), name=name)
  268.     if name in _RELOADING:
  269.         return _RELOADING[name]
  270.     _RELOADING[name] = module
  271.     try:
  272.         parent_name = name.rpartition('.')[0]
  273.         if parent_name and parent_name not in sys.modules:
  274.             msg = "parent {!r} not in sys.modules"
  275.             raise ImportError(msg.format(parent_name), name=parent_name)
  276.         module.__loader__.load_module(name)
  277.         # The module may have replaced itself in sys.modules!
  278.         return sys.modules[module.__name__]
  279.     finally:
  280.         try:
  281.             del _RELOADING[name]
  282.         except KeyError:
  283.             pass
  284.