home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-9.10-netbook-remix-PL.iso / casper / filesystem.squashfs / usr / lib / python2.6 / runpy.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-11-11  |  3.9 KB  |  129 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. '''runpy.py - locating and running Python code using the module namespace
  5.  
  6. Provides support for locating and running Python scripts using the Python
  7. module namespace instead of the native filesystem.
  8.  
  9. This allows Python code to play nicely with non-filesystem based PEP 302
  10. importers when locating support scripts as well as when importing modules.
  11. '''
  12. import sys
  13. import imp
  14.  
  15. try:
  16.     from imp import get_loader
  17. except ImportError:
  18.     from pkgutil import get_loader
  19.  
  20. __all__ = [
  21.     'run_module']
  22.  
  23. def _run_code(code, run_globals, init_globals = None, mod_name = None, mod_fname = None, mod_loader = None, pkg_name = None):
  24.     '''Helper for _run_module_code'''
  25.     if init_globals is not None:
  26.         run_globals.update(init_globals)
  27.     
  28.     run_globals.update(__name__ = mod_name, __file__ = mod_fname, __loader__ = mod_loader, __package__ = pkg_name)
  29.     exec code in run_globals
  30.     return run_globals
  31.  
  32.  
  33. def _run_module_code(code, init_globals = None, mod_name = None, mod_fname = None, mod_loader = None, pkg_name = None):
  34.     '''Helper for run_module'''
  35.     temp_module = imp.new_module(mod_name)
  36.     mod_globals = temp_module.__dict__
  37.     saved_argv0 = sys.argv[0]
  38.     restore_module = mod_name in sys.modules
  39.     if restore_module:
  40.         saved_module = sys.modules[mod_name]
  41.     
  42.     sys.argv[0] = mod_fname
  43.     sys.modules[mod_name] = temp_module
  44.     
  45.     try:
  46.         _run_code(code, mod_globals, init_globals, mod_name, mod_fname, mod_loader, pkg_name)
  47.     finally:
  48.         sys.argv[0] = saved_argv0
  49.         if restore_module:
  50.             sys.modules[mod_name] = saved_module
  51.         else:
  52.             del sys.modules[mod_name]
  53.  
  54.     return mod_globals.copy()
  55.  
  56.  
  57. def _get_filename(loader, mod_name):
  58.     for attr in ('get_filename', '_get_filename'):
  59.         meth = getattr(loader, attr, None)
  60.         if meth is not None:
  61.             return meth(mod_name)
  62.     
  63.  
  64.  
  65. def _get_module_details(mod_name):
  66.     loader = get_loader(mod_name)
  67.     if loader is None:
  68.         raise ImportError('No module named %s' % mod_name)
  69.     loader is None
  70.     if loader.is_package(mod_name):
  71.         raise ImportError(('%s is a package and cannot ' + 'be directly executed') % mod_name)
  72.     loader.is_package(mod_name)
  73.     code = loader.get_code(mod_name)
  74.     if code is None:
  75.         raise ImportError('No code object available for %s' % mod_name)
  76.     code is None
  77.     filename = _get_filename(loader, mod_name)
  78.     return (loader, code, filename)
  79.  
  80.  
  81. def _run_module_as_main(mod_name, set_argv0 = True):
  82.     '''Runs the designated module in the __main__ namespace
  83.  
  84.        These __*__ magic variables will be overwritten:
  85.            __file__
  86.            __loader__
  87.     '''
  88.     
  89.     try:
  90.         (loader, code, fname) = _get_module_details(mod_name)
  91.     except ImportError:
  92.         exc = None
  93.         if set_argv0:
  94.             info = str(exc)
  95.         else:
  96.             info = "can't find '__main__.py' in %r" % sys.argv[0]
  97.         msg = '%s: %s' % (sys.executable, info)
  98.         sys.exit(msg)
  99.  
  100.     pkg_name = mod_name.rpartition('.')[0]
  101.     main_globals = sys.modules['__main__'].__dict__
  102.     if set_argv0:
  103.         sys.argv[0] = fname
  104.     
  105.     return _run_code(code, main_globals, None, '__main__', fname, loader, pkg_name)
  106.  
  107.  
  108. def run_module(mod_name, init_globals = None, run_name = None, alter_sys = False):
  109.     """Execute a module's code without importing it
  110.  
  111.        Returns the resulting top level namespace dictionary
  112.     """
  113.     (loader, code, fname) = _get_module_details(mod_name)
  114.     if run_name is None:
  115.         run_name = mod_name
  116.     
  117.     pkg_name = mod_name.rpartition('.')[0]
  118.     if alter_sys:
  119.         return _run_module_code(code, init_globals, run_name, fname, loader, pkg_name)
  120.     return _run_code(code, { }, init_globals, run_name, fname, loader, pkg_name)
  121.  
  122. if __name__ == '__main__':
  123.     if len(sys.argv) < 2:
  124.         print >>sys.stderr, 'No module specified for execution'
  125.     else:
  126.         del sys.argv[0]
  127.         _run_module_as_main(sys.argv[0])
  128.  
  129.