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

coverage/inorout.py

@@ -15,51 +15,54 @@ import re
 import sys
 import sysconfig
 import traceback
-
-from types import FrameType, ModuleType
-from typing import (
-    cast, Any, TYPE_CHECKING,
-)
 from collections.abc import Iterable
+from types import FrameType, ModuleType
+from typing import TYPE_CHECKING, Any, cast
 
 from coverage import env
 from coverage.disposition import FileDisposition, disposition_init
-from coverage.exceptions import CoverageException, PluginError
-from coverage.files import TreeMatcher, GlobMatcher, ModuleMatcher
-from coverage.files import prep_patterns, find_python_files, canonical_filename
+from coverage.exceptions import ConfigError, CoverageException, PluginError
+from coverage.files import (
+    GlobMatcher,
+    ModuleMatcher,
+    TreeMatcher,
+    canonical_filename,
+    find_python_files,
+    prep_patterns,
+)
 from coverage.misc import isolate_module, sys_modules_saved
 from coverage.python import source_for_file, source_for_morf
-from coverage.types import TFileDisposition, TMorf, TWarnFn, TDebugCtl
+from coverage.types import TDebugCtl, TFileDisposition, TMorf, TWarnFn
 
 if TYPE_CHECKING:
     from coverage.config import CoverageConfig
     from coverage.plugin_support import Plugins
 
 
-# Pypy has some unusual stuff in the "stdlib".  Consider those locations
-# when deciding where the stdlib is.  These modules are not used for anything,
-# they are modules importable from the pypy lib directories, so that we can
-# find those directories.
 modules_we_happen_to_have: list[ModuleType] = [
-    inspect, itertools, os, platform, re, sysconfig, traceback,
+    inspect,
+    itertools,
+    os,
+    platform,
+    re,
+    sysconfig,
+    traceback,
 ]
 
 if env.PYPY:
-    try:
-        import _structseq
-        modules_we_happen_to_have.append(_structseq)
-    except ImportError:
-        pass
+    # Pypy has some unusual stuff in the "stdlib".  Consider those locations
+    # when deciding where the stdlib is.  These modules are not used for anything,
+    # they are modules importable from the pypy lib directories, so that we can
+    # find those directories.
+    import _pypy_irc_topic  # pylint: disable=import-error
+    import _structseq  # pylint: disable=import-error
 
-    try:
-        import _pypy_irc_topic
-        modules_we_happen_to_have.append(_pypy_irc_topic)
-    except ImportError:
-        pass
+    modules_we_happen_to_have.extend([_structseq, _pypy_irc_topic])
 
 
 os = isolate_module(os)
 
+
 def canonical_path(morf: TMorf, directory: bool = False) -> str:
     """Return the canonical path of the module or file `morf`.
 
@@ -74,7 +77,7 @@ def canonical_path(morf: TMorf, directory: bool = False) -> str:
     return morf_path
 
 
-def name_for_module(filename: str, frame: FrameType | None) -> str:
+def name_for_module(filename: str, frame: FrameType | None) -> str | None:
     """Get the name of the module for a filename and frame.
 
     For configurability's sake, we allow __main__ modules to be matched by
