sarj-python-lint 1.27.2__tar.gz → 1.27.4__tar.gz

{sarj_python_lint-1.27.2 → sarj_python_lint-1.27.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 1.27.2
+Version: 1.27.4
 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.27.2 → sarj_python_lint-1.27.4}/pyproject.toml

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

{sarj_python_lint-1.27.2 → sarj_python_lint-1.27.4}/src/sarj_python_lint/_file_context.py

@@ -5,6 +5,7 @@ from functools import cached_property
 from typing import TYPE_CHECKING, final
 
 from sarj_python_lint._analysis_session import AnalysisSession
+from sarj_python_lint._source import symbol_prefilter_source
 from sarj_python_lint.rules._ast_index import NodeIndex
 from sarj_python_lint.rules._fastapi import FastapiIndex
 from sarj_python_lint.rules._imports import ImportIndex
@@ -26,6 +27,10 @@ class PythonFileContext:
         self.source = source
         self.session = session if session is not None else AnalysisSession()
 
+    @cached_property
+    def symbol_source(self) -> str:
+        return symbol_prefilter_source(self.source)
+
     @cached_property
     def tree(self) -> ast.Module | None:
         if self.session.project is not None:

{sarj_python_lint-1.27.2 → sarj_python_lint-1.27.4}/src/sarj_python_lint/_source.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from io import BytesIO
 import tokenize
 from typing import TYPE_CHECKING
+import unicodedata
 
 
 if TYPE_CHECKING:
@@ -16,3 +17,8 @@ def python_source_encoding(data: bytes) -> str:
 def read_python_source(path: Path) -> str:
     with tokenize.open(path) as stream:
         return stream.read()
+
+
+def symbol_prefilter_source(source: str) -> str:
+    # Only necessary symbol gates may use this view; parse and locate original source.
+    return source if source.isascii() else unicodedata.normalize("NFKC", source)

{sarj_python_lint-1.27.2 → sarj_python_lint-1.27.4}/src/sarj_python_lint/interpreter_argv.py

@@ -28,9 +28,45 @@ class InterpreterInvocation:
 class ParsedOption:
     invocation: InterpreterInvocation | None = None
     consumed: int = 1
+    stdin_mode: bool = False
 
 
 _SHELLS = frozenset({"sh", "bash", "dash", "zsh", "ksh"})
+_SHELL_SHORT_FLAGS = frozenset("abefhkmnptuvxBCEHPrDilscoO")
+_SHELL_LONG_FLAGS = frozenset(
+    {"--norc", "--noprofile", "--posix", "--restricted", "--verbose", "--login", "--noediting"}
+)
+_SHELL_NAMED_OPTIONS = frozenset(
+    {
+        "allexport",
+        "braceexpand",
+        "emacs",
+        "errexit",
+        "errtrace",
+        "functrace",
+        "hashall",
+        "histexpand",
+        "history",
+        "ignoreeof",
+        "interactive-comments",
+        "keyword",
+        "monitor",
+        "noclobber",
+        "noexec",
+        "noglob",
+        "nolog",
+        "notify",
+        "nounset",
+        "onecmd",
+        "physical",
+        "pipefail",
+        "posix",
+        "privileged",
+        "verbose",
+        "vi",
+        "xtrace",
+    }
+)
 _NODE_VALUE_FLAGS = frozenset(
     {
         "--require",
@@ -85,18 +121,20 @@ class UnprovableCommandError(ValueError):
     """A wrapper executable position cannot be established safely."""
 
 
-def unwrap_command(argv: Sequence[str]) -> tuple[str, ...]:
+def unwrap_command(
+    argv: Sequence[str], *, allow_shell_builtins: bool = True, allowed_wrappers: frozenset[str] | None = None
+) -> tuple[str, ...]:
     current = tuple(argv)
     for _ in range(_MAX_WRAPPERS):
         if not current:
             return ()
         command = PurePosixPath(current[0]).name
-        if command in {"exec", "command"}:
+        if allow_shell_builtins and command in {"exec", "command"}:
             if command == "command" and any(argument in {"-v", "-V"} for argument in current[1:2]):
                 return current
             current = current[_command_wrapper_index(current, command) :]
             continue
-        if command not in _WRAPPER_VALUES:
+        if command not in _WRAPPER_VALUES or (allowed_wrappers is not None and command not in allowed_wrappers):
             return current
         current = current[_value_wrapper_index(current, command) :]
     msg = "command wrapper nesting exceeds analysis bound"
@@ -120,25 +158,69 @@ def _command_wrapper_index(arguments: Sequence[str], command: str) -> int:
 
 
 def _value_wrapper_index(arguments: Sequence[str], command: str) -> int:
+    if command == "env":
+        return _env_wrapper_index(arguments)
     index = 1
     while index < len(arguments):
         argument = arguments[index]
         if argument == "--":
             index += 1
             break
-        if command == "env" and re.match(r"^[A-Za-z_][A-Za-z0-9_]*=", argument):
-            index += 1
-            continue
         if not argument.startswith("-") or argument == "-":
             break
-        if command == "env" and argument in {"-S", "--split-string"}:
-            msg = "env split-string has a separate unproven quoting grammar"
-            raise UnprovableCommandError(msg)
         index += 2 if argument in _WRAPPER_VALUES[command] else 1
     # Timeout's positional duration precedes its executable.
     return index + int(command == "timeout")
 
 
+def _env_wrapper_index(arguments: Sequence[str]) -> int:
+    index = 1
+    while index < len(arguments) and arguments[index].startswith("-"):
+        argument = arguments[index]
+        if argument == "-":
+            index += 1
+            break
+        if argument == "--":
+            index += 1
+            break
+        index += _env_option_size(arguments, index)
+    # Assignments follow options, including after --; later option-looking words
+    # are executable operands, not additional env options.
+    while index < len(arguments) and "=" in arguments[index]:
+        if arguments[index].startswith("="):
+            msg = "env assignment requires a nonempty variable name"
+            raise UnprovableCommandError(msg)
+        index += 1
+    return index
+
+
+def _env_option_size(arguments: Sequence[str], index: int) -> int:
+    argument = arguments[index]
+    if argument in {"--help", "--version"}:
+        return len(arguments) - index  # GNU env terminates without executing operands.
+    if argument in {"-S", "--split-string"} or argument.startswith(("-S", "--split-string=")):
+        msg = "env split-string has a separate unproven quoting grammar"
+        raise UnprovableCommandError(msg)
+    if argument in {"-i", "--ignore-environment", "-v", "--debug"}:
+        return 1
+    if argument in _WRAPPER_VALUES["env"]:
+        value = arguments[index + 1] if index + 1 < len(arguments) else ""
+        _validate_env_operand(argument, value)
+        return 2
+    for option in ("--unset=", "--chdir=", "-u", "-C"):
+        if argument.startswith(option):
+            _validate_env_operand(option, argument[len(option) :])
+            return 1
+    msg = "unsupported env wrapper option"
+    raise UnprovableCommandError(msg)
+
+
+def _validate_env_operand(option: str, value: str) -> None:
+    if not value or (option in {"-u", "--unset", "--unset="} and "=" in value):
+        msg = "env option requires a valid value"
+        raise UnprovableCommandError(msg)
+
+
 def is_python_executable(executable: str) -> bool:
     return re.fullmatch(r"python(?:[23](?:\.\d+)?)?", PurePosixPath(executable).name) is not None
 
@@ -154,7 +236,9 @@ def classify_interpreter(argv: Sequence[str]) -> InterpreterInvocation:
     if is_python_executable(executable):
         return _python(arguments[1:])
     if executable in _SHELLS:
-        return _short_options(arguments[1:], source="c", values=frozenset({"o", "O"}), shell_mode=True)
+        return _short_options(
+            arguments[1:], source="c", values=frozenset({"o", "O"}), shell_mode=True, bash_mode=executable == "bash"
+        )
     if executable in {"node", "nodejs"}:
         return _node(arguments[1:])
     if executable == "jq":
@@ -175,6 +259,11 @@ def _python(arguments: Sequence[str]) -> InterpreterInvocation:
         if boundary is not None:
             return boundary
         argument = arguments[index]
+        if argument == "--check-hash-based-pycs":
+            if _following_operand(arguments, index) not in {"default", "always", "never"}:
+                return InterpreterInvocation("unknown")
+            index += 2
+            continue
         if argument.startswith("--"):
             return InterpreterInvocation(
                 "external"
@@ -253,31 +342,66 @@ def _ruby_long_option(argument: str, following: str | None) -> ParsedOption:
 
 
 def _short_options(
-    arguments: Sequence[str], *, source: str, values: frozenset[str], shell_mode: bool = False
+    arguments: Sequence[str], *, source: str, values: frozenset[str], shell_mode: bool = False, bash_mode: bool = False
 ) -> InterpreterInvocation:
     index = 0
+    stdin_mode = False
+    short_seen = False
     while index < len(arguments):
         boundary = _external_boundary(arguments, index, plus_options=True)
         if boundary is not None:
-            return boundary
+            return InterpreterInvocation("stdin") if stdin_mode else boundary
         argument = arguments[index]
         if argument.startswith("--"):
-            index += 2 if shell_mode and argument in {"--rcfile", "--init-file"} else 1
-            continue
-        parsed = _short_option(arguments, index, source=source, values=values, shell_mode=shell_mode)
+            parsed = _long_option(arguments, index, shell_mode=shell_mode, bash_mode=bash_mode, short_seen=short_seen)
+        else:
+            short_seen = True
+            parsed = _short_option(
+                arguments, index, source=source, values=values, shell_mode=shell_mode, bash_mode=bash_mode
+            )
         if parsed.invocation is not None:
             return parsed.invocation
+        stdin_mode = stdin_mode or parsed.stdin_mode
         index += parsed.consumed
     return InterpreterInvocation("stdin")
 
 
+def _long_option(
+    arguments: Sequence[str], index: int, *, shell_mode: bool, bash_mode: bool, short_seen: bool
+) -> ParsedOption:
+    if not bash_mode:
+        consumed = 2 if shell_mode and arguments[index] in {"--rcfile", "--init-file"} else 1
+        return ParsedOption(consumed=consumed)
+    if short_seen:
+        return ParsedOption(InterpreterInvocation("unknown"))
+    argument = arguments[index]
+    if argument in {"--help", "--version"}:
+        return ParsedOption(InterpreterInvocation("other"))
+    if argument in {"--rcfile", "--init-file"}:
+        return (
+            ParsedOption(consumed=2)
+            if _following_operand(arguments, index) is not None
+            else ParsedOption(InterpreterInvocation("unknown"))
+        )
+    if argument not in _SHELL_LONG_FLAGS:
+        return ParsedOption(InterpreterInvocation("unknown"))
+    return ParsedOption()
+
+
 def _short_option(
-    arguments: Sequence[str], index: int, *, source: str, values: frozenset[str], shell_mode: bool
+    arguments: Sequence[str],
+    index: int,
+    *,
+    source: str,
+    values: frozenset[str],
+    shell_mode: bool,
+    bash_mode: bool = False,
 ) -> ParsedOption:
+    if bash_mode:
+        return _shell_short_option(arguments, index, values)
     argument = arguments[index]
     for cursor, flag in enumerate(argument[1:], 1):
         if flag in source:
-            # Shell -c always consumes the next word, including inside -ceu.
             attached = "" if shell_mode else argument[cursor + 1 :]
             operand = attached or _following_operand(arguments, index)
             forwarded = tuple(arguments[index + 3 :]) if shell_mode else ()
@@ -287,6 +411,26 @@ def _short_option(
     return ParsedOption()
 
 
+def _shell_short_option(arguments: Sequence[str], index: int, values: frozenset[str]) -> ParsedOption:
+    flags = arguments[index][1:]
+    if any(flag not in _SHELL_SHORT_FLAGS for flag in flags):
+        return ParsedOption(InterpreterInvocation("unknown"))
+    consumed = 1
+    for flag in flags:
+        if flag in values:
+            operand = _following_operand(arguments, index + consumed - 1)
+            # Bash shopt (-O) has a separate, version-dependent namespace. Keep
+            # it unproven until a native option contract is available.
+            if flag == "O" or operand not in _SHELL_NAMED_OPTIONS:
+                return ParsedOption(InterpreterInvocation("unknown"))
+            consumed += 1
+    if "c" in flags:
+        operand = _following_operand(arguments, index + consumed - 1)
+        forwarded = tuple(arguments[index + consumed + 2 :])
+        return ParsedOption(InterpreterInvocation("shell", operand, forwarded))
+    return ParsedOption(consumed=consumed, stdin_mode="s" in flags)
+
+
 def _node(arguments: Sequence[str]) -> InterpreterInvocation:
     index = 0
     while index < len(arguments):

{sarj_python_lint-1.27.2 → sarj_python_lint-1.27.4}/src/sarj_python_lint/rules/_project_index.py

@@ -11,7 +11,7 @@ import re
 from types import MappingProxyType
 from typing import TYPE_CHECKING, final
 
-from sarj_python_lint._source import read_python_source
+from sarj_python_lint._source import read_python_source, symbol_prefilter_source
 from sarj_python_lint.rules._ast_index import walk as walk_ast
 from sarj_python_lint.rules._first_party import FirstPartyFacts, project_root
 from sarj_python_lint.rules._paths import is_generated
@@ -46,7 +46,6 @@ _MAX_FILES_PER_ROOT = 10_000
 _MAX_FILE_BYTES = 500_000
 _MAX_SOURCE_CHARS_PER_ROOT = 50_000_000
 _NEW_TYPE_MIN_ARGS = 2
-_MATCH_CLASS_RE: re.Pattern[str] = re.compile(r"\bcase\s+([A-Z][A-Za-z0-9_]*)\s*\(")
 
 
 @dataclass(frozen=True, slots=True)
@@ -210,7 +209,7 @@ class ProjectIndexSet:
         return frozenset(
             (candidate.path, node.name)
             for candidate in self._units.values()
-            if candidate.tree is not None and name in candidate.source
+            if candidate.tree is not None
             for node in candidate.tree.body
             if isinstance(node, ast.ClassDef)
             and any(_direct_base_symbol(candidate, base) == target for base in node.bases)
@@ -223,7 +222,7 @@ class ProjectIndexSet:
         return frozenset(
             (candidate.path, owner.name)
             for candidate in self._units.values()
-            if candidate.tree is not None and name in candidate.source
+            if candidate.tree is not None
             for owner in candidate.tree.body
             if isinstance(owner, ast.ClassDef) and _class_has_typed_dependency(candidate, owner, target)
         )
@@ -236,7 +235,6 @@ class ProjectIndexSet:
             candidate.path
             for candidate in self._units.values()
             if candidate.tree is not None
-            and name in candidate.source
             and any(
                 _is_mock_spec_for(candidate, call, target)
                 for call in walk_ast(candidate.tree)
@@ -265,15 +263,9 @@ class ProjectIndexSet:
 
 
 def _units(sources: Mapping[Path, str], roots: Sequence[Path] = ()) -> dict[Path, SourceUnit]:
-    matched_classes = {
-        match.group(1)
-        for source in sources.values()
-        if "match " in source and "str(" in source
-        for match in _MATCH_CLASS_RE.finditer(source)
-    }
     parsed: dict[Path, tuple[str | None, str, ast.Module | None]] = {}
     for path, source in sources.items():
-        if not _is_index_candidate(source, matched_classes):
+        if not _is_index_candidate(symbol_prefilter_source(source)):
             continue
         tree: ast.Module | None = None
         with suppress(SyntaxError):
@@ -291,16 +283,8 @@ def _units(sources: Mapping[Path, str], roots: Sequence[Path] = ()) -> dict[Path
     }
 
 
-def _is_index_candidate(source: str, matched_classes: set[str]) -> bool:
-    return (
-        "NewType(" in source
-        or "class " in source
-        or "spec=" in source
-        or "spec_set=" in source
-        or "create_autospec(" in source
-        or ("match " in source and "str(" in source)
-        or any(f"class {name}" in source for name in matched_classes)
-    )
+def _is_index_candidate(source: str) -> bool:
+    return "NewType" in source or "class" in source or "spec" in source or ("match" in source and "str" in source)
 
 
 def _module_name(path: Path, roots: Sequence[Path]) -> str | None:

{sarj_python_lint-1.27.2 → sarj_python_lint-1.27.4}/src/sarj_python_lint/rules/async_cleanup_registered_synchronously.py

@@ -68,7 +68,7 @@ class AsyncCleanupRegisteredSynchronously(Rule):
 
     @override
     def check_context(self, context: PythonFileContext) -> list[Diagnostic]:
-        if "callback" not in context.source or context.generated or context.tree is None:
+        if "callback" not in context.symbol_source or context.generated or context.tree is None:
             return []
         provenance = ResourceProvenance(context)
         findings: list[Diagnostic] = []

{sarj_python_lint-1.27.2 → sarj_python_lint-1.27.4}/src/sarj_python_lint/rules/async_mock_call_without_await_assertion.py

@@ -101,6 +101,36 @@ class AsyncMockCallWithoutAwaitAssertion(Rule):
             "Custom assertion helpers and intentional scheduling contracts may require a reasoned local suppression.",
         ),
         examples=(
+            RuleExample(
+                example_id="spaced-positive-called-state",
+                scenario="called-attribute-spacing",
+                title="A spaced positive call state still needs await evidence",
+                outcome=ExampleOutcome.MATCH,
+                files=(
+                    ExampleFile.python(
+                        "tests/test_delivery.py",
+                        "from unittest.mock import AsyncMock\nasync def test_delivery():\n    send = AsyncMock()\n    pending = send()\n    pending.close()\n    assert send. called\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("tests/test_delivery.py"),
+                expected_count=1,
+                public=True,
+            ),
+            RuleExample(
+                example_id="spaced-called-with-await-evidence",
+                scenario="called-attribute-spacing",
+                title="Await evidence covers the same spaced call state",
+                outcome=ExampleOutcome.NO_MATCH,
+                files=(
+                    ExampleFile.python(
+                        "tests/test_delivery.py",
+                        "from unittest.mock import AsyncMock\nasync def test_delivery():\n    send = AsyncMock()\n    await send()\n    assert send. called\n    send.assert_awaited_once()\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("tests/test_delivery.py"),
+                expected_count=0,
+                public=True,
+            ),
             RuleExample(
                 example_id="call-only-async-mock",
                 title="A call assertion does not prove awaiting",
@@ -166,11 +196,11 @@ class AsyncMockCallWithoutAwaitAssertion(Rule):
     @override
     def check_context(self, context: PythonFileContext) -> list[Diagnostic]:
         path = context.path
-        source = context.source
+        signals = context.symbol_source
         if (
             path.suffix != ".py"
-            or "AsyncMock" not in source
-            or not any(token in source for token in ("assert_called", "call_count", ".called"))
+            or "AsyncMock" not in signals
+            or not any(token in signals for token in ("called", "call_count"))
             or not (path.stem.startswith("test_") or path.stem.endswith("_test"))
             or context.generated
         ):

{sarj_python_lint-1.27.2 → sarj_python_lint-1.27.4}/src/sarj_python_lint/rules/no_dunder_all.py

@@ -85,6 +85,30 @@ class NoDunderAll(Rule):
                 expected_count=0,
                 public=True,
             ),
+            RuleExample(
+                example_id="normalized-module-export-binding",
+                title="Compatibility identifiers bind the native module export name",
+                outcome=ExampleOutcome.MATCH,
+                files=(ExampleFile.python("app/service.py", '__ａｌｌ__ = ["value"]\nvalue = 1\n'),),
+                focus_path=PurePosixPath("app/service.py"),
+                expected_count=1,
+                public=True,
+                scenario="normalized-module-name",
+            ),
+            RuleExample(
+                example_id="normalized-local-binding",
+                title="A local binding is outside the module export contract",
+                outcome=ExampleOutcome.NO_MATCH,
+                files=(
+                    ExampleFile.python(
+                        "app/service.py", 'def values():\n    __ａｌｌ__ = ["value"]\n    return __all__\n'
+                    ),
+                ),
+                focus_path=PurePosixPath("app/service.py"),
+                expected_count=0,
+                public=True,
+                scenario="normalized-module-name",
+            ),
         ),
     )
     description = documentation.summary
@@ -92,8 +116,8 @@ class NoDunderAll(Rule):
     @override
     def check_context(self, context: PythonFileContext) -> list[Diagnostic]:
         path = context.path
-        source = context.source
-        if path.suffix != ".py" or "__all__" not in source or context.generated:
+        signals = context.symbol_source
+        if path.suffix != ".py" or "__all__" not in signals or context.generated:
             return []
         tree = context.tree
         if tree is None:

{sarj_python_lint-1.27.2 → sarj_python_lint-1.27.4}/src/sarj_python_lint/rules/no_fixed_sleep_before_assert.py

@@ -135,8 +135,8 @@ class NoFixedSleepBeforeAssert(Rule):
     @override
     def check_context(self, context: PythonFileContext) -> list[Diagnostic]:
         path = context.path
-        source = context.source
-        if not _is_collected_test_module(path) or "sleep" not in source or context.generated:
+        signals = context.symbol_source
+        if not _is_collected_test_module(path) or "sleep" not in signals or context.generated:
             return []
         tree = context.tree
         if tree is None:

{sarj_python_lint-1.27.2 → sarj_python_lint-1.27.4}/src/sarj_python_lint/rules/no_fixed_sleep_in_loop.py

@@ -139,7 +139,7 @@ class NoFixedSleepInLoop(Rule):
     def check_context(self, context: PythonFileContext) -> list[Diagnostic]:
         path = context.path
         if (
-            "sleep" not in context.source
+            "sleep" not in context.symbol_source
             or is_test_path(path)
             or is_test_support_path(path)
             or context.generated

{sarj_python_lint-1.27.2 → sarj_python_lint-1.27.4}/src/sarj_python_lint/rules/no_hidden_constructor_fallback.py

@@ -7,7 +7,7 @@ import os
 from pathlib import Path, PurePosixPath
 from typing import TYPE_CHECKING, ClassVar, NamedTuple, final, override
 
-from sarj_python_lint._source import read_python_source
+from sarj_python_lint._source import read_python_source, symbol_prefilter_source
 from sarj_python_lint.rule_base import (
     Diagnostic,
     ExampleFile,
@@ -785,7 +785,7 @@ def _candidate_calls_class(
         source = read_python_source(candidate)
     except OSError, SyntaxError, UnicodeError:
         return False
-    if class_name not in source or is_generated(candidate, source):
+    if class_name not in symbol_prefilter_source(source) or is_generated(candidate, source):
         return False
     try:
         tree = ast.parse(source, filename=str(candidate))

{sarj_python_lint-1.27.2 → sarj_python_lint-1.27.4}/src/sarj_python_lint/rules/no_positional_psycopg_row_escape.py

@@ -117,7 +117,7 @@ class NoPositionalPsycopgRowEscape(Rule):
     @override
     def check_context(self, context: PythonFileContext) -> list[Diagnostic]:
         path = context.path
-        source = context.source
+        signals = context.symbol_source
         if (
             context.generated
             or is_test_path(path)
@@ -125,7 +125,7 @@ class NoPositionalPsycopgRowEscape(Rule):
             or "migrations" in {part.lower() for part in path.parts}
         ):
             return []
-        if ".cursor" not in source or not any(f".{method}" in source for method in _FETCH_METHODS):
+        if "cursor" not in signals or not any(method in signals for method in _FETCH_METHODS):
             return []
         tree = context.tree
         if tree is None:

{sarj_python_lint-1.27.2 → sarj_python_lint-1.27.4}/src/sarj_python_lint/rules/no_redundant_module_alias_exports.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import ast
 from pathlib import PurePosixPath
-import re
 from typing import TYPE_CHECKING, ClassVar, final, override
 
 from sarj_python_lint.rule_base import (
@@ -24,7 +23,6 @@ if TYPE_CHECKING:
 
 
 _SYS_SOURCES = frozenset({"sys"})
-_PRIVATE_ALIAS_CANDIDATE_RE = re.compile(r"(?m)^(?![\d_])\w+(?:\s*:[^=\n]+)?(?:\s*=\s*(?!_)\w+)*\s*=\s*_(?!_)\w")
 
 
 @final
@@ -126,6 +124,33 @@ class NoRedundantModuleAliasExports(Rule):
                 public=True,
                 scenario="module-replacement",
             ),
+            RuleExample(
+                example_id="native-parenthesized-alias-matching",
+                title="Native syntax preserves the existing ownership contract",
+                outcome=ExampleOutcome.MATCH,
+                files=(
+                    ExampleFile.python(
+                        "app/pagination.py",
+                        "def _encode_cursor(value: str) -> str:\n    return value\n\n\nencode_phone_number_cursor = (_encode_cursor)\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("app/pagination.py"),
+                expected_count=1,
+                public=True,
+                scenario="native-parenthesized-alias",
+            ),
+            RuleExample(
+                example_id="native-parenthesized-alias-nonmatching",
+                title="Existing semantic ownership exclusions remain valid",
+                outcome=ExampleOutcome.NO_MATCH,
+                files=(
+                    ExampleFile.python("app/pagination.py", '__version__ = "value"\npublic_version = (__version__)\n'),
+                ),
+                focus_path=PurePosixPath("app/pagination.py"),
+                expected_count=0,
+                public=True,
+                scenario="native-parenthesized-alias",
+            ),
         ),
     )
     description: str = documentation.summary
@@ -133,13 +158,8 @@ class NoRedundantModuleAliasExports(Rule):
     @override
     def check_context(self, context: PythonFileContext) -> list[Diagnostic]:
         path = context.path
-        source = context.source
-        has_module_replacement_candidate = "modules" in source and "__name__" in source
-        if (
-            path.suffix != ".py"
-            or (not has_module_replacement_candidate and _PRIVATE_ALIAS_CANDIDATE_RE.search(source) is None)
-            or context.generated
-        ):
+        signals = context.symbol_source
+        if path.suffix != ".py" or "=" not in context.source or "_" not in signals or context.generated:
             return []
         tree = context.tree
         if tree is None: