sarj-python-lint 0.80.8__tar.gz → 0.80.11__tar.gz

{sarj_python_lint-0.80.8 → sarj_python_lint-0.80.11}/PKG-INFO

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

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

{sarj_python_lint-0.80.8 → sarj_python_lint-0.80.11}/src/sarj_python_lint/rules/_fixed_record.py

@@ -48,9 +48,7 @@ def builds_fixed_record(node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
                     else:
                         aliases[target.id] = current.value.id
             else:
-                invalidated_names.update(
-                    target.id for target in current.targets if isinstance(target, ast.Name)
-                )
+                invalidated_names.update(target.id for target in current.targets if isinstance(target, ast.Name))
             for target in current.targets:
                 if isinstance(target, ast.Subscript):
                     invalidated_names.update(_mutated_record_roots(target))
@@ -115,8 +113,7 @@ def builds_fixed_record(node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
     ):
         return False
     return any(
-        _is_record_literal(value)
-        or (isinstance(value, ast.Name) and original_name(value.id) in intact_record_names)
+        _is_record_literal(value) or (isinstance(value, ast.Name) and original_name(value.id) in intact_record_names)
         for value in returned
     )
 
@@ -140,9 +137,7 @@ def _is_record_literal(node: ast.expr) -> bool:
         return _is_record_literal(node.elt)
     if not isinstance(node, ast.Dict):
         return False
-    return bool(node.keys) and all(
-        isinstance(key, ast.Constant) and isinstance(key.value, str) for key in node.keys
-    )
+    return bool(node.keys) and all(isinstance(key, ast.Constant) and isinstance(key.value, str) for key in node.keys)
 
 
 def _mutated_record_roots(target: ast.AST) -> set[str]:

{sarj_python_lint-0.80.8 → sarj_python_lint-0.80.11}/src/sarj_python_lint/rules/_imports.py

@@ -39,9 +39,7 @@ class ImportIndex:
                     pass
 
         imported_names = frozenset(candidates)
-        non_import_bindings = (
-            _module_non_import_bindings(tree) if module_scope_only else _non_import_bindings(tree)
-        )
+        non_import_bindings = _module_non_import_bindings(tree) if module_scope_only else _non_import_bindings(tree)
         rebound = non_import_bindings & imported_names
         bindings = {
             local: next(iter(targets))
@@ -166,9 +164,7 @@ def _module_import_statements(tree: ast.Module) -> list[ast.stmt]:
     for statement in tree.body:
         if not isinstance(statement, ast.If) or not _is_type_checking_guard(statement.test):
             continue
-        statements.extend(
-            child for child in statement.body if isinstance(child, (ast.Import, ast.ImportFrom))
-        )
+        statements.extend(child for child in statement.body if isinstance(child, (ast.Import, ast.ImportFrom)))
     return statements
 
 

{sarj_python_lint-0.80.8 → sarj_python_lint-0.80.11}/src/sarj_python_lint/rules/_prose_budget.py

@@ -428,7 +428,13 @@ def _yielded_type(node: ast.expr) -> str | None:
         node = parsed
     if not isinstance(node, ast.Subscript):
         return None
-    name = node.value.attr if isinstance(node.value, ast.Attribute) else node.value.id if isinstance(node.value, ast.Name) else ""
+    name = (
+        node.value.attr
+        if isinstance(node.value, ast.Attribute)
+        else node.value.id
+        if isinstance(node.value, ast.Name)
+        else ""
+    )
     if name not in {"AsyncGenerator", "AsyncIterable", "AsyncIterator", "Generator", "Iterable", "Iterator"}:
         return None
     members = node.slice.elts if isinstance(node.slice, ast.Tuple) else (node.slice,)

{sarj_python_lint-0.80.8 → sarj_python_lint-0.80.11}/src/sarj_python_lint/rules/fastapi_explicit_openapi_contract.py

@@ -430,9 +430,8 @@ def _check_return(
                 continue
             response_model = route.keywords.get("response_model")
             status = _status_code(route.keywords.get("status_code"), index) or HTTPStatus.OK
-            if (
-                _concrete_response_model(response_model, index)
-                or any(_documents_response_model(node, status, index) for node in _route_response_nodes(route))
+            if _concrete_response_model(response_model, index) or any(
+                _documents_response_model(node, status, index) for node in _route_response_nodes(route)
             ):
                 continue
             return [

{sarj_python_lint-0.80.8 → sarj_python_lint-0.80.11}/src/sarj_python_lint/rules/invalid_pydantic_field_default.py

@@ -181,9 +181,7 @@ class InvalidPydanticFieldDefault(Rule):
                 files=(
                     ExampleFile.python(
                         "app/models.py",
-                        "from pydantic import BaseModel\n\n"
-                        "class User(BaseModel):\n"
-                        "    display_name: str = None\n",
+                        "from pydantic import BaseModel\n\nclass User(BaseModel):\n    display_name: str = None\n",
                     ),
                 ),
                 focus_path=PurePosixPath("app/models.py"),
@@ -231,11 +229,7 @@ class InvalidPydanticFieldDefault(Rule):
                 if statement.target.id.startswith("_"):
                     continue
                 contract = _annotation_contract(path, tree, statement.annotation)
-                if (
-                    contract.transforms_default
-                    or transformers.all_fields
-                    or statement.target.id in transformers.fields
-                ):
+                if contract.transforms_default or transformers.all_fields or statement.target.id in transformers.fields:
                     continue
                 assignment_field = (
                     statement.value
@@ -276,10 +270,7 @@ def _is_direct_base_model(node: ast.ClassDef, imports: ImportIndex) -> bool:
         return False
     return all(
         imports.resolves(base, sources=_PYDANTIC_BASE_MODEL_SOURCES, symbol="BaseModel")
-        or (
-            isinstance(base, ast.Subscript)
-            and imports.resolves(base.value, sources=_TYPING_SOURCES, symbol="Generic")
-        )
+        or (isinstance(base, ast.Subscript) and imports.resolves(base.value, sources=_TYPING_SOURCES, symbol="Generic"))
         for base in node.bases
     )
 

{sarj_python_lint-0.80.8 → sarj_python_lint-0.80.11}/src/sarj_python_lint/rules/mock_without_spec.py

@@ -333,9 +333,7 @@ class _MockNames:
 
     def _is_shadowed(self, name: str, node: ast.AST) -> bool:
         scope = self.scopes.get(id(node))
-        return name in self.shadowed or (
-            scope is not None and name in self.local_shadowed.get(scope, frozenset())
-        )
+        return name in self.shadowed or (scope is not None and name in self.local_shadowed.get(scope, frozenset()))
 
 
 class _FileFacts:
@@ -559,14 +557,12 @@ def _escaped_names(argument: ast.expr) -> set[str]:
 
 def _mock_add_spec_has_contract(node: ast.Call) -> bool:
     if any(
-        not isinstance(argument, ast.Starred)
-        and not (isinstance(argument, ast.Constant) and argument.value is None)
+        not isinstance(argument, ast.Starred) and not (isinstance(argument, ast.Constant) and argument.value is None)
         for argument in node.args
     ):
         return True
     return any(
-        keyword.arg == "spec"
-        and not (isinstance(keyword.value, ast.Constant) and keyword.value.value is None)
+        keyword.arg == "spec" and not (isinstance(keyword.value, ast.Constant) and keyword.value.value is None)
         for keyword in node.keywords
     )
 

{sarj_python_lint-0.80.8 → sarj_python_lint-0.80.11}/src/sarj_python_lint/rules/no_analytical_aggregation_in_postgres_store.py

@@ -112,7 +112,7 @@ class NoAnalyticalAggregationInPostgresStore(Rule):
                     ExampleFile.python(
                         "app/event_store.py",
                         "import psycopg\n\n"
-                        'QUERY = "SELECT DATE_TRUNC(\'day\', occurred_at), COUNT(*), AVG(latency_ms) '
+                        "QUERY = \"SELECT DATE_TRUNC('day', occurred_at), COUNT(*), AVG(latency_ms) "
                         'FROM event GROUP BY 1"\n',
                     ),
                 ),
@@ -127,8 +127,7 @@ class NoAnalyticalAggregationInPostgresStore(Rule):
                 files=(
                     ExampleFile.python(
                         "app/account_store.py",
-                        "import psycopg\n\n"
-                        'QUERY = "SELECT SUM(amount) FROM ledger WHERE account_id = %s FOR UPDATE"\n',
+                        'import psycopg\n\nQUERY = "SELECT SUM(amount) FROM ledger WHERE account_id = %s FOR UPDATE"\n',
                     ),
                 ),
                 focus_path=PurePosixPath("app/account_store.py"),

{sarj_python_lint-0.80.8 → sarj_python_lint-0.80.11}/src/sarj_python_lint/rules/no_nested_pydantic_field_validator.py

@@ -23,9 +23,7 @@ if TYPE_CHECKING:
     from pathlib import Path
 
 
-_PYDANTIC_BASE_MODEL_SOURCES = frozenset(
-    {"pydantic", "pydantic.main", "pydantic.v1", "pydantic.v1.main"}
-)
+_PYDANTIC_BASE_MODEL_SOURCES = frozenset({"pydantic", "pydantic.main", "pydantic.v1", "pydantic.v1.main"})
 _PYDANTIC_SETTINGS_SOURCES = frozenset({"pydantic", "pydantic.v1", "pydantic_settings"})
 _FIELD_VALIDATOR_SOURCES = frozenset({"pydantic", "pydantic.functional_validators"})
 _LEGACY_VALIDATOR_SOURCES = frozenset(
@@ -199,9 +197,7 @@ def _is_class_var(annotation: ast.expr, imports: ImportIndex) -> bool:
 
 def _literal_check_fields_false(decorator: ast.Call) -> bool:
     return any(
-        keyword.arg == "check_fields"
-        and isinstance(keyword.value, ast.Constant)
-        and keyword.value.value is False
+        keyword.arg == "check_fields" and isinstance(keyword.value, ast.Constant) and keyword.value.value is False
         for keyword in decorator.keywords
     )
 
@@ -235,9 +231,7 @@ def _shadowed_in_enclosing_function(
         return False
     current = parents.get(owner)
     while current is not None:
-        if isinstance(current, (ast.FunctionDef, ast.AsyncFunctionDef, ast.Lambda)) and _function_binds(
-            current, root
-        ):
+        if isinstance(current, (ast.FunctionDef, ast.AsyncFunctionDef, ast.Lambda)) and _function_binds(current, root):
             return True
         current = parents.get(current)
     return False
@@ -251,11 +245,10 @@ def _root_name(node: ast.expr) -> str | None:
 
 def _function_binds(node: ast.FunctionDef | ast.AsyncFunctionDef | ast.Lambda, name: str) -> bool:
     arguments = node.args
-    if any(
-        argument.arg == name
-        for argument in (*arguments.posonlyargs, *arguments.args, *arguments.kwonlyargs)
-    ) or (arguments.vararg is not None and arguments.vararg.arg == name) or (
-        arguments.kwarg is not None and arguments.kwarg.arg == name
+    if (
+        any(argument.arg == name for argument in (*arguments.posonlyargs, *arguments.args, *arguments.kwonlyargs))
+        or (arguments.vararg is not None and arguments.vararg.arg == name)
+        or (arguments.kwarg is not None and arguments.kwarg.arg == name)
     ):
         return True
     body = node.body if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) else [node.body]

{sarj_python_lint-0.80.8 → sarj_python_lint-0.80.11}/src/sarj_python_lint/rules/no_positional_psycopg_row_escape.py

@@ -272,9 +272,7 @@ def _cursors(
     )
 
 
-def _initial_bindings(
-    function: ast.FunctionDef | ast.AsyncFunctionDef, imports: ImportIndex
-) -> dict[str, _Shape]:
+def _initial_bindings(function: ast.FunctionDef | ast.AsyncFunctionDef, imports: ImportIndex) -> dict[str, _Shape]:
     result: dict[str, _Shape] = {}
     for name, annotation in _parameter_annotations(function).items():
         shape = _connection_annotation_shape(annotation, imports)
@@ -480,7 +478,11 @@ def _connection_context_shape(
         or _resolves_connection_connect(call.func, imports)
     ):
         return _connect_call_shape(call, imports, shadowed)
-    if isinstance(call.func, ast.Attribute) and call.func.attr == "connection" and isinstance(call.func.value, ast.Name):
+    if (
+        isinstance(call.func, ast.Attribute)
+        and call.func.attr == "connection"
+        and isinstance(call.func.value, ast.Name)
+    ):
         return visible.get(call.func.value.id)
     return None
 
@@ -509,7 +511,12 @@ def _receiver_shape(
 ) -> _Shape:
     if isinstance(receiver, ast.Name):
         return visible.get(receiver.id, _Shape.UNKNOWN)
-    if owner is not None and isinstance(receiver, ast.Attribute) and isinstance(receiver.value, ast.Name) and receiver.value.id == "self":
+    if (
+        owner is not None
+        and isinstance(receiver, ast.Attribute)
+        and isinstance(receiver.value, ast.Name)
+        and receiver.value.id == "self"
+    ):
         if receiver.attr in invalidated_attrs:
             return _Shape.UNKNOWN
         return class_attrs.get((owner.lineno, receiver.attr), _Shape.UNKNOWN)
@@ -587,7 +594,9 @@ def _cursor_shape(cursor: _Cursor, fetch: ast.Call, imports: ImportIndex, shadow
         if _position(statement) >= _position(fetch):
             break
         match statement:
-            case ast.Assign(targets=[ast.Attribute(value=ast.Name(id=name), attr="row_factory")], value=value) if name == cursor.name:
+            case ast.Assign(targets=[ast.Attribute(value=ast.Name(id=name), attr="row_factory")], value=value) if (
+                name == cursor.name
+            ):
                 assignments.append(value)
             case _ if _assigns_cursor_factory(statement, cursor.name):
                 ambiguous = True
@@ -755,11 +764,7 @@ def _merge_origins(states: Iterable[dict[str, _OriginSet]]) -> dict[str, _Origin
     materialized = tuple(states)
     names = {name for state in materialized for name in state}
     return {
-        name: frozenset(
-            origin
-            for state in materialized
-            for origin in state.get(name, frozenset({None}))
-        )
+        name: frozenset(origin for state in materialized for origin in state.get(name, frozenset({None})))
         for name in names
     }
 
@@ -789,7 +794,9 @@ def _statement_mutation_roots(statement: ast.stmt) -> frozenset[str]:
         root: str | None = None
         if isinstance(node, ast.Attribute | ast.Subscript) and isinstance(node.ctx, ast.Store | ast.Del):
             root = _root_name(node)
-        elif isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute) and node.func.attr in _MUTATING_METHODS:
+        elif (
+            isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute) and node.func.attr in _MUTATING_METHODS
+        ):
             root = _root_name(node.func.value)
         if root is not None:
             roots.add(root)
@@ -894,9 +901,13 @@ def _scope_nodes(statements: Iterable[ast.stmt], *, stop_rebinding: str | None =
         yield node
         if isinstance(node, _SCOPE_NODES):
             continue
-        if stop_rebinding is not None and isinstance(node, ast.With | ast.AsyncWith) and any(
-            isinstance(item.optional_vars, ast.Name) and item.optional_vars.id == stop_rebinding
-            for item in node.items
+        if (
+            stop_rebinding is not None
+            and isinstance(node, ast.With | ast.AsyncWith)
+            and any(
+                isinstance(item.optional_vars, ast.Name) and item.optional_vars.id == stop_rebinding
+                for item in node.items
+            )
         ):
             continue
         pending.extend(reversed(list(ast.iter_child_nodes(node))))

{sarj_python_lint-0.80.8 → sarj_python_lint-0.80.11}/src/sarj_python_lint/rules/no_redundant_literal_description.py

@@ -149,9 +149,7 @@ class NoRedundantLiteralDescription(Rule):
 
 
 def _is_direct_model(node: ast.ClassDef, imports: ImportIndex) -> bool:
-    return any(
-        imports.resolves(base, sources=_PYDANTIC_BASE_MODEL_SOURCES, symbol="BaseModel") for base in node.bases
-    )
+    return any(imports.resolves(base, sources=_PYDANTIC_BASE_MODEL_SOURCES, symbol="BaseModel") for base in node.bases)
 
 
 def _local_closed_domains(tree: ast.Module, imports: ImportIndex) -> dict[str, frozenset[str]]:

{sarj_python_lint-0.80.8 → sarj_python_lint-0.80.11}/src/sarj_python_lint/rules/no_repeated_string_literal.py

@@ -163,9 +163,7 @@ class NoRepeatedStringLiteral(Rule):
             function_scopes = {scope for n in nodes if (scope := scope_of.get(id(n), _MODULE_SCOPE)) != _MODULE_SCOPE}
             canonical = canonical_constants.get(value, ())
             eligible_canonical = tuple(
-                name
-                for name, line in canonical
-                if all(line < scope_line_of.get(scope, 0) for scope in function_scopes)
+                name for name, line in canonical if all(line < scope_line_of.get(scope, 0) for scope in function_scopes)
             )
             if len(eligible_canonical) == 1 and function_scopes:
                 (constant_name,) = eligible_canonical
@@ -282,6 +280,16 @@ def _preview(value: str) -> str:
 
 def _is_skipped_path(path: Path) -> bool:
     excluded_parts = frozenset(
-        {"benchmark", "benchmarks", "example", "examples", "fixture", "fixtures", "migration", "migrations", "snapshots"}
+        {
+            "benchmark",
+            "benchmarks",
+            "example",
+            "examples",
+            "fixture",
+            "fixtures",
+            "migration",
+            "migrations",
+            "snapshots",
+        }
     )
     return is_test_path(path) or bool(excluded_parts.intersection(part.lower() for part in path.parts))

{sarj_python_lint-0.80.8 → sarj_python_lint-0.80.11}/src/sarj_python_lint/rules/no_unique_violation_message_match.py

@@ -164,9 +164,7 @@ def _module_import_index(tree: ast.Module) -> ImportIndex:
             if regular_names:
                 body.append(ast.ImportFrom(module=statement.module, names=regular_names, level=statement.level))
             body.extend(
-                ast.Import(
-                    names=[ast.alias(name=f"{statement.module}.errors", asname=alias.asname or alias.name)]
-                )
+                ast.Import(names=[ast.alias(name=f"{statement.module}.errors", asname=alias.asname or alias.name)])
                 for alias in statement.names
                 if alias.name == "errors"
             )
@@ -311,7 +309,9 @@ def _classification_matches(statements: list[ast.stmt], context: _HandlerContext
 
 
 def _branch_translates(statements: list[ast.stmt]) -> bool:
-    return any(isinstance(node, (ast.Raise, ast.Return)) for statement in statements for node in _walk_same_scope(statement))
+    return any(
+        isinstance(node, (ast.Raise, ast.Return)) for statement in statements for node in _walk_same_scope(statement)
+    )
 
 
 def _message_matches(node: ast.expr, context: _HandlerContext) -> list[ast.expr]:

{sarj_python_lint-0.80.8 → sarj_python_lint-0.80.11}/src/sarj_python_lint/rules/over_mocked_test.py

@@ -762,9 +762,7 @@ def _parametrized_arguments(
             continue
         argnames = _call_argument(decorator, 0, "argnames")
         if isinstance(argnames, ast.Constant) and isinstance(argnames.value, str):
-            parametrized.update(
-                stripped_name for name in argnames.value.split(",") if (stripped_name := name.strip())
-            )
+            parametrized.update(stripped_name for name in argnames.value.split(",") if (stripped_name := name.strip()))
         elif isinstance(argnames, (ast.List, ast.Tuple)):
             parametrized.update(
                 element.value

{sarj_python_lint-0.80.8 → sarj_python_lint-0.80.11}/src/sarj_python_lint/rules/phase_label_comment.py

@@ -15,6 +15,8 @@ from sarj_python_lint.rule_base import (
     RuleCategory,
     RuleDocumentation,
     RuleExample,
+    Severity,
+    parse_or_none,
 )
 from sarj_python_lint.rules._comments import nested_comment_lines, standalone_comments
 from sarj_python_lint.rules._paths import is_generated, is_test_path
@@ -26,44 +28,49 @@ if TYPE_CHECKING:
 
 # A bounded whole-body grammar: decoration and joins are ceremony only when
 # every substantive token is itself a phase label.
-_PHASE_WORD = (
-    r"arrange|act|assert(?:ion)?s?|given|when|then|exercise|execute|"
-    r"verif(?:y|ication)|cleanup|prepare|sanity(?:\s+check)?"
-)
+_PHASE_WORD = r"(?:arrange|act|assert(?:ion)?s?|given|when|then)(?:\s+phase)?"
 _PHASE_RE = re.compile(
-    rf"^[-=~*_#.\s]{{0,40}}(?:{_PHASE_WORD})"
-    rf"(?:\s*(?:[/&+,|]|->|and)\s*(?:{_PHASE_WORD}))*"
+    rf"^(?:\d+[.)]\s*)?[-=~*_#.\s]{{0,40}}(?:{_PHASE_WORD})"
+    rf"(?:\s*(?:[/&+,|]|-|->|→|and)\s*(?:{_PHASE_WORD}))*"
     rf"[-=~*_#.\s:;!–—]{{0,40}}$",
     re.IGNORECASE,
 )
 
 
 class TestPhaseLabelComment(Rule):
-    id: str = "test-phase-label-comment"
+    id: str = "no-bare-test-phase-comments"
     code: str = "SARJ089"
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
-        summary="Tests must not use bare Arrange, Act, Assert, Given, When, or Then phase comments.",
+        summary="Test files must not use bare phase comments such as Arrange, Act, Assert, Given, When, or Then.",
         rationale="Phase labels narrate test structure without explaining behavior and often indicate that a test needs clearer names or smaller units.",
         remediation="Delete the label; if the phases remain hard to follow, extract a named helper or split the test.",
         category=RuleCategory.TESTING,
         autofix=AutofixPolicy.NONE,
+        aliases=("test-phase-label-comment",),
         limitations=(
-            "Only standalone comments in recognized test files are checked; nested literal comments and trailing comments are excluded.",
+            "Standalone comments across recognized test and test-support files are checked, including fixtures, helpers, and module sections.",
+            "Trailing comments and comments inside bracketed expressions are excluded.",
             "Comments containing words beyond the bounded phase-label grammar are preserved.",
         ),
         examples=(
             RuleExample(
-                example_id="bare-phase-label",
-                title="Bare phase label",
+                example_id="bare-test-phase-comments",
+                title="Bare Arrange, Act, and Assert labels",
                 outcome=ExampleOutcome.MATCH,
                 files=(
                     ExampleFile.python(
                         "tests/test_widget.py",
-                        "def test_widget():\n    # Arrange\n    widget = make_widget()\n    assert widget\n",
+                        "def test_widget():\n"
+                        "    # Arrange\n"
+                        "    widget = make_widget()\n"
+                        "    # Act\n"
+                        "    result = widget.run()\n"
+                        "    # Assert\n"
+                        "    assert result.ok\n",
                     ),
                 ),
                 focus_path=PurePosixPath("tests/test_widget.py"),
-                expected_count=1,
+                expected_count=3,
                 public=True,
             ),
             RuleExample(
@@ -73,7 +80,9 @@ class TestPhaseLabelComment(Rule):
                 files=(
                     ExampleFile.python(
                         "tests/test_widget.py",
-                        "def test_widget():\n    # Then the retry loop would spin forever.\n    assert works()\n",
+                        "def test_widget():\n"
+                        "    # A stale token here would authorize the wrong tenant.\n"
+                        "    assert request_is_rejected()\n",
                     ),
                 ),
                 focus_path=PurePosixPath("tests/test_widget.py"),
@@ -86,7 +95,7 @@ class TestPhaseLabelComment(Rule):
 
     @override
     def check(self, path: Path, source: str) -> list[Diagnostic]:
-        if is_generated(path, source) or not is_test_path(path):
+        if is_generated(path, source) or not is_test_path(path) or parse_or_none(path, source) is None:
             return []
         try:
             standalone, _ = standalone_comments(source)
@@ -99,7 +108,11 @@ class TestPhaseLabelComment(Rule):
                 line=line,
                 col=col + 1,
                 code=self.code,
-                message=self.description,
+                message=(
+                    f"Bare test phase comment {body.strip()!r} narrates structure; delete it or replace it "
+                    "with non-obvious rationale."
+                ),
+                severity=Severity.WARNING,
                 column_encoding=ColumnEncoding.CODEPOINTS,
             )
             for line, col, body in standalone

{sarj_python_lint-0.80.8 → sarj_python_lint-0.80.11}/src/sarj_python_lint/rules/prefer_class_row.py

@@ -401,9 +401,7 @@ def _model_name(node: ast.expr) -> str | None:
 
 def _is_rebound_between(scoped_nodes: list[ast.AST], name: str, start: int, end: int) -> bool:
     return any(
-        start < node.lineno < end and _writes_name(node, name)
-        for node in scoped_nodes
-        if isinstance(node, ast.stmt)
+        start < node.lineno < end and _writes_name(node, name) for node in scoped_nodes if isinstance(node, ast.stmt)
     )
 
 

{sarj_python_lint-0.80.8 → sarj_python_lint-0.80.11}/src/sarj_python_lint/rules/prefer_constant_time_secret_compare.py

@@ -50,7 +50,9 @@ _CATEGORY_WORDS = frozenset({"kind", "kinds", "type", "types"})
 _DESCRIPTOR_WORDS = frozenset(
     {"id", "ids", "kind", "kinds", "name", "names", "permission", "permissions", "scope", "scopes", "type", "types"}
 )
-_EXTERNAL_PREFIXES = frozenset({"given", "incoming", "presented", "provided", "received", "request", "submitted", "supplied"})
+_EXTERNAL_PREFIXES = frozenset(
+    {"given", "incoming", "presented", "provided", "received", "request", "submitted", "supplied"}
+)
 _EXPECTED_PREFIXES = frozenset({"configured", "current", "expected", "known", "stored"})
 _AUTH_MAPPING_WORDS = frozenset({"authorization", "cookies", "headers", "path_params", "query_params"})
 _STORED_OWNER_WORDS = frozenset({"config", "configuration", "self", "session", "settings"})
@@ -340,8 +342,10 @@ def _is_auth_mapping(node: ast.expr) -> bool:
 
 
 def _is_auth_key(node: ast.expr) -> bool:
-    return isinstance(node, ast.Constant) and isinstance(node.value, str) and (
-        node.value.lower() == "token" or _is_authenticator_name(node.value)
+    return (
+        isinstance(node, ast.Constant)
+        and isinstance(node.value, str)
+        and (node.value.lower() == "token" or _is_authenticator_name(node.value))
     )
 
 
@@ -409,10 +413,7 @@ def _environment_names(module: ast.Module) -> frozenset[str]:
 
 
 def _bound_names(scope: ast.FunctionDef | ast.AsyncFunctionDef) -> frozenset[str]:
-    names = {
-        argument.arg
-        for argument in (*scope.args.posonlyargs, *scope.args.args, *scope.args.kwonlyargs)
-    }
+    names = {argument.arg for argument in (*scope.args.posonlyargs, *scope.args.args, *scope.args.kwonlyargs)}
     for assignment in _assignments(scope.body):
         target, _ = _assignment_parts(assignment)
         if target is not None:

{sarj_python_lint-0.80.8 → sarj_python_lint-0.80.11}/src/sarj_python_lint/rules/prefer_fstring_over_concat.py

@@ -559,9 +559,7 @@ def _shadowed_producers(statements: list[ast.stmt], before_line: int | None) ->
             bound = _bound_names(statement)
         if isinstance(statement, ast.Import):
             bound.difference_update(
-                alias.asname or alias.name
-                for alias in statement.names
-                if alias.name in {"json", "re"}
+                alias.asname or alias.name for alias in statement.names if alias.name in {"json", "re"}
             )
         shadowed.update(bound & _PRODUCER_NAMES)
     return frozenset(shadowed)

{sarj_python_lint-0.80.8 → sarj_python_lint-0.80.11}/src/sarj_python_lint/rules/prefer_immutable_module_constant.py

@@ -49,7 +49,23 @@ _MUTATING_METHODS = frozenset(
 )
 _CONCRETE_COLLECTION_METHODS = _MUTATING_METHODS | {"copy"}
 _NON_ESCAPING_CALLS = frozenset(
-    {"all", "any", "dict", "enumerate", "frozenset", "iter", "len", "list", "max", "min", "reversed", "set", "sorted", "sum", "tuple"}
+    {
+        "all",
+        "any",
+        "dict",
+        "enumerate",
+        "frozenset",
+        "iter",
+        "len",
+        "list",
+        "max",
+        "min",
+        "reversed",
+        "set",
+        "sorted",
+        "sum",
+        "tuple",
+    }
 )
 
 
@@ -57,9 +73,7 @@ class PreferImmutableModuleConstant(Rule):
     id: str = "prefer-immutable-module-constant"
     code: str = "SARJ096"
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
-        summary=(
-            "Nonempty uppercase module collections allow top-level membership or keys to change at runtime."
-        ),
+        summary=("Nonempty uppercase module collections allow top-level membership or keys to change at runtime."),
         rationale=(
             "A constant-looking collection can expose process-wide top-level mutation even when callers intend it as a "
             "read-only lookup table."
@@ -259,7 +273,9 @@ class _MutationVisitor(ast.NodeVisitor):
             self.visit(node.value)
 
     def visit_AugAssign(self, node: ast.AugAssign) -> None:
-        self._record_name(_mutated_target(node.target) or (node.target.id if isinstance(node.target, ast.Name) else None))
+        self._record_name(
+            _mutated_target(node.target) or (node.target.id if isinstance(node.target, ast.Name) else None)
+        )
         self.visit(node.value)
 
     def visit_Delete(self, node: ast.Delete) -> None: