+++ /dev/null
-"""runpy.py - locating and running Python code using the module namespace\r
-\r
-Provides support for locating and running Python scripts using the Python\r
-module namespace instead of the native filesystem.\r
-\r
-This allows Python code to play nicely with non-filesystem based PEP 302\r
-importers when locating support scripts as well as when importing modules.\r
-"""\r
-# Written by Nick Coghlan <ncoghlan at gmail.com>\r
-# to implement PEP 338 (Executing Modules as Scripts)\r
-\r
-import sys\r
-import imp\r
-from pkgutil import read_code\r
-try:\r
- from imp import get_loader\r
-except ImportError:\r
- from pkgutil import get_loader\r
-\r
-__all__ = [\r
- "run_module", "run_path",\r
-]\r
-\r
-class _TempModule(object):\r
- """Temporarily replace a module in sys.modules with an empty namespace"""\r
- def __init__(self, mod_name):\r
- self.mod_name = mod_name\r
- self.module = imp.new_module(mod_name)\r
- self._saved_module = []\r
-\r
- def __enter__(self):\r
- mod_name = self.mod_name\r
- try:\r
- self._saved_module.append(sys.modules[mod_name])\r
- except KeyError:\r
- pass\r
- sys.modules[mod_name] = self.module\r
- return self\r
-\r
- def __exit__(self, *args):\r
- if self._saved_module:\r
- sys.modules[self.mod_name] = self._saved_module[0]\r
- else:\r
- del sys.modules[self.mod_name]\r
- self._saved_module = []\r
-\r
-class _ModifiedArgv0(object):\r
- def __init__(self, value):\r
- self.value = value\r
- self._saved_value = self._sentinel = object()\r
-\r
- def __enter__(self):\r
- if self._saved_value is not self._sentinel:\r
- raise RuntimeError("Already preserving saved value")\r
- self._saved_value = sys.argv[0]\r
- sys.argv[0] = self.value\r
-\r
- def __exit__(self, *args):\r
- self.value = self._sentinel\r
- sys.argv[0] = self._saved_value\r
-\r
-def _run_code(code, run_globals, init_globals=None,\r
- mod_name=None, mod_fname=None,\r
- mod_loader=None, pkg_name=None):\r
- """Helper to run code in nominated namespace"""\r
- if init_globals is not None:\r
- run_globals.update(init_globals)\r
- run_globals.update(__name__ = mod_name,\r
- __file__ = mod_fname,\r
- __loader__ = mod_loader,\r
- __package__ = pkg_name)\r
- exec code in run_globals\r
- return run_globals\r
-\r
-def _run_module_code(code, init_globals=None,\r
- mod_name=None, mod_fname=None,\r
- mod_loader=None, pkg_name=None):\r
- """Helper to run code in new namespace with sys modified"""\r
- with _TempModule(mod_name) as temp_module, _ModifiedArgv0(mod_fname):\r
- mod_globals = temp_module.module.__dict__\r
- _run_code(code, mod_globals, init_globals,\r
- mod_name, mod_fname, mod_loader, pkg_name)\r
- # Copy the globals of the temporary module, as they\r
- # may be cleared when the temporary module goes away\r
- return mod_globals.copy()\r
-\r
-\r
-# This helper is needed due to a missing component in the PEP 302\r
-# loader protocol (specifically, "get_filename" is non-standard)\r
-# Since we can't introduce new features in maintenance releases,\r
-# support was added to zipimporter under the name '_get_filename'\r
-def _get_filename(loader, mod_name):\r
- for attr in ("get_filename", "_get_filename"):\r
- meth = getattr(loader, attr, None)\r
- if meth is not None:\r
- return meth(mod_name)\r
- return None\r
-\r
-# Helper to get the loader, code and filename for a module\r
-def _get_module_details(mod_name):\r
- loader = get_loader(mod_name)\r
- if loader is None:\r
- raise ImportError("No module named %s" % mod_name)\r
- if loader.is_package(mod_name):\r
- if mod_name == "__main__" or mod_name.endswith(".__main__"):\r
- raise ImportError("Cannot use package as __main__ module")\r
- try:\r
- pkg_main_name = mod_name + ".__main__"\r
- return _get_module_details(pkg_main_name)\r
- except ImportError, e:\r
- raise ImportError(("%s; %r is a package and cannot " +\r
- "be directly executed") %(e, mod_name))\r
- code = loader.get_code(mod_name)\r
- if code is None:\r
- raise ImportError("No code object available for %s" % mod_name)\r
- filename = _get_filename(loader, mod_name)\r
- return mod_name, loader, code, filename\r
-\r
-\r
-def _get_main_module_details():\r
- # Helper that gives a nicer error message when attempting to\r
- # execute a zipfile or directory by invoking __main__.py\r
- main_name = "__main__"\r
- try:\r
- return _get_module_details(main_name)\r
- except ImportError as exc:\r
- if main_name in str(exc):\r
- raise ImportError("can't find %r module in %r" %\r
- (main_name, sys.path[0]))\r
- raise\r
-\r
-# This function is the actual implementation of the -m switch and direct\r
-# execution of zipfiles and directories and is deliberately kept private.\r
-# This avoids a repeat of the situation where run_module() no longer met the\r
-# needs of mainmodule.c, but couldn't be changed because it was public\r
-def _run_module_as_main(mod_name, alter_argv=True):\r
- """Runs the designated module in the __main__ namespace\r
-\r
- Note that the executed module will have full access to the\r
- __main__ namespace. If this is not desirable, the run_module()\r
- function should be used to run the module code in a fresh namespace.\r
-\r
- At the very least, these variables in __main__ will be overwritten:\r
- __name__\r
- __file__\r
- __loader__\r
- __package__\r
- """\r
- try:\r
- if alter_argv or mod_name != "__main__": # i.e. -m switch\r
- mod_name, loader, code, fname = _get_module_details(mod_name)\r
- else: # i.e. directory or zipfile execution\r
- mod_name, loader, code, fname = _get_main_module_details()\r
- except ImportError as exc:\r
- msg = "%s: %s" % (sys.executable, str(exc))\r
- sys.exit(msg)\r
- pkg_name = mod_name.rpartition('.')[0]\r
- main_globals = sys.modules["__main__"].__dict__\r
- if alter_argv:\r
- sys.argv[0] = fname\r
- return _run_code(code, main_globals, None,\r
- "__main__", fname, loader, pkg_name)\r
-\r
-def run_module(mod_name, init_globals=None,\r
- run_name=None, alter_sys=False):\r
- """Execute a module's code without importing it\r
-\r
- Returns the resulting top level namespace dictionary\r
- """\r
- mod_name, loader, code, fname = _get_module_details(mod_name)\r
- if run_name is None:\r
- run_name = mod_name\r
- pkg_name = mod_name.rpartition('.')[0]\r
- if alter_sys:\r
- return _run_module_code(code, init_globals, run_name,\r
- fname, loader, pkg_name)\r
- else:\r
- # Leave the sys module alone\r
- return _run_code(code, {}, init_globals, run_name,\r
- fname, loader, pkg_name)\r
-\r
-\r
-# XXX (ncoghlan): Perhaps expose the C API function\r
-# as imp.get_importer instead of reimplementing it in Python?\r
-def _get_importer(path_name):\r
- """Python version of PyImport_GetImporter C API function"""\r
- cache = sys.path_importer_cache\r
- try:\r
- importer = cache[path_name]\r
- except KeyError:\r
- # Not yet cached. Flag as using the\r
- # standard machinery until we finish\r
- # checking the hooks\r
- cache[path_name] = None\r
- for hook in sys.path_hooks:\r
- try:\r
- importer = hook(path_name)\r
- break\r
- except ImportError:\r
- pass\r
- else:\r
- # The following check looks a bit odd. The trick is that\r
- # NullImporter throws ImportError if the supplied path is a\r
- # *valid* directory entry (and hence able to be handled\r
- # by the standard import machinery)\r
- try:\r
- importer = imp.NullImporter(path_name)\r
- except ImportError:\r
- return None\r
- cache[path_name] = importer\r
- return importer\r
-\r
-def _get_code_from_file(fname):\r
- # Check for a compiled file first\r
- with open(fname, "rb") as f:\r
- code = read_code(f)\r
- if code is None:\r
- # That didn't work, so try it as normal source code\r
- with open(fname, "rU") as f:\r
- code = compile(f.read(), fname, 'exec')\r
- return code\r
-\r
-def run_path(path_name, init_globals=None, run_name=None):\r
- """Execute code located at the specified filesystem location\r
-\r
- Returns the resulting top level namespace dictionary\r
-\r
- The file path may refer directly to a Python script (i.e.\r
- one that could be directly executed with execfile) or else\r
- it may refer to a zipfile or directory containing a top\r
- level __main__.py script.\r
- """\r
- if run_name is None:\r
- run_name = "<run_path>"\r
- importer = _get_importer(path_name)\r
- if isinstance(importer, imp.NullImporter):\r
- # Not a valid sys.path entry, so run the code directly\r
- # execfile() doesn't help as we want to allow compiled files\r
- code = _get_code_from_file(path_name)\r
- return _run_module_code(code, init_globals, run_name, path_name)\r
- else:\r
- # Importer is defined for path, so add it to\r
- # the start of sys.path\r
- sys.path.insert(0, path_name)\r
- try:\r
- # Here's where things are a little different from the run_module\r
- # case. There, we only had to replace the module in sys while the\r
- # code was running and doing so was somewhat optional. Here, we\r
- # have no choice and we have to remove it even while we read the\r
- # code. If we don't do this, a __loader__ attribute in the\r
- # existing __main__ module may prevent location of the new module.\r
- main_name = "__main__"\r
- saved_main = sys.modules[main_name]\r
- del sys.modules[main_name]\r
- try:\r
- mod_name, loader, code, fname = _get_main_module_details()\r
- finally:\r
- sys.modules[main_name] = saved_main\r
- pkg_name = ""\r
- with _TempModule(run_name) as temp_module, \\r
- _ModifiedArgv0(path_name):\r
- mod_globals = temp_module.module.__dict__\r
- return _run_code(code, mod_globals, init_globals,\r
- run_name, fname, loader, pkg_name).copy()\r
- finally:\r
- try:\r
- sys.path.remove(path_name)\r
- except ValueError:\r
- pass\r
-\r
-\r
-if __name__ == "__main__":\r
- # Run the module specified as the next command line argument\r
- if len(sys.argv) < 2:\r
- print >> sys.stderr, "No module specified for execution"\r
- else:\r
- del sys.argv[0] # Make the requested module sys.argv[0]\r
- _run_module_as_main(sys.argv[0])\r
projects / mirror_edk2.git / blobdiff