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

{sarj_python_lint-0.25.0 → sarj_python_lint-0.26.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.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sarj-python-lint
-Version: 0.25.0
+Version: 0.26.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.26.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.26.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sarj-python-lint"
-version = "0.25.0"
+version = "0.26.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.26.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.26.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.25.0 → sarj_python_lint-0.26.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.26.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.25.0 → sarj_python_lint-0.26.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"]

{sarj_python_lint-0.25.0 → sarj_python_lint-0.26.0}/src/sarj_python_lint/rules/conditional_assertion_in_test.py

@@ -901,9 +901,9 @@ def _parametrized_nonempty(node: ast.FunctionDef | ast.AsyncFunctionDef) -> set[
 def _parametrize_names(dec: ast.Call) -> list[str]:
     argnames = dec.args[0] if dec.args else None
     if isinstance(argnames, ast.Constant) and isinstance(argnames.value, str):
-        return [part.strip() for part in argnames.value.split(",") if part.strip()]
+        return [p for part in argnames.value.split(",") if (p := part.strip())]
     if isinstance(argnames, (ast.List, ast.Tuple)):
-        return [elt.value for elt in argnames.elts if isinstance(elt, ast.Constant) and isinstance(elt.value, str)]
+        return [val for elt in argnames.elts if isinstance(elt, ast.Constant) and isinstance(val := elt.value, str)]
     return []
 
 

{sarj_python_lint-0.25.0 → sarj_python_lint-0.26.0}/src/sarj_python_lint/rules/duplicate_test_body.py

@@ -294,6 +294,15 @@ class DuplicateTestBody(Rule):
             groups = _duplicate_groups(tree, source)
         except tokenize.TokenError, IndentationError, SyntaxError:
             return []
+        except RecursionError:
+            # Normalisation deep-copies each body and `ast.dump`s it, both of
+            # which recurse once per AST level. A left-nested `+` spine of a few
+            # thousand terms — generated or minified source, never hand-written;
+            # the deepest real test-file AST measured across 43k files is 33 —
+            # exhausts the stack. Returning nothing skips this one file, where
+            # letting it propagate would abort the whole lint run: `check()` is
+            # called per file by a CLI that does not catch it.
+            return []
 
         diags = [
             Diagnostic(

{sarj_python_lint-0.25.0 → sarj_python_lint-0.26.0}/src/sarj_python_lint/rules/kwonly_same_type_params.py

@@ -301,9 +301,9 @@ def _calls_super_same_name(node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool
 
     """
     return any(
-        isinstance(call.func, ast.Attribute)
-        and call.func.attr == node.name
-        and isinstance(inner := call.func.value, ast.Call)
+        isinstance(func := call.func, ast.Attribute)
+        and func.attr == node.name
+        and isinstance(inner := func.value, ast.Call)
         and isinstance(inner.func, ast.Name)
         and inner.func.id == "super"
         for call in ast.walk(node)
@@ -362,9 +362,11 @@ def _swap_prone_annotation(args: ast.arguments) -> str | None:
         if isinstance(ann := p.annotation, ast.Name) and ann.id in _PRIMITIVES:
             groups.setdefault(ann.id, []).append(p.arg)
     for name, arg_names in sorted(groups.items(), key=lambda kv: -len(kv[1])):
-        if len(arg_names) >= _MIN_SAME_TYPE and not (
-            _is_symmetric_numbering(arg_names) or _is_conventional_order(arg_names)
-        ) and _is_high_value_group(name, arg_names):
+        if (
+            len(arg_names) >= _MIN_SAME_TYPE
+            and not (_is_symmetric_numbering(arg_names) or _is_conventional_order(arg_names))
+            and _is_high_value_group(name, arg_names)
+        ):
             return name
     return None
 

{sarj_python_lint-0.25.0 → sarj_python_lint-0.26.0}/src/sarj_python_lint/rules/mock_without_spec.py

@@ -126,6 +126,7 @@ _PATCHERS = frozenset({"patch"})
 # Any one of these gives the double a real contract to honour.
 _SPEC_KEYWORDS = frozenset({"spec", "spec_set", "autospec", "new", "new_callable", "wraps"})
 
+
 # How many positional arguments a callee must receive before the spec/new
 # parameter is filled. `Mock(spec, wraps, ...)`, `patch(target, new, ...)` and
 # `patch.object(target, attribute, new, ...)` all take it positionally, and that

{sarj_python_lint-0.25.0 → sarj_python_lint-0.26.0}/src/sarj_python_lint/rules/no_comment_cruft.py

@@ -178,8 +178,6 @@ _DIRECTIVE_PREFIXES = (
     "flake8:",
     "nosec",
     "nosemgrep",
-    "todo",
-    "fixme",
     "hack",
     "xxx:",
     "-*-",
@@ -249,7 +247,7 @@ _SENTENCE_END_RE = re.compile(r"""[.!?:;)\]}"'`]$""")
 # holds") aren't mistaken for an enumeration marker.
 _STEP_NARRATION_RE = re.compile(
     r"^(?:first(?:ly)?|second(?:ly)?|third(?:ly)?|then|next|after(?:wards| that)?"
-    r"|finally|lastly|now)\s*[,:]\s*\S|^step\s+\d+\b",
+    r"|finally|lastly|now)\s*[,:]\s*\S",
     re.IGNORECASE,
 )
 
@@ -274,14 +272,49 @@ _META_COMMENTARY_RE = re.compile(
 # demo-gateway, 12 of 12 sampled were true positives. Closed vocabulary on
 # purpose: a one-word comment outside this list ("# Riyadh") is far more likely
 # to be a genuine label for a value.
-_SECTION_LABEL_WORDS = frozenset({
-    "actions", "components", "config", "configuration", "constant", "constants",
-    "enums", "exports", "fixtures", "getters", "globals", "handler", "handlers",
-    "helper", "helpers", "hook", "hooks", "imports", "interfaces", "main",
-    "mocks", "models", "mutations", "props", "queries", "reducers", "routes",
-    "schemas", "selectors", "setters", "setup", "state", "styles", "teardown",
-    "type", "types", "util", "utilities", "utils",
-})
+_SECTION_LABEL_WORDS = frozenset(
+    {
+        "actions",
+        "components",
+        "config",
+        "configuration",
+        "constant",
+        "constants",
+        "enums",
+        "exports",
+        "fixtures",
+        "getters",
+        "globals",
+        "handler",
+        "handlers",
+        "helper",
+        "helpers",
+        "hook",
+        "hooks",
+        "imports",
+        "interfaces",
+        "main",
+        "mocks",
+        "models",
+        "mutations",
+        "props",
+        "queries",
+        "reducers",
+        "routes",
+        "schemas",
+        "selectors",
+        "setters",
+        "setup",
+        "state",
+        "styles",
+        "teardown",
+        "type",
+        "types",
+        "util",
+        "utilities",
+        "utils",
+    }
+)
 _SECTION_LABEL_RE = re.compile(r"^([A-Za-z]+)\s*:?\s*$")
 
 # "Helper function to check if a path is active" — the opener announces the
@@ -315,7 +348,13 @@ _LETS_RE = re.compile(
 # `# Phase 2: reconcile`. Flagged only when the file carries exactly one of
 # them — a *run* of them is a documented algorithm walkthrough, which is the
 # kind of comment this rule exists to protect.
-_ENUMERATION_RE = re.compile(r"^(?:\d+[.)]\s+\S|phase\s+\d+\b)", re.IGNORECASE)
+_ENUMERATION_RE = re.compile(r"^(?:\d+[.)]\s+\S|(?:phase|step)\s+\d+\b)", re.IGNORECASE)
+
+# Dummy translational comments: ultra-short comments that just restate the code.
+_DUMMY_TRANSLATION_RE = re.compile(
+    r"^(?:increment|return|returns|get|gets|set\b(?! up\b)|sets\b(?! up\b)|function to|method to)\b",
+    re.IGNORECASE,
+)
 
 
 def _is_word_char(ch: str) -> bool:
@@ -493,6 +532,14 @@ def _is_redundant_narration(
         return True
     if _HELPER_OPENER_RE.match(c) or _LETS_RE.match(c):
         return True
+    words = c.split()
+    if len(words) <= 4 and _DUMMY_TRANSLATION_RE.match(c) and not any(ch in c for ch in "():="):
+        # Exclude common rationale words or test markers
+        lower_c = c.lower()
+        if not any(w in lower_c for w in ("when", "because", "if", "so that", "due to", "for", "instead of", "to prevent", "to avoid", "only")):
+            # Also exclude single-word labels like `# get` which are often group labels in tests
+            if len(words) > 1:
+                return True
     if not nested and _is_section_label(c):
         return True
     return isolated_enumeration and bool(_ENUMERATION_RE.match(c))
@@ -559,6 +606,9 @@ def _looks_like_code(body: str) -> bool:
     if c.startswith("@"):
         return _compiles(c + "\ndef _f():\n    pass")
     if _ASSIGN_OR_CALL_RE.match(c):
+        # Implicit type condition documentation (e.g. under `else:`)
+        if c.startswith("isinstance(") or c.startswith("issubclass("):
+            return False
         return _is_assign_or_call(c)
     return False
 
@@ -660,6 +710,10 @@ class NoCommentCruft(Rule):
     ) -> str | None:
         if _CODE_REGEN_CALL_RE.match(body):
             return None
+        if re.match(r"^(?:todo|fixme)\b", body, re.IGNORECASE):
+            if not narration_protected:
+                return "Untracked TODO/FIXME marker — add an issue ticket or context link."
+            return None
         if _is_banner(body):
             if _is_heading_underline(body, prev_body):
                 return None
@@ -670,9 +724,7 @@ class NoCommentCruft(Rule):
             return "Commented-out code — delete it; git history remembers."
         if narration_protected:
             return None
-        if _is_redundant_narration(
-            body, prev_body, isolated_enumeration=isolated_enumeration, nested=nested
-        ):
+        if _is_redundant_narration(body, prev_body, isolated_enumeration=isolated_enumeration, nested=nested):
             return "Comment narrates the code — delete it or say why, not what. Code is self-documenting."
         return None
 

{sarj_python_lint-0.25.0 → sarj_python_lint-0.26.0}/src/sarj_python_lint/rules/no_cors_wildcard_with_credentials.py

@@ -48,7 +48,7 @@ class NoCorsWildcardWithCredentials(Rule):
         for node in ast.walk(tree):
             if not isinstance(node, ast.Call):
                 continue
-            keywords = {kw.arg: kw.value for kw in node.keywords if kw.arg is not None}
+            keywords = {arg: kw.value for kw in node.keywords if (arg := kw.arg) is not None}
             credentials = keywords.get("allow_credentials")
             origins = keywords.get("allow_origins")
             if credentials is None or origins is None:

{sarj_python_lint-0.25.0 → sarj_python_lint-0.26.0}/src/sarj_python_lint/rules/no_first_party_private_import.py

@@ -148,9 +148,9 @@ def _from_import_hits(node: ast.ImportFrom) -> list[tuple[int, int, str, str]]:
     if private_segment is not None:
         return [(node.lineno, node.col_offset + 1, node.module, private_segment)]
     return [
-        (alias.lineno, alias.col_offset + 1, node.module, alias.name)
+        (alias.lineno, alias.col_offset + 1, node.module, name)
         for alias in node.names
-        if _is_private_name(alias.name)
+        if _is_private_name(name := alias.name)
     ]