--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/eric7/DebugClients/Python/coverage/execfile.py Thu Jul 07 11:23:56 2022 +0200
@@ -0,0 +1,307 @@
+# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+
+"""Execute files of Python code."""
+
+import importlib.machinery
+import importlib.util
+import inspect
+import marshal
+import os
+import struct
+import sys
+import types
+
+from coverage import env
+from coverage.exceptions import CoverageException, _ExceptionDuringRun, NoCode, NoSource
+from coverage.files import canonical_filename, python_reported_file
+from coverage.misc import isolate_module
+from coverage.phystokens import compile_unicode
+from coverage.python import get_python_source
+
+os = isolate_module(os)
+
+
+PYC_MAGIC_NUMBER = importlib.util.MAGIC_NUMBER
+
+class DummyLoader:
+ """A shim for the pep302 __loader__, emulating pkgutil.ImpLoader.
+
+ Currently only implements the .fullname attribute
+ """
+ def __init__(self, fullname, *_args):
+ self.fullname = fullname
+
+
+def find_module(modulename):
+ """Find the module named `modulename`.
+
+ Returns the file path of the module, the name of the enclosing
+ package, and the spec.
+ """
+ try:
+ spec = importlib.util.find_spec(modulename)
+ except ImportError as err:
+ raise NoSource(str(err)) from err
+ if not spec:
+ raise NoSource(f"No module named {modulename!r}")
+ pathname = spec.origin
+ packagename = spec.name
+ if spec.submodule_search_locations:
+ mod_main = modulename + ".__main__"
+ spec = importlib.util.find_spec(mod_main)
+ if not spec:
+ raise NoSource(
+ f"No module named {mod_main}; " +
+ f"{modulename!r} is a package and cannot be directly executed"
+ )
+ pathname = spec.origin
+ packagename = spec.name
+ packagename = packagename.rpartition(".")[0]
+ return pathname, packagename, spec
+
+
+class PyRunner:
+ """Multi-stage execution of Python code.
+
+ This is meant to emulate real Python execution as closely as possible.
+
+ """
+ def __init__(self, args, as_module=False):
+ self.args = args
+ self.as_module = as_module
+
+ self.arg0 = args[0]
+ self.package = self.modulename = self.pathname = self.loader = self.spec = None
+
+ def prepare(self):
+ """Set sys.path properly.
+
+ This needs to happen before any importing, and without importing anything.
+ """
+ if self.as_module:
+ path0 = os.getcwd()
+ elif os.path.isdir(self.arg0):
+ # Running a directory means running the __main__.py file in that
+ # directory.
+ path0 = self.arg0
+ else:
+ path0 = os.path.abspath(os.path.dirname(self.arg0))
+
+ if os.path.isdir(sys.path[0]):
+ # sys.path fakery. If we are being run as a command, then sys.path[0]
+ # is the directory of the "coverage" script. If this is so, replace
+ # sys.path[0] with the directory of the file we're running, or the
+ # current directory when running modules. If it isn't so, then we
+ # don't know what's going on, and just leave it alone.
+ top_file = inspect.stack()[-1][0].f_code.co_filename
+ sys_path_0_abs = os.path.abspath(sys.path[0])
+ top_file_dir_abs = os.path.abspath(os.path.dirname(top_file))
+ sys_path_0_abs = canonical_filename(sys_path_0_abs)
+ top_file_dir_abs = canonical_filename(top_file_dir_abs)
+ if sys_path_0_abs != top_file_dir_abs:
+ path0 = None
+
+ else:
+ # sys.path[0] is a file. Is the next entry the directory containing
+ # that file?
+ if sys.path[1] == os.path.dirname(sys.path[0]):
+ # Can it be right to always remove that?
+ del sys.path[1]
+
+ if path0 is not None:
+ sys.path[0] = python_reported_file(path0)
+
+ def _prepare2(self):
+ """Do more preparation to run Python code.
+
+ Includes finding the module to run and adjusting sys.argv[0].
+ This method is allowed to import code.
+
+ """
+ if self.as_module:
+ self.modulename = self.arg0
+ pathname, self.package, self.spec = find_module(self.modulename)
+ if self.spec is not None:
+ self.modulename = self.spec.name
+ self.loader = DummyLoader(self.modulename)
+ self.pathname = os.path.abspath(pathname)
+ self.args[0] = self.arg0 = self.pathname
+ elif os.path.isdir(self.arg0):
+ # Running a directory means running the __main__.py file in that
+ # directory.
+ for ext in [".py", ".pyc", ".pyo"]:
+ try_filename = os.path.join(self.arg0, "__main__" + ext)
+ # 3.8.10 changed how files are reported when running a
+ # directory. But I'm not sure how far this change is going to
+ # spread, so I'll just hard-code it here for now.
+ if env.PYVERSION >= (3, 8, 10):
+ try_filename = os.path.abspath(try_filename)
+ if os.path.exists(try_filename):
+ self.arg0 = try_filename
+ break
+ else:
+ raise NoSource(f"Can't find '__main__' module in '{self.arg0}'")
+
+ # Make a spec. I don't know if this is the right way to do it.
+ try_filename = python_reported_file(try_filename)
+ self.spec = importlib.machinery.ModuleSpec("__main__", None, origin=try_filename)
+ self.spec.has_location = True
+ self.package = ""
+ self.loader = DummyLoader("__main__")
+ else:
+ self.loader = DummyLoader("__main__")
+
+ self.arg0 = python_reported_file(self.arg0)
+
+ def run(self):
+ """Run the Python code!"""
+
+ self._prepare2()
+
+ # Create a module to serve as __main__
+ main_mod = types.ModuleType('__main__')
+
+ from_pyc = self.arg0.endswith((".pyc", ".pyo"))
+ main_mod.__file__ = self.arg0
+ if from_pyc:
+ main_mod.__file__ = main_mod.__file__[:-1]
+ if self.package is not None:
+ main_mod.__package__ = self.package
+ main_mod.__loader__ = self.loader
+ if self.spec is not None:
+ main_mod.__spec__ = self.spec
+
+ main_mod.__builtins__ = sys.modules['builtins']
+
+ sys.modules['__main__'] = main_mod
+
+ # Set sys.argv properly.
+ sys.argv = self.args
+
+ try:
+ # Make a code object somehow.
+ if from_pyc:
+ code = make_code_from_pyc(self.arg0)
+ else:
+ code = make_code_from_py(self.arg0)
+ except CoverageException:
+ raise
+ except Exception as exc:
+ msg = f"Couldn't run '{self.arg0}' as Python code: {exc.__class__.__name__}: {exc}"
+ raise CoverageException(msg) from exc
+
+ # Execute the code object.
+ # Return to the original directory in case the test code exits in
+ # a non-existent directory.
+ cwd = os.getcwd()
+ try:
+ exec(code, main_mod.__dict__)
+ except SystemExit: # pylint: disable=try-except-raise
+ # The user called sys.exit(). Just pass it along to the upper
+ # layers, where it will be handled.
+ raise
+ except Exception:
+ # Something went wrong while executing the user code.
+ # Get the exc_info, and pack them into an exception that we can
+ # throw up to the outer loop. We peel one layer off the traceback
+ # so that the coverage.py code doesn't appear in the final printed
+ # traceback.
+ typ, err, tb = sys.exc_info()
+
+ # PyPy3 weirdness. If I don't access __context__, then somehow it
+ # is non-None when the exception is reported at the upper layer,
+ # and a nested exception is shown to the user. This getattr fixes
+ # it somehow? https://bitbucket.org/pypy/pypy/issue/1903
+ getattr(err, '__context__', None)
+
+ # Call the excepthook.
+ try:
+ err.__traceback__ = err.__traceback__.tb_next
+ sys.excepthook(typ, err, tb.tb_next)
+ except SystemExit: # pylint: disable=try-except-raise
+ raise
+ except Exception as exc:
+ # Getting the output right in the case of excepthook
+ # shenanigans is kind of involved.
+ sys.stderr.write("Error in sys.excepthook:\n")
+ typ2, err2, tb2 = sys.exc_info()
+ err2.__suppress_context__ = True
+ err2.__traceback__ = err2.__traceback__.tb_next
+ sys.__excepthook__(typ2, err2, tb2.tb_next)
+ sys.stderr.write("\nOriginal exception was:\n")
+ raise _ExceptionDuringRun(typ, err, tb.tb_next) from exc
+ else:
+ sys.exit(1)
+ finally:
+ os.chdir(cwd)
+
+
+def run_python_module(args):
+ """Run a Python module, as though with ``python -m name args...``.
+
+ `args` is the argument array to present as sys.argv, including the first
+ element naming the module being executed.
+
+ This is a helper for tests, to encapsulate how to use PyRunner.
+
+ """
+ runner = PyRunner(args, as_module=True)
+ runner.prepare()
+ runner.run()
+
+
+def run_python_file(args):
+ """Run a Python file as if it were the main program on the command line.
+
+ `args` is the argument array to present as sys.argv, including the first
+ element naming the file being executed. `package` is the name of the
+ enclosing package, if any.
+
+ This is a helper for tests, to encapsulate how to use PyRunner.
+
+ """
+ runner = PyRunner(args, as_module=False)
+ runner.prepare()
+ runner.run()
+
+
+def make_code_from_py(filename):
+ """Get source from `filename` and make a code object of it."""
+ # Open the source file.
+ try:
+ source = get_python_source(filename)
+ except (OSError, NoSource) as exc:
+ raise NoSource(f"No file to run: '{filename}'") from exc
+
+ code = compile_unicode(source, filename, "exec")
+ return code
+
+
+def make_code_from_pyc(filename):
+ """Get a code object from a .pyc file."""
+ try:
+ fpyc = open(filename, "rb")
+ except OSError as exc:
+ raise NoCode(f"No file to run: '{filename}'") from exc
+
+ with fpyc:
+ # First four bytes are a version-specific magic number. It has to
+ # match or we won't run the file.
+ magic = fpyc.read(4)
+ if magic != PYC_MAGIC_NUMBER:
+ raise NoCode(f"Bad magic number in .pyc file: {magic!r} != {PYC_MAGIC_NUMBER!r}")
+
+ flags = struct.unpack('<L', fpyc.read(4))[0]
+ hash_based = flags & 0x01
+ if hash_based:
+ fpyc.read(8) # Skip the hash.
+ else:
+ # Skip the junk in the header that we don't need.
+ fpyc.read(4) # Skip the moddate.
+ fpyc.read(4) # Skip the size.
+
+ # The rest of the file is the code object we want.
+ code = marshal.load(fpyc)
+
+ return code
