sarj-python-lint 1.28.3__tar.gz → 1.28.5__tar.gz

{sarj_python_lint-1.28.3 → sarj_python_lint-1.28.5}/PKG-INFO

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

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

{sarj_python_lint-1.28.3 → sarj_python_lint-1.28.5}/src/sarj_python_lint/_file_context.py

@@ -61,6 +61,12 @@ class PythonFileContext:
     def has_wildcard_import(self) -> bool:
         return any(alias.name == "*" for node in self.nodes(ast.ImportFrom) for alias in node.names)
 
+    @cached_property
+    def consumed_docstring_names(self) -> frozenset[str]:
+        from sarj_python_lint.rules._docstrings import consumed_docstring_names  # ruff: ignore[import-outside-top-level] -- share runtime docstring analysis only when requested.
+
+        return consumed_docstring_names(self._valid_tree(), node_index=self.node_index)
+
     @property
     def parents(self) -> Mapping[ast.AST, ast.AST]:
         return self.node_index.parents

{sarj_python_lint-1.28.3 → sarj_python_lint-1.28.5}/src/sarj_python_lint/rules/_docstrings.py

@@ -5,12 +5,17 @@ from itertools import starmap
 import re
 from typing import TYPE_CHECKING, NamedTuple
 
+from sarj_python_lint.rules._ast_index import walk as walk_ast
 from sarj_python_lint.rules._comments import split_identifier, stem
 
 
 if TYPE_CHECKING:
     from collections.abc import Iterable
 
+    from sarj_python_lint.rules._ast_index import NodeIndex
+
+
+_GETATTR_MIN_ARGS = 2
 
 # Docstring filler that says nothing about *which* thing is being described.
 _BASE_STOPWORDS = frozenset(
@@ -325,3 +330,88 @@ def restates(text: str, known: Iterable[str]) -> bool:
     if not content:
         return False
     return all(stem(word) in known_stems for word in content)
+
+
+def consumed_docstring_names(tree: ast.Module, *, node_index: NodeIndex | None = None) -> frozenset[str]:
+    consumed: set[str] = set()
+    aliases: dict[str, set[str]] = {}
+    for node in walk_ast(tree, index=node_index):
+        _record_docstring_use(node, consumed, aliases)
+    changed = True
+    while changed:
+        changed = False
+        for alias, originals in aliases.items():
+            if alias not in consumed:
+                continue
+            before = len(consumed)
+            consumed.update(originals)
+            changed |= len(consumed) != before
+    return frozenset(consumed)
+
+
+def _terminal_name(node: ast.expr) -> str | None:
+    match node:
+        case ast.Name():
+            return node.id
+        case ast.Attribute():
+            return node.attr
+        case _:
+            return None
+
+
+def _record_docstring_use(node: ast.AST, consumed: set[str], aliases: dict[str, set[str]]) -> None:
+    if isinstance(node, ast.Attribute) and node.attr == "__doc__":
+        if name := _terminal_name(node.value):
+            consumed.add(name)
+    elif isinstance(node, ast.Call) and _is_docstring_reader(node):
+        if name := _terminal_name(node.args[0]):
+            consumed.add(name)
+    elif isinstance(node, ast.Subscript):
+        if name := _subscripted_docstring_owner(node):
+            consumed.add(name)
+    else:
+        _record_docstring_alias(node, aliases)
+
+
+def _subscripted_docstring_owner(node: ast.Subscript) -> str | None:
+    if not isinstance(node.slice, ast.Constant) or node.slice.value != "__doc__":
+        return None
+    value = node.value
+    if isinstance(value, ast.Attribute) and value.attr == "__dict__":
+        return _terminal_name(value.value)
+    if isinstance(value, ast.Call) and isinstance(value.func, ast.Name) and value.func.id == "vars" and value.args:
+        return _terminal_name(value.args[0])
+    return None
+
+
+def _is_docstring_reader(node: ast.Call) -> bool:
+    if not node.args:
+        return False
+    function = node.func
+    if isinstance(function, ast.Name) and function.id == "help":
+        return True
+    if isinstance(function, ast.Attribute) and function.attr in {"getdoc", "render_doc"}:
+        return True
+    return (
+        isinstance(function, ast.Name)
+        and function.id == "getattr"
+        and len(node.args) >= _GETATTR_MIN_ARGS
+        and isinstance(node.args[1], ast.Constant)
+        and node.args[1].value == "__doc__"
+    )
+
+
+def _record_docstring_alias(node: ast.AST, aliases: dict[str, set[str]]) -> None:
+    if isinstance(node, ast.Assign) and isinstance(node.value, (ast.Name, ast.Attribute)):
+        original = _terminal_name(node.value)
+        for target in node.targets:
+            if isinstance(target, ast.Name) and original is not None:
+                aliases.setdefault(target.id, set()).add(original)
+    elif (
+        isinstance(node, ast.AnnAssign)
+        and isinstance(node.target, ast.Name)
+        and isinstance(node.value, (ast.Name, ast.Attribute))
+    ):
+        original = _terminal_name(node.value)
+        if original is not None:
+            aliases.setdefault(node.target.id, set()).add(original)

{sarj_python_lint-1.28.3 → sarj_python_lint-1.28.5}/src/sarj_python_lint/rules/defect_xfail_requires_explicit_strict.py

@@ -64,13 +64,16 @@ class DefectXfailRequiresExplicitStrict(Rule):
         ),
         remediation=(
             "Set literal `strict=True` so an unexpected pass fails. If only some parameter cases carry the defect, "
-            "move the marker to those `pytest.param(...)` cases before making it strict."
+            "move the marker to those `pytest.param(...)` cases before making it strict. When the defect's exception "
+            "type or group shape is independently known, native `raises=...`, where supported, can narrow unrelated failures; "
+            "same-type failures still need an origin oracle. Keep intentional broad expected-failure policies."
         ),
         category=RuleCategory.TESTING,
         aliases=("defect-xfail-requires-strict", "xfail-requires-strict"),
         limitations=(
             "Only markers resolved through an unambiguous pytest or pytest.mark import are analyzed.",
             "Only xfail reasons that explicitly identify a defect are analyzed.",
+            "Exception narrowing and defect identity remain manual review; strictness or a typed marker alone does not establish failure origin.",
             "Nondeterministic, recognized Hypothesis, network, environment-gated, run=False, and statically disabled pins are excluded.",
             "Repository-level strict_xfail / xfail_strict configuration is intentionally not consulted: defect pins remain locally explicit.",
             "Default pytest test_/Test collection names are recognized; repositories with custom collection patterns may need a local suppression.",

{sarj_python_lint-1.28.3 → sarj_python_lint-1.28.5}/src/sarj_python_lint/rules/prefer_fstring_over_concat.py

@@ -124,13 +124,16 @@ class PreferFstringOverConcat(Rule):
         summary="Prefer f-strings for short human-readable interpolation when they make the result clearer.",
         rationale="For prose-like strings, f-strings keep interpolated values and surrounding text visible together.",
         remediation=(
-            "Replace the interpolation with one f-string. Preserve an explicit `str(value)` conversion as `{value!s}` "
-            "and `repr(value)` as `{value!r}` when those conversion semantics matter."
+            "Use one f-string when it preserves the required conversion and operator semantics. Preserve an explicit "
+            "`str(value)` conversion as `{value!s}` "
+            "and `repr(value)` as `{value!r}` when those conversion semantics matter. Retain required custom "
+            "concatenation or formatting behavior; a `str` annotation alone does not prove equivalence."
         ),
         category=RuleCategory.STYLE,
         autofix=AutofixPolicy.NONE,
         limitations=(
             "Runtime operands must have concrete string evidence.",
+            "String evidence does not prove that custom concatenation operators and `__format__` agree; this remains manual review.",
             (
                 "Logging, common direct SQL and regular-expression forms, lazy strings, ORM expressions, generated files, long "
                 "literals, and punctuation-oriented fragment composition are excluded."

{sarj_python_lint-1.28.3 → sarj_python_lint-1.28.5}/src/sarj_python_lint/rules/prefer_injected_dependency_over_monkeypatch.py

@@ -55,7 +55,9 @@ class PreferInjectedDependencyOverMonkeypatch(Rule):
             "fake when rebuilding the fixture would add wiring without improving the boundary. Keep attribute-existence "
             "checks enabled and the tested implementation intact. Suppress SARJ445 only at that call, naming the "
             "owned instance and injection seam. For inherently global boundaries or lookup interception, explain why "
-            "injection would invalidate the test. Do not switch to bare assignment merely to avoid this rule."
+            "injection would invalidate the test. Establish the binding the exercised consumer actually reads, "
+            "including already-bound import aliases, and show that the oracle rejects a wrong consumer. "
+            "Do not switch to bare assignment merely to avoid this rule."
         ),
         category=RuleCategory.TESTING,
         autofix=AutofixPolicy.NONE,
@@ -65,7 +67,7 @@ class PreferInjectedDependencyOverMonkeypatch(Rule):
             "Environment, mapping, import-path, and working-directory mutations are intentionally allowed.",
             "Untyped handles are recognized only on pytest tests or fixtures; directly parametrized values are excluded.",
             "A nested function that captures a monkeypatch handle from an outer scope is not inferred.",
-            "Instance ownership and collaborator contracts are not inferred; justified scoped patches need a local suppression.",
+            "Instance ownership, collaborator contracts, and active consumer lookups are not inferred; justified scoped patches need a local suppression.",
         ),
         examples=(
             RuleExample(

{sarj_python_lint-1.28.3 → sarj_python_lint-1.28.5}/src/sarj_python_lint/rules/redundant_class_docstring.py

@@ -17,7 +17,6 @@ from sarj_python_lint.rule_base import (
     Severity,
     is_suppressed,
 )
-from sarj_python_lint.rules._ast_index import walk as walk_ast
 from sarj_python_lint.rules._comments import is_protected, stem
 from sarj_python_lint.rules._docstrings import (
     VALUE_MARKER_RE,
@@ -27,11 +26,9 @@ from sarj_python_lint.rules._docstrings import (
 
 if TYPE_CHECKING:
     from sarj_python_lint._file_context import PythonFileContext
-    from sarj_python_lint.rules._ast_index import NodeIndex
 
 
 _GRAMMATICAL_FILLER = frozenset({"a", "an", "class", "the"})
-_GETATTR_MIN_ARGS = 2
 _DOCSTRING_TOKEN_RE = re.compile(r"[^\W\d_]+(?:'[^\W\d_]+)?|\d+")
 
 
@@ -93,7 +90,7 @@ class RedundantClassDocstring(Rule):
         if tree is None:
             return []
         source_lines = context.source_lines
-        consumed_docstrings = _consumed_docstring_names(tree, node_index=context.node_index)
+        consumed_docstrings = context.consumed_docstring_names
         diags: list[Diagnostic] = []
         for node in context.nodes(ast.ClassDef):
             if node.name not in consumed_docstrings and self._is_ceremony(node):
@@ -128,88 +125,3 @@ class RedundantClassDocstring(Rule):
             if (word := match.group(0).lower()) not in _GRAMMATICAL_FILLER
         ]
         return bool(content) and all(stem(word) in known for word in content)
-
-
-def _consumed_docstring_names(tree: ast.Module, *, node_index: NodeIndex | None = None) -> set[str]:
-    consumed: set[str] = set()
-    aliases: dict[str, set[str]] = {}
-    for node in walk_ast(tree, index=node_index):
-        _record_docstring_use(node, consumed, aliases)
-    changed = True
-    while changed:
-        changed = False
-        for alias, originals in aliases.items():
-            if alias not in consumed:
-                continue
-            before = len(consumed)
-            consumed.update(originals)
-            changed |= len(consumed) != before
-    return consumed
-
-
-def _terminal_name(node: ast.expr) -> str | None:
-    match node:
-        case ast.Name():
-            return node.id
-        case ast.Attribute():
-            return node.attr
-        case _:
-            return None
-
-
-def _record_docstring_use(node: ast.AST, consumed: set[str], aliases: dict[str, set[str]]) -> None:
-    if isinstance(node, ast.Attribute) and node.attr == "__doc__":
-        if name := _terminal_name(node.value):
-            consumed.add(name)
-    elif isinstance(node, ast.Call) and _is_docstring_reader(node):
-        if name := _terminal_name(node.args[0]):
-            consumed.add(name)
-    elif isinstance(node, ast.Subscript):
-        if name := _subscripted_docstring_owner(node):
-            consumed.add(name)
-    else:
-        _record_docstring_alias(node, aliases)
-
-
-def _subscripted_docstring_owner(node: ast.Subscript) -> str | None:
-    if not isinstance(node.slice, ast.Constant) or node.slice.value != "__doc__":
-        return None
-    value = node.value
-    if isinstance(value, ast.Attribute) and value.attr == "__dict__":
-        return _terminal_name(value.value)
-    if isinstance(value, ast.Call) and isinstance(value.func, ast.Name) and value.func.id == "vars" and value.args:
-        return _terminal_name(value.args[0])
-    return None
-
-
-def _is_docstring_reader(node: ast.Call) -> bool:
-    if not node.args:
-        return False
-    function = node.func
-    if isinstance(function, ast.Name) and function.id == "help":
-        return True
-    if isinstance(function, ast.Attribute) and function.attr in {"getdoc", "render_doc"}:
-        return True
-    return (
-        isinstance(function, ast.Name)
-        and function.id == "getattr"
-        and len(node.args) >= _GETATTR_MIN_ARGS
-        and isinstance(node.args[1], ast.Constant)
-        and node.args[1].value == "__doc__"
-    )
-
-
-def _record_docstring_alias(node: ast.AST, aliases: dict[str, set[str]]) -> None:
-    if isinstance(node, ast.Assign) and isinstance(node.value, (ast.Name, ast.Attribute)):
-        original = _terminal_name(node.value)
-        for target in node.targets:
-            if isinstance(target, ast.Name) and original is not None:
-                aliases.setdefault(target.id, set()).add(original)
-    elif (
-        isinstance(node, ast.AnnAssign)
-        and isinstance(node.target, ast.Name)
-        and isinstance(node.value, (ast.Name, ast.Attribute))
-    ):
-        original = _terminal_name(node.value)
-        if original is not None:
-            aliases.setdefault(node.target.id, set()).add(original)

{sarj_python_lint-1.28.3 → sarj_python_lint-1.28.5}/src/sarj_python_lint/rules/redundant_docstring.py

@@ -18,7 +18,7 @@ from sarj_python_lint.rule_base import (
     Severity,
     is_suppressed,
 )
-from sarj_python_lint.rules._ast_index import children, walk as walk_ast
+from sarj_python_lint.rules._ast_index import children
 from sarj_python_lint.rules._comments import is_protected, split_identifier, stem
 from sarj_python_lint.rules._docstrings import (
     VALUE_MARKER_RE,
@@ -28,12 +28,10 @@ from sarj_python_lint.rules._docstrings import (
 
 if TYPE_CHECKING:
     from sarj_python_lint._file_context import PythonFileContext
-    from sarj_python_lint.rules._ast_index import NodeIndex
 
 
 _DOCSTRING_TOKEN_RE = re.compile(r"[^\W\d_]+(?:'[^\W\d_]+)?|\d+")
 _GRAMMATICAL_FILLER = frozenset({"a", "an", "function", "method", "the"})
-_GETATTR_MIN_ARGS = 2
 _MULTI_PARAMETER_MIN = 2
 
 
@@ -41,7 +39,7 @@ _MULTI_PARAMETER_MIN = 2
 class _ScanContext:
     path: Path
     source_lines: list[str]
-    consumed_docstrings: set[str]
+    consumed_docstrings: frozenset[str]
     diagnostics: list[Diagnostic]
 
 
@@ -105,7 +103,7 @@ class RedundantDocstring(Rule):
         if tree is None:
             return []
         source_lines = context.source_lines
-        consumed_docstrings = _consumed_docstring_names(tree, node_index=context.node_index)
+        consumed_docstrings = context.consumed_docstring_names
         diags: list[Diagnostic] = []
         analysis_context = _ScanContext(path, source_lines, consumed_docstrings, diags)
         self._walk(tree, analysis_context)
@@ -190,88 +188,3 @@ def _parameters_are_distinguished(groups: list[set[str]], content: set[str]) ->
         if not distinguishing or distinguishing.isdisjoint(content):
             return False
     return True
-
-
-def _consumed_docstring_names(tree: ast.Module, *, node_index: NodeIndex | None = None) -> set[str]:
-    consumed: set[str] = set()
-    aliases: dict[str, set[str]] = {}
-    for node in walk_ast(tree, index=node_index):
-        _record_docstring_use(node, consumed, aliases)
-    changed = True
-    while changed:
-        changed = False
-        for alias, originals in aliases.items():
-            if alias not in consumed:
-                continue
-            before = len(consumed)
-            consumed.update(originals)
-            changed |= len(consumed) != before
-    return consumed
-
-
-def _terminal_name(node: ast.expr) -> str | None:
-    match node:
-        case ast.Name():
-            return node.id
-        case ast.Attribute():
-            return node.attr
-        case _:
-            return None
-
-
-def _record_docstring_use(node: ast.AST, consumed: set[str], aliases: dict[str, set[str]]) -> None:
-    if isinstance(node, ast.Attribute) and node.attr == "__doc__":
-        if name := _terminal_name(node.value):
-            consumed.add(name)
-    elif isinstance(node, ast.Call) and _is_docstring_reader(node):
-        if name := _terminal_name(node.args[0]):
-            consumed.add(name)
-    elif isinstance(node, ast.Subscript):
-        if name := _subscripted_docstring_owner(node):
-            consumed.add(name)
-    else:
-        _record_docstring_alias(node, aliases)
-
-
-def _subscripted_docstring_owner(node: ast.Subscript) -> str | None:
-    if not isinstance(node.slice, ast.Constant) or node.slice.value != "__doc__":
-        return None
-    value = node.value
-    if isinstance(value, ast.Attribute) and value.attr == "__dict__":
-        return _terminal_name(value.value)
-    if isinstance(value, ast.Call) and isinstance(value.func, ast.Name) and value.func.id == "vars" and value.args:
-        return _terminal_name(value.args[0])
-    return None
-
-
-def _is_docstring_reader(node: ast.Call) -> bool:
-    if not node.args:
-        return False
-    function = node.func
-    if isinstance(function, ast.Name) and function.id == "help":
-        return True
-    if isinstance(function, ast.Attribute) and function.attr in {"getdoc", "render_doc"}:
-        return True
-    return (
-        isinstance(function, ast.Name)
-        and function.id == "getattr"
-        and len(node.args) >= _GETATTR_MIN_ARGS
-        and isinstance(node.args[1], ast.Constant)
-        and node.args[1].value == "__doc__"
-    )
-
-
-def _record_docstring_alias(node: ast.AST, aliases: dict[str, set[str]]) -> None:
-    if isinstance(node, ast.Assign) and isinstance(node.value, (ast.Name, ast.Attribute)):
-        original = _terminal_name(node.value)
-        for target in node.targets:
-            if isinstance(target, ast.Name) and original is not None:
-                aliases.setdefault(target.id, set()).add(original)
-    elif (
-        isinstance(node, ast.AnnAssign)
-        and isinstance(node.target, ast.Name)
-        and isinstance(node.value, (ast.Name, ast.Attribute))
-    ):
-        original = _terminal_name(node.value)
-        if original is not None:
-            aliases.setdefault(node.target.id, set()).add(original)

{sarj_python_lint-1.28.3 → sarj_python_lint-1.28.5}/src/sarj_python_lint/rules/require_precise_factory_signature.py

@@ -35,7 +35,7 @@ class RequirePreciseFactorySignature(ProjectRule):
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
         default_level=Severity.WARNING,
         summary="Keep fixed keyword factory calls behind a precise callable signature.",
-        rationale="Callable[..., T] erases argument checking, so misspelled keywords and incompatible injected factories pass strict typing and can fail at runtime.",
+        rationale="Callable[..., T] and functools.partial[T] erase argument checking at injected boundaries, so misspelled keywords and incompatible factories pass strict typing and can fail at runtime.",
         remediation=(
             "If factory substitution is unnecessary, call the existing constructor directly. Otherwise reuse an "
             "existing precise callable contract; use type[T] when the dependency requires a class, accounting "
@@ -46,7 +46,7 @@ class RequirePreciseFactorySignature(ProjectRule):
         category=RuleCategory.ARCHITECTURE,
         autofix=AutofixPolicy.NONE,
         limitations=(
-            "Only undecorated module-level functions with proven standard Callable[..., OwnedClass] parameters directly called with at least one named keyword are considered. Imported classes require scanned first-party declarations.",
+            "Only undecorated module-level functions with proven standard Callable[..., OwnedClass] or functools.partial[OwnedClass] parameters directly called with at least one named keyword are considered. Imported classes require scanned first-party declarations; direct partial construction and calls remain native type-checker ownership.",
             "Tests, test support, generated code, unresolved/string/generic annotations, positional-only calls, unpacking, forwarding, nested captures, rebinding and ambiguous imports are excluded. Import capture checks are conservative across the file, so an unrelated local pattern, exception or walrus binding can prevent a warning.",
             "A fixed call demonstrates signature erasure, not a current runtime defect. Genuine dynamic APIs can use a reasoned suppression. No autofix: the correct contract depends on whether classes or function factories are intended.",
         ),
@@ -65,6 +65,36 @@ class RequirePreciseFactorySignature(ProjectRule):
                 expected_count=1,
                 public=True,
             ),
+            RuleExample(
+                example_id="erased-partial-factory",
+                title="An injected partial retains its result type but loses argument checking",
+                outcome=ExampleOutcome.MATCH,
+                files=(
+                    ExampleFile.python(
+                        "app/service.py",
+                        "from functools import partial\nclass Result: pass\ndef build(factory: partial[Result]):\n    return factory(size=4)\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("app/service.py"),
+                expected_count=1,
+                scenario="partial-erasure",
+                public=True,
+            ),
+            RuleExample(
+                example_id="direct-partial-factory",
+                title="Direct partial construction keeps native argument checking",
+                outcome=ExampleOutcome.NO_MATCH,
+                files=(
+                    ExampleFile.python(
+                        "app/service.py",
+                        "from functools import partial\nclass Result:\n    def __init__(self, *, size: int):\n        self.size = size\ndef build():\n    factory = partial(Result)\n    return factory(size=4)\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("app/service.py"),
+                expected_count=0,
+                scenario="partial-erasure",
+                public=True,
+            ),
             RuleExample(
                 example_id="exact-factory",
                 title="Factory declares its keyword contract",
@@ -113,7 +143,7 @@ class RequirePreciseFactorySignature(ProjectRule):
                         col=argument.col_offset + 1,
                         code=self.code,
                         message=(
-                            f"`{argument.arg}` is called with fixed keywords but Callable[..., T] erases its "
+                            f"`{argument.arg}` is called with fixed keywords but its factory annotation erases its "
                             "argument contract; remove unnecessary factory indirection or reuse a precise callable "
                             "contract that preserves the accepted keywords."
                         ),
@@ -124,19 +154,20 @@ class RequirePreciseFactorySignature(ProjectRule):
 
 
 def _factory_result(annotation: ast.expr | None, context: PythonFileContext) -> ast.Name | ast.Attribute | None:
-    if (
-        not isinstance(annotation, ast.Subscript)
-        or context.module_imports.resolved_qualified_name(annotation.value) not in _CALLABLES
-    ):
+    if not isinstance(annotation, ast.Subscript):
         return None
-    if not isinstance(annotation.slice, ast.Tuple) or len(annotation.slice.elts) != _CALLABLE_ARITY:
+    carrier = context.module_imports.resolved_qualified_name(annotation.value)
+    if carrier in _CALLABLES:
+        if not isinstance(annotation.slice, ast.Tuple) or len(annotation.slice.elts) != _CALLABLE_ARITY:
+            return None
+        parameters, result = annotation.slice.elts
+        if not isinstance(parameters, ast.Constant) or parameters.value is not Ellipsis:
+            return None
+    elif carrier == "functools.partial":
+        result = annotation.slice
+    else:
         return None
-    parameters, result = annotation.slice.elts
-    if (
-        not isinstance(parameters, ast.Constant)
-        or parameters.value is not Ellipsis
-        or not isinstance(result, (ast.Name, ast.Attribute))
-    ):
+    if not isinstance(result, (ast.Name, ast.Attribute)):
         return None
     root = _root(annotation.value)
     if (root is not None and _captured_import_root(root, context)) or any(