Make full module name available as __module_name__ even when __name__ is set to something else (like '__main__')

2 files changed, 34 insertions, 18 deletions

diff --git a/Lib/runpy.py b/Lib/runpy.py
index 8290dfe..6c44850 100755
--- a/Lib/runpy.py
+++ b/Lib/runpy.py
@@ -21,18 +21,19 @@ __all__ = [
 ]
 
 
-def _run_code(code, run_globals, init_globals,
+def _run_code(code, run_globals, init_globals, run_name,
               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__ = mod_name,
+    run_globals.update(__name__ = run_name,
+                       __module_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,
+def _run_module_code(code, init_globals=None, run_name=None,
                     mod_name=None, mod_fname=None,
                     mod_loader=None, alter_sys=False):
     """Helper for run_module"""
@@ -42,26 +43,33 @@ def _run_module_code(code, init_globals=None,
         temp_module = imp.new_module(mod_name)
         mod_globals = temp_module.__dict__
         saved_argv0 = sys.argv[0]
-        restore_module = mod_name in sys.modules
-        if restore_module:
-            saved_module = sys.modules[mod_name]
+        sentinel = object()
+        module_mod_name = sys.modules.get(mod_name, sentinel)
+        module_run_name = sys.modules.get(run_name, sentinel)
         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_code(code, mod_globals, init_globals, run_name,
                       mod_name, mod_fname, mod_loader)
         finally:
             sys.argv[0] = saved_argv0
-        if restore_module:
-            sys.modules[mod_name] = saved_module
-        else:
-            del sys.modules[mod_name]
+            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]
         # 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,
+        return _run_code(code, {}, init_globals, run_name,
                          mod_name, mod_fname, mod_loader)
 
 
@@ -92,7 +100,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,
-                            filename, loader, alter_sys)
+                            mod_name, filename, loader, alter_sys)
 
 
 if __name__ == "__main__":
diff --git a/Lib/test/test_runpy.py b/Lib/test/test_runpy.py
index 88e9900..acbd3fc 100644
--- a/Lib/test/test_runpy.py
+++ b/Lib/test/test_runpy.py
@@ -23,6 +23,8 @@ 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"
@@ -32,14 +34,16 @@ class RunModuleCodeTest(unittest.TestCase):
 
     def test_run_module_code(self):
         initial = object()
-        name = "<Nonsense>"
+        run_name = "<Nonsense>"
+        mod_name = "<ModuleNonsense>"
         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,
-                              name,
+                              run_name,
+                              mod_name,
                               file,
                               loader,
                               True)
@@ -47,19 +51,23 @@ 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 name)
-        self.failUnless(d2["run_name"] is name)
+        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["__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(name not in sys.modules)
+        self.failUnless(mod_name not in sys.modules)
+        self.failUnless(run_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)