python-constricter 0.4.1__cp313-cp313-win32.whl

constricter/fix/index/crossed.py

@@ -0,0 +1,327 @@
+# SPDX-License-Identifier: MIT
+"""What crosses into a file from the other checked files it imports, for `--fix`.
+
+`imported` gives a file the return types of the functions it imports (see `project.calls`), and
+each imported class's attributes and methods' returns, its plain classes' variables, and which are
+generic, each keyed as the file spells the class (`spelled_classes`): only where every name in a
+type means the same in the file as where it was written (see `project.portable`).
+"""
+
+from collections.abc import Iterator, Mapping
+from pathlib import Path
+from typing import NamedTuple, TypeAlias
+
+from constricter.fix.core.known import Classes, Guarded, Origin, Partial, Returns
+from constricter.fix.index.modules import (
+    SUFFIX,
+    Index,
+    Memo,
+    Module,
+    classes_under,
+    exported,
+    module_name,
+)
+from constricter.fix.index.project import (
+    BUILTINS,
+    CLASS,
+    HOPS,
+    NO_TYPE,
+    PARTIAL,
+    Imported,
+    calls,
+    definition,
+    is_generic,
+    portable,
+    resolved,
+    returned,
+    typed_calls,
+)
+from constricter.rules.annotations import roots
+
+_Named: TypeAlias = tuple[Mapping[str, Origin], frozenset[str] | None]  # see `spelled_classes`
+
+
+def imported(
+    catalog: Index,
+    path: Path,
+    seeded: tuple[Mapping[str, Guarded], frozenset[str]] | None = None,
+) -> Imported:
+    """Return, for the file at `path`, what it imports from other checked files that it can name.
+
+    Each function's return type (`calls`), and each class's attributes and methods' returns, keyed as
+    the file spells the class (`Row`, `m.Row`); a type naming the class itself (a `Self` return) is
+    spelled that way too. `seeded`: the names its fixtures' types are written with, imported for type
+    checking alone (see `fixtures.visible`), whose classes' members it takes as well; and the
+    attributes those types take of a module it imports (`MonkeyPatch`, in `pytest.MonkeyPatch`).
+
+    Returns:
+      Them, and the names their types need imported for type checking alone (see `Guarded`); nothing
+      for a file `catalog` doesn't have (a notebook, standard input).
+
+    """
+    taken: _Taken = _Taken({}, {}, {}, {}, set())
+    guarded: dict[str, Guarded] = {} if seeded is None else dict(seeded[0])
+    target: Module | None
+    if path.suffix != SUFFIX or (target := catalog.modules.get(module_name(path))) is None:
+        return Imported({}, Classes(taken.attributes, taken.methods))
+    # Its own attributes as they are where the fixtures' add none: the index keeps what they find.
+    attributes: frozenset[str] = (
+        target.attributes
+        if seeded is None or seeded[1] <= target.attributes
+        else target.attributes | seeded[1]
+    )
+    checking: dict[str, Origin] = {
+        name: found.origin for name, found in guarded.items() if name not in target.names
+    }
+    named: _Named = ({**checking, **target.names}, attributes)
+    _take(catalog, target, (checking, attributes), taken, guarded)
+    _take(catalog, target, (target.names, attributes), taken, guarded)
+    found: tuple[dict[str, str], Returns, dict[str, str]] = (
+        calls(catalog, path, guarded),
+        returned(catalog, path, guarded),
+        {name: each for name, each, _ in typed_calls(catalog, path, PARTIAL, guarded)},
+    )
+    known: set[str] = set(named[0])
+    for _ in range(HOPS):  # a class those types need imported is a receiver's too, needing more in turn
+        fresh: dict[str, Origin] = {name: each.origin for name, each in guarded.items() if name not in known}
+        # Any class their packages re-export: the types naming them aren't written in the file yet.
+        _take(catalog, target, (fresh, None), taken, guarded)
+        known.update(fresh)
+    return Imported(
+        found[0],
+        Classes(taken.attributes, taken.methods),
+        found[1],
+        guarded,
+        frozenset(taken.generics),
+        taken.members,
+        Partial(found[2], {name: each for name, each in taken.partial.items() if each}),
+    )
+
+
+def guarded_classes(catalog: Index, path: Path, found: Imported, guarded: Mapping[str, Guarded]) -> Classes:
+    """Add the members of the classes `guarded` names that `found` hasn't taken, as the file names them.
+
+    Those of the imports later steps add for type checking (an overloaded method's return):
+    `df = pd.DataFrame(...).set_index("C")`, typed `DataFrame` by its import: `df.explode()` is one of
+    that class's methods in the same pass, not only once the import is written.
+
+    Returns:
+      `found`'s classes, with theirs.
+
+    """
+    target: Module | None
+    if path.suffix != SUFFIX or (target := catalog.modules.get(module_name(path))) is None:
+        return found.classes
+    fresh: dict[str, Origin] = {
+        name: each.origin
+        for name, each in guarded.items()
+        if name not in found.guarded and name not in target.names and name not in found.classes.methods
+    }
+    if not fresh:
+        return found.classes
+    taken: _Taken = _Taken(
+        {key: dict(each) for key, each in found.classes.attributes.items()},
+        {key: dict(each) for key, each in found.classes.methods.items()},
+        {},
+        {},
+        set(),
+    )
+    _take(catalog, target, (fresh, None), taken, dict(guarded))
+    return Classes(taken.attributes, taken.methods)
+
+
+class _Taken(NamedTuple):
+    """What `imported` takes of the classes a file names, each keyed as the file spells the class."""
+
+    attributes: dict[str, dict[str, str]]
+    methods: dict[str, dict[str, str]]
+    partial: dict[str, dict[str, str]]
+    members: dict[str, Mapping[str, str]]
+    generics: set[str]
+
+
+def _take(catalog: Index, target: Module, named: _Named, taken: _Taken, guarded: dict[str, Guarded]) -> None:
+    """Add to `taken` the members `target` uses of the classes `named` finds (see `spelled_classes`)."""
+    key: str
+    defined: tuple[Module, str]
+    for key, defined in spelled_classes(catalog, target, named, taken.generics):
+        if defined[1] in defined[0].generics:
+            taken.generics.add(key)
+        if defined[1] in defined[0].plain and defined[1] in defined[0].members:
+            taken.members[key] = _variables(catalog.modules, (target, defined), key, guarded)
+        if _declared_members(catalog, defined).isdisjoint(target.attributes):
+            # Most classes it can name: it takes none of their members, and asks whether it names one
+            # only by what it writes (`m.Row(...)` constructs one).
+            if _written(key, target.attributes):
+                taken.attributes[key], taken.methods[key], taken.partial[key] = {}, {}, {}
+            continue
+        taken.attributes[key], taken.methods[key], taken.partial[key] = (
+            _used(catalog.modules, (target, defined), key, table.get(defined[1]), guarded)
+            for table in (defined[0].classes, defined[0].methods, defined[0].partial_methods)
+        )
+
+
+def _written(spelled: str, attributes: frozenset[str]) -> bool:
+    """Check whether a file can write a class as `spelled`: each part after its first an attribute it takes.
+
+    Returns:
+      Whether it can.
+
+    """
+    return all(part in attributes for part in spelled.split(".")[1:])
+
+
+def _variables(
+    modules: Mapping[str, Module],
+    where: tuple[Module, tuple[Module, str]],
+    key: str,
+    guarded: dict[str, Guarded],
+) -> dict[str, str]:
+    """Write a plain class's variables' types as the file (`where[0]`) can (see `portable`).
+
+    Returns:
+      Each one's type: its own, made of builtins alone; one naming anything else, as the file
+      spells it, or `NO_TYPE` where it can't, which still holds a class under it to no other.
+
+    """
+    typed: Mapping[str, str] = where[1][0].members[where[1][1]]
+    named: dict[str, str] = {name: text for name, text in typed.items() if not roots(text) <= BUILTINS}
+    written: dict[str, str] = portable(modules, where, key, named, guarded) if named else {}
+    return {name: written.get(name, NO_TYPE) if name in named else text for name, text in typed.items()}
+
+
+def _declared_members(catalog: Index, defined: tuple[Module, str]) -> frozenset[str]:
+    """Name the members a class declares a type for, once for the index.
+
+    Returns:
+      Its attributes' and methods' names.
+
+    """
+    module: Module
+    name: str
+    module, name = defined
+    memo: Memo | None = catalog.memo
+    found: frozenset[str] | None
+    if (found := None if memo is None else memo.members.get((module.name, name))) is None:
+        found = frozenset[str]().union(
+            *(table.get(name, ()) for table in (module.classes, module.methods, module.partial_methods)),
+        )
+        if memo is not None:
+            memo.members[module.name, name] = found
+    return found
+
+
+def _used(
+    modules: Mapping[str, Module],
+    where: tuple[Module, tuple[Module, str]],
+    key: str,
+    members: Mapping[str, str] | None,
+    guarded: dict[str, Guarded],
+) -> dict[str, str]:
+    """Keep the types of a class's `members` that the file (`where[0]`) takes of something, and can write.
+
+    Returns:
+      Each kept member's type (see `portable`): none for most classes it can name, whose members it
+      doesn't use.
+
+    """
+    used: frozenset[str] = where[0].attributes
+    taken: dict[str, str] = {name: typed for name, typed in (members or {}).items() if name in used}
+    return portable(modules, where, key, taken, guarded) if taken else {}
+
+
+def spelled_classes(
+    catalog: Index,
+    target: Module,
+    named: _Named,
+    generics: set[str],
+) -> Iterator[tuple[str, tuple[Module, str]]]:
+    """Find the classes other checked files define that `target` names, each as it spells it.
+
+    `named`: the names it's to find them by, and the attributes it takes of anything (`None`: any).
+    `Row` after `from m import Row`; `m.Row`, or `pkg.m.Row` after `import pkg.m`, for a module's,
+    and `pkg.Row` for one `pkg` re-exports, where `Row` is such an attribute.
+    The generic classes a module it imports re-exports are added to `generics`, as it spells them.
+
+    Yields:
+      Each spelling, and the module defining the class and its name there.
+
+    """
+    memo: Memo | None = catalog.memo
+    if memo is None or named[0] is not target.names or named[1] is not target.attributes:
+        yield from _spelled_classes(catalog, target, named, generics)
+        return
+    kept: tuple[str, str]  # with its folder: several `conftest.py`s share the one name
+    if (kept := (target.name, target.folder)) not in memo.spelled:
+        added: set[str] = set()
+        memo.spelled[kept] = (
+            [
+                (key, defined[0].name, defined[1])
+                for key, defined in _spelled_classes(catalog, target, named, added)
+            ],
+            sorted(added),
+        )
+    generics.update(memo.spelled[kept][1])
+    key: str
+    module: str
+    name: str
+    for key, module, name in memo.spelled[kept][0]:
+        yield key, (catalog.modules[module], name)
+
+
+def _spelled_classes(
+    catalog: Index,
+    target: Module,
+    named: _Named,
+    generics: set[str],
+) -> Iterator[tuple[str, tuple[Module, str]]]:
+    """Find the classes `spelled_classes` yields, from the index itself.
+
+    Yields:
+      Each spelling, and the module defining the class and its name there.
+
+    """
+    local: str
+    origin: Origin
+    for local, origin in resolved(catalog, named[0]):
+        spelled: list[tuple[str, Origin]] = []
+        if origin[1] is not None and origin[0] != target.name:
+            spelled = [(local, origin)]
+            generics.update([local] * is_generic(catalog.modules, origin))
+        elif origin[1] is None:
+            package: Module | None = catalog.modules.get(origin[0])
+            spelled = [
+                *classes_under(catalog, local, origin[0], CLASS),
+                *(
+                    (f"{local}.{name}", where)
+                    for name, where in (() if package is None else exported(package).items())
+                    if (named[1] is None or name in named[1])
+                    and where[1] is not None
+                    and where[0] != origin[0]
+                ),
+            ]
+            generics.update(_reexported_generics(catalog.modules, local, origin[0]))
+        key: str
+        where: Origin
+        for key, where in spelled:
+            defined: tuple[Module, str] | None
+            if (defined := definition(catalog.modules, where, CLASS)) is not None:
+                yield key, defined
+
+
+def _reexported_generics(modules: Mapping[str, Module], local: str, name: str) -> Iterator[str]:
+    """Spell the generic classes module `name` re-exports (`from ._c import OrderedSet`) as `local.C`.
+
+    Only its own names, not its submodules': a package's `__init__` is where they're re-exported,
+    for type checking alone too, where it imports them only when they're asked for (pydantic's).
+
+    Yields:
+      Each spelling.
+
+    """
+    module: Module | None = modules.get(name)
+    reexported: str
+    origin: Origin
+    for reexported, origin in ({} if module is None else {**module.guarded, **module.names}).items():
+        if origin[1] is not None and origin[0] != name and is_generic(modules, origin):
+            yield f"{local}.{reexported}"

constricter/fix/index/decorated.py

@@ -0,0 +1,140 @@
+# SPDX-License-Identifier: MIT
+"""Returns under decorators another module defines: kept where it gives the function back.
+
+A module alone vouches for the standard library's such decorators and its own (see
+`constricter.rules.decorators`); with the index, for those it imports from a checked file or an
+installed package too (`@set_module("pandas")`, declared `-> Callable[[F], F]`), once the type
+variables their signatures name are found to be ones. A declared return is kept, and an unannotated
+function's `return`s may type its calls (`unannotated`), as an undecorated one's do.
+"""
+
+from collections.abc import Iterator, Mapping
+from dataclasses import replace
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from constricter.fix.index import project
+from constricter.fix.index.modules import SUFFIX, Index, Module, module_name
+from constricter.fix.index.project import DECORATOR
+
+if TYPE_CHECKING:
+    from constricter.fix.core.known import Origin
+    from constricter.rules.decorators import Pass
+
+
+def passed(catalog: Index) -> Index:
+    """Add to each module's functions' declared returns those under decorators the index vouches for.
+
+    Its classes' classmethods' and staticmethods' too; and its unannotated functions under such
+    decorators (`decorated`) join those a `return` could type (`unannotated`).
+
+    Returns:
+      The index, with them among each module's `returns`, `sides` and `unannotated`, and named in
+      its `vouched` and `vouched_sides`.
+
+    """
+    found: dict[str, Module] = {}
+    module: Module
+    for module in catalog.modules.values():
+        if not (module.held or module.held_sides or module.decorated):
+            continue
+        trusted: frozenset[str] = frozenset(_vouched(catalog, module))
+        more: dict[str, str] = {
+            name: held.returns for name, held in module.held.items() if trusted.issuperset(held.decorators)
+        }
+        sides: dict[tuple[str, str], str] = {
+            (owner, name): held.returns
+            for owner, methods in module.held_sides.items()
+            for name, held in methods.items()
+            if trusted.issuperset(held.decorators)
+        }
+        freed: frozenset[str] = frozenset(
+            name for name, spellings in module.decorated.items() if trusted.issuperset(spellings)
+        )
+        if more or sides or freed:
+            found[module.name] = replace(
+                module,
+                returns={**module.returns, **more},
+                vouched=frozenset(more),
+                sides=_with_sides(module.sides, sides),
+                vouched_sides=frozenset(sides),
+                unannotated=module.unannotated | freed,
+            )
+    return catalog._replace(modules={**catalog.modules, **found}) if found else catalog
+
+
+def vouched(catalog: Index, path: Path) -> frozenset[str]:
+    """Spell the decorators the file at `path` uses that give a function back, by the index.
+
+    Returns:
+      Each, as `decorators.spelled` reads its use; nothing for a file `catalog` doesn't have.
+
+    """
+    module: Module | None
+    if path.suffix != SUFFIX or (module := catalog.modules.get(module_name(path))) is None:
+        return frozenset()
+    return frozenset(_vouched(catalog, module))
+
+
+def _with_sides(
+    sides: Mapping[str, Mapping[str, str]],
+    more: Mapping[tuple[str, str], str],
+) -> dict[str, dict[str, str]]:
+    """Add methods' returns (`more`, by class and name) to classes' (`sides`).
+
+    Returns:
+      Each class's, with them.
+
+    """
+    found: dict[str, dict[str, str]] = {owner: dict(methods) for owner, methods in sides.items()}
+    owner: str
+    name: str
+    annotation: str
+    for (owner, name), annotation in more.items():
+        found.setdefault(owner, {})[name] = annotation
+    return found
+
+
+def _vouched(catalog: Index, module: Module) -> Iterator[str]:
+    """Spell the decorators `module` uses that give a function back, by the index: its own, and imported.
+
+    Yields:
+      Each, as `decorators.spelled` reads its use.
+
+    """
+    name: str
+    read: Pass
+    for name, read in module.passes.items():
+        if all(project.is_type_var(catalog.modules, module, word) for word in read.type_vars):
+            yield read.spelled(name)
+    key: str
+    origin: Origin
+    for key, origin in project.spellings(catalog, module, DECORATOR):
+        defined: tuple[Module, str] | None
+        if (defined := project.definition(catalog.modules, origin, DECORATOR)) is not None:
+            read = defined[0].passes[defined[1]]
+            if all(project.is_type_var(catalog.modules, defined[0], word) for word in read.type_vars):
+                yield read.spelled(key)
+
+
+def own(catalog: Index, path: Path) -> dict[str, str]:
+    """Return, for the file at `path`, its own functions' returns the index vouched for (see `passed`).
+
+    Its classes' classmethods' and staticmethods' too, as called on the class (`Box.make`), where
+    the class's name is the class throughout the file.
+
+    Returns:
+      Each one's name and declared return; nothing for a file `catalog` doesn't have.
+
+    """
+    module: Module | None
+    if path.suffix != SUFFIX or (module := catalog.modules.get(module_name(path))) is None:
+        return {}
+    return {
+        **{name: module.returns[name] for name in module.vouched},
+        **{
+            f"{owner}.{name}": module.sides[owner][name]
+            for owner, name in module.vouched_sides
+            if module.names.get(owner) == (module.name, owner) and owner not in module.shadowed
+        },
+    }

constricter/fix/index/fixtures.py

@@ -0,0 +1,176 @@
+# SPDX-License-Identifier: MIT
+"""Pytest fixtures' values, for the tests that take them as parameters.
+
+A test (or a fixture) names the fixtures it wants as its parameters, which no call passes: pytest
+finds each in the test's module, then in the `conftest.py` of each package above it, the nearest
+first. A fixture's value is what its function returns, or yields: its declared return, or the one
+its `return`s give (see `constricter.fix.values.returned`). A parameter so typed is a guess
+(`fixture`): a plugin's fixture, or one a `conftest.py` out of the checked files defines, may be
+the one pytest takes. A `conftest.py` in a directory that isn't a package is looked in next, by
+where it is: the test's directory's, or its top package's, then each one's above it. Pytest's own
+come last (`capsys`, `monkeypatch`, `caplog`), read from its installed modules where a checked file
+imports `pytest`.
+"""
+
+import ast
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Final
+
+from constricter.fix.core.known import Guarded, Passed
+from constricter.fix.index import project
+from constricter.fix.index.modules import CONFTEST, SUFFIX, Index, Module
+
+KIND: Final = "fixture"  # the guessing mechanism (`FIX_KINDS`)
+_DOT: Final = "."
+_PYTEST: Final = "_pytest"  # the package pytest defines its own fixtures in
+# pytest's own fixtures whose value is a standard-library class's instance, each with its class:
+# typed without the index, by an import the module has or one added (see `rules.calls`).
+STDLIB_OWN: Final = {"tmp_path": "pathlib.Path"}
+# What a generator fixture declares it returns: its value is the first argument.
+_YIELDING: Final = frozenset({"Iterator", "Generator", "Iterable", "AsyncIterator", "AsyncGenerator"})
+
+
+def providers(catalog: Index, name: str) -> list[Module]:
+    """Find the modules whose fixtures module `name`'s tests can take, the nearest first.
+
+    Returns:
+      It, then its packages' `conftest`s, those `catalog` has, then those outside any package (see
+      `_above`), then pytest's own modules.
+
+    """
+    parts: list[str] = name.split(_DOT)
+    names: list[str] = [
+        name,
+        *(_DOT.join([*parts[:depth], CONFTEST]) for depth in range(len(parts) - 1, 0, -1)),
+    ]
+    found: list[Module] = [catalog.modules[each] for each in dict.fromkeys(names) if each in catalog.modules]
+    target: Module | None = catalog.modules.get(name)
+    return [*found, *(each for each in _above(catalog, name) if each is not target), *_own(catalog)]
+
+
+def _above(catalog: Index, name: str) -> list[Module]:
+    """Find the `conftest.py`s outside any package that module `name`'s tests take fixtures from.
+
+    Returns:
+      Those in the directory of `name`'s file, or of its top package, and in each one above it, the
+      nearest first.
+
+    """
+    target: Module | None = catalog.modules.get(name)
+    folder: str = "" if target is None else target.folder
+    top: Path = Path(folder).joinpath(*[".."] * name.count(_DOT)).resolve()
+    folders: list[str] = [str(each) for each in (top, *top.parents)] if folder else []
+    flat: Module | None = catalog.modules.get(CONFTEST)
+    if flat is not None and CONFTEST not in catalog.repeated:  # the index's: it has what it returns
+        return [flat] if flat.folder in folders else []
+    return [catalog.conftests[each] for each in folders if each in catalog.conftests]
+
+
+def _own(catalog: Index) -> list[Module]:
+    """Find pytest's modules that define its own fixtures, among the installed ones `catalog` has.
+
+    Returns:
+      Them, by name.
+
+    """
+    return [
+        module
+        for name, module in sorted(catalog.modules.items())
+        if module.installed and module.fixtures and name.partition(_DOT)[0] == _PYTEST
+    ]
+
+
+def needed(catalog: Index, name: str) -> set[str]:
+    """Name the other modules whose fixtures module `name` can take: checked before it, their types are known.
+
+    Returns:
+      Them.
+
+    """
+    return {module.name for module in providers(catalog, name) if module.fixtures} - {name}
+
+
+def visible(catalog: Index, path: Path, guarded: dict[str, Guarded]) -> dict[str, Passed]:
+    """Type the fixtures the file at `path` can take, as it can write each type (see `project.spelled_in`).
+
+    `guarded` records the names those types need imported for type checking.
+
+    Returns:
+      Each typed fixture's value's type, and what it rests on, by its name; nothing for a file
+      `catalog` doesn't have.
+
+    """
+    target: Module | None
+    if path.suffix != SUFFIX or (target := catalog.modules.get(project.module_name(path))) is None:
+        return {}
+    if target.name in catalog.repeated:  # another file's module, maybe: its `conftest.py`s aren't this one's
+        return {}
+    found: dict[str, Passed | None] = {}
+    module: Module
+    for module in providers(catalog, target.name):
+        fixture: str
+        # A nearer one of the name is the one taken; pytest's of a standard-library class is `STDLIB_OWN`'s.
+        skipped: set[str] = found.keys() | (STDLIB_OWN.keys() if module.installed else set())
+        for fixture in module.fixtures.keys() - skipped:
+            found[fixture] = _typed(catalog, target, module, fixture, guarded)
+    return {fixture: typed for fixture, typed in found.items() if typed is not None}
+
+
+def attributes(seeds: Mapping[str, Passed]) -> frozenset[str]:
+    """Name the attributes fixtures' types are written with: `MonkeyPatch`, in `pytest.MonkeyPatch`.
+
+    Returns:
+      Them.
+
+    """
+    return frozenset(
+        node.attr
+        for typed, _ in seeds.values()
+        for node in ast.walk(ast.parse(typed, mode="eval"))
+        if isinstance(node, ast.Attribute)
+    )
+
+
+def _typed(
+    catalog: Index,
+    target: Module,
+    module: Module,
+    fixture: str,
+    guarded: dict[str, Guarded],
+) -> Passed | None:
+    """Type one of `module`'s fixtures' value, as `target` can write it.
+
+    Returns:
+      The type, and what it rests on; or `None`.
+
+    """
+    declared: str | None = module.held[fixture].returns if fixture in module.held else None
+    annotation: str | None = declared or module.returned.calls.get(fixture)
+    if annotation is not None and module.fixtures[fixture]:
+        annotation = _yielded(annotation)
+    written: str | None = (
+        None if annotation is None else project.spelled_in(catalog, target, module, annotation, guarded)
+    )
+    if written is None:
+        return None
+    rests: frozenset[str] = frozenset() if declared else module.returned.guesses.get(fixture, frozenset())
+    return written, frozenset({KIND}) | rests
+
+
+def _yielded(annotation: str) -> str | None:
+    """Read what a generator's declared type says it yields: `Frame` of an `Iterator[Frame]`.
+
+    Returns:
+      It, or `None` for anything else.
+
+    """
+    head: ast.expr
+    inner: ast.expr
+    match ast.parse(annotation, mode="eval").body:
+        case ast.Subscript(value=ast.Name() | ast.Attribute() as head, slice=inner) if (
+            ast.unparse(head).rpartition(_DOT)[2] in _YIELDING
+        ):
+            return ast.unparse(inner.elts[0] if isinstance(inner, ast.Tuple) else inner)
+        case _:
+            return None