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

coverage/results.py

@@ -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
@@ -34,16 +33,15 @@ def analysis_from_file_reporter(
 
     if has_arcs:
         arc_possibilities_set = file_reporter.arcs()
-        arcs = data.arcs(filename) or []
+        arcs: Iterable[TArc] = data.arcs(filename) or []
+        arcs = file_reporter.translate_arcs(arcs)
 
         # Reduce the set of arcs to the ones that could be branches.
         dests = collections.defaultdict(set)
         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:
@@ -99,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
 
@@ -115,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.
 
@@ -177,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
-                    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?"""
@@ -202,8 +157,7 @@ class Analysis:
         branch_lines = set(self._branch_lines())
         mba = collections.defaultdict(list)
         for l1, l2 in missing:
-            if l1 == l2:
-                continue
+            assert l1 != l2, f"In {self.filename}, didn't expect {l1} == {l2}"
             if l1 in branch_lines:
                 mba[l1].append(l2)
         return mba
@@ -219,8 +173,7 @@ class Analysis:
         branch_lines = set(self._branch_lines())
         eba = collections.defaultdict(list)
         for l1, l2 in self.arcs_executed:
-            if l1 == l2:
-                continue
+            assert l1 != l2, f"Oops: Didn't think this could happen: {l1 = }, {l2 = }"
             if (l1, l2) not in self.arc_possibilities_set:
                 continue
             if l1 in branch_lines:
@@ -232,6 +185,7 @@ class Analysis:
 
         Returns a dict mapping line numbers to a tuple:
         (total_exits, taken_exits).
+
         """
 
         missing_arcs = self.missing_branch_arcs()
@@ -243,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.
@@ -313,7 +365,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
 
 
@@ -325,14 +377,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(
@@ -344,7 +396,7 @@ def _line_ranges(
     lines = sorted(lines)
 
     pairs = []
-    start = None
+    start: TLineNo | None = None
     lidx = 0
     for stmt in statements:
         if lidx >= len(lines):
@@ -390,7 +442,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))