eric: comparison eric7/DebugClients/Python/coverage/execfile.py

-:d728227e8ebb
+:0802ae193343
 # 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.backward import BUILTINS
+from coverage.exceptions import CoverageException, ExceptionDuringRun, NoCode, NoSource
-from coverage.backward import PYC_MAGIC_NUMBER, imp, importlib_util_find_spec
 from coverage.files import canonical_filename, python_reported_file
-from coverage.misc import CoverageException, ExceptionDuringRun, NoCode, NoSource, isolate_module
+from coverage.misc import isolate_module
 from coverage.phystokens import compile_unicode
 from coverage.python import get_python_source
 os = isolate_module(os)
-class DummyLoader(object):
+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
-if importlib_util_find_spec:
+def find_module(modulename):
-def find_module(modulename):
+"""Find the module named `modulename`.
-"""Find the module named `modulename`.
+Returns the file path of the module, the name of the enclosing
-Returns the file path of the module, the name of the enclosing
+package, and the spec.
-package, and the spec.
+"""
-"""
+try:
-try:
+spec = importlib.util.find_spec(modulename)
-spec = importlib_util_find_spec(modulename)
+except ImportError as err:
-except ImportError as err:
+raise NoSource(str(err)) from err
-raise NoSource(str(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("No module named %r" % (modulename,))
+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
-if spec.submodule_search_locations:
+packagename = packagename.rpartition(".")[0]
-mod_main = modulename + ".__main__"
+return pathname, packagename, spec
-spec = importlib_util_find_spec(mod_main)
-if not spec:
-raise NoSource(
+class PyRunner:
-"No module named %s; "
-"%r is a package and cannot be directly executed"
-% (mod_main, modulename)
-)
-pathname = spec.origin
-packagename = spec.name
-packagename = packagename.rpartition(".")[0]
-return pathname, packagename, spec
-else:
-def find_module(modulename):
-"""Find the module named `modulename`.
-Returns the file path of the module, the name of the enclosing
-package, and None (where a spec would have been).
-"""
-openfile = None
-glo, loc = globals(), locals()
-try:
-# Search for the module - inside its parent package, if any - using
-# standard import mechanics.
-if '.' in modulename:
-packagename, name = modulename.rsplit('.', 1)
-package = __import__(packagename, glo, loc, ['__path__'])
-searchpath = package.__path__
-else:
-packagename, name = None, modulename
-searchpath = None  # "top-level search" in imp.find_module()
-openfile, pathname, _ = imp.find_module(name, searchpath)
-# Complain if this is a magic non-file module.
-if openfile is None and pathname is None:
-raise NoSource(
-"module does not live in a file: %r" % modulename
-)
-# If `modulename` is actually a package, not a mere module, then we
-# pretend to be Python 2.7 and try running its __main__.py script.
-if openfile is None:
-packagename = modulename
-name = '__main__'
-package = __import__(packagename, glo, loc, ['__path__'])
-searchpath = package.__path__
-openfile, pathname, _ = imp.find_module(name, searchpath)
-except ImportError as err:
-raise NoSource(str(err))
-finally:
-if openfile:
-openfile.close()
-return pathname, packagename, None
-class PyRunner(object):
 """Multi-stage execution of Python code.
 This is meant to emulate real Python execution as closely as possible.
 """
 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("Can't find '__main__' module in '%s'" % self.arg0)
-if env.PY2:
-self.arg0 = os.path.abspath(self.arg0)
 # Make a spec. I don't know if this is the right way to do it.
-try:
+try_filename = python_reported_file(try_filename)
-import importlib.machinery
+self.spec = importlib.machinery.ModuleSpec("__main__", None, origin=try_filename)
-except ImportError:
+self.spec.has_location = True
-pass
-else:
-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:
-if env.PY3:
+self.loader = DummyLoader("__main__")
-self.loader = DummyLoader("__main__")
 self.arg0 = python_reported_file(self.arg0)
 def run(self):
 """Run the Python code!"""
 main_mod.__package__ = self.package
 main_mod.__loader__ = self.loader
 if self.spec is not None:
 main_mod.__spec__ = self.spec
-main_mod.__builtins__ = BUILTINS
+main_mod.__builtins__ = sys.modules['builtins']
 sys.modules['__main__'] = main_mod
 # Set sys.argv properly.
 sys.argv = self.args
 else:
 code = make_code_from_py(self.arg0)
 except CoverageException:
 raise
 except Exception as exc:
-msg = "Couldn't run '{filename}' as Python code: {exc.__class__.__name__}: {exc}"
+msg = f"Couldn't run '{self.arg0}' as Python code: {exc.__class__.__name__}: {exc}"
-raise CoverageException(msg.format(filename=self.arg0, exc=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()
 # it somehow? https://bitbucket.org/pypy/pypy/issue/1903
 getattr(err, '__context__', None)
 # Call the excepthook.
 try:
-if hasattr(err, "__traceback__"):
+err.__traceback__ = err.__traceback__.tb_next
-err.__traceback__ = err.__traceback__.tb_next
 sys.excepthook(typ, err, tb.tb_next)
 except SystemExit:                      # pylint: disable=try-except-raise
 raise
-except Exception:
+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
-if hasattr(err2, "__traceback__"):
+err2.__traceback__ = err2.__traceback__.tb_next
-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)
+raise ExceptionDuringRun(typ, err, tb.tb_next) from exc
 else:
 sys.exit(1)
 finally:
 os.chdir(cwd)
 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 (IOError, NoSource):
+except (OSError, NoSource) as exc:
-raise NoSource("No file to run: '%s'" % filename)
+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 IOError:
+except OSError as exc:
-raise NoCode("No file to run: '%s'" % filename)
+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("Bad magic number in .pyc file: {} != {}".format(magic, PYC_MAGIC_NUMBER))
+raise NoCode(f"Bad magic number in .pyc file: {magic} != {PYC_MAGIC_NUMBER}")
 date_based = True
 if env.PYBEHAVIOR.hashed_pyc_pep552:
 flags = struct.unpack('<L', fpyc.read(4))[0]
 hash_based = flags & 0x01
 fpyc.read(8)    # Skip the hash.
 date_based = False
 if date_based:
 # Skip the junk in the header that we don't need.
 fpyc.read(4)            # Skip the moddate.
-if env.PYBEHAVIOR.size_in_pyc:
+# 3.3 added another long to the header (size), skip it.
-# 3.3 added another long to the header (size), skip it.
+fpyc.read(4)
-fpyc.read(4)
 # The rest of the file is the code object we want.
 code = marshal.load(fpyc)
 return code

Mercurial Repositories > eric / file comparison

comparison: eric7/DebugClients/Python/coverage/execfile.py

eric7/DebugClients/Python/coverage/execfile.py