sarj-python-lint 1.54.0__tar.gz → 1.56.0__tar.gz

{sarj_python_lint-1.54.0 → sarj_python_lint-1.56.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 1.54.0
+Version: 1.56.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.54.0 → sarj_python_lint-1.56.0}/pyproject.toml

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

{sarj_python_lint-1.54.0 → sarj_python_lint-1.56.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
@@ -80,13 +81,29 @@ class _DataUnions:
             if isinstance(node, ast.ClassDef)
             and len(bindings.get(node.name, ())) == 1
             and node.name not in self.provenance.mutated
+            and node.name not in self.provenance.external_bindings
         }
         self.aliases: dict[str, ast.expr] = {}
         self.declarations: dict[str, ast.stmt] = {}
+        self.values: dict[str, ast.expr] = {}
+        self.metadata_aliases = _metadata_alias_graph(tree, bindings)
+        self.metadata_mutation_cache: dict[str, bool | None] = {}
+        self.metadata_writes = _metadata_attribute_writes(context, tree, self.provenance)
         for node in tree.body:
-            value = _alias_value(node, context)
+            binding = _value_binding(node)
+            if binding is not None:
+                bound_name, bound_value = binding
+                if len(bindings.get(bound_name, ())) == 1:
+                    self.values[bound_name] = bound_value
+            value = _alias_value(node, context, self.provenance)
             name = _alias_name(node)
-            if value is not None and name is not None and len(bindings.get(name, ())) == 1:
+            if (
+                value is not None
+                and name is not None
+                and len(bindings.get(name, ())) == 1
+                and name not in self.provenance.external_bindings
+                and name not in self.provenance.mutated
+            ):
                 self.aliases[name] = value
                 self.declarations[name] = node
         self.records: dict[str, _Record | None] = {}
@@ -161,25 +178,199 @@ class _DataUnions:
         )
 
     def _discriminator_metadata(self, node: ast.expr) -> bool:
-        if not isinstance(node, ast.Call) or not _untouched(node.func, self.provenance):
+        seen: frozenset[str] = frozenset()
+        for _ in range(_MAX_EXPANSION):
+            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)
+            step = self._metadata_step(node)
+            if isinstance(step, bool):
+                return self._metadata_aliases_discriminate(seen, callable_metadata=step)
+            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
-        if self.context.module_imports.resolves(node.func, sources=_DISCRIMINATOR_SOURCES, symbol="Discriminator"):
-            discriminator = (
-                node.args[0]
-                if node.args
-                else next((keyword.value for keyword in node.keywords if keyword.arg == "discriminator"), None)
-            )
-            return discriminator is not None and not (
-                isinstance(discriminator, ast.Constant) and isinstance(discriminator.value, str)
-            )
-        return self.context.module_imports.resolves(node.func, sources=_FIELD_SOURCES, symbol="Field") and any(
-            keyword.arg == "discriminator" and self._discriminator_metadata(keyword.value) for keyword in node.keywords
+        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
+        discriminator = next((keyword.value for keyword in node.keywords if keyword.arg == "discriminator"), None)
+        if self._metadata_constructor(node.func, _DISCRIMINATOR_SOURCES, "Discriminator"):
+            argument = node.args[0] if node.args else discriminator
+            return argument is not None and not self._string_discriminator(argument)
+        if self._metadata_constructor(node.func, _FIELD_SOURCES, "Field") and discriminator is not None:
+            return discriminator
+        return False
+
+    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))
+
+    def _metadata_mutated(self, name: str) -> bool | None:
+        if name in self.metadata_mutation_cache:
+            return self.metadata_mutation_cache[name]
+        pending = [name]
+        seen: set[str] = set()
+        mutated = False
+        for _ in range(_MAX_EXPANSION):
+            if not pending:
+                self.metadata_mutation_cache.update(dict.fromkeys(seen, mutated))
+                return mutated
+            current = pending.pop()
+            if current in seen:
+                continue
+            seen.add(current)
+            if current in self.provenance.external_bindings or self._metadata_escaped(current):
+                return None
+            if current in self.provenance.mutated:
+                if not self._metadata_string_writes(current):
+                    return None
+                mutated = True
+            pending.extend(self.metadata_aliases.get(current, set()).difference(seen))
+        return None
+
+    def _metadata_string_writes(self, name: str) -> bool:
+        writes = self.metadata_writes.get(name, ())
+        return (
+            bool(writes)
+            and len(writes) <= _MAX_EXPANSION
+            and all(attribute == "discriminator" and self._string_discriminator(value) for attribute, value in writes)
         )
 
+    def _metadata_escaped(self, name: str) -> bool:
+        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)
+                if isinstance(node, ast.Call):
+                    return True
+                if node is None or isinstance(node, ast.stmt):
+                    break
+            else:
+                return True
+        return False
+
+    def _metadata_constructor(self, node: ast.expr, sources: frozenset[str], symbol: str) -> bool:
+        imports = self.context.module_imports
+        return imports.resolves(node, sources=sources, symbol=symbol) or (
+            isinstance(node, ast.Attribute)
+            and node.attr == symbol
+            and imports.resolved_qualified_name(node.value) in sources
+        )
+
+    def _string_discriminator(self, node: ast.expr) -> bool:
+        pending = [_Expansion(node)]
+        for _ in range(_MAX_EXPANSION):
+            if not pending:
+                return True
+            item = pending.pop()
+            node = item.node
+            if isinstance(node, ast.Constant) and isinstance(node.value, str):
+                continue
+            if (
+                isinstance(node, ast.Name)
+                and node.id in self.values
+                and node.id not in item.aliases
+                and node.id not in self.provenance.mutated
+                and node.id not in self.provenance.external_bindings
+            ):
+                pending.append(_Expansion(self.values[node.id], item.aliases | {node.id}))
+            elif isinstance(node, ast.BinOp) and isinstance(node.op, ast.Add):
+                pending.extend(_Expansion(child, item.aliases) for child in (node.left, node.right))
+            else:
+                return False
+        return False
+
     def _typing_symbol(self, node: ast.expr) -> str | None:
         if not _untouched(node, self.provenance):
             return None
-        return self.context.imports.resolved_symbol(node, sources=TYPING_SOURCES)
+        return self.context.module_imports.resolved_symbol(node, sources=TYPING_SOURCES)
 
     def _variants(self, expression: ast.expr) -> set[str] | None:
         leaves = self._leaves(expression)
@@ -251,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):
@@ -296,13 +489,17 @@ class _DataUnions:
             return _Domain(frozenset({_tag(None)}))
         if isinstance(node, ast.Name | ast.Attribute) and (
             (isinstance(node, ast.Name) and node.id in self.classes)
-            or self.context.imports.resolved_qualified_name(node) is not None
+            or (
+                _untouched(node, self.provenance)
+                and self.context.module_imports.resolved_qualified_name(node) is not None
+            )
         ):
             return _Domain(unresolved=True)
         if (
             isinstance(node, ast.Name)
             and node.id in _NON_LITERAL_BUILTINS
-            and self.context.imports.builtin_is_unshadowed(node.id)
+            and self.context.module_imports.builtin_is_unshadowed(node.id)
+            and _untouched(node, self.provenance)
         ):
             return _Domain()
         if not isinstance(node, ast.Subscript):
@@ -313,7 +510,8 @@ class _DataUnions:
         if symbol is not None or (
             isinstance(node.value, ast.Name)
             and node.value.id in {"list", "dict", "tuple", "set", "frozenset", "type"}
-            and self.context.imports.builtin_is_unshadowed(node.value.id)
+            and self.context.module_imports.builtin_is_unshadowed(node.value.id)
+            and _untouched(node.value, self.provenance)
         ):
             return _Domain()
         return _Domain(opaque=True)
@@ -363,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:
@@ -381,9 +599,37 @@ def _record(node: ast.ClassDef, context: PythonFileContext, provenance: Resource
             continue
         else:
             return None
+    field_names = frozenset(fields)
+    if any(_class_annotation_shadowed(field.annotation, field_names, context) for field in fields.values()):
+        return None
     return _Record(fields, required)
 
 
+def _class_annotation_shadowed(annotation: ast.expr, names: frozenset[str], context: PythonFileContext) -> bool:
+    pending = [(annotation, True)]
+    for _ in range(_MAX_EXPANSION):
+        if not pending:
+            return False
+        node, forward = pending.pop()
+        parsed = _string_expression(node) if forward else node
+        if parsed is None or (isinstance(parsed, ast.Name) and parsed.id in names):
+            return True
+        pending.extend(_class_annotation_children(parsed, forward=forward, context=context))
+    return True
+
+
+def _class_annotation_children(
+    node: ast.expr, *, forward: bool, context: PythonFileContext
+) -> list[tuple[ast.expr, bool]]:
+    if not isinstance(node, ast.Subscript):
+        return [(child, forward) for child in ast.iter_child_nodes(node) if isinstance(child, ast.expr)]
+    members = _subscript_members(node)
+    symbol = context.module_imports.resolved_symbol(node.value, sources=TYPING_SOURCES)
+    if symbol == "Annotated" and members:
+        return [(node.value, False), (members[0], True)]
+    return [(node.value, False), *((member, symbol != "Literal") for member in members)]
+
+
 def _record_required(node: ast.ClassDef, context: PythonFileContext, provenance: ResourceProvenance) -> bool | None:
     if node.type_params:
         return None
@@ -394,16 +640,16 @@ def _record_required(node: ast.ClassDef, context: PythonFileContext, provenance:
         for decorator in node.decorator_list
         if not (
             _untouched(decorator, provenance)
-            and context.imports.resolves(decorator, sources=TYPING_SOURCES, symbol="final")
+            and context.module_imports.resolves(decorator, sources=TYPING_SOURCES, symbol="final")
         )
     ]
     if decorators:
         return _direct_dataclass(node, context, provenance, decorators)
     if len(node.bases) != 1:
         return None
-    if context.imports.resolves(node.bases[0], sources=MODEL_SOURCES, symbol="BaseModel"):
+    if context.module_imports.resolves(node.bases[0], sources=MODEL_SOURCES, symbol="BaseModel"):
         return True if not node.keywords else None
-    if not context.imports.resolves(node.bases[0], sources=TYPING_SOURCES, symbol="TypedDict"):
+    if not context.module_imports.resolves(node.bases[0], sources=TYPING_SOURCES, symbol="TypedDict"):
         return None
     required = True
     for keyword in node.keywords:
@@ -422,7 +668,7 @@ def _direct_dataclass(
         return None
     decorator = decorators[0]
     target = decorator.func if isinstance(decorator, ast.Call) else decorator
-    if not _untouched(target, provenance) or not context.imports.resolves(
+    if not _untouched(target, provenance) or not context.module_imports.resolves(
         target, sources=_DATACLASS_SOURCES, symbol="dataclass"
     ):
         return None
@@ -479,12 +725,91 @@ def _alias_name(node: ast.stmt) -> str | None:
             return None
 
 
-def _alias_value(node: ast.stmt, context: PythonFileContext) -> ast.expr | 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:
+        binding = _value_binding(node)
+        if binding is None:
+            continue
+        name, value = binding
+        if len(bindings.get(name, ())) != 1 or not isinstance(value, ast.Name):
+            continue
+        graph.setdefault(name, set()).add(value.id)
+        graph.setdefault(value.id, set()).add(name)
+    return graph
+
+
+def _metadata_attribute_writes(
+    context: PythonFileContext, tree: ast.Module, provenance: ResourceProvenance
+) -> dict[str, list[tuple[str, ast.expr]]]:
+    writes: dict[str, list[tuple[str, ast.expr]]] = {}
+    for target in context.nodes(ast.Attribute):
+        if not isinstance(target.ctx, ast.Store) or not isinstance(target.value, ast.Name):
+            continue
+        binding = provenance.binding(target.value.id, target)
+        if binding is None or provenance.scope(binding) is not tree or provenance.scope(target) is not tree:
+            continue
+        parent = context.parents.get(target)
+        if isinstance(parent, ast.Assign | ast.AnnAssign) and parent.value is not None:
+            writes.setdefault(target.value.id, []).append((target.attr, parent.value))
+    return writes
+
+
+def _value_binding(node: ast.stmt) -> tuple[str, ast.expr] | None:
+    match node:
+        case (
+            ast.Assign(targets=[ast.Name(id=name)], value=value)
+            | ast.AnnAssign(target=ast.Name(id=name), value=ast.expr() as value)
+        ):
+            return name, value
+        case _:
+            return None
+
+
+def _alias_value(
+    node: ast.stmt, context: PythonFileContext, provenance: ResourceProvenance | None = None
+) -> ast.expr | None:
     match node:
         case ast.TypeAlias(type_params=[]):
             return node.value
         case ast.AnnAssign(target=ast.Name(), annotation=annotation, value=value):
-            return value if context.imports.resolves(annotation, sources=TYPING_SOURCES, symbol="TypeAlias") else None
+            return (
+                value
+                if context.module_imports.resolves(annotation, sources=TYPING_SOURCES, symbol="TypeAlias")
+                and (provenance is None or _untouched(annotation, provenance))
+                else None
+            )
         case ast.Assign(targets=[ast.Name()], value=value):
             return None if isinstance(value, ast.Constant) and isinstance(value.value, str) else value
         case _:
@@ -500,10 +825,93 @@ 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
-    return isinstance(node, ast.Name) and node.id not in provenance.mutated
+    if not isinstance(node, ast.Name) or node.id in provenance.mutated or node.id in provenance.external_bindings:
+        return False
+    binding = provenance.binding(node.id, node)
+    return binding is None or isinstance(binding, ast.alias)
 
 
 def _union_expression(node: ast.expr, context: PythonFileContext) -> bool:
@@ -516,7 +924,7 @@ def _union_expression(node: ast.expr, context: PythonFileContext) -> bool:
             return True
         if not isinstance(node, ast.Subscript):
             return False
-        symbol = context.imports.resolved_symbol(node.value, sources=TYPING_SOURCES)
+        symbol = context.module_imports.resolved_symbol(node.value, sources=TYPING_SOURCES)
         if symbol == "Union":
             return True
         if symbol == "Optional":

{sarj_python_lint-1.54.0 → sarj_python_lint-1.56.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. An explicit Pydantic callable Discriminator is respected; string field-name discriminators still need Literal fields. 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.",