coverage 7.6.7__cp311-cp311-win_amd64.whl → 7.11.1__cp311-cp311-win_amd64.whl

coverage/env.py

@@ -8,9 +8,8 @@ from __future__ import annotations
 import os
 import platform
 import sys
-
-from typing import Any
 from collections.abc import Iterable
+from typing import Any, Final
 
 # debug_info() at the bottom wants to show all the globals, but not imports.
 # Grab the global names here to know which names to not show. Nothing defined
@@ -22,11 +21,11 @@ _UNINTERESTING_GLOBALS += ["PYBEHAVIOR", "debug_info"]
 # Operating systems.
 WINDOWS = sys.platform == "win32"
 LINUX = sys.platform.startswith("linux")
-OSX = sys.platform == "darwin"
+MACOS = sys.platform == "darwin"
 
 # Python implementations.
-CPYTHON = (platform.python_implementation() == "CPython")
-PYPY = (platform.python_implementation() == "PyPy")
+CPYTHON = (platform.python_implementation() == "CPython")  # fmt: skip
+PYPY = (platform.python_implementation() == "PyPy")  # fmt: skip
 
 # Python versions. We amend version_info with one more value, a zero if an
 # official version, or 1 if built from source beyond an official version.
@@ -36,69 +35,80 @@ PYVERSION = sys.version_info + (int(platform.python_version()[-1] == "+"),)
 
 if PYPY:
     # Minimum now is 7.3.16
-    PYPYVERSION = sys.pypy_version_info         # type: ignore[attr-defined]
+    PYPYVERSION = tuple(sys.pypy_version_info)  # type: ignore[attr-defined]
 else:
     PYPYVERSION = (0,)
 
-# Python behavior.
-class PYBEHAVIOR:
-    """Flags indicating this Python's behavior."""
-
-    # Does Python conform to PEP626, Precise line numbers for debugging and other tools.
-    # https://www.python.org/dev/peps/pep-0626
-    pep626 = (PYVERSION > (3, 10, 0, "alpha", 4))
-
-    # Is "if __debug__" optimized away?
-    optimize_if_debug = not pep626
-
-    # Is "if not __debug__" optimized away? The exact details have changed
-    # across versions.
-    if pep626:
-        optimize_if_not_debug = 1
-    else:
-        optimize_if_not_debug = 2
-
-    # 3.7 changed how functions with only docstrings are numbered.
-    docstring_only_function = (not PYPY) and (PYVERSION <= (3, 10))
-
-    # Lines after break/continue/return/raise are no longer compiled into the
-    # bytecode.  They used to be marked as missing, now they aren't executable.
-    omit_after_jump = pep626 or PYPY
+# Do we have a GIL?
+GIL = getattr(sys, "_is_gil_enabled", lambda: True)()
 
-    # PyPy has always omitted statements after return.
-    omit_after_return = omit_after_jump or PYPY
+# Do we ship compiled coveragepy wheels for this version?
+SHIPPING_WHEELS = CPYTHON and PYVERSION[:2] <= (3, 14)
 
-    # Optimize away unreachable try-else clauses.
-    optimize_unreachable_try_else = pep626
+# Should we default to sys.monitoring?
+SYSMON_DEFAULT = CPYTHON and PYVERSION >= (3, 14)
 
-    # Modules used to have firstlineno equal to the line number of the first
-    # real line of code.  Now they always start at 1.
-    module_firstline_1 = pep626
 
-    # Are "if 0:" lines (and similar) kept in the compiled code?
-    keep_constant_test = pep626
-
-    # When leaving a with-block, do we visit the with-line again for the exit?
-    exit_through_with = (PYVERSION >= (3, 10, 0, "beta"))
+# Python behavior.
+class PYBEHAVIOR:
+    """Flags indicating this Python's behavior."""
 
     # When leaving a with-block, do we visit the with-line exactly,
