sarj-python-lint 0.80.15__tar.gz → 0.80.17__tar.gz

{sarj_python_lint-0.80.15 → sarj_python_lint-0.80.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 0.80.15
+Version: 0.80.17
 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/
@@ -19,6 +19,7 @@ Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: >=3.14
 Requires-Dist: ruff>=0.16.5
 Requires-Dist: sqlglot==30.18.0
+Requires-Dist: typer==0.27.2
 Description-Content-Type: text/markdown
 
 <!-- Generated by `code-standards maintain docs sync`; do not edit. -->

{sarj_python_lint-0.80.15 → sarj_python_lint-0.80.17}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sarj-python-lint"
-version = "0.80.15"
+version = "0.80.17"
 description = "Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults"
 readme = "README.md"
 authors = [{ name = "sarj-ai" }]
@@ -15,7 +15,7 @@ classifiers = [
   "Programming Language :: Python :: 3.14",
   "Topic :: Software Development :: Quality Assurance",
 ]
-dependencies = ["ruff>=0.16.5", "sqlglot==30.18.0"]
+dependencies = ["ruff>=0.16.5", "sqlglot==30.18.0", "typer==0.27.2"]
 
 [project.scripts]
 sarj-python-lint = "sarj_python_lint.__main__:main"

{sarj_python_lint-0.80.15 → sarj_python_lint-0.80.17}/src/sarj_python_lint/__main__.py

@@ -1,13 +1,15 @@
 from __future__ import annotations
 
-import argparse
 import ast
 from collections import Counter
+from dataclasses import dataclass
 import json
 from pathlib import Path
 import sys
 from types import MappingProxyType
-from typing import NamedTuple
+from typing import Annotated, NamedTuple
+
+import typer
 
 from sarj_python_lint import __version__
 from sarj_python_lint._analysis_session import AnalysisSession
@@ -236,24 +238,9 @@ def _docstring_owner_locations(source: str) -> dict[int, _OwnerLocation]:
     return owners
 
 
-class _Args(argparse.Namespace):
-    cmd: str | None
-    rule: list[str]
-    # `explain` takes exactly one rule, so it cannot share `--rule`'s list slot
-    # without widening the type and losing the check on every `check` call site.
-    which: str
-    files: list[Path]
-    baseline: Path | None
-    update_baseline: Path | None
-
-    def __init__(self) -> None:
-        super().__init__()
-        self.cmd = None
-        self.rule = []
-        self.which = ""
-        self.files = []
-        self.baseline = None
-        self.update_baseline = None
+@dataclass
+class _Result:
+    code: int = 0
 
 
 def _explain(wanted: str) -> int:
@@ -328,78 +315,98 @@ def _apply_baseline(
     return out
 
 
-def main(argv: list[str] | None = None) -> int:
-    parser = argparse.ArgumentParser(
-        prog="sarj-python-lint",
-        description="Custom Python lint rules.",
-    )
-    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
-    sub = parser.add_subparsers(dest="cmd", required=True)
-
-    check_p = sub.add_parser("check", help="Run rules over files.")
-    check_p.add_argument(
-        "--rule",
-        action="append",
-        required=True,
-        help="Rule ID (repeat for multiple).",
-    )
-    check_p.add_argument(
-        "--baseline",
-        type=Path,
-        help="Per-file shrink-only baseline JSON: {path: {CODE: count}}. Diags up to the baselined count are suppressed.",
-    )
-    check_p.add_argument(
-        "--update-baseline",
-        type=Path,
-        help="Write the current per-file diagnostic counts to this JSON and exit 0.",
-    )
-    check_p.add_argument("files", nargs="+", type=Path)
-
-    sub.add_parser("list-rules", help="List available rule IDs.")
-
-    explain_p = sub.add_parser("explain", help="Print one rule's summary and the links to its examples and evidence.")
-    explain_p.add_argument("which", metavar="rule", help="Rule ID or SARJ code.")
-
-    args = parser.parse_args(argv, namespace=_Args())
-
-    if args.cmd == "list-rules":
-        for rid, cls in sorted(REGISTRY.items()):
-            inst = cls()
-            sys.stdout.write(f"{inst.code:8}  {rid:40}  {inst.description}\n")
-        return 0
-
-    if args.cmd == "explain":
-        return _explain(args.which)
-
+def _run_check(rule: list[str], files: list[Path], baseline: Path | None, update_baseline: Path | None) -> int:
     try:
-        diags = analyze(args.rule, args.files)
+        diags = analyze(rule, files)
     except (OSError, ValueError) as exc:
         sys.stderr.write(f"error: {exc}\n")
         return 2
-    if args.update_baseline is not None:
+    if update_baseline is not None:
         counts = _baseline_counts(diags)
         blocking = sum(d.severity is Severity.ERROR for d in diags)
         warnings = len(diags) - blocking
         try:
-            atomic_write_text(args.update_baseline, json.dumps(counts, indent=2, sort_keys=True) + "\n")
+            atomic_write_text(update_baseline, json.dumps(counts, indent=2, sort_keys=True) + "\n")
         except OSError as exc:
-            sys.stderr.write(f"error: cannot write baseline {args.update_baseline}: {exc}\n")
+            sys.stderr.write(f"error: cannot write baseline {update_baseline}: {exc}\n")
             return 2
         sys.stdout.write(
-            f"baseline written: {args.update_baseline} "
+            f"baseline written: {update_baseline} "
             f"({blocking} blocking diagnostics over {len(counts)} files; {warnings} warnings excluded)\n"
         )
         return 0
-    if args.baseline is not None:
+    if baseline is not None:
         try:
-            diags = _apply_baseline(diags, _read_baseline(args.baseline))
+            diags = _apply_baseline(diags, _read_baseline(baseline))
         except (OSError, ValueError) as exc:
-            sys.stderr.write(f"error: invalid baseline {args.baseline}: {exc}\n")
+            sys.stderr.write(f"error: invalid baseline {baseline}: {exc}\n")
             return 2
     for d in diags:
         sys.stdout.write(d.format() + "\n")
     return 1 if any(d.severity is Severity.ERROR for d in diags) else 0
 
 
+app = typer.Typer(
+    help="Custom Python lint rules.",
+    add_completion=False,
+    no_args_is_help=False,
+    pretty_exceptions_enable=False,
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+
+
+def _show_version(*, value: bool) -> None:
+    if value:
+        sys.stdout.write(f"sarj-python-lint {__version__}\n")
+        raise typer.Exit
+
+
+@app.callback()
+def _root(
+    *,
+    _version: Annotated[bool, typer.Option("--version", callback=_show_version, is_eager=True)] = False,
+) -> None:
+    pass
+
+
+@app.command("list-rules", help="List available rule IDs.")
+def _list_rules() -> None:
+    for rid, cls in sorted(REGISTRY.items()):
+        inst = cls()
+        sys.stdout.write(f"{inst.code:8}  {rid:40}  {inst.description}\n")
+
+
+@app.command("explain", help="Print one rule's summary and the links to its examples and evidence.")
+def _explain_command(
+    context: typer.Context, which: Annotated[str, typer.Argument(metavar="rule", help="Rule ID or SARJ code.")]
+) -> None:
+    context.ensure_object(_Result).code = _explain(which)
+
+
+@app.command("check", help="Run rules over files.")
+def _check_command(
+    context: typer.Context,
+    files: Annotated[list[Path], typer.Argument()],
+    rule: Annotated[list[str], typer.Option("--rule", help="Rule ID (repeat for multiple).")],
+    baseline: Annotated[
+        Path | None, typer.Option(help="Per-file shrink-only baseline JSON: {path: {CODE: count}}.")
+    ] = None,
+    update_baseline: Annotated[
+        Path | None, typer.Option(help="Write current per-file diagnostic counts to JSON and exit 0.")
+    ] = None,
+) -> None:
+    context.ensure_object(_Result).code = _run_check(rule, files, baseline, update_baseline)
+
+
+def main(argv: list[str] | None = None) -> int:
+    result = _Result()
+    try:
+        app(args=argv, prog_name="sarj-python-lint", obj=result)
+    except SystemExit as exc:
+        if exc.code != 0:
+            raise
+    return result.code
+
+
 if __name__ == "__main__":
     sys.exit(main())

{sarj_python_lint-0.80.15 → sarj_python_lint-0.80.17}/src/sarj_python_lint/_ratchet_cli.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
-import argparse
+from dataclasses import dataclass
 import json
 from pathlib import Path
 import subprocess  # ruff: ignore[suspicious-subprocess-import] -- fixed local Ruff introspection only
 import sys
-from typing import TYPE_CHECKING, TypeGuard
+from typing import TYPE_CHECKING, Annotated, TypeGuard
+
+import typer
 
 from sarj_python_lint._filesystem import atomic_write_text
 from sarj_python_lint._version import __version__
@@ -29,7 +31,8 @@ if TYPE_CHECKING:
 _DEFAULT_BASELINE_NAME = "suppression-baseline.json"
 
 
-class _Args(argparse.Namespace):
+@dataclass(frozen=True)
+class _Options:
     root: Path
     baseline: Path | None
     package: list[str]
@@ -38,19 +41,8 @@ class _Args(argparse.Namespace):
     update: bool
     allow_increase: bool
 
-    def __init__(self) -> None:
-        super().__init__()
-        self.root = Path()
-        self.baseline = None
-        self.package = []
-        self.exclude_subtree = []
-        self.per_file_ceiling = None
-        self.update = False
-        self.allow_increase = False
-
 
-def main(argv: list[str] | None = None) -> int:
-    args = _build_parser().parse_args(argv, namespace=_Args())
+def _run(args: _Options) -> int:
     root = args.root.resolve()
     baseline_path = args.baseline if args.baseline is not None else root / _DEFAULT_BASELINE_NAME
 
@@ -180,48 +172,68 @@ def _is_string_object_mapping(value: object) -> TypeGuard[dict[str, object]]:
     return isinstance(value, dict)
 
 
-def _build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(
-        prog="sarj-ratchet",
-        description=(
-            "Ratchet on lint/type suppressions: per-code, per-package and per-file ceilings that may only shrink."
+@dataclass
+class _Result:
+    code: int = 0
+
+
+app = typer.Typer(
+    help="Ratchet on lint/type suppressions: per-code, per-package and per-file ceilings that may only shrink.",
+    add_completion=False,
+    no_args_is_help=False,
+    pretty_exceptions_enable=False,
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+
+
+def _show_version(*, value: bool) -> None:
+    if value:
+        sys.stdout.write(f"sarj-ratchet {__version__}\n")
+        raise typer.Exit
+
+
+@app.command()
+def _command(
+    context: typer.Context,
+    *,
+    root: Annotated[Path, typer.Argument(help="tree to scan (default: cwd)")] = Path(),
+    baseline: Annotated[
+        Path | None, typer.Option(help=f"baseline JSON (default: <root>/{_DEFAULT_BASELINE_NAME})")
+    ] = None,
+    package: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--package", help="package directory relative to root (repeatable; default: baseline or auto-discovered)"
         ),
+    ] = None,
+    exclude_subtree: Annotated[
+        list[str] | None, typer.Option("--exclude-subtree", help="root-relative path prefix to skip (repeatable)")
+    ] = None,
+    per_file_ceiling: Annotated[
+        int | None,
+        typer.Option(help=f"max suppressions in any one file (default: baseline or {DEFAULT_PER_FILE_CEILING})"),
+    ] = None,
+    update: Annotated[
+        bool, typer.Option("--update", help="rewrite baseline from current counts (refuses to raise a ceiling)")
+    ] = False,
+    allow_increase: Annotated[
+        bool, typer.Option("--allow-increase", help="with --update: permit ceilings to rise (requires explicit review)")
+    ] = False,
+    _version: Annotated[bool, typer.Option("--version", callback=_show_version, is_eager=True)] = False,
+) -> None:
+    context.ensure_object(_Result).code = _run(
+        _Options(root, baseline, package or [], exclude_subtree or [], per_file_ceiling, update, allow_increase)
     )
-    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
-    parser.add_argument("root", nargs="?", type=Path, default=Path(), help="tree to scan (default: cwd)")
-    parser.add_argument(
-        "--baseline",
-        type=Path,
-        help=f"baseline JSON (default: <root>/{_DEFAULT_BASELINE_NAME})",
-    )
-    parser.add_argument(
-        "--package",
-        action="append",
-        default=[],
-        help="package directory relative to root (repeatable; default: the baseline's, else auto-discovered)",
-    )
-    parser.add_argument(
-        "--exclude-subtree",
-        action="append",
-        default=[],
-        help="root-relative path prefix to skip, e.g. generated client output (repeatable)",
-    )
-    parser.add_argument(
-        "--per-file-ceiling",
-        type=int,
-        help=f"max suppressions in any one file (default: the baseline's, else {DEFAULT_PER_FILE_CEILING})",
-    )
-    parser.add_argument(
-        "--update",
-        action="store_true",
-        help="rewrite the baseline from current counts (refuses to raise a ceiling)",
-    )
-    parser.add_argument(
-        "--allow-increase",
-        action="store_true",
-        help="with --update: permit ceilings to rise (requires explicit review)",
-    )
-    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    result = _Result()
+    try:
+        app(args=argv, prog_name="sarj-ratchet", obj=result)
+    except SystemExit as exc:
+        if exc.code != 0:
+            raise
+    return result.code
 
 
 def _update(

{sarj_python_lint-0.80.15 → sarj_python_lint-0.80.17}/src/sarj_python_lint/rules/_registry.py

@@ -92,6 +92,7 @@ from sarj_python_lint.rules.prefer_immutable_module_constant import (
 from sarj_python_lint.rules.prefer_library_fake import PreferLibraryFake
 from sarj_python_lint.rules.prefer_match_assert_never import PreferMatchAssertNever
 from sarj_python_lint.rules.prefer_match_type_dispatch import PreferMatchTypeDispatch
+from sarj_python_lint.rules.prefer_match_value_dispatch import PreferMatchValueDispatch
 from sarj_python_lint.rules.prefer_module_level_constant import (
     PreferModuleLevelConstant,
 )
@@ -218,6 +219,7 @@ REGISTRY: Mapping[str, type[Rule]] = MappingProxyType(
         RequirePortForService.id: RequirePortForService,
         PreferNonNullableCollection.id: PreferNonNullableCollection,
         PreferMatchTypeDispatch.id: PreferMatchTypeDispatch,
+        PreferMatchValueDispatch.id: PreferMatchValueDispatch,
         PreferWalrusRegexMatch.id: PreferWalrusRegexMatch,
         PreferWalrusComprehensionFilter.id: PreferWalrusComprehensionFilter,
         PreferWalrusStreamLoop.id: PreferWalrusStreamLoop,

{sarj_python_lint-0.80.15 → sarj_python_lint-0.80.17}/src/sarj_python_lint/rules/no_comment_cruft.py

@@ -4,6 +4,7 @@ import ast
 from pathlib import PurePosixPath
 import re
 import tokenize
+import tomllib
 from typing import TYPE_CHECKING, ClassVar, override
 
 from sarj_python_lint.rule_base import (
@@ -227,6 +228,27 @@ _CODING_COOKIE_RE = re.compile(r"coding[:=]\s*[-_.a-zA-Z0-9]+")
 # Only `>>>` arms a doctest block.
 _DOCTEST_PROMPT = ">>>"
 
+_SCRIPT_METADATA_RE = re.compile(r"^# /// script\n(?P<content>(?:#(?: .*)?\n)+)# ///(?=\n|$)", re.MULTILINE)
+
+
+def _script_metadata_lines(source: str, standalone: Sequence[PositionedComment]) -> frozenset[int]:
+    normalized = "\n".join(source.splitlines())
+    matches = list(_SCRIPT_METADATA_RE.finditer(normalized))
+    if len(matches) != 1:
+        return frozenset()
+    match = matches[0]
+    first = normalized.count("\n", 0, match.start()) + 1
+    lines = frozenset(range(first, first + match.group().count("\n") + 1))
+    top_level = {line for line, col, _ in standalone if col == 0}
+    if not lines <= top_level:
+        return frozenset()
+    content = "\n".join(line[2:] if line.startswith("# ") else "" for line in match.group("content").splitlines())
+    try:
+        tomllib.loads(content)
+    except tomllib.TOMLDecodeError:
+        return frozenset()
+    return lines
+
 
 def _is_coding_cookie(body: str) -> bool:
     return bool(_CODING_COOKIE_RE.search(body))
@@ -499,6 +521,8 @@ class NoCommentCruft(Rule):
             standalone, first_code_line = standalone_comments(source)
         except tokenize.TokenError, IndentationError, SyntaxError:
             return []
+        skip = _script_metadata_lines(source, standalone)
+        standalone = [comment for comment in standalone if comment.line not in skip]
         diags: dict[int, Diagnostic] = {}
         by_line = {line: (col, body) for line, col, body in standalone}
         skip = _doctest_block_lines(standalone) | _illustration_block_lines(standalone)

sarj_python_lint-0.80.17/src/sarj_python_lint/rules/prefer_match_value_dispatch.py

@@ -0,0 +1,230 @@
+from __future__ import annotations
+
+import ast
+from collections import Counter
+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,
+    parse_or_none,
+)
+from sarj_python_lint.rules._paths import is_generated
+
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+type _Literal = str | bytes | int | float
+_MIN_TESTS = 2
+
+
+@final
+class PreferMatchValueDispatch(Rule):
+    id: str = "prefer-match-value-dispatch"
+    code: str = "SARJ439"
+    documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
+        summary="Prefer match/case for repeated equality dispatch with a fallback.",
+        rationale="A single dispatch subject makes distinct value cases and their fallback easier to review.",
+        remediation=(
+            "Consider match/case while preserving fallback and constant semantics; use literal or dotted value "
+            "patterns, never bare constant names that capture instead of compare."
+        ),
+        category=RuleCategory.MAINTAINABILITY,
+        autofix=AutofixPolicy.NONE,
+        limitations=(
+            "Only two or more equality tests on the same left-hand name or attribute chain, followed by else, are checked.",
+            "Cases must be distinct string, bytes, or numeric literals, or singly bound module constants containing them; shadowed constants and singleton values are excluded.",
+            "This is a readability suggestion, not proof of exhaustiveness or a safe automatic rewrite: attributes can have side effects and match evaluates its subject once.",
+        ),
+        examples=(
+            RuleExample(
+                example_id="named-file-dispatch",
+                title="Make repeated filename dispatch explicit",
+                outcome=ExampleOutcome.MATCH,
+                files=(
+                    ExampleFile.python(
+                        "app/migrate.py",
+                        "_ESLINT_SUPPRESSIONS = 'eslint.json'\n"
+                        "_RATCHET_SUPPRESSIONS = 'ratchet.json'\n"
+                        "def migrate(path):\n"
+                        "    if path.name == _ESLINT_SUPPRESSIONS:\n"
+                        "        migrated = rewrite_eslint(path)\n"
+                        "    elif path.name == _RATCHET_SUPPRESSIONS:\n"
+                        "        migrated = rewrite_ratchet(path)\n"
+                        "    else:\n"
+                        "        migrated = rewrite(path)\n"
+                        "    return migrated\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("app/migrate.py"),
+                expected_count=1,
+                public=True,
+            ),
+            RuleExample(
+                example_id="literal-match-dispatch",
+                title="Use value cases and retain the fallback",
+                outcome=ExampleOutcome.NO_MATCH,
+                files=(
+                    ExampleFile.python(
+                        "app/migrate.py",
+                        "def migrate(path):\n"
+                        "    match path.name:\n"
+                        "        case 'eslint.json':\n"
+                        "            return rewrite_eslint(path)\n"
+                        "        case 'ratchet.json':\n"
+                        "            return rewrite_ratchet(path)\n"
+                        "        case _:\n"
+                        "            return rewrite(path)\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("app/migrate.py"),
+                expected_count=0,
+                public=True,
+            ),
+        ),
+    )
+    description: str = documentation.summary
+
+    @override
+    def check(self, path: Path, source: str) -> list[Diagnostic]:
+        if is_generated(path, source):
+            return []
+        tree = parse_or_none(path, source)
+        if tree is None:
+            return []
+        constants = _module_constants(tree)
+        lines = source.splitlines()
+        continuations: set[int] = set()
+        findings: list[Diagnostic] = []
+        for node in ast.walk(tree):
+            if not isinstance(node, ast.If) or id(node) in continuations:
+                continue
+            branches = [node]
+            current = node
+            while len(current.orelse) == 1:
+                child = current.orelse[0]
+                if not isinstance(child, ast.If) or not lines[child.lineno - 1].lstrip().startswith("elif"):
+                    break
+                continuations.add(id(child))
+                branches.append(child)
+                current = child
+            if len(branches) < _MIN_TESTS or not current.orelse:
+                continue
+            subject = _dispatch_subject(branches, constants)
+            if subject is not None:
+                findings.append(
+                    Diagnostic(
+                        path=path,
+                        line=node.lineno,
+                        col=node.col_offset + 1,
+                        code=self.code,
+                        severity=Severity.WARNING,
+                        message=(
+                            f"Repeated equality dispatch on '{subject}' with a fallback — consider match/case; "
+                            "preserve fallback and constant semantics, and review repeated attribute evaluation."
+                        ),
+                    )
+                )
+        return findings
+
+
+def _module_constants(tree: ast.Module) -> dict[str, _Literal]:
+    bindings: Counter[str] = Counter()
+    for node in ast.walk(tree):
+        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)
+                | ast.TypeVar(name=name)
+                | ast.ParamSpec(name=name)
+                | ast.TypeVarTuple(name=name)
+            ):
+                bindings[name] += 1
+            case ast.alias(name=name, asname=alias):
+                if name == "*":
+                    return {}
+                bindings[alias or name.partition(".")[0]] += 1
+            case (
+                ast.ExceptHandler(name=name)
+                | ast.MatchAs(name=name)
+                | ast.MatchStar(name=name)
+                | ast.MatchMapping(rest=name)
+            ):
+                if name is not None:
+                    bindings[name] += 1
+            case ast.Global(names=names) | ast.Nonlocal(names=names):
+                bindings.update(names)
+            case _:
+                pass
+    constants: dict[str, _Literal] = {}
+    for statement in tree.body:
+        match statement:
+            case ast.Assign(targets=[ast.Name(id=name)], value=value):
+                literal = _literal(value)
+            case ast.AnnAssign(target=ast.Name(id=name), value=value) if value is not None:
+                literal = _literal(value)
+            case _:
+                continue
+        if literal is not None and bindings[name] == 1:
+            constants[name] = literal
+    return constants
+
+
+def _literal(expression: ast.expr) -> _Literal | None:
+    match expression:
+        case ast.Constant(value=value) if isinstance(value, (str, bytes, int, float)) and not isinstance(value, bool):
+            return value
+        case ast.UnaryOp(op=ast.USub() | ast.UAdd(), operand=ast.Constant(value=value)) if isinstance(
+            value, (int, float)
+        ) and not isinstance(value, bool):
+            return -value if isinstance(expression.op, ast.USub) else value
+        case _:
+            return None
+
+
+def _dispatch_subject(branches: list[ast.If], constants: dict[str, _Literal]) -> str | None:
+    subject: str | None = None
+    values: set[_Literal] = set()
+    bodies: set[tuple[str, ...]] = set()
+    for branch in branches:
+        body = tuple(ast.dump(statement) for statement in branch.body)
+        if body in bodies:
+            return None
+        bodies.add(body)
+        match branch.test:
+            case ast.Compare(left=left, ops=[ast.Eq()], comparators=[right]):
+                candidate = _subject(left)
+                value = constants.get(right.id) if isinstance(right, ast.Name) else _literal(right)
+            case _:
+                return None
+        if candidate is None or candidate.partition(".")[0] in constants or value is None or value in values:
+            return None
+        if subject is not None and candidate != subject:
+            return None
+        subject = candidate
+        values.add(value)
+    return subject
+
+
+def _subject(expression: ast.expr) -> str | None:
+    match expression:
+        case ast.Name(id=name):
+            return name
+        case ast.Attribute(value=value, attr=attribute):
+            parent = _subject(value)
+            return f"{parent}.{attribute}" if parent is not None else None
+        case _:
+            return None

{sarj_python_lint-0.80.15 → sarj_python_lint-0.80.17}/src/sarj_python_lint/rules/prefer_str_enum.py

@@ -1492,12 +1492,13 @@ def _merge_cluster(
     entry = clusters.get(key, (*pos, set[str](), set[str](), set[str](), set[str](), False))
     line, col, seen, eq_seen, ne_seen, in_seen, was_closed = entry
     line, col = min((line, col), pos)
-    if operator == _EQ:
-        eq_seen |= set(literals)
-    elif operator == _NE:
-        ne_seen |= set(literals)
-    else:
-        in_seen |= set(literals)
+    match operator:
+        case "==":
+            eq_seen |= set(literals)
+        case "!=":
+            ne_seen |= set(literals)
+        case _:
+            in_seen |= set(literals)
     clusters[key] = (line, col, seen | set(literals), eq_seen, ne_seen, in_seen, was_closed or closed)