Use runpy to run modules with -m

Author: coolreader18

Lib/__importlib_util.py

@@ -0,0 +1,97 @@
+"""Utility code for constructing importers, etc."""
+from _frozen_importlib import _resolve_name
+from _frozen_importlib import _find_spec
+
+import sys
+
+
+def resolve_name(name, package):
+    """Resolve a relative module name to an absolute one."""
+    if not name.startswith('.'):
+        return name
+    elif not package:
+        raise ValueError(f'no package specified for {repr(name)} '
+                         '(required for relative module names)')
+    level = 0
+    for character in name:
+        if character != '.':
+            break
+        level += 1
+    return _resolve_name(name[level:], package, level)
+
+
+def _find_spec_from_path(name, path=None):
+    """Return the spec for the specified module.
+
+    First, sys.modules is checked to see if the module was already imported. If
+    so, then sys.modules[name].__spec__ is returned. If that happens to be
+    set to None, then ValueError is raised. If the module is not in
+    sys.modules, then sys.meta_path is searched for a suitable spec with the
+    value of 'path' given to the finders. None is returned if no spec could
+    be found.
+
+    Dotted names do not have their parent packages implicitly imported. You will
+    most likely need to explicitly import all parent packages in the proper
+    order for a submodule to get the correct spec.
+
+    """
+    if name not in sys.modules:
+        return _find_spec(name, path)
+    else:
+        module = sys.modules[name]
+        if module is None:
+            return None
+        try:
+            spec = module.__spec__
+        except AttributeError:
+            raise ValueError('{}.__spec__ is not set'.format(name)) from None
+        else:
+            if spec is None:
+                raise ValueError('{}.__spec__ is None'.format(name))
+            return spec
+
+
+def find_spec(name, package=None):
+    """Return the spec for the specified module.
+
+    First, sys.modules is checked to see if the module was already imported. If
+    so, then sys.modules[name].__spec__ is returned. If that happens to be
+    set to None, then ValueError is raised. If the module is not in
+    sys.modules, then sys.meta_path is searched for a suitable spec with the
+    value of 'path' given to the finders. None is returned if no spec could
+    be found.
+
+    If the name is for submodule (contains a dot), the parent module is
+    automatically imported.
+
+    The name and package arguments work the same as importlib.import_module().
+    In other words, relative module names (with leading dots) work.
+
+    """
+    fullname = resolve_name(name, package) if name.startswith('.') else name
+    if fullname not in sys.modules:
+        parent_name = fullname.rpartition('.')[0]
+        if parent_name:
+            parent = __import__(parent_name, fromlist=['__path__'])
+            try:
+                parent_path = parent.__path__
+            except AttributeError as e:
+                raise ModuleNotFoundError(
+                    f"__path__ attribute not found on {parent_name!r} "
+                    f"while trying to find {fullname!r}", name=fullname) from e
+        else:
+            parent_path = None
+        return _find_spec(fullname, parent_path)
+    else:
+        module = sys.modules[fullname]
+        if module is None:
+            return None
+        try:
+            spec = module.__spec__
+        except AttributeError:
+            raise ValueError('{}.__spec__ is not set'.format(name)) from None
+        else:
+            if spec is None:
+                raise ValueError('{}.__spec__ is None'.format(name))
+            return spec
+

Lib/runpy.py

@@ -11,10 +11,13 @@
 
 
 import sys
-import importlib.machinery # importlib first so we can test #15386 via -m
-import importlib.util
+import __importlib_util
+# FIXME replace above with below once we can import importlib
+# import importlib.machinery # importlib first so we can test #15386 via -m
+# import importlib.util
 import types
-from pkgutil import read_code, get_importer
+# FIXME uncomment line below once we can import pkgutil
+# from pkgutil import read_code, get_importer
 
 __all__ = [
     "run_module", "run_path",
@@ -125,7 +128,8 @@ def _get_module_details(mod_name, error=ImportError):
             warn(RuntimeWarning(msg))
 
     try:
-        spec = importlib.util.find_spec(mod_name)
+        # FIXME replace with importlib.util.find_spec() once we can import importlib
+        spec = __importlib_util.find_spec(mod_name)
     except (ImportError, AttributeError, TypeError, ValueError) as ex:
         # This hack fixes an impedance mismatch between pkgutil and
         # importlib, where the latter raises other errors for cases where

src/main.rs

@@ -204,7 +204,7 @@ fn create_settings(matches: &ArgMatches) -> PySettings {
     let argv = if let Some(script) = matches.values_of("script") {
         script.map(ToOwned::to_owned).collect()
     } else if let Some(module) = matches.values_of("m") {
-        std::iter::once("PLACEHOLEDER".to_owned())
+        std::iter::once("PLACEHOLDER".to_owned())
             .chain(module.skip(1).map(ToOwned::to_owned))
             .collect()
     } else if let Some(cmd) = matches.values_of("c") {
@@ -353,18 +353,12 @@ fn run_command(vm: &VirtualMachine, source: String) -> PyResult<()> {
 
 fn run_module(vm: &VirtualMachine, module: &str) -> PyResult<()> {
     debug!("Running module {}", module);
-    let importlib = vm.import("_frozen_importlib", &vm.ctx.new_tuple(vec![]), 0)?;
-    let find_spec = vm.get_attribute(importlib, "_find_spec")?;
-    let spec = vm.invoke(
-        find_spec,
-        vec![vm.ctx.new_str(module.to_owned()), vm.get_none()],
-    )?;
-    if !vm.is_none(&spec) {
-        let origin = vm.get_attribute(spec, "origin")?;
-        let sys_path = vm.get_attribute(vm.sys_module.clone(), "argv")?;
-        sys_path.set_item(0, origin, vm)?;
-    }
-    vm.import(module, &vm.ctx.new_tuple(vec![]), 0)?;
+    let main_module = vm.ctx.new_module("__main__", vm.ctx.new_dict());
+    vm.get_attribute(vm.sys_module.clone(), "modules")?
+        .set_item("__main__", main_module, vm)?;
+    let runpy = vm.import("runpy", &vm.ctx.new_tuple(vec![]), 0)?;
+    let run_module_as_main = vm.get_attribute(runpy, "_run_module_as_main")?;
+    vm.invoke(run_module_as_main, vec![vm.new_str(module.to_owned())])?;
     Ok(())
 }