coverage 7.10.6__cp311-cp311-win32.whl → 7.11.0__cp311-cp311-win32.whl

coverage/parser.py

@@ -10,7 +10,6 @@ import collections
 import functools
 import os
 import re
-import sys
 import token
 import tokenize
 from collections.abc import Iterable, Sequence
@@ -299,10 +298,9 @@ class PythonParser:
         aaa = AstArcAnalyzer(self.filename, self._ast_root, self.raw_statements, self._multiline)
         aaa.analyze()
         arcs = aaa.arcs
-        if env.PYBEHAVIOR.exit_through_with:
-            self._with_jump_fixers = aaa.with_jump_fixers()
-            if self._with_jump_fixers:
-                arcs = self.fix_with_jumps(arcs)
+        self._with_jump_fixers = aaa.with_jump_fixers()
+        if self._with_jump_fixers:
+            arcs = self.fix_with_jumps(arcs)
 
         self._all_arcs = set()
         for l1, l2 in arcs:
@@ -451,33 +449,11 @@ class ByteParser:
     def _line_numbers(self) -> Iterable[TLineNo]:
         """Yield the line numbers possible in this code object.
 
-        Uses co_lnotab described in Python/compile.c to find the
-        line numbers.  Produces a sequence: l0, l1, ...
+        Uses co_lines() to produce a sequence: l0, l1, ...
         """
-        if hasattr(self.code, "co_lines"):
-            # PYVERSIONS: new in 3.10
-            for _, _, line in self.code.co_lines():
-                if line:
-                    yield line
-        else:
-            # Adapted from dis.py in the standard library.
-            byte_increments = self.code.co_lnotab[0::2]
-            line_increments = self.code.co_lnotab[1::2]
-
-            last_line_num: TLineNo | None = None
-            line_num = self.code.co_firstlineno
-            byte_num = 0
-            for byte_incr, line_incr in zip(byte_increments, line_increments):
-                if byte_incr:
-                    if line_num != last_line_num:
-                        yield line_num
-                        last_line_num = line_num
-                    byte_num += byte_incr
-                if line_incr >= 0x80:
-                    line_incr -= 0x100
-                line_num += line_incr
-            if line_num != last_line_num:
-                yield line_num
+        for _, _, line in self.code.co_lines():
+            if line:
+                yield line
 
     def _find_statements(self) -> Iterable[TLineNo]:
         """Find the statements in `self.code`.
@@ -650,19 +626,6 @@ class TryBlock(Block):
         return True
 
 
-class NodeList(ast.AST):
-    """A synthetic fictitious node, containing a sequence of nodes.
-
-    This is used when collapsing optimized if-statements, to represent the
-    unconditional execution of one of the clauses.
-
-    """
-
-    def __init__(self, body: Sequence[ast.AST]) -> None:
-        self.body = body
-        self.lineno = body[0].lineno  # type: ignore[attr-defined]
-
-
 # TODO: Shouldn't the cause messages join with "and" instead of "or"?
 
 
@@ -673,20 +636,22 @@ def is_constant_test_expr(node: ast.AST) -> tuple[bool, bool]:
     handle the kinds of constant expressions people might actually use.
 
     """
-    if isinstance(node, ast.Constant):
-        return True, bool(node.value)
-    elif isinstance(node, ast.Name):
-        if node.id in ["True", "False", "None", "__debug__"]:
-            return True, eval(node.id)  # pylint: disable=eval-used
-    elif isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.Not):
-        is_constant, val = is_constant_test_expr(node.operand)
-        return is_constant, not val
-    elif isinstance(node, ast.BoolOp):
-        rets = [is_constant_test_expr(v) for v in node.values]
-        is_constant = all(is_const for is_const, _ in rets)
-        if is_constant:
-            op = any if isinstance(node.op, ast.Or) else all
-            return True, op(v for _, v in rets)
+    match node:
+        case ast.Constant():
+            return True, bool(node.value)
+        case ast.Name():
+            if node.id in ["True", "False", "None", "__debug__"]:
+                return True, eval(node.id)  # pylint: disable=eval-used
+        case ast.UnaryOp():
+            if isinstance(node.op, ast.Not):
+                is_constant, val = is_constant_test_expr(node.operand)
+                return is_constant, not val
+        case ast.BoolOp():
+            rets = [is_constant_test_expr(v) for v in node.values]
+            is_constant = all(is_const for is_const, _ in rets)
+            if is_constant:
+                op = any if isinstance(node.op, ast.Or) else all
+                return True, op(v for _, v in rets)
     return False, False
 
 
@@ -890,14 +855,8 @@ class AstArcAnalyzer:
         else:
             return node.lineno
 
-    def _line__Module(self, node: ast.Module) -> TLineNo:
-        if env.PYBEHAVIOR.module_firstline_1:
-            return 1
-        elif node.body:
-            return self.line_for_node(node.body[0])
-        else:
-            # Empty modules have no line number, they always start at 1.
-            return 1
+    def _line__Module(self, node: ast.Module) -> TLineNo:  # pylint: disable=unused-argument
+        return 1
 
     # The node types that just flow to the next node with no complications.
     OK_TO_DEFAULT = {
@@ -982,98 +941,12 @@ class AstArcAnalyzer:
         for body_node in body:
             lineno = self.line_for_node(body_node)
             if lineno not in self.statements:
-                maybe_body_node = self.find_non_missing_node(body_node)
-                if maybe_body_node is None:
-                    continue
-                body_node = maybe_body_node
-                lineno = self.line_for_node(body_node)
+                continue
             for prev_start in prev_starts:
                 self.add_arc(prev_start.lineno, lineno, prev_start.cause)
             prev_starts = self.node_exits(body_node)
         return prev_starts
 
-    def find_non_missing_node(self, node: ast.AST) -> ast.AST | None:
-        """Search `node` looking for a child that has not been optimized away.
-
-        This might return the node you started with, or it will work recursively
-        to find a child node in self.statements.
-
-        Returns a node, or None if none of the node remains.
-
-        """
-        # This repeats work just done in process_body, but this duplication
-        # means we can avoid a function call in the 99.9999% case of not
-        # optimizing away statements.
-        lineno = self.line_for_node(node)
-        if lineno in self.statements:
-            return node
-
-        missing_fn = cast(
-            Optional[Callable[[ast.AST], Optional[ast.AST]]],
-            getattr(self, f"_missing__{node.__class__.__name__}", None),
-        )
-        if missing_fn is not None:
-            ret_node = missing_fn(node)
-        else:
-            ret_node = None
-        return ret_node
-
-    # Missing nodes: _missing__*
-    #
-    # Entire statements can be optimized away by Python. They will appear in
-    # the AST, but not the bytecode.  These functions are called (by
-    # find_non_missing_node) to find a node to use instead of the missing
-    # node.  They can return None if the node should truly be gone.
-
-    def _missing__If(self, node: ast.If) -> ast.AST | None:
-        # If the if-node is missing, then one of its children might still be
-        # here, but not both. So return the first of the two that isn't missing.
-        # Use a NodeList to hold the clauses as a single node.
-        non_missing = self.find_non_missing_node(NodeList(node.body))
-        if non_missing:
-            return non_missing
-        if node.orelse:
-            return self.find_non_missing_node(NodeList(node.orelse))
-        return None
-
-    def _missing__NodeList(self, node: NodeList) -> ast.AST | None:
-        # A NodeList might be a mixture of missing and present nodes. Find the
-        # ones that are present.
-        non_missing_children = []
-        for child in node.body:
-            maybe_child = self.find_non_missing_node(child)
-            if maybe_child is not None:
-                non_missing_children.append(maybe_child)
-
-        # Return the simplest representation of the present children.
-        if not non_missing_children:
-            return None
-        if len(non_missing_children) == 1:
-            return non_missing_children[0]
-        return NodeList(non_missing_children)
-
-    def _missing__While(self, node: ast.While) -> ast.AST | None:
-        body_nodes = self.find_non_missing_node(NodeList(node.body))
-        if not body_nodes:
-            return None
-        # Make a synthetic While-true node.
-        new_while = ast.While()  # type: ignore[call-arg]
-        new_while.lineno = body_nodes.lineno  # type: ignore[attr-defined]
-        new_while.test = ast.Name()  # type: ignore[call-arg]
-        new_while.test.lineno = body_nodes.lineno  # type: ignore[attr-defined]
-        new_while.test.id = "True"
-        assert hasattr(body_nodes, "body")
-        new_while.body = body_nodes.body
-        new_while.orelse = []
-        return new_while
-
-    # In the fullness of time, these might be good tests to write:
-    #   while EXPR:
-    #   while False:
-    #   listcomps hidden deep in other expressions
-    #   listcomps hidden in lists: x = [[i for i in range(10)]]
-    #   nested function definitions
-
     # Exit processing: process_*_exits
     #
     # These functions process the four kinds of jump exits: break, continue,
@@ -1192,41 +1065,34 @@ class AstArcAnalyzer:
             exits |= self.process_body(node.orelse, from_start=from_start)
         return exits
 
-    if sys.version_info >= (3, 10):
-
-        def _handle__Match(self, node: ast.Match) -> set[ArcStart]:
-            start = self.line_for_node(node)
-            last_start = start
-            exits = set()
-            for case in node.cases:
-                case_start = self.line_for_node(case.pattern)
-                self.add_arc(last_start, case_start, "the pattern on line {lineno} always matched")
-                from_start = ArcStart(
-                    case_start,
-                    cause="the pattern on line {lineno} never matched",
-                )
-                exits |= self.process_body(case.body, from_start=from_start)
-                last_start = case_start
-
-            # case is now the last case, check for wildcard match.
-            pattern = case.pattern  # pylint: disable=undefined-loop-variable
-            while isinstance(pattern, ast.MatchOr):
-                pattern = pattern.patterns[-1]
-            while isinstance(pattern, ast.MatchAs) and pattern.pattern is not None:
-                pattern = pattern.pattern
-            had_wildcard = (
-                isinstance(pattern, ast.MatchAs) and pattern.pattern is None and case.guard is None  # pylint: disable=undefined-loop-variable
+    def _handle__Match(self, node: ast.Match) -> set[ArcStart]:
+        start = self.line_for_node(node)
+        last_start = start
+        exits = set()
+        for case in node.cases:
+            case_start = self.line_for_node(case.pattern)
+            self.add_arc(last_start, case_start, "the pattern on line {lineno} always matched")
+            from_start = ArcStart(
+                case_start,
+                cause="the pattern on line {lineno} never matched",
             )
+            exits |= self.process_body(case.body, from_start=from_start)
+            last_start = case_start
+
+        # case is now the last case, check for wildcard match.
+        pattern = case.pattern  # pylint: disable=undefined-loop-variable
+        while isinstance(pattern, ast.MatchOr):
+            pattern = pattern.patterns[-1]
+        while isinstance(pattern, ast.MatchAs) and pattern.pattern is not None:
+            pattern = pattern.pattern
+        had_wildcard = (
+            isinstance(pattern, ast.MatchAs) and pattern.pattern is None and case.guard is None  # pylint: disable=undefined-loop-variable
+        )
 
-            if not had_wildcard:
-                exits.add(
-                    ArcStart(case_start, cause="the pattern on line {lineno} always matched"),
-                )
-            return exits
-
-    def _handle__NodeList(self, node: NodeList) -> set[ArcStart]:
-        start = self.line_for_node(node)
-        exits = self.process_body(node.body, from_start=ArcStart(start))
+        if not had_wildcard:
+            exits.add(
+                ArcStart(case_start, cause="the pattern on line {lineno} always matched"),
+            )
         return exits
 
     def _handle__Raise(self, node: ast.Raise) -> set[ArcStart]:
@@ -1301,13 +1167,6 @@ class AstArcAnalyzer:
     def _handle__While(self, node: ast.While) -> set[ArcStart]:
         start = to_top = self.line_for_node(node.test)
         constant_test, _ = is_constant_test_expr(node.test)
-        top_is_body0 = False
-        if constant_test:
-            top_is_body0 = True
-        if env.PYBEHAVIOR.keep_constant_test:
-            top_is_body0 = False
-        if top_is_body0:
-            to_top = self.line_for_node(node.body[0])
         self.block_stack.append(LoopBlock(start=to_top))
         from_start = ArcStart(start, cause="the condition on line {lineno} was never true")
         exits = self.process_body(node.body, from_start=from_start)
@@ -1332,22 +1191,20 @@ class AstArcAnalyzer:
             starts = [self.line_for_node(item.context_expr) for item in node.items]
         else:
             starts = [self.line_for_node(node)]
-        if env.PYBEHAVIOR.exit_through_with:
-            for start in starts:
-                self.current_with_starts.add(start)
-                self.all_with_starts.add(start)
+        for start in starts:
+            self.current_with_starts.add(start)
+            self.all_with_starts.add(start)
 
         exits = self.process_body(node.body, from_start=ArcStart(starts[-1]))
 
-        if env.PYBEHAVIOR.exit_through_with:
-            start = starts[-1]
-            self.current_with_starts.remove(start)
-            with_exit = {ArcStart(start)}
-            if exits:
-                for xit in exits:
-                    self.add_arc(xit.lineno, start)
-                    self.with_exits.add((xit.lineno, start))
-                exits = with_exit
+        start = starts[-1]
+        self.current_with_starts.remove(start)
+        with_exit = {ArcStart(start)}
+        if exits:
+            for xit in exits:
+                self.add_arc(xit.lineno, start)
+                self.with_exits.add((xit.lineno, start))
+            exits = with_exit
 
         return exits
 

coverage/patch.py

@@ -32,20 +32,21 @@ def apply_patches(
     """Apply invasive patches requested by `[run] patch=`."""
     debug = debug if debug.should("patch") else DevNullDebug()
     for patch in sorted(set(config.patch)):
-        if patch == "_exit":
-            _patch__exit(cov, debug)
+        match patch:
+            case "_exit":
+                _patch__exit(cov, debug)
 
-        elif patch == "execv":
-            _patch_execv(cov, config, debug)
+            case "execv":
+                _patch_execv(cov, config, debug)
 
-        elif patch == "fork":
-            _patch_fork(debug)
+            case "fork":
+                _patch_fork(debug)
 
-        elif patch == "subprocess":
-            _patch_subprocess(config, debug, make_pth_file)
+            case "subprocess":
+                _patch_subprocess(config, debug, make_pth_file)
 
-        else:
-            raise ConfigError(f"Unknown patch {patch!r}")
+            case _:
+                raise ConfigError(f"Unknown patch {patch!r}")
 
 
 def _patch__exit(cov: Coverage, debug: TDebugCtl) -> None:

coverage/phystokens.py

@@ -95,7 +95,7 @@ def find_soft_key_lines(source: str) -> set[TLineNo]:
     soft_key_lines: set[TLineNo] = set()
 
     for node in ast.walk(ast.parse(source)):
-        if sys.version_info >= (3, 10) and isinstance(node, ast.Match):
+        if isinstance(node, ast.Match):
             soft_key_lines.add(node.lineno)
             for case in node.cases:
                 soft_key_lines.add(case.pattern.lineno)
@@ -128,10 +128,7 @@ def source_token_lines(source: str) -> TSourceTokenLines:
     source = source.expandtabs(8).replace("\r\n", "\n")
     tokgen = generate_tokens(source)
 
-    if env.PYBEHAVIOR.soft_keywords:
-        soft_key_lines = find_soft_key_lines(source)
-    else:
-        soft_key_lines = set()
+    soft_key_lines = find_soft_key_lines(source)
 
     for ttype, ttext, (sline, scol), (_, ecol), _ in _phys_tokens(tokgen):
         mark_start = True
@@ -157,7 +154,7 @@ def source_token_lines(source: str) -> TSourceTokenLines:
                     if keyword.iskeyword(ttext):
                         # Hard keywords are always keywords.
                         tok_class = "key"
-                    elif env.PYBEHAVIOR.soft_keywords and keyword.issoftkeyword(ttext):
+                    elif keyword.issoftkeyword(ttext):
                         # Soft keywords appear at the start of their line.
                         if len(line) == 0:
                             is_start_of_line = True

coverage/python.py

@@ -61,7 +61,7 @@ def get_python_source(filename: str) -> str:
             break
     else:
         # Couldn't find source.
-        raise NoSource(f"No source for code: '{filename}'.")
+        raise NoSource(f"No source for code: '{filename}'.", slug="no-source")
 
     # Replace \f because of http://bugs.python.org/issue19035
     source_bytes = source_bytes.replace(b"\f", b" ")

coverage/results.py

@@ -7,7 +7,7 @@ from __future__ import annotations
 
 import collections
 import dataclasses
-from collections.abc import Container, Iterable
+from collections.abc import Iterable
 from typing import TYPE_CHECKING
 
 from coverage.exceptions import ConfigError
@@ -113,45 +113,6 @@ class Analysis:
             n_missing_branches=n_missing_branches,
         )
 
-    def narrow(self, lines: Container[TLineNo]) -> Analysis:
-        """Create a narrowed Analysis.
-
-        The current analysis is copied to make a new one that only considers
-        the lines in `lines`.
-        """
-
-        statements = {lno for lno in self.statements if lno in lines}
-        excluded = {lno for lno in self.excluded if lno in lines}
-        executed = {lno for lno in self.executed if lno in lines}
-
-        if self.has_arcs:
-            arc_possibilities_set = {
-                (a, b) for a, b in self.arc_possibilities_set if a in lines or b in lines
-            }
-            arcs_executed_set = {
-                (a, b) for a, b in self.arcs_executed_set if a in lines or b in lines
-            }
-            exit_counts = {lno: num for lno, num in self.exit_counts.items() if lno in lines}
-            no_branch = {lno for lno in self.no_branch if lno in lines}
-        else:
-            arc_possibilities_set = set()
-            arcs_executed_set = set()
-            exit_counts = {}
-            no_branch = set()
-
-        return Analysis(
-            precision=self.precision,
-            filename=self.filename,
-            has_arcs=self.has_arcs,
-            statements=statements,
-            excluded=excluded,
-            executed=executed,
-            arc_possibilities_set=arc_possibilities_set,
-            arcs_executed_set=arcs_executed_set,
-            exit_counts=exit_counts,
-            no_branch=no_branch,
-        )
-
     def missing_formatted(self, branches: bool = False) -> str:
         """The missing line numbers, formatted nicely.
 
@@ -236,6 +197,104 @@ class Analysis:
         return stats
 
 
+TRegionLines = frozenset[TLineNo]
+
+
+class AnalysisNarrower:
+    """
+    For reducing an `Analysis` to a subset of its lines.
+
+    Originally this was a simpler method on Analysis, but that led to quadratic
+    behavior.  This class does the bulk of the work up-front to provide the
+    same results in linear time.
+
+    Create an AnalysisNarrower from an Analysis, bulk-add region lines to it
+    with `add_regions`, then individually request new narrowed Analysis objects
+    for each region with `narrow`.  Doing most of the work in limited calls to
+    `add_regions` lets us avoid poor performance.
+    """
+
+    # In this class, regions are represented by a frozenset of their lines.
+
+    def __init__(self, analysis: Analysis) -> None:
+        self.analysis = analysis
+        self.region2arc_possibilities: dict[TRegionLines, set[TArc]] = collections.defaultdict(set)
+        self.region2arc_executed: dict[TRegionLines, set[TArc]] = collections.defaultdict(set)
+        self.region2exit_counts: dict[TRegionLines, dict[TLineNo, int]] = collections.defaultdict(
+            dict
+        )
+
+    def add_regions(self, liness: Iterable[set[TLineNo]]) -> None:
+        """
+        Pre-process a number of sets of line numbers.  Later calls to `narrow`
+        with one of these sets will provide a narrowed Analysis.
+        """
+        if self.analysis.has_arcs:
+            line2region: dict[TLineNo, TRegionLines] = {}
+
+            for lines in liness:
+                fzlines = frozenset(lines)
+                for line in lines:
+                    line2region[line] = fzlines
+
+            def collect_arcs(
+                arc_set: set[TArc],
+                region2arcs: dict[TRegionLines, set[TArc]],
+            ) -> None:
+                for a, b in arc_set:
+                    if r := line2region.get(a):
+                        region2arcs[r].add((a, b))
+                    if r := line2region.get(b):
+                        region2arcs[r].add((a, b))
+
+            collect_arcs(self.analysis.arc_possibilities_set, self.region2arc_possibilities)
+            collect_arcs(self.analysis.arcs_executed_set, self.region2arc_executed)
+
+            for lno, num in self.analysis.exit_counts.items():
+                if r := line2region.get(lno):
+                    self.region2exit_counts[r][lno] = num
+
+    def narrow(self, lines: set[TLineNo]) -> Analysis:
+        """Create a narrowed Analysis.
+
+        The current analysis is copied to make a new one that only considers
+        the lines in `lines`.
+        """
+
+        # Technically, the set intersections in this method are still O(N**2)
+        # since this method is called N times, but they're very fast and moving
+        # them to `add_regions` won't avoid the quadratic time.
+
+        statements = self.analysis.statements & lines
+        excluded = self.analysis.excluded & lines
+        executed = self.analysis.executed & lines
+
+        if self.analysis.has_arcs:
+            fzlines = frozenset(lines)
+            arc_possibilities_set = self.region2arc_possibilities[fzlines]
+            arcs_executed_set = self.region2arc_executed[fzlines]
+            exit_counts = self.region2exit_counts[fzlines]
+            no_branch = self.analysis.no_branch & lines
+        else:
+            arc_possibilities_set = set()
+            arcs_executed_set = set()
+            exit_counts = {}
+            no_branch = set()
+
+        return Analysis(
+            precision=self.analysis.precision,
+            filename=self.analysis.filename,
+            has_arcs=self.analysis.has_arcs,
+            statements=statements,
+            excluded=excluded,
+            executed=executed,
+            arc_possibilities_set=arc_possibilities_set,
+            arcs_executed_set=arcs_executed_set,
+            exit_counts=exit_counts,
+            no_branch=no_branch,
+        )
+
+
 @dataclasses.dataclass
 class Numbers:
     """The numerical results of measuring coverage.

coverage/sqldata.py

@@ -706,9 +706,13 @@ class CoverageData:
                 )
             )
         if self._has_lines and other_data._has_arcs:
-            raise DataError("Can't combine branch coverage data with statement data")
+            raise DataError(
+                "Can't combine branch coverage data with statement data", slug="cant-combine"
+            )
         if self._has_arcs and other_data._has_lines:
-            raise DataError("Can't combine statement coverage data with branch data")
+            raise DataError(
+                "Can't combine statement coverage data with branch data", slug="cant-combine"
+            )
 
         map_path = map_path or (lambda p: p)
 

coverage/types.py

@@ -11,7 +11,7 @@ import os
 import pathlib
 from collections.abc import Iterable, Mapping
 from types import FrameType, ModuleType
-from typing import TYPE_CHECKING, Any, Callable, Optional, Protocol, Union
+from typing import TYPE_CHECKING, Any, Callable, Optional, Protocol
 
 if TYPE_CHECKING:
     from coverage.plugin import FileTracer
@@ -22,14 +22,10 @@ AnyCallable = Callable[..., Any]
 ## File paths
 
 # For arguments that are file paths:
-if TYPE_CHECKING:
-    FilePath = Union[str, os.PathLike[str]]
-else:
-    # PathLike < python3.9 doesn't support subscription
-    FilePath = Union[str, os.PathLike]
+FilePath = str | os.PathLike[str]
 # For testing FilePath arguments
 FilePathClasses = [str, pathlib.Path]
-FilePathType = Union[type[str], type[pathlib.Path]]
+FilePathType = type[str] | type[pathlib.Path]
 
 ## Python tracing
 
@@ -77,14 +73,14 @@ class TFileDisposition(Protocol):
 # - If measuring arcs in the C tracer, the values are sets of packed arcs (two
 #   line numbers combined into one integer).
 
-TTraceFileData = Union[set[TLineNo], set[TArc], set[int]]
+TTraceFileData = set[TLineNo] | set[TArc] | set[int]
 
 TTraceData = dict[str, TTraceFileData]
 
 # Functions passed into collectors.
 TShouldTraceFn = Callable[[str, FrameType], TFileDisposition]
 TCheckIncludeFn = Callable[[str, FrameType], bool]
-TShouldStartContextFn = Callable[[FrameType], Union[str, None]]
+TShouldStartContextFn = Callable[[FrameType], str | None]
 
 
 class Tracer(Protocol):
@@ -127,8 +123,8 @@ TCovKwargs = Any
 ## Configuration
 
 # One value read from a config file.
-TConfigValueIn = Optional[Union[bool, int, float, str, Iterable[str], Mapping[str, Iterable[str]]]]
-TConfigValueOut = Optional[Union[bool, int, float, str, list[str], dict[str, list[str]]]]
+TConfigValueIn = Optional[bool | int | float | str | Iterable[str] | Mapping[str, Iterable[str]]]
+TConfigValueOut = Optional[bool | int | float | str | list[str] | dict[str, list[str]]]
 # An entire config section, mapping option names to values.
 TConfigSectionIn = Mapping[str, TConfigValueIn]
 TConfigSectionOut = Mapping[str, TConfigValueOut]
@@ -169,7 +165,7 @@ class TPluginConfig(Protocol):
 
 ## Parsing
 
-TMorf = Union[ModuleType, str]
+TMorf = ModuleType | str
 
 TSourceTokenLines = Iterable[list[tuple[str, str]]]