@@ -87,7 +90,7 @@ def name_for_module(filename: str, frame: FrameType | None) -> str:
 
     """
     module_globals = frame.f_globals if frame is not None else {}
-    dunder_name: str = module_globals.get("__name__", None)
+    dunder_name: str | None = module_globals.get("__name__", None)
 
     if isinstance(dunder_name, str) and dunder_name != "__main__":
         # This is the usual case: an imported module.
@@ -191,14 +194,23 @@ class InOrOut:
         self.debug = debug
         self.include_namespace_packages = include_namespace_packages
 
-        self.source: list[str] = []
         self.source_pkgs: list[str] = []
         self.source_pkgs.extend(config.source_pkgs)
+        self.source_dirs: list[str] = []
+        self.source_dirs.extend(config.source_dirs)
         for src in config.source or []:
             if os.path.isdir(src):
-                self.source.append(canonical_filename(src))
+                self.source_dirs.append(src)
             else:
                 self.source_pkgs.append(src)
+
+        # Canonicalize everything in `source_dirs`.
+        # Also confirm that they actually are directories.
+        for i, src in enumerate(self.source_dirs):
+            if not os.path.isdir(src):
+                raise ConfigError(f"Source dir is not a directory: {src!r}")
+            self.source_dirs[i] = canonical_filename(src)
+
         self.source_pkgs_unmatched = self.source_pkgs[:]
 
         self.include = prep_patterns(config.run_include)
@@ -233,10 +245,10 @@ class InOrOut:
         self.pylib_match = None
         self.include_match = self.omit_match = None
 
-        if self.source or self.source_pkgs:
+        if self.source_dirs or self.source_pkgs:
             against = []
-            if self.source:
-                self.source_match = TreeMatcher(self.source, "source")
+            if self.source_dirs:
+                self.source_match = TreeMatcher(self.source_dirs, "source")
                 against.append(f"trees {self.source_match!r}")
             if self.source_pkgs:
                 self.source_pkgs_match = ModuleMatcher(self.source_pkgs, "source_pkgs")
@@ -285,7 +297,7 @@ class InOrOut:
                             )
                             self.source_in_third_paths.add(pathdir)
 
-        for src in self.source:
+        for src in self.source_dirs:
             if self.third_match.match(src):
                 _debug(f"Source in third-party: source directory {src!r}")
                 self.source_in_third_paths.add(src)
@@ -410,7 +422,7 @@ class InOrOut:
             extra = ""
             ok = False
             if self.source_pkgs_match:
-                if self.source_pkgs_match.match(modulename):
+                if isinstance(modulename, str) and self.source_pkgs_match.match(modulename):
                     ok = True
                     if modulename in self.source_pkgs_unmatched:
                         self.source_pkgs_unmatched.remove(modulename)
@@ -457,12 +469,12 @@ class InOrOut:
     def warn_conflicting_settings(self) -> None:
         """Warn if there are settings that conflict."""
         if self.include:
-            if self.source or self.source_pkgs:
+            if self.source_dirs or self.source_pkgs:
                 self.warn("--include is ignored because --source is set", slug="include-ignored")
 
     def warn_already_imported_files(self) -> None:
         """Warn if files have already been imported that we will be measuring."""
-        if self.include or self.source or self.source_pkgs:
+        if self.include or self.source_dirs or self.source_pkgs:
             warned = set()
             for mod in list(sys.modules.values()):
                 filename = getattr(mod, "__file__", None)
@@ -488,7 +500,8 @@ class InOrOut:
                 elif self.debug and self.debug.should("trace"):
                     self.debug.write(
                         "Didn't trace already imported file {!r}: {}".format(
-                            disp.original_filename, disp.reason,
+                            disp.original_filename,
+                            disp.reason,
                         ),
                     )
 
@@ -529,13 +542,12 @@ class InOrOut:
         Yields pairs: file path, and responsible plug-in name.
         """
         for pkg in self.source_pkgs:
-            if (pkg not in sys.modules or
-                not module_has_file(sys.modules[pkg])):
+            if pkg not in sys.modules or not module_has_file(sys.modules[pkg]):
                 continue
             pkg_file = source_for_file(cast(str, sys.modules[pkg].__file__))
             yield from self._find_executable_files(canonical_path(pkg_file))
 
-        for src in self.source:
+        for src in self.source_dirs:
             yield from self._find_executable_files(src)
 
     def _find_plugin_files(self, src_dir: str) -> Iterable[tuple[str, str]]:
@@ -555,8 +567,8 @@ class InOrOut:
 
         """
         py_files = (
-            (py_file, None) for py_file in
-            find_python_files(src_dir, self.include_namespace_packages)
+            (py_file, None)
+            for py_file in find_python_files(src_dir, self.include_namespace_packages)
         )
         plugin_files = self._find_plugin_files(src_dir)
 
@@ -581,9 +593,14 @@ class InOrOut:
         ]
 
         matcher_names = [
-            "source_match", "source_pkgs_match",
-            "include_match", "omit_match",
-            "cover_match", "pylib_match", "third_match", "source_in_third_match",
+            "source_match",
+            "source_pkgs_match",
+            "include_match",
+            "omit_match",
+            "cover_match",
+            "pylib_match",
+            "third_match",
+            "source_in_third_match",
         ]
 
         for matcher_name in matcher_names:

coverage/jsonreport.py

@@ -8,14 +8,13 @@ from __future__ import annotations
 import datetime
 import json
 import sys
-
 from collections.abc import Iterable
-from typing import Any, IO, TYPE_CHECKING
+from typing import IO, TYPE_CHECKING, Any
 
 from coverage import __version__
 from coverage.report_core import get_analysis_to_report
-from coverage.results import Analysis, Numbers
-from coverage.types import TMorf, TLineNo
+from coverage.results import Analysis, AnalysisNarrower, Numbers
+from coverage.types import TLineNo, TMorf
 
 if TYPE_CHECKING:
     from coverage import Coverage
@@ -31,6 +30,7 @@ JsonObj = dict[str, Any]
 # 3: add region information (functions, classes)
 FORMAT_VERSION = 3
 
+
 class JsonReporter:
     """A reporter for writing JSON coverage results."""
 
@@ -128,21 +128,30 @@ class JsonReporter:
             )
 
         num_lines = len(file_reporter.source().splitlines())
+        regions = file_reporter.code_regions()
         for noun, plural in file_reporter.code_region_kinds():
-            reported_file[plural] = region_data = {}
             outside_lines = set(range(1, num_lines + 1))
-            for region in file_reporter.code_regions():
+            for region in regions:
                 if region.kind != noun:
                     continue
                 outside_lines -= region.lines
+
+            narrower = AnalysisNarrower(analysis)
+            narrower.add_regions(r.lines for r in regions if r.kind == noun)
+            narrower.add_regions([outside_lines])
+
+            reported_file[plural] = region_data = {}
+            for region in regions:
+                if region.kind != noun:
+                    continue
                 region_data[region.name] = self.make_region_data(
                     coverage_data,
-                    analysis.narrow(region.lines),
+                    narrower.narrow(region.lines),
                 )
 
             region_data[""] = self.make_region_data(
                 coverage_data,
-                analysis.narrow(outside_lines),
+                narrower.narrow(outside_lines),
             )
         return reported_file
 

coverage/lcovreport.py

@@ -8,13 +8,12 @@ from __future__ import annotations
 import base64
 import hashlib
 import sys
-
-from typing import IO, TYPE_CHECKING
 from collections.abc import Iterable
+from typing import IO, TYPE_CHECKING
 
 from coverage.plugin import FileReporter
 from coverage.report_core import get_analysis_to_report
-from coverage.results import Analysis, Numbers
+from coverage.results import Analysis, AnalysisNarrower, Numbers
 from coverage.types import TMorf
 
 if TYPE_CHECKING:
@@ -43,7 +42,7 @@ def lcov_lines(
     hash_suffix = ""
     for line in lines:
         if source_lines:
-            hash_suffix = "," + line_hash(source_lines[line-1])
+            hash_suffix = "," + line_hash(source_lines[line - 1])
         # Q: can we get info about the number of times a statement is
         # executed?  If so, that should be recorded here.
         hit = int(line not in analysis.missing)
@@ -71,21 +70,26 @@ def lcov_functions(
 
     # suppressions because of https://github.com/pylint-dev/pylint/issues/9923
     functions = [
-        (min(region.start, min(region.lines)), #pylint: disable=nested-min-max
-         max(region.start, max(region.lines)), #pylint: disable=nested-min-max
-         region)
+        (
+            min(region.start, min(region.lines)),  # pylint: disable=nested-min-max
+            max(region.start, max(region.lines)),  # pylint: disable=nested-min-max
+            region,
+        )
         for region in fr.code_regions()
         if region.kind == "function" and region.lines
     ]
     if not functions:
         return
 
+    narrower = AnalysisNarrower(file_analysis)
+    narrower.add_regions(r.lines for _, _, r in functions)
+
     functions.sort()
     functions_hit = 0
     for first_line, last_line, region in functions:
         # A function counts as having been executed if any of it has been
         # executed.
-        analysis = file_analysis.narrow(region.lines)
+        analysis = narrower.narrow(region.lines)
         hit = int(analysis.numbers.n_executed > 0)
         functions_hit += hit
 
@@ -118,23 +122,15 @@ def lcov_arcs(
 
         if taken == 0:
             # When _none_ of the out arcs from 'line' were executed,
-            # this probably means 'line' was never executed at all.
-            # Cross-check with the line stats.
+            # it can mean the line always raised an exception.
             assert len(executed_arcs[line]) == 0
-            assert line in analysis.missing
-            destinations = [
-                (dst, "-") for dst in missing_arcs[line]
-            ]
+            destinations = [(dst, "-") for dst in missing_arcs[line]]
         else:
             # Q: can we get counts of the number of times each arc was executed?
             # branch_stats has "total" and "taken" counts for each branch,
             # but it doesn't have "taken" broken down by destination.
-            destinations = [
-                (dst, "1") for dst in executed_arcs[line]
-            ]
-            destinations.extend(
-                (dst, "0") for dst in missing_arcs[line]
-            )
+            destinations = [(dst, "1") for dst in executed_arcs[line]]
+            destinations.extend((dst, "0") for dst in missing_arcs[line])
 
         # Sort exit arcs after normal arcs.  Exit arcs typically come from
         # an if statement, at the end of a function, with no else clause.

coverage/misc.py

@@ -18,20 +18,16 @@ import os.path
 import re
 import sys
 import types
-
-from types import ModuleType
-from typing import (
-    Any, NoReturn, TypeVar,
-)
 from collections.abc import Iterable, Iterator, Mapping, Sequence
-
-from coverage.exceptions import CoverageException
-from coverage.types import TArc
+from types import ModuleType
+from typing import Any, NoReturn, TypeVar
 
 # In 6.0, the exceptions moved from misc.py to exceptions.py.  But a number of
 # other packages were importing the exceptions from misc, so import them here.
 # pylint: disable=unused-wildcard-import
-from coverage.exceptions import *   # pylint: disable=wildcard-import
+from coverage.exceptions import *  # pylint: disable=wildcard-import
+from coverage.exceptions import CoverageException
+from coverage.types import TArc
 
 ISOLATED_MODULES: dict[ModuleType, ModuleType] = {}
 
@@ -54,11 +50,13 @@ def isolate_module(mod: ModuleType) -> ModuleType:
             setattr(new_mod, name, value)
     return ISOLATED_MODULES[mod]
 
+
 os = isolate_module(os)
 
 
 class SysModuleSaver:
     """Saves the contents of sys.modules, and removes new modules later."""
+
     def __init__(self) -> None:
         self.old_modules = set(sys.modules)
 
@@ -111,9 +109,9 @@ def nice_pair(pair: TArc) -> str:
     """
     start, end = pair
     if start == end:
-        return "%d" % start
+        return f"{start}"
     else:
-        return "%d-%d" % (start, end)
+        return f"{start}-{end}"
 
 
 def bool_or_none(b: Any) -> bool | None:
@@ -158,37 +156,39 @@ def ensure_dir_for_file(path: str) -> None:
 
 class Hasher:
     """Hashes Python data for fingerprinting."""
+
     def __init__(self) -> None:
         self.hash = hashlib.new("sha3_256", usedforsecurity=False)
 
     def update(self, v: Any) -> None:
         """Add `v` to the hash, recursively if needed."""
         self.hash.update(str(type(v)).encode("utf-8"))
-        if isinstance(v, str):
-            self.hash.update(v.encode("utf-8"))
-        elif isinstance(v, bytes):
-            self.hash.update(v)
-        elif v is None:
-            pass
-        elif isinstance(v, (int, float)):
-            self.hash.update(str(v).encode("utf-8"))
-        elif isinstance(v, (tuple, list)):
-            for e in v:
-                self.update(e)
-        elif isinstance(v, dict):
-            keys = v.keys()
-            for k in sorted(keys):
-                self.update(k)
-                self.update(v[k])
-        else:
-            for k in dir(v):
-                if k.startswith("__"):
-                    continue
-                a = getattr(v, k)
-                if inspect.isroutine(a):
-                    continue
-                self.update(k)
-                self.update(a)
+        match v:
+            case None:
+                pass
+            case str():
+                self.hash.update(v.encode("utf-8"))
+            case bytes():
+                self.hash.update(v)
+            case int() | float():
+                self.hash.update(str(v).encode("utf-8"))
+            case tuple() | list():
+                for e in v:
+                    self.update(e)
+            case dict():
+                keys = v.keys()
+                for k in sorted(keys):
+                    self.update(k)
+                    self.update(v[k])
+            case _:
+                for k in dir(v):
+                    if k.startswith("__"):
+                        continue
+                    a = getattr(v, k)
+                    if inspect.isroutine(a):
+                        continue
+                    self.update(k)
+                    self.update(a)
         self.hash.update(b".")
 
     def hexdigest(self) -> str:
