sarj-python-lint 1.32.0__tar.gz → 1.34.0__tar.gz

{sarj_python_lint-1.32.0 → sarj_python_lint-1.34.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 1.32.0
+Version: 1.34.0
 Summary: Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults
 Project-URL: Homepage, https://code-standards.sarj.ai/rules/python/
 Project-URL: Documentation, https://code-standards.sarj.ai/rules/python/

{sarj_python_lint-1.32.0 → sarj_python_lint-1.34.0}/pyproject.toml

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

{sarj_python_lint-1.32.0 → sarj_python_lint-1.34.0}/src/sarj_python_lint/_python_target.py

@@ -99,7 +99,7 @@ def _project_declaration(path: Path) -> str | None:
     return declaration if isinstance(declaration, str) else None
 
 
-def _is_toml_table(value: object) -> TypeGuard[dict[str, object]]:
+def _is_toml_table(value: object) -> TypeGuard[dict[object, object]]:
     return isinstance(value, dict)
 
 

{sarj_python_lint-1.32.0 → sarj_python_lint-1.34.0}/src/sarj_python_lint/_ratchet_cli.py

@@ -148,7 +148,7 @@ def _ruff_selector_aliases() -> dict[str, str]:
         raise TypeError(msg)
     aliases: dict[str, str] = {}
     for raw_item in raw:
-        if not _is_string_object_mapping(raw_item):
+        if not _is_object_mapping(raw_item):
             msg = "Ruff rule catalog contains a non-object entry"
             raise TypeError(msg)
         code = raw_item.get("code")
@@ -173,8 +173,7 @@ def _is_object_list(value: object) -> TypeGuard[list[object]]:
     return isinstance(value, list)
 
 
-def _is_string_object_mapping(value: object) -> TypeGuard[dict[str, object]]:
-    # JSON object keys are strings by definition; json.loads supplied `value`.
+def _is_object_mapping(value: object) -> TypeGuard[dict[object, object]]:
     return isinstance(value, dict)
 
 

sarj_python_lint-1.34.0/src/sarj_python_lint/rules/_inert_model_annotation.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import ast
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from sarj_python_lint.rules._imports import ImportIndex
+
+
+_BUILTINS = frozenset({"bool", "bytes", "dict", "float", "frozenset", "int", "list", "object", "set", "str", "tuple"})
+_QUALIFIED_BUILTINS = frozenset(f"builtins.{name}" for name in _BUILTINS)
+_MAX_ANNOTATION_LENGTH = 4096
+_CANONICAL_TYPES = frozenset(
+    {
+        "typing.Annotated",
+        "typing.Any",
+        "typing.ClassVar",
+        "typing.Literal",
+        "typing.Optional",
+        "typing.Union",
+        "typing_extensions.Annotated",
+        "typing_extensions.ClassVar",
+        "typing_extensions.Literal",
+        "pydantic.PositiveInt",
+        "pydantic.NonNegativeInt",
+        "pydantic.types.PositiveInt",
+        "pydantic.types.NonNegativeInt",
+    }
+)
+_LITERAL_CONSTRAINTS = frozenset(
+    {
+        "pydantic.Field",
+        "pydantic.fields.Field",
+        "annotated_types.Ge",
+        "annotated_types.Gt",
+        "annotated_types.Le",
+        "annotated_types.Lt",
+        "annotated_types.MultipleOf",
+    }
+)
+
+
+def inert_model_annotation(node: ast.expr, imports: ImportIndex, *, remaining: int = 64) -> bool:
+    if remaining <= 0:
+        return False
+    match node:
+        case ast.Constant(value=str() as source):
+            if len(source) > _MAX_ANNOTATION_LENGTH:
+                return False
+            try:
+                parsed = ast.parse(source, mode="eval").body
+            except SyntaxError, ValueError, RecursionError:
+                return False
+            return inert_model_annotation(parsed, imports, remaining=remaining - 1)
+        case ast.Constant(value=None):
+            return True
+        case ast.Name(id=name):
+            return (name in _BUILTINS and imports.builtin_is_unshadowed(name)) or imports.resolved_qualified_name(
+                node
+            ) in _CANONICAL_TYPES
+        case ast.Attribute():
+            qualified = imports.resolved_qualified_name(node)
+            return qualified in _CANONICAL_TYPES or qualified in _QUALIFIED_BUILTINS
+        case ast.BinOp(left=left, op=ast.BitOr(), right=right):
+            return inert_model_annotation(left, imports, remaining=remaining - 1) and inert_model_annotation(
+                right, imports, remaining=remaining - 1
+            )
+        case ast.Subscript():
+            return _subscript_annotation(node, imports, remaining=remaining)
+        case _:
+            return False
+
+
+def _subscript_annotation(node: ast.Subscript, imports: ImportIndex, *, remaining: int) -> bool:
+    if not inert_model_annotation(node.value, imports, remaining=remaining - 1):
+        return False
+    arguments = node.slice.elts if isinstance(node.slice, ast.Tuple) else [node.slice]
+    qualified = imports.resolved_qualified_name(node.value)
+    if qualified in {"typing.Literal", "typing_extensions.Literal"}:
+        return all(_literal(item) for item in arguments)
+    if qualified in {"typing.Annotated", "typing_extensions.Annotated"}:
+        return (
+            bool(arguments)
+            and inert_model_annotation(arguments[0], imports, remaining=remaining - 1)
+            and all(_constraint(item, imports) for item in arguments[1:])
+        )
+    return all(inert_model_annotation(item, imports, remaining=remaining - 1) for item in arguments)
+
+
+def _constraint(node: ast.expr, imports: ImportIndex) -> bool:
+    if _literal(node):
+        return True
+    return (
+        isinstance(node, ast.Call)
+        and imports.resolved_qualified_name(node.func) in _LITERAL_CONSTRAINTS
+        and all(_literal(argument) for argument in node.args)
+        and all(keyword.arg is not None and _literal(keyword.value) for keyword in node.keywords)
+    )
+
+
+def _literal(node: ast.expr) -> bool:
+    return isinstance(node, ast.Constant) or (
+        isinstance(node, ast.UnaryOp)
+        and isinstance(node.op, ast.UAdd | ast.USub)
+        and isinstance(node.operand, ast.Constant)
+        and isinstance(node.operand.value, int | float)
+        and not isinstance(node.operand.value, bool)
+    )
+
+
+_MODEL_FIELD_SOURCES = frozenset({"pydantic", "pydantic.fields", "pydantic.v1", "pydantic.v1.fields"})
+
+
+def inert_direct_model_body(cls: ast.ClassDef, imports: ImportIndex) -> bool:
+    if cls.decorator_list or cls.keywords or cls.type_params or len(cls.bases) != 1:
+        return False
+    for statement in cls.body:
+        match statement:
+            case ast.Pass() | ast.Expr(value=ast.Constant(value=str())):
+                continue
+            case ast.AnnAssign(target=ast.Name(), annotation=annotation, value=value):
+                if not inert_model_annotation(annotation, imports):
+                    return False
+                if value is None or isinstance(value, ast.Constant):
+                    continue
+                if (
+                    isinstance(value, ast.Call)
+                    and imports.resolves(value.func, sources=_MODEL_FIELD_SOURCES, symbol="Field")
+                    and not value.args
+                    and all(
+                        keyword.arg is not None and _model_literal_value(keyword.value) is not None
+                        for keyword in value.keywords
+                    )
+                ):
+                    continue
+                return False
+            case _:
+                return False
+    return True
+
+
+def _model_literal_value(node: ast.expr | None) -> object:
+    if isinstance(node, ast.Constant):
+        return node.value
+    if isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.USub) and isinstance(node.operand, ast.Constant):
+        numeric = _model_numeric_value(node.operand.value)
+        if numeric is not None:
+            return -numeric
+    return None
+
+
+def _model_numeric_value(value: object) -> float | None:
+    match value:
+        case bool():
+            return None
+        case int() | float():
+            return float(value)
+        case _:
+            return None

sarj_python_lint-1.34.0/src/sarj_python_lint/rules/_resolved_operation_signature.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import ast
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from sarj_python_lint.rules._imports import ImportIndex
+    from sarj_python_lint.rules._project_index import SourceUnit
+
+
+_BUILTINS = frozenset({"str", "bytes", "int", "float", "bool", "object", "list", "dict", "tuple", "set", "frozenset"})
+
+
+def stable_local_class(unit: SourceUnit, name: str) -> bool:
+    if unit.tree is None:
+        return False
+    return sum(
+        isinstance(node, ast.ClassDef | ast.FunctionDef | ast.AsyncFunctionDef) and node.name == name
+        for node in ast.walk(unit.tree)
+    ) == 1 and not any(
+        (isinstance(node, ast.Name) and node.id == name and not isinstance(node.ctx, ast.Load))
+        or (isinstance(node, ast.arg) and node.arg == name)
+        for node in ast.walk(unit.tree)
+    )
+
+
+def resolved_operation_signature(
+    method: ast.FunctionDef | ast.AsyncFunctionDef, unit: SourceUnit, imports: ImportIndex
+) -> str | None:
+    arguments = method.args
+    if method.type_params or arguments.vararg is not None or arguments.kwarg is not None or method.returns is None:
+        return None
+    positional = [*arguments.posonlyargs, *arguments.args]
+    if not positional or positional[0].arg != "self" or positional[0].annotation is not None:
+        return None
+    keys = [_type_key(argument.annotation, unit, imports) for argument in (*positional[1:], *arguments.kwonlyargs)]
+    result = _type_key(method.returns, unit, imports)
+    defaults = [*arguments.defaults, *(default for default in arguments.kw_defaults if default is not None)]
+    if (
+        result is None
+        or any(key is None for key in keys)
+        or any(not isinstance(default, ast.Constant) for default in defaults)
+    ):
+        return None
+    return repr(
+        (
+            type(method).__name__,
+            len(arguments.posonlyargs),
+            tuple(argument.arg for argument in (*positional, *arguments.kwonlyargs)),
+            keys,
+            result,
+            tuple(ast.dump(default) for default in arguments.defaults),
+            tuple(None if default is None else ast.dump(default) for default in arguments.kw_defaults),
+        )
+    )
+
+
+def _type_key(node: ast.expr | None, unit: SourceUnit, imports: ImportIndex) -> str | None:
+    if node is None or unit.tree is None:
+        return None
+    match node:
+        case ast.Name():
+            return _name_type_key(node, unit, imports)
+        case ast.Attribute():
+            return imports.resolved_qualified_name(node)
+        case ast.Constant(value=str()):
+            return None
+        case ast.Constant():
+            return ast.dump(node)
+        case _:
+            return _compound_type_key(node, unit, imports)
+
+
+def _name_type_key(node: ast.Name, unit: SourceUnit, imports: ImportIndex) -> str | None:
+    if unit.tree is None:
+        return None
+    name = node.id
+    if name in _BUILTINS and imports.builtin_is_unshadowed(name):
+        return f"builtins.{name}"
+    imported = imports.resolved_qualified_name(node)
+    if imported is not None:
+        return imported
+    if any(isinstance(child, ast.ClassDef) and child.name == name for child in unit.tree.body) and stable_local_class(
+        unit, name
+    ):
+        return f"{unit.module}.{name}"
+    return None
+
+
+def _compound_type_key(node: ast.expr, unit: SourceUnit, imports: ImportIndex) -> str | None:
+    match node:
+        case ast.Subscript(value=value, slice=argument):
+            kind, parts = "subscript", (value, argument)
+        case ast.BinOp(left=left, op=ast.BitOr(), right=right):
+            kind, parts = "union", (left, right)
+        case ast.Tuple(elts=elements):
+            kind, parts = "tuple", tuple(elements)
+        case _:
+            return None
+    keys = tuple(_type_key(part, unit, imports) for part in parts)
+    return repr((kind, keys)) if all(key is not None for key in keys) else None

{sarj_python_lint-1.32.0 → sarj_python_lint-1.34.0}/src/sarj_python_lint/rules/_resource_provenance.py

@@ -26,18 +26,23 @@ _SCOPES = (
 )
 _RESOURCE_OWNERS = MappingProxyType(
     {
+        "asyncio": frozenset({"sleep", "CancelledError", "exceptions.CancelledError"}),
         "contextlib": frozenset({"ExitStack", "AsyncExitStack", "_BaseExitStack"}),
         "subprocess": frozenset({"Popen", "TimeoutExpired"}),
         "re": frozenset({"compile", "Match", "Pattern"}),
         "unittest": frozenset({"mock.Mock", "mock.MagicMock", "mock.AsyncMock"}),
-        "typing": frozenset({"final"}),
-        "typing_extensions": frozenset({"final"}),
+        "typing": frozenset({"final", "Literal", "Annotated"}),
+        "typing_extensions": frozenset({"final", "Literal", "Annotated"}),
         "pydantic": frozenset(
             {
                 "BaseModel",
                 "main.BaseModel",
+                "v1.BaseModel",
+                "v1.main.BaseModel",
                 "Field",
                 "fields.Field",
+                "v1.Field",
+                "v1.fields.Field",
                 "ConfigDict",
                 "config.ConfigDict",
                 "model_validator",

sarj_python_lint-1.34.0/src/sarj_python_lint/rules/_static_json_alias.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import ast
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from sarj_python_lint.rules._annotation_semantics import AnnotationSemantics
+
+
+_CONTAINERS = frozenset({"list", "dict", "tuple"})
+_TYPING_CONTAINERS = frozenset({"List", "Dict", "Tuple", "Optional", "Union"})
+_SCALARS = frozenset({"str", "int", "float", "bool", "None"})
+_TYPING_SOURCES = frozenset({"typing", "typing_extensions"})
+_RUNTIME_ATTRIBUTES = frozenset({"__annotations__", "__value__", "get_type_hints", "TypeAdapter", "validate_call"})
+
+
+def private_static_json_alias(tree: ast.Module, name: str, semantics: AnnotationSemantics) -> bool:
+    if not name.startswith("_") or name.startswith("__"):
+        return False
+    nodes = tuple(ast.walk(tree))
+    parents = {id(child): parent for parent in nodes for child in ast.iter_child_nodes(parent)}
+    if any(_runtime_annotation_consumer(node, semantics) for node in nodes):
+        return False
+    safe: set[int] = set()
+    for statement in tree.body:
+        if (value := _alias_value(statement, name)) is not None:
+            safe.update(id(node) for node in ast.walk(value))
+    annotations = _private_annotations(tree, name, semantics, nodes, parents)
+    if not annotations:
+        return False
+    safe.update(id(node) for annotation in annotations for node in ast.walk(annotation))
+    return all(id(node) in safe for node in nodes if _references_name(node, name))
+
+
+def _private_annotations(
+    tree: ast.Module, name: str, semantics: AnnotationSemantics, nodes: tuple[ast.AST, ...], parents: dict[int, ast.AST]
+) -> list[ast.expr]:
+    annotations: list[ast.expr] = []
+    for function in tree.body:
+        if not isinstance(function, ast.FunctionDef | ast.AsyncFunctionDef):
+            continue
+        if not _function_stays_local(function, nodes, parents):
+            continue
+        annotations.extend(
+            annotation
+            for annotation in _function_annotations(function)
+            if any(_references_name(node, name) for node in ast.walk(annotation))
+            and _static_annotation(annotation, name, semantics)
+        )
+    return annotations
+
+
+def _alias_value(statement: ast.stmt, name: str) -> ast.expr | None:
+    match statement:
+        case ast.TypeAlias(name=ast.Name(id=identifier), value=value) if identifier == name:
+            return value
+        case ast.AnnAssign(target=ast.Name(id=identifier), value=value) if identifier == name:
+            return value
+        case _:
+            return None
+
+
+def _references_name(node: ast.AST, name: str) -> bool:
+    if isinstance(node, ast.Name):
+        return isinstance(node.ctx, ast.Load) and node.id == name
+    return isinstance(node, ast.Constant) and isinstance(node.value, str) and name in node.value
+
+
+def _function_stays_local(
+    function: ast.FunctionDef | ast.AsyncFunctionDef, nodes: tuple[ast.AST, ...], parents: dict[int, ast.AST]
+) -> bool:
+    if not function.name.startswith("_") or function.name.startswith("__") or function.decorator_list:
+        return False
+    for node in nodes:
+        if not _references_name(node, function.name):
+            continue
+        parent = parents.get(id(node))
+        if not isinstance(node, ast.Name) or not isinstance(parent, ast.Call) or parent.func is not node:
+            return False
+    return True
+
+
+def _function_annotations(function: ast.FunctionDef | ast.AsyncFunctionDef) -> list[ast.expr]:
+    arguments = function.args
+    annotations = [
+        argument.annotation
+        for argument in (*arguments.posonlyargs, *arguments.args, *arguments.kwonlyargs)
+        if argument.annotation is not None
+    ]
+    if function.returns is not None:
+        annotations.append(function.returns)
+    return annotations
+
+
+def _static_annotation(node: ast.expr, name: str, semantics: AnnotationSemantics, *, remaining: int = 64) -> bool:
+    if remaining <= 0 or (parsed := semantics.parse(node)) is None:
+        return False
+    match parsed:
+        case ast.Name(id=identifier):
+            return identifier == name or (
+                identifier in _SCALARS | _CONTAINERS and semantics.imports.builtin_is_unshadowed(identifier)
+            )
+        case ast.Constant(value=None):
+            return True
+        case ast.BinOp(left=left, op=ast.BitOr(), right=right):
+            return _static_annotation(left, name, semantics, remaining=remaining - 1) and _static_annotation(
+                right, name, semantics, remaining=remaining - 1
+            )
+        case ast.Subscript(value=value, slice=arguments):
+            builtin = (
+                isinstance(value, ast.Name)
+                and value.id in _CONTAINERS
+                and semantics.imports.builtin_is_unshadowed(value.id)
+            )
+            canonical = any(
+                semantics.imports.resolves(value, sources=_TYPING_SOURCES, symbol=symbol)
+                for symbol in _TYPING_CONTAINERS
+            )
+            return (builtin or canonical) and all(
+                _static_annotation(argument, name, semantics, remaining=remaining - 1)
+                for argument in (arguments.elts if isinstance(arguments, ast.Tuple) else [arguments])
+            )
+        case _:
+            return False
+
+
+def _runtime_annotation_consumer(node: ast.AST, semantics: AnnotationSemantics) -> bool:
+    if isinstance(node, ast.Attribute) and node.attr in _RUNTIME_ATTRIBUTES:
+        return True
+    if isinstance(node, ast.Constant) and isinstance(node.value, str) and node.value in _RUNTIME_ATTRIBUTES:
+        return True
+    if not isinstance(node, ast.Call):
+        return False
+    qualified = semantics.imports.resolved_qualified_name(node.func)
+    return qualified in {
+        "pydantic.TypeAdapter",
+        "pydantic.type_adapter.TypeAdapter",
+        "pydantic.validate_call",
+        "typing.get_type_hints",
+        "typing_extensions.get_type_hints",
+    }

{sarj_python_lint-1.32.0 → sarj_python_lint-1.34.0}/src/sarj_python_lint/rules/async_mock_call_without_await_assertion.py

@@ -21,6 +21,7 @@ from sarj_python_lint.rule_base import (
 from sarj_python_lint.rules._ast_index import walk as walk_ast
 from sarj_python_lint.rules._imports import ImportIndex
 from sarj_python_lint.rules._pytest import collected_tests
+from sarj_python_lint.rules._resource_provenance import ResourceProvenance
 
 
 if TYPE_CHECKING:
@@ -78,7 +79,7 @@ class AsyncMockCallWithoutAwaitAssertion(Rule):
     id = "async-mock-call-without-await-assertion"
     code = "SARJ456"
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
-        default_level=Severity.WARNING,
+        default_level=Severity.ERROR,
         summary="Pair positive AsyncMock call assertions with evidence that the mock was awaited.",
         rationale=(
             "Calling an AsyncMock records a call before its coroutine is awaited. A positive call assertion can "
@@ -94,6 +95,7 @@ class AsyncMockCallWithoutAwaitAssertion(Rule):
         limitations=(
             "Only direct statements in collected test functions and methods are inspected; fixtures, helpers, nested blocks, and generated files are excluded.",
             "Requires a fresh local unittest.mock.AsyncMock constructor with unshadowed imports; aliases, reassignment, reset, and ambiguous configuration are excluded.",
+            "Visible provider replacement, escape or unresolved lexical ownership retains WARNING; only the closed canonical AsyncMock provider proof blocks.",
             "Only the mock itself and unchanged immediate children of unspecced, unwrapped mocks are inferred; spec children, return values, and deeper chains are excluded.",
             "Positive call evidence includes direct assertion methods and literal integer or boolean call-state checks; unresolved call expectations are excluded.",
             "Await evidence excludes provably vacuous checks, including zero or nonnegative counts and empty expected await sequences; unresolved expectations are accepted without inferring their values.",
@@ -215,23 +217,54 @@ class AsyncMockCallWithoutAwaitAssertion(Rule):
             for node in context.nodes(ast.AST)
             if isinstance(node, ast.Attribute) and isinstance(node.ctx, (ast.Store, ast.Del))
         }
-        lines = context.source_lines
         return [
-            Diagnostic(
-                path=path,
-                line=call.lineno,
-                col=call.col_offset + 1,
-                code=self.code,
-                severity=Severity.WARNING,
-                message="AsyncMock call assertions do not prove awaiting; keep this assertion and add an await assertion",
-            )
+            finding
             for test in collected_tests(tree.body)
             if not _is_pytest_fixture(test, imports)
-            for call in _uncovered_calls(_test_imports(imports, test), test, writes)
-            if not is_suppressed(lines, call.lineno, self.code)
+            for finding in _test_diagnostics(test, context, imports, writes, self.code)
         ]
 
 
+def _test_diagnostics(
+    test: _TestFunction, context: PythonFileContext, imports: ImportIndex, writes: set[_Reference], code: str
+) -> list[Diagnostic]:
+    calls = tuple(_uncovered_calls(_test_imports(imports, test), test, writes))
+    if not calls:
+        return []
+    severity = Severity.ERROR if _mock_provider_proven(test, context) else Severity.WARNING
+    message = "AsyncMock call assertions do not prove awaiting; keep this assertion and add an await assertion"
+    if severity is Severity.WARNING:
+        message = (
+            "Verify the mock provider is asynchronous before adding an await assertion; "
+            "keep the call assertion and preserve intentional scheduling or synchronous replacement contracts."
+        )
+    return [
+        Diagnostic(
+            path=context.path,
+            line=call.lineno,
+            col=call.col_offset + 1,
+            code=code,
+            severity=severity,
+            message=message,
+        )
+        for call in calls
+        if not is_suppressed(context.source_lines, call.lineno, code)
+    ]
+
+
+def _mock_provider_proven(test: _TestFunction, context: PythonFileContext) -> bool:
+    provenance = ResourceProvenance(context, require_static_namespace=True)
+    constructors = [
+        node
+        for node in ast.walk(test)
+        if isinstance(node, ast.Call)
+        and context.imports.resolved_qualified_name(node.func) == "unittest.mock.AsyncMock"
+    ]
+    return bool(constructors) and all(
+        provenance.imported(node.func, "unittest.mock.AsyncMock") for node in constructors
+    )
+
+
 def _is_pytest_fixture(test: _TestFunction, imports: ImportIndex) -> bool:
     return any(
         imports.resolved_qualified_name(decorator.func if isinstance(decorator, ast.Call) else decorator)

{sarj_python_lint-1.32.0 → sarj_python_lint-1.34.0}/src/sarj_python_lint/rules/no_broad_keyword_capture.py

@@ -45,13 +45,13 @@ class NoBroadKeywordCapture(Rule):
     id = "no-broad-keyword-capture"
     code = "SARJ477"
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
-        default_level=Severity.WARNING,
+        default_level=Severity.ERROR,
         summary="Prefer precise keyword interfaces over missing, Any- or object-valued captures.",
         rationale=(
             "Replacing a fixed typed interface with broad **kwargs can erase required keyword names and per-key "
             "value types, making test doubles accept calls the real implementation rejects. object remains a safe "
-            "typed top type, and deliberately open data interfaces can be valid; this warning requests interface "
-            "review rather than proving every broad capture is defective."
+            "typed top type, and deliberately open data interfaces can be valid; this strict interface policy "
+            "requires a precise contract or a documented open-boundary exception."
         ),
         remediation=(
             "Keep explicit typed parameters at fixed interfaces. Preserve required keyword names with named unused "
@@ -61,13 +61,14 @@ class NoBroadKeywordCapture(Rule):
         category=RuleCategory.MAINTAINABILITY,
         autofix=AutofixPolicy.NONE,
         limitations=(
-            "This is an advisory interface policy, not proof of incorrect behavior or a universal ban on the object type.",
+            "This strict interface policy is not proof of incorrect behavior or a universal ban on the object type; genuinely open boundaries use a reasoned exact-code exception.",
             "Reports missing, Any- or object-valued keyword captures whether discarded, read or forwarded.",
             "Precise or unresolved decorated signature-declaration families and functions with unresolved decorator effects are excluded; known classmethod/staticmethod/abstractmethod/final/override declarations remain eligible.",
             "Homogeneous keyword types constrain values but allow arbitrary names; ParamSpec preserves only its target's existing contract.",
             "Generated/vendor source and stubs are excluded. Unresolved imports, wildcard imports, conflicting imports, actual global or definition-time writes and shadowed annotation provenance are conservative. Identical imports and read-only global declarations remain eligible.",
             "Cross-file aliases, external stubs, generated signatures and runtime reflection are not resolved; transparent annotation metadata and ambiguous decorated declaration families can cause conservative false negatives.",
             "No autofix can infer the intended contract. Dynamic payload/formatting APIs can intentionally need an exact-code exception.",
+            "Runtime special methods and canonical override declarations retain WARNING because framework and inherited signatures can require an open keyword contract; ordinary declared interfaces use ERROR.",
         ),
         examples=(
             RuleExample(
@@ -196,7 +197,7 @@ class NoBroadKeywordCapture(Rule):
                     line=argument.lineno,
                     col=argument.col_offset + 1,
                     code=self.code,
-                    severity=Severity.WARNING,
+                    severity=_interface_severity(function, context, semantics, mutated_members),
                     message=(
                         f"keyword capture `{argument.arg}` has no declared names or narrow value type; "
                         "prefer an explicit typed interface or document a deliberately open contract."
@@ -206,6 +207,23 @@ class NoBroadKeywordCapture(Rule):
         return sorted(findings, key=lambda finding: (finding.line, finding.col))
 
 
+def _interface_severity(
+    function: ast.FunctionDef | ast.AsyncFunctionDef,
+    context: PythonFileContext,
+    semantics: AnnotationSemantics,
+    mutated_members: frozenset[str],
+) -> Severity:
+    if function.name.startswith("__") and function.name.endswith("__"):
+        return Severity.WARNING
+    if any(
+        _known_decorator(decorator, function, context, semantics, mutated_members)
+        in {"typing.override", "typing_extensions.override"}
+        for decorator in function.decorator_list
+    ):
+        return Severity.WARNING
+    return Severity.ERROR
+
+
 def _stable_annotation_semantics(context: PythonFileContext, tree: ast.Module) -> AnnotationSemantics:
     semantics = AnnotationSemantics.from_tree(tree)
     unstable = _conflicting_annotation_imports(context, semantics) | _annotation_binding_writes(context)

{sarj_python_lint-1.32.0 → sarj_python_lint-1.34.0}/src/sarj_python_lint/rules/no_fixed_sleep_in_loop.py

@@ -45,7 +45,7 @@ class NoFixedSleepInLoop(Rule):
     id = "no-fixed-sleep-in-loop"
     code = "SARJ485"
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
-        default_level=Severity.WARNING,
+        default_level=Severity.ERROR,
         summary="Do not sleep for a fixed literal interval inside a production loop.",
         rationale=(
             "A polling or cleanup loop that sleeps for a literal interval gives tests no seam: every test that "
@@ -161,7 +161,7 @@ class NoFixedSleepInLoop(Rule):
                 col=reported.col_offset + 1,
                 code=self.code,
                 message=_MESSAGE,
-                severity=Severity.WARNING,
+                severity=Severity.ERROR,
             )
             for reported, duration in sleeps
             if (seconds := _folded_seconds(duration, constants)) is not None