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

coverage/pytracer.py

@@ -10,7 +10,6 @@ import dis
 import itertools
 import sys
 import threading
-
 from types import FrameType, ModuleType
 from typing import Any, Callable, cast
 
@@ -19,15 +18,23 @@ from coverage.types import (
     TArc,
     TFileDisposition,
     TLineNo,
+    Tracer,
     TShouldStartContextFn,
     TShouldTraceFn,
     TTraceData,
     TTraceFileData,
     TTraceFn,
     TWarnFn,
-    Tracer,
 )
 
+# I don't understand why, but if we use `cast(set[TLineNo], ...)` inside
+# the _trace() function, we get some strange behavior on PyPy 3.10.
+# Assigning these names here and using them below fixes the problem.
+# See https://github.com/nedbat/coveragepy/issues/1902
+set_TLineNo = set[TLineNo]
+set_TArc = set[TArc]
+
+
 # We need the YIELD_VALUE opcode below, in a comparison-friendly form.
 # PYVERSIONS: RESUME is new in Python3.11
 RESUME = dis.opmap.get("RESUME")
@@ -44,6 +51,7 @@ else:
 
 THIS_FILE = __file__.rstrip("co")
 
+
 class PyTracer(Tracer):
     """Python implementation of the raw data tracer."""
 
@@ -117,19 +125,20 @@ class PyTracer(Tracer):
 
     def log(self, marker: str, *args: Any) -> None:
         """For hard-core logging of what this tracer is doing."""
-        with open("/tmp/debug_trace.txt", "a") as f:
+        with open("/tmp/debug_trace.txt", "a", encoding="utf-8") as f:
             f.write(f"{marker} {self.id}[{len(self.data_stack)}]")
-            if 0:   # if you want thread ids..
-                f.write(".{:x}.{:x}".format(                    # type: ignore[unreachable]
-                    self.thread.ident,
-                    self.threading.current_thread().ident,
-                ))
+            if 0:  # if you want thread ids..
+                f.write(  # type: ignore[unreachable]
+                    ".{:x}.{:x}".format(
+                        self.thread.ident,
+                        self.threading.current_thread().ident,
+                    )
+                )
             f.write(" {}".format(" ".join(map(str, args))))
-            if 0:   # if you want callers..
-                f.write(" | ")                                  # type: ignore[unreachable]
+            if 0:  # if you want callers..
+                f.write(" | ")  # type: ignore[unreachable]
                 stack = " / ".join(
-                    (fname or "???").rpartition("/")[-1]
-                    for _, fname, _, _ in self.data_stack
+                    (fname or "???").rpartition("/")[-1] for _, fname, _, _ in self.data_stack
                 )
                 f.write(stack)
             f.write("\n")
@@ -138,8 +147,8 @@ class PyTracer(Tracer):
         self,
         frame: FrameType,
         event: str,
-        arg: Any,                               # pylint: disable=unused-argument
-        lineno: TLineNo | None = None,       # pylint: disable=unused-argument
+        arg: Any,  # pylint: disable=unused-argument
+        lineno: TLineNo | None = None,  # pylint: disable=unused-argument
     ) -> TTraceFn | None:
         """The trace function passed to sys.settrace."""
 
@@ -149,11 +158,11 @@ class PyTracer(Tracer):
         # f = frame; code = f.f_code
         # self.log(":", f"{code.co_filename} {f.f_lineno} {code.co_name}()", event)
 
-        if (self.stopped and sys.gettrace() == self._cached_bound_method_trace):    # pylint: disable=comparison-with-callable
+        if self.stopped and sys.gettrace() == self._cached_bound_method_trace:  # pylint: disable=comparison-with-callable
             # The PyTrace.stop() method has been called, possibly by another
             # thread, let's deactivate ourselves now.
             if 0:
-                f = frame                           # type: ignore[unreachable]
+                f = frame  # type: ignore[unreachable]
                 self.log("---\nX", f.f_code.co_filename, f.f_lineno)
                 while f:
                     self.log(">", f.f_code.co_filename, f.f_lineno, f.f_code.co_name, f.f_trace)
@@ -178,12 +187,12 @@ class PyTracer(Tracer):
         if event == "call":
             # Should we start a new context?
             if self.should_start_context and self.context is None:
-                context_maybe = self.should_start_context(frame)    # pylint: disable=not-callable
+                context_maybe = self.should_start_context(frame)  # pylint: disable=not-callable
                 if context_maybe is not None:
                     self.context = context_maybe
                     started_context = True
                     assert self.switch_context is not None
