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

coverage/patch.py

@@ -0,0 +1,166 @@
+# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+
+"""Invasive patches for coverage.py."""
+
+from __future__ import annotations
+
+import atexit
+import contextlib
+import os
+import site
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, NoReturn
+
+from coverage import env
+from coverage.debug import NoDebugging, DevNullDebug
+from coverage.exceptions import ConfigError, CoverageException
+
+if TYPE_CHECKING:
+    from coverage import Coverage
+    from coverage.config import CoverageConfig
+    from coverage.types import TDebugCtl
+
+
+def apply_patches(
+    cov: Coverage,
+    config: CoverageConfig,
+    debug: TDebugCtl,
+    *,
+    make_pth_file: bool = True,
+) -> None:
+    """Apply invasive patches requested by `[run] patch=`."""
+    debug = debug if debug.should("patch") else DevNullDebug()
+    for patch in sorted(set(config.patch)):
+        match patch:
+            case "_exit":
+                _patch__exit(cov, debug)
+
+            case "execv":
+                _patch_execv(cov, config, debug)
+
+            case "fork":
+                _patch_fork(debug)
+
+            case "subprocess":
+                _patch_subprocess(config, debug, make_pth_file)
+
+            case _:
+                raise ConfigError(f"Unknown patch {patch!r}")
+
+
+def _patch__exit(cov: Coverage, debug: TDebugCtl) -> None:
+    """Patch os._exit."""
+    debug.write("Patching _exit")
+
+    old_exit = os._exit
+
+    def coverage_os_exit_patch(status: int) -> NoReturn:
+        with contextlib.suppress(Exception):
+            debug.write(f"Using _exit patch with {cov = }")
+        with contextlib.suppress(Exception):
+            cov.save()
+        old_exit(status)
+
+    os._exit = coverage_os_exit_patch
+
+
+def _patch_execv(cov: Coverage, config: CoverageConfig, debug: TDebugCtl) -> None:
+    """Patch the execv family of functions."""
+    if env.WINDOWS:
+        raise CoverageException("patch=execv isn't supported yet on Windows.")
+
+    debug.write("Patching execv")
+
+    def make_execv_patch(fname: str, old_execv: Any) -> Any:
+        def coverage_execv_patch(*args: Any, **kwargs: Any) -> Any:
+            with contextlib.suppress(Exception):
+                debug.write(f"Using execv patch for {fname} with {cov = }")
+            with contextlib.suppress(Exception):
+                cov.save()
+
+            if fname.endswith("e"):
+                # Assume the `env` argument is passed positionally.
+                new_env = args[-1]
+                # Pass our configuration in the new environment.
+                new_env["COVERAGE_PROCESS_CONFIG"] = config.serialize()
+                if env.TESTING:
+                    # The subprocesses need to use the same core as the main process.
+                    new_env["COVERAGE_CORE"] = os.getenv("COVERAGE_CORE")
+
+                    # When testing locally, we need to honor the pyc file location
+                    # or they get written to the .tox directories and pollute the
+                    # next run with a different core.
+                    if (cache_prefix := os.getenv("PYTHONPYCACHEPREFIX")) is not None:
+                        new_env["PYTHONPYCACHEPREFIX"] = cache_prefix
+
+                    # Without this, it fails on PyPy and Ubuntu.
+                    new_env["PATH"] = os.getenv("PATH")
+            old_execv(*args, **kwargs)
+
+        return coverage_execv_patch
+
+    # All the exec* and spawn* functions eventually call execv or execve.
+    os.execv = make_execv_patch("execv", os.execv)
+    os.execve = make_execv_patch("execve", os.execve)
+
+
+def _patch_fork(debug: TDebugCtl) -> None:
+    """Ensure Coverage is properly reset after a fork."""
+    from coverage.control import _after_fork_in_child
+
+    if env.WINDOWS:
+        raise CoverageException("patch=fork isn't supported yet on Windows.")
+
+    debug.write("Patching fork")
+    os.register_at_fork(after_in_child=_after_fork_in_child)
+
+
+def _patch_subprocess(config: CoverageConfig, debug: TDebugCtl, make_pth_file: bool) -> None:
+    """Write .pth files and set environment vars to measure subprocesses."""
+    debug.write("Patching subprocess")
+
+    if make_pth_file:
+        pth_files = create_pth_files(debug)
+
+        def delete_pth_files() -> None:
+            for p in pth_files:
+                debug.write(f"Deleting subprocess .pth file: {str(p)!r}")
+                p.unlink(missing_ok=True)
+
+        atexit.register(delete_pth_files)
+    assert config.config_file is not None
+    os.environ["COVERAGE_PROCESS_CONFIG"] = config.serialize()
+
+
+# Writing .pth files is not obvious. On Windows, getsitepackages() returns two
+# directories.  A .pth file in the first will be run, but coverage isn't
+# importable yet.  We write into all the places we can, but with defensive
+# import code.
+
+PTH_CODE = """\
+try:
+    import coverage
+except:
+    pass
+else:
+    coverage.process_startup()
+"""
+
+PTH_TEXT = f"import sys; exec({PTH_CODE!r})\n"
+
+
+def create_pth_files(debug: TDebugCtl = NoDebugging()) -> list[Path]:
+    """Create .pth files for measuring subprocesses."""
+    pth_files = []
+    for pth_dir in site.getsitepackages():
+        pth_file = Path(pth_dir) / f"subcover_{os.getpid()}.pth"
+        try:
+            if debug.should("patch"):
+                debug.write(f"Writing subprocess .pth file: {str(pth_file)!r}")
+            pth_file.write_text(PTH_TEXT, encoding="utf-8")
+        except OSError:  # pragma: cant happen
+            continue
+        else:
+            pth_files.append(pth_file)
+    return pth_files

