| 1 | """runpy.py - locating and running Python code using the module namespace
|
|---|
| 2 |
|
|---|
| 3 | Provides support for locating and running Python scripts using the Python
|
|---|
| 4 | module namespace instead of the native filesystem.
|
|---|
| 5 |
|
|---|
| 6 | This allows Python code to play nicely with non-filesystem based PEP 302
|
|---|
| 7 | importers when locating support scripts as well as when importing modules.
|
|---|
| 8 | """
|
|---|
| 9 | # Written by Nick Coghlan <ncoghlan at gmail.com>
|
|---|
| 10 | # to implement PEP 338 (Executing Modules as Scripts)
|
|---|
| 11 |
|
|---|
| 12 | import sys
|
|---|
| 13 | import imp
|
|---|
| 14 | try:
|
|---|
| 15 | from imp import get_loader
|
|---|
| 16 | except ImportError:
|
|---|
| 17 | from pkgutil import get_loader
|
|---|
| 18 |
|
|---|
| 19 | __all__ = [
|
|---|
| 20 | "run_module",
|
|---|
| 21 | ]
|
|---|
| 22 |
|
|---|
| 23 |
|
|---|
| 24 | def _run_code(code, run_globals, init_globals=None,
|
|---|
| 25 | mod_name=None, mod_fname=None,
|
|---|
| 26 | mod_loader=None, pkg_name=None):
|
|---|
| 27 | """Helper for _run_module_code"""
|
|---|
| 28 | if init_globals is not None:
|
|---|
| 29 | run_globals.update(init_globals)
|
|---|
| 30 | run_globals.update(__name__ = mod_name,
|
|---|
| 31 | __file__ = mod_fname,
|
|---|
| 32 | __loader__ = mod_loader,
|
|---|
| 33 | __package__ = pkg_name)
|
|---|
| 34 | exec code in run_globals
|
|---|
| 35 | return run_globals
|
|---|
| 36 |
|
|---|
| 37 | def _run_module_code(code, init_globals=None,
|
|---|
| 38 | mod_name=None, mod_fname=None,
|
|---|
| 39 | mod_loader=None, pkg_name=None):
|
|---|
| 40 | """Helper for run_module"""
|
|---|
| 41 | # Set up the top level namespace dictionary
|
|---|
| 42 | temp_module = imp.new_module(mod_name)
|
|---|
| 43 | mod_globals = temp_module.__dict__
|
|---|
| 44 | # Modify sys.argv[0] and sys.module[mod_name]
|
|---|
| 45 | saved_argv0 = sys.argv[0]
|
|---|
| 46 | restore_module = mod_name in sys.modules
|
|---|
| 47 | if restore_module:
|
|---|
| 48 | saved_module = sys.modules[mod_name]
|
|---|
| 49 | sys.argv[0] = mod_fname
|
|---|
| 50 | sys.modules[mod_name] = temp_module
|
|---|
| 51 | try:
|
|---|
| 52 | _run_code(code, mod_globals, init_globals,
|
|---|
| 53 | mod_name, mod_fname,
|
|---|
| 54 | mod_loader, pkg_name)
|
|---|
| 55 | finally:
|
|---|
| 56 | sys.argv[0] = saved_argv0
|
|---|
| 57 | if restore_module:
|
|---|
| 58 | sys.modules[mod_name] = saved_module
|
|---|
| 59 | else:
|
|---|
| 60 | del sys.modules[mod_name]
|
|---|
| 61 | # Copy the globals of the temporary module, as they
|
|---|
| 62 | # may be cleared when the temporary module goes away
|
|---|
| 63 | return mod_globals.copy()
|
|---|
| 64 |
|
|---|
| 65 |
|
|---|
| 66 | # This helper is needed due to a missing component in the PEP 302
|
|---|
| 67 | # loader protocol (specifically, "get_filename" is non-standard)
|
|---|
| 68 | # Since we can't introduce new features in maintenance releases,
|
|---|
| 69 | # support was added to zipimporter under the name '_get_filename'
|
|---|
| 70 | def _get_filename(loader, mod_name):
|
|---|
| 71 | for attr in ("get_filename", "_get_filename"):
|
|---|
| 72 | meth = getattr(loader, attr, None)
|
|---|
| 73 | if meth is not None:
|
|---|
| 74 | return meth(mod_name)
|
|---|
| 75 | return None
|
|---|
| 76 |
|
|---|
| 77 | # Helper to get the loader, code and filename for a module
|
|---|
| 78 | def _get_module_details(mod_name):
|
|---|
| 79 | loader = get_loader(mod_name)
|
|---|
| 80 | if loader is None:
|
|---|
| 81 | raise ImportError("No module named %s" % mod_name)
|
|---|
| 82 | if loader.is_package(mod_name):
|
|---|
| 83 | raise ImportError(("%s is a package and cannot " +
|
|---|
| 84 | "be directly executed") % mod_name)
|
|---|
| 85 | code = loader.get_code(mod_name)
|
|---|
| 86 | if code is None:
|
|---|
| 87 | raise ImportError("No code object available for %s" % mod_name)
|
|---|
| 88 | filename = _get_filename(loader, mod_name)
|
|---|
| 89 | return loader, code, filename
|
|---|
| 90 |
|
|---|
| 91 |
|
|---|
| 92 | # XXX ncoghlan: Should this be documented and made public?
|
|---|
| 93 | # (Current thoughts: don't repeat the mistake that lead to its
|
|---|
| 94 | # creation when run_module() no longer met the needs of
|
|---|
| 95 | # mainmodule.c, but couldn't be changed because it was public)
|
|---|
| 96 | def _run_module_as_main(mod_name, set_argv0=True):
|
|---|
| 97 | """Runs the designated module in the __main__ namespace
|
|---|
| 98 |
|
|---|
| 99 | These __*__ magic variables will be overwritten:
|
|---|
| 100 | __file__
|
|---|
| 101 | __loader__
|
|---|
| 102 | """
|
|---|
| 103 | try:
|
|---|
| 104 | loader, code, fname = _get_module_details(mod_name)
|
|---|
| 105 | except ImportError as exc:
|
|---|
| 106 | # Try to provide a good error message
|
|---|
| 107 | # for directories, zip files and the -m switch
|
|---|
| 108 | if set_argv0:
|
|---|
| 109 | # For -m switch, just disply the exception
|
|---|
| 110 | info = str(exc)
|
|---|
| 111 | else:
|
|---|
| 112 | # For directories/zipfiles, let the user
|
|---|
| 113 | # know what the code was looking for
|
|---|
| 114 | info = "can't find '__main__.py' in %r" % sys.argv[0]
|
|---|
| 115 | msg = "%s: %s" % (sys.executable, info)
|
|---|
| 116 | sys.exit(msg)
|
|---|
| 117 | pkg_name = mod_name.rpartition('.')[0]
|
|---|
| 118 | main_globals = sys.modules["__main__"].__dict__
|
|---|
| 119 | if set_argv0:
|
|---|
| 120 | sys.argv[0] = fname
|
|---|
| 121 | return _run_code(code, main_globals, None,
|
|---|
| 122 | "__main__", fname, loader, pkg_name)
|
|---|
| 123 |
|
|---|
| 124 | def run_module(mod_name, init_globals=None,
|
|---|
| 125 | run_name=None, alter_sys=False):
|
|---|
| 126 | """Execute a module's code without importing it
|
|---|
| 127 |
|
|---|
| 128 | Returns the resulting top level namespace dictionary
|
|---|
| 129 | """
|
|---|
| 130 | loader, code, fname = _get_module_details(mod_name)
|
|---|
| 131 | if run_name is None:
|
|---|
| 132 | run_name = mod_name
|
|---|
| 133 | pkg_name = mod_name.rpartition('.')[0]
|
|---|
| 134 | if alter_sys:
|
|---|
| 135 | return _run_module_code(code, init_globals, run_name,
|
|---|
| 136 | fname, loader, pkg_name)
|
|---|
| 137 | else:
|
|---|
| 138 | # Leave the sys module alone
|
|---|
| 139 | return _run_code(code, {}, init_globals, run_name,
|
|---|
| 140 | fname, loader, pkg_name)
|
|---|
| 141 |
|
|---|
| 142 |
|
|---|
| 143 | if __name__ == "__main__":
|
|---|
| 144 | # Run the module specified as the next command line argument
|
|---|
| 145 | if len(sys.argv) < 2:
|
|---|
| 146 | print >> sys.stderr, "No module specified for execution"
|
|---|
| 147 | else:
|
|---|
| 148 | del sys.argv[0] # Make the requested module sys.argv[0]
|
|---|
| 149 | _run_module_as_main(sys.argv[0])
|
|---|