@@ -218,6 +218,7 @@ class DefaultValue:
     and Sphinx output.
 
     """
+
     def __init__(self, display_as: str) -> None:
         self.display_as = display_as
 
@@ -244,13 +245,13 @@ def substitute_variables(text: str, variables: Mapping[str, str]) -> str:
     dollar_pattern = r"""(?x)   # Use extended regex syntax
         \$                      # A dollar sign,
         (?:                     # then
-            (?P<dollar>\$) |        # a dollar sign, or
-            (?P<word1>\w+) |        # a plain word, or
-            {                       # a {-wrapped
-                (?P<word2>\w+)          # word,
-                (?:
-                    (?P<strict>\?) |        # with a strict marker
-                    -(?P<defval>[^}]*)      # or a default value
+            (?P<dollar> \$ ) |      # a dollar sign, or
+            (?P<word1> \w+ ) |      # a plain word, or
+            \{                      # a {-wrapped
+                (?P<word2> \w+ )        # word,
+                (?:                         # either
+                    (?P<strict> \? ) |      # with a strict marker
+                    -(?P<defval> [^}]* )    # or a default value
                 )?                      # maybe.
             }
         )
@@ -261,7 +262,7 @@ def substitute_variables(text: str, variables: Mapping[str, str]) -> str:
     def dollar_replace(match: re.Match[str]) -> str:
         """Called for each $replacement."""
         # Only one of the dollar_groups will have matched, just get its text.
-        word = next(g for g in match.group(*dollar_groups) if g)    # pragma: always breaks
+        word = next(g for g in match.group(*dollar_groups) if g)  # pragma: always breaks
         if word == "$":
             return "$"
         elif word in variables:
@@ -277,8 +278,7 @@ def substitute_variables(text: str, variables: Mapping[str, str]) -> str:
 
 
 def format_local_datetime(dt: datetime.datetime) -> str:
-    """Return a string with local timezone representing the date.
-    """
+    """Return a string with local timezone representing the date."""
     return dt.astimezone().strftime("%Y-%m-%d %H:%M %z")
 
 
@@ -311,6 +311,7 @@ def _human_key(s: str) -> tuple[list[str | int], str]:
     The original string is appended as a last value to ensure the
     key is unique enough so that "x1y" and "x001y" can be distinguished.
     """
+
     def tryint(s: str) -> str | int:
         """If `s` is a number, return an int, else `s` unchanged."""
         try:
@@ -320,6 +321,7 @@ def _human_key(s: str) -> tuple[list[str | int], str]:
 
     return ([tryint(c) for c in re.split(r"(\d+)", s)], s)
 
+
 def human_sorted(strings: Iterable[str]) -> list[str]:
     """Sort the given iterable of strings the way that humans expect.
 
@@ -330,8 +332,10 @@ def human_sorted(strings: Iterable[str]) -> list[str]:
     """
     return sorted(strings, key=_human_key)
 
+
 SortableItem = TypeVar("SortableItem", bound=Sequence[Any])
 
+
 def human_sorted_items(
     items: Iterable[SortableItem],
     reverse: bool = False,

coverage/multiproc.py

@@ -11,7 +11,6 @@ import os
 import os.path
 import sys
 import traceback
-
 from typing import Any
 
 from coverage.debug import DebugControl
@@ -22,16 +21,18 @@ PATCHED_MARKER = "_coverage$patched"
 
 
 OriginalProcess = multiprocessing.process.BaseProcess
-original_bootstrap = OriginalProcess._bootstrap     # type: ignore[attr-defined]
+original_bootstrap = OriginalProcess._bootstrap  # type: ignore[attr-defined]
+
 
-class ProcessWithCoverage(OriginalProcess):         # pylint: disable=abstract-method
+class ProcessWithCoverage(OriginalProcess):  # pylint: disable=abstract-method
     """A replacement for multiprocess.Process that starts coverage."""
 
-    def _bootstrap(self, *args, **kwargs):          # type: ignore[no-untyped-def]
+    def _bootstrap(self, *args, **kwargs):  # type: ignore[no-untyped-def]
         """Wrapper around _bootstrap to start coverage."""
         debug: DebugControl | None = None
         try:
-            from coverage import Coverage       # avoid circular import
+            from coverage import Coverage  # avoid circular import
+
             cov = Coverage(data_suffix=True, auto_data=True)
             cov._warn_preimported_source = False
             cov.start()
@@ -61,8 +62,10 @@ class ProcessWithCoverage(OriginalProcess):         # pylint: disable=abstract-m
             if debug:
                 debug.write("Saved multiprocessing data")
 
+
 class Stowaway:
     """An object to pickle, so when it is unpickled, it can apply the monkey-patch."""
+
     def __init__(self, rcfile: str) -> None:
         self.rcfile = rcfile
 
@@ -86,7 +89,7 @@ def patch_multiprocessing(rcfile: str) -> None:
     if hasattr(multiprocessing, PATCHED_MARKER):
         return
 
-    OriginalProcess._bootstrap = ProcessWithCoverage._bootstrap     # type: ignore[attr-defined]
+    OriginalProcess._bootstrap = ProcessWithCoverage._bootstrap  # type: ignore[attr-defined]
 
     # Set the value in ProcessWithCoverage that will be pickled into the child
     # process.
@@ -94,16 +97,18 @@ def patch_multiprocessing(rcfile: str) -> None:
 
     # When spawning processes rather than forking them, we have no state in the
     # new process.  We sneak in there with a Stowaway: we stuff one of our own
-    # objects into the data that gets pickled and sent to the sub-process. When
+    # objects into the data that gets pickled and sent to the subprocess. When
     # the Stowaway is unpickled, its __setstate__ method is called, which
     # re-applies the monkey-patch.
     # Windows only spawns, so this is needed to keep Windows working.
     try:
         from multiprocessing import spawn
+
         original_get_preparation_data = spawn.get_preparation_data
     except (ImportError, AttributeError):
         pass
     else:
+
         def get_preparation_data_with_stowaway(name: str) -> dict[str, Any]:
             """Get the original preparation data, and also insert our stowaway."""
             d = original_get_preparation_data(name)

coverage/numbits.py

@@ -18,9 +18,8 @@ from __future__ import annotations
 
 import json
 import sqlite3
-
-from itertools import zip_longest
 from collections.abc import Iterable
+from itertools import zip_longest
 
 
 def nums_to_numbits(nums: Iterable[int]) -> bytes:
@@ -39,7 +38,7 @@ def nums_to_numbits(nums: Iterable[int]) -> bytes:
         return b""
     b = bytearray(nbytes)
     for num in nums:
-        b[num//8] |= 1 << num % 8
+        b[num // 8] |= 1 << num % 8
     return bytes(b)
 
 
@@ -59,7 +58,7 @@ def numbits_to_nums(numbits: bytes) -> list[int]:
     nums = []
     for byte_i, byte in enumerate(numbits):
         for bit_i in range(8):
-            if (byte & (1 << bit_i)):
+            if byte & (1 << bit_i):
                 nums.append(byte_i * 8 + bit_i)
     return nums