coverage/phystokens.py

@@ -12,13 +12,11 @@ import re
 import sys
 import token
 import tokenize
-
 from collections.abc import Iterable
 
 from coverage import env
 from coverage.types import TLineNo, TSourceTokenLines
 
-
 TokenInfos = Iterable[tokenize.TokenInfo]
 
 
@@ -57,8 +55,10 @@ def _phys_tokens(toks: TokenInfos) -> TokenInfos:
                 if last_ttext.endswith("\\"):
                     inject_backslash = False
                 elif ttype == token.STRING:
-                    if (last_line.endswith("\\\n") and  # pylint: disable=simplifiable-if-statement
-                        last_line.rstrip(" \\\n").endswith(last_ttext)):
+                    if (  # pylint: disable=simplifiable-if-statement
+                        last_line.endswith("\\\n")
+                        and last_line.rstrip(" \\\n").endswith(last_ttext)
+                    ):
                         # Deal with special cases like such code::
                         #
                         #   a = ["aaa",\ # there may be zero or more blanks between "," and "\".
@@ -70,15 +70,17 @@ def _phys_tokens(toks: TokenInfos) -> TokenInfos:
                         # It's a multi-line string and the first line ends with
                         # a backslash, so we don't need to inject another.
                         inject_backslash = False
-                elif sys.version_info >= (3, 12) and ttype == token.FSTRING_MIDDLE:
+                elif env.PYBEHAVIOR.fstring_syntax and ttype == token.FSTRING_MIDDLE:
                     inject_backslash = False
                 if inject_backslash:
                     # Figure out what column the backslash is in.
                     ccol = len(last_line.split("\n")[-2]) - 1
                     # Yield the token, with a fake token type.
                     yield tokenize.TokenInfo(
-                        99999, "\\\n",
-                        (slineno, ccol), (slineno, ccol+2),
+                        99999,
+                        "\\\n",
+                        (slineno, ccol),
+                        (slineno, ccol + 2),
                         last_line,
                     )
             last_line = ltext
@@ -93,7 +95,7 @@ def find_soft_key_lines(source: str) -> set[TLineNo]:
     soft_key_lines: set[TLineNo] = set()
 
     for node in ast.walk(ast.parse(source)):
-        if sys.version_info >= (3, 10) and isinstance(node, ast.Match):
+        if isinstance(node, ast.Match):
             soft_key_lines.add(node.lineno)
             for case in node.cases:
                 soft_key_lines.add(case.pattern.lineno)
@@ -126,10 +128,7 @@ def source_token_lines(source: str) -> TSourceTokenLines:
     source = source.expandtabs(8).replace("\r\n", "\n")
     tokgen = generate_tokens(source)
 
-    if env.PYBEHAVIOR.soft_keywords:
-        soft_key_lines = find_soft_key_lines(source)
-    else:
-        soft_key_lines = set()
+    soft_key_lines = find_soft_key_lines(source)
 
     for ttype, ttext, (sline, scol), (_, ecol), _ in _phys_tokens(tokgen):
         mark_start = True
