sarj-python-lint 1.70.1__tar.gz → 1.72.0__tar.gz

{sarj_python_lint-1.70.1 → sarj_python_lint-1.72.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 1.70.1
+Version: 1.72.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.70.1 → sarj_python_lint-1.72.0}/pyproject.toml

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

{sarj_python_lint-1.70.1 → sarj_python_lint-1.72.0}/src/sarj_python_lint/__init__.py

@@ -1,3 +1,5 @@
+from sarj_python_lint._analysis_session import AnalysisSession as AnalysisSession
+from sarj_python_lint._fixes import apply_fixes as apply_fixes, python_source_hash as python_source_hash
 from sarj_python_lint._ratchet_cli import run_ratchet as run_ratchet
 from sarj_python_lint._source import python_source_encoding as python_source_encoding
 from sarj_python_lint._version import __version__ as __version__

{sarj_python_lint-1.70.1 → sarj_python_lint-1.72.0}/src/sarj_python_lint/_file_context.py

@@ -5,7 +5,7 @@ from functools import cached_property
 from typing import TYPE_CHECKING, final
 
 from sarj_python_lint._analysis_session import AnalysisSession
-from sarj_python_lint._source import symbol_prefilter_source
+from sarj_python_lint._source import python_source_lines, symbol_prefilter_source
 from sarj_python_lint.rules._annotation_semantics import AnnotationSemantics
 from sarj_python_lint.rules._ast_index import NodeIndex
 from sarj_python_lint.rules._fastapi import FastapiIndex
@@ -47,7 +47,7 @@ class PythonFileContext:
 
     @cached_property
     def source_lines(self) -> list[str]:
-        return self.source.splitlines()
+        return python_source_lines(self.source)
 
     @cached_property
     def generated(self) -> bool:

sarj_python_lint-1.72.0/src/sarj_python_lint/_fixes.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import ast
+from hashlib import sha256
+from typing import TYPE_CHECKING
+
+from sarj_python_lint.rule_base import AutofixPolicy
+
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from sarj_python_lint.rule_base import Fix
+
+
+def python_source_hash(source: str) -> str:
+    canonical = source.removeprefix("\ufeff").replace("\r\n", "\n").replace("\r", "\n")
+    return sha256(canonical.encode("utf-8")).hexdigest()
+
+
+def apply_fixes(source: str, fixes: Sequence[Fix]) -> str:
+    if not fixes:
+        return source
+    digest = python_source_hash(source)
+    prefix = "\ufeff" if source.startswith("\ufeff") else ""
+    raw = source[len(prefix) :].encode("utf-8")
+    lines = raw.splitlines(keepends=True)
+    offsets = [0]
+    for line in lines:
+        offsets.append(offsets[-1] + len(line))
+    if not lines or lines[-1].endswith((b"\n", b"\r")):
+        lines.append(b"")
+
+    def offset(line: int, col: int) -> int:
+        if line < 1 or line > len(lines) or col < 1 or col > len(lines[line - 1].rstrip(b"\r\n")) + 1:
+            msg = "fix position is outside the source"
+            raise ValueError(msg)
+        prefix = lines[line - 1][: col - 1]
+        prefix.decode("utf-8")
+        return offsets[line - 1] + len(prefix)
+
+    edits: list[tuple[int, int, bytes]] = []
+    for fix in fixes:
+        if fix.safety is not AutofixPolicy.SAFE or fix.source_hash != digest or not fix.edits:
+            msg = "fix must be safe, nonempty and match the complete source revision"
+            raise ValueError(msg)
+        for edit in fix.edits:
+            start = offset(edit.start_line, edit.start_col)
+            end = offset(edit.end_line, edit.end_col)
+            if end < start:
+                msg = "fix range runs backwards"
+                raise ValueError(msg)
+            edits.append((start, end, edit.replacement.encode("utf-8")))
+    edits.sort()
+    result: list[bytes] = []
+    previous = 0
+    for start, end, replacement in edits:
+        if start < previous:
+            msg = "fix groups overlap"
+            raise ValueError(msg)
+        result.extend((raw[previous:start], replacement))
+        previous = end
+    result.append(raw[previous:])
+    fixed = b"".join(result).decode("utf-8")
+    tree = ast.parse(fixed)
+    compile(tree, "<native-fix>", "exec")
+    return prefix + fixed

{sarj_python_lint-1.70.1 → sarj_python_lint-1.72.0}/src/sarj_python_lint/_source.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from io import BytesIO
+import re
 import tokenize
 from typing import TYPE_CHECKING
 import unicodedata
@@ -19,6 +20,11 @@ def read_python_source(path: Path) -> str:
         return stream.read()
 
 
+def python_source_lines(source: str) -> list[str]:
+    lines = re.split(r"\r\n?|\n", source)
+    return lines[:-1] if not lines[-1] else lines
+
+
 def symbol_prefilter_source(source: str) -> str:
     # Only necessary symbol gates may use this view; parse and locate original source.
     return source if source.isascii() else unicodedata.normalize("NFKC", source)

{sarj_python_lint-1.70.1 → sarj_python_lint-1.72.0}/src/sarj_python_lint/rule_base.py

@@ -75,6 +75,28 @@ class ColumnEncoding(StrEnum):
     CODEPOINTS = "codepoints"
 
 
+@dataclass(frozen=True, slots=True)
+class TextEdit:
+    """An exact, half-open range of one-based lines and UTF-8 byte columns.
+
+    Columns refer to decoded source without its original leading BOM.
+    """
+
+    start_line: int
+    start_col: int
+    end_line: int
+    end_col: int
+    replacement: str
+
+
+@dataclass(frozen=True, slots=True)
+class Fix:
+    title: str
+    safety: AutofixPolicy
+    source_hash: str
+    edits: tuple[TextEdit, ...]
+
+
 @dataclass(frozen=True, slots=True)
 class Diagnostic:
     path: Path
@@ -84,6 +106,7 @@ class Diagnostic:
     message: str
     severity: Severity = Severity.ERROR
     column_encoding: ColumnEncoding = ColumnEncoding.UTF8_BYTES
+    fixes: tuple[Fix, ...] = ()
 
     def format(self) -> str:
         label = "warning: " if self.severity is Severity.WARNING else ""

sarj_python_lint-1.72.0/src/sarj_python_lint/rules/_annotation_origins.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import ast
+from typing import TYPE_CHECKING
+
+from sarj_python_lint.rules._imports import ImportIndex
+
+
+if TYPE_CHECKING:
+    from sarj_python_lint._file_context import PythonFileContext
+
+
+class AnnotationOrigins:
+    def __init__(self, context: PythonFileContext) -> None:
+        self.context = context
+        self.provenance = context.static_resource_provenance
+        self.imports = {
+            node: ImportIndex.from_tree(ast.Module(body=[node], type_ignores=[]))
+            for node in context.nodes(ast.Import, ast.ImportFrom)
+        }
+
+    def shadowed(self, name: str, at: ast.AST) -> bool:
+        return type_parameter_shadow(name, at, self.context)
+
+    def qualified(self, node: ast.expr, at: ast.AST) -> str | None:
+        root = node
+        while isinstance(root, ast.Attribute):
+            root = root.value
+        if (
+            not isinstance(root, ast.Name)
+            or root.id in self.provenance.mutated | self.provenance.external_bindings
+            or type_parameter_shadow(root.id, at, self.context)
+        ):
+            return None
+        binding = self.provenance.binding(root.id, at)
+        parent = self.context.parents.get(binding) if binding is not None else None
+        index = self.imports.get(parent) if isinstance(parent, ast.Import | ast.ImportFrom) else None
+        return index.resolved_qualified_name(node) if index is not None else None
+
+    def builtin(self, node: ast.expr, name: str, at: ast.AST) -> bool:
+        return (
+            self.provenance.builtin_namespace_untouched
+            and isinstance(node, ast.Name)
+            and node.id == name
+            and not type_parameter_shadow(name, at, self.context)
+            and self.provenance.binding(name, at) is None
+        )
+
+
+def type_parameter_shadow(name: str, at: ast.AST, context: PythonFileContext) -> bool:
+    outside: set[ast.AST] = set()
+    current = at
+    while (parent := context.parents.get(current)) is not None:
+        if (
+            isinstance(parent, ast.arguments)
+            and (current in parent.defaults or current in parent.kw_defaults)
+            and (owner := context.parents.get(parent)) is not None
+        ):
+            outside.add(owner)
+        if (
+            isinstance(parent, ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef | ast.TypeAlias)
+            and parent not in outside
+            and not (
+                isinstance(parent, ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef)
+                and current in parent.decorator_list
+            )
+            and any(
+                isinstance(parameter, ast.TypeVar | ast.ParamSpec | ast.TypeVarTuple) and parameter.name == name
+                for parameter in parent.type_params
+            )
+        ):
+            return True
+        current = parent
+    return False

{sarj_python_lint-1.70.1 → sarj_python_lint-1.72.0}/src/sarj_python_lint/rules/_annotation_semantics.py

@@ -63,7 +63,7 @@ class AnnotationSemantics:
                 candidates[name] = value
         if not candidates:
             return cls(imports, MappingProxyType({}))
-        rebound = _module_rebindings(tree)
+        rebound = module_rebindings(tree)
         aliases = {name: value for name, value in candidates.items() if name not in ambiguous and name not in rebound}
         return cls(imports, MappingProxyType(aliases))
 
@@ -139,7 +139,7 @@ class AnnotationSemantics:
         return [node.slice]
 
 
-def _module_rebindings(tree: ast.Module) -> set[str]:
+def module_rebindings(tree: ast.Module) -> set[str]:
     counts: dict[str, int] = {}
     for statement in tree.body:
         for name in _bound_names(statement):

{sarj_python_lint-1.70.1 → sarj_python_lint-1.72.0}/src/sarj_python_lint/rules/_ast_index.py

@@ -15,7 +15,32 @@ if TYPE_CHECKING:
 _AST = ast.AST
 
 
-def object_list(value: object) -> TypeIs[list[object]]:
+def statement_blocks(statements: list[ast.stmt]) -> Iterator[list[ast.stmt]]:
+    pending = [statements]
+    while pending:
+        block = pending.pop()
+        yield block
+        for statement in reversed(block):
+            match statement:
+                case ast.For() | ast.AsyncFor() | ast.While() | ast.If():
+                    nested = [statement.body, statement.orelse]
+                case ast.With() | ast.AsyncWith():
+                    nested = [statement.body]
+                case ast.Try() | ast.TryStar():
+                    nested = [
+                        statement.body,
+                        *(handler.body for handler in statement.handlers),
+                        statement.orelse,
+                        statement.finalbody,
+                    ]
+                case ast.Match():
+                    nested = [case.body for case in statement.cases]
+                case _:
+                    continue
+            pending.extend(reversed(nested))
+
+
+def object_list(value: object) -> TypeIs[list[object]]:  # sarj-noqa: SARJ528 -- narrows opaque AST fields.
     return isinstance(value, list)
 
 

{sarj_python_lint-1.70.1 → sarj_python_lint-1.72.0}/src/sarj_python_lint/rules/_declared_contracts.py

@@ -28,27 +28,30 @@ class DeclaredClass:
 
 
 def _class_metadata_annotation(annotation: ast.expr, semantics: AnnotationSemantics) -> bool:
-    pending = [annotation]
     seen: set[str] = set()
-    while pending:
-        node = semantics.parse(pending.pop())
-        if node is None:
+    node = semantics.parse(annotation)
+    while node is not None:
+        if isinstance(node, ast.Name) and node.id in semantics.aliases and node.id not in seen:
+            seen.add(node.id)
+            node = semantics.parse(semantics.aliases[node.id])
+            continue
+        if not isinstance(node, ast.Subscript):
+            return False
+        wrapper = semantics.imports.resolved_symbol(node.value, sources=_TYPING_SOURCES)
+        if wrapper in {"ClassVar", "Final"}:
+            return True
+        if wrapper != "Annotated":
+            return False
+        if isinstance(node.slice, ast.Tuple) and not node.slice.elts:
             return True
-        for member in ast.walk(node):
-            if isinstance(member, ast.Subscript) and semantics.imports.resolved_symbol(
-                member.value, sources=_TYPING_SOURCES
-            ) in {"ClassVar", "Final"}:
-                return True
-            if isinstance(member, ast.Name) and member.id in semantics.aliases and member.id not in seen:
-                seen.add(member.id)
-                pending.append(semantics.aliases[member.id])
-    return False
+        node = semantics.parse(node.slice.elts[0] if isinstance(node.slice, ast.Tuple) else node.slice)
+    return True
 
 
 class DeclaredContracts:
     def __init__(self, context: PythonFileContext) -> None:
         self.context = context
-        self._field_cache: dict[ast.ClassDef, dict[str, ast.AnnAssign]] = {}
+        self._field_cache: dict[tuple[ast.ClassDef, bool], dict[str, ast.AnnAssign]] = {}
         self._module_annotations: dict[Path, AnnotationSemantics] = {}
         self.project = context.session.project or ProjectIndexSet.single(context.path, context.source)
         self.unit = self.project.unit(context.path)
@@ -130,23 +133,32 @@ class DeclaredContracts:
     def inherits(self, model: DeclaredClass, bases: frozenset[str]) -> bool:
         return self.project.class_inherits_from(model.unit, model.declaration.name, bases)
 
-    def model_fields(self, model: DeclaredClass) -> dict[str, ast.AnnAssign]:
+    def model_fields(
+        self, model: DeclaredClass, *, inherited: bool = False, seen: frozenset[ast.ClassDef] = frozenset()
+    ) -> dict[str, ast.AnnAssign]:
         if model.unit.tree is None:
             return {}
-        cached = self._field_cache.get(model.declaration)
+        key = (model.declaration, inherited)
+        cached = self._field_cache.get(key)
         if cached is not None:
             return cached
+        if model.declaration in seen or len(seen) >= _MAX_DEPTH:
+            return {}
         semantics = self._module_semantics(model.unit)
-        fields = {
-            node.target.id: node
-            for node in model.declaration.body
-            if isinstance(node, ast.AnnAssign)
-            and isinstance(node.target, ast.Name)
-            and not node.target.id.startswith("_")
-            and node.target.id != "model_config"
-            and not _class_metadata_annotation(node.annotation, semantics)
-        }
-        self._field_cache[model.declaration] = fields
+        fields: dict[str, ast.AnnAssign] = {}
+        if inherited and len(model.declaration.bases) == 1:
+            parent = self.class_type(model.declaration.bases[0], model.unit)
+            if parent is not None:
+                fields.update(self.model_fields(parent, inherited=True, seen=seen | {model.declaration}))
+        for node in model.declaration.body:
+            if not isinstance(node, ast.AnnAssign) or not isinstance(node.target, ast.Name):
+                continue
+            name = node.target.id
+            if name.startswith("_") or name == "model_config" or _class_metadata_annotation(node.annotation, semantics):
+                fields.pop(name, None)
+            else:
+                fields[name] = node
+        self._field_cache[key] = fields
         return fields
 
     def _module_semantics(self, unit: SourceUnit) -> AnnotationSemantics:

sarj_python_lint-1.72.0/src/sarj_python_lint/rules/_local_alias_fix.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import ast
+from functools import cached_property
+from typing import TYPE_CHECKING
+
+from sarj_python_lint._fixes import python_source_hash
+from sarj_python_lint._source import python_source_encoding
+from sarj_python_lint.rule_base import AutofixPolicy, Fix, TextEdit
+from sarj_python_lint.rules._suppression_comments import comment_lines
+
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+    from sarj_python_lint._file_context import PythonFileContext
+
+
+_NAMESPACE_MUTATORS = frozenset(
+    {
+        "setattr",
+        "delattr",
+        "setitem",
+        "delitem",
+        "__setattr__",
+        "__delattr__",
+        "__setitem__",
+        "__delitem__",
+        "__init__",
+        "__ior__",
+        "ior",
+        "methodcaller",
+        "patch",
+        "clear",
+        "pop",
+        "popitem",
+        "setdefault",
+        "update",
+    }
+)
+
+
+class LocalAliasFixes:
+    def __init__(self, context: PythonFileContext) -> None:
+        self.context = context
+
+    @cached_property
+    def _lines(self) -> tuple[bytes, ...]:
+        return tuple(line.encode("utf-8") for line in self.context.source_lines)
+
+    def spelling(self, node: ast.Name) -> str:
+        return self._lines[node.lineno - 1][node.col_offset : node.end_col_offset].decode("utf-8")
+
+    @cached_property
+    def _available(self) -> bool:
+        context = self.context
+        return (
+            python_source_encoding(context.source.encode("utf-8")) in {"utf-8", "utf-8-sig"}
+            and context.imports.builtin_is_unshadowed("dict")
+            and not any("dict" in bindings for bindings in context.resource_provenance.bindings.values())
+            and context.resource_provenance.builtin_namespace_untouched
+            and not any(node.attr == "__code__" for node in context.nodes(ast.Attribute))
+            and not _visible_namespace_mutation(context)
+        )
+
+    @cached_property
+    def _comments(self) -> Mapping[int, str]:
+        return comment_lines(tuple(self.context.source_lines))
+
+    @cached_property
+    def _digest(self) -> str:
+        return python_source_hash(self.context.source)
+
+    def for_alias(self, assignment: ast.Assign, use: ast.Name) -> tuple[Fix, ...]:
+        context = self.context
+        owner = context.parents.get(assignment)
+        if not isinstance(owner, ast.FunctionDef | ast.AsyncFunctionDef):
+            return ()
+        if not isinstance(context.parents.get(owner), ast.Module) or owner.decorator_list or owner.type_params:
+            return ()
+        args = owner.args
+        parameters = [*args.posonlyargs, *args.args, *args.kwonlyargs]
+        if len(parameters) != 1 or args.vararg or args.kwarg or args.defaults or any(args.kw_defaults):
+            return ()
+        source = assignment.value
+        if not isinstance(source, ast.Name) or parameters[0].arg != source.id:
+            return ()
+        body = owner.body[1:] if ast.get_docstring(owner) is not None else owner.body
+        if body[:1] != [assignment] or len(body[1:]) != 1 or not isinstance(body[-1], ast.Return):
+            return ()
+        call = body[-1].value
+        if not isinstance(call, ast.Call) or not isinstance(call.func, ast.Name) or call.func.id != "dict":
+            return ()
+        if call.args or len(call.keywords) != 1 or call.keywords[0].value is not use or not self._available:
+            return ()
+        edits = self._edits(assignment, use, source=source, owner=owner)
+        if not edits:
+            return ()
+        return (Fix("Pass the original local directly", AutofixPolicy.SAFE, self._digest, edits),)
+
+    def _edits(
+        self,
+        assignment: ast.Assign,
+        use: ast.Name,
+        *,
+        source: ast.Name,
+        owner: ast.FunctionDef | ast.AsyncFunctionDef,
+    ) -> tuple[TextEdit, ...]:
+        if any(line in self._comments for line in range(owner.lineno, (owner.end_lineno or owner.lineno) + 1)):
+            return ()
+        if assignment.end_lineno != assignment.lineno:
+            return ()
+        line = self.context.source_lines[assignment.lineno - 1]
+        raw = self._lines[assignment.lineno - 1]
+        if (
+            raw[: assignment.col_offset].strip()
+            or raw[assignment.end_col_offset :].strip()
+            or ";" in line
+            or "\\" in line
+        ):
+            return ()
+        return (
+            TextEdit(assignment.lineno, 1, assignment.lineno + 1, 1, ""),
+            TextEdit(
+                use.lineno,
+                use.col_offset + 1,
+                use.end_lineno or use.lineno,
+                (use.end_col_offset or 0) + 1,
+                self.spelling(source),
+            ),
+        )
+
+
+def _visible_namespace_mutation(context: PythonFileContext) -> bool:
+    if _imports_unittest(context):
+        return True
+    for node in context.nodes(ast.Name, ast.alias, ast.Attribute, ast.Subscript, ast.AugAssign):
+        match node:
+            case ast.Name(id=name) | ast.alias(name=name):
+                if name in _NAMESPACE_MUTATORS:
+                    return True
+            case ast.Attribute(attr=name, ctx=ctx):
+                if name in _NAMESPACE_MUTATORS or not isinstance(ctx, ast.Load):
+                    return True
+            case ast.Subscript(ctx=ctx):
+                if not isinstance(ctx, ast.Load):
+                    return True
+            case ast.AugAssign(op=op):
+                if isinstance(op, ast.BitOr):
+                    return True
+    return False
+
+
+def _imports_unittest(context: PythonFileContext) -> bool:
+    for node in context.nodes(ast.Import):
+        if any(alias.name.partition(".")[0] == "unittest" for alias in node.names):
+            return True
+    return any(
+        node.module is not None and node.module.partition(".")[0] == "unittest"
+        for node in context.nodes(ast.ImportFrom)
+    )

{sarj_python_lint-1.70.1 → sarj_python_lint-1.72.0}/src/sarj_python_lint/rules/_test_composition.py

@@ -5,6 +5,7 @@ from collections import Counter
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
+from sarj_python_lint.rules._declared_contracts import DeclaredClass
 from sarj_python_lint.rules._project_index import ProjectIndexSet, SourceUnit, SymbolRef
 
 
@@ -40,9 +41,7 @@ def direct_nodes(node: ast.AST) -> Iterator[ast.AST]:
             yield from direct_nodes(child)
 
 
-def _class_owner(
-    context: PythonFileContext, expression: ast.expr, project: ProjectIndexSet
-) -> tuple[SourceUnit, ast.ClassDef] | None:
+def _class_owner(context: PythonFileContext, expression: ast.expr, project: ProjectIndexSet) -> DeclaredClass | None:
     qualified = context.module_imports.resolved_qualified_name(expression)
     unit = project.unit(context.path)
     if qualified is not None:
@@ -62,7 +61,7 @@ def _class_owner(
         for node in direct_nodes(unit.tree)
     ):
         return None
-    return unit, owner
+    return DeclaredClass(unit, owner)
 
 
 def constructor(
@@ -75,7 +74,7 @@ def constructor(
     resolved = _class_owner(context, expression, project)
     if resolved is None:
         return None
-    unit, owner = resolved
+    unit, owner = resolved.unit, resolved.declaration
     if unit.module is None:
         return None
     initializer = next(
@@ -240,15 +239,9 @@ def wiring(
     spec: Constructor,
     scope: WiringScope,
 ) -> tuple[tuple[str, str], ...] | None:
-    if any(isinstance(arg, ast.Starred) for arg in call.args) or any(keyword.arg is None for keyword in call.keywords):
-        return None
-    if len(call.args) > len(spec.positional):
+    values = call_arguments(call, spec.positional)
+    if values is None:
         return None
-    values = dict(zip(spec.positional, call.args, strict=False))
-    for keyword in call.keywords:
-        if keyword.arg is None or keyword.arg in values:
-            return None
-        values[keyword.arg] = keyword.value
     result: list[tuple[str, str]] = []
     for name in sorted(spec.collaborators):
         value = values.get(name)
@@ -261,6 +254,19 @@ def wiring(
     return tuple(result)
 
 
+def call_arguments(call: ast.Call, positional: tuple[str, ...]) -> dict[str, ast.expr] | None:
+    if any(isinstance(arg, ast.Starred) for arg in call.args) or any(keyword.arg is None for keyword in call.keywords):
+        return None
+    if len(call.args) > len(positional):
+        return None
+    values = dict(zip(positional, call.args, strict=False))
+    for keyword in call.keywords:
+        if keyword.arg is None or keyword.arg in values:
+            return None
+        values[keyword.arg] = keyword.value
+    return values
+
+
 def _value_key(
     context: PythonFileContext,
     project: ProjectIndexSet,
@@ -300,4 +306,4 @@ def _value_key(
     ]
     if any(key is None for key in positional) or any(key is None for _, key in keywords):
         return None
-    return f"{owner[0].module}.{owner[1].name}:{positional!r}:{sorted(keywords)!r}"
+    return f"{owner.unit.module}.{owner.declaration.name}:{positional!r}:{sorted(keywords)!r}"