python-constricter 0.4.4__py3-none-any.whl → 0.4.5__py3-none-any.whl

constricter/_version.py

@@ -1,3 +1,3 @@
 """The version this was built as, from its git tag (written by the build, not tracked)."""
 
-__version__ = "0.4.4"
+__version__ = "0.4.5"

constricter/cli/rounds.py

@@ -18,7 +18,7 @@ from constricter.cli.runs import CheckRun, FileRun, merged
 from constricter.cli.workers import Workers, running, started
 from constricter.empty import Empty
 from constricter.fix.core.known import Callee, Hints, Outside
-from constricter.fix.index import callers, decorated, loose, plain, project
+from constricter.fix.index import callers, crossed, decorated, loose, plain, project
 from constricter.fix.index.stubs import installed
 from constricter.offences import UNANNOTATED_ATTRIBUTE, UNANNOTATED_PARAMETER, Edit, Fix
 
@@ -67,10 +67,15 @@ def settled(
     again: list[int] = [
         index
         for index, run in enumerate(runs)
-        if fixing and paths[index] != STDIN and _unsettled(run, session, options.guesses)
+        if fixing
+        and paths[index] != STDIN
+        and (_unsettled(run, session, options.guesses) or _imports_read(modules, paths[index], run))
     ]
     changed: list[int] = [
-        at for at in range(len(runs)) if _reaching(paths[at], runs[at], onward=onward, signing=signing)
+        at
+        for at in range(len(runs))
+        if _reaching(paths[at], runs[at], onward=onward, signing=signing)
+        or (fixing and _imports_read(modules, paths[at], runs[at]))
     ]
     for _ in range(HINT_ROUNDS - 1):
         held: dict[int, FileRun] = {}
@@ -83,13 +88,37 @@ def settled(
         latest: project.Index
         fresh, latest = _round(paths, runs, (again, held), _How(check, options, session), modules)
         modules = latest if onward or signing else modules
-        again = [index for index, run in fresh if _unsettled(run, session, options.guesses)]
+        again = [
+            index
+            for index, run in fresh
+            if _unsettled(run, session, options.guesses) or _imports_read(modules, paths[index], run)
+        ]
         changed = [
-            index for index, run in fresh if _reaching(paths[index], run, onward=onward, signing=signing)
+            index
+            for index, run in fresh
+            if _reaching(paths[index], run, onward=onward, signing=signing)
+            or _imports_read(modules, paths[index], run)
         ]
     return runs
 
 
+def _imports_read(modules: project.Index, path: Path, run: FileRun) -> bool:
+    """Check whether a round of `--fix` imported a checked file's class whose members the file reads.
+
+    What's read of them had no type while the file didn't spell the class (`f: TextIO`, from the
+    standard-library tables, then `f.encoding`, on a corpus that checks `typing.py`).
+
+    Returns:
+      Whether it did.
+
+    """
+    return _changed(path, run) and any(
+        isinstance(made.offence.edit, Fix)
+        and crossed.reads_imported(modules, path, made.offence.edit.imports)
+        for made in cast("CheckRun", run).made
+    )
+
+
 def _reaching(path: Path, run: FileRun, *, onward: bool, signing: bool) -> bool:
     """Check whether a round of `--fix` changed a file in a way the other files may see.
 

constricter/fix/core/imports.py

@@ -2,6 +2,7 @@
 
 import ast
 import bisect
+import builtins
 import re
 import sys
 from collections.abc import Callable, Iterator, Mapping, Sequence
@@ -11,7 +12,7 @@ from weakref import WeakKeyDictionary
 
 from constricter.fix.core.known import Checking, Guarded, ImportPlan, Origin, Returns
 from constricter.source.annotations import dotted, roots
-from constricter.source.syntax import FunctionDef, Start, import_bindings
+from constricter.source.syntax import FunctionDef, Start, generic_named, import_bindings
 from constricter.source.walked import classes, of_type
 
 _TYPE_CHECKING: Final = "TYPE_CHECKING"
@@ -22,6 +23,8 @@ _FUTURE: Final = "__future__"
 _IMPORTORSKIP: Final = "pytest.importorskip"  # a module it names may be missing
 _MODNAME: Final = "modname"  # its parameter
 _DOT: Final = "."
+BUILTINS: Final = frozenset(dir(builtins))
+_NONE: Final[frozenset[str]] = frozenset()
 _ANNOTATIONS: Final = "annotations"  # `from __future__ import annotations` postpones them all
 # Each module's names, for as long as its tree lives: the index reads them, then the check.
 _Taken: TypeAlias = tuple[frozenset[str], frozenset[str]]
@@ -43,12 +46,14 @@ _BINDERS: Final = (
 )
 
 
-def plan(tree: ast.Module) -> ImportPlan:
+def plan(tree: ast.Module, imported_values: frozenset[str] = _NONE) -> ImportPlan:
     """Read what `tree` already imports, every name it binds, and where its imports end.
 
     Only imports that run count as binding a name to use (not those under `if TYPE_CHECKING:`: a
     module's own annotations are evaluated when it's imported); every name bound anywhere in the
-    file is taken, so an added import never shadows one (nor a builtin).
+    file is taken, so an added import never shadows one (nor a builtin). `imported_values`: the
+    names it imports that another module binds as a value (`linked.values`), which with its own
+    functions and assignments say which builtins it shadows.
 
     Returns:
       A fresh plan for the module's fixes.
@@ -64,6 +69,7 @@ def plan(tree: ast.Module) -> ImportPlan:
         taken,
         _after(tree),
         defined,
+        shadowed=_shadowed(tree) | (imported_values & BUILTINS),
         checking=Checking(
             _block(tree),
             _lazy(tree, bound),
@@ -76,6 +82,7 @@ def plan(tree: ast.Module) -> ImportPlan:
         ),
         postponed=_postponed(tree),
         values=values,
+        generic=generic_named(tree),
     )
 
 
@@ -149,6 +156,8 @@ def unwritable(annotation: str, planned: ImportPlan, nested: Mapping[str, str])
 def added_origin(statement: str) -> Origin:
     """Read what an import `ImportPlan.spell` added binds: `from m import T`, or `import m`.
 
+    `import m.sub` binds `m`, as one in the source does (`syntax.import_bindings`).
+
     Returns:
       Its origin: `("m", "T")`, or `("m", None)`.
 
@@ -156,7 +165,7 @@ def added_origin(statement: str) -> Origin:
     module: str
     name: str
     module, _, name = statement.removeprefix("from ").removeprefix("import ").partition(" import ")
-    return module, name or None
+    return (module, name) if name else (module.partition(_DOT)[0], None)
 
 
 def added_dotted(statement: str) -> str:
@@ -264,6 +273,25 @@ def _bound(tree: ast.Module) -> dict[str, str]:
     return {name: origin for name, origin, _ in import_bindings(_running(tree.body))}
 
 
+def _shadowed(tree: ast.Module) -> frozenset[str]:
+    """Name the builtins the module binds at its top level to a function or a value of its own.
+
+    `def str(val)` (`locale`'s), `str = str` (a Python 2 shim): a type written with the name would
+    name those, which a type checker refuses ("Variable not allowed in type expression"). A class
+    of the name (`enum`'s `property`) is a class, named as any is.
+
+    Returns:
+      Them.
+
+    """
+    found: set[str] = set()
+    stmt: ast.stmt
+    for stmt in _running(tree.body):
+        if isinstance(stmt, ast.FunctionDef | ast.AsyncFunctionDef | ast.Assign | ast.AnnAssign):
+            found.update(name for name in _names(stmt) if name in BUILTINS)
+    return frozenset(found)
+
+
 def _defined(tree: ast.Module) -> dict[str, int]:
     """Map each name the module binds at its top level (or under a top-level `if`/`try`) to its line.
 

constricter/fix/core/known.py

@@ -16,7 +16,7 @@ from constricter.fix.core.inherited import Beyond, Lineage
 from constricter.fix.core.signatures import Expansion, ReadSignature
 from constricter.offences import MAX_LENGTH, VAGUE
 from constricter.overrides import override
-from constricter.source.annotations import free_of, free_of_all, roots
+from constricter.source.annotations import GENERIC_HOMES, free_of, free_of_all, roots
 from constricter.source.declarations import GenericClass
 
 if TYPE_CHECKING:
@@ -40,6 +40,7 @@ Origin: TypeAlias = tuple[str, str | None]
 SPELLED: Final = "="
 # After a fixture's `request` parameter's name: the key its `request.param` is typed under (see `Typed`).
 PARAM: Final = ".param"
+OWN_SELF: Final = "self.own"  # in a scope's types: the class whose method reads `self`, unannotated or not
 
 
 # A `dict` itself, not a `UserDict`: every inference reads it, as fast as a `dict` is read.
@@ -164,7 +165,9 @@ class ImportPlan:  # pylint: disable=too-many-instance-attributes
     `bound`: each name its imports bind, and what that is (`io`, `io.BytesIO`); `taken`: every name
     bound anywhere in it; `after`: the line added imports go after; `defined`: each name it binds
     at its top level (an import, a class, a function, an assignment), and the line it's first bound
-    on; `added`: each name an added import binds, and that import's statement, as `spell` chose them.
+    on; `shadowed`: the builtins it binds at its top level to what a checker reads as no class (a
+    function, an assignment, an import of a value), so no type is written with them; `added`: each
+    name an added import binds, and that import's statement, as `spell` chose them.
     `guarded`: the names other checked files' types and a type checker's hints are written with
     that the module imports (or is to import) under `if TYPE_CHECKING:` alone; `checking`: its own
     such imports, where one goes, and whose types need one (see `Checking`); `postponed`: whether
@@ -175,30 +178,72 @@ class ImportPlan:  # pylint: disable=too-many-instance-attributes
     taken: frozenset[str]
     after: int
     defined: Mapping[str, int] = field(default_factory=dict[str, int])
+    shadowed: frozenset[str] = frozenset()
     added: dict[str, str] = field(default_factory=dict[str, str])
     guarded: Mapping[str, Guarded] = field(default_factory=dict[str, Guarded])
     checking: Checking = field(default_factory=Checking)
     postponed: bool = False
     values: frozenset[str] = frozenset()  # names it binds as values somewhere (see `imports.taken_names`)
+    generic: frozenset[str] = (
+        frozenset()
+    )  # its classes of a generic's name, generic too (`syntax.generic_named`)
     # Names it imports from another checked file that re-exports a type's factory there (`Outside`).
     factories: frozenset[str] = frozenset()
 
+    def own_names(self) -> frozenset[str]:
+        """Name what the module binds, or is to import, other than from where typing's generics come.
+
+        Its own `class Generator`, `from numpy.random import Generator`, `import numpy as np`: a
+        generic's name written bare (`Generator`) or through one (`np.random.Generator`) is then
+        that, not the generic missing its arguments (see `annotations.is_vague`).
+
+        Returns:
+          Them.
+
+        """
+        found: set[str] = {
+            name
+            for name in self.defined.keys() - self.generic
+            if name not in self.bound
+            or not {self.bound[name], self.bound[name].rpartition(_DOT)[0]} & GENERIC_HOMES
+        }
+        name: str
+        statement: str
+        for name, statement in self.added.items():
+            if statement.split()[1] not in GENERIC_HOMES:
+                found.add(name)
+        each: Guarded
+        for name, each in self.guarded.items():
+            if each.origin[0] not in GENERIC_HOMES:
+                found.add(name)
+        return frozenset(found)
+
     def type_checking(self) -> str | None:
         """Name `typing.TYPE_CHECKING` for a new block, by an import that runs: the module reads it.
 
+        The block goes after `after`, so through an import the module has only where it binds the
+        name by then: an `import typing` below a `try:` of other imports isn't, and a new import
+        goes with the block.
+
         Returns:
           The name, or `None` if every way to write it is taken.
 
         """
-        return self.spell("typing.TYPE_CHECKING", runs=True)
+        qualified: str = "typing.TYPE_CHECKING"
+        found: str | None = self.named(qualified)
+        if found is not None and self.defined.get(found.partition(_DOT)[0], self.after + 1) <= self.after:
+            return found
+        return self._added(qualified, runs=True)
 
     def spell(self, qualified: str, *, runs: bool = False) -> str | None:
         """Name `qualified` (`io.BufferedReader`) in this module, adding an import if it has to.
 
         Through an import it has (see `named`), for type checking alone too (`checking`, or one
-        `guarded` already), else a new `from io import BufferedReader`, else a new `import io`, but
-        only binding a name nothing in the module binds. Under `if TYPE_CHECKING:` for a module in
-        `checking.lazy`, and not at all for one only some platforms have. With `runs`, only through
+        `guarded` already), else a new `from io import BufferedReader`, else a new `import io`
+        (`import collections.abc`, binding `collections`, unless the module imports the name or
+        defines a class of it), but only binding a name nothing in the module binds. Under
+        `if TYPE_CHECKING:` for a module in `checking.lazy`, and not at all for one only some
+        platforms have. With `runs`, only through
         an import that runs: the name is read as the module is imported (`TYPE_CHECKING` itself).
 
         Returns:
@@ -208,6 +253,15 @@ class ImportPlan:  # pylint: disable=too-many-instance-attributes
         found: str | None
         if (found := self.named(qualified) or (None if runs else self._checked(qualified))) is not None:
             return found
+        return self._added(qualified, runs=runs)
+
+    def _added(self, qualified: str, *, runs: bool) -> str | None:
+        """Name `qualified` by an import to add, as `spell` does past the module's own.
+
+        Returns:
+          The name, or `None` if every way to write it is taken.
+
+        """
         module: str
         name: str
         module, _, name = qualified.rpartition(".")
@@ -220,9 +274,14 @@ class ImportPlan:  # pylint: disable=too-many-instance-attributes
         if self._free(name, statement):
             self.added[name] = statement
             return name
-        statement = f"import {module}"
-        if _DOT not in module and self._free(module, statement):
-            self.added[module] = statement
+        statement = f"import {module}"  # `import collections.abc` binds `collections`
+        # What the module imports or defines a class of the name as, anywhere (`from distutils.core
+        # import Distribution`, `_collections_abc`'s own `Iterator`), is the one meant, or the same:
+        # no new import beside it, past a module of one name.
+        if _DOT in module and name in self.taken and name not in self.values:
+            return None
+        if self._free(top, statement):
+            self.added[top] = statement
             return qualified
         return None
 
@@ -310,7 +369,8 @@ class LibraryNames(NamedTuple):
     every Python the module runs on parses an unpacked tuple in a subscript (`tuple[int, *Ts]`,
     3.11's syntax), so an annotation may be written with one. `aliased`: whether `typing` has
     `TypeAlias` on every Python the module runs on (3.10's; yes where that isn't known), so a new
-    import may name it.
+    import may name it. `written`: the installed and checked files' classes it names, none generic,
+    which a docstring's return may name (see `Lineages.written`).
     """
 
     casts: frozenset[str] = frozenset()
@@ -323,6 +383,7 @@ class LibraryNames(NamedTuple):
     aliases: Mapping[str, Expansion] = MappingProxyType({})
     starred: bool = False
     aliased: bool = True
+    written: frozenset[str] = frozenset()
 
 
 class Returned(NamedTuple):
@@ -579,9 +640,12 @@ class Outside:  # pylint: disable=too-many-instance-attributes
     classes: Classes | None = None
     hints: tuple[Hints, ...] = ()  # each checker's, in the order they were named
     type_vars: frozenset[str] = frozenset()
+    defaulted: frozenset[str] = frozenset()  # those of them with a default (see `project.defaulted`)
     returned: Returns = field(default_factory=Returns)
     guarded: Mapping[str, Guarded] = field(default_factory=dict[str, Guarded])
     generics: frozenset[str] = frozenset()  # other checked files' generic classes, as it spells them
+    # Those of theirs a type checker reads bare with their defaults (see `Module.defaulted_generics`).
+    defaulted_generics: frozenset[str] = frozenset()
     # Those classes' type parameters and the members it takes of them (see `GenericClass`).
     generic: Mapping[str, GenericClass] = field(default_factory=dict[str, GenericClass])
     # Their descriptors, as it spells them, each with what an instance's attribute of it gives.
@@ -610,6 +674,8 @@ class Outside:  # pylint: disable=too-many-instance-attributes
     installed_aliases: Mapping[str, Expansion] = field(
         default_factory=dict[str, Expansion],
     )
+    # See `LibraryNames.written`
+    written: frozenset[str] = frozenset()
     # The classes it imports under `if TYPE_CHECKING:` alone, which an annotation can name (see `offers.own`).
     checking: Mapping[str, Guarded] = field(default_factory=dict[str, Guarded])
     plain: frozenset[str] | None = None

constricter/fix/index/across.py

@@ -4,9 +4,11 @@ Each file is checked knowing what the files it imports declare and return, the h
 checker gave it, and what the index's other readers say of the names it imports (see `Outside`).
 """
 
+import re
 from collections.abc import Mapping
+from dataclasses import replace
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Final
 
 from constricter.fix.core.known import Guarded, Hints, Origin, Outside, Passed
 from constricter.fix.index import (
@@ -38,6 +40,10 @@ if TYPE_CHECKING:
     from constricter.fix.core.signatures import ReadSignature
 
 
+# A dotted name in a type (`trio.SocketListener`): a class spelled through a module.
+_DOTTED: Final = re.compile(r"\b[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)+")
+
+
 def outside(modules: project.Index, path: Path, hinted: Mapping[Path, tuple[Hints, ...]]) -> Outside:
     """Find what's known of a file from outside it: what it imports from the others, and its hints.
 
@@ -60,17 +66,17 @@ def outside(modules: project.Index, path: Path, hinted: Mapping[Path, tuple[Hint
     hints: tuple[Hints, ...] = offers.vetted(modules, path, hinted.get(path, ()))
     # What only a hint can name: the classes the file imports for type checking alone.
     own: offers.Own = offers.own(modules, path) if hints else offers.Own()
+    lineage: own_types.Lineages = own_types.lineages(modules, path, guarded, methods.lineage)
     overloaded: dict[str, tuple[ReadSignature, ...]] = {
         **stubbed.overloaded(modules, path, guarded),
         **methods.signatures,
         **own_methods.overloaded(modules, path, guarded),
     }
-    return Outside(
+    found: Outside = Outside(
         calls={**imported.calls, **side_calls, **decorated.own(modules, path)},
-        # With those of the classes the overloaded methods' returns import.
-        classes=crossed.guarded_classes(modules, path, imported, guarded),
         hints=hints,
         type_vars=project.type_vars(modules, path),
+        defaulted=project.defaulted(modules, path),
         returned=awaits.returned(
             modules,
             path,
@@ -79,6 +85,7 @@ def outside(modules: project.Index, path: Path, hinted: Mapping[Path, tuple[Hint
         ),
         guarded=guarded,
         generics=imported.generics | own.generics,
+        defaulted_generics=imported.defaulted_generics,
         generic=dict(imported.generic),
         descriptors=dict(imported.descriptors),
         callees=callers.callees(modules, path),
@@ -88,7 +95,8 @@ def outside(modules: project.Index, path: Path, hinted: Mapping[Path, tuple[Hint
         installed_classes=stubbed.classes(modules, path),
         read_members=crossed.member_names(modules, path),
         installed_parameters=methods.parameters,
-        installed_lineage=own_types.lineages(modules, path, guarded, methods.lineage),
+        installed_lineage=lineage,
+        written=lineage.written(),
         installed_aliases=methods.aliases,
         checking=own.guarded,
         plain=plain.classes(modules, path),
@@ -109,6 +117,26 @@ def outside(modules: project.Index, path: Path, hinted: Mapping[Path, tuple[Hint
         emptied=beyond.emptied(modules, path),
         factories=factories(modules, path),
     )
+    # With those of the classes the types above import for type checking (an overloaded method's
+    # return, an awaited call's, an item's): read last, as each of them adds to `guarded`.
+    return replace(found, classes=crossed.guarded_classes(modules, path, imported, guarded, _spelled(found)))
+
+
+def _spelled(found: Outside) -> frozenset[str]:
+    """Find the dotted names in the types found of a file from outside it: `trio.SocketListener`.
+
+    Returns:
+      Them.
+
+    """
+    types: list[str] = [
+        *found.calls.values(),
+        *found.awaits.values(),
+        *found.tuples.values(),
+        *found.unions.values(),
+        *found.returned.calls.values(),
+    ]
+    return frozenset(match.group() for each in types for match in _DOTTED.finditer(each))
 
 
 def factories(modules: project.Index, path: Path) -> frozenset[str]:

constricter/fix/index/crossed.py

@@ -7,13 +7,23 @@ only where every name in a type means the same in the file as where it was writt
 `spelling.portable`).
 """
 
-from collections.abc import Iterator, Mapping
+import ast
+from collections.abc import Iterable, Iterator, Mapping
 from pathlib import Path
 from typing import Final, NamedTuple, TypeAlias
 
 from constricter.fix.core.known import Classes, Guarded, Origin, Partial, Returns
 from constricter.fix.index.modules import Index, Memo, Module, classes_under, exported, module_at
-from constricter.fix.index.project import BUILTINS, CLASS, HOPS, NO_TYPE, PARTIAL, Imported, definition
+from constricter.fix.index.project import (
+    BUILTINS,
+    CLASS,
+    HOPS,
+    NO_TYPE,
+    PARTIAL,
+    Imported,
+    definition,
+    starred_names,
+)
 from constricter.fix.index.spelling import (
     calls,
     generic_portable,
@@ -62,7 +72,15 @@ def imported(
     checking: dict[str, Origin] = {
         name: found.origin for name, found in guarded.items() if name not in target.names
     }
+    # What it imports for type checking alone, `if TYPE_CHECKING:`: a parameter annotated with one is one.
+    own: dict[str, Origin] = {
+        name: origin
+        for name, origin in target.guarded.items()
+        if name not in target.names and name not in checking and origin[0] != target.name
+    }
     _take(catalog, target, (checking, attributes), taken, guarded)
+    if own:
+        _take(catalog, target, (own, attributes), taken, guarded)
     _take(catalog, target, (target.names, attributes), taken, guarded)
     found: tuple[dict[str, str], Returns, dict[str, str]] = (
         calls(catalog, path, guarded),
@@ -85,6 +103,7 @@ def imported(
         Partial(found[2], {name: each for name, each in taken.partial.items() if each}),
         taken.generic,
         taken.descriptors,
+        frozenset(taken.defaulted_generics),
     )
 
 
@@ -127,12 +146,21 @@ def _bound_members(module: Module, name: str, seen: set[str]) -> frozenset[str]:
     )
 
 
-def guarded_classes(catalog: Index, path: Path, found: Imported, guarded: Mapping[str, Guarded]) -> Classes:
+def guarded_classes(
+    catalog: Index,
+    path: Path,
+    found: Imported,
+    guarded: Mapping[str, Guarded],
+    spelled: frozenset[str],
+) -> 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.
+    that class's methods in the same pass, not only once the import is written. And those `spelled`
+    names through a module the file imports, as the types those steps give write them
+    (`trio.SocketListener`, which `trio` re-exports): the file reads no such attribute until a fix
+    writes the type, so `found` took none of them.
 
     Returns:
       `found`'s classes, with theirs.
@@ -146,13 +174,24 @@ def guarded_classes(catalog: Index, path: Path, found: Imported, guarded: Mappin
         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:
+    through: dict[str, Origin] = {}
+    attributes: set[str] = set()
+    each: str
+    for each in spelled:
+        root: str = each.partition(".")[0]
+        if each not in found.classes.methods and root in target.names:
+            through[root] = target.names[root]
+            attributes.add(each.rpartition(".")[2])
+    if not fresh and not through:
         return found.classes
     taken: _Taken = _taking(
         {key: dict(each) for key, each in found.classes.attributes.items()},
         {key: dict(each) for key, each in found.classes.methods.items()},
     )
-    _take(catalog, target, (fresh, None), taken, dict(guarded))
+    if fresh:
+        _take(catalog, target, (fresh, None), taken, dict(guarded))
+    if through:
+        _take(catalog, target, (through, frozenset(attributes)), taken, dict(guarded))
     return Classes(taken.attributes, taken.methods)
 
 
@@ -166,6 +205,7 @@ class _Taken(NamedTuple):
     generics: set[str]
     generic: dict[str, GenericClass]
     descriptors: dict[str, str | None]
+    defaulted_generics: set[str]
 
 
 def _taking(attributes: dict[str, dict[str, str]], methods: dict[str, dict[str, str]]) -> _Taken:
@@ -175,7 +215,7 @@ def _taking(attributes: dict[str, dict[str, str]], methods: dict[str, dict[str,
       It, nothing else taken yet.
 
     """
-    return _Taken(attributes, methods, {}, {}, set(), {}, {})
+    return _Taken(attributes, methods, {}, {}, set(), {}, {}, set())
 
 
 def _take(catalog: Index, target: Module, named: _Named, taken: _Taken, guarded: dict[str, Guarded]) -> None:
@@ -185,6 +225,8 @@ def _take(catalog: Index, target: Module, named: _Named, taken: _Taken, guarded:
     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].defaulted_generics:
+            taken.defaulted_generics.add(key)
         if defined[1] in defined[0].generic_members:
             klass: GenericClass = defined[0].generic_members[defined[1]]
             taken.generic[key] = generic_portable(catalog.modules, (target, defined), key, klass, guarded)
@@ -210,6 +252,35 @@ def _take(catalog: Index, target: Module, named: _Named, taken: _Taken, guarded:
         )
 
 
+def reads_imported(catalog: Index, path: Path, statements: Iterable[str]) -> bool:
+    """Check whether a file reads a member of a checked file's class that `statements` import into it.
+
+    It took none of the class's members while it didn't spell the class (see `_take`).
+
+    Returns:
+      Whether it does; not for a file `catalog` doesn't have.
+
+    """
+    target: Module | None
+    if (target := module_at(catalog, path)) is None:
+        return False
+    statement: str
+    for statement in statements:
+        node: ast.stmt = ast.parse(statement).body[0]
+        names: list[ast.alias] = node.names if isinstance(node, ast.ImportFrom) else []
+        module: str = node.module or "" if isinstance(node, ast.ImportFrom) else ""
+        alias: ast.alias
+        for alias in names:
+            defined: tuple[Module, str] | None = definition(catalog.modules, (module, alias.name), CLASS)
+            if (
+                defined is not None
+                and not defined[0].installed
+                and not _declared_members(catalog, defined).isdisjoint(target.attributes)
+            ):
+                return True
+    return False
+
+
 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.
 
@@ -343,7 +414,9 @@ def _spelled_classes(
                 *classes_under(catalog, local, origin[0], CLASS),
                 *(
                     (f"{local}.{name}", where)
-                    for name, where in (() if package is None else exported(package).items())
+                    for name, where in (
+                        () if package is None else _reexported(catalog.modules, package).items()
+                    )
                     if (named[1] is None or name in named[1])
                     and where[1] is not None
                     and where[0] != origin[0]
@@ -358,6 +431,16 @@ def _spelled_classes(
                 yield key, defined
 
 
+def _reexported(modules: Mapping[str, Module], module: Module) -> Mapping[str, Origin]:
+    """Name what a module imports from others, by name or everything (see `exported`, `starred_names`).
+
+    Returns:
+      Each, by its name there.
+
+    """
+    return {**starred_names(modules, module), **exported(module)} if module.stars else exported(module)
+
+
 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`.
 
@@ -371,6 +454,6 @@ def _reexported_generics(modules: Mapping[str, Module], local: str, name: str) -
     module: Module | None = modules.get(name)
     reexported: str
     origin: Origin
-    for reexported, origin in () if module is None else exported(module).items():
+    for reexported, origin in () if module is None else _reexported(modules, module).items():
         if origin[1] is not None and origin[0] != name and is_generic(modules, origin):
             yield f"{local}.{reexported}"

constricter/fix/index/linked.py

@@ -48,10 +48,13 @@ def same(catalog: Index, path: Path, guarded: Mapping[str, Guarded]) -> tuple[fr
 
 
 def values(catalog: Index, path: Path) -> frozenset[str]:
-    """Find the names the file at `path` imports that another checked module binds by assignment.
+    """Find the names the file at `path` imports that another module binds as a value, not a class.
 
-    `F`, by `F = duckdb.FunctionExpression` there: a value, whatever its name looks like, and a call
-    of it constructs nothing a type can be written for.
+    `F`, by `F = duckdb.FunctionExpression` in another checked module (its `assigned`): a value,
+    whatever its name looks like, and a call of it constructs nothing a type can be written for. And
+    `Observer`, by `Observer = _get_observer_cls()` in an installed module, or bound there in more than
+    one arm of an `if` (its `variables`): a variable to a checker, whatever it holds at run time.
+    Imported at the file's top level, or inside a function for its own use (`inner`).
 
     Returns:
       Them, as the file binds them; none for a file `catalog` doesn't have.
@@ -63,10 +66,12 @@ def values(catalog: Index, path: Path) -> frozenset[str]:
     found: set[str] = set()
     local: str
     origin: Origin
-    for local, origin in target.names.items():
+    for local, origin in {**target.inner, **target.names}.items():
         where: Origin = spelling.canonical_origin(catalog.modules, origin)
         defining: Module | None = catalog.modules.get(where[0])
-        if defining is not None and where[1] in defining.assigned and where[0] != target.name:
+        if defining is None or where[0] == target.name:
+            continue
+        if where[1] in (defining.variables if defining.installed else defining.assigned):
             found.add(local)
     return frozenset(found)