sarj-python-lint 1.55.0__tar.gz → 1.57.0__tar.gz

{sarj_python_lint-1.55.0 → sarj_python_lint-1.57.0}/PKG-INFO

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

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

{sarj_python_lint-1.55.0 → sarj_python_lint-1.57.0}/src/sarj_python_lint/rules/_data_union_discriminator.py

@@ -73,6 +73,7 @@ class _DataUnions:
     def __init__(self, context: PythonFileContext, tree: ast.Module) -> None:
         self.context = context
         self.provenance = ResourceProvenance(context, require_static_namespace=True)
+        self.provenance.mutated = _scoped_module_mutations(self.provenance, tree)
         bindings = self.provenance.bindings.get(tree, {})
         self.classes = {
             node.name: node
@@ -177,13 +178,13 @@ class _DataUnions:
         )
 
     def _discriminator_metadata(self, node: ast.expr) -> bool:
-        seen: set[str] = set()
+        seen: frozenset[str] = frozenset()
         for _ in range(_MAX_EXPANSION):
-            if isinstance(node, ast.Name) and node.id in self.values:
-                if node.id in seen:
-                    return True
-                seen.add(node.id)
-                node = self.values[node.id]
+            reference = self._metadata_reference(node, seen)
+            if isinstance(reference, bool):
+                return reference
+            if reference is not None:
+                node, seen = reference.node, reference.aliases
                 continue
             if not isinstance(node, ast.Call):
                 return self._metadata_aliases_discriminate(seen, callable_metadata=False)
@@ -193,6 +194,81 @@ class _DataUnions:
             node = step
         return True
 
+    def _metadata_reference(self, node: ast.expr, seen: frozenset[str]) -> _Expansion | bool | None:
+        if isinstance(node, ast.Name) and node.id in self.values:
+            return True if node.id in seen else _Expansion(self.values[node.id], seen | {node.id})
+        projected = self._metadata_projection(node)
+        if projected is None or isinstance(projected, bool):
+            return projected
+        if not projected.aliases.isdisjoint(seen) or any(
+            self._metadata_projection_escaped(name) for name in projected.aliases
+        ):
+            return True
+        return _Expansion(projected.node, seen | projected.aliases)
+
+    def _metadata_projection(self, node: ast.expr) -> _Expansion | bool | None:
+        if isinstance(node, ast.Subscript):
+            return self._metadata_tuple_item(node)
+        if not isinstance(node, ast.Attribute) or not isinstance(node.value, ast.Name):
+            return None
+        bindings = self.provenance.bindings.get(self.context.tree, {}).get(node.value.id, ())
+        if len(bindings) != 1 or not isinstance(bindings[0], ast.ClassDef):
+            return None
+        value = _namespace_metadata_value(bindings[0], node.attr)
+        return _Expansion(value, frozenset({node.value.id})) if value is not None else None
+
+    def _metadata_tuple_item(self, node: ast.Subscript) -> _Expansion | bool | None:
+        value = node.value
+        names: frozenset[str] = frozenset()
+        for _ in range(_MAX_EXPANSION):
+            if not isinstance(value, ast.Name) or value.id not in self.values:
+                break
+            if value.id in names:
+                return True
+            names |= {value.id}
+            value = self.values[value.id]
+        else:
+            return True
+        if not isinstance(value, ast.Tuple):
+            return None
+        if len(value.elts) > _MAX_EXPANSION:
+            return True
+        if any(isinstance(item, ast.Starred) for item in value.elts):
+            return None
+        index = _metadata_tuple_index(node.slice)
+        if index is None:
+            return True
+        if not -len(value.elts) <= index < len(value.elts):
+            return None
+        return _Expansion(value.elts[index], names)
+
+    def _metadata_projection_escaped(self, name: str) -> bool:
+        bindings = self.provenance.bindings.get(self.context.tree, {}).get(name, ())
+        reads = self.provenance.reads.get(name, ())
+        if len(bindings) != 1 or len(reads) > _MAX_EXPANSION:
+            return True
+        for read in reads:
+            if self.provenance.binding(name, read) is not bindings[0]:
+                continue
+            projection = self.context.parents.get(read)
+            if not isinstance(projection, ast.Attribute | ast.Subscript) or projection.value is not read:
+                return True
+            if not self._metadata_annotation_member(projection):
+                return True
+        return False
+
+    def _metadata_annotation_member(self, node: ast.expr) -> bool:
+        parent = self.context.parents.get(node)
+        if not isinstance(parent, ast.Tuple) or len(parent.elts) > _MAX_EXPANSION:
+            return False
+        owner = self.context.parents.get(parent)
+        return (
+            isinstance(owner, ast.Subscript)
+            and owner.slice is parent
+            and self._typing_symbol(owner.value) == "Annotated"
+            and node in parent.elts[1:]
+        )
+
     def _metadata_step(self, node: ast.Call) -> ast.expr | bool:
         if not _untouched(node.func, self.provenance):
             return False
@@ -204,7 +280,7 @@ class _DataUnions:
             return discriminator
         return False
 
-    def _metadata_aliases_discriminate(self, names: set[str], *, callable_metadata: bool) -> bool:
+    def _metadata_aliases_discriminate(self, names: frozenset[str], *, callable_metadata: bool) -> bool:
         mutations = [self._metadata_mutated(name) for name in names]
         return any(mutation is None for mutation in mutations) or (callable_metadata and not any(mutations))
 
@@ -243,7 +319,12 @@ class _DataUnions:
         reads = self.provenance.reads.get(name, ())
         if len(reads) > _MAX_EXPANSION:
             return True
+        bindings = self.provenance.bindings.get(self.context.tree, {}).get(name, ())
+        if len(bindings) != 1:
+            return True
         for read in reads:
+            if self.provenance.binding(name, read) is not bindings[0]:
+                continue
             node: ast.AST | None = read
             for _ in range(_MAX_EXPANSION):
                 node = self.context.parents.get(node)
@@ -361,6 +442,8 @@ class _DataUnions:
         return uncertain
 
     def _field_domain(self, field: ast.AnnAssign, *, required: bool) -> _Domain:
+        if _direct_initvar_field(field, self.context, self.provenance):
+            return _Domain()
         node = field.annotation
         aliases: set[str] = set()
         for _ in range(_MAX_EXPANSION):
@@ -478,6 +561,26 @@ def _wrapped_annotation(node: ast.Subscript, symbol: str | None, *, required: bo
     return None
 
 
+def _direct_initvar_field(field: ast.AnnAssign, context: PythonFileContext, provenance: ResourceProvenance) -> bool:
+    if field.value is not None or not isinstance(field.annotation, ast.Subscript):
+        return False
+    target = field.annotation.value
+    if not _untouched(target, provenance) or not context.module_imports.resolves(
+        target, sources=_DATACLASS_SOURCES, symbol="InitVar"
+    ):
+        return False
+    owner = context.parents.get(field)
+    if not isinstance(owner, ast.ClassDef):
+        return False
+    for decorator in owner.decorator_list:
+        target = decorator.func if isinstance(decorator, ast.Call) else decorator
+        if _untouched(target, provenance) and context.module_imports.resolves(
+            target, sources=_DATACLASS_SOURCES, symbol="dataclass"
+        ):
+            return True
+    return False
+
+
 def _record(node: ast.ClassDef, context: PythonFileContext, provenance: ResourceProvenance) -> _Record | None:
     required = _record_required(node, context, provenance)
     if required is None:
@@ -622,6 +725,37 @@ def _alias_name(node: ast.stmt) -> str | None:
             return None
 
 
+def _namespace_metadata_value(node: ast.ClassDef, attribute: str) -> ast.expr | None:
+    if node.bases or node.keywords or node.decorator_list or node.type_params or len(node.body) > _MAX_EXPANSION:
+        return None
+    values: list[tuple[str, ast.expr]] = []
+    for member in node.body:
+        binding = _value_binding(member)
+        if binding is not None and not binding[0].startswith("__"):
+            values.append(binding)
+        elif isinstance(member, ast.Pass | ast.Expr) and (
+            isinstance(member, ast.Pass)
+            or (isinstance(member.value, ast.Constant) and isinstance(member.value.value, str))
+        ):
+            continue
+        else:
+            return None
+    if len(values) != 1 or values[0][0] != attribute:
+        return None
+    return values[0][1]
+
+
+def _metadata_tuple_index(node: ast.expr) -> int | None:
+    if isinstance(node, ast.Constant) and type(node.value) is int:
+        return node.value
+    if isinstance(node, ast.UnaryOp) and isinstance(node.operand, ast.Constant) and type(node.operand.value) is int:
+        if isinstance(node.op, ast.USub):
+            return -node.operand.value
+        if isinstance(node.op, ast.UAdd):
+            return node.operand.value
+    return None
+
+
 def _metadata_alias_graph(tree: ast.Module, bindings: dict[str, list[ast.AST]]) -> dict[str, set[str]]:
     graph: dict[str, set[str]] = {}
     for node in tree.body:
@@ -691,6 +825,86 @@ def _string_expression(node: ast.expr) -> ast.expr | None:
         return None
 
 
+def _scoped_module_mutations(provenance: ResourceProvenance, tree: ast.Module) -> set[str]:
+    original = provenance.mutated
+    if not original:
+        return original
+    bindings = provenance.bindings.get(tree, {})
+    owners = {name: bindings[name][0] for name in original if len(bindings.get(name, ())) == 1}
+    writes = _module_attribute_mutations(provenance, owners)
+    if writes is None:
+        return original
+    return {
+        name
+        for name in original
+        if name not in owners or name in writes or _module_binding_escaped(name, owners[name], provenance)
+    }
+
+
+def _module_attribute_mutations(provenance: ResourceProvenance, owners: dict[str, ast.AST]) -> set[str] | None:
+    changed: set[str] = set()
+    count = 0
+    for target in provenance.context.nodes(ast.Attribute):
+        if not isinstance(target.ctx, ast.Store | ast.Del):
+            continue
+        count += 1
+        if count > _MAX_EXPANSION:
+            return None
+        root: ast.expr = target
+        while isinstance(root, ast.Attribute):
+            root = root.value
+        if not isinstance(root, ast.Name) or root.id not in owners:
+            continue
+        binding = provenance.binding(root.id, target)
+        if binding is None or binding is owners[root.id]:
+            changed.add(root.id)
+    return changed
+
+
+def _module_binding_escaped(name: str, owner: ast.AST, provenance: ResourceProvenance) -> bool:
+    reads = provenance.reads.get(name, ())
+    if len(reads) > _MAX_EXPANSION:
+        return True
+    return any(
+        provenance.binding(name, read) is owner and _module_read_escapes(read, provenance.context) for read in reads
+    )
+
+
+def _module_read_escapes(read: ast.Name, context: PythonFileContext) -> bool:
+    current: ast.AST = read
+    for _ in range(_MAX_EXPANSION):
+        parent = context.parents.get(current)
+        if parent is None:
+            return False
+        step = _module_escape_step(parent, current, context)
+        if step is not None:
+            return step
+        current = parent
+    return True
+
+
+def _module_escape_step(parent: ast.AST, current: ast.AST, context: PythonFileContext) -> bool | None:
+    match parent:
+        case ast.Call():
+            return parent.func is not current
+        case ast.Return() | ast.Yield() | ast.YieldFrom() | ast.NamedExpr():
+            return True
+        case ast.arguments():
+            return True if current in parent.defaults or current in parent.kw_defaults else None
+        case ast.Assign() | ast.AnnAssign() | ast.AugAssign():
+            value = parent.value
+            return value is not None and value is current and not _union_expression(value, context)
+        case ast.Subscript() if parent.value is not current:
+            symbol = context.module_imports.resolved_symbol(parent.value, sources=TYPING_SOURCES)
+            if symbol is None:
+                return True
+        case ast.withitem():
+            return parent.context_expr is current
+        case _:
+            pass
+    return False if isinstance(parent, ast.stmt) else None
+
+
 def _untouched(node: ast.expr, provenance: ResourceProvenance) -> bool:
     while isinstance(node, ast.Attribute):
         node = node.value

sarj_python_lint-1.57.0/src/sarj_python_lint/rules/_mapping_shape_callbacks.py

@@ -0,0 +1,260 @@
+from __future__ import annotations
+
+import ast
+from typing import TYPE_CHECKING, final
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from sarj_python_lint._file_context import PythonFileContext
+    from sarj_python_lint.rules._resource_provenance import ResourceProvenance
+
+
+type _Function = ast.FunctionDef | ast.AsyncFunctionDef
+_VALIDATORS = frozenset(
+    {
+        "pydantic.model_validator",
+        "pydantic.field_validator",
+        "pydantic.functional_validators.model_validator",
+        "pydantic.functional_validators.field_validator",
+    }
+)
+_DISCRIMINATORS = frozenset({"pydantic.Discriminator", "pydantic.types.Discriminator"})
+_RAW_METADATA = frozenset(
+    {
+        "pydantic.BeforeValidator",
+        "pydantic.WrapValidator",
+        "pydantic.functional_validators.BeforeValidator",
+        "pydantic.functional_validators.WrapValidator",
+    }
+)
+_MAX_DEPTH = 32
+
+
+@final
+class RawMappingCallbacks:
+    def __init__(
+        self,
+        context: PythonFileContext,
+        provenance: ResourceProvenance,
+        qualified: Callable[[ast.expr, ast.AST], str | None],
+        builtin: Callable[[ast.expr, str, ast.AST], bool],
+        shadowed: Callable[[str, ast.AST], bool],
+    ) -> None:
+        self.context = context
+        self.provenance = provenance
+        self.qualified = qualified
+        self.builtin = builtin
+        self.shadowed = shadowed
+        self.ownership: dict[_Function, bool] = {}
+        self.callbacks = {
+            binding
+            for call in context.nodes(ast.Call)
+            if (origin := qualified(call.func, call)) in _DISCRIMINATORS | _RAW_METADATA
+            if (argument := _callback_argument(call, origin)) is not None
+            if (binding := self.callback(argument)) is not None
+        }
+
+    def callback(self, node: ast.expr, *, seen: frozenset[ast.AST] = frozenset()) -> _Function | None:
+        if len(seen) >= _MAX_DEPTH:
+            return None
+        if isinstance(node, ast.Call):
+            return (
+                self._partial(node, seen)
+                if self.qualified(node.func, node) == "functools.partial"
+                else self._method(node, "__call__", seen)
+            )
+        if isinstance(node, ast.Attribute):
+            return self._method(node.value, node.attr, seen)
+        if not isinstance(node, ast.Name) or not self._stable(node.id) or self.shadowed(node.id, node):
+            return None
+        binding = self.provenance.binding(node.id, node)
+        if isinstance(binding, ast.FunctionDef | ast.AsyncFunctionDef):
+            return binding if not binding.decorator_list else None
+        if not isinstance(binding, ast.Name) or binding in seen:
+            return None
+        value = self.provenance.assignment_value(binding, node)
+        return self.callback(value, seen=seen | {binding}) if value is not None else None
+
+    def _partial(self, node: ast.Call, seen: frozenset[ast.AST]) -> _Function | None:
+        if len(node.args) != 1 or isinstance(node.args[0], ast.Starred):
+            return None
+        callback = self.callback(node.args[0], seen=seen | {node})
+        if callback is None or not (callback.args.posonlyargs or callback.args.args):
+            return None
+        configuration = {argument.arg for argument in callback.args.kwonlyargs}
+        return callback if all(keyword.arg in configuration for keyword in node.keywords) else None
+
+    def _stable(self, name: str) -> bool:
+        return name not in self.provenance.mutated | self.provenance.external_bindings
+
+    def _method(self, node: ast.expr, name: str, seen: frozenset[ast.AST]) -> ast.FunctionDef | None:
+        owner = self._owner(node, seen)
+        if owner is None:
+            return None
+        declaration, on_class = owner
+        if declaration.bases or declaration.keywords or declaration.type_params:
+            return None
+        if (
+            not isinstance(self.context.parents.get(declaration), ast.Module | ast.FunctionDef | ast.AsyncFunctionDef)
+            or not self._stable(declaration.name)
+            or any(
+                self.qualified(decorator, decorator) not in {"typing.final", "typing_extensions.final"}
+                for decorator in declaration.decorator_list
+            )
+        ):
+            return None
+        method = _plain_method(declaration, name)
+        if method is None:
+            return None
+        if not method.decorator_list:
+            return method if not on_class else None
+        if len(method.decorator_list) != 1:
+            return None
+        decorator = method.decorator_list[0]
+        return (
+            method
+            if any(self.builtin(decorator, kind, decorator) for kind in ("staticmethod", "classmethod"))
+            else None
+        )
+
+    def _owner(self, node: ast.expr, seen: frozenset[ast.AST]) -> tuple[ast.ClassDef, bool] | None:
+        if len(seen) >= _MAX_DEPTH:
+            return None
+        if isinstance(node, ast.Call):
+            if node.args or node.keywords or not isinstance(node.func, ast.Name):
+                return None
+            owner = self._owner(node.func, seen | {node})
+            return (owner[0], False) if owner is not None and owner[1] else None
+        if not isinstance(node, ast.Name) or not self._stable(node.id) or self.shadowed(node.id, node):
+            return None
+        binding = self.provenance.binding(node.id, node)
+        if isinstance(binding, ast.ClassDef):
+            return binding, True
+        if not isinstance(binding, ast.Name) or binding in seen:
+            return None
+        value = self.provenance.assignment_value(binding, node)
+        return self._owner(value, seen | {binding}) if value is not None else None
+
+    def owns(self, node: ast.AST) -> bool:
+        function = self._function(node)
+        return function is not None and self._owned(function, frozenset())
+
+    def _function(self, node: ast.AST) -> _Function | None:
+        current = self.context.parents.get(node)
+        while current is not None:
+            if isinstance(current, ast.FunctionDef | ast.AsyncFunctionDef):
+                return current
+            if isinstance(current, ast.ClassDef | ast.Lambda):
+                return None
+            current = self.context.parents.get(current)
+        return None
+
+    def _owned(self, function: _Function, seen: frozenset[ast.AST]) -> bool:
+        if function in self.ownership:
+            return self.ownership[function]
+        if function in seen or len(seen) >= _MAX_DEPTH:
+            return False
+        result = self._raw_validator(function)
+        if not result:
+            owner = self._function(function)
+            result = owner is not None and self._owned(owner, seen | {function}) and self._local_helper(function, owner)
+        self.ownership[function] = result
+        return result
+
+    def _local_helper(self, function: _Function, owner: _Function) -> bool:
+        if (
+            function.decorator_list
+            or self.context.parents.get(function) is not owner
+            or not self._stable(function.name)
+        ):
+            return False
+        reads = [
+            read
+            for read in self.provenance.reads.get(function.name, ())
+            if self.provenance.binding(function.name, read) is function
+        ]
+        return bool(reads) and all(
+            isinstance(parent := self.context.parents.get(read), ast.Call)
+            and parent.func is read
+            and self._function(read) in {owner, function}
+            for read in reads
+        )
+
+    def _raw_validator(self, function: _Function) -> bool:
+        if function in self.callbacks:
+            return True
+        return any(
+            isinstance(decorator, ast.Call)
+            and self.qualified(decorator.func, decorator) in _VALIDATORS
+            and any(
+                keyword.arg == "mode" and self._mode(keyword.value) in {"before", "wrap"}
+                for keyword in decorator.keywords
+            )
+            for decorator in function.decorator_list
+        )
+
+    def _mode(self, node: ast.expr, *, seen: frozenset[ast.AST] = frozenset()) -> str | None:
+        if isinstance(node, ast.Constant) and isinstance(node.value, str):
+            return node.value
+        if (
+            len(seen) >= _MAX_DEPTH
+            or not isinstance(node, ast.Name)
+            or not self._stable(node.id)
+            or self.shadowed(node.id, node)
+        ):
+            return None
+        binding = self.provenance.binding(node.id, node)
+        if not isinstance(binding, ast.Name) or binding in seen:
+            return None
+        statement = self.context.parents.get(binding)
+        if not isinstance(statement, ast.Assign | ast.AnnAssign):
+            return None
+        if (
+            (isinstance(statement, ast.Assign) and len(statement.targets) != 1)
+            or statement.value is None
+            or statement.lineno >= node.lineno
+            or not isinstance(
+                self.context.parents.get(statement), ast.Module | ast.ClassDef | ast.FunctionDef | ast.AsyncFunctionDef
+            )
+        ):
+            return None
+        return self._mode(statement.value, seen=seen | {binding})
+
+
+def _callback_argument(call: ast.Call, qualified: str | None) -> ast.expr | None:
+    if call.args:
+        return call.args[0]
+    parameter = "discriminator" if qualified in _DISCRIMINATORS else "func"
+    return next((keyword.value for keyword in call.keywords if keyword.arg == parameter), None)
+
+
+def _plain_method(node: ast.ClassDef, name: str) -> ast.FunctionDef | None:
+    method: ast.FunctionDef | None = None
+    for statement in node.body:
+        match statement:
+            case ast.FunctionDef(name=declared) if declared == name and method is None:
+                method = statement
+            case ast.Assign(value=value, targets=targets) if all(
+                isinstance(target, ast.Name) and target.id != name and _inert_attribute(target.id, value)
+                for target in targets
+            ):
+                continue
+            case ast.AnnAssign(target=ast.Name(id=attribute), value=value) if attribute != name and _inert_attribute(
+                attribute, value
+            ):
+                continue
+            case ast.Pass() | ast.Expr(value=ast.Constant(value=str())):
+                continue
+            case _:
+                return None
+    return method
+
+
+def _inert_attribute(name: str, value: ast.expr | None) -> bool:
+    if name == "__slots__":
+        return isinstance(value, ast.Tuple) and not value.elts
+    return (name == "__name__" or not (name.startswith("__") and name.endswith("__"))) and (
+        value is None or isinstance(value, ast.Constant)
+    )

{sarj_python_lint-1.55.0 → sarj_python_lint-1.57.0}/src/sarj_python_lint/rules/prefer_discriminated_model_union.py

@@ -107,7 +107,7 @@ class PreferDiscriminatedModelUnion(Rule):
         limitations=(
             "Declared module-level unions of at least two source-visible direct dataclasses, Pydantic BaseModels or TypedDicts require a shared disjoint Literal field. PEP 604, typing Union, Optional, Annotated, forward references and bounded local aliases are supported; a None branch is allowed.",
             "The explicit-tag policy is a modeling preference: nominal variants already support isinstance narrowing. Scalar/container unions, inline annotations, generic or inherited variants, behavior classes, unresolved variants and dynamic or ambiguous namespaces are excluded. Imported tag aliases are not resolved; an explicit literal field paired with an unresolved imported or local class domain abstains, as do opaque explicit Literal domains. Qualified imported domains and unsupported computed aliases remain uncertain rather than proving a missing tag.",
-            "String, bytes, integer, Boolean and None tag values are supported. Boolean and integer Literal values retain their distinct static types; use identity checks when equality would conflate their runtime values. A bounded hierarchy of shared literal fields may distinguish nested groups; overlapping tags without a further discriminator still warn. Nested Literal domains and transparent Final, ReadOnly, Annotated and local alias wrappers are supported. TypedDict tags must be required; dataclass ClassVar tags must have a value. Import-proven typing final decorators preserve record recognition. Explicit Pydantic callable Discriminators, bounded stable reusable metadata and imported pydantic.types constructors are respected; source-proven string field names, including local bindings and concatenation, still need Literal fields. Source-proven string discriminator writes through stable aliases invalidate callable coverage; opaque mutation, helper escapes and excessive alias graphs abstain. Module imports are independent of unrelated local parameters; class annotation shadows and global rebinding remain excluded. Other runtime configuration and default correctness remain separate contracts. No automatic field addition is safe for every constructor or serializer.",
+            "String, bytes, integer, Boolean and None tag values are supported. Boolean and integer Literal values retain their distinct static types; use identity checks when equality would conflate their runtime values. A bounded hierarchy of shared literal fields may distinguish nested groups; overlapping tags without a further discriminator still warn. Nested Literal domains and transparent Final, ReadOnly, Annotated and local alias wrappers are supported. TypedDict tags must be required; dataclass ClassVar tags must have a value. Direct import-proven InitVar annotations without defaults are constructor inputs rather than instance tags; quoted, wrapped, locally aliased or defaulted InitVar forms remain uncertain. Import-proven typing final decorators preserve record recognition. Explicit Pydantic callable Discriminators, bounded stable reusable metadata, single-value plain local class namespaces, literal immutable tuple projections and imported pydantic.types constructors are respected; source-proven string field names, including local bindings and concatenation, still need Literal fields. Source-proven string discriminator writes through stable aliases invalidate callable coverage; opaque mutation, helper escapes and excessive alias graphs abstain. Module bindings are independent of unrelated local parameters and their attribute writes; class annotation shadows and global rebinding remain excluded. Other runtime configuration and default correctness remain separate contracts. No automatic field addition is safe for every constructor or serializer.",
             "For nullable-field dependencies, only stable direct module-level import-proven Pydantic BaseModel subclasses with pure direct after model validators are inspected.",
             "Bounded paths may contain finite tag comparisons or literal-container membership, None identity tests, Boolean combinations, nested guards and returns of the same instance. Every rejection region must prove one tag-dependent nullable-field requirement; joint missing-field or independent-tag-axis conditions abstain.",
             "Tags must use imported Literal domains, optionally composed through direct unions, with at least two distinct homogeneous string, integer or Boolean values, optionally including an explicit None state. Mixed primitive families, bool/int equality collisions, open or computed tags abstain. Payloads must explicitly include None in a union, imported Union or Optional.",