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

coverage/collector.py

@@ -9,13 +9,11 @@ import contextlib
 import functools
 import os
 import sys
-
 from collections.abc import Mapping
 from types import FrameType
-from typing import cast, Any, Callable, TypeVar
+from typing import Any, Callable, TypeVar, cast
 
 from coverage import env
-from coverage.config import CoverageConfig
 from coverage.core import Core
 from coverage.data import CoverageData
 from coverage.debug import short_stack
@@ -26,11 +24,11 @@ from coverage.types import (
     TArc,
     TCheckIncludeFn,
     TFileDisposition,
+    Tracer,
     TShouldStartContextFn,
     TShouldTraceFn,
     TTraceData,
     TTraceFn,
-    Tracer,
     TWarnFn,
 )
 
@@ -61,9 +59,6 @@ class Collector:
     # the top, and resumed when they become the top again.
     _collectors: list[Collector] = []
 
-    # The concurrency settings we support here.
-    LIGHT_THREADS = {"greenlet", "eventlet", "gevent"}
-
     def __init__(
         self,
         core: Core,
@@ -113,8 +108,7 @@ class Collector:
         self.file_mapper = file_mapper
         self.branch = branch
         self.warn = warn
-        self.concurrency = concurrency
-        assert isinstance(self.concurrency, list), f"Expected a list: {self.concurrency!r}"
+        assert isinstance(concurrency, list), f"Expected a list: {concurrency!r}"
 
         self.pid = os.getpid()
 
@@ -126,34 +120,27 @@ class Collector:
 
         self.concur_id_func = None
 
-        # We can handle a few concurrency options here, but only one at a time.
-        concurrencies = set(self.concurrency)
-        unknown = concurrencies - CoverageConfig.CONCURRENCY_CHOICES
-        if unknown:
-            show = ", ".join(sorted(unknown))
-            raise ConfigError(f"Unknown concurrency choices: {show}")
-        light_threads = concurrencies & self.LIGHT_THREADS
-        if len(light_threads) > 1:
-            show = ", ".join(sorted(light_threads))
-            raise ConfigError(f"Conflicting concurrency settings: {show}")
         do_threading = False
 
         tried = "nothing"  # to satisfy pylint
         try:
-            if "greenlet" in concurrencies:
+            if "greenlet" in concurrency:
                 tried = "greenlet"
                 import greenlet
+
                 self.concur_id_func = greenlet.getcurrent
-            elif "eventlet" in concurrencies:
+            elif "eventlet" in concurrency:
                 tried = "eventlet"
-                import eventlet.greenthread     # pylint: disable=import-error,useless-suppression
+                import eventlet.greenthread
+
                 self.concur_id_func = eventlet.greenthread.getcurrent
-            elif "gevent" in concurrencies:
+            elif "gevent" in concurrency:
                 tried = "gevent"
-                import gevent                   # pylint: disable=import-error,useless-suppression
+                import gevent
+
                 self.concur_id_func = gevent.getcurrent
 
-            if "thread" in concurrencies:
+            if "thread" in concurrency:
                 do_threading = True
         except ImportError as ex:
             msg = f"Couldn't trace with concurrency={tried}, the module isn't installed."
@@ -162,15 +149,17 @@ class Collector:
         if self.concur_id_func and not hasattr(core.tracer_class, "concur_id_func"):
             raise ConfigError(
                 "Can't support concurrency={} with {}, only threads are supported.".format(
-                    tried, self.tracer_name(),
+                    tried,
+                    self.tracer_name(),
                 ),
             )
 
-        if do_threading or not concurrencies:
+        if do_threading or not concurrency:
             # It's important to import threading only if we need it.  If
             # it's imported early, and the program being measured uses
             # gevent, then gevent's monkey-patching won't work properly.
             import threading
+
             self.threading = threading
 
         self.reset()
@@ -222,7 +211,8 @@ class Collector:
         # being excluded by the inclusion rules, in which case the
         # FileDisposition will be replaced by None in the cache.
         if env.PYPY:
-            import __pypy__                     # pylint: disable=import-error
+            import __pypy__  # pylint: disable=import-error
+
             # Alex Gaynor said:
             # should_trace_cache is a strictly growing key: once a key is in
             # it, it never changes.  Further, the keys used to access it are
@@ -267,19 +257,19 @@ class Collector:
         tracer.should_trace_cache = self.should_trace_cache
         tracer.warn = self.warn
 
-        if hasattr(tracer, 'concur_id_func'):
+        if hasattr(tracer, "concur_id_func"):
             tracer.concur_id_func = self.concur_id_func
-        if hasattr(tracer, 'file_tracers'):
+        if hasattr(tracer, "file_tracers"):
             tracer.file_tracers = self.file_tracers
-        if hasattr(tracer, 'threading'):
+        if hasattr(tracer, "threading"):
             tracer.threading = self.threading
-        if hasattr(tracer, 'check_include'):
+        if hasattr(tracer, "check_include"):
             tracer.check_include = self.check_include
-        if hasattr(tracer, 'should_start_context'):
+        if hasattr(tracer, "should_start_context"):
             tracer.should_start_context = self.should_start_context
-        if hasattr(tracer, 'switch_context'):
+        if hasattr(tracer, "switch_context"):
             tracer.switch_context = self.switch_context
-        if hasattr(tracer, 'disable_plugin'):
+        if hasattr(tracer, "disable_plugin"):
             tracer.disable_plugin = self.disable_plugin
 
         fn = tracer.start()
@@ -367,7 +357,7 @@ class Collector:
             tracer.stop()
             stats = tracer.get_stats()
             if stats:
-                print("\nCoverage.py tracer stats:")
+                print(f"\nCoverage.py {tracer.__class__.__name__} stats:")
                 for k, v in human_sorted_items(stats.items()):
                     print(f"{k:>20}: {v}")
         if self.threading:
@@ -419,7 +409,7 @@ class Collector:
         plugin._coverage_enabled = False
         disposition.trace = False
 
-    @functools.cache          # pylint: disable=method-cache-max-size-none
+    @functools.cache  # pylint: disable=method-cache-max-size-none
     def cached_mapped_file(self, filename: str) -> str:
         """A locally cached version of file names mapped through file_mapper."""
         return self.file_mapper(filename)
@@ -431,14 +421,14 @@ class Collector:
         # in other threads. We try three times in case of concurrent
         # access, hoping to get a clean copy.
         runtime_err = None
-        for _ in range(3):                      # pragma: part covered
+        for _ in range(3):  # pragma: part covered
             try:
                 items = list(d.items())
-            except RuntimeError as ex:          # pragma: cant happen
+            except RuntimeError as ex:  # pragma: cant happen
                 runtime_err = ex
             else:
                 break
-        else:                                   # pragma: cant happen
+        else:  # pragma: cant happen
             assert isinstance(runtime_err, Exception)
             raise runtime_err
 
@@ -488,8 +478,7 @@ class Collector:
             self.covdata.add_lines(self.mapped_file_dict(line_data))
 
         file_tracers = {
-            k: v for k, v in self.file_tracers.items()
-            if v not in self.disabled_plugins
+            k: v for k, v in self.file_tracers.items() if v not in self.disabled_plugins
         }
         self.covdata.add_file_tracers(self.mapped_file_dict(file_tracers))
 

coverage/config.py

@@ -5,24 +5,27 @@
 
 from __future__ import annotations
 
+import base64
 import collections
 import configparser
 import copy
+import json
 import os
 import os.path
 import re
-
-from typing import (
-    Any, Callable, Union,
-)
 from collections.abc import Iterable
+from typing import Any, Callable, Final, Mapping
 
 from coverage.exceptions import ConfigError
-from coverage.misc import isolate_module, human_sorted_items, substitute_variables
+from coverage.misc import human_sorted_items, isolate_module, substitute_variables
 from coverage.tomlconfig import TomlConfigParser, TomlDecodeError
 from coverage.types import (
-    TConfigurable, TConfigSectionIn, TConfigValueIn, TConfigSectionOut,
-    TConfigValueOut, TPluginConfig,
+    TConfigSectionIn,
+    TConfigSectionOut,
+    TConfigurable,
+    TConfigValueIn,
+    TConfigValueOut,
+    TPluginConfig,
 )
 
 os = isolate_module(os)
@@ -44,7 +47,7 @@ class HandyConfigParser(configparser.ConfigParser):
         if our_file:
             self.section_prefixes.append("")
 
-    def read( # type: ignore[override]
+    def read(  # type: ignore[override]
         self,
         filenames: Iterable[str],
         encoding_unused: str | None = None,
@@ -61,16 +64,16 @@ class HandyConfigParser(configparser.ConfigParser):
                 return real_section
         return None
 
-    def has_option(self, section: str, option: str) -> bool:
+    def has_option(self, section: str, option: str) -> bool:  # type: ignore[override]
         real_section = self.real_section(section)
         if real_section is not None:
             return super().has_option(real_section, option)
         return False
 
-    def has_section(self, section: str) -> bool:
+    def has_section(self, section: str) -> bool:  # type: ignore[override]
         return bool(self.real_section(section))
 
-    def options(self, section: str) -> list[str]:
+    def options(self, section: str) -> list[str]:  # type: ignore[override]
         real_section = self.real_section(section)
         if real_section is not None:
             return super().options(real_section)
@@ -83,7 +86,7 @@ class HandyConfigParser(configparser.ConfigParser):
             d[opt] = self.get(section, opt)
         return d
 
-    def get(self, section: str, option: str, *args: Any, **kwargs: Any) -> str: # type: ignore
+    def get(self, section: str, option: str, *args: Any, **kwargs: Any) -> str:  # type: ignore
         """Get a value, replacing environment variables also.
 
         The arguments are the same as `ConfigParser.get`, but in the found
@@ -104,6 +107,11 @@ class HandyConfigParser(configparser.ConfigParser):
         v = substitute_variables(v, os.environ)
         return v
 
+    def getfile(self, section: str, option: str) -> str:
+        """Fix up a file path setting."""
+        path = self.get(section, option)
+        return process_file_value(path)
+
     def getlist(self, section: str, option: str) -> list[str]:
         """Read a list of strings.
 
@@ -132,26 +140,17 @@ class HandyConfigParser(configparser.ConfigParser):
 
         """
         line_list = self.get(section, option)
-        value_list = []
-        for value in line_list.splitlines():
-            value = value.strip()
-            try:
-                re.compile(value)
-            except re.error as e:
-                raise ConfigError(
-                    f"Invalid [{section}].{option} value {value!r}: {e}",
-                ) from e
-            if value:
-                value_list.append(value)
-        return value_list
+        return process_regexlist(section, option, line_list.splitlines())
 
 
-TConfigParser = Union[HandyConfigParser, TomlConfigParser]
+TConfigParser = HandyConfigParser | TomlConfigParser
 
 
 # The default line exclusion regexes.
 DEFAULT_EXCLUDE = [
     r"#\s*(pragma|PRAGMA)[:\s]?\s*(no|NO)\s*(cover|COVER)",
+    r"^\s*(((async )?def .*?)?\)(\s*->.*?)?:\s*)?\.\.\.\s*(#|$)",
+    r"if (typing\.)?TYPE_CHECKING:",
 ]
 
 # The default partial branch regexes, to be modified by the user.
@@ -175,6 +174,7 @@ class CoverageConfig(TConfigurable, TPluginConfig):
     operation of coverage.py.
 
     """
+
     # pylint: disable=too-many-instance-attributes
 
     def __init__(self) -> None:
@@ -197,6 +197,7 @@ class CoverageConfig(TConfigurable, TPluginConfig):
         self.command_line: str | None = None
         self.concurrency: list[str] = []
         self.context: str | None = None
+        self.core: str | None = None
         self.cover_pylib = False
         self.data_file = ".coverage"
         self.debug: list[str] = []
@@ -204,6 +205,7 @@ class CoverageConfig(TConfigurable, TPluginConfig):
         self.disable_warnings: list[str] = []
         self.dynamic_context: str | None = None
         self.parallel = False
+        self.patch: list[str] = []
         self.plugins: list[str] = []
         self.relative_files = False
         self.run_include: list[str] = []
@@ -211,6 +213,7 @@ class CoverageConfig(TConfigurable, TPluginConfig):
         self.sigterm = False
         self.source: list[str] | None = None
         self.source_pkgs: list[str] = []
+        self.source_dirs: list[str] = []
         self.timid = False
         self._crash: str | None = None
 
@@ -225,6 +228,7 @@ class CoverageConfig(TConfigurable, TPluginConfig):
         self.report_omit: list[str] | None = None
         self.partial_always_list = DEFAULT_PARTIAL_ALWAYS[:]
         self.partial_list = DEFAULT_PARTIAL[:]
+        self.partial_also: list[str] = []
         self.precision = 0
         self.report_contexts: list[str] | None = None
         self.show_missing = False
@@ -260,9 +264,25 @@ class CoverageConfig(TConfigurable, TPluginConfig):
         self.plugin_options: dict[str, TConfigSectionOut] = {}
 
     MUST_BE_LIST = {
-        "debug", "concurrency", "plugins",
-        "report_omit", "report_include",
-        "run_omit", "run_include",
+        "debug",
+        "concurrency",
+        "plugins",
+        "report_omit",
+        "report_include",
+        "run_omit",
+        "run_include",
+        "patch",
+    }
+
+    # File paths to make absolute during serialization.
+    # The pairs are (config_key, must_exist).
+    SERIALIZE_ABSPATH = {
+        ("data_file", False),
+        ("debug_file", False),
+        # `source` can be directories or modules, so don't abspath it if it
+        # doesn't exist.
+        ("source", True),
+        ("source_dirs", False),
     }
 
     def from_args(self, **kwargs: TConfigValueIn) -> None:
@@ -325,7 +345,9 @@ class CoverageConfig(TConfigurable, TPluginConfig):
                 for unknown in set(cp.options(section)) - options:
                     warn(
                         "Unrecognized option '[{}] {}=' in config file {}".format(
-                            real_section, unknown, filename,
+                            real_section,
+                            unknown,
+                            filename,
                         ),
                     )
 
@@ -360,7 +382,16 @@ class CoverageConfig(TConfigurable, TPluginConfig):
         """Return a copy of the configuration."""
         return copy.deepcopy(self)
 
-    CONCURRENCY_CHOICES = {"thread", "gevent", "greenlet", "eventlet", "multiprocessing"}
+    CONCURRENCY_CHOICES: Final[set[str]] = {
+        "thread",
+        "gevent",
+        "greenlet",
+        "eventlet",
+        "multiprocessing",
+    }
+
+    # Mutually exclusive concurrency settings.
+    LIGHT_THREADS = {"greenlet", "eventlet", "gevent"}
 
     CONFIG_FILE_OPTIONS = [
         # These are *args for _set_attr_from_config_option:
@@ -370,19 +401,21 @@ class CoverageConfig(TConfigurable, TPluginConfig):
         #   where is the section:name to read from the configuration file.
         #   type_ is the optional type to apply, by using .getTYPE to read the
         #       configuration value from the file.
-
+        #
         # [run]
         ("branch", "run:branch", "boolean"),
         ("command_line", "run:command_line"),
         ("concurrency", "run:concurrency", "list"),
         ("context", "run:context"),
+        ("core", "run:core"),
         ("cover_pylib", "run:cover_pylib", "boolean"),
-        ("data_file", "run:data_file"),
+        ("data_file", "run:data_file", "file"),
         ("debug", "run:debug", "list"),
-        ("debug_file", "run:debug_file"),
+        ("debug_file", "run:debug_file", "file"),
         ("disable_warnings", "run:disable_warnings", "list"),
         ("dynamic_context", "run:dynamic_context"),
         ("parallel", "run:parallel", "boolean"),
+        ("patch", "run:patch", "list"),
         ("plugins", "run:plugins", "list"),
         ("relative_files", "run:relative_files", "boolean"),
         ("run_include", "run:include", "list"),
@@ -390,9 +423,10 @@ class CoverageConfig(TConfigurable, TPluginConfig):
         ("sigterm", "run:sigterm", "boolean"),
         ("source", "run:source", "list"),
         ("source_pkgs", "run:source_pkgs", "list"),
+        ("source_dirs", "run:source_dirs", "list"),
         ("timid", "run:timid", "boolean"),
         ("_crash", "run:_crash"),
-
+        #
         # [report]
         ("exclude_list", "report:exclude_lines", "regexlist"),
         ("exclude_also", "report:exclude_also", "regexlist"),
@@ -402,6 +436,7 @@ class CoverageConfig(TConfigurable, TPluginConfig):
         ("include_namespace_packages", "report:include_namespace_packages", "boolean"),
         ("partial_always_list", "report:partial_branches_always", "regexlist"),
         ("partial_list", "report:partial_branches", "regexlist"),
+        ("partial_also", "report:partial_also", "regexlist"),
         ("precision", "report:precision", "int"),
         ("report_contexts", "report:contexts", "list"),
         ("report_include", "report:include", "list"),
@@ -410,27 +445,27 @@ class CoverageConfig(TConfigurable, TPluginConfig):
         ("skip_covered", "report:skip_covered", "boolean"),
         ("skip_empty", "report:skip_empty", "boolean"),
         ("sort", "report:sort"),
-
+        #
         # [html]
         ("extra_css", "html:extra_css"),
-        ("html_dir", "html:directory"),
+        ("html_dir", "html:directory", "file"),
         ("html_skip_covered", "html:skip_covered", "boolean"),
         ("html_skip_empty", "html:skip_empty", "boolean"),
         ("html_title", "html:title"),
         ("show_contexts", "html:show_contexts", "boolean"),
-
+        #
         # [xml]
-        ("xml_output", "xml:output"),
+        ("xml_output", "xml:output", "file"),
         ("xml_package_depth", "xml:package_depth", "int"),
-
+        #
         # [json]
-        ("json_output", "json:output"),
+        ("json_output", "json:output", "file"),
         ("json_pretty_print", "json:pretty_print", "boolean"),
         ("json_show_contexts", "json:show_contexts", "boolean"),
-
+        #
         # [lcov]
-        ("lcov_output", "lcov:output"),
-        ("lcov_line_checksums", "lcov:line_checksums", "boolean")
+        ("lcov_output", "lcov:output", "file"),
+        ("lcov_line_checksums", "lcov:line_checksums", "boolean"),
     ]
 
     def _set_attr_from_config_option(
@@ -447,7 +482,7 @@ class CoverageConfig(TConfigurable, TPluginConfig):
         """
         section, option = where.split(":")
         if cp.has_option(section, option):
-            method = getattr(cp, "get" + type_)
+            method = getattr(cp, f"get{type_}")
             setattr(self, attr, method(section, option))
             return True
         return False
@@ -468,7 +503,13 @@ class CoverageConfig(TConfigurable, TPluginConfig):
         """
         # Special-cased options.
         if option_name == "paths":
-            self.paths = value  # type: ignore[assignment]
+            # This is ugly, but type-checks and ensures the values are close
+            # to right.
+            self.paths = {}
+            assert isinstance(value, Mapping)
+            for k, v in value.items():
+                assert isinstance(v, Iterable)
+                self.paths[k] = list(v)
             return
 
         # Check all the hard-coded options.
@@ -481,7 +522,7 @@ class CoverageConfig(TConfigurable, TPluginConfig):
         # See if it's a plugin option.
         plugin_name, _, key = option_name.partition(":")
         if key and plugin_name in self.plugins:
-            self.plugin_options.setdefault(plugin_name, {})[key] = value # type: ignore[index]
+            self.plugin_options.setdefault(plugin_name, {})[key] = value  # type: ignore[index]
             return
 
         # If we get here, we didn't find the option.
@@ -499,7 +540,7 @@ class CoverageConfig(TConfigurable, TPluginConfig):
         """
         # Special-cased options.
         if option_name == "paths":
-            return self.paths  # type: ignore[return-value]
+            return self.paths
 
         # Check all the hard-coded options.
         for option_spec in self.CONFIG_FILE_OPTIONS:
@@ -515,26 +556,82 @@ class CoverageConfig(TConfigurable, TPluginConfig):
         # If we get here, we didn't find the option.
         raise ConfigError(f"No such option: {option_name!r}")
 
-    def post_process_file(self, path: str) -> str:
-        """Make final adjustments to a file path to make it usable."""
-        return os.path.expanduser(path)
-
     def post_process(self) -> None:
         """Make final adjustments to settings to make them usable."""
-        self.data_file = self.post_process_file(self.data_file)
-        self.html_dir = self.post_process_file(self.html_dir)
-        self.xml_output = self.post_process_file(self.xml_output)
-        self.paths = {
-            k: [self.post_process_file(f) for f in v]
-            for k, v in self.paths.items()
-        }
+        self.paths = {k: [process_file_value(f) for f in v] for k, v in self.paths.items()}
+
         self.exclude_list += self.exclude_also
+        self.partial_list += self.partial_also
+
+        if "subprocess" in self.patch:
+            self.parallel = True
+
+        # We can handle a few concurrency options here, but only one at a time.
+        concurrencies = set(self.concurrency)
+        unknown = concurrencies - self.CONCURRENCY_CHOICES
+        if unknown:
+            show = ", ".join(sorted(unknown))
+            raise ConfigError(f"Unknown concurrency choices: {show}")
+        light_threads = concurrencies & self.LIGHT_THREADS
+        if len(light_threads) > 1:
+            show = ", ".join(sorted(light_threads))
+            raise ConfigError(f"Conflicting concurrency settings: {show}")
 
     def debug_info(self) -> list[tuple[str, Any]]:
         """Make a list of (name, value) pairs for writing debug info."""
-        return human_sorted_items(
-            (k, v) for k, v in self.__dict__.items() if not k.startswith("_")
-        )
+        return human_sorted_items((k, v) for k, v in self.__dict__.items() if not k.startswith("_"))
+
+    def serialize(self) -> str:
+        """Convert to a string that can be ingested with `deserialize`.
+
+        File paths used by `coverage run` are made absolute to ensure the
+        deserialized config will refer to the same files.
+        """
+        data = {k: v for k, v in self.__dict__.items() if not k.startswith("_")}
+        for k, must_exist in self.SERIALIZE_ABSPATH:
+            abs_fn = abs_path_if_exists if must_exist else os.path.abspath
+            v = data[k]
+            if isinstance(v, list):
+                v = list(map(abs_fn, v))
+            elif isinstance(v, str):
+                v = abs_fn(v)
+            data[k] = v
+        return base64.b64encode(json.dumps(data).encode()).decode()
+
+    @classmethod
+    def deserialize(cls, config_str: str) -> CoverageConfig:
+        """Take a string from `serialize`, and make a CoverageConfig."""
+        data = json.loads(base64.b64decode(config_str.encode()).decode())
+        config = cls()
+        config.__dict__.update(data)
+        return config
+
+
+def process_file_value(path: str) -> str:
+    """Make adjustments to a file path to make it usable."""
+    return os.path.expanduser(path)
+
+
+def abs_path_if_exists(path: str) -> str:
+    """os.path.abspath, but only if the path exists."""
+    if os.path.exists(path):
+        return os.path.abspath(path)
+    else:
+        return path
+
+
+def process_regexlist(name: str, option: str, values: list[str]) -> list[str]:
+    """Check the values in a regex list and keep the non-blank ones."""
+    value_list = []
+    for value in values:
+        value = value.strip()
+        try:
+            re.compile(value)
+        except re.error as e:
+            raise ConfigError(f"Invalid [{name}].{option} value {value!r}: {e}") from e
+        if value:
+            value_list.append(value)
+    return value_list
 
 
 def config_files_to_try(config_file: bool | str) -> list[tuple[str, bool, bool]]:
@@ -548,7 +645,7 @@ def config_files_to_try(config_file: bool | str) -> list[tuple[str, bool, bool]]
     # True, so make it so.
     if config_file == ".coveragerc":
         config_file = True
-    specified_file = (config_file is not True)
+    specified_file = config_file is not True
     if not specified_file:
         # No file was specified. Check COVERAGE_RCFILE.
         rcfile = os.getenv("COVERAGE_RCFILE")
@@ -607,11 +704,18 @@ def read_coverage_config(
     env_data_file = os.getenv("COVERAGE_FILE")
     if env_data_file:
         config.data_file = env_data_file
+
     # $set_env.py: COVERAGE_DEBUG - Debug options: https://coverage.rtfd.io/cmd.html#debug
     debugs = os.getenv("COVERAGE_DEBUG")
     if debugs:
         config.debug.extend(d.strip() for d in debugs.split(","))
 
+    # Read the COVERAGE_CORE environment variable for backward compatibility,
+    # and because we use it in the test suite to pick a specific core.
+    env_core = os.getenv("COVERAGE_CORE")
+    if env_core:
+        config.core = env_core
+
     # 4) from constructor arguments:
     config.from_args(**kwargs)
 

coverage/context.py

@@ -5,9 +5,8 @@
 
 from __future__ import annotations
 
-from types import FrameType
-from typing import cast
 from collections.abc import Sequence
+from types import FrameType
 
 from coverage.types import TShouldStartContextFn
 
@@ -65,11 +64,11 @@ def qualname_from_frame(frame: FrameType) -> str | None:
         func = frame.f_globals.get(fname)
         if func is None:
             return None
-        return cast(str, func.__module__ + "." + fname)
+        return f"{func.__module__}.{fname}"
 
     func = getattr(method, "__func__", None)
     if func is None:
         cls = self.__class__
-        return cast(str, cls.__module__ + "." + cls.__name__ + "." + fname)
+        return f"{cls.__module__}.{cls.__name__}.{fname}"
 
-    return cast(str, func.__module__ + "." + func.__qualname__)
+    return f"{func.__module__}.{func.__qualname__}"