coverage 7.11.1__cp314-cp314-musllinux_1_2_aarch64.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

@@ -0,0 +1,197 @@
+# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+
+"""Better tokenizing for coverage.py."""
+
+from __future__ import annotations
+
+import ast
+import io
+import keyword
+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]
+
+
+def _phys_tokens(toks: TokenInfos) -> TokenInfos:
+    """Return all physical tokens, even line continuations.
+
+    tokenize.generate_tokens() doesn't return a token for the backslash that
+    continues lines.  This wrapper provides those tokens so that we can
+    re-create a faithful representation of the original source.
+
+    Returns the same values as generate_tokens()
+
+    """
+    last_line: str | None = None
+    last_lineno = -1
+    last_ttext: str = ""
+    for ttype, ttext, (slineno, scol), (elineno, ecol), ltext in toks:
+        if last_lineno != elineno:
+            if last_line and last_line.endswith("\\\n"):
+                # We are at the beginning of a new line, and the last line
+                # ended with a backslash.  We probably have to inject a
+                # backslash token into the stream. Unfortunately, there's more
+                # to figure out.  This code::
+                #
+                #   usage = """\
+                #   HEY THERE
+                #   """
+                #
+                # triggers this condition, but the token text is::
+                #
+                #   '"""\\\nHEY THERE\n"""'
+                #
+                # so we need to figure out if the backslash is already in the
+                # string token or not.
+                inject_backslash = True
+                if last_ttext.endswith("\\"):
+                    inject_backslash = False
+                elif ttype == token.STRING:
+                    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 "\".
+                        #        "bbb \
+                        #        ccc"]
+                        #
+                        inject_backslash = True
+                    else:
+                        # 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 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),
+                        last_line,
+                    )
+            last_line = ltext
+        if ttype not in (tokenize.NEWLINE, tokenize.NL):
+            last_ttext = ttext
+        yield tokenize.TokenInfo(ttype, ttext, (slineno, scol), (elineno, ecol), ltext)
+        last_lineno = elineno
+
+
+def find_soft_key_lines(source: str) -> set[TLineNo]:
+    """Helper for finding lines with soft keywords, like match/case lines."""
+    soft_key_lines: set[TLineNo] = set()
+
+    for node in ast.walk(ast.parse(source)):
+        if isinstance(node, ast.Match):
+            soft_key_lines.add(node.lineno)
+            for case in node.cases:
+                soft_key_lines.add(case.pattern.lineno)
+        elif sys.version_info >= (3, 12) and isinstance(node, ast.TypeAlias):
+            soft_key_lines.add(node.lineno)
+
+    return soft_key_lines
+
+
+def source_token_lines(source: str) -> TSourceTokenLines:
+    """Generate a series of lines, one for each line in `source`.
+
+    Each line is a list of pairs, each pair is a token::
+
+        [('key', 'def'), ('ws', ' '), ('nam', 'hello'), ('op', '('), ... ]
+
+    Each pair has a token class, and the token text.
+
+    If you concatenate all the token texts, and then join them with newlines,
+    you should have your original `source` back, with two differences:
+    trailing white space is not preserved, and a final line with no newline
+    is indistinguishable from a final line with a newline.
+
+    """
+
+    ws_tokens = {token.INDENT, token.DEDENT, token.NEWLINE, tokenize.NL}
+    line: list[tuple[str, str]] = []
+    col = 0
+
+    source = source.expandtabs(8).replace("\r\n", "\n")
+    tokgen = generate_tokens(source)
+
+    soft_key_lines = find_soft_key_lines(source)
+
+    for ttype, ttext, (sline, scol), (_, ecol), _ in _phys_tokens(tokgen):
+        mark_start = True
+        for part in re.split("(\n)", ttext):
+            if part == "\n":
+                yield line
+                line = []
+                col = 0
+                mark_end = False
+            elif part == "":
+                mark_end = False
+            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
+                tok_class = tokenize.tok_name.get(ttype, "xx").lower()[:3]
+                if ttype == token.NAME:
+                    if keyword.iskeyword(ttext):
+                        # Hard keywords are always keywords.
+                        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
+        if mark_end:
+            col = ecol
+
+    if line:
+        yield line
+
+
+def generate_tokens(text: str) -> TokenInfos:
+    """A helper around `tokenize.generate_tokens`.
+
+    Originally this was used to cache the results, but it didn't seem to make
+    reporting go faster, and caused issues with using too much memory.
+
+    """
+    readline = io.StringIO(text).readline
+    return tokenize.generate_tokens(readline)
+
+
+def source_encoding(source: bytes) -> str:
+    """Determine the encoding for `source`, according to PEP 263.
+
+    `source` is a byte string: the text of the program.
+
+    Returns a string, the name of the encoding.
+
+    """
+    readline = iter(source.splitlines(True)).__next__
+    return tokenize.detect_encoding(readline)[0]