@@ -144,6 +143,9 @@ def source_token_lines(source: str) -> TSourceTokenLines:
             elif ttype in ws_tokens:
                 mark_end = False
             else:
+                if env.PYBEHAVIOR.fstring_syntax and ttype == token.FSTRING_MIDDLE:
+                    part = part.replace("{", "{{").replace("}", "}}")
+                    ecol = scol + len(part)
                 if mark_start and scol > col:
                     line.append(("ws", " " * (scol - col)))
                     mark_start = False
@@ -152,19 +154,16 @@ def source_token_lines(source: str) -> TSourceTokenLines:
                     if keyword.iskeyword(ttext):
                         # Hard keywords are always keywords.
                         tok_class = "key"
-                    elif sys.version_info >= (3, 10):   # PYVERSIONS
-                        # Need the version_info check to keep mypy from borking
-                        # on issoftkeyword here.
-                        if env.PYBEHAVIOR.soft_keywords and keyword.issoftkeyword(ttext):
-                            # Soft keywords appear at the start of their line.
-                            if len(line) == 0:
-                                is_start_of_line = True
-                            elif (len(line) == 1) and line[0][0] == "ws":
-                                is_start_of_line = True
-                            else:
-                                is_start_of_line = False
-                            if is_start_of_line and sline in soft_key_lines:
-                                tok_class = "key"
+                    elif keyword.issoftkeyword(ttext):
+                        # Soft keywords appear at the start of their line.
+                        if len(line) == 0:
+                            is_start_of_line = True
+                        elif (len(line) == 1) and line[0][0] == "ws":
+                            is_start_of_line = True
+                        else:
+                            is_start_of_line = False
+                        if is_start_of_line and sline in soft_key_lines:
+                            tok_class = "key"
                 line.append((tok_class, part))
                 mark_end = True
             scol = 0

coverage/plugin.py

@@ -116,10 +116,9 @@ from __future__ import annotations
 
 import dataclasses
 import functools
-
+from collections.abc import Iterable
 from types import FrameType
 from typing import Any
-from collections.abc import Iterable
 
 from coverage import files
 from coverage.misc import _needs_to_implement
@@ -132,7 +131,7 @@ class CoveragePlugin:
     _coverage_plugin_name: str
     _coverage_enabled: bool
 
-    def file_tracer(self, filename: str) -> FileTracer | None: # pylint: disable=unused-argument
+    def file_tracer(self, filename: str) -> FileTracer | None:  # pylint: disable=unused-argument
         """Get a :class:`FileTracer` object for a file.
 
         Plug-in type: file tracer.
@@ -174,8 +173,8 @@ class CoveragePlugin:
 
     def file_reporter(
         self,
-        filename: str,                  # pylint: disable=unused-argument
-    ) -> FileReporter | str:      # str should be Literal["python"]
+        filename: str,  # pylint: disable=unused-argument
+    ) -> FileReporter | str:  # str should be Literal["python"]
         """Get the :class:`FileReporter` class to use for a file.
 
         Plug-in type: file tracer.
@@ -191,7 +190,7 @@ class CoveragePlugin:
 
     def dynamic_context(
         self,
-        frame: FrameType,               # pylint: disable=unused-argument
+        frame: FrameType,  # pylint: disable=unused-argument
     ) -> str | None:
         """Get the dynamically computed context label for `frame`.
 
@@ -210,7 +209,7 @@ class CoveragePlugin:
 
     def find_executable_files(
         self,
-        src_dir: str,                   # pylint: disable=unused-argument
+        src_dir: str,  # pylint: disable=unused-argument
     ) -> Iterable[str]:
         """Yield all of the executable files in `src_dir`, recursively.
 
@@ -256,6 +255,7 @@ class CoveragePlugin:
 
 class CoveragePluginBase:
     """Plugins produce specialized objects, which point back to the original plugin."""
+
     _coverage_plugin: CoveragePlugin
 
 
@@ -311,8 +311,8 @@ class FileTracer(CoveragePluginBase):
 
     def dynamic_source_filename(
         self,
-        filename: str,                  # pylint: disable=unused-argument
-        frame: FrameType,               # pylint: disable=unused-argument
+        filename: str,  # pylint: disable=unused-argument
+        frame: FrameType,  # pylint: disable=unused-argument
     ) -> str | None:
         """Get a dynamically computed source file name.
 
@@ -527,7 +527,7 @@ class FileReporter(CoveragePluginBase):
         self,
         start: TLineNo,
         end: TLineNo,
-        executed_arcs: Iterable[TArc] | None = None,     # pylint: disable=unused-argument
+        executed_arcs: Iterable[TArc] | None = None,  # pylint: disable=unused-argument
     ) -> str:
         """Provide an English sentence describing a missing arc.
 
