coverage 7.15.4__cp315-cp315-win_amd64.whl

a1_coverage.pth

@@ -0,0 +1 @@
+import sys; exec('import os\n\nif os.getenv("COVERAGE_PROCESS_START") or os.getenv("COVERAGE_PROCESS_CONFIG"):\n try:\n  import coverage\n except:\n  pass\n else:\n  coverage.process_startup(slug="pth")')

coverage/__init__.py

@@ -0,0 +1,38 @@
+# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+# For details: https://github.com/coveragepy/coveragepy/blob/main/NOTICE.txt
+
+"""
+Code coverage measurement for Python.
+
+Ned Batchelder
+https://coverage.readthedocs.io
+
+"""
+
+from __future__ import annotations
+
+# mypy's convention is that "import as" names are public from the module.
+# We import names as themselves to indicate that. Pylint sees it as pointless,
+# so disable its warning.
+# pylint: disable=useless-import-alias
+
+from coverage.version import (
+    __version__ as __version__,
+    version_info as version_info,
+)
+
+from coverage.control import (
+    Coverage as Coverage,
+    process_startup as process_startup,
+)
+from coverage.data import CoverageData as CoverageData
+from coverage.exceptions import CoverageException as CoverageException
+from coverage.plugin import (
+    CodeRegion as CodeRegion,
+    CoveragePlugin as CoveragePlugin,
+    FileReporter as FileReporter,
+    FileTracer as FileTracer,
+)
+
+# Backward compatibility.
+coverage = Coverage

coverage/__main__.py

@@ -0,0 +1,12 @@
+# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+# For details: https://github.com/coveragepy/coveragepy/blob/main/NOTICE.txt
+
+"""Coverage.py's main entry point."""
+
+from __future__ import annotations
+
+import sys
+
+from coverage.cmdline import main
+
+sys.exit(main())

coverage/annotate.py

@@ -0,0 +1,113 @@
+# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+# For details: https://github.com/coveragepy/coveragepy/blob/main/NOTICE.txt
+
+"""Source file annotation for coverage.py."""
+
+from __future__ import annotations
+
+import os
+import re
+from typing import TYPE_CHECKING
+
+from coverage.files import flat_rootname
+from coverage.misc import ensure_dir, isolate_module
+from coverage.plugin import FileReporter
+from coverage.report_core import get_analysis_to_report
+from coverage.results import Analysis
+from coverage.types import TMorfs
+
+if TYPE_CHECKING:
+    from coverage import Coverage
+
+os = isolate_module(os)
+
+
+class AnnotateReporter:
+    """Generate annotated source files showing line coverage.
+
+    This reporter creates annotated copies of the measured source files. Each
+    .py file is copied as a .py,cover file, with a left-hand margin annotating
+    each line::
+
+        > def h(x):
+        -     if 0:   #pragma: no cover
+        -         pass
+        >     if x == 1:
+        !         a = 1
+        >     else:
+        >         a = 2
+
+        > h(2)
+
+    Executed lines use ">", lines not executed use "!", lines excluded from
+    consideration use "-".
+
+    """
+
+    def __init__(self, coverage: Coverage) -> None:
+        self.coverage = coverage
+        self.config = self.coverage.config
+        self.directory: str | None = None
+
+    blank_re = re.compile(r"\s*(#|$)")
+    else_re = re.compile(r"\s*else\s*:\s*(#|$)")
+
+    def report(self, morfs: TMorfs, directory: str | None = None) -> None:
+        """Run the report.
+
+        See `coverage.report()` for arguments.
+
+        """
+        self.directory = directory
+        self.coverage.get_data()
+        for fr, analysis in get_analysis_to_report(self.coverage, morfs):
+            self.annotate_file(fr, analysis)
+
+    def annotate_file(self, fr: FileReporter, analysis: Analysis) -> None:
+        """Annotate a single file.
+
+        `fr` is the FileReporter for the file to annotate.
+
+        """
+        statements = sorted(analysis.statements)
+        missing = sorted(analysis.missing)
+        excluded = sorted(analysis.excluded)
+
+        if self.directory:
+            ensure_dir(self.directory)
+            dest_file = os.path.join(self.directory, flat_rootname(fr.relative_filename()))
+            assert dest_file.endswith("_py")
+            dest_file = dest_file[:-3] + ".py"
+        else:
+            dest_file = fr.filename
+        dest_file += ",cover"
+
+        with open(dest_file, "w", encoding="utf-8") as dest:
+            i = j = 0
+            covered = True
+            source = fr.source()
+            for lineno, line in enumerate(source.splitlines(True), start=1):
+                while i < len(statements) and statements[i] < lineno:
+                    i += 1
+                while j < len(missing) and missing[j] < lineno:
+                    j += 1
+                if i < len(statements) and statements[i] == lineno:
+                    covered = j >= len(missing) or missing[j] > lineno
+                if self.blank_re.match(line):
+                    dest.write("  ")
+                elif self.else_re.match(line):
+                    # Special logic for lines containing only "else:".
+                    if j >= len(missing):
+                        dest.write("> ")
+                    elif statements[i] == missing[j]:
+                        dest.write("! ")
+                    else:
+                        dest.write("> ")
+                elif lineno in excluded:
+                    dest.write("- ")
+                elif covered:
+                    dest.write("> ")
+                else:
+                    dest.write("! ")
+
+                dest.write(line)

coverage/bytecode.py

@@ -0,0 +1,208 @@
+# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+# For details: https://github.com/coveragepy/coveragepy/blob/main/NOTICE.txt
+
+"""Bytecode analysis for coverage.py"""
+
+from __future__ import annotations
+
+import dis
+from collections.abc import Iterable, Mapping
+from types import CodeType
+
+from coverage.types import TArc, TLineNo, TOffset
+
+
+class ByteParser:
+    """Parse bytecode to understand the structure of code."""
+
+    def __init__(
+        self,
+        *,
+        code: CodeType | None = None,
+        text: str | None = None,
+        filename: str | None = None,
+    ) -> None:
+        if code is None:
+            assert text is not None
+            code = compile(text, filename or "<string>", "exec", dont_inherit=True)
+        self.code = code
+
+    def _child_parsers(self) -> Iterable[ByteParser]:
+        """Iterate over all the code objects nested within this one.
+
+        The iteration includes `self` as its first value.
+
+        We skip code objects named `__annotate__` since they are deferred
+        annotations that usually are never run.  If there are errors in the
+        annotations, they will be caught by type checkers or other tools that
+        use annotations.
+
+        """
+        return (ByteParser(code=c) for c in self.code_objects() if c.co_name != "__annotate__")
+
+    def code_objects(self) -> Iterable[CodeType]:
+        """Iterate over all the code objects in `code`."""
+        stack = [self.code]
+        while stack:
+            # We're going to return the code object on the stack, but first
+            # push its children for later returning.
+            code = stack.pop()
+            for c in code.co_consts:
+                if isinstance(c, CodeType):
+                    stack.append(c)
+            yield code
+
+    def _line_numbers(self) -> Iterable[TLineNo]:
+        """Yield the line numbers possible in this code object.
+
+        Uses co_lines() to produce a sequence: l0, l1, ...
+        """
+        for _, _, line in self.code.co_lines():
+            if line:
+                yield line
+
+    def find_statements(self) -> Iterable[TLineNo]:
+        """Find the statements in `self.code`.
+
+        Produce a sequence of line numbers that start statements.  Recurses
+        into all code objects reachable from `self.code`.
+
+        """
+        for bp in self._child_parsers():
+            # Get all of the lineno information from this code.
+            yield from bp._line_numbers()
+
+
+def bytes_to_lines(code: CodeType) -> dict[TOffset, TLineNo]:
+    """Make a dict mapping byte code offsets to line numbers."""
+    b2l = {}
+    for bstart, bend, lineno in code.co_lines():
+        if lineno is not None:
+            for boffset in range(bstart, bend, 2):
+                b2l[boffset] = lineno
+    return b2l
+
+
+def op_set(*op_names: str) -> set[int]:
+    """Make a set of opcodes from instruction names.
+
+    The names might not exist in this version of Python, skip those if not.
+    """
+    ops = {op for name in op_names if (op := dis.opmap.get(name))}
+    assert ops, f"At least one opcode must exist: {op_names}"
+    return ops
+
+
+# Opcodes that are unconditional jumps elsewhere.
+ALWAYS_JUMPS = op_set(
+    "JUMP_BACKWARD",
+    "JUMP_BACKWARD_NO_INTERRUPT",
+    "JUMP_FORWARD",
+)
+
+# Opcodes that exit from a function.
+RETURNS = op_set(
+    "RETURN_VALUE",
+    "RETURN_GENERATOR",
+)
+
+
+# CACHE doesn't exist in Python 3.10, but the branch resolver is only used
+# on 3.14+, so a placeholder value is fine.
+_CACHE = dis.opmap.get("CACHE", -1)
+_EXTENDED_ARG = dis.opmap["EXTENDED_ARG"]
+
+# All opcodes with a jump target.
+JUMPS = set(dis.hasjrel) | set(dis.hasjabs)
+
+# Opcodes that jump backwards.
+BACKWARD_JUMPS = {op for op in JUMPS if "JUMP_BACKWARD" in dis.opname[op]}
+
+
+class BranchArcResolver:
+    """Resolve branch events to line arcs, one (source, dest) pair at a time.
+
+    Branch events are one-shot (they are DISABLEd after firing), so each
+    (source offset, destination offset) pair is resolved at most a couple of
+    times per code object.  Resolving pairs on demand is much cheaper than
+    precomputing trails for every branch in the code object, most of which
+    never fire.  We walk the raw bytecode bytes so that we never need to
+    disassemble whole code objects with `dis`.
+
+    To resolve one pair:
+    starting from the destination, follow the trail of instructions (through
+    unconditional jumps) until we reach an instruction on a new source line
+    (giving us the arc), a return (an arc to leaving the code object), or
+    another branch possibility (no arc: that branch will produce its own
+    events).
+
+    """
+
+    def __init__(
+        self,
+        code: CodeType,
+        byte_to_line: Mapping[TOffset, TLineNo],
+        multiline_map: Mapping[TLineNo, TLineNo],
+    ) -> None:
+        self.code = code
+        # co_code re-copies the bytes on each access, so fetch it once.
+        self.co_code = code.co_code
+        self.byte_to_line = byte_to_line
+        self.multiline_map = multiline_map
+
+    def line_at(self, offset: TOffset) -> TLineNo | None:
+        """The source line of the instruction at `offset`, de-multilined."""
+        line = self.byte_to_line.get(offset)
+        if line is not None:
+            line = self.multiline_map.get(line, line)
+        return line
+
+    def resolve(self, source: TOffset, dest: TOffset) -> TArc | None:
+        """Turn a branch event's (source, dest) offsets into an arc, or None."""
+        from_line = self.line_at(source)
+        if from_line is None:
+            return None
+        co_code = self.co_code
+        max_offset = len(co_code)
+        byte_to_line = self.byte_to_line
+        multiline_map = self.multiline_map
+        offset = dest
+        ext_arg = 0
+        seen: set[TOffset] = set()
+        while 0 <= offset < max_offset and offset not in seen:
+            seen.add(offset)
+            op = co_code[offset]
+            if op == _CACHE:
+                offset += 2
+                continue
+            if op == _EXTENDED_ARG:
+                ext_arg = (ext_arg | co_code[offset + 1]) << 8
+                offset += 2
+                continue
+            line = byte_to_line.get(offset)
+            if line is not None:
+                line = multiline_map.get(line, line)
+                if line and line != from_line:
+                    return (from_line, line)
+            if op in JUMPS:
+                if op in ALWAYS_JUMPS:
+                    arg = ext_arg | co_code[offset + 1]
+                    # Jump distances are measured from the end of the
+                    # instruction's inline CACHE entries, which appear in
+                    # co_code as CACHE opcodes immediately following it.
+                    next_offset = offset + 2
+                    while next_offset < max_offset and co_code[next_offset] == _CACHE:
+                        next_offset += 2
+                    if op in BACKWARD_JUMPS:
+                        offset = next_offset - 2 * arg
+                    else:
+                        offset = next_offset + 2 * arg
+                    ext_arg = 0
+                    continue
+                # Another branch possibility: it will get its own events.
+                return None
+            if op in RETURNS:
+                return (from_line, -self.code.co_firstlineno)
+            ext_arg = 0
+            offset += 2
+        return None