coverage 7.13.1__cp313-cp313-musllinux_1_2_riscv64.whl

coverage/core.py

@@ -0,0 +1,139 @@
+# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+# For details: https://github.com/coveragepy/coveragepy/blob/main/NOTICE.txt
+
+"""Management of core choices."""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import Any
+
+from coverage import env
+from coverage.config import CoverageConfig
+from coverage.disposition import FileDisposition
+from coverage.exceptions import ConfigError
+from coverage.misc import isolate_module
+from coverage.pytracer import PyTracer
+from coverage.sysmon import SysMonitor
+from coverage.types import TDebugCtl, TFileDisposition, Tracer, TWarnFn
+
+os = isolate_module(os)
+
+IMPORT_ERROR: str = ""
+
+try:
+    # Use the C extension code when we can, for speed.
+    import coverage.tracer
+
+    CTRACER_FILE: str | None = getattr(coverage.tracer, "__file__", "unknown")
+except ImportError as imp_err:
+    # Couldn't import the C extension, maybe it isn't built.
+    # We still need to check the environment variable directly here,
+    # as this code runs before configuration is loaded.
+    if os.getenv("COVERAGE_CORE") == "ctrace":  # pragma: part covered
+        # During testing, we use the COVERAGE_CORE environment variable
+        # to indicate that we've fiddled with the environment to test this
+        # fallback code.  If we thought we had a C tracer, but couldn't import
+        # it, then exit quickly and clearly instead of dribbling confusing
+        # errors. I'm using sys.exit here instead of an exception because an
+        # exception here causes all sorts of other noise in unittest.
+        sys.stderr.write("*** COVERAGE_CORE is 'ctrace' but can't import CTracer!\n")
+        sys.exit(1)
+    IMPORT_ERROR = str(imp_err)
+    CTRACER_FILE = None
+
+
+class Core:
+    """Information about the central technology enabling execution measurement."""
+
+    tracer_class: type[Tracer]
+    tracer_kwargs: dict[str, Any]
+    file_disposition_class: type[TFileDisposition]
+    supports_plugins: bool
+    packed_arcs: bool
+    systrace: bool
+
+    def __init__(
+        self,
+        *,
+        warn: TWarnFn,
+        debug: TDebugCtl | None,
+        config: CoverageConfig,
+        dynamic_contexts: bool,
+        metacov: bool,
+    ) -> None:
+        def _debug(msg: str) -> None:
+            if debug:
+                debug.write(msg)
+
+        _debug("in core.py")
+
+        # Check the conditions that preclude us from using sys.monitoring.
+        reason_no_sysmon = ""
+        if not env.PYBEHAVIOR.pep669:
+            reason_no_sysmon = "sys.monitoring isn't available in this version"
+        elif config.branch and not env.PYBEHAVIOR.branch_right_left:
+            reason_no_sysmon = "sys.monitoring can't measure branches in this version"
+        elif dynamic_contexts:
+            reason_no_sysmon = "it doesn't yet support dynamic contexts"
+        elif any((bad := c) in config.concurrency for c in ["greenlet", "eventlet", "gevent"]):
+            reason_no_sysmon = f"it doesn't support concurrency={bad}"
+
+        core_name: str | None = None
+        if config.timid:
+            core_name = "pytrace"
+            _debug("core.py: Using pytrace because timid=True")
+        elif core_name is None:
+            # This could still leave core_name as None.
+            core_name = config.core
+            _debug(f"core.py: core from config is {core_name!r}")
+
+        if core_name == "sysmon" and reason_no_sysmon:
+            _debug(f"core.py: defaulting because sysmon not usable: {reason_no_sysmon}")
+            warn(f"Can't use core=sysmon: {reason_no_sysmon}, using default core", slug="no-sysmon")
+            core_name = None
+
+        if core_name is None:
+            if env.SYSMON_DEFAULT and not reason_no_sysmon:
+                core_name = "sysmon"
+                _debug("core.py: Using sysmon because SYSMON_DEFAULT is set")
+            else:
+                core_name = "ctrace"
+                _debug("core.py: Defaulting to ctrace core")
+
+        if core_name == "ctrace":
+            if not CTRACER_FILE:
+                if IMPORT_ERROR and env.SHIPPING_WHEELS:
+                    warn(f"Couldn't import C tracer: {IMPORT_ERROR}", slug="no-ctracer", once=True)
+                core_name = "pytrace"
+                _debug("core.py: Falling back to pytrace because C tracer not available")
+
+        _debug(f"core.py: Using core={core_name}")
+
+        self.tracer_kwargs = {}
+
+        if core_name == "sysmon":
+            self.tracer_class = SysMonitor
+            self.tracer_kwargs["tool_id"] = 3 if metacov else 1
+            self.file_disposition_class = FileDisposition
+            self.supports_plugins = False
+            self.packed_arcs = False
+            self.systrace = False
+        elif core_name == "ctrace":
+            self.tracer_class = coverage.tracer.CTracer
+            self.file_disposition_class = coverage.tracer.CFileDisposition
+            self.supports_plugins = True
+            self.packed_arcs = True
+            self.systrace = True
+        elif core_name == "pytrace":
+            self.tracer_class = PyTracer
+            self.file_disposition_class = FileDisposition
+            self.supports_plugins = False
+            self.packed_arcs = False
+            self.systrace = True
+        else:
+            raise ConfigError(f"Unknown core value: {core_name!r}")
+
+    def __repr__(self) -> str:
+        return f"<Core tracer_class={self.tracer_class.__name__}>"

coverage/data.py

@@ -0,0 +1,251 @@
+# 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 data for coverage.py.
+
+This file had the 4.x JSON data support, which is now gone.  This file still
+has storage-agnostic helpers, and is kept to avoid changing too many imports.
+CoverageData is now defined in sqldata.py, and imported here to keep the
+imports working.
+
+"""
+
+from __future__ import annotations
+
+import functools
+import glob
+import hashlib
+import os.path
+from collections.abc import Callable, Iterable
+from typing import Literal
+
+from coverage.exceptions import CoverageException, NoDataError
+from coverage.files import PathAliases
+from coverage.misc import Hasher, file_be_gone, human_sorted, plural
+from coverage.sqldata import CoverageData as CoverageData  # pylint: disable=useless-import-alias
+from coverage.sqldata import filename_match
+
+
+def line_counts(data: CoverageData, fullpath: bool = False) -> dict[str, int]:
+    """Return a dict summarizing the line coverage data.
+
+    Keys are based on the file names, and values are the number of executed
+    lines.  If `fullpath` is true, then the keys are the full pathnames of
+    the files, otherwise they are the basenames of the files.
+
+    Returns a dict mapping file names to counts of lines.
+
+    """
+    summ = {}
+    filename_fn: Callable[[str], str]
+    if fullpath:
+        # pylint: disable=unnecessary-lambda-assignment
+        filename_fn = lambda f: f
+    else:
+        filename_fn = os.path.basename
+    for filename in data.measured_files():
+        lines = data.lines(filename)
+        assert lines is not None
+        summ[filename_fn(filename)] = len(lines)
+    return summ
+
+
+def add_data_to_hash(data: CoverageData, filename: str, hasher: Hasher) -> None:
+    """Contribute `filename`'s data to the `hasher`.
+
+    `hasher` is a `coverage.misc.Hasher` instance to be updated with
+    the file's data.  It should only get the results data, not the run
+    data.
+
+    """
+    if data.has_arcs():
+        hasher.update(sorted(data.arcs(filename) or []))
+    else:
+        hasher.update(sorted_lines(data, filename))
+    hasher.update(data.file_tracer(filename))
+
+
+def combinable_files(data_file: str, data_paths: Iterable[str] | None = None) -> list[str]:
+    """Make a list of data files to be combined.
+
+    `data_file` is a path to a data file.  `data_paths` is a list of files or
+    directories of files.
+
+    Returns a list of absolute file paths.
+    """
+    data_dir, local = os.path.split(os.path.abspath(data_file))
+
+    data_paths = data_paths or [data_dir]
+    files_to_combine = []
+    for p in data_paths:
+        if os.path.isfile(p):
+            files_to_combine.append(os.path.abspath(p))
+        elif os.path.isdir(p):
+            pattern = glob.escape(os.path.join(os.path.abspath(p), local)) + ".*"
+            files_to_combine.extend(glob.glob(pattern))
+        else:
+            raise NoDataError(f"Couldn't combine from non-existent path '{p}'")
+
+    # SQLite might have made journal files alongside our database files.
+    # We never want to combine those.
+    files_to_combine = [fnm for fnm in files_to_combine if not fnm.endswith("-journal")]
+
+    # Sorting isn't usually needed, since it shouldn't matter what order files
+    # are combined, but sorting makes tests more predictable, and makes
+    # debugging more understandable when things go wrong.
+    return sorted(files_to_combine)
+
+
+def hash_for_data_file(dbfilename: str) -> str:
+    """Get the hash of the data in the file."""
+    m = filename_match(dbfilename)
+    if m and m["hash"]:
+        return m["hash"]
+    else:
+        with open(dbfilename, "rb") as fobj:
+            hasher = hashlib.new("sha3_256", usedforsecurity=False)
+            hasher.update(fobj.read())
+        return hasher.hexdigest()
+
+
+class DataFileClassifier:
+    """Track what files to combine and which to skip."""
+
+    def __init__(self) -> None:
+        self.file_hashes: set[str] = set()
+
+    def classify(self, f: str) -> Literal["combine", "skip"]:
+        """Determine whether to combine or skip this file."""
+        sha = hash_for_data_file(f)
+        if sha in self.file_hashes:
+            return "skip"
+        else:
+            self.file_hashes.add(sha)
+            return "combine"
+
+
+def combine_parallel_data(
+    data: CoverageData,
+    aliases: PathAliases | None = None,
+    data_paths: Iterable[str] | None = None,
+    strict: bool = False,
+    keep: bool = False,
+    message: Callable[[str], None] | None = None,
+) -> None:
+    """Combine a number of data files together.
+
+    `data` is a CoverageData.
+
+    Treat `data.filename` as a file prefix, and combine the data from all
+    of the data files starting with that prefix plus a dot.
+
+    If `aliases` is provided, it's a `PathAliases` object that is used to
+    re-map paths to match the local machine's.
+
+    If `data_paths` is provided, it is a list of directories or files to
+    combine.  Directories are searched for files that start with
+    `data.filename` plus dot as a prefix, and those files are combined.
+
+    If `data_paths` is not provided, then the directory portion of
+    `data.filename` is used as the directory to search for data files.
+
+    Unless `keep` is True every data file found and combined is then deleted
+    from disk. If a file cannot be read, a warning will be issued, and the
+    file will not be deleted.
+
+    If `strict` is true, and no files are found to combine, an error is
+    raised.
+
+    `message` is a function to use for printing messages to the user.
+
+    """
+    files_to_combine = combinable_files(data.base_filename(), data_paths)
+
+    if strict and not files_to_combine:
+        raise NoDataError("No data to combine")
+
+    if aliases is None:
+        map_path = None
+    else:
+        map_path = functools.cache(aliases.map)
+
+    classifier = DataFileClassifier()
+    combined_any = False
+
+    for f in files_to_combine:
+        if f == data.data_filename():
+            # Sometimes we are combining into a file which is one of the
+            # parallel files.  Skip that file.
+            if data._debug.should("dataio"):
+                data._debug.write(f"Skipping combining ourself: {f!r}")
+            continue
+
+        try:
+            rel_file_name = os.path.relpath(f)
+        except ValueError:
+            # ValueError can be raised under Windows when os.getcwd() returns a
+            # folder from a different drive than the drive of f, in which case
+            # we print the original value of f instead of its relative path.
+            rel_file_name = f
+
+        file_action = classifier.classify(f)
+
+        delete_this_one = not keep
+        if file_action == "combine":
+            if data._debug.should("dataio"):
+                data._debug.write(f"Combining data file {f!r}")
+            try:
+                new_data = CoverageData(f, debug=data._debug)
+                new_data.read()
+            except CoverageException as exc:
+                if data._warn:
+                    # The CoverageException has the file name in it, so just
+                    # use the message as the warning.
+                    data._warn(str(exc))
+                if message:
+                    message(f"Couldn't combine data file {rel_file_name}: {exc}")
+                delete_this_one = False
+            else:
+                data.update(new_data, map_path=map_path)
+                combined_any = True
+                if message:
+                    message(f"Combined data file {rel_file_name}")
+        else:
+            if message:
+                message(f"Skipping duplicate data {rel_file_name}")
+
+        if delete_this_one:
+            if data._debug.should("dataio"):
+                data._debug.write(f"Deleting data file {f!r}")
+            file_be_gone(f)
+
+    if strict and not combined_any:
+        raise NoDataError("No usable data files")
+
+
+def debug_data_file(filename: str) -> None:
+    """Implementation of 'coverage debug data'."""
+    data = CoverageData(filename)
+    filename = data.data_filename()
+    print(f"path: {filename}")
+    if not os.path.exists(filename):
+        print("No data collected: file doesn't exist")
+        return
+    data.read()
+    print(f"has_arcs: {data.has_arcs()!r}")
+    summary = line_counts(data, fullpath=True)
+    filenames = human_sorted(summary.keys())
+    nfiles = len(filenames)
+    print(f"{nfiles} file{plural(nfiles)}:")
+    for f in filenames:
+        line = f"{f}: {summary[f]} line{plural(summary[f])}"
+        plugin = data.file_tracer(f)
+        if plugin:
+            line += f" [{plugin}]"
+        print(line)
+
+
+def sorted_lines(data: CoverageData, filename: str) -> list[int]:
+    """Get the sorted lines for a file, for tests."""
+    lines = data.lines(filename)
+    return sorted(lines or [])