@@ -545,8 +545,8 @@ class FileReporter(CoveragePluginBase):
 
     def arc_description(
         self,
-        start: TLineNo,     # pylint: disable=unused-argument
-        end: TLineNo
+        start: TLineNo,  # pylint: disable=unused-argument
+        end: TLineNo,
     ) -> str:
         """Provide an English description of an arc's effect."""
         return f"jump to line {end}"
@@ -614,4 +614,4 @@ class FileReporter(CoveragePluginBase):
         return isinstance(other, FileReporter) and self.filename < other.filename
 
     # This object doesn't need to be hashed.
-    __hash__ = None         # type: ignore[assignment]
+    __hash__ = None  # type: ignore[assignment]

coverage/plugin_support.py

@@ -8,17 +8,14 @@ from __future__ import annotations
 import os
 import os.path
 import sys
-
-from types import FrameType
-from typing import Any
 from collections.abc import Iterable, Iterator
+from types import FrameType
+from typing import Any, Callable
 
 from coverage.exceptions import PluginError
 from coverage.misc import isolate_module
-from coverage.plugin import CoveragePlugin, FileTracer, FileReporter
-from coverage.types import (
-    TArc, TConfigurable, TDebugCtl, TLineNo, TPluginConfig, TSourceTokenLines,
-)
+from coverage.plugin import CoveragePlugin, FileReporter, FileTracer
+from coverage.types import TArc, TConfigurable, TDebugCtl, TLineNo, TPluginConfig, TSourceTokenLines
 
 os = isolate_module(os)
 
@@ -26,7 +23,7 @@ os = isolate_module(os)
 class Plugins:
     """The currently loaded collection of coverage.py plugins."""
 
-    def __init__(self) -> None:
+    def __init__(self, debug: TDebugCtl | None = None) -> None:
         self.order: list[CoveragePlugin] = []
         self.names: dict[str, CoveragePlugin] = {}
         self.file_tracers: list[CoveragePlugin] = []
@@ -34,25 +31,17 @@ class Plugins:
         self.context_switchers: list[CoveragePlugin] = []
 
         self.current_module: str | None = None
-        self.debug: TDebugCtl | None
+        self.debug = debug
 
-    @classmethod
-    def load_plugins(
-        cls,
+    def load_from_config(
+        self,
         modules: Iterable[str],
         config: TPluginConfig,
-        debug: TDebugCtl | None = None,
-    ) -> Plugins:
-        """Load plugins from `modules`.
-
-        Returns a Plugins object with the loaded and configured plugins.
-
-        """
-        plugins = cls()
-        plugins.debug = debug
+    ) -> None:
+        """Load plugin modules, and read their settings from configuration."""
 
         for module in modules:
-            plugins.current_module = module
+            self.current_module = module
             __import__(module)
             mod = sys.modules[module]
 
@@ -63,10 +52,17 @@ class Plugins:
                 )
 
             options = config.get_plugin_options(module)
-            coverage_init(plugins, options)
+            coverage_init(self, options)
+
+        self.current_module = None
 
-        plugins.current_module = None
-        return plugins
+    def load_from_callables(
+        self,
+        plugin_inits: Iterable[TCoverageInit],
+    ) -> None:
+        """Load plugins from callables provided."""
+        for fn in plugin_inits:
+            fn(self)
 
     def add_file_tracer(self, plugin: CoveragePlugin) -> None:
         """Add a file tracer plugin.
@@ -138,6 +134,9 @@ class Plugins:
         return self.names[plugin_name]
 
 
+TCoverageInit = Callable[[Plugins], None]
+
+
 class LabelledDebug:
     """A Debug writer, but with labels for prepending to the messages."""
 
@@ -152,7 +151,7 @@ class LabelledDebug:
     def message_prefix(self) -> str:
         """The prefix to use on messages, combining the labels."""
         prefixes = self.labels + [""]
-        return ":\n".join("  "*i+label for i, label in enumerate(prefixes))
+        return ":\n".join("  " * i + label for i, label in enumerate(prefixes))
 
     def write(self, message: str) -> None:
         """Write `message`, but with the labels prepended."""
@@ -211,10 +210,8 @@ class DebugFileTracerWrapper(FileTracer):
 
     def _show_frame(self, frame: FrameType) -> str:
         """A short string identifying a frame, for debug messages."""
-        return "%s@%d" % (
-            os.path.basename(frame.f_code.co_filename),
-            frame.f_lineno,
-        )
+        filename = os.path.basename(frame.f_code.co_filename)
+        return f"{filename}@{frame.f_lineno}"
 
     def source_filename(self) -> str:
         sfilename = self.tracer.source_filename()
@@ -228,9 +225,13 @@ class DebugFileTracerWrapper(FileTracer):
 
     def dynamic_source_filename(self, filename: str, frame: FrameType) -> str | None:
         dyn = self.tracer.dynamic_source_filename(filename, frame)
-        self.debug.write("dynamic_source_filename({!r}, {}) --> {!r}".format(
-            filename, self._show_frame(frame), dyn,
-        ))
+        self.debug.write(
+            "dynamic_source_filename({!r}, {}) --> {!r}".format(
+                filename,
+                self._show_frame(frame),
+                dyn,
+            )
+        )
         return dyn
 
     def line_number_range(self, frame: FrameType) -> tuple[TLineNo, TLineNo]:
@@ -289,10 +290,10 @@ class DebugFileReporterWrapper(FileReporter):
 
     def source(self) -> str:
         ret = self.reporter.source()
-        self.debug.write("source() --> %d chars" % (len(ret),))
+        self.debug.write(f"source() --> {len(ret)} chars")
         return ret
 
     def source_token_lines(self) -> TSourceTokenLines:
         ret = list(self.reporter.source_token_lines())
-        self.debug.write("source_token_lines() --> %d tokens" % (len(ret),))
+        self.debug.write(f"source_token_lines() --> {len(ret)} tokens")
         return ret

coverage/python.py

@@ -8,16 +8,15 @@ from __future__ import annotations
 import os.path
 import types
 import zipimport
-
-from typing import TYPE_CHECKING
 from collections.abc import Iterable
+from typing import TYPE_CHECKING
 
 from coverage import env
 from coverage.exceptions import CoverageException, NoSource
 from coverage.files import canonical_filename, relative_filename, zip_location
 from coverage.misc import isolate_module, join_regex
 from coverage.parser import PythonParser
-from coverage.phystokens import source_token_lines, source_encoding
+from coverage.phystokens import source_encoding, source_token_lines
 from coverage.plugin import CodeRegion, FileReporter
 from coverage.regions import code_regions
 from coverage.types import TArc, TLineNo, TMorf, TSourceTokenLines
@@ -62,7 +61,7 @@ def get_python_source(filename: str) -> str:
             break
     else:
         # Couldn't find source.
-        raise NoSource(f"No source for code: '{filename}'.")
+        raise NoSource(f"No source for code: '{filename}'.", slug="no-source")
 
     # Replace \f because of http://bugs.python.org/issue19035
     source_bytes = source_bytes.replace(b"\f", b" ")
@@ -194,6 +193,10 @@ class PythonFileReporter(FileReporter):
         """Return the line numbers of statements in the file."""
         return self.parser.statements
 
+    def multiline_map(self) -> dict[TLineNo, TLineNo]:
+        """A map of line numbers to first-line in a multi-line statement."""
+        return self.parser.multiline_map
+
     def excluded_lines(self) -> set[TLineNo]:
         """Return the line numbers of statements in the file."""
         return self.parser.excluded
@@ -207,10 +210,7 @@ class PythonFileReporter(FileReporter):
     def no_branch_lines(self) -> set[TLineNo]:
         assert self.coverage is not None
         no_branch = self.parser.lines_matching(
-            join_regex(
-                self.coverage.config.partial_list
-                + self.coverage.config.partial_always_list
-            )
+            join_regex(self.coverage.config.partial_list + self.coverage.config.partial_always_list)
         )
         return no_branch
 
@@ -228,11 +228,7 @@ class PythonFileReporter(FileReporter):
     ) -> str:
         return self.parser.missing_arc_description(start, end)
 
-    def arc_description(
-        self,
-        start: TLineNo,
-        end: TLineNo
-    ) -> str:
+    def arc_description(self, start: TLineNo, end: TLineNo) -> str:
         return self.parser.arc_description(start, end)
 
     def source(self) -> str: