sarj-python-lint 1.27.3__tar.gz → 1.27.5__tar.gz

{sarj_python_lint-1.27.3 → sarj_python_lint-1.27.5}/PKG-INFO

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

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

{sarj_python_lint-1.27.3 → sarj_python_lint-1.27.5}/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.3 → sarj_python_lint-1.27.5}/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.3 → sarj_python_lint-1.27.5}/src/sarj_python_lint/interpreter_argv.py

@@ -28,9 +28,46 @@ class InterpreterInvocation:
 class ParsedOption:
     invocation: InterpreterInvocation | None = None
     consumed: int = 1
+    stdin_mode: bool = False
+    command_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",
@@ -76,6 +113,7 @@ _WRAPPER_VALUES = MappingProxyType(
             }
         ),
         "timeout": frozenset({"-s", "--signal", "-k", "--kill-after"}),
+        "dumb-init": frozenset(),
     }
 )
 _MAX_WRAPPERS = 8
@@ -100,6 +138,8 @@ def unwrap_command(
             continue
         if command not in _WRAPPER_VALUES or (allowed_wrappers is not None and command not in allowed_wrappers):
             return current
+        # dumb-init uses execvp; its child cannot be a shell builtin.
+        allow_shell_builtins = allow_shell_builtins and command != "dumb-init"
         current = current[_value_wrapper_index(current, command) :]
     msg = "command wrapper nesting exceeds analysis bound"
     raise UnprovableCommandError(msg)
@@ -124,6 +164,8 @@ 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)
+    if command == "dumb-init":
+        return _dumb_init_wrapper_index(arguments)
     index = 1
     while index < len(arguments):
         argument = arguments[index]
@@ -137,6 +179,24 @@ def _value_wrapper_index(arguments: Sequence[str], command: str) -> int:
     return index + int(command == "timeout")
 
 
+def _dumb_init_wrapper_index(arguments: Sequence[str]) -> int:
+    index = 1
+    while index < len(arguments):
+        argument = arguments[index]
+        if argument in {"-h", "--help", "-V", "--version"}:
+            return len(arguments)
+        if argument == "--":
+            index += 1
+            break
+        if not argument.startswith("-") or argument == "-":
+            break
+        if argument not in {"-c", "--single-child", "-v", "--verbose"}:
+            msg = "unsupported dumb-init wrapper option"
+            raise UnprovableCommandError(msg)
+        index += 1
+    return index
+
+
 def _env_wrapper_index(arguments: Sequence[str]) -> int:
     index = 1
     while index < len(arguments) and arguments[index].startswith("-"):
@@ -200,7 +260,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, shell_name=executable
+        )
     if executable in {"node", "nodejs"}:
         return _node(arguments[1:])
     if executable == "jq":
@@ -304,40 +366,105 @@ 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, shell_name: str = ""
 ) -> InterpreterInvocation:
     index = 0
+    stdin_mode = False
+    command_mode = False
+    short_seen = False
+    bash_mode = shell_name == "bash"
+    validated_shell = shell_name in {"bash", "sh", "dash"}
     while index < len(arguments):
         boundary = _external_boundary(arguments, index, plus_options=True)
+        if boundary is not None and command_mode:
+            index += int(arguments[index] in {"-", "--"})
+            if index >= len(arguments):
+                return InterpreterInvocation("unknown")
+            return InterpreterInvocation("shell", arguments[index], tuple(arguments[index + 2 :]))
         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, validated_shell=validated_shell
+            )
         if parsed.invocation is not None:
             return parsed.invocation
+        stdin_mode = stdin_mode or parsed.stdin_mode
+        command_mode = command_mode or parsed.command_mode
         index += parsed.consumed
-    return InterpreterInvocation("stdin")
+    return InterpreterInvocation("unknown" if command_mode else "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,
+    validated_shell: bool = False,
 ) -> ParsedOption:
