sarj-python-lint 0.25.0__tar.gz → 0.27.0__tar.gz

{sarj_python_lint-0.25.0 → sarj_python_lint-0.27.0}/.gitignore

@@ -34,3 +34,4 @@ Thumbs.db
 # Claude Code local state (shared settings.json is tracked)
 .claude/*
 !.claude/settings.json
+.worktrees/

{sarj_python_lint-0.25.0 → sarj_python_lint-0.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sarj-python-lint
-Version: 0.25.0
+Version: 0.27.0
 Summary: Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults
 Project-URL: Homepage, https://github.com/sarj-ai/standards/tree/main/packages/python
 Project-URL: Repository, https://github.com/sarj-ai/standards
@@ -240,7 +240,7 @@ disappears — and the query still runs — whenever the filter is empty:
 
 ```python
 where_conditions = []
-if args.organization_ids:                                    # ← optional
+if args.organization_ids:  # ← optional
     where_conditions.append(SQL("organization_id = ANY(%s::uuid[])"))
 ...
 where_clause = SQL(" AND ").join(where_conditions) if where_conditions else SQL("1=1")
@@ -282,12 +282,12 @@ is the assertion whose real condition slid out of the condition slot, because it
 was a working assertion when it was typed:
 
 ```python
-assert {                                              # ← braces, not parentheses
+assert {  # ← braces, not parentheses
     "referencing a non existing `via_device` " in caplog.text
-}                                                     # one-element SET, always truthy
+}  # one-element SET, always truthy
 
-assert [f"No logs found on hdfs for ti={ti}"]         # the `== messages` was lost
-assert True, cover_result_json[0]["success"][...]     # slid into the MESSAGE slot
+assert [f"No logs found on hdfs for ti={ti}"]  # the `== messages` was lost
+assert True, cover_result_json[0]["success"][...]  # slid into the MESSAGE slot
 ```
 
 **The narrowness is the rule.** The obvious generalisation — "flag a comparison

{sarj_python_lint-0.25.0 → sarj_python_lint-0.27.0}/README.md

@@ -222,7 +222,7 @@ disappears — and the query still runs — whenever the filter is empty:
 
 ```python
 where_conditions = []
-if args.organization_ids:                                    # ← optional
+if args.organization_ids:  # ← optional
     where_conditions.append(SQL("organization_id = ANY(%s::uuid[])"))
 ...
 where_clause = SQL(" AND ").join(where_conditions) if where_conditions else SQL("1=1")
@@ -264,12 +264,12 @@ is the assertion whose real condition slid out of the condition slot, because it
 was a working assertion when it was typed:
 
 ```python
-assert {                                              # ← braces, not parentheses
+assert {  # ← braces, not parentheses
     "referencing a non existing `via_device` " in caplog.text
-}                                                     # one-element SET, always truthy
+}  # one-element SET, always truthy
 
-assert [f"No logs found on hdfs for ti={ti}"]         # the `== messages` was lost
-assert True, cover_result_json[0]["success"][...]     # slid into the MESSAGE slot
+assert [f"No logs found on hdfs for ti={ti}"]  # the `== messages` was lost
+assert True, cover_result_json[0]["success"][...]  # slid into the MESSAGE slot
 ```
 
 **The narrowness is the rule.** The obvious generalisation — "flag a comparison

{sarj_python_lint-0.25.0 → sarj_python_lint-0.27.0}/pyproject.toml

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

{sarj_python_lint-0.25.0 → sarj_python_lint-0.27.0}/src/sarj_python_lint/ratchet.py

@@ -210,14 +210,14 @@ def gate(measurement: Measurement, baseline: Baseline) -> list[Failure]:
 
     """
     failures = [
-        Failure(dimension="code", key=key, ceiling=baseline.codes.get(key, 0), actual=n)
+        Failure(dimension="code", key=key, ceiling=c, actual=n)
         for key, n in sorted(measurement.codes.items())
-        if n > baseline.codes.get(key, 0)
+        if n > (c := baseline.codes.get(key, 0))
     ]
     failures += [
-        Failure(dimension="package", key=key, ceiling=baseline.packages.get(key, 0), actual=n)
+        Failure(dimension="package", key=key, ceiling=c, actual=n)
         for key, n in sorted(measurement.packages.items())
-        if n > baseline.packages.get(key, 0)
+        if n > (c := baseline.packages.get(key, 0))
     ]
     failures += [
         Failure(dimension="file", key=key, ceiling=ceiling, actual=n)
@@ -337,11 +337,11 @@ def discover_packages(root: Path, excluded_dir_names: frozenset[str] = DEFAULT_E
 
     """
     return sorted(
-        child.name
+        name
         for child in root.iterdir()
-        if child.is_dir()
-        and child.name not in excluded_dir_names
-        and not child.name.startswith(".")
+        if (name := child.name) not in excluded_dir_names
+        and not name.startswith(".")
+        and child.is_dir()
         and any(True for _ in _python_files(child, excluded_dir_names))
     )
 

{sarj_python_lint-0.25.0 → sarj_python_lint-0.27.0}/src/sarj_python_lint/rule_base.py

@@ -46,7 +46,7 @@ def is_suppressed(source_lines: Sequence[str], line: int, code: str) -> bool:
     if not codes_str:
         # Bare `# sarj-noqa` suppresses every SARJ code on the line
         return True
-    codes = {c.strip().upper() for c in codes_str.split(",") if c.strip()}
+    codes = {val.upper() for c in codes_str.split(",") if (val := c.strip())}
     return code.upper() in codes
 
 

sarj_python_lint-0.27.0/src/sarj_python_lint/rules/_ast_index.py

@@ -0,0 +1,180 @@
+"""One tree traversal per file, shared by every rule that needs node lookups.
+
+Profiling the whole registry over a 1,920-line module showed `ast.walk` and its
+helpers (`iter_child_nodes` / `iter_fields`) accounting for ~60% of all rule
+time. The cause is structural rather than any one rule's fault: the dominant
+shape of a rule is
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Something):
+            ...
+
+so a file with N nodes and R rules asking that question pays R full traversals,
+each one re-deriving the same partition of the tree by node type.
+
+`nodes()` derives that partition **once per file** and answers every subsequent
+type query from it. The index is memoized in a single slot keyed on tree
+identity, mirroring `parse_or_none`: the CLI iterates files on the outer loop
+and rules on the inner one, so one slot is all that is ever live. The slot holds
+a strong reference to the tree, so a recycled `id()` can never alias a stale
+index.
+
+Two invariants make the substitution finding-preserving, not merely faster:
+
+* **Order.** The index is built by breadth-first traversal, the same order
+  `ast.walk` yields, and every query preserves it. `nodes(tree, T)` is therefore
+  elementwise equal to `[n for n in ast.walk(tree) if isinstance(n, T)]`, so a
+  rule that takes the *first* match, or reports in discovery order, is
+  unaffected.
+* **Subclasses.** Queries match by `isinstance`, not by exact type: the buckets
+  are keyed on exact class, and a query resolves to the set of present classes
+  that are subclasses of the requested types. Asking for `ast.stmt` still
+  returns every statement.
+
+`walk()` is the same breadth-first order for the cases the index cannot serve —
+traversing a *subtree* rather than the module, where containment is not
+something a whole-module partition can answer.
+
+No rule may mutate the tree. That was already required — every rule shares one
+memoized parse, and `duplicate_test_body` deep-copies before normalizing — and
+the index inherits the requirement, since it holds references into the tree it
+was built from.
+"""
+
+from __future__ import annotations
+
+import ast
+from typing import TYPE_CHECKING, final
+
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+
+_AST = ast.AST
+
+
+def children(node: ast.AST) -> list[ast.AST]:
+    """`node`'s direct children, in the same order as `ast.iter_child_nodes`.
+
+    A list rather than a generator: every caller either iterates it once or
+    extends a stack with it, and the hand-rolled walkers in this package call
+    this once per node, where the generator's setup cost dominates the work.
+
+    Returns:
+        The child nodes, in field-declaration order.
+
+    """
+    out: list[ast.AST] = []
+    for name in node._fields:
+        value: object = getattr(node, name, None)
+        if isinstance(value, list):
+            out += [item for item in value if isinstance(item, _AST)]  # pyright: ignore[reportUnknownVariableType] — element narrowed by isinstance
+        elif isinstance(value, _AST):
+            out.append(value)
+    return out
+
+
+def walk(node: ast.AST) -> Iterator[ast.AST]:
+    """Yield `node` and every descendant, breadth-first.
+
+    Identical in order to `ast.walk`, but reads each node's fields directly
+    instead of routing every node through two intermediate generators.
+
+    Yields:
+        `node` first, then its descendants breadth-first.
+
+    """
+    queue: list[ast.AST] = [node]
+    i = 0
+    while i < len(queue):
+        current = queue[i]
+        i += 1
+        for name in current._fields:
+            value: object = getattr(current, name, None)
+            if isinstance(value, list):
+                queue += [item for item in value if isinstance(item, _AST)]  # pyright: ignore[reportUnknownVariableType] — element narrowed by isinstance
+            elif isinstance(value, _AST):
+                queue.append(value)
+        yield current
+
+
+@final
+class _NodeIndex:
+    """A module's nodes partitioned by exact class, in breadth-first order."""
+
+    __slots__ = ("_buckets", "_flat", "_queries")
+
+    def __init__(self, tree: ast.AST) -> None:
+        buckets: dict[type[ast.AST], list[ast.AST]] = {}
+        flat: list[ast.AST] = [tree]
+        i = 0
+        while i < len(flat):
+            current = flat[i]
+            i += 1
+            cls = current.__class__
+            bucket = buckets.get(cls)
+            if bucket is None:
+                buckets[cls] = [current]
+            else:
+                bucket.append(current)
+            for name in cls._fields:
+                value: object = getattr(current, name, None)
+                if isinstance(value, list):
+                    flat += [item for item in value if isinstance(item, _AST)]  # pyright: ignore[reportUnknownVariableType] — element narrowed by isinstance
+                elif isinstance(value, _AST):
+                    flat.append(value)
+        self._buckets: dict[type[ast.AST], list[ast.AST]] = buckets
+        self._flat: list[ast.AST] = flat
+        self._queries: dict[tuple[type[ast.AST], ...], list[ast.AST]] = {}
+
+    def query(self, types: tuple[type[ast.AST], ...]) -> list[ast.AST]:
+        """Return every node matching `isinstance(node, types)`, breadth-first.
+
+        Returns:
+            The match list, cached per `types` and shared — treat as read-only.
+
+        """
+        hit = self._queries.get(types)
+        if hit is not None:
+            return hit
+        matched = frozenset(cls for cls in self._buckets if issubclass(cls, types))
+        if len(matched) == 1:
+            # The single bucket is already the answer, in breadth-first order.
+            result = self._buckets[next(iter(matched))]
+        elif len(matched) == len(self._buckets):
+            # Every class present matches — e.g. `nodes(tree, ast.AST)`, asked by
+            # a rule whose loop body inspects every node rather than a few types.
+            result = self._flat
+        elif matched:
+            result = [node for node in self._flat if node.__class__ in matched]
+        else:
+            result = []
+        self._queries[types] = result
+        return result
+
+
+_last_index: tuple[ast.AST, _NodeIndex] | None = None
+
+
+def nodes[NodeT: ast.AST](tree: ast.AST, *types: type[NodeT]) -> list[NodeT]:
+    """Every node of `tree` matching `types`, in `ast.walk` order.
+
+    A drop-in, memoized replacement for the ubiquitous
+    `[n for n in ast.walk(tree) if isinstance(n, types)]`. Pass the *module*
+    tree: the index is per-file, so calling this with a subtree builds a fresh
+    index and evicts the module's. Use `walk` for subtrees.
+
+    Returns:
+        The matching nodes, breadth-first. A fresh list per call; the partition
+        it is drawn from is what gets cached.
+
+    """
+    global _last_index  # ruff: ignore[global-statement] — single-slot memo, mirroring `parse_or_none`
+    if _last_index is None or _last_index[0] is not tree:
+        _last_index = (tree, _NodeIndex(tree))
+    # The `isinstance` pass is what narrows `list[ast.AST]` to `list[NodeT]`
+    # honestly, rather than asserting it with a `cast` the house style bans. It
+    # runs over the matches only — never the tree — and every element passes by
+    # construction, so it costs one type check per node actually returned.
+    return [node for node in _last_index[1].query(types) if isinstance(node, types)]

{sarj_python_lint-0.25.0 → sarj_python_lint-0.27.0}/src/sarj_python_lint/rules/_comments.py

@@ -180,7 +180,134 @@ _CAMEL_RE = re.compile(r"[A-Z]+(?=[A-Z][a-z])|[A-Z]?[a-z]+|[A-Z]+|\d+")
 # the prototype's list: shrinking it costs recall, growing it costs precision by
 # letting a genuinely novel word be discounted.
 STOPWORDS: frozenset[str] = frozenset(
-    ["a", "an", "the", "this", "that", "these", "those", "it", "its", "their", "his", "her", "our", "your", "my", "is", "are", "was", "were", "be", "been", "being", "am", "do", "does", "did", "done", "doing", "has", "have", "had", "having", "will", "would", "shall", "should", "can", "could", "may", "might", "must", "and", "or", "but", "nor", "so", "yet", "not", "no", "none", "to", "of", "for", "in", "on", "at", "by", "with", "from", "into", "onto", "out", "up", "down", "over", "under", "about", "as", "if", "then", "than", "when", "where", "which", "who", "whom", "whose", "what", "how", "why", "while", "we", "you", "they", "i", "he", "she", "them", "him", "us", "me", "also", "just", "only", "even", "still", "already", "again", "there", "here", "all", "any", "each", "every", "some", "via", "per", "etc", "eg", "ie", "vs", "need", "needs", "needed", "want", "wants", "make", "makes", "making", "let", "lets", "please", "note", "see", "above", "below"]
+    [
+        "a",
+        "an",
+        "the",
+        "this",
+        "that",
+        "these",
+        "those",
+        "it",
+        "its",
+        "their",
+        "his",
+        "her",
+        "our",
+        "your",
+        "my",
+        "is",
+        "are",
+        "was",
+        "were",
+        "be",
+        "been",
+        "being",
+        "am",
+        "do",
+        "does",
+        "did",
+        "done",
+        "doing",
+        "has",
+        "have",
+        "had",
+        "having",
+        "will",
+        "would",
+        "shall",
+        "should",
+        "can",
+        "could",
+        "may",
+        "might",
+        "must",
+        "and",
+        "or",
+        "but",
+        "nor",
+        "so",
+        "yet",
+        "not",
+        "no",
+        "none",
+        "to",
+        "of",
+        "for",
+        "in",
+        "on",
+        "at",
+        "by",
+        "with",
+        "from",
+        "into",
+        "onto",
+        "out",
+        "up",
+        "down",
+        "over",
+        "under",
+        "about",
+        "as",
+        "if",
+        "then",
+        "than",
+        "when",
+        "where",
+        "which",
+        "who",
+        "whom",
+        "whose",
+        "what",
+        "how",
+        "why",
+        "while",
+        "we",
+        "you",
+        "they",
+        "i",
+        "he",
+        "she",
+        "them",
+        "him",
+        "us",
+        "me",
+        "also",
+        "just",
+        "only",
+        "even",
+        "still",
+        "already",
+        "again",
+        "there",
+        "here",
+        "all",
+        "any",
+        "each",
+        "every",
+        "some",
+        "via",
+        "per",
+        "etc",
+        "eg",
+        "ie",
+        "vs",
+        "need",
+        "needs",
+        "needed",
+        "want",
+        "wants",
+        "make",
+        "makes",
+        "making",
+        "let",
+        "lets",
+        "please",
+        "note",
+        "see",
+        "above",
+        "below",
+    ]
 )
 
 

{sarj_python_lint-0.25.0 → sarj_python_lint-0.27.0}/src/sarj_python_lint/rules/_first_party.py

@@ -50,23 +50,25 @@ _PROJECT_MARKER = "pyproject.toml"
 
 # Never descend into these: a virtualenv or vendored tree holds *third-party*
 # packages, and collecting their names would classify every dependency as ours.
-_SKIP_DIR_NAMES = frozenset({
-    ".git",
-    ".mypy_cache",
-    ".next",
-    ".pytest_cache",
-    ".ruff_cache",
-    ".tox",
-    ".turbo",
-    ".venv",
-    "__pycache__",
-    "build",
-    "coverage",
-    "dist",
-    "node_modules",
-    "site-packages",
-    "venv",
-})
+_SKIP_DIR_NAMES = frozenset(
+    {
+        ".git",
+        ".mypy_cache",
+        ".next",
+        ".pytest_cache",
+        ".ruff_cache",
+        ".tox",
+        ".turbo",
+        ".venv",
+        "__pycache__",
+        "build",
+        "coverage",
+        "dist",
+        "node_modules",
+        "site-packages",
+        "venv",
+    }
+)
 
 # Deep enough for a uv/pnpm-style monorepo (`<root>/packages/python/src/<pkg>`),
 # shallow enough that the scan stays a few hundred `iterdir()` calls.
@@ -119,6 +121,10 @@ def own_top_package(path: Path) -> str | None:
             top = ancestor.name
         if ancestor == root:
             break
+    if top is None and root is not None:
+        roots = _first_party_roots(root)
+        if len(roots) == 1:
+            return next(iter(roots))
     return top
 
 

sarj_python_lint-0.27.0/src/sarj_python_lint/rules/_logging.py

@@ -0,0 +1,54 @@
+"""Shared logging-receiver detection for SARJ012/SARJ017.
+
+A single resolver for "does this receiver expression evaluate to a logger?",
+used by both the secret-in-log and f-string-in-log rules so they recognise the
+same factory/builder forms.
+"""
+
+from __future__ import annotations
+
+import ast
+
+
+_LOGGER_NAMES = frozenset({"logger", "log", "logging", "loguru", "_logger", "_log"})
+
+_LOGGER_FACTORIES = frozenset({"getlogger", "get_logger"})
+
+
+def is_logger_expr(expr: ast.expr) -> bool:
+    """Report whether `expr` evaluates to a logger.
+
+    Resolves the whole receiver chain so adapter/builder/factory calls are
+    caught: `logger.bind(...).info(...)`, `logger.opt(lazy=True).debug(...)`,
+    `logging.getLogger(__name__).info(...)`, `self.logger.error(...)`, and the
+    bare-name factory `get_logger().info(...)`.
+
+    Returns:
+        True when `expr` resolves to a logger receiver.
+
+    """
+    if isinstance(expr, ast.Name):
+        return expr.id.lower() in _LOGGER_NAMES
+    if isinstance(expr, ast.Attribute):
+        if expr.attr.lower() in _LOGGER_NAMES or expr.attr.lower() in _LOGGER_FACTORIES:
+            return True
+        return is_logger_expr(expr.value)
+    if isinstance(expr, ast.Call):
+        # A factory names a logger only when it is *called*: `get_logger()` is a
+        # logger, the bare name `get_logger` is a function — which is why the
+        # factories live in their own set and not in `_LOGGER_NAMES`. Both the
+        # dotted spelling (`structlog.get_logger()`, `logging.getLogger()`) and
+        # the bare one (`from structlog import get_logger`, then `get_logger()`)
+        # have to be recognised right here: a bare callee is an `ast.Name`, and
+        # recursing on it lands in the `_LOGGER_NAMES` branch, which by that
+        # design does not carry the factory names. Omitting this second check is
+        # a silent false negative rather than a crash, so it went unnoticed —
+        # `get_logger().info("auth", token=token)`, structlog's own documented
+        # module-level idiom, was unlinted by both SARJ012 and SARJ017.
+        callee = expr.func
+        if isinstance(callee, ast.Attribute) and callee.attr.lower() in _LOGGER_FACTORIES:
+            return True
+        if isinstance(callee, ast.Name) and callee.id.lower() in _LOGGER_FACTORIES:
+            return True
+        return is_logger_expr(callee)
+    return False

{sarj_python_lint-0.25.0 → sarj_python_lint-0.27.0}/src/sarj_python_lint/rules/_pytest.py

@@ -13,6 +13,8 @@ from __future__ import annotations
 
 import ast
 
+from sarj_python_lint.rules._ast_index import walk
+
 
 # The pytest-benchmark fixture: the test measures time, it does not verify.
 _BENCHMARK = "benchmark"
@@ -33,7 +35,7 @@ def uses_benchmark_fixture(node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool
     """
     args = node.args
     declared = any(arg.arg == _BENCHMARK for arg in (*args.posonlyargs, *args.args, *args.kwonlyargs))
-    return declared and any(isinstance(child, ast.Name) and child.id == _BENCHMARK for child in ast.walk(node))
+    return declared and any(isinstance(child, ast.Name) and child.id == _BENCHMARK for child in walk(node))
 
 
 def has_benchmark_marker(node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:

{sarj_python_lint-0.25.0 → sarj_python_lint-0.27.0}/src/sarj_python_lint/rules/_registry.py

@@ -27,6 +27,7 @@ from sarj_python_lint.rules.no_first_party_private_import import (
 )
 from sarj_python_lint.rules.no_fstring_in_log import NoFstringInLog
 from sarj_python_lint.rules.no_gen_random_uuid_in_sql import NoGenRandomUuidInSql
+from sarj_python_lint.rules.no_implicit_attribute_access import NoImplicitAttributeAccess
 from sarj_python_lint.rules.no_isinstance_union_chain import NoIsinstanceUnionChain
 from sarj_python_lint.rules.no_offset_pagination import NoOffsetPagination
 from sarj_python_lint.rules.no_optional_tenant_predicate import (
@@ -57,6 +58,7 @@ from sarj_python_lint.rules.prefer_fstring_over_concat import PreferFstringOverC
 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_pattern_destructuring import PreferMatchPatternDestructuring
+from sarj_python_lint.rules.prefer_match_type_dispatch import PreferMatchTypeDispatch
 from sarj_python_lint.rules.prefer_module_level_constant import (
     PreferModuleLevelConstant,
 )
@@ -67,7 +69,9 @@ from sarj_python_lint.rules.prefer_non_nullable_collection import (
     PreferNonNullableCollection,
 )
 from sarj_python_lint.rules.prefer_or_pattern import PreferOrPattern
+from sarj_python_lint.rules.prefer_pattern_matching import PreferPatternMatching
 from sarj_python_lint.rules.prefer_real_store_in_tests import PreferRealStoreInTests
+from sarj_python_lint.rules.prefer_self_type_annotation import PreferSelfTypeAnnotation
 from sarj_python_lint.rules.prefer_str_enum import PreferStrEnum
 from sarj_python_lint.rules.prefer_struct_over_namedtuple import (
     PreferStructOverNamedtuple,
@@ -75,6 +79,14 @@ from sarj_python_lint.rules.prefer_struct_over_namedtuple import (
 from sarj_python_lint.rules.prefer_timedelta_for_durations import (
     PreferTimedeltaForDurations,
 )
+from sarj_python_lint.rules.prefer_walrus_comprehension_filter import (
+    PreferWalrusComprehensionFilter,
+)
+from sarj_python_lint.rules.prefer_walrus_regex_match import PreferWalrusRegexMatch
+from sarj_python_lint.rules.prefer_walrus_stream_loop import PreferWalrusStreamLoop
+from sarj_python_lint.rules.primary_export_file_name import (
+    PrimaryExportFileName,
+)
 from sarj_python_lint.rules.pydantic_at_boundaries import PydanticAtBoundaries
 from sarj_python_lint.rules.redundant_docstring import RedundantDocstring
 from sarj_python_lint.rules.require_port_for_service import RequirePortForService
@@ -98,34 +110,6 @@ from sarj_python_lint.rules.zero_assertion_test import ZeroAssertionTest
 if TYPE_CHECKING:
     from sarj_python_lint.rule_base import Rule
 
-
-# Retired codes — never reuse these for new rules:
-#   SARJ004, SARJ005 (retired before the standards merge),
-#   SARJ027, SARJ029, SARJ030 (dropped in 0.11.1 as too noisy),
-#   SARJ033 httpx-client-requires-timeout, SARJ035 no-import-time-settings
-#   (dropped by user veto after the 0.13.x mined-rules review),
-#   SARJ055 no-filler-success-adverb (built and corpus-validated, then dropped
-#   — but not for the reason first recorded. The headline "4.7% of Airflow's
-#   info/debug logs" is a composition artifact: 237 of those 248 hits are in
-#   `providers/` (contributed vendor operators, heavily copy-pasted — the
-#   template "%s completed successfully." appears 22 times verbatim). Airflow's
-#   maintainer-owned `airflow-core/` sits at 1.15% and Home Assistant at 1.24%,
-#   so the real external baseline is ~1.2%, not 4.7%. The rule was re-measured
-#   and dropped on a stronger basis: the narrow variant — fire only when the
-#   adverb is the sole content beyond a bare verb — has 12 external hits and
-#   ZERO internal ones across all six repos, so it would govern nothing we
-#   write. The broad rule remains opt-in house style, not a defect check.
-#   (Noted for any future revisit: noura-be measures 7.92%, a genuine outlier
-#   against every corpus; that, not the narrow variant, is the case to make.),
-#   SARJ037 no-trivial-single-use-helper (prototyped and dropped for FP rate;
-#   see the 0.13.1 inlining commit for the corpus analysis).
-#   SARJ072 unbound-mock-assertion and SARJ073 raises-needs-specific-error
-#   (built, corpus-measured and dropped before ever being registered, in the
-#   wave that added SARJ058-071). SARJ072 found 0 hits across 16,130 files in
-#   9 repos, including 0 against 8,322 real mock-assertion API uses; ruff B018
-#   covers its bare-statement shape. SARJ073 was a strict superset of ruff
-#   PT011, which this standard already enables — its one real gap,
-#   RuntimeError, is closed by `lint.flake8-pytest-style.raises-require-match-for`.
 REGISTRY: dict[str, type[Rule]] = {
     NoSequentialAwait.id: NoSequentialAwait,
     InefficientStringConcatInLoop.id: InefficientStringConcatInLoop,
@@ -133,6 +117,7 @@ REGISTRY: dict[str, type[Rule]] = {
     PreferStrEnum.id: PreferStrEnum,
     NoFatTryBlocks.id: NoFatTryBlocks,
     NoIsinstanceUnionChain.id: NoIsinstanceUnionChain,
+    NoImplicitAttributeAccess.id: NoImplicitAttributeAccess,
     NoOffsetPagination.id: NoOffsetPagination,
     PreferNamedtupleOverTupleReturn.id: PreferNamedtupleOverTupleReturn,
     NoCorsWildcardWithCredentials.id: NoCorsWildcardWithCredentials,
@@ -188,8 +173,15 @@ REGISTRY: dict[str, type[Rule]] = {
     PreferFstringOverConcat.id: PreferFstringOverConcat,
     PreferMatchPatternDestructuring.id: PreferMatchPatternDestructuring,
     PreferOrPattern.id: PreferOrPattern,
+    PreferPatternMatching.id: PreferPatternMatching,
     RequirePortForService.id: RequirePortForService,
     PreferNonNullableCollection.id: PreferNonNullableCollection,
+    PreferMatchTypeDispatch.id: PreferMatchTypeDispatch,
+    PrimaryExportFileName.id: PrimaryExportFileName,
+    PreferWalrusRegexMatch.id: PreferWalrusRegexMatch,
+    PreferWalrusComprehensionFilter.id: PreferWalrusComprehensionFilter,
+    PreferWalrusStreamLoop.id: PreferWalrusStreamLoop,
+    PreferSelfTypeAnnotation.id: PreferSelfTypeAnnotation,
 }
 
 __all__ = ["REGISTRY"]