-    # or the inner-most context manager?
-    exit_with_through_ctxmgr = (PYVERSION >= (3, 12, 6))
-
-    # Match-case construct.
-    match_case = (PYVERSION >= (3, 10))
-
-    # Some words are keywords in some places, identifiers in other places.
-    soft_keywords = (PYVERSION >= (3, 10))
+    # or the context managers in inner-out order?
+    #
+    # mwith.py:
+    #    with (
+    #        open("/tmp/one", "w") as f2,
+    #        open("/tmp/two", "w") as f3,
+    #        open("/tmp/three", "w") as f4,
+    #    ):
+    #        print("hello 6")
+    #
+    # % python3.11 -m trace -t mwith.py | grep mwith
+    #  --- modulename: mwith, funcname: <module>
+    # mwith.py(2):     open("/tmp/one", "w") as f2,
+    # mwith.py(1): with (
+    # mwith.py(2):     open("/tmp/one", "w") as f2,
+    # mwith.py(3):     open("/tmp/two", "w") as f3,
+    # mwith.py(1): with (
+    # mwith.py(3):     open("/tmp/two", "w") as f3,
+    # mwith.py(4):     open("/tmp/three", "w") as f4,
+    # mwith.py(1): with (
+    # mwith.py(4):     open("/tmp/three", "w") as f4,
+    # mwith.py(6):     print("hello 6")
+    # mwith.py(1): with (
+    #
+    # % python3.12 -m trace -t mwith.py | grep mwith
+    #  --- modulename: mwith, funcname: <module>
+    # mwith.py(2):      open("/tmp/one", "w") as f2,
+    # mwith.py(3):      open("/tmp/two", "w") as f3,
+    # mwith.py(4):      open("/tmp/three", "w") as f4,
+    # mwith.py(6):      print("hello 6")
+    # mwith.py(4):      open("/tmp/three", "w") as f4,
+    # mwith.py(3):      open("/tmp/two", "w") as f3,
+    # mwith.py(2):      open("/tmp/one", "w") as f2,
+
+    exit_with_through_ctxmgr = (PYVERSION >= (3, 12, 6))  # fmt: skip
+
+    # f-strings are parsed as code, pep 701
+    fstring_syntax = (PYVERSION >= (3, 12))  # fmt: skip
 
     # PEP669 Low Impact Monitoring: https://peps.python.org/pep-0669/
-    pep669 = bool(getattr(sys, "monitoring", None))
+    pep669: Final[bool] = bool(getattr(sys, "monitoring", None))
 
     # Where does frame.f_lasti point when yielding from a generator?
     # It used to point at the YIELD, in 3.13 it points at the RESUME,
     # then it went back to the YIELD.
     # https://github.com/python/cpython/issues/113728
-    lasti_is_yield = (PYVERSION[:2] != (3, 13))
+    lasti_is_yield = (PYVERSION[:2] != (3, 13))  # fmt: skip
+
+    # PEP649 and PEP749: Deferred annotations
+    deferred_annotations = (PYVERSION >= (3, 14))  # fmt: skip
+
+    # Does sys.monitoring support BRANCH_RIGHT and BRANCH_LEFT?  The names
+    # were added in early 3.14 alphas, but didn't work entirely correctly until
+    # after 3.14.0a5.
+    branch_right_left = pep669 and (PYVERSION > (3, 14, 0, "alpha", 5, 0))
 
 
 # Coverage.py specifics, about testing scenarios. See tests/testenv.py also.
@@ -115,11 +125,11 @@ TESTING = os.getenv("COVERAGE_TESTING") == "True"
 def debug_info() -> Iterable[tuple[str, Any]]:
     """Return a list of (name, value) pairs for printing debug information."""
     info = [
-        (name, value) for name, value in globals().items()
+        (name, value)
+        for name, value in globals().items()
         if not name.startswith("_") and name not in _UNINTERESTING_GLOBALS
     ]
     info += [
-        (name, value) for name, value in PYBEHAVIOR.__dict__.items()
-        if not name.startswith("_")
+        (name, value) for name, value in PYBEHAVIOR.__dict__.items() if not name.startswith("_")
     ]
     return sorted(info)

coverage/exceptions.py

@@ -5,47 +5,73 @@
 
 from __future__ import annotations
 
