sarj-python-lint 1.33.0__tar.gz → 1.35.0__tar.gz

{sarj_python_lint-1.33.0 → sarj_python_lint-1.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 1.33.0
+Version: 1.35.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/
@@ -18,10 +18,10 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: >=3.14
 Requires-Dist: packaging==26.3
-Requires-Dist: ruff>=0.16.10
-Requires-Dist: sarj-rule-contracts==0.2.3
-Requires-Dist: sqlglot==30.19.0
-Requires-Dist: typer==0.27.2
+Requires-Dist: ruff>=0.17.0
+Requires-Dist: sarj-rule-contracts==0.2.4
+Requires-Dist: sqlglot==30.22.0
+Requires-Dist: typer==0.27.3
 Description-Content-Type: text/markdown
 
 <!-- Generated by `code-standards maintain docs sync`; do not edit. -->

{sarj_python_lint-1.33.0 → sarj_python_lint-1.35.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sarj-python-lint"
-version = "1.33.0"
+version = "1.35.0"
 description = "Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults"
 readme = "README.md"
 authors = [{ name = "sarj-ai" }]
@@ -15,7 +15,7 @@ classifiers = [
   "Programming Language :: Python :: 3.14",
   "Topic :: Software Development :: Quality Assurance",
 ]
-dependencies = ["sarj-rule-contracts==0.2.3", "packaging==26.3", "ruff>=0.16.10", "sqlglot==30.19.0", "typer==0.27.2"]
+dependencies = ["sarj-rule-contracts==0.2.4", "packaging==26.3", "ruff>=0.17.0", "sqlglot==30.22.0", "typer==0.27.3"]
 
 [project.scripts]
 sarj-python-lint = "sarj_python_lint.__main__:main"
@@ -31,8 +31,8 @@ Issues = "https://github.com/sarj-ai/code-standards/issues"
 [dependency-groups]
 dev = [
   "pytest>=9.1.1",
-  "ruff>=0.16.10",
-  "basedpyright>=1.40.1",
+  "ruff>=0.17.0",
+  "basedpyright>=1.40.2",
 ]
 
 [build-system]

{sarj_python_lint-1.33.0 → sarj_python_lint-1.35.0}/src/sarj_python_lint/rules/_inert_model_annotation.py

@@ -107,3 +107,54 @@ def _literal(node: ast.expr) -> bool:
         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.33.0 → sarj_python_lint-1.35.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.35.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.33.0 → sarj_python_lint-1.35.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.33.0 → sarj_python_lint-1.35.0}/src/sarj_python_lint/rules/no_redundant_literal_description.py

@@ -18,7 +18,9 @@ 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._inert_model_annotation import inert_direct_model_body
 from sarj_python_lint.rules._paths import is_test_path
+from sarj_python_lint.rules._resource_provenance import ResourceProvenance
 
 
 if TYPE_CHECKING:
@@ -44,7 +46,7 @@ class NoRedundantLiteralDescription(Rule):
     id = "no-restated-closed-domain-description"
     code = "SARJ423"
     documentation = RuleDocumentation(
-        default_level=Severity.WARNING,
+        default_level=Severity.ERROR,
         summary="Do not restate a string Literal or local string Enum domain in its Pydantic description.",
         rationale=(
             "Pydantic already publishes literal and enum domains in JSON Schema; duplicate must-be prose can "
@@ -61,6 +63,7 @@ class NoRedundantLiteralDescription(Rule):
             "Only direct fields on classes with a direct BaseModel base are inspected.",
             "Domains are resolved only from direct string Literals and static Literal aliases or string-valued Enums in the same module.",
             "Descriptions are reported only when a narrow clause repeats the complete domain without mapping or rationale.",
+            "ERROR requires an inert direct model with no json_schema_extra options; custom construction, schema metadata, local aliases and Enum annotations retain WARNING with schema-ownership review guidance.",
             "Test and generated files are excluded.",
         ),
         examples=(
@@ -116,7 +119,9 @@ class NoRedundantLiteralDescription(Rule):
         local_domains = _local_closed_domains(tree, imports)
         diagnostics: list[Diagnostic] = []
 
-        def collect_field_descriptions(statement: ast.AnnAssign, field_name: str, domain: frozenset[str]) -> None:
+        def collect_field_descriptions(
+            statement: ast.AnnAssign, field_name: str, domain: frozenset[str], *, severity: Severity
+        ) -> None:
             for field_call in _field_calls(statement, imports):
                 description = next(
                     (keyword.value for keyword in field_call.keywords if keyword.arg == "description"), None
@@ -134,26 +139,74 @@ class NoRedundantLiteralDescription(Rule):
                         col=description.col_offset + 1,
                         code=self.code,
                         message=(
-                            f"`{field_name}` repeats values already emitted by its Literal or Enum schema; "
-                            "remove the repeated domain while preserving behavioral guidance."
+                            f"`{field_name}` repeats its declared Literal or Enum domain; "
+                            "remove the repeated list only after preserving required schema metadata and behavioral guidance."
                         ),
-                        severity=Severity.WARNING,
+                        severity=severity,
                     )
                 )
 
-        for model in (node for node in context.nodes(ast.AST) if isinstance(node, ast.ClassDef)):
+        for model in context.nodes(ast.ClassDef):
             if not _is_direct_model(model, imports) or _has_custom_schema_hook(model):
                 continue
+            severity = _description_level(model, context)
             for statement in model.body:
                 if not isinstance(statement, ast.AnnAssign) or not isinstance(statement.target, ast.Name):
                     continue
                 domain = _closed_domain(statement.annotation, imports, local_domains)
                 if domain is None or _has_schema_override(statement.annotation, imports):
                     continue
-                collect_field_descriptions(statement, statement.target.id, domain)
+                collect_field_descriptions(
+                    statement,
+                    statement.target.id,
+                    domain,
+                    severity=severity,
+                )
         return diagnostics
 
 
+def _description_level(model: ast.ClassDef, context: PythonFileContext) -> Severity:
+    return Severity.ERROR if _inert_description_model(model, context) else Severity.WARNING
+
+
+def _inert_description_model(model: ast.ClassDef, context: PythonFileContext) -> bool:
+    if context.dynamic_namespace or not inert_direct_model_body(model, context.imports):
+        return False
+    provenance = ResourceProvenance(context, require_static_namespace=True)
+    for node in walk_ast(model):
+        if isinstance(node, ast.keyword) and node.arg == "json_schema_extra":
+            return False
+        if not _annotation_provider_proven(node, context, provenance):
+            return False
+        if isinstance(node, ast.Call) and not provenance.imported(
+            node.func, context.imports.resolved_qualified_name(node.func) or "pydantic.Field"
+        ):
+            return False
+    return any(
+        provenance.imported(base, context.imports.resolved_qualified_name(base) or "pydantic.BaseModel")
+        for base in model.bases
+    )
+
+
+def _annotation_provider_proven(node: ast.AST, context: PythonFileContext, provenance: ResourceProvenance) -> bool:
+    if isinstance(node, ast.AnnAssign) and isinstance(node.annotation, ast.Constant):
+        return False
+    if isinstance(node, ast.Subscript) and context.imports.resolved_qualified_name(node.value) in {
+        "typing.Annotated",
+        "typing_extensions.Annotated",
+    }:
+        argument = node.slice.elts[0] if isinstance(node.slice, ast.Tuple) and node.slice.elts else node.slice
+        return not isinstance(argument, ast.Constant)
+    if isinstance(node, ast.Name | ast.Attribute) and (qualified := context.imports.resolved_qualified_name(node)) in {
+        "typing.Literal",
+        "typing.Annotated",
+        "typing_extensions.Literal",
+        "typing_extensions.Annotated",
+    }:
+        return provenance.imported(node, qualified)
+    return True
+
+
 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)
 

{sarj_python_lint-1.33.0 → sarj_python_lint-1.35.0}/src/sarj_python_lint/rules/no_redundant_module_alias_exports.py

@@ -30,7 +30,7 @@ class NoRedundantModuleAliasExports(Rule):
     id: str = "no-redundant-module-alias-exports"
     code: str = "SARJ440"
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
-        default_level=Severity.WARNING,
+        default_level=Severity.ERROR,
         summary="Do not manufacture public APIs from private names or replace the current module.",
         rationale=(
             "Binding a public name to a private implementation creates two names for one API and disguises the "
@@ -41,7 +41,8 @@ class NoRedundantModuleAliasExports(Rule):
         remediation=(
             "Define maintained APIs under their public names and update local callers directly. Import the canonical "
             "path inside maintained code. If a compatibility module is still required, expose its supported names with "
-            "explicit same-name imports grouped by source module."
+            "explicit same-name imports grouped by source module. Preserve a required compatibility or module-identity "
+            "contract with a reasoned exact suppression rather than renaming automatically."
         ),
         category=RuleCategory.MAINTAINABILITY,
         autofix=AutofixPolicy.NONE,

{sarj_python_lint-1.33.0 → sarj_python_lint-1.35.0}/src/sarj_python_lint/rules/no_swallowed_asyncio_cancellation.py

@@ -19,6 +19,7 @@ from sarj_python_lint.rule_base import (
 )
 from sarj_python_lint.rules._ast_index import nodes
 from sarj_python_lint.rules._paths import is_test_path, is_test_support_path
+from sarj_python_lint.rules._resource_provenance import ResourceProvenance
 
 
 if TYPE_CHECKING:
@@ -41,7 +42,7 @@ class NoSwallowedAsyncioCancellation(Rule):
     id = "no-swallowed-asyncio-cancellation"
     code = "SARJ458"
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
-        default_level=Severity.WARNING,
+        default_level=Severity.ERROR,
         summary="Preserve cancellation when an async operation is cancelled.",
         rationale=(
             "Returning or falling through after catching CancelledError can make cancelled work look successful "
@@ -60,6 +61,7 @@ class NoSwallowedAsyncioCancellation(Rule):
             "Only straight-line handlers with a return or normal fallthrough are reported. Compound handlers, re-raising, and translated exceptions are excluded. Any attribute call named uncancel is conservatively excluded without proving its receiver, so unrelated methods can hide a finding.",
             "A single-name task created by asyncio.create_task, immediately cancelled before a try that only awaits it, is intentionally excluded as child cleanup; this does not prove concurrent caller cancellation cannot occur.",
             "Try statements with control-transferring or compound finalizers are excluded, including handlers nested beneath them. Runtime helper effects and interprocedural task ownership are not inferred.",
+            "Only a try body consisting of one awaited, unmodified canonical asyncio.sleep call with literal arguments is blocking. Unresolved operations and child cancellation remain advisory.",
         ),
         examples=(
             RuleExample(
@@ -129,12 +131,34 @@ def _function_diagnostics(function: ast.AsyncFunctionDef, context: PythonFileCon
                     col=handler.col_offset + 1,
                     code=code,
                     message=_MESSAGE,
-                    severity=Severity.WARNING,
+                    severity=Severity.ERROR if _caller_sleep(node, context) else Severity.WARNING,
                 )
             )
     return diagnostics
 
 
+def _caller_sleep(node: ast.Try, context: PythonFileContext) -> bool:
+    if context.dynamic_namespace or len(node.body) != 1 or len(node.handlers) != 1:
+        return False
+    provenance = ResourceProvenance(context, require_static_namespace=True)
+    caught = node.handlers[0].type
+    if caught is None or not provenance.imported(
+        caught, context.imports.resolved_qualified_name(caught) or "asyncio.CancelledError"
+    ):
+        return False
+    match node.body[0]:
+        case ast.Expr(value=ast.Await(value=ast.Call() as call)):
+            if not context.imports.resolves(call.func, sources=frozenset({"asyncio"}), symbol="sleep"):
+                return False
+            if not provenance.imported(call.func, "asyncio.sleep"):
+                return False
+            if not all(isinstance(value, ast.Constant) for value in call.args):
+                return False
+            return not call.keywords
+        case _:
+            return False
+
+
 def _local_nodes(function: ast.AsyncFunctionDef) -> Iterator[ast.AST]:
     stack: list[ast.AST] = list(reversed(function.body))
     yield function

{sarj_python_lint-1.33.0 → sarj_python_lint-1.35.0}/src/sarj_python_lint/rules/no_test_method_grafting.py

@@ -28,7 +28,7 @@ class NoTestMethodGrafting(ProjectRule):
     id = "no-test-method-grafting"
     code = "SARJ478"
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
-        default_level=Severity.WARNING,
+        default_level=Severity.ERROR,
         summary="Avoid assigning replacement implementations directly onto resolved methods in tests.",
         rationale=(
             "Grafting a function onto a collaborator or mock hides the boundary's callable contract and bypasses "
@@ -135,7 +135,7 @@ class NoTestMethodGrafting(ProjectRule):
                     line=position.line,
                     col=position.column + 1,
                     code=self.code,
-                    severity=Severity.WARNING,
+                    severity=Severity.ERROR,
                     message=(
                         f"Test assigns an implementation directly to resolved method `{method}`; inject a fake, "
                         "or configure the existing autospecced mock method's side_effect"

{sarj_python_lint-1.33.0 → sarj_python_lint-1.35.0}/src/sarj_python_lint/rules/no_unused_copy_result.py

@@ -26,7 +26,7 @@ class NoUnusedCopyResult(ProjectRule):
     id = "no-unused-copy-result"
     code = "SARJ483"
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
-        default_level=Severity.WARNING,
+        default_level=Severity.ERROR,
         summary="Use the replacement returned by a resolved copy API.",
         rationale="Copy-on-write replacement APIs return another value rather than updating the original. Discarding their result can silently leave subsequent operations using unchanged data.",
         remediation="Assign, return, or otherwise consume the replacement. A copy hook intentionally exercised for its effects or exceptions can use a narrow suppression; do not automatically delete the call.",
@@ -113,7 +113,7 @@ class NoUnusedCopyResult(ProjectRule):
                 col=node.col_offset + 1,
                 code=self.code,
                 message="This copy API returns a replacement that is discarded; assign or return it, or document intentional copy-hook effects.",
-                severity=Severity.WARNING,
+                severity=Severity.ERROR,
             )
             for node in (context.copy_on_write.discarded)
             if not is_suppressed(context.source_lines, node.lineno, self.code)