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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 1.32.0
+Version: 1.33.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.33.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sarj-python-lint"
-version = "1.32.0"
+version = "1.33.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.33.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.33.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.33.0/src/sarj_python_lint/rules/_inert_model_annotation.py

@@ -0,0 +1,109 @@
+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)
+    )

sarj_python_lint-1.33.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.33.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.33.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

{sarj_python_lint-1.32.0 → sarj_python_lint-1.33.0}/src/sarj_python_lint/rules/no_input_model_mutation.py

@@ -26,7 +26,7 @@ class NoInputModelMutation(ProjectRule):
     id = "no-input-model-mutation"
     code = "SARJ481"
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
-        default_level=Severity.WARNING,
+        default_level=Severity.ERROR,
         summary="Return replacement values instead of mutating caller-owned Pydantic models.",
         rationale="Assignments through shared model inputs also change every caller alias. Copying only the outer list or model retains nested aliases and can make repeated transformations observe each other's changes.",
         remediation="Return replacement models and explicitly capture the result. Copy each changed ancestor; permit fresh local builders and use exact suppressions for documented in-place APIs. model_copy updates must already satisfy the complete model contract.",
@@ -127,7 +127,7 @@ class NoInputModelMutation(ProjectRule):
                 col=node.col_offset + 1,
                 code=self.code,
                 message="This write changes a caller-owned model or shared descendant; return replacements and copy each changed ancestor, or document an intentional in-place contract.",
-                severity=Severity.WARNING,
+                severity=Severity.ERROR,
             )
             for node in (mutation.node for mutation in context.copy_on_write.mutations if not mutation.before_validator)
             if not is_suppressed(context.source_lines, node.lineno, self.code)

{sarj_python_lint-1.32.0 → sarj_python_lint-1.33.0}/src/sarj_python_lint/rules/no_mocked_pydantic_value_object.py

@@ -27,7 +27,7 @@ class NoMockedPydanticValueObject(ProjectRule):
     id = "no-mocked-pydantic-value-object"
     code = "SARJ479"
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
-        default_level=Severity.WARNING,
+        default_level=Severity.ERROR,
         summary="Build real Pydantic models when test doubles supply model field data.",
         rationale=(
             "Mocking a Pydantic value object bypasses validation, defaults, serialization, and field relationships. "
@@ -126,7 +126,7 @@ class NoMockedPydanticValueObject(ProjectRule):
                 line=call.lineno,
                 col=call.col_offset + 1,
                 code=self.code,
-                severity=Severity.WARNING,
+                severity=Severity.ERROR,
                 message=(
                     f"Mock supplies field data for Pydantic model `{model}`; construct the real model "
                     "or use a typed factory with valid defaults"

{sarj_python_lint-1.32.0 → sarj_python_lint-1.33.0}/src/sarj_python_lint/rules/no_shallow_container_type_guard.py

@@ -43,7 +43,7 @@ class NoShallowContainerTypeGuard(Rule):
     id = "no-shallow-container-type-guard"
     code = "SARJ472"
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
-        default_level=Severity.WARNING,
+        default_level=Severity.ERROR,
         summary="Do not claim typed container contents from a container-only type guard.",
         rationale="TypeGuard and TypeIs let callers trust their declared narrowing. Checking only dict, list, or set does not validate keys, values, or elements, so callers can perform operations that fail at runtime.",
         remediation="Use object for unchecked container slots, or validate their contents when the narrower contract is required. Keep constrained input types that already prove the contents.",
@@ -56,6 +56,7 @@ class NoShallowContainerTypeGuard(Rule):
             "Annotation imports include TYPE_CHECKING imports. Runtime imports use conservative file-wide shadow facts, so unrelated local rebinding can cause false negatives. Wildcard imports, explicit writes to relevant builtin or typing attributes, and exception, pattern or walrus bindings that shadow relevant names or imported aliases exclude the file; dynamic namespace mutation is not inferred.",
             "Relative or conditional imports that replace relevant builtin or typing names exclude the file unless the import proves the same canonical symbol. Unrelated relative imports remain in scope.",
             "No autofix: widening the return contract can require caller changes, while adding content validation changes behavior and cost.",
+            "Visible __builtins__ namespace access abstains because mapping-backed replacement can change the meaning of builtin checks.",
         ),
         examples=(
             RuleExample(
@@ -98,7 +99,7 @@ class NoShallowContainerTypeGuard(Rule):
                     col=statement.col_offset + 1,
                     code=self.code,
                     message="Container-only isinstance check does not validate the declared container contents; use object for unchecked slots or validate the contents required by the return type.",
-                    severity=Severity.WARNING,
+                    severity=Severity.ERROR,
                 )
             )
         return findings
@@ -176,6 +177,8 @@ def _builtin_symbol(node: ast.expr | None, imports: ImportIndex) -> str | None:
 
 
 def _ambiguous_symbols(context: PythonFileContext) -> bool:
+    if context.dynamic_namespace or any(node.id == "__builtins__" for node in context.nodes(ast.Name)):
+        return True
     sensitive_names = _BUILTINS | {
         name
         for name, target in context.module_imports.bindings.items()

{sarj_python_lint-1.32.0 → sarj_python_lint-1.33.0}/src/sarj_python_lint/rules/no_typed_doc_sections.py

@@ -14,6 +14,7 @@ from sarj_python_lint.rule_base import (
     RuleDocumentation,
     RuleExample,
     Severity,
+    is_suppressed,
 )
 from sarj_python_lint.rules._prose_budget import groups
 
@@ -29,7 +30,7 @@ class NoTypedDocSections(Rule):
     id = "no-docstring-type-restatement"
     code = "SARJ092"
     documentation = RuleDocumentation(
-        default_level=Severity.WARNING,
+        default_level=Severity.ERROR,
         summary="A docstring type label repeats an annotation from the fully typed signature.",
         rationale=(
             "A repeated type spelling can drift from the annotation and obscures the behavioral contract that only prose "
@@ -47,6 +48,7 @@ class NoTypedDocSections(Rule):
             "A documented label must parse as a Python type expression and match the corresponding annotation.",
             "Generated files, runtime-consumed prompt, CLI, and route docstrings, properties, abstract methods, overloads, protocol methods, and partially typed signatures are excluded.",
             "NumPy underlined sections and Sphinx type fields intentionally remain with their selected documentation convention.",
+            "A reasoned exact-code suppression on the function declaration or closing docstring line preserves required documentation tooling conventions; markers inside string content are not suppression comments.",
         ),
         examples=(
             RuleExample(
@@ -96,7 +98,7 @@ class NoTypedDocSections(Rule):
                     f"This docstring repeats {len(group.typed_restatements)} type label(s) already present in the "
                     "signature; remove only the type labels and keep the behavioral descriptions."
                 ),
-                severity=Severity.WARNING,
+                severity=Severity.ERROR,
                 column_encoding=group.column_encoding,
             )
             for group in groups(path, source)
@@ -120,7 +122,11 @@ def _public_contract_docstring_lines(context: PythonFileContext) -> frozenset[in
         first = node.body[0]
         if not (isinstance(first, ast.Expr) and isinstance(first.value, ast.Constant)):
             continue
-        if _is_public_contract(node, parents):
+        if (
+            _is_public_contract(node, parents)
+            or is_suppressed(context.source_lines, node.lineno, NoTypedDocSections.code)
+            or is_suppressed(context.source_lines, first.end_lineno or first.lineno, NoTypedDocSections.code)
+        ):
             excluded.add(first.lineno)
     return frozenset(excluded)
 

{sarj_python_lint-1.32.0 → sarj_python_lint-1.33.0}/src/sarj_python_lint/rules/prefer_module_level_constant.py

@@ -98,7 +98,7 @@ class PreferModuleLevelConstant(Rule):
     id: str = "prefer-module-level-constant"
     code: str = "SARJ039"
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
-        default_level=Severity.WARNING,
+        default_level=Severity.ERROR,
         summary="Hoist repeatedly read static values when a module constant preserves behavior.",
         rationale=(
             "Rebuilding a substantial static collection repeats allocation, while calling `re.compile` with a "
@@ -116,7 +116,8 @@ class PreferModuleLevelConstant(Rule):
             "Test, test-support, and generated files are excluded.",
             "Collections require at least eight deeply immutable elements, or three when allocated inside a loop; only representation-insensitive reads are accepted.",
             "Final dictionaries retain mutable contents at runtime; unknown calls, mutation, and escaping references are excluded from hoisting candidates.",
-            "Regex findings require a proven stdlib `re.compile` binding and exclude `re.DEBUG`; the rule cannot prove that a function is hot, so findings remain advisory.",
+            "Visible frame or dynamic-namespace observation retains WARNING because moving a local binding can change observed caller state.",
+            "Regex findings require a proven stdlib `re.compile` binding and exclude `re.DEBUG`; regex cache lookup findings remain warnings because invocation frequency and initialization timing are unproved. Immutable literal collection tables enforce the explicit static-lifetime policy at error severity; preserve any intentional per-call ownership with an exact-code exception.",
         ),
         examples=(
             RuleExample(
@@ -209,7 +210,9 @@ class PreferModuleLevelConstant(Rule):
                         col=stmt.col_offset + 1,
                         code=self.code,
                         message=_message(name, candidate),
-                        severity=Severity.WARNING,
+                        severity=Severity.WARNING
+                        if candidate.kind == "regex" or context.dynamic_namespace
+                        else Severity.ERROR,
                     )
                 )
         diags.sort(key=lambda d: (d.line, d.col))

{sarj_python_lint-1.32.0 → sarj_python_lint-1.33.0}/src/sarj_python_lint/rules/prefer_pytest_fixture_injection.py

@@ -47,7 +47,7 @@ class PreferPytestFixtureInjection(Rule):
     id: str = "prefer-pytest-fixture-injection"
     code: str = "SARJ476"
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
-        default_level=Severity.WARNING,
+        default_level=Severity.ERROR,
         summary="Request shared database-pool setup through a pytest fixture.",
         rationale=(
             "Calling a shared conftest pool helper during initial test setup bypasses an explicit pytest "
@@ -199,7 +199,7 @@ class PreferPytestFixtureInjection(Rule):
                             "open/close with application lifespan when it owns them; keep factories for variants "
                             "or fresh instances."
                         ),
-                        severity=Severity.WARNING,
+                        severity=Severity.ERROR,
                     )
                 )
         return diagnostics

{sarj_python_lint-1.32.0 → sarj_python_lint-1.33.0}/src/sarj_python_lint/rules/prefer_regex_fullmatch.py

@@ -35,10 +35,10 @@ class PreferRegexFullmatch(Rule):
     id: str = "prefer-regex-fullmatch"
     code: str = "SARJ460"
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
-        default_level=Severity.WARNING,
+        default_level=Severity.ERROR,
         summary="An anchored regex validation predicate does not require a full-string match.",
         rationale="The regex `$` anchor can match before a final newline, so an anchored match can accept a value that was not fully validated.",
-        remediation="Use `re.fullmatch` or the compiled pattern's `fullmatch` method for whole-value validation; review whether a terminal newline is intentionally allowed.",
+        remediation="Use `re.fullmatch` or the compiled pattern's `fullmatch` method for strict whole-value validation. Preserve deliberate terminal-newline acceptance or an existing match contract with a reasoned exact SARJ460 exception; do not rewrite that behavior automatically.",
         category=RuleCategory.CORRECTNESS,
         autofix=AutofixPolicy.NONE,
         limitations=(
@@ -133,8 +133,8 @@ class PreferRegexFullmatch(Rule):
                     line=call.lineno,
                     col=call.col_offset + 1,
                     code=self.code,
-                    message="anchored match is used as a validation predicate, but `$` can accept a final newline; use fullmatch for whole-value validation and review newline handling.",
-                    severity=Severity.WARNING,
+                    message="anchored match is used as a validation predicate, but `$` can accept a final newline; use fullmatch for the strict whole-value policy, or preserve an intentional newline contract with a reasoned SARJ460 exception.",
+                    severity=Severity.ERROR,
                 )
             )
         return sorted(findings, key=lambda item: (item.line, item.col))