"""Temporarily replace a module in sys.modules with an empty namespace"""

def __init__(self, mod_name):

self.mod_name = mod_name

self.module = ModuleType(mod_name)

self._saved_module = []

def __enter__(self):

mod_name = self.mod_name

try:

self._saved_module.append(sys.modules[mod_name])

except KeyError:

pass

sys.modules[mod_name] = self.module

return self

def __exit__(self, *args):

if self._saved_module:

sys.modules[self.mod_name] = self._saved_module[0]

else:

del sys.modules[self.mod_name]

def __init__(self, value):

self.value = value

self._saved_value = self._sentinel = object()

def __enter__(self):

if self._saved_value is not self._sentinel:

raise RuntimeError("Already preserving saved value")

self._saved_value = sys.argv[0]

sys.argv[0] = self.value

def __exit__(self, *args):

self.value = self._sentinel

mod_name=None, mod_spec=None,

pkg_name=None, script_name=None):

"""Helper to run code in nominated namespace"""

if init_globals is not None:

run_globals.update(init_globals)

if mod_spec is None:

loader = None

fname = script_name

cached = None

else:

loader = mod_spec.loader

fname = mod_spec.origin

cached = mod_spec.cached

if pkg_name is None:

pkg_name = mod_spec.parent

run_globals.update(__name__ = mod_name,

__file__ = fname,

__doc__ = None,

__loader__ = loader,

__package__ = pkg_name,

__spec__ = mod_spec)

exec(code, run_globals)

mod_name=None, mod_spec=None,

pkg_name=None, script_name=None):

"""Helper to run code in new namespace with sys modified"""

fname = script_name if mod_spec is None else mod_spec.origin

with _TempModule(mod_name) as temp_module, _ModifiedArgv0(fname):

mod_globals = temp_module.module.__dict__

_run_code(code, mod_globals, init_globals,

mod_name, mod_spec, pkg_name, script_name)

# Copy the globals of the temporary module, as they

# may be cleared when the temporary module goes away

# name= is only accepted by ImportError and its subclasses.

kwargs = {"name": mod_name} if issubclass(error, ImportError) else {}

if mod_name.startswith("."):

raise error("Relative module names not supported", **kwargs)

pkg_name, _, _ = mod_name.rpartition(".")

if pkg_name:

# Try importing the parent to avoid catching initialization errors

try:

__import__(pkg_name)

except ImportError as e:

# If the parent or higher ancestor package is missing, let the

# error be raised by find_spec() below and then be caught. But do

# not allow other errors to be caught.

if e.name is None or (e.name != pkg_name and

not pkg_name.startswith(e.name + ".")):

raise

# Warn if the module has already been imported under its normal name

existing = sys.modules.get(mod_name)

if existing is not None and not hasattr(existing, "__path__"):

from warnings import warn

msg = "{mod_name!r} found in sys.modules after import of " \

"package {pkg_name!r}, but prior to execution of " \

"{mod_name!r}; this may result in unpredictable " \

"behaviour".format(mod_name=mod_name, pkg_name=pkg_name)

warn(RuntimeWarning(msg))

try:

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

# pkgutil previously raised ImportError

msg = "Error while finding module specification for {!r} ({}: {})"

if mod_name.endswith(".py"):

msg += (f". Try using '{mod_name[:-3]}' instead of "

f"'{mod_name}' as the module name.")

raise error(msg.format(mod_name, type(ex).__name__, ex),

**kwargs) from ex

if spec is None:

raise error("No module named %s" % mod_name, **kwargs)

if spec.submodule_search_locations is not None:

if mod_name == "__main__" or mod_name.endswith(".__main__"):

raise error("Cannot use package as __main__ module", **kwargs)

try:

pkg_main_name = mod_name + ".__main__"

return _get_module_details(pkg_main_name, error)

except error as e:

if mod_name not in sys.modules:

raise # No module loaded; being a package is irrelevant

raise error(("%s; %r is a package and cannot " +

"be directly executed") %(e, mod_name),

**kwargs)

loader = spec.loader

if loader is None:

raise error("%r is a namespace package and cannot be executed"

% mod_name,

**kwargs)

try:

code = loader.get_code(mod_name)

except ImportError as e:

raise error(format(e), **kwargs) from e

if code is None:

raise error("No code object available for %s" % mod_name, **kwargs)

"""Runs the designated module in the __main__ namespace

try:

if alter_argv or mod_name != "__main__": # i.e. -m switch

mod_name, mod_spec, code = _get_module_details(mod_name, _Error)

else: # i.e. directory or zipfile execution

mod_name, mod_spec, code = _get_main_module_details(_Error)

except _Error as exc:

msg = "%s: %s" % (sys.executable, exc)

sys.exit(msg)

main_globals = sys.modules["__main__"].__dict__

if alter_argv:

sys.argv[0] = mod_spec.origin

return _run_code(code, main_globals, None,

run_name=None, alter_sys=False):

"""Execute a module's code without importing it.

mod_name, mod_spec, code = _get_module_details(mod_name)

if run_name is None:

run_name = mod_name

if alter_sys:

return _run_module_code(code, init_globals, run_name, mod_spec)

else:

# Leave the sys module alone

# Helper that gives a nicer error message when attempting to

# execute a zipfile or directory by invoking __main__.py

# Also moves the standard __main__ out of the way so that the

# preexisting __loader__ entry doesn't cause issues

main_name = "__main__"

kwargs = {"name": main_name} if issubclass(error, ImportError) else {}

saved_main = sys.modules[main_name]

del sys.modules[main_name]

try:

return _get_module_details(main_name)

except ImportError as exc:

if main_name in str(exc):

raise error("can't find %r module in %r" %

(main_name, sys.path[0]),

**kwargs) from exc

raise

finally:

# Check for a compiled file first

from pkgutil import read_code

code_path = os.path.abspath(fname)

with io.open_code(code_path) as f:

code = read_code(f)

if code is None:

# That didn't work, so try it as normal source code

with io.open_code(code_path) as f:

code = compile(f.read(), fname, 'exec', module=module)

"""Execute code located at the specified filesystem location.

if run_name is None:

run_name = "<run_path>"

pkg_name = run_name.rpartition(".")[0]

from pkgutil import get_importer

importer = get_importer(path_name)

path_name = os.fsdecode(path_name)

if isinstance(importer, type(None)):

# Not a valid sys.path entry, so run the code directly

# execfile() doesn't help as we want to allow compiled files

code = _get_code_from_file(path_name, run_name)

return _run_module_code(code, init_globals, run_name,

pkg_name=pkg_name, script_name=path_name)

else:

# Finder is defined for path, so add it to

# the start of sys.path

sys.path.insert(0, path_name)

try:

# Here's where things are a little different from the run_module

# case. There, we only had to replace the module in sys while the

# code was running and doing so was somewhat optional. Here, we

# have no choice and we have to remove it even while we read the

# code. If we don't do this, a __loader__ attribute in the

# existing __main__ module may prevent location of the new module.

mod_name, mod_spec, code = _get_main_module_details()

with _TempModule(run_name) as temp_module, \

_ModifiedArgv0(path_name):

mod_globals = temp_module.module.__dict__

return _run_code(code, mod_globals, init_globals,

run_name, mod_spec, pkg_name).copy()

finally:

try:

sys.path.remove(path_name)

except ValueError: