sarj-python-lint 1.3.1__tar.gz → 1.4.0__tar.gz

{sarj_python_lint-1.3.1 → sarj_python_lint-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 1.3.1
+Version: 1.4.0
 Summary: Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults
 Project-URL: Homepage, https://code-standards.sarj.ai/rules/python/
 Project-URL: Documentation, https://code-standards.sarj.ai/rules/python/

{sarj_python_lint-1.3.1 → sarj_python_lint-1.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sarj-python-lint"
-version = "1.3.1"
+version = "1.4.0"
 description = "Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults"
 readme = "README.md"
 authors = [{ name = "sarj-ai" }]

sarj_python_lint-1.4.0/src/sarj_python_lint/rules/_dict_key_views.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import ast
+from typing import TYPE_CHECKING
+
+from sarj_python_lint.rules._ast_index import walk
+
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+
+_SCOPES = (ast.Module, ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)
+_NESTED = (ast.Lambda, ast.ListComp, ast.SetComp, ast.DictComp, ast.GeneratorExp)
+
+
+def proven_dict_key_views(tree: ast.Module, shadowed: frozenset[str]) -> set[ast.Call]:
+    parents = {child: parent for parent in walk(tree) for child in ast.iter_child_nodes(parent)}
+    result: set[ast.Call] = set()
+    scopes: dict[ast.AST, dict[str, ast.AST]] = {}
+    for node in walk(tree):
+        if not (
+            isinstance(node, ast.Call)
+            and isinstance(node.func, ast.Attribute)
+            and node.func.attr == "keys"
+            and not node.args
+            and not node.keywords
+        ):
+            continue
+        receiver = node.func.value
+        if _literal_dict(receiver, shadowed) or (
+            isinstance(receiver, ast.Name) and _local_dict(receiver, parents, shadowed, scopes)
+        ):
+            result.add(node)
+    return result
+
+
+def _literal_dict(node: ast.expr, shadowed: frozenset[str]) -> bool:
+    return isinstance(node, ast.Dict | ast.DictComp) or (
+        isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Name)
+        and node.func.id == "dict"
+        and "dict" not in shadowed
+    )
+
+
+def _local_dict(
+    node: ast.Name,
+    parents: Mapping[ast.AST, ast.AST],
+    shadowed: frozenset[str],
+    scopes: dict[ast.AST, dict[str, ast.AST]],
+) -> bool:
+    ancestor: ast.AST = node
+    while not isinstance(ancestor, _SCOPES):
+        if isinstance(ancestor, _NESTED):
+            return False
+        ancestor = parents[ancestor]
+    if isinstance(ancestor, ast.ClassDef):
+        return False
+    if ancestor not in scopes:
+        scopes[ancestor] = _unique_bindings(ancestor)
+    binding = scopes[ancestor].get(node.id)
+    if binding is None:
+        return False
+    statement = parents.get(binding)
+    if not isinstance(statement, ast.Assign | ast.AnnAssign) or parents.get(statement) is not ancestor:
+        return False
+    if isinstance(statement, ast.Assign) and len(statement.targets) != 1:
+        return False
+    return statement.lineno < node.lineno and statement.value is not None and _literal_dict(statement.value, shadowed)
+
+
+def _unique_bindings(scope: ast.AST) -> dict[str, ast.AST]:
+    bindings: dict[str, ast.AST] = {}
+    repeated: set[str] = set()
+    for node in walk(scope):
+        for name in _bound_names(node):
+            if name == "*":
+                return {}
+            if name in bindings:
+                repeated.add(name)
+            bindings[name] = node
+    return {name: node for name, node in bindings.items() if name not in repeated}
+
+
+def _bound_names(node: ast.AST) -> tuple[str, ...]:
+    match node:
+        case ast.Name(id=name, ctx=ast.Store() | ast.Del()) | ast.arg(arg=name):
+            return (name,)
+        case ast.alias():
+            return (node.asname or node.name.split(".")[0],)
+        case (
+            ast.ExceptHandler(name=str() as name)
+            | ast.MatchAs(name=str() as name)
+            | ast.MatchStar(name=str() as name)
+            | ast.MatchMapping(rest=str() as name)
+            | ast.FunctionDef(name=name)
+            | ast.AsyncFunctionDef(name=name)
+            | ast.ClassDef(name=name)
+        ):
+            return (name,)
+        case ast.Global(names=names) | ast.Nonlocal(names=names):
+            return tuple(names)
+        case _:
+            return ()

{sarj_python_lint-1.3.1 → sarj_python_lint-1.4.0}/src/sarj_python_lint/rules/_registry.py

@@ -115,6 +115,7 @@ from sarj_python_lint.rules.prefer_module_level_constant import (
 from sarj_python_lint.rules.prefer_monkeypatch_for_process_state_in_test import (
     PreferMonkeypatchForProcessStateInTest,
 )
+from sarj_python_lint.rules.prefer_monotonic_for_elapsed_time import PreferMonotonicForElapsedTime
 from sarj_python_lint.rules.prefer_namedtuple_over_tuple_return import (
     PreferNamedtupleOverTupleReturn,
 )
@@ -124,6 +125,7 @@ from sarj_python_lint.rules.prefer_non_nullable_collection import (
 )
 from sarj_python_lint.rules.prefer_or_pattern import PreferOrPattern
 from sarj_python_lint.rules.prefer_pydantic_json_value import PreferPydanticJsonValue
+from sarj_python_lint.rules.prefer_regex_fullmatch import PreferRegexFullmatch
 from sarj_python_lint.rules.prefer_self_documenting_constant import (
     PreferSelfDocumentingConstant,
 )
@@ -162,6 +164,7 @@ from sarj_python_lint.rules.require_pydantic_ordinal_lower_bound import (
     RequirePydanticOrdinalLowerBound,
 )
 from sarj_python_lint.rules.restated_test_docstring import RestatedTestDocstring
+from sarj_python_lint.rules.shared_mutable_pydantic_factory import SharedMutablePydanticFactory
 from sarj_python_lint.rules.stepdown import Stepdown
 from sarj_python_lint.rules.store_get_delegates_to_bulk_read import StoreGetDelegatesToBulkRead
 from sarj_python_lint.rules.store_insert_requires_on_conflict import (
@@ -291,6 +294,9 @@ REGISTRY: Mapping[str, type[Rule]] = MappingProxyType(
         RequireNoDecodeForSplittingSettingsField.id: RequireNoDecodeForSplittingSettingsField,
         NoVagueSuppressionDescription.id: NoVagueSuppressionDescription,
         NoWholeRequestResponsePayloadInLog.id: NoWholeRequestResponsePayloadInLog,
+        SharedMutablePydanticFactory.id: SharedMutablePydanticFactory,
+        PreferRegexFullmatch.id: PreferRegexFullmatch,
+        PreferMonotonicForElapsedTime.id: PreferMonotonicForElapsedTime,
         TypedErrorReasons.id: TypedErrorReasons,
     }
 )

sarj_python_lint-1.4.0/src/sarj_python_lint/rules/prefer_monotonic_for_elapsed_time.py

@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+import ast
+from pathlib import PurePosixPath
+from typing import TYPE_CHECKING, ClassVar, final, override
+
+from sarj_python_lint.rule_base import (
+    AutofixPolicy,
+    Diagnostic,
+    ExampleFile,
+    ExampleOutcome,
+    Rule,
+    RuleCategory,
+    RuleDocumentation,
+    RuleExample,
+    Severity,
+    is_suppressed,
+)
+
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from sarj_python_lint._file_context import PythonFileContext
+
+
+type _Function = ast.FunctionDef | ast.AsyncFunctionDef
+_SCOPES = (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef, ast.Lambda)
+_COMPREHENSIONS = (ast.ListComp, ast.SetComp, ast.DictComp, ast.GeneratorExp)
+_REFLECTIVE_CALLS = frozenset({"locals", "globals", "vars", "eval", "exec", "setattr", "delattr"})
+
+
+@final
+class PreferMonotonicForElapsedTime(Rule):
+    id = "prefer-monotonic-for-elapsed-time"
+    code = "SARJ461"
+    documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
+        default_level=Severity.WARNING,
+        summary="Use a monotonic clock for a local wall-clock value used only to measure elapsed time.",
+        rationale=(
+            "System-clock corrections can make wall-clock differences negative or unexpectedly large. "
+            "A monotonic clock measures elapsed intervals without these jumps."
+        ),
+        remediation=(
+            "Use time.monotonic() or time.perf_counter() for both the start reading and its elapsed-time readings. "
+            "Keep time.time() when measuring absolute timestamps or deliberate wall-clock adjustments."
+        ),
+        category=RuleCategory.CORRECTNESS,
+        autofix=AutofixPolicy.NONE,
+        limitations=(
+            "Only an unconditional, single-assignment function-local start reading whose every read is the right operand of time.time() - start is reported.",
+            "Only unshadowed module-level clock imports are resolved. Reassignment, additional timestamp uses, escapes, nested-scope reads, comprehensions, reflection, and mixed-clock expressions are excluded.",
+            "Instance fields, process or persisted deadlines, indirect end-clock readings, and generated files are not inferred. No automatic rewrite is provided.",
+        ),
+        examples=(
+            RuleExample(
+                example_id="wall-clock-elapsed",
+                title="A local wall clock measures duration",
+                outcome=ExampleOutcome.MATCH,
+                files=(
+                    ExampleFile.python(
+                        "app/metrics.py",
+                        "import time\n\ndef measure():\n    started = time.time()\n    work()\n    return time.time() - started\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("app/metrics.py"),
+                expected_count=1,
+                public=True,
+            ),
+            RuleExample(
+                example_id="monotonic-elapsed",
+                title="A monotonic clock measures duration",
+                outcome=ExampleOutcome.NO_MATCH,
+                files=(
+                    ExampleFile.python(
+                        "app/metrics.py",
+                        "import time\n\ndef measure():\n    started = time.monotonic()\n    work()\n    return time.monotonic() - started\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("app/metrics.py"),
+                expected_count=0,
+                public=True,
+            ),
+        ),
+    )
+    description = documentation.summary
+
+    @override
+    def check_context(self, context: PythonFileContext) -> list[Diagnostic]:
+        if "time" not in context.source or context.generated or context.tree is None or _clock_is_mutated(context):
+            return []
+        findings: list[Diagnostic] = []
+        for function in context.nodes(ast.FunctionDef, ast.AsyncFunctionDef):
+            for start in _elapsed_starts(context, function):
+                if is_suppressed(context.source_lines, start.lineno, self.code):
+                    continue
+                findings.append(
+                    Diagnostic(
+                        path=context.path,
+                        line=start.lineno,
+                        col=start.col_offset + 1,
+                        code=self.code,
+                        severity=Severity.WARNING,
+                        message="this wall-clock reading is used only for elapsed time; use a monotonic clock for both the start and elapsed readings",
+                    )
+                )
+        return sorted(findings, key=lambda finding: (finding.line, finding.col))
+
+
+def _elapsed_starts(context: PythonFileContext, function: _Function) -> Iterator[ast.Call]:
+    nodes = tuple(ast.walk(function))
+    if any(_reflective_call(node) for node in nodes):
+        return
+    for statement in function.body:
+        candidate = _start_assignment(statement)
+        if candidate is None:
+            continue
+        target, call = candidate
+        if not _wall_clock(context, call) or any(_rebinds(node, target) for node in nodes):
+            continue
+        reads = _reads_of(nodes, target.id)
+        if reads and all(_elapsed_read(context, function, call, read) for read in reads):
+            yield call
+
+
+def _start_assignment(statement: ast.stmt) -> tuple[ast.Name, ast.Call] | None:
+    match statement:
+        case (
+            ast.Assign(targets=[ast.Name() as target], value=ast.Call() as call)
+            | ast.AnnAssign(target=ast.Name() as target, value=ast.Call() as call)
+        ):
+            return target, call
+        case _:
+            return None
+
+
+def _reads_of(nodes: tuple[ast.AST, ...], name: str) -> list[ast.Name]:
+    return [node for node in nodes if isinstance(node, ast.Name) and node.id == name and isinstance(node.ctx, ast.Load)]
+
+
+def _wall_clock(context: PythonFileContext, call: ast.expr) -> bool:
+    return (
+        isinstance(call, ast.Call)
+        and not call.args
+        and not call.keywords
+        and context.imports.resolved_qualified_name(call.func) == "time.time"
+    )
+
+
+def _elapsed_read(context: PythonFileContext, function: _Function, start: ast.Call, read: ast.Name) -> bool:
+    if (read.lineno, read.col_offset) <= (start.lineno, start.col_offset):
+        return False
+    parent = context.parents.get(read)
+    if not isinstance(parent, ast.BinOp) or not isinstance(parent.op, ast.Sub) or parent.right is not read:
+        return False
+    if not _wall_clock(context, parent.left):
+        return False
+    owner = context.parents.get(parent)
+    while owner is not None and owner is not function:
+        if isinstance(owner, (*_SCOPES, *_COMPREHENSIONS)):
+            return False
+        owner = context.parents.get(owner)
+    return owner is function
+
+
+def _rebinds(node: ast.AST, target: ast.Name) -> bool:
+    match node:
+        case ast.Name(id=name, ctx=ast.Store() | ast.Del()):
+            return node is not target and name == target.id
+        case ast.arg(arg=name) | ast.FunctionDef(name=name) | ast.AsyncFunctionDef(name=name) | ast.ClassDef(name=name):
+            return name == target.id
+        case ast.alias(name=name, asname=alias):
+            return (alias or name.partition(".")[0]) == target.id
+        case ast.Global(names=names) | ast.Nonlocal(names=names):
+            return target.id in names
+        case (
+            ast.ExceptHandler(name=name)
+            | ast.MatchAs(name=name)
+            | ast.MatchStar(name=name)
+            | ast.MatchMapping(rest=name)
+        ):
+            return name == target.id
+        case _:
+            return False
+
+
+def _reflective_call(node: ast.AST) -> bool:
+    if not isinstance(node, ast.Call):
+        return False
+    return (isinstance(node.func, ast.Name) and node.func.id in _REFLECTIVE_CALLS) or (
+        isinstance(node.func, ast.Attribute) and node.func.attr in _REFLECTIVE_CALLS
+    )
+
+
+def _clock_is_mutated(context: PythonFileContext) -> bool:
+    if any(
+        isinstance(node.ctx, (ast.Store, ast.Del)) and context.imports.resolved_qualified_name(node) == "time.time"
+        for node in context.nodes(ast.Attribute)
+    ):
+        return True
+    clocks = _clock_imports(context)
+    if context.tree is None:
+        return False
+    for node in ast.walk(context.tree):
+        if isinstance(node, ast.alias):
+            if node.name == "*":
+                return True
+            statement = context.parents.get(node)
+            if _is_direct_clock_import(context, statement, node):
+                continue
+        if any(_rebinds(node, clock) for clock in clocks):
+            return True
+    return False
+
+
+def _clock_imports(context: PythonFileContext) -> list[ast.Name]:
+    return [
+        ast.Name(id=name, ctx=ast.Load())
+        for name in context.imports.bindings
+        if context.imports.resolved_qualified_name(ast.Name(id=name, ctx=ast.Load())) == "time.time"
+        or context.imports.resolved_qualified_name(
+            ast.Attribute(value=ast.Name(id=name, ctx=ast.Load()), attr="time", ctx=ast.Load())
+        )
+        == "time.time"
+    ]
+
+
+def _is_direct_clock_import(context: PythonFileContext, statement: ast.AST | None, alias: ast.alias) -> bool:
+    if statement is None or context.parents.get(statement) is not context.tree or alias.name != "time":
+        return False
+    return isinstance(statement, ast.Import) or (
+        isinstance(statement, ast.ImportFrom) and statement.module == "time" and statement.level == 0
+    )

sarj_python_lint-1.4.0/src/sarj_python_lint/rules/prefer_regex_fullmatch.py

@@ -0,0 +1,298 @@
+from __future__ import annotations
+
+import ast
+from collections import Counter
+from pathlib import PurePosixPath
+import re
+from typing import TYPE_CHECKING, ClassVar, override
+
+from sarj_python_lint.rule_base import (
+    AutofixPolicy,
+    Diagnostic,
+    ExampleFile,
+    ExampleOutcome,
+    Rule,
+    RuleCategory,
+    RuleDocumentation,
+    RuleExample,
+    Severity,
+    is_suppressed,
+)
+from sarj_python_lint.rules._paths import is_test_path
+
+
+if TYPE_CHECKING:
+    from sarj_python_lint._file_context import PythonFileContext
+
+
+_RE = frozenset({"re"})
+_SCOPES = (ast.Module, ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef, ast.Lambda)
+_BAD = "import re\n\ndef validate(value):\n    if not re.match(r'^[a-z]+$', value):\n        raise ValueError('invalid value')\n"
+_GOOD = _BAD.replace("re.match(r'^[a-z]+$'", "re.fullmatch(r'[a-z]+'")
+
+
+class PreferRegexFullmatch(Rule):
+    id: str = "prefer-regex-fullmatch"
+    code: str = "SARJ460"
+    documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
+        default_level=Severity.WARNING,
+        summary="An anchored regex match rejects invalid values without requiring a full-string match.",
+        rationale="The regex `$` anchor can match before a final newline, so an anchored match can accept a value that was not fully validated.",
+        remediation="Use `re.fullmatch` or the compiled pattern's `fullmatch` method for whole-value validation; review whether a terminal newline is intentionally allowed.",
+        category=RuleCategory.CORRECTNESS,
+        autofix=AutofixPolicy.NONE,
+        limitations=(
+            "Only direct negative match or `is None` conditions whose sole rejection statement raises are checked; extraction, search, compound conditions, and return-based validators are excluded.",
+            "Patterns must be valid string or bytes literals bounded by `^` or `\\A` and an unescaped outer `$`; top-level alternation, inline extension groups other than noncapturing groups, and flags other than literal zero are excluded.",
+            "Only imported standard-library re functions and unique, unconditional module or same-function compile bindings are resolved. Rebinding, import shadowing, escaped regex objects or modules, explicit match positions, tests, and generated files are excluded.",
+            "Binding checks are deliberately file-wide, so unrelated same-named locals can suppress findings. Dynamic monkeypatching and interprocedural changes are not inferred.",
+        ),
+        examples=(
+            RuleExample(
+                example_id="anchored-rejection",
+                title="An end anchor permits a final newline",
+                outcome=ExampleOutcome.MATCH,
+                files=(ExampleFile.python("app/validation.py", _BAD),),
+                focus_path=PurePosixPath("app/validation.py"),
+                expected_count=1,
+                public=True,
+            ),
+            RuleExample(
+                example_id="whole-value-rejection",
+                title="Validate the entire value",
+                outcome=ExampleOutcome.NO_MATCH,
+                files=(ExampleFile.python("app/validation.py", _GOOD),),
+                focus_path=PurePosixPath("app/validation.py"),
+                expected_count=0,
+                public=True,
+            ),
+        ),
+    )
+    description: str = documentation.summary
+
+    @override
+    def check_context(self, context: PythonFileContext) -> list[Diagnostic]:
+        if "match" not in context.source or context.tree is None or context.generated or is_test_path(context.path):
+            return []
+        bindings = _binding_counts(context)
+        mutated = {
+            root
+            for node in context.nodes(ast.Attribute)
+            if isinstance(node.ctx, (ast.Store, ast.Del)) and (root := _root_name(node)) is not None
+        }
+        mutated.update(
+            node.id for node in context.nodes(ast.Name) if isinstance(node.ctx, ast.Load) and _escapes(context, node)
+        )
+        compiled = _compiled_patterns(context, bindings, mutated)
+        findings: list[Diagnostic] = []
+        for guard in context.nodes(ast.If):
+            call = _rejection_call(guard)
+            if call is None or is_suppressed(context.source_lines, call.lineno, self.code):
+                continue
+            pattern = _match_pattern(context, call, bindings, mutated, compiled)
+            if pattern is None or not _whole_value_pattern(pattern):
+                continue
+            findings.append(
+                Diagnostic(
+                    path=context.path,
+                    line=call.lineno,
+                    col=call.col_offset + 1,
+                    code=self.code,
+                    message="anchored match is used to reject invalid values, but `$` can accept a final newline; use fullmatch for whole-value validation and review newline handling.",
+                    severity=Severity.WARNING,
+                )
+            )
+        return sorted(findings, key=lambda item: (item.line, item.col))
+
+
+def _rejection_call(guard: ast.If) -> ast.Call | None:
+    if len(guard.body) != 1 or not isinstance(guard.body[0], ast.Raise):
+        return None
+    condition = guard.test
+    if isinstance(condition, ast.UnaryOp) and isinstance(condition.op, ast.Not):
+        return condition.operand if isinstance(condition.operand, ast.Call) else None
+    if not isinstance(condition, ast.Compare) or len(condition.ops) != 1:
+        return None
+    if (
+        isinstance(condition.ops[0], ast.Is)
+        and isinstance(condition.left, ast.Call)
+        and isinstance(condition.comparators[0], ast.Constant)
+        and condition.comparators[0].value is None
+    ):
+        return condition.left
+    return None
+
+
+def _binding_counts(context: PythonFileContext) -> Counter[str]:
+    result: Counter[str] = Counter()
+    for node in context.nodes(ast.AST):
+        match node:
+            case (
+                ast.Name(id=name, ctx=(ast.Store() | ast.Del()))
+                | ast.arg(arg=name)
+                | ast.FunctionDef(name=name)
+                | ast.AsyncFunctionDef(name=name)
+                | ast.ClassDef(name=name)
+            ):
+                result[name] += 1
+            case ast.alias(name=name, asname=alias):
+                result[alias or name.partition(".")[0]] += 1
+            case (
+                ast.ExceptHandler(name=str(name))
+                | ast.MatchAs(name=str(name))
+                | ast.MatchStar(name=str(name))
+                | ast.MatchMapping(rest=str(name))
+            ):
+                result[name] += 1
+            case _:
+                pass
+    return result
+
+
+def _root_name(node: ast.expr) -> str | None:
+    while isinstance(node, ast.Attribute):
+        node = node.value
+    return node.id if isinstance(node, ast.Name) else None
+
+
+def _escapes(context: PythonFileContext, node: ast.Name) -> bool:
+    parent = context.parents.get(node)
+    if isinstance(parent, ast.Attribute) and parent.value is node:
+        return False
+    return not (isinstance(parent, ast.Call) and parent.func is node)
+
+
+def _resolves(
+    context: PythonFileContext, node: ast.expr, symbol: str, bindings: Counter[str], mutated: set[str]
+) -> bool:
+    root = _root_name(node)
+    return (
+        root is not None
+        and bindings[root] == 1
+        and root not in mutated
+        and context.imports.resolves(node, sources=_RE, symbol=symbol)
+    )
+
+
+def _literal_pattern(call: ast.Call, *, compile_call: bool) -> str | bytes | None:
+    names = ("pattern", "flags") if compile_call else ("pattern", "string", "flags")
+    if len(call.args) > len(names) or any(isinstance(argument, ast.Starred) for argument in call.args):
+        return None
+    arguments: dict[str, ast.expr] = dict(zip(names, call.args, strict=False))
+    for keyword in call.keywords:
+        if keyword.arg is None or keyword.arg not in names or keyword.arg in arguments:
+            return None
+        arguments[keyword.arg] = keyword.value
+    required = {"pattern"} if compile_call else {"pattern", "string"}
+    if not required <= arguments.keys():
+        return None
+    flags = arguments.get("flags")
+    if flags is not None and not (isinstance(flags, ast.Constant) and type(flags.value) is int and flags.value == 0):
+        return None
+    pattern = arguments["pattern"]
+    return pattern.value if isinstance(pattern, ast.Constant) and isinstance(pattern.value, (str, bytes)) else None
+
+
+def _compiled_patterns(
+    context: PythonFileContext, bindings: Counter[str], mutated: set[str]
+) -> dict[str, tuple[ast.AST, ast.expr, str | bytes]]:
+    patterns: dict[str, tuple[ast.AST, ast.expr, str | bytes]] = {}
+    for node in context.nodes(ast.Assign, ast.AnnAssign):
+        if isinstance(node, ast.Assign) and len(node.targets) == 1:
+            target, value = node.targets[0], node.value
+        elif isinstance(node, ast.AnnAssign):
+            target, value = node.target, node.value
+        else:
+            continue
+        owner = context.parents.get(node)
+        if not isinstance(owner, (ast.Module, ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        if (
+            not isinstance(target, ast.Name)
+            or bindings[target.id] != 1
+            or target.id in mutated
+            or not isinstance(value, ast.Call)
+            or not _resolves(context, value.func, "compile", bindings, mutated)
+        ):
+            continue
+        pattern = _literal_pattern(value, compile_call=True)
+        if pattern is not None:
+            patterns[target.id] = owner, target, pattern
+    return patterns
+
+
+def _match_pattern(
+    context: PythonFileContext,
+    call: ast.Call,
+    bindings: Counter[str],
+    mutated: set[str],
+    compiled: dict[str, tuple[ast.AST, ast.expr, str | bytes]],
+) -> str | bytes | None:
+    if _resolves(context, call.func, "match", bindings, mutated):
+        return _literal_pattern(call, compile_call=False)
+    if not isinstance(call.func, ast.Attribute) or call.func.attr != "match" or len(call.args) != 1 or call.keywords:
+        return None
+    receiver = call.func.value
+    if isinstance(receiver, ast.Call) and _resolves(context, receiver.func, "compile", bindings, mutated):
+        return _literal_pattern(receiver, compile_call=True)
+    if not isinstance(receiver, ast.Name) or receiver.id not in compiled:
+        return None
+    owner, target, pattern = compiled[receiver.id]
+    if target.lineno >= call.lineno or (not isinstance(owner, ast.Module) and owner is not _scope(context, call)):
+        return None
+    return pattern
+
+
+def _scope(context: PythonFileContext, node: ast.AST) -> ast.AST | None:
+    parent = context.parents.get(node)
+    while parent is not None and not isinstance(parent, _SCOPES):
+        parent = context.parents.get(parent)
+    return parent
+
+
+def _whole_value_pattern(pattern: str | bytes) -> bool:
+    text = pattern.decode("latin1") if isinstance(pattern, bytes) else pattern
+    if not text.startswith(("^", r"\A")) or not text.endswith("$"):
+        return False
+    try:
+        re.compile(pattern)
+    except re.PatternError, OverflowError, RecursionError:
+        return False
+    depth = 0
+    index = 0
+    while index < len(text):
+        char = text[index]
+        if char == "\\":
+            index += 2
+            continue
+        if char == "[":
+            index = _class_end(text, index) + 1
+            continue
+        if char == "(":
+            if text[index : index + 2] == "(?" and text[index : index + 3] != "(?:":
+                return False
+            depth += 1
+        elif char == ")":
+            depth -= 1
+        elif char == "|" and depth == 0:
+            return False
+        elif char == "$" and index == len(text) - 1:
+            return depth == 0
+        index += 1
+    return False
+
+
+def _class_end(text: str, start: int) -> int:
+    index = start + 1
+    if text[index] == "^":
+        index += 1
+    if text[index] == "]":
+        index += 1
+    while index < len(text):
+        if text[index] == "\\":
+            index += 2
+            continue
+        if text[index] == "]":
+            return index
+        index += 1
+    return len(text)