traverseda
/
cpython
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Revert the __module_name__ changes made in rev 47142. We'll revisit this in Python 2.6

This commit is contained in:
Nick Coghlan 2006-07-06 12:53:04 +00:00
parent bf84e54078
commit 56829d5b4a
3 changed files with 26 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
Doc/lib/librunpy.tex
View File

@ -35,19 +35,16 @@ The supplied dictionary will not be modified. If any of the special
global variables below are defined in the supplied dictionary, those
definitions are overridden by the \code{run_module} function.
The special global variables \code{__name__}, \code{__module_name__},
\code{__file__}, \code{__loader__} and \code{__builtins__} are
set in the globals dictionary before the module code is executed.
The special global variables \code{__name__}, \code{__file__},
\code{__loader__} and \code{__builtins__} are set in the globals
dictionary before the module code is executed.
\code{__name__} is set to \var{run_name} if this optional argument is
supplied, and the \var{mod_name} argument otherwise.
\code{__module_name__} is always set to \var{mod_name} (this allows
modules to use imports relative to their package name).
\code{__loader__} is set to the PEP 302 module loader used to retrieve
the code for the module (This will not be defined if the module was
found using the standard import mechanism).
the code for the module (This loader may be a wrapper around the
standard import mechanism).
\code{__file__} is set to the name provided by the module loader. If
the loader does not make filename information available, this
@ -58,12 +55,10 @@ the top level namespace of the \module{__builtin__} module.
If the argument \var{alter_sys} is supplied and evaluates to
\code{True}, then \code{sys.argv[0]} is updated with the value of
\code{__file__} and \code{sys.modules[mod_name]} is updated with a
\code{__file__} and \code{sys.modules[__name__]} is updated with a
temporary module object for the module being executed. Both
\code{sys.argv[0]} and \code{sys.modules[mod_name]} are restored to
their original values before the function returns. If \var{run_name}
differs from \var{mod_name} entries are made in \code{sys.modules}
for both names.
\code{sys.argv[0]} and \code{sys.modules[__name__]} are restored to
their original values before the function returns.
Note that this manipulation of \module{sys} is not thread-safe. Other
threads may see the partially initialised module, as well as the

34
Lib/runpy.py
View File

@ -21,19 +21,18 @@ __all__ = [
]
def _run_code(code, run_globals, init_globals, run_name,
def _run_code(code, run_globals, init_globals,
mod_name, mod_fname, mod_loader):
"""Helper for _run_module_code"""
if init_globals is not None:
run_globals.update(init_globals)
run_globals.update(__name__ = run_name,
__module_name__ = mod_name,
run_globals.update(__name__ = mod_name,
__file__ = mod_fname,
__loader__ = mod_loader)
exec code in run_globals
return run_globals
def _run_module_code(code, init_globals=None, run_name=None,
def _run_module_code(code, init_globals=None,
mod_name=None, mod_fname=None,
mod_loader=None, alter_sys=False):
"""Helper for run_module"""
@ -43,33 +42,26 @@ def _run_module_code(code, init_globals=None, run_name=None,
temp_module = imp.new_module(mod_name)
mod_globals = temp_module.__dict__
saved_argv0 = sys.argv[0]
sentinel = object()
module_mod_name = sys.modules.get(mod_name, sentinel)
module_run_name = sys.modules.get(run_name, sentinel)
restore_module = mod_name in sys.modules
if restore_module:
saved_module = sys.modules[mod_name]
sys.argv[0] = mod_fname
sys.modules[mod_name] = temp_module
if run_name != mod_name:
sys.modules[run_name] = temp_module
try:
_run_code(code, mod_globals, init_globals, run_name,
_run_code(code, mod_globals, init_globals,
mod_name, mod_fname, mod_loader)
finally:
sys.argv[0] = saved_argv0
if module_mod_name is not sentinel:
sys.modules[mod_name] = module_mod_name
else:
del sys.modules[mod_name]
if run_name != mod_name:
if module_run_name is not sentinel:
sys.modules[run_name] = module_run_name
else:
del sys.modules[run_name]
if restore_module:
sys.modules[mod_name] = saved_module
else:
del sys.modules[mod_name]
# Copy the globals of the temporary module, as they
# may be cleared when the temporary module goes away
return mod_globals.copy()
else:
# Leave the sys module alone
return _run_code(code, {}, init_globals, run_name,
return _run_code(code, {}, init_globals,
mod_name, mod_fname, mod_loader)
@ -100,7 +92,7 @@ def run_module(mod_name, init_globals=None,
if run_name is None:
run_name = mod_name
return _run_module_code(code, init_globals, run_name,
mod_name, filename, loader, alter_sys)
filename, loader, alter_sys)
if __name__ == "__main__":

18
Lib/test/test_runpy.py
View File

@ -23,8 +23,6 @@ class RunModuleCodeTest(unittest.TestCase):
"run_argv0 = sys.argv[0]\n"
"if __name__ in sys.modules:\n"
" run_name = sys.modules[__name__].__name__\n"
"if __module_name__ in sys.modules:\n"
" mod_name = sys.modules[__module_name__].__module_name__\n"
"# Check nested operation\n"
"import runpy\n"
"nested = runpy._run_module_code('x=1\\n', mod_name='<run>',\n"
@ -34,16 +32,14 @@ class RunModuleCodeTest(unittest.TestCase):
def test_run_module_code(self):
initial = object()
run_name = "<Nonsense>"
mod_name = "<ModuleNonsense>"
name = "<Nonsense>"
file = "Some other nonsense"
loader = "Now you're just being silly"
d1 = dict(initial=initial)
saved_argv0 = sys.argv[0]
d2 = _run_module_code(self.test_source,
d1,
run_name,
mod_name,
name,
file,
loader,
True)
@ -51,23 +47,19 @@ class RunModuleCodeTest(unittest.TestCase):
self.failUnless(d2["initial"] is initial)
self.failUnless(d2["result"] == self.expected_result)
self.failUnless(d2["nested"]["x"] == 1)
self.failUnless(d2["__name__"] is run_name)
self.failUnless(d2["run_name"] is run_name)
self.failUnless(d2["__module_name__"] is mod_name)
self.failUnless(d2["mod_name"] is mod_name)
self.failUnless(d2["__name__"] is name)
self.failUnless(d2["run_name"] is name)
self.failUnless(d2["__file__"] is file)
self.failUnless(d2["run_argv0"] is file)
self.failUnless(d2["__loader__"] is loader)
self.failUnless(sys.argv[0] is saved_argv0)
self.failUnless(mod_name not in sys.modules)
self.failUnless(run_name not in sys.modules)
self.failUnless(name not in sys.modules)
def test_run_module_code_defaults(self):
saved_argv0 = sys.argv[0]
d = _run_module_code(self.test_source)
self.failUnless(d["result"] == self.expected_result)
self.failUnless(d["__name__"] is None)
self.failUnless(d["__module_name__"] is None)
self.failUnless(d["__file__"] is None)
self.failUnless(d["__loader__"] is None)
self.failUnless(d["run_argv0"] is saved_argv0)