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

coverage/core.py

@@ -10,27 +10,28 @@ 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 (
-    TFileDisposition,
-    Tracer,
-    TWarnFn,
-)
-
+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.
-    from coverage.tracer import CTracer, CFileDisposition
-    HAS_CTRACER = True
-except ImportError:
+    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.
-    if os.getenv("COVERAGE_CORE") == "ctrace":      # pragma: part covered
+    # 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
@@ -39,7 +40,8 @@ except ImportError:
         # 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)
-    HAS_CTRACER = False
+    IMPORT_ERROR = str(imp_err)
+    CTRACER_FILE = None
 
 
 class Core:
@@ -52,43 +54,78 @@ class Core:
     packed_arcs: bool
     systrace: bool
 
-    def __init__(self,
+    def __init__(
+        self,
+        *,
         warn: TWarnFn,
-        timid: bool,
+        debug: TDebugCtl | None,
+        config: CoverageConfig,
+        dynamic_contexts: bool,
         metacov: bool,
     ) -> None:
-        # Defaults
-        self.tracer_kwargs = {}
+        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
-        if timid:
+        core_name: str | None = None
+        if config.timid:
             core_name = "pytrace"
-        else:
-            core_name = os.getenv("COVERAGE_CORE")
+            _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: raising ConfigError because sysmon not usable: {reason_no_sysmon}")
+            raise ConfigError(
+                f"Can't use core=sysmon: {reason_no_sysmon}",
+                skip_tests=True,
+                slug="no-sysmon",
+            )
+
+        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 == "sysmon" and not env.PYBEHAVIOR.pep669:
-                warn("sys.monitoring isn't available, using default core", slug="no-sysmon")
-                core_name = None
+        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")
 
-            if not core_name:
-                # Once we're comfortable with sysmon as a default:
-                # if env.PYBEHAVIOR.pep669 and self.should_start_context is None:
-                #     core_name = "sysmon"
-                if HAS_CTRACER:
-                    core_name = "ctrace"
-                else:
-                    core_name = "pytrace"
+        _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.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 = CTracer
-            self.file_disposition_class = CFileDisposition
+            self.tracer_class = coverage.tracer.CTracer
+            self.file_disposition_class = coverage.tracer.CFileDisposition
             self.supports_plugins = True
             self.packed_arcs = True
             self.systrace = True

coverage/data.py

@@ -16,14 +16,13 @@ import functools
 import glob
 import hashlib
 import os.path
-
-from typing import Callable
 from collections.abc import Iterable
+from typing import Callable
 
 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
+from coverage.sqldata import CoverageData as CoverageData  # pylint: disable=useless-import-alias
 
 
 def line_counts(data: CoverageData, fullpath: bool = False) -> dict[str, int]:
@@ -81,7 +80,7 @@ def combinable_files(data_file: str, data_paths: Iterable[str] | None = None) ->
         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)) +".*"
+            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}'")

coverage/debug.py

@@ -5,8 +5,10 @@
 
 from __future__ import annotations
 
+import _thread
 import atexit
 import contextlib
+import datetime
 import functools
 import inspect
 import itertools
@@ -17,13 +19,8 @@ import reprlib
 import sys
 import traceback
 import types
-import _thread
-
-from typing import (
-    overload,
-    Any, Callable, IO,
-)
 from collections.abc import Iterable, Iterator, Mapping
+from typing import IO, Any, Callable, Final, overload
 
 from coverage.misc import human_sorted_items, isolate_module
 from coverage.types import AnyCallable, TWritable
@@ -41,7 +38,7 @@ FORCED_DEBUG_FILE = None
 class DebugControl:
     """Control and output for debugging."""
 
-    show_repr_attr = False      # For auto_repr
+    show_repr_attr = False  # For auto_repr
 
     def __init__(
         self,
@@ -76,7 +73,7 @@ class DebugControl:
         """Decide whether to output debug information in category `option`."""
         if option == "callers" and self.suppress_callers:
             return False
-        return (option in self.options)
+        return option in self.options
 
     @contextlib.contextmanager
     def without_callers(self) -> Iterator[None]:
@@ -111,25 +108,38 @@ class DebugControl:
 
 class NoDebugging(DebugControl):
     """A replacement for DebugControl that will never try to do anything."""
+
     def __init__(self) -> None:
         # pylint: disable=super-init-not-called
-        ...
+        pass
 
     def should(self, option: str) -> bool:
         """Should we write debug messages?  Never."""
         return False
 
+    @contextlib.contextmanager
+    def without_callers(self) -> Iterator[None]:
+        """A dummy context manager to satisfy the api."""
+        yield  # pragma: never called
+
     def write(self, msg: str, *, exc: BaseException | None = None) -> None:
         """This will never be called."""
         raise AssertionError("NoDebugging.write should never be called.")
 
 
+class DevNullDebug(NoDebugging):
+    """A DebugControl that won't write anywhere."""
+
+    def write(self, msg: str, *, exc: BaseException | None = None) -> None:
+        pass
+
+
 def info_header(label: str) -> str:
     """Make a nice header string."""
-    return "--{:-<60s}".format(" "+label+" ")
+    return "--{:-<60s}".format(" " + label + " ")
 
 
-def info_formatter(info: Iterable[tuple[str, Any]]) -> Iterator[str]:
+def info_formatter(info: Iterable[tuple[str, Any]]) -> Iterable[str]:
     """Produce a sequence of formatted lines from info.
 
     `info` is a sequence of pairs (label, data).  The produced lines are
@@ -139,21 +149,21 @@ def info_formatter(info: Iterable[tuple[str, Any]]) -> Iterator[str]:
     info = list(info)
     if not info:
         return
-    label_len = 30
-    assert all(len(l) < label_len for l, _ in info)
+    LABEL_LEN = 30
+    assert all(len(l) < LABEL_LEN for l, _ in info)
     for label, data in info:
         if data == []:
             data = "-none-"
-        if isinstance(data, tuple) and len(repr(tuple(data))) < 30:
-            # Convert to tuple to scrub namedtuples.
-            yield "%*s: %r" % (label_len, label, tuple(data))
-        elif isinstance(data, (list, set, tuple)):
-            prefix = "%*s:" % (label_len, label)
-            for e in data:
-                yield "%*s %s" % (label_len+1, prefix, e)
-                prefix = ""
-        else:
-            yield "%*s: %s" % (label_len, label, data)
+        prefix = f"{label:>{LABEL_LEN}}: "
+        match data:
+            case tuple() if len(str(data)) < 30:
+                yield f"{prefix}{data}"
+            case tuple() | list() | set():
+                for e in data:
+                    yield f"{prefix}{e}"
+                    prefix = " " * (LABEL_LEN + 2)
+            case _:
+                yield f"{prefix}{data}"
 
 
 def write_formatted_info(
@@ -185,20 +195,24 @@ _FILENAME_REGEXES: list[tuple[str, str]] = [
 ]
 _FILENAME_SUBS: list[tuple[str, str]] = []
 
+
 @overload
 def short_filename(filename: str) -> str:
     pass
 
+
 @overload
 def short_filename(filename: None) -> None:
     pass
 
+
 def short_filename(filename: str | None) -> str | None:
     """Shorten a file name. Directories are replaced by prefixes like 'syspath:'"""
     if not _FILENAME_SUBS:
         for pathdir in sys.path:
             _FILENAME_SUBS.append((pathdir, "syspath:"))
         import coverage
+
         _FILENAME_SUBS.append((os.path.dirname(coverage.__file__), "cov:"))
         _FILENAME_SUBS.sort(key=(lambda pair: len(pair[0])), reverse=True)
     if filename is not None:
@@ -209,6 +223,20 @@ def short_filename(filename: str | None) -> str | None:
     return filename
 
 
+def file_summary(filename: str) -> str:
+    """A one-line summary of a file, for log messages."""
+    try:
+        s = os.stat(filename)
+    except FileNotFoundError:
+        summary = "does not exist"
+    except Exception as e:
+        summary = f"error: {e}"
+    else:
+        mod = datetime.datetime.fromtimestamp(s.st_mtime)
+        summary = f"{s.st_size} bytes, modified {mod}"
+    return summary
+
+
 def short_stack(
     skip: int = 0,
     full: bool = False,
@@ -237,11 +265,13 @@ def short_stack(
 
     """
     # Regexes in initial frames that we don't care about.
+    # fmt: off
     BORING_PRELUDE = [
         "<string>",             # pytest-xdist has string execution.
         r"\bigor.py$",          # Our test runner.
         r"\bsite-packages\b",   # pytest etc getting to our tests.
     ]
+    # fmt: on
 
     stack: Iterable[inspect.FrameInfo] = inspect.stack()[:skip:-1]
     if not full:
@@ -265,7 +295,7 @@ def short_stack(
 
 def dump_stack_frames(out: TWritable, skip: int = 0) -> None:
     """Print a summary of the stack to `out`."""
-    out.write(short_stack(skip=skip+1) + "\n")
+    out.write(short_stack(skip=skip + 1) + "\n")
 
 
 def clipped_repr(text: str, numchars: int = 50) -> str:
@@ -293,10 +323,12 @@ def add_pid_and_tid(text: str) -> str:
 
 AUTO_REPR_IGNORE = {"$coverage.object_id"}
 
+
 def auto_repr(self: Any) -> str:
     """A function implementing an automatic __repr__ for debugging."""
     show_attrs = (
-        (k, v) for k, v in self.__dict__.items()
+        (k, v)
+        for k, v in self.__dict__.items()
         if getattr(v, "show_repr_attr", True)
         and not inspect.ismethod(v)
         and k not in AUTO_REPR_IGNORE
@@ -308,22 +340,26 @@ def auto_repr(self: Any) -> str:
     )
 
 
-def simplify(v: Any) -> Any:                                # pragma: debugging
+def simplify(v: Any) -> Any:  # pragma: debugging
     """Turn things which are nearly dict/list/etc into dict/list/etc."""
     if isinstance(v, dict):
-        return {k:simplify(vv) for k, vv in v.items()}
+        return {k: simplify(vv) for k, vv in v.items()}
     elif isinstance(v, (list, tuple)):
         return type(v)(simplify(vv) for vv in v)
     elif hasattr(v, "__dict__"):
-        return simplify({"."+k: v for k, v in v.__dict__.items()})
+        return simplify({"." + k: v for k, v in v.__dict__.items()})
     else:
         return v
 
 
-def pp(v: Any) -> None:                                     # pragma: debugging
+def ppformat(v: Any) -> str:  # pragma: debugging
+    """Debug helper to pretty-print data, including SimpleNamespace objects."""
+    return pprint.pformat(simplify(v), indent=4, compact=True, sort_dicts=True, width=140)
+
+
+def pp(v: Any) -> None:  # pragma: debugging
     """Debug helper to pretty-print data, including SimpleNamespace objects."""
-    # Might not be needed in 3.9+
-    pprint.pprint(simplify(v))
+    print(ppformat(v))
 
 
 def filter_text(text: str, filters: Iterable[Callable[[str], str]]) -> str:
@@ -338,7 +374,7 @@ def filter_text(text: str, filters: Iterable[Callable[[str], str]]) -> str:
 
     """
     clean_text = text.rstrip()
-    ending = text[len(clean_text):]
+    ending = text[len(clean_text) :]
     text = clean_text
     for filter_fn in filters:
         lines = []
@@ -350,6 +386,7 @@ def filter_text(text: str, filters: Iterable[Callable[[str], str]]) -> str:
 
 class CwdTracker:
     """A class to add cwd info to debug messages."""
+
     def __init__(self) -> None:
         self.cwd: str | None = None
 
@@ -357,13 +394,14 @@ class CwdTracker:
         """Add a cwd message for each new cwd."""
         cwd = os.getcwd()
         if cwd != self.cwd:
-            text = f"cwd is now {cwd!r}\n" + text
+            text = f"cwd is now {cwd!r}\n{text}"
             self.cwd = cwd
         return text
 
 
 class ProcessTracker:
     """Track process creation for debug logging."""
+
     def __init__(self) -> None:
         self.pid: int = os.getpid()
         self.did_welcome = False
@@ -392,6 +430,7 @@ class ProcessTracker:
 
 class PytestTracker:
     """Track the current pytest test name to add to debug messages."""
+
     def __init__(self) -> None:
         self.test_name: str | None = None
 
@@ -399,13 +438,14 @@ class PytestTracker:
         """Add a message when the pytest test changes."""
         test_name = os.getenv("PYTEST_CURRENT_TEST")
         if test_name != self.test_name:
-            text = f"Pytest context: {test_name}\n" + text
+            text = f"Pytest context: {test_name}\n{text}"
             self.test_name = test_name
         return text
 
 
 class DebugOutputFile:
     """A file-like object that includes pid and cwd information."""
+
     def __init__(
         self,
         outfile: IO[str] | None,
@@ -448,7 +488,7 @@ class DebugOutputFile:
             else:
                 # $set_env.py: COVERAGE_DEBUG_FILE - Where to write debug output
                 file_name = os.getenv("COVERAGE_DEBUG_FILE", FORCED_DEBUG_FILE)
-                if file_name in ("stdout", "stderr"):
+                if file_name in ["stdout", "stderr"]:
                     fileobj = getattr(sys, file_name)
                 elif file_name:
                     fileobj = open(file_name, "a", encoding="utf-8")
@@ -458,7 +498,7 @@ class DebugOutputFile:
             the_one = cls(fileobj, filters)
             cls._set_singleton_data(the_one, interim)
 
-        if not(the_one.filters):
+        if not (the_one.filters):
             the_one.filters = list(filters)
         return the_one
 
@@ -467,8 +507,8 @@ class DebugOutputFile:
     # a process-wide singleton. So stash it in sys.modules instead of
     # on a class attribute. Yes, this is aggressively gross.
 
-    SYS_MOD_NAME = "$coverage.debug.DebugOutputFile.the_one"
-    SINGLETON_ATTR = "the_one_and_is_interim"
+    SYS_MOD_NAME: Final[str] = "$coverage.debug.DebugOutputFile.the_one"
+    SINGLETON_ATTR: Final[str] = "the_one_and_is_interim"
 
     @classmethod
     def _set_singleton_data(cls, the_one: DebugOutputFile, interim: bool) -> None:
@@ -492,19 +532,21 @@ class DebugOutputFile:
     def write(self, text: str) -> None:
         """Just like file.write, but filter through all our filters."""
         assert self.outfile is not None
-        self.outfile.write(filter_text(text, self.filters))
-        self.outfile.flush()
+        if not self.outfile.closed:
+            self.outfile.write(filter_text(text, self.filters))
+            self.outfile.flush()
 
     def flush(self) -> None:
         """Flush our file."""
         assert self.outfile is not None
-        self.outfile.flush()
+        if not self.outfile.closed:
+            self.outfile.flush()
 
 
-def log(msg: str, stack: bool = False) -> None:             # pragma: debugging
+def log(msg: str, stack: bool = False) -> None:  # pragma: debugging
     """Write a log message as forcefully as possible."""
     out = DebugOutputFile.get_one(interim=True)
-    out.write(msg+"\n")
+    out.write(msg + "\n")
     if stack:
         dump_stack_frames(out=out, skip=1)
 
@@ -513,9 +555,10 @@ def decorate_methods(
     decorator: Callable[..., Any],
     butnot: Iterable[str] = (),
     private: bool = False,
-) -> Callable[..., Any]:                                    # pragma: debugging
+) -> Callable[..., Any]:  # pragma: debugging
     """A class decorator to apply a decorator to methods."""
-    def _decorator(cls):                                    # type: ignore[no-untyped-def]
+
+    def _decorator(cls):  # type: ignore[no-untyped-def]
         for name, meth in inspect.getmembers(cls, inspect.isroutine):
             if name not in cls.__dict__:
                 continue
@@ -526,17 +569,21 @@ def decorate_methods(
                 continue
             setattr(cls, name, decorator(meth))
         return cls
+
     return _decorator
 
 
 def break_in_pudb(func: AnyCallable) -> AnyCallable:  # pragma: debugging
     """A function decorator to stop in the debugger for each call."""
+
     @functools.wraps(func)
     def _wrapper(*args: Any, **kwargs: Any) -> Any:
         import pudb
+
         sys.stdout = sys.__stdout__
         pudb.set_trace()
         return func(*args, **kwargs)
+
     return _wrapper
 
 
@@ -544,12 +591,14 @@ OBJ_IDS = itertools.count()
 CALLS = itertools.count()
 OBJ_ID_ATTR = "$coverage.object_id"
 
+
 def show_calls(
     show_args: bool = True,
     show_stack: bool = False,
     show_return: bool = False,
-) -> Callable[..., Any]:                                    # pragma: debugging
+) -> Callable[..., Any]:  # pragma: debugging
     """A method decorator to debug-log each call to the function."""
+
     def _decorator(func: AnyCallable) -> AnyCallable:
         @functools.wraps(func)
         def _wrapper(self: Any, *args: Any, **kwargs: Any) -> Any:
@@ -578,7 +627,9 @@ def show_calls(
                 msg = f"{oid} {callid:04d} {func.__name__} return {ret!r}\n"
                 DebugOutputFile.get_one(interim=True).write(msg)
             return ret
+
         return _wrapper
+
     return _decorator
 
 
@@ -595,19 +646,24 @@ def relevant_environment_display(env: Mapping[str, str]) -> list[tuple[str, str]
         A list of pairs (name, value) to show.
 
     """
-    slugs = {"COV", "PY"}
-    include = {"HOME", "TEMP", "TMP"}
-    cloak = {"API", "TOKEN", "KEY", "SECRET", "PASS", "SIGNATURE"}
+    SLUGS = {"COV", "PY"}
+    INCLUDE = {"HOME", "TEMP", "TMP"}
+    CLOAK = {"API", "TOKEN", "KEY", "SECRET", "PASS", "SIGNATURE"}
+    TRUNCATE = {"COVERAGE_PROCESS_CONFIG"}
+    TRUNCATE_LEN = 60
 
     to_show = []
     for name, val in env.items():
-        keep = False
-        if name in include:
-            keep = True
-        elif any(slug in name for slug in slugs):
-            keep = True
-        if keep:
-            if any(slug in name for slug in cloak):
+        show = False
+        if name in INCLUDE:
+            show = True
+        elif any(slug in name for slug in SLUGS):
+            show = True
+        if show:
+            if any(slug in name for slug in CLOAK):
                 val = re.sub(r"\w", "*", val)
+            if name in TRUNCATE:
+                if len(val) > TRUNCATE_LEN:
+                    val = val[: TRUNCATE_LEN - 3] + "..."
             to_show.append((name, val))
     return human_sorted_items(to_show)

coverage/disposition.py

@@ -32,6 +32,7 @@ class FileDisposition:
 # be implemented in either C or Python.  Acting on them is done with these
 # functions.
 
+
 def disposition_init(cls: type[TFileDisposition], original_filename: str) -> TFileDisposition:
     """Construct and initialize a new FileDisposition object."""
     disp = cls()