+    if validated_shell:
+        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 :]
+            if shell_mode:
+                if not values.isdisjoint(argument[cursor + 1 :]):
+                    return ParsedOption(InterpreterInvocation("unknown"))
+                return ParsedOption(command_mode=True)
+            attached = argument[cursor + 1 :]
             operand = attached or _following_operand(arguments, index)
-            forwarded = tuple(arguments[index + 3 :]) if shell_mode else ()
-            return ParsedOption(InterpreterInvocation("shell" if shell_mode else "inline", operand, forwarded))
+            return ParsedOption(InterpreterInvocation("inline", operand))
         if flag in values:
+            if shell_mode and (flag == "O" or argument[cursor + 1 :] == "c"):
+                return ParsedOption(InterpreterInvocation("unknown"))
             return ParsedOption(consumed=1 + int(cursor + 1 == len(argument)))
     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
+    return ParsedOption(consumed=consumed, stdin_mode="s" in flags, command_mode="c" in flags)
+
+
 def _node(arguments: Sequence[str]) -> InterpreterInvocation:
     index = 0
     while index < len(arguments):

{sarj_python_lint-1.27.3 → sarj_python_lint-1.27.5}/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.3 → sarj_python_lint-1.27.5}/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.3 → sarj_python_lint-1.27.5}/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.3 → sarj_python_lint-1.27.5}/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.3 → sarj_python_lint-1.27.5}/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.3 → sarj_python_lint-1.27.5}/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.3 → sarj_python_lint-1.27.5}/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.3 → sarj_python_lint-1.27.5}/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.3 → sarj_python_lint-1.27.5}/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:

{sarj_python_lint-1.27.3 → sarj_python_lint-1.27.5}/src/sarj_python_lint/rules/no_service_behavior_in_settings.py

@@ -25,7 +25,6 @@ if TYPE_CHECKING:
 
 
 _DATA_NAME_RE = re.compile(r"(?:Settings|Config|Configuration|Options)$")
-_DATA_CLASS_RE = re.compile(r"\bclass\s+\w+(?:Settings|Config|Configuration|Options)\b")
 _COLLABORATOR_RE = re.compile(
     r"(?:Client|Service|Store|Repository|Repo|Gateway|Provider|Pool|Publisher|Queue|Scheduler)$"
 )
@@ -104,6 +103,36 @@ class NoServiceBehaviorInSettings(Rule):
                 expected_count=0,
                 public=True,
             ),
+            RuleExample(
+                example_id="bare-settings-matching",
+                title="Native syntax preserves the existing ownership contract",
+                outcome=ExampleOutcome.MATCH,
+                files=(
+                    ExampleFile.python(
+                        "app/settings.py",
+                        "class Settings:\n    def __init__(self, store: ScheduleStore) -> None:\n        self._store = store\n\n    async def repoint(self, batch_id: str) -> int:\n        return await self._store.repoint(batch_id)\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("app/settings.py"),
+                expected_count=1,
+                public=True,
+                scenario="bare-settings",
+            ),
+            RuleExample(
+                example_id="bare-settings-nonmatching",
+                title="Existing semantic ownership exclusions remain valid",
+                outcome=ExampleOutcome.NO_MATCH,
+                files=(
+                    ExampleFile.python(
+                        "app/settings.py",
+                        "class Settings:\n    def __init__(self, size: int): self.size = size\n    def double(self): return self.size * 2\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("app/settings.py"),
+                expected_count=0,
+                public=True,
+                scenario="bare-settings",
+            ),
         ),
     )
     description: str = documentation.summary
@@ -111,12 +140,13 @@ class NoServiceBehaviorInSettings(Rule):
     @override
     def check_context(self, context: PythonFileContext) -> list[Diagnostic]:
         path = context.path
-        source = context.source
+        signals = context.symbol_source
         if (
             is_test_path(path)
             or is_test_support_path(path)
             or context.generated
-            or _DATA_CLASS_RE.search(source) is None
+            or "class" not in signals
+            or not any(name in signals for name in ("Settings", "Config", "Options"))
         ):
             return []
         tree = context.tree