-class _BaseCoverageException(Exception):
-    """The base-base of all Coverage exceptions."""
-    pass
+from typing import Any
 
 
-class CoverageException(_BaseCoverageException):
+class CoverageException(Exception):
     """The base class of all exceptions raised by Coverage.py."""
-    pass
 
-
-class ConfigError(_BaseCoverageException):
+    def __init__(
+        self,
+        *args: Any,
+        slug: str | None = None,
+        skip_tests: bool = False,
+    ) -> None:
+        """Create an exception.
+
+        Args:
+            slug: A short string identifying the exception, will be used for
+                linking to documentation.
+            skip_tests: If True, raising this exception will skip the test it
+                is raised in.  This is used for shutting off large numbers of
+                tests that we know will not succeed because of a configuration
+                mismatch.
+        """
+
+        super().__init__(*args)
+        self.slug = slug
+        self.skip_tests = skip_tests
+
+
+class ConfigError(CoverageException):
     """A problem with a config file, or a value in one."""
+
     pass
 
 
 class DataError(CoverageException):
     """An error in using a data file."""
+
     pass
 
+
 class NoDataError(CoverageException):
     """We didn't have data to work with."""
+
     pass
 
 
 class NoSource(CoverageException):
     """We couldn't find the source for a module."""
+
     pass
 
 
 class NoCode(NoSource):
     """We couldn't find any code at all."""
+
     pass
 
 
 class NotPython(CoverageException):
     """A source file turned out not to be parsable Python."""
+
     pass
 
 
 class PluginError(CoverageException):
     """A plugin misbehaved."""
+
     pass
 
 
@@ -55,9 +81,11 @@ class _ExceptionDuringRun(CoverageException):
     Construct it with three arguments, the values from `sys.exc_info`.
 
     """
+
     pass
 
 
 class CoverageWarning(Warning):
     """A warning from Coverage.py."""
+
     pass

coverage/execfile.py

@@ -12,12 +12,11 @@ import marshal
 import os
 import struct
 import sys
-
 from importlib.machinery import ModuleSpec
 from types import CodeType, ModuleType
 from typing import Any
 
-from coverage.exceptions import CoverageException, _ExceptionDuringRun, NoCode, NoSource
+from coverage.exceptions import CoverageException, NoCode, NoSource, _ExceptionDuringRun
 from coverage.files import canonical_filename, python_reported_file
 from coverage.misc import isolate_module
 from coverage.python import get_python_source
@@ -27,11 +26,13 @@ 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: str, *_args: Any) -> None:
         self.fullname = fullname
 
@@ -57,8 +58,8 @@ def find_module(
         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",
+                f"No module named {mod_main}; "
+                + f"{modulename!r} is a package and cannot be directly executed",
             )
         pathname = spec.origin
         packagename = spec.name
@@ -72,6 +73,7 @@ class PyRunner:
     This is meant to emulate real Python execution as closely as possible.
 
     """
+
     def __init__(self, args: list[str], as_module: bool = False) -> None:
         self.args = args
         self.as_module = as_module
@@ -89,7 +91,10 @@ class PyRunner:
         This needs to happen before any importing, and without importing anything.
         """
         path0: str | None
-        if self.as_module:
+        if getattr(sys.flags, "safe_path", False):
+            # See https://docs.python.org/3/using/cmdline.html#cmdoption-P
+            path0 = None
+        elif self.as_module:
             path0 = os.getcwd()
         elif os.path.isdir(self.arg0):
             # Running a directory means running the __main__.py file in that
@@ -142,7 +147,7 @@ class PyRunner:
             # 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)
+                try_filename = os.path.join(self.arg0, f"__main__{ext}")
                 # 3.8.10 changed how files are reported when running a
                 # directory.
                 try_filename = os.path.abspath(try_filename)
@@ -177,11 +182,11 @@ class PyRunner:
             main_mod.__file__ = main_mod.__file__[:-1]
         if self.package is not None:
             main_mod.__package__ = self.package
-        main_mod.__loader__ = self.loader   # type: ignore[assignment]
+        main_mod.__loader__ = self.loader  # type: ignore[assignment]
         if self.spec is not None:
             main_mod.__spec__ = self.spec
 
-        main_mod.__builtins__ = sys.modules["builtins"]     # type: ignore[attr-defined]
+        main_mod.__builtins__ = sys.modules["builtins"]  # type: ignore[attr-defined]
 
         sys.modules["__main__"] = main_mod
 
@@ -206,7 +211,7 @@ class PyRunner:
         cwd = os.getcwd()
         try:
             exec(code, main_mod.__dict__)
-        except SystemExit:                          # pylint: disable=try-except-raise
+        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
@@ -232,7 +237,7 @@ class PyRunner:
                 assert err.__traceback__ is not None
                 err.__traceback__ = err.__traceback__.tb_next
                 sys.excepthook(typ, err, tb.tb_next)
-            except SystemExit:                      # pylint: disable=try-except-raise
+            except SystemExit:  # pylint: disable=try-except-raise
                 raise
             except Exception as exc:
                 # Getting the output right in the case of excepthook
@@ -311,11 +316,11 @@ def make_code_from_pyc(filename: str) -> CodeType:
         flags = struct.unpack("<L", fpyc.read(4))[0]
         hash_based = flags & 0x01
         if hash_based:
-            fpyc.read(8)    # Skip the hash.
+            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.
+            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)

coverage/files.py

@@ -12,21 +12,20 @@ import os.path
 import posixpath
 import re
 import sys
-
-from typing import Callable
 from collections.abc import Iterable
+from typing import Callable
 
 from coverage import env
 from coverage.exceptions import ConfigError
 from coverage.misc import human_sorted, isolate_module, join_regex
 
-
 os = isolate_module(os)
 
 
 RELATIVE_DIR: str = ""
 CANONICAL_FILENAME_CACHE: dict[str, str] = {}
 
+
 def set_relative_directory() -> None:
     """Set the directory that `relative_filename` will be relative to."""
     global RELATIVE_DIR, CANONICAL_FILENAME_CACHE
@@ -59,7 +58,7 @@ def relative_filename(filename: str) -> str:
     """
     fnorm = os.path.normcase(filename)
     if fnorm.startswith(RELATIVE_DIR):
-        filename = filename[len(RELATIVE_DIR):]
+        filename = filename[len(RELATIVE_DIR) :]
     return filename
 
 
@@ -74,7 +73,7 @@ def canonical_filename(filename: str) -> str:
         if not os.path.isabs(filename):
             for path in [os.curdir] + sys.path:
                 if path is None:
-                    continue # type: ignore[unreachable]
+                    continue  # type: ignore[unreachable]
                 f = os.path.join(path, filename)
                 try:
                     exists = os.path.exists(f)
@@ -112,7 +111,6 @@ def flat_rootname(filename: str) -> str:
 
 
 if env.WINDOWS:
-
     _ACTUAL_PATH_CACHE: dict[str, str] = {}
     _ACTUAL_PATH_LIST_CACHE: dict[str, list[str]] = {}
 
@@ -149,6 +147,7 @@ if env.WINDOWS:
         return actpath
 
 else:
+
     def actual_path(path: str) -> str:
         """The actual path for non-Windows platforms."""
         return path
@@ -166,7 +165,7 @@ def zip_location(filename: str) -> tuple[str, str] | None:
     name is in the zipfile.
 
     """
-    for ext in [".zip", ".whl", ".egg", ".pex"]:
+    for ext in [".zip", ".whl", ".egg", ".pex", ".par"]:
         zipbase, extension, inner = filename.partition(ext + sep(filename))
         if extension:
             zipfile = zipbase + ext
@@ -224,9 +223,9 @@ class TreeMatcher:
     somewhere in a subtree rooted at one of the directories.
 
     """
+
     def __init__(self, paths: Iterable[str], name: str = "unknown") -> None:
         self.original_paths: list[str] = human_sorted(paths)
-        #self.paths = list(map(os.path.normcase, paths))
         self.paths = [os.path.normcase(p) for p in paths]
         self.name = name
 
@@ -253,7 +252,8 @@ class TreeMatcher:
 
 class ModuleMatcher:
     """A matcher for modules in a tree."""
-    def __init__(self, module_names: Iterable[str], name:str = "unknown") -> None:
+
+    def __init__(self, module_names: Iterable[str], name: str = "unknown") -> None:
         self.modules = list(module_names)
         self.name = name
 
@@ -282,6 +282,7 @@ class ModuleMatcher:
 
 class GlobMatcher:
     """A matcher for files by file name pattern."""
+
     def __init__(self, pats: Iterable[str], name: str = "unknown") -> None:
         self.pats = list(pats)
         self.re = globs_to_regex(self.pats, case_insensitive=env.WINDOWS)
@@ -310,6 +311,7 @@ def sep(s: str) -> str:
 
 # Tokenizer for _glob_to_regex.
 # None as a sub means disallowed.
+# fmt: off
 G2RX_TOKENS = [(re.compile(rx), sub) for rx, sub in [
     (r"\*\*\*+", None),             # Can't have ***
     (r"[^/]+\*\*+", None),          # Can't have x**
@@ -326,17 +328,19 @@ G2RX_TOKENS = [(re.compile(rx), sub) for rx, sub in [
     (r"[\[\]]", None),              # Can't have single square brackets
     (r".", r"\\\g<0>"),             # Anything else is escaped to be safe
 ]]
+# fmt: on
+
 
 def _glob_to_regex(pattern: str) -> str:
     """Convert a file-path glob pattern into a regex."""
     # Turn all backslashes into slashes to simplify the tokenizer.
     pattern = pattern.replace("\\", "/")
     if "/" not in pattern:
-        pattern = "**/" + pattern
+        pattern = f"**/{pattern}"
     path_rx = []
     pos = 0
     while pos < len(pattern):
-        for rx, sub in G2RX_TOKENS:                     # pragma: always breaks
+        for rx, sub in G2RX_TOKENS:  # pragma: always breaks
             if m := rx.match(pattern, pos=pos):
                 if sub is None:
                     raise ConfigError(f"File pattern can't include {m[0]!r}")
@@ -372,7 +376,7 @@ def globs_to_regex(
         flags |= re.IGNORECASE
     rx = join_regex(map(_glob_to_regex, patterns))
     if not partial:
-        rx = fr"(?:{rx})\Z"
+        rx = rf"(?:{rx})\Z"
     compiled = re.compile(rx, flags=flags)
     return compiled
 
@@ -388,6 +392,7 @@ class PathAliases:
     map a path through those aliases to produce a unified path.
 
     """
+
     def __init__(
         self,
         debugfn: Callable[[str], None] | None = None,
@@ -444,7 +449,7 @@ class PathAliases:
         result = result.rstrip(r"\/") + result_sep
         self.aliases.append((original_pattern, regex, result))
 
-    def map(self, path: str, exists:Callable[[str], bool] = source_exists) -> str:
+    def map(self, path: str, exists: Callable[[str], bool] = source_exists) -> str:
         """Map `path` through the aliases.
 
         `path` is checked against all of the patterns.  The first pattern to
@@ -478,13 +483,13 @@ class PathAliases:
                     new = new[2:]
                 if not exists(new):
                     self.debugfn(
-                        f"Rule {original_pattern!r} changed {path!r} to {new!r} " +
-                        "which doesn't exist, continuing",
+                        f"Rule {original_pattern!r} changed {path!r} to {new!r} "
+                        + "which doesn't exist, continuing",
                     )
                     continue
                 self.debugfn(
-                    f"Matched path {path!r} to rule {original_pattern!r} -> {result!r}, " +
-                    f"producing {new!r}",
+                    f"Matched path {path!r} to rule {original_pattern!r} -> {result!r}, "
+                    + f"producing {new!r}",
                 )
                 return new
 
@@ -499,7 +504,7 @@ class PathAliases:
             if len(parts) > 1:
                 dir1 = parts[0]
                 pattern = f"*/{dir1}"
-                regex_pat = fr"^(.*[\\/])?{re.escape(dir1)}[\\/]"
+                regex_pat = rf"^(.*[\\/])?{re.escape(dir1)}[\\/]"
                 result = f"{dir1}{os.sep}"
                 # Only add a new pattern if we don't already have this pattern.
                 if not any(p == pattern for p, _, _ in self.aliases):