coverage 7.6.10__cp312-cp312-musllinux_1_2_aarch64.whl → 7.12.0__cp312-cp312-musllinux_1_2_aarch64.whl

coverage/results.py

@@ -1,5 +1,5 @@
 # Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
-# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+# For details: https://github.com/coveragepy/coveragepy/blob/main/NOTICE.txt
 
 """Results of coverage measurement."""
 
@@ -7,8 +7,7 @@ from __future__ import annotations
 
 import collections
 import dataclasses
-
-from collections.abc import Container, Iterable
+from collections.abc import Iterable
 from typing import TYPE_CHECKING
 
 from coverage.exceptions import ConfigError
@@ -42,9 +41,7 @@ def analysis_from_file_reporter(
         for fromno, tono in arc_possibilities_set:
             dests[fromno].add(tono)
         single_dests = {
-            fromno: list(tonos)[0]
-            for fromno, tonos in dests.items()
-            if len(tonos) == 1
+            fromno: list(tonos)[0] for fromno, tonos in dests.items() if len(tonos) == 1
         }
         new_arcs = set()
         for fromno, tono in arcs:
@@ -100,8 +97,8 @@ class Analysis:
         if self.has_arcs:
             n_branches = self._total_branches()
             mba = self.missing_branch_arcs()
-            n_partial_branches = sum(len(v) for k,v in mba.items() if k not in self.missing)
-            n_missing_branches = sum(len(v) for k,v in mba.items())
+            n_partial_branches = sum(len(v) for k, v in mba.items() if k not in self.missing)
+            n_missing_branches = sum(len(v) for k, v in mba.items())
         else:
             n_branches = n_partial_branches = n_missing_branches = 0
 
@@ -116,50 +113,6 @@ class Analysis:
             n_missing_branches=n_missing_branches,
         )
 
-    def narrow(self, lines: Container[TLineNo]) -> Analysis:
-        """Create a narrowed Analysis.
-
-        The current analysis is copied to make a new one that only considers
-        the lines in `lines`.
-        """
-
-        statements = {lno for lno in self.statements if lno in lines}
-        excluded = {lno for lno in self.excluded if lno in lines}
-        executed = {lno for lno in self.executed if lno in lines}
-
-        if self.has_arcs:
-            arc_possibilities_set = {
-                (a, b) for a, b in self.arc_possibilities_set
-                if a in lines or b in lines
-            }
-            arcs_executed_set = {
-                (a, b) for a, b in self.arcs_executed_set
-                if a in lines or b in lines
-            }
-            exit_counts = {
-                lno: num for lno, num in self.exit_counts.items()
-                if lno in lines
-            }
-            no_branch = {lno for lno in self.no_branch if lno in lines}
-        else:
-            arc_possibilities_set = set()
-            arcs_executed_set = set()
-            exit_counts = {}
-            no_branch = set()
-
-        return Analysis(
-            precision=self.precision,
-            filename=self.filename,
-            has_arcs=self.has_arcs,
-            statements=statements,
-            excluded=excluded,
-            executed=executed,
-            arc_possibilities_set=arc_possibilities_set,
-            arcs_executed_set=arcs_executed_set,
-            exit_counts=exit_counts,
-            no_branch=no_branch,
-        )
-
     def missing_formatted(self, branches: bool = False) -> str:
         """The missing line numbers, formatted nicely.
 
@@ -178,16 +131,17 @@ class Analysis:
     def arcs_missing(self) -> list[TArc]:
         """Returns a sorted list of the un-executed arcs in the code."""
         missing = (
-            p for p in self.arc_possibilities
-                if p not in self.arcs_executed_set
-                    and p[0] not in self.no_branch
-                    and p[1] not in self.excluded
+            p
+            for p in self.arc_possibilities
+            if p not in self.arcs_executed_set
+            and p[0] not in self.no_branch
+            and p[1] not in self.excluded
         )
         return sorted(missing)
 
     def _branch_lines(self) -> list[TLineNo]:
         """Returns a list of line numbers that have more than one exit."""
-        return [l1 for l1,count in self.exit_counts.items() if count > 1]
+        return [l1 for l1, count in self.exit_counts.items() if count > 1]
 
     def _total_branches(self) -> int:
         """How many total branches are there?"""
@@ -231,6 +185,7 @@ class Analysis:
 
         Returns a dict mapping line numbers to a tuple:
         (total_exits, taken_exits).
+
         """
 
         missing_arcs = self.missing_branch_arcs()
@@ -242,6 +197,104 @@ class Analysis:
         return stats
 
 
+TRegionLines = frozenset[TLineNo]
+
+
+class AnalysisNarrower:
+    """
+    For reducing an `Analysis` to a subset of its lines.
+
+    Originally this was a simpler method on Analysis, but that led to quadratic
+    behavior.  This class does the bulk of the work up-front to provide the
+    same results in linear time.
+
+    Create an AnalysisNarrower from an Analysis, bulk-add region lines to it
+    with `add_regions`, then individually request new narrowed Analysis objects
+    for each region with `narrow`.  Doing most of the work in limited calls to
+    `add_regions` lets us avoid poor performance.
+    """
+
+    # In this class, regions are represented by a frozenset of their lines.
+
+    def __init__(self, analysis: Analysis) -> None:
+        self.analysis = analysis
+        self.region2arc_possibilities: dict[TRegionLines, set[TArc]] = collections.defaultdict(set)
+        self.region2arc_executed: dict[TRegionLines, set[TArc]] = collections.defaultdict(set)
+        self.region2exit_counts: dict[TRegionLines, dict[TLineNo, int]] = collections.defaultdict(
+            dict
+        )
+
+    def add_regions(self, liness: Iterable[set[TLineNo]]) -> None:
+        """
+        Pre-process a number of sets of line numbers.  Later calls to `narrow`
+        with one of these sets will provide a narrowed Analysis.
+        """
+        if self.analysis.has_arcs:
+            line2region: dict[TLineNo, TRegionLines] = {}
+
+            for lines in liness:
+                fzlines = frozenset(lines)
+                for line in lines:
+                    line2region[line] = fzlines
+
+            def collect_arcs(
+                arc_set: set[TArc],
+                region2arcs: dict[TRegionLines, set[TArc]],
+            ) -> None:
+                for a, b in arc_set:
+                    if r := line2region.get(a):
+                        region2arcs[r].add((a, b))
+                    if r := line2region.get(b):
+                        region2arcs[r].add((a, b))
+
+            collect_arcs(self.analysis.arc_possibilities_set, self.region2arc_possibilities)
+            collect_arcs(self.analysis.arcs_executed_set, self.region2arc_executed)
+
+            for lno, num in self.analysis.exit_counts.items():
+                if r := line2region.get(lno):
+                    self.region2exit_counts[r][lno] = num
+
+    def narrow(self, lines: set[TLineNo]) -> Analysis:
+        """Create a narrowed Analysis.
+
+        The current analysis is copied to make a new one that only considers
+        the lines in `lines`.
+        """
+
+        # Technically, the set intersections in this method are still O(N**2)
+        # since this method is called N times, but they're very fast and moving
+        # them to `add_regions` won't avoid the quadratic time.
+
+        statements = self.analysis.statements & lines
+        excluded = self.analysis.excluded & lines
+        executed = self.analysis.executed & lines
+
+        if self.analysis.has_arcs:
+            fzlines = frozenset(lines)
+            arc_possibilities_set = self.region2arc_possibilities[fzlines]
+            arcs_executed_set = self.region2arc_executed[fzlines]
+            exit_counts = self.region2exit_counts[fzlines]
+            no_branch = self.analysis.no_branch & lines
+        else:
+            arc_possibilities_set = set()
+            arcs_executed_set = set()
+            exit_counts = {}
+            no_branch = set()
+
+        return Analysis(
+            precision=self.analysis.precision,
+            filename=self.analysis.filename,
+            has_arcs=self.analysis.has_arcs,
+            statements=statements,
+            excluded=excluded,
+            executed=executed,
+            arc_possibilities_set=arc_possibilities_set,
+            arcs_executed_set=arcs_executed_set,
+            exit_counts=exit_counts,
+            no_branch=no_branch,
+        )
+
+
 @dataclasses.dataclass
 class Numbers:
     """The numerical results of measuring coverage.
@@ -270,15 +323,36 @@ class Numbers:
         """Returns the number of executed branches."""
         return self.n_branches - self.n_missing_branches
 
+    @property
+    def ratio_statements(self) -> tuple[int, int]:
+        """Return numerator/denominator for statement coverage."""
+        return self.n_executed, self.n_statements
+
+    @property
+    def ratio_branches(self) -> tuple[int, int]:
+        """Return numerator/denominator for branch coverage."""
+        return self.n_executed_branches, self.n_branches
+
+    def _percent(self, numerator: int, denominator: int) -> float:
+        """Helper for pc_* properties."""
+        if denominator > 0:
+            return (100.0 * numerator) / denominator
+        return 100.0
+
     @property
     def pc_covered(self) -> float:
         """Returns a single percentage value for coverage."""
-        if self.n_statements > 0:
-            numerator, denominator = self.ratio_covered
-            pc_cov = (100.0 * numerator) / denominator
-        else:
-            pc_cov = 100.0
-        return pc_cov
+        return self._percent(*self.ratio_covered)
+
+    @property
+    def pc_statements(self) -> float:
+        """Returns the percentage covered for statements."""
+        return self._percent(*self.ratio_statements)
+
+    @property
+    def pc_branches(self) -> float:
+        """Returns the percentage covered for branches."""
+        return self._percent(*self.ratio_branches)
 
     @property
     def pc_covered_str(self) -> str:
@@ -291,6 +365,16 @@ class Numbers:
         """
         return display_covered(self.pc_covered, self.precision)
 
+    @property
+    def pc_statements_str(self) -> str:
+        """Returns the statement percent covered without a percent sign."""
+        return display_covered(self.pc_statements, self.precision)
+
+    @property
+    def pc_branches_str(self) -> str:
+        """Returns the branch percent covered without a percent sign."""
+        return display_covered(self.pc_branches, self.precision)
+
     @property
     def ratio_covered(self) -> tuple[int, int]:
         """Return a numerator and denominator for the coverage ratio."""
@@ -312,7 +396,7 @@ class Numbers:
 
     def __radd__(self, other: int) -> Numbers:
         # Implementing 0+Numbers allows us to sum() a list of Numbers.
-        assert other == 0   # we only ever call it this way.
+        assert other == 0  # we only ever call it this way.
         return self
 
 
@@ -324,14 +408,14 @@ def display_covered(pc: float, precision: int) -> str:
     result in either "0" or "100".
 
     """
-    near0 = 1.0 / 10 ** precision
+    near0 = 1.0 / 10**precision
     if 0 < pc < near0:
         pc = near0
     elif (100.0 - near0) < pc < 100:
         pc = 100.0 - near0
     else:
         pc = round(pc, precision)
-    return "%.*f" % (precision, pc)
+    return f"{pc:.{precision}f}"
 
 
 def _line_ranges(
@@ -343,7 +427,7 @@ def _line_ranges(
     lines = sorted(lines)
 
     pairs = []
-    start = None
+    start: TLineNo | None = None
     lidx = 0
     for stmt in statements:
         if lidx >= len(lines):
@@ -389,7 +473,7 @@ def format_lines(
         for line, exits in line_exits:
             for ex in sorted(exits):
                 if line not in lines and ex not in lines:
-                    dest = (ex if ex > 0 else "exit")
+                    dest = ex if ex > 0 else "exit"
                     line_items.append((line, f"{line}->{dest}"))
 
     ret = ", ".join(t[-1] for t in sorted(line_items))