sarj-python-lint 1.44.0__tar.gz → 1.45.0__tar.gz

{sarj_python_lint-1.44.0 → sarj_python_lint-1.45.0}/PKG-INFO

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

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

{sarj_python_lint-1.44.0 → sarj_python_lint-1.45.0}/src/sarj_python_lint/_file_context.py

@@ -40,7 +40,7 @@ class PythonFileContext:
                 return unit.tree
         try:
             return ast.parse(self.source, filename=str(self.path))
-        except SyntaxError:
+        except SyntaxError, UnicodeError:
             return None
 
     @cached_property

{sarj_python_lint-1.44.0 → sarj_python_lint-1.45.0}/src/sarj_python_lint/rule_base.py

@@ -167,6 +167,6 @@ class ProjectRule(Rule, ABC):
 def parse_or_none(path: Path, source: str) -> ast.Module | None:
     try:
         tree = ast.parse(source, filename=str(path))
-    except SyntaxError:
+    except SyntaxError, UnicodeError:
         tree = None
     return tree

{sarj_python_lint-1.44.0 → sarj_python_lint-1.45.0}/src/sarj_python_lint/rules/_annotation_semantics.py

@@ -52,7 +52,7 @@ class AnnotationSemantics:
             return annotation
         try:
             parsed = ast.parse(annotation.value.strip(), mode="eval").body
-        except SyntaxError:
+        except SyntaxError, UnicodeError:
             return None
         ast.copy_location(parsed, annotation)
         return parsed

{sarj_python_lint-1.44.0 → sarj_python_lint-1.45.0}/src/sarj_python_lint/rules/_comments.py

@@ -338,7 +338,10 @@ def _scan_memo(source: str) -> _Scan:
     global _last_scan  # ruff: ignore[global-statement] — single-slot memo; the CLI runs rules per file sequentially
     if _last_scan is not None and _last_scan[0] is source:
         return _last_scan[1]
-    result = _scan(source)
+    try:
+        result = _scan(source)
+    except UnicodeError:
+        result = _Scan([], [], set(), 1 << 30, [])
     _last_scan = (source, result)
     return result
 

sarj_python_lint-1.45.0/src/sarj_python_lint/rules/_inherited_contract.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+import ast
+
+
+def inherited_contract(owner: ast.AST | None) -> bool:
+    return isinstance(owner, ast.ClassDef) and bool(owner.bases)

{sarj_python_lint-1.44.0 → sarj_python_lint-1.45.0}/src/sarj_python_lint/rules/_paths.py

@@ -81,7 +81,7 @@ def _leading_header_bodies(source: str) -> list[str]:
             token = next(tokens)
         except StopIteration:
             break
-        except IndentationError, tokenize.TokenError:
+        except IndentationError, tokenize.TokenError, UnicodeError:
             break
         if token.start[0] > _GENERATED_HEADER_LINES:
             break

{sarj_python_lint-1.44.0 → sarj_python_lint-1.45.0}/src/sarj_python_lint/rules/_registry.py

@@ -218,6 +218,7 @@ from sarj_python_lint.rules.no_contradictory_type_guard import NoContradictoryTy
 from sarj_python_lint.rules.no_impossible_pydantic_field_bounds import NoImpossiblePydanticFieldBounds
 from sarj_python_lint.rules.no_invalid_pydantic_bypass import NoInvalidPydanticBypass
 from sarj_python_lint.rules.no_partial_type_is import NoPartialTypeIs
+from sarj_python_lint.rules.no_shallow_record_type_guard import NoShallowRecordTypeGuard
 from sarj_python_lint.rules.no_unknown_pydantic_validator_field import NoUnknownPydanticValidatorField
 from sarj_python_lint.rules.prefer_discriminated_model_union import PreferDiscriminatedModelUnion
 from sarj_python_lint.rules.redundant_test_constructor_forwarder import RedundantTestConstructorForwarder
@@ -232,6 +233,7 @@ REGISTRY: Mapping[str, type[Rule]] = MappingProxyType(
         NoInvalidPydanticBypass.id: NoInvalidPydanticBypass,
         NoPartialTypeIs.id: NoPartialTypeIs,
         NoContradictoryTypeGuard.id: NoContradictoryTypeGuard,
+        NoShallowRecordTypeGuard.id: NoShallowRecordTypeGuard,
         NoConflictingPydanticAliasValidation.id: NoConflictingPydanticAliasValidation,
         NoUnknownPydanticValidatorField.id: NoUnknownPydanticValidatorField,
         NoImpossiblePydanticFieldBounds.id: NoImpossiblePydanticFieldBounds,

{sarj_python_lint-1.44.0 → sarj_python_lint-1.45.0}/src/sarj_python_lint/rules/no_invalid_pydantic_bypass.py

@@ -4,8 +4,9 @@ import ast
 from dataclasses import dataclass
 from itertools import starmap
 from pathlib import PurePosixPath
-from typing import TYPE_CHECKING, final, override
+from typing import TYPE_CHECKING, Final, TypeIs, final, override
 
+from sarj_python_lint.json_boundary import is_object_mapping
 from sarj_python_lint.rule_base import (
     AutofixPolicy,
     Diagnostic,
@@ -40,6 +41,9 @@ _PASSIVE_CONFIG = frozenset({"frozen", "strict", "validate_default"})
 _MODEL_APIS = frozenset({"model_construct", "model_validate", "model_validate_json", "model_validate_strings"})
 _MAX_ANNOTATION_DEPTH = 64
 _MAX_ANNOTATION_NODES = 1024
+_MAX_LITERAL_TEXT = 65536
+_UNKNOWN_LITERAL: Final = object()
+_PAIR_ARITY = 2
 
 
 @dataclass(frozen=True, slots=True)
@@ -75,11 +79,12 @@ class NoInvalidPydanticBypass(Rule):
         autofix=AutofixPolicy.NONE,
         limitations=(
             "Only plain, direct, module-level Pydantic BaseModel subclasses with supported built-in and typing field annotations are inspected; hooks, inheritance, class decorators and custom methods are excluded.",
-            "Only explicit None conflicts and closed string Literal domains are checked. Numeric Literal equality, bounds, opaque aliases, custom field types and coercions are not inferred.",
+            "Checks explicit None conflicts, closed string Literal domains, and bounded side-effect-free literal values contradicting builtin primitive or container field contracts. Coercible input is not assumed to be validated stored output.",
+            "Container literals preserve their actual construction semantics, including last-wins dictionary keys. Unpacking, calls, unhashable literal containers, opaque values, numeric Literal domains, bounds, aliases and custom field types are not inferred. Bool remains an int subtype, and numeric int-to-float/complex assignability is preserved.",
             "model_construct must use explicit keywords; omitted required fields are checked only when no unpacking or positional argument can supply them.",
             "model_copy requires a fresh exact constructor or a stable unescaped local constructor binding, plus a plain literal update dictionary. Arbitrary annotated receivers and overridden methods are excluded.",
             "Field aliases, non-passive model configuration, class or instance mutation and escape, ambiguous namespaces, tests and generated files are excluded.",
-            "Direct model field annotations exceeding a bounded depth or node budget exclude the file rather than risking recursive analysis failure.",
+            "Direct model field annotations exceeding a bounded depth or node budget exclude the file rather than risking recursive analysis failure. Literal analysis also bounds the value tree and combined string/bytes content to avoid excessive witness work.",
             "Trusted valid construction and copy operations remain legal. No autofix chooses domain values or changes validation behavior.",
         ),
         examples=(
@@ -111,6 +116,36 @@ class NoInvalidPydanticBypass(Rule):
                 expected_count=0,
                 public=True,
             ),
+            RuleExample(
+                example_id="construct-invalid-list-member",
+                scenario="stored-literal-contract",
+                title="Unchecked list elements must satisfy the stored field type",
+                outcome=ExampleOutcome.MATCH,
+                files=(
+                    ExampleFile.python(
+                        "app/models.py",
+                        "from pydantic import BaseModel\nclass Payload(BaseModel):\n    labels: list[str]\npayload = Payload.model_construct(labels=[3])\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("app/models.py"),
+                expected_count=1,
+                public=True,
+            ),
+            RuleExample(
+                example_id="construct-trusted-list-members",
+                scenario="stored-literal-contract",
+                title="Trusted list elements preserve the field contract",
+                outcome=ExampleOutcome.NO_MATCH,
+                files=(
+                    ExampleFile.python(
+                        "app/models.py",
+                        "from pydantic import BaseModel\nclass Payload(BaseModel):\n    labels: list[str]\npayload = Payload.model_construct(labels=['ready'])\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("app/models.py"),
+                expected_count=0,
+                public=True,
+            ),
         ),
     )
     description = documentation.summary
@@ -161,7 +196,10 @@ def _bounded_annotation(annotation: ast.expr) -> bool:
         visited += 1
         if depth > _MAX_ANNOTATION_DEPTH or visited > _MAX_ANNOTATION_NODES:
             return False
-        pending.extend((child, depth + 1) for child in ast.iter_child_nodes(node))
+        for child in ast.iter_child_nodes(node):
+            if visited + len(pending) >= _MAX_ANNOTATION_NODES:
+                return False
+            pending.append((child, depth + 1))
     return True
 
 
@@ -423,28 +461,142 @@ def _invalid_values(
         )
     for name, value in values.items():
         field = model.fields.get(name)
-        if field is None or not isinstance(value, ast.Constant):
+        if field is None:
             continue
-        domain = _string_domain(field.annotation, context)
-        if domain is not None and value.value not in domain:
-            findings.append(
-                _diagnostic(
-                    value,
-                    context,
-                    f"Unchecked `{name}={value.value!r}` is outside `{model.node.name}`'s declared string Literal domain; validate a complete input mapping or supply an admitted value.",
-                )
-            )
-        elif value.value is None and _excludes_none(field.annotation, context):
-            findings.append(
-                _diagnostic(
-                    value,
-                    context,
-                    f"Unchecked `{name}=None` contradicts `{model.node.name}`'s non-null field annotation; validate a complete input mapping or supply a non-null value.",
-                )
-            )
+        finding = _invalid_field_value(model, name, field.annotation, value, context)
+        if finding is not None:
+            findings.append(finding)
     return findings
 
 
+def _invalid_field_value(
+    model: _Model, name: str, annotation: ast.expr, value: ast.expr, context: PythonFileContext
+) -> Diagnostic | None:
+    literal = _literal_value(value)
+    if literal is _UNKNOWN_LITERAL:
+        return None
+    if not _bounded_literal_text(annotation, value):
+        return None
+    domain = _string_domain(annotation, context)
+    if domain is not None and not any(literal == member for member in domain):
+        message = f"Unchecked `{name}` is outside `{model.node.name}`'s declared string Literal domain; validate a complete input mapping or supply an admitted value."
+    elif literal is None and _excludes_none(annotation, context):
+        message = f"Unchecked `{name}=None` contradicts `{model.node.name}`'s non-null field annotation; validate a complete input mapping or supply a non-null value."
+    elif _literal_incompatible(annotation, literal, context):
+        message = f"Unchecked `{name}` stores a literal incompatible with `{model.node.name}`'s field type; validate a complete input mapping or supply a value satisfying the stored contract."
+    else:
+        return None
+    return _diagnostic(value, context, message)
+
+
+def _bounded_literal_text(annotation: ast.expr, value: ast.expr) -> bool:
+    length = 0
+    for expression in (annotation, value):
+        for node in ast.walk(expression):
+            if isinstance(node, ast.Constant) and isinstance(node.value, str | bytes):
+                length += len(node.value)
+                if length > _MAX_LITERAL_TEXT:
+                    return False
+    return True
+
+
+def _literal_value(node: ast.expr) -> object:
+    if not _bounded_annotation(node) or any(isinstance(member, ast.Call) for member in ast.walk(node)):
+        return _UNKNOWN_LITERAL
+    try:
+        return ast.literal_eval(node)  # pyright: ignore[reportAny] -- bounded stdlib literal parser boundary exports object.
+    except ValueError, TypeError, SyntaxError, RecursionError:
+        return _UNKNOWN_LITERAL
+
+
+def _literal_incompatible(annotation: ast.expr, value: object, context: PythonFileContext) -> bool:
+    if isinstance(annotation, ast.Constant):
+        return annotation.value is None and value is not None
+    if isinstance(annotation, ast.BinOp) and isinstance(annotation.op, ast.BitOr):
+        return _literal_incompatible(annotation.left, value, context) and _literal_incompatible(
+            annotation.right, value, context
+        )
+    if isinstance(annotation, ast.Name) and annotation.id in _BUILTINS:
+        return _builtin_incompatible(annotation.id, value)
+    if not isinstance(annotation, ast.Subscript):
+        return False
+    return _subscript_incompatible(annotation, value, context)
+
+
+def _subscript_incompatible(annotation: ast.Subscript, value: object, context: PythonFileContext) -> bool:
+    members = _members(annotation.slice)
+    if _typing_wrapper(annotation, "Annotated", context):
+        return bool(members) and _literal_incompatible(members[0], value, context)
+    if _typing_wrapper(annotation, "Optional", context):
+        return value is not None and _literal_incompatible(annotation.slice, value, context)
+    if _typing_wrapper(annotation, "Union", context):
+        return bool(members) and all(_literal_incompatible(member, value, context) for member in members)
+    domain = _string_domain(annotation, context)
+    if domain is not None:
+        return not any(value == member for member in domain)
+    if isinstance(annotation.value, ast.Name) and annotation.value.id in _GENERICS:
+        return _container_incompatible(annotation.value.id, members, value, context)
+    return False
+
+
+def _builtin_incompatible(kind: str, value: object) -> bool:
+    match kind:
+        case "str":
+            return not isinstance(value, str)
+        case "bytes":
+            return not isinstance(value, bytes)
+        case "bool":
+            return not isinstance(value, bool)
+        case "int":
+            return not isinstance(value, int)
+        case "float":
+            return not isinstance(value, int | float)
+        case "complex":
+            return not isinstance(value, int | float | complex)
+        case "list":
+            return not isinstance(value, list)
+        case "dict":
+            return not isinstance(value, dict)
+        case "set":
+            return not isinstance(value, set)
+        case "frozenset":
+            return not isinstance(value, frozenset)
+        case "tuple":
+            return not isinstance(value, tuple)
+        case _:
+            return False
+
+
+def _container_incompatible(kind: str, members: list[ast.expr], value: object, context: PythonFileContext) -> bool:
+    if _builtin_incompatible(kind, value):
+        return True
+    if kind == "dict" and is_object_mapping(value) and len(members) == _PAIR_ARITY:
+        return any(
+            _literal_incompatible(members[0], key, context) or _literal_incompatible(members[1], item, context)
+            for key, item in value.items()
+        )
+    if _is_literal_items(value):
+        if kind == "tuple" and isinstance(value, tuple):
+            return _tuple_incompatible(members, value, context)
+        if kind in {"list", "set", "frozenset"} and len(members) == 1:
+            return any(_literal_incompatible(members[0], item, context) for item in value)
+    return False
+
+
+def _is_literal_items(value: object) -> TypeIs[list[object] | set[object] | frozenset[object] | tuple[object, ...]]:
+    return isinstance(value, list | set | frozenset | tuple)
+
+
+def _tuple_incompatible(members: list[ast.expr], value: tuple[object, ...], context: PythonFileContext) -> bool:
+    if len(members) == _PAIR_ARITY and _ellipsis(members[1]):
+        return any(_literal_incompatible(members[0], item, context) for item in value)
+    if any(_ellipsis(member) for member in members):
+        return False
+    return len(members) != len(value) or any(
+        _literal_incompatible(member, item, context) for member, item in zip(members, value, strict=False)
+    )
+
+
 def _string_domain(annotation: ast.expr, context: PythonFileContext) -> frozenset[str | None] | None:
     if isinstance(annotation, ast.Constant) and annotation.value is None:
         return frozenset({None})

{sarj_python_lint-1.44.0 → sarj_python_lint-1.45.0}/src/sarj_python_lint/rules/no_psycopg_execution_outside_injected_owner.py

@@ -848,6 +848,6 @@ def _module_type_aliases(tree: ast.Module, counts: dict[str, int]) -> dict[str,
 def _string_annotation_kind(value: str, types: _TypeIndex, seen: frozenset[str]) -> str | None:
     try:
         parsed = ast.parse(value, mode="eval")
-    except SyntaxError:
+    except SyntaxError, UnicodeError:
         return None
     return _annotation_kind(parsed.body, types, seen)