-                    self.switch_context(self.context)   # pylint: disable=not-callable
+                    self.switch_context(self.context)  # pylint: disable=not-callable
                 else:
                     started_context = False
             else:
@@ -239,9 +248,9 @@ class PyTracer(Tracer):
                 # The current opcode is guaranteed to be RESUME. The argument
                 # determines what kind of resume it is.
                 oparg = frame.f_code.co_code[frame.f_lasti + 1]
-                real_call = (oparg == 0)
+                real_call = (oparg == 0)  # fmt: skip
             else:
-                real_call = (getattr(frame, "f_lasti", -1) < 0)
+                real_call = (getattr(frame, "f_lasti", -1) < 0)  # fmt: skip
             if real_call:
                 self.last_line = -frame.f_code.co_firstlineno
             else:
@@ -253,9 +262,9 @@ class PyTracer(Tracer):
                 flineno: TLineNo = frame.f_lineno
 
                 if self.trace_arcs:
-                    cast(set[TArc], self.cur_file_data).add((self.last_line, flineno))
+                    cast(set_TArc, self.cur_file_data).add((self.last_line, flineno))
                 else:
-                    cast(set[TLineNo], self.cur_file_data).add(flineno)
+                    cast(set_TLineNo, self.cur_file_data).add(flineno)
                 self.last_line = flineno
 
         elif event == "return":
@@ -272,7 +281,7 @@ class PyTracer(Tracer):
                         # It is a real return if we aren't going to resume next.
                         if env.PYBEHAVIOR.lasti_is_yield:
                             lasti += 2
-                        real_return = (code[lasti] != RESUME)
+                        real_return = code[lasti] != RESUME
                 else:
                     if code[lasti] == RETURN_VALUE:
                         real_return = True
@@ -286,7 +295,7 @@ class PyTracer(Tracer):
                         real_return = True
                 if real_return:
                     first = frame.f_code.co_firstlineno
-                    cast(set[TArc], self.cur_file_data).add((self.last_line, -first))
+                    cast(set_TArc, self.cur_file_data).add((self.last_line, -first))
 
             # Leaving this function, pop the filename stack.
             self.cur_file_data, self.cur_file_name, self.last_line, self.started_context = (
@@ -296,7 +305,8 @@ class PyTracer(Tracer):
             if self.started_context:
                 assert self.switch_context is not None
                 self.context = None
-                self.switch_context(None)   # pylint: disable=not-callable
+                self.switch_context(None)  # pylint: disable=not-callable
+
         return self._cached_bound_method_trace
 
     def start(self) -> TTraceFn:
@@ -330,22 +340,19 @@ class PyTracer(Tracer):
                 # Called on a different thread than started us: we can't unhook
                 # ourselves, but we've set the flag that we should stop, so we
                 # won't do any more tracing.
-                #self.log("~", "stopping on different threads")
+                # self.log("~", "stopping on different threads")
                 return
 
         # PyPy clears the trace function before running atexit functions,
         # so don't warn if we are in atexit on PyPy and the trace function
         # has changed to None.  Metacoverage also messes this up, so don't
         # warn if we are measuring ourselves.
-        suppress_warning = (
-            (env.PYPY and self.in_atexit and tf is None)
-            or env.METACOV
-        )
+        suppress_warning = (env.PYPY and self.in_atexit and tf is None) or env.METACOV
         if self.warn and not suppress_warning:
-            if tf != self._cached_bound_method_trace:   # pylint: disable=comparison-with-callable
+            if tf != self._cached_bound_method_trace:  # pylint: disable=comparison-with-callable
                 self.warn(
-                    "Trace function changed, data is likely wrong: " +
-                    f"{tf!r} != {self._cached_bound_method_trace!r}",
+                    "Trace function changed, data is likely wrong: "
+                    + f"{tf!r} != {self._cached_bound_method_trace!r}",
                     slug="trace-changed",
                 )
 

coverage/regions.py

@@ -7,7 +7,6 @@ from __future__ import annotations
 
 import ast
 import dataclasses
-
 from typing import cast
 
 from coverage.plugin import CodeRegion
@@ -16,6 +15,7 @@ from coverage.plugin import CodeRegion
 @dataclasses.dataclass
 class Context:
     """The nested named context of a function or class."""
+
     name: str
     kind: str
     lines: set[int]
@@ -28,6 +28,7 @@ class RegionFinder:
     attribute.
 
     """
+
     def __init__(self) -> None:
         self.regions: list[CodeRegion] = []
         self.context: list[Context] = []

coverage/report.py

@@ -6,12 +6,11 @@
 from __future__ import annotations
 
 import sys
-
-from typing import Any, IO, TYPE_CHECKING
 from collections.abc import Iterable
+from typing import IO, TYPE_CHECKING, Any
 
 from coverage.exceptions import ConfigError, NoDataError
-from coverage.misc import human_sorted_items
+from coverage.misc import human_sorted_items, plural
 from coverage.plugin import FileReporter
 from coverage.report_core import get_analysis_to_report
 from coverage.results import Analysis, Numbers
@@ -32,7 +31,7 @@ class SummaryReporter:
         self.output_format = self.config.format or "text"
         if self.output_format not in {"text", "markdown", "total"}:
             raise ConfigError(f"Unknown report format choice: {self.output_format!r}")
-        self.fr_analysis: list[tuple[FileReporter, Analysis]] = []
+        self.fr_analyses: list[tuple[FileReporter, Analysis]] = []
         self.skipped_count = 0
         self.empty_count = 0
         self.total = Numbers(precision=self.config.precision)
@@ -47,7 +46,7 @@ class SummaryReporter:
         """Write a list of strings, joined together."""
         self.write("".join(items))
 
-    def _report_text(
+    def report_text(
         self,
         header: list[str],
         lines_values: list[list[Any]],
@@ -75,10 +74,7 @@ class SummaryReporter:
             Cover="{:>{n}}",
             Missing="{:>10}",
         )
-        header_items = [
-            formats[item].format(item, name_len=max_name, n=max_n)
-            for item in header
-        ]
+        header_items = [formats[item].format(item, name_len=max_name, n=max_n) for item in header]
         header_str = "".join(header_items)
         rule = "-" * len(header_str)
 
@@ -86,29 +82,36 @@ class SummaryReporter:
         self.write(header_str)
         self.write(rule)
 
-        formats.update(dict(Cover="{:>{n}}%"), Missing="   {:9}")
+        # Write the data lines
+        formats.update(
+            dict(
+                Cover="{:>{n}}%",
+                Missing="   {:9}",
+            )
+        )
         for values in lines_values:
-            # build string with line values
-            line_items = [
-                formats[item].format(str(value),
-                name_len=max_name, n=max_n-1) for item, value in zip(header, values)
-            ]
-            self.write_items(line_items)
+            self.write_items(
+                (
+                    formats[item].format(str(value), name_len=max_name, n=max_n - 1)
+                    for item, value in zip(header, values)
+                )
+            )
 
         # Write a TOTAL line
         if lines_values:
             self.write(rule)
 
-        line_items = [
-            formats[item].format(str(value),
-            name_len=max_name, n=max_n-1) for item, value in zip(header, total_line)
-        ]
-        self.write_items(line_items)
+        self.write_items(
+            (
+                formats[item].format(str(value), name_len=max_name, n=max_n - 1)
+                for item, value in zip(header, total_line)
+            )
+        )
 
         for end_line in end_lines:
             self.write(end_line)
 
-    def _report_markdown(
+    def report_markdown(
         self,
         header: list[str],
         lines_values: list[list[Any]],
@@ -138,25 +141,38 @@ class SummaryReporter:
         max_n = max(len(total_line[header.index("Cover")]) + 6, len(" Cover "))
         header_items = [formats[item].format(item, name_len=max_name, n=max_n) for item in header]
         header_str = "".join(header_items)
-        rule_str = "|" + " ".join(["- |".rjust(len(header_items[0])-1, "-")] +
-            ["-: |".rjust(len(item)-1, "-") for item in header_items[1:]],
+        rule_str = "|" + " ".join(
+            ["- |".rjust(len(header_items[0]) - 1, "-")]
+            + ["-: |".rjust(len(item) - 1, "-") for item in header_items[1:]],
         )
 
         # Write the header
         self.write(header_str)
         self.write(rule_str)
 
+        # Write the data lines
         for values in lines_values:
-            # build string with line values
-            formats.update(dict(Cover="{:>{n}}% |"))
-            line_items = [
-                formats[item].format(str(value).replace("_", "\\_"), name_len=max_name, n=max_n-1)
-                for item, value in zip(header, values)
-            ]
-            self.write_items(line_items)
+            formats.update(
+                dict(
+                    Cover="{:>{n}}% |",
+                )
+            )
+            self.write_items(
+                (
+                    formats[item].format(
+                        str(value).replace("_", "\\_"), name_len=max_name, n=max_n - 1
+                    )
+                    for item, value in zip(header, values)
+                )
+            )
 
         # Write the TOTAL line
-        formats.update(dict(Name="|{:>{name_len}} |", Cover="{:>{n}} |"))
+        formats.update(
+            dict(
+                Name="|{:>{name_len}} |",
+                Cover="{:>{n}} |",
+            ),
+        )
         total_line_items: list[str] = []
         for item, value in zip(header, total_line):
             if value == "":
@@ -167,6 +183,7 @@ class SummaryReporter:
                 insert = f" **{value}**"
             total_line_items += formats[item].format(insert, name_len=max_name, n=max_n)
         self.write_items(total_line_items)
+
         for end_line in end_lines:
             self.write(end_line)
 
@@ -209,9 +226,8 @@ class SummaryReporter:
         # `lines_values` is list of lists of sortable values.
         lines_values = []
 
-        for (fr, analysis) in self.fr_analysis:
+        for fr, analysis in self.fr_analyses:
             nums = analysis.numbers
-
             args = [fr.relative_filename(), nums.n_statements, nums.n_missing]
             if self.branches:
                 args += [nums.n_branches, nums.n_partial_branches]
@@ -251,18 +267,18 @@ class SummaryReporter:
         # Create other final lines.
         end_lines = []
         if self.config.skip_covered and self.skipped_count:
-            file_suffix = "s" if self.skipped_count>1 else ""
+            files = plural(self.skipped_count, "file")
             end_lines.append(
-                f"\n{self.skipped_count} file{file_suffix} skipped due to complete coverage.",
+                f"\n{self.skipped_count} {files} skipped due to complete coverage.",
             )
         if self.config.skip_empty and self.empty_count:
-            file_suffix = "s" if self.empty_count > 1 else ""
-            end_lines.append(f"\n{self.empty_count} empty file{file_suffix} skipped.")
+            files = plural(self.empty_count, "file")
+            end_lines.append(f"\n{self.empty_count} empty {files} skipped.")
 
         if self.output_format == "markdown":
-            formatter = self._report_markdown
+            formatter = self.report_markdown
         else:
-            formatter = self._report_text
+            formatter = self.report_text
         formatter(header, lines_values, total_line, end_lines)
 
     def report_one_file(self, fr: FileReporter, analysis: Analysis) -> None:
@@ -270,8 +286,8 @@ class SummaryReporter:
         nums = analysis.numbers
         self.total += nums
 
-        no_missing_lines = (nums.n_missing == 0)
-        no_missing_branches = (nums.n_partial_branches == 0)
+        no_missing_lines = (nums.n_missing == 0)  # fmt: skip
+        no_missing_branches = (nums.n_partial_branches == 0)  # fmt: skip
         if self.config.skip_covered and no_missing_lines and no_missing_branches:
             # Don't report on 100% files.
             self.skipped_count += 1
@@ -279,4 +295,4 @@ class SummaryReporter:
             # Don't report on empty files.
             self.empty_count += 1
         else:
-            self.fr_analysis.append((fr, analysis))
+            self.fr_analyses.append((fr, analysis))

coverage/report_core.py

@@ -6,14 +6,11 @@
 from __future__ import annotations
 
 import sys
-
-from typing import (
-    Callable, IO, Protocol, TYPE_CHECKING,
-)
-from collections.abc import Iterable, Iterator
+from collections.abc import Iterable
+from typing import IO, TYPE_CHECKING, Callable, Protocol
 
 from coverage.exceptions import NoDataError, NotPython
-from coverage.files import prep_patterns, GlobMatcher
+from coverage.files import GlobMatcher, prep_patterns
 from coverage.misc import ensure_dir_for_file, file_be_gone
 from coverage.plugin import FileReporter
 from coverage.results import Analysis
@@ -68,13 +65,13 @@ def render_report(
         if file_to_close is not None:
             file_to_close.close()
             if delete_file:
-                file_be_gone(output_path)           # pragma: part covered (doesn't return)
+                file_be_gone(output_path)  # pragma: part covered (doesn't return)
 
 
 def get_analysis_to_report(
     coverage: Coverage,
     morfs: Iterable[TMorf] | None,
-) -> Iterator[tuple[FileReporter, Analysis]]:
+) -> Iterable[tuple[FileReporter, Analysis]]:
     """Get the files to report on.
 
     For each morf in `morfs`, if it should be reported on (based on the omit
@@ -104,7 +101,7 @@ def get_analysis_to_report(
             # explicitly suppress those errors.
             # NotPython is only raised by PythonFileReporter, which has a
             # should_be_python() method.
-            if fr.should_be_python():       # type: ignore[attr-defined]
+            if fr.should_be_python():  # type: ignore[attr-defined]
                 if config.ignore_errors:
                     msg = f"Couldn't parse Python file '{fr.filename}'"
                     coverage._warn(msg, slug="couldnt-parse")