home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Narzedzia / Calibre / calibre-0.8.18.msi / file_262 / runpy.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-09-09  |  6.3 KB  |  231 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.7)
  3.  
  4. import sys
  5. import imp
  6. from pkgutil import read_code
  7.  
  8. try:
  9.     from imp import get_loader
  10. except ImportError:
  11.     from pkgutil import get_loader
  12.  
  13. __all__ = [
  14.     'run_module',
  15.     'run_path']
  16.  
  17. class _TempModule(object):
  18.     
  19.     def __init__(self, mod_name):
  20.         self.mod_name = mod_name
  21.         self.module = imp.new_module(mod_name)
  22.         self._saved_module = []
  23.  
  24.     
  25.     def __enter__(self):
  26.         mod_name = self.mod_name
  27.         
  28.         try:
  29.             self._saved_module.append(sys.modules[mod_name])
  30.         except KeyError:
  31.             pass
  32.  
  33.         sys.modules[mod_name] = self.module
  34.         return self
  35.  
  36.     
  37.     def __exit__(self, *args):
  38.         if self._saved_module:
  39.             sys.modules[self.mod_name] = self._saved_module[0]
  40.         else:
  41.             del sys.modules[self.mod_name]
  42.         self._saved_module = []
  43.  
  44.  
  45.  
  46. class _ModifiedArgv0(object):
  47.     
  48.     def __init__(self, value):
  49.         self.value = value
  50.         self._saved_value = self._sentinel = object()
  51.  
  52.     
  53.     def __enter__(self):
  54.         if self._saved_value is not self._sentinel:
  55.             raise RuntimeError('Already preserving saved value')
  56.         self._saved_value = sys.argv[0]
  57.         sys.argv[0] = self.value
  58.  
  59.     
  60.     def __exit__(self, *args):
  61.         self.value = self._sentinel
  62.         sys.argv[0] = self._saved_value
  63.  
  64.  
  65.  
  66. def _run_code(code, run_globals, init_globals = None, mod_name = None, mod_fname = None, mod_loader = None, pkg_name = None):
  67.     if init_globals is not None:
  68.         run_globals.update(init_globals)
  69.     run_globals.update(__name__ = mod_name, __file__ = mod_fname, __loader__ = mod_loader, __package__ = pkg_name)
  70.     exec code in run_globals
  71.     return run_globals
  72.  
  73.  
  74. def _run_module_code(code, init_globals = None, mod_name = None, mod_fname = None, mod_loader = None, pkg_name = None):
  75.     with _TempModule(mod_name) as temp_module:
  76.         with _ModifiedArgv0(mod_fname):
  77.             mod_globals = temp_module.module.__dict__
  78.             _run_code(code, mod_globals, init_globals, mod_name, mod_fname, mod_loader, pkg_name)
  79.     return mod_globals.copy()
  80.  
  81.  
  82. def _get_filename(loader, mod_name):
  83.     for attr in ('get_filename', '_get_filename'):
  84.         meth = getattr(loader, attr, None)
  85.         if meth is not None:
  86.             return meth(mod_name)
  87.     
  88.  
  89.  
  90. def _get_module_details(mod_name):
  91.     loader = get_loader(mod_name)
  92.     if loader is None:
  93.         raise ImportError('No module named %s' % mod_name)
  94.     if loader.is_package(mod_name):
  95.         if mod_name == '__main__' or mod_name.endswith('.__main__'):
  96.             raise ImportError('Cannot use package as __main__ module')
  97.         
  98.         try:
  99.             pkg_main_name = mod_name + '.__main__'
  100.             return _get_module_details(pkg_main_name)
  101.         except ImportError:
  102.             e = None
  103.             raise ImportError(('%s; %r is a package and cannot ' + 'be directly executed') % (e, mod_name))
  104.         
  105.  
  106.     code = loader.get_code(mod_name)
  107.     if code is None:
  108.         raise ImportError('No code object available for %s' % mod_name)
  109.     filename = _get_filename(loader, mod_name)
  110.     return (mod_name, loader, code, filename)
  111.  
  112.  
  113. def _get_main_module_details():
  114.     main_name = '__main__'
  115.     
  116.     try:
  117.         return _get_module_details(main_name)
  118.     except ImportError:
  119.         exc = None
  120.         if main_name in str(exc):
  121.             raise ImportError("can't find %r module in %r" % (main_name, sys.path[0]))
  122.         raise 
  123.  
  124.  
  125.  
  126. def _run_module_as_main(mod_name, alter_argv = True):
  127.     
  128.     try:
  129.         if alter_argv or mod_name != '__main__':
  130.             (mod_name, loader, code, fname) = _get_module_details(mod_name)
  131.         else:
  132.             (mod_name, loader, code, fname) = _get_main_module_details()
  133.     except ImportError:
  134.         exc = None
  135.         msg = '%s: %s' % (sys.executable, str(exc))
  136.         sys.exit(msg)
  137.  
  138.     pkg_name = mod_name.rpartition('.')[0]
  139.     main_globals = sys.modules['__main__'].__dict__
  140.     if alter_argv:
  141.         sys.argv[0] = fname
  142.     return _run_code(code, main_globals, None, '__main__', fname, loader, pkg_name)
  143.  
  144.  
  145. def run_module(mod_name, init_globals = None, run_name = None, alter_sys = False):
  146.     (mod_name, loader, code, fname) = _get_module_details(mod_name)
  147.     if run_name is None:
  148.         run_name = mod_name
  149.     pkg_name = mod_name.rpartition('.')[0]
  150.     if alter_sys:
  151.         return _run_module_code(code, init_globals, run_name, fname, loader, pkg_name)
  152.     return None(code, { }, init_globals, run_name, fname, loader, pkg_name)
  153.  
  154.  
  155. def _get_importer(path_name):
  156.     cache = sys.path_importer_cache
  157.     
  158.     try:
  159.         importer = cache[path_name]
  160.     except KeyError:
  161.         cache[path_name] = None
  162.         for hook in sys.path_hooks:
  163.             
  164.             try:
  165.                 importer = hook(path_name)
  166.             continue
  167.             except ImportError:
  168.                 continue
  169.             
  170.  
  171.         else:
  172.             
  173.             try:
  174.                 importer = imp.NullImporter(path_name)
  175.             except ImportError:
  176.                 return None
  177.  
  178.         cache[path_name] = importer
  179.  
  180.     return importer
  181.  
  182.  
  183. def _get_code_from_file(fname):
  184.     with open(fname, 'rb') as f:
  185.         code = read_code(f)
  186.     if code is None:
  187.         with open(fname, 'rU') as f:
  188.             code = compile(f.read(), fname, 'exec')
  189.     return code
  190.  
  191.  
  192. def run_path(path_name, init_globals = None, run_name = None):
  193.     if run_name is None:
  194.         run_name = '<run_path>'
  195.     importer = _get_importer(path_name)
  196.     if isinstance(importer, imp.NullImporter):
  197.         code = _get_code_from_file(path_name)
  198.         return _run_module_code(code, init_globals, run_name, path_name)
  199.     None.path.insert(0, path_name)
  200.     
  201.     try:
  202.         main_name = '__main__'
  203.         saved_main = sys.modules[main_name]
  204.         del sys.modules[main_name]
  205.         
  206.         try:
  207.             (mod_name, loader, code, fname) = _get_main_module_details()
  208.         finally:
  209.             sys.modules[main_name] = saved_main
  210.  
  211.         pkg_name = ''
  212.         with _TempModule(run_name) as temp_module:
  213.             with _ModifiedArgv0(path_name):
  214.                 mod_globals = temp_module.module.__dict__
  215.                 return _run_code(code, mod_globals, init_globals, run_name, fname, loader, pkg_name).copy()
  216.     finally:
  217.         
  218.         try:
  219.             sys.path.remove(path_name)
  220.         except ValueError:
  221.             pass
  222.  
  223.  
  224.  
  225. if __name__ == '__main__':
  226.     if len(sys.argv) < 2:
  227.         print >>sys.stderr, 'No module specified for execution'
  228.     else:
  229.         del sys.argv[0]
  230.         _run_module_as_main(sys.argv[0])
  231.