python-constricter 0.4.1__cp312-cp312-win32.whl

constricter/fix/index/linked.py

@@ -0,0 +1,142 @@
+# SPDX-License-Identifier: MIT
+"""What the index says of checked modules together: one type's several spellings, and what's checked first.
+
+The ways a file spells one class or alias another module defines (`same`), the names it imports
+that are values where they're defined (`values`), the modules whose
+unannotated functions a module calls, checked before it (`needs`), those functions as the file
+spells them (`untyped`), and the index with what a checked module's functions return
+(`with_returned`).
+"""
+
+from collections.abc import Mapping
+from dataclasses import replace
+from pathlib import Path
+
+from constricter.fix.core.known import Guarded, Origin, Returns
+from constricter.fix.index import project
+from constricter.fix.index.modules import SUFFIX, Index, Module, module_name
+
+
+def same(catalog: Index, path: Path, guarded: Mapping[str, Guarded]) -> tuple[frozenset[str], ...]:
+    """Group the ways the file at `path` spells one class or alias another module defines.
+
+    `CoreSchema` and `core_schema.CoreSchema`, in a file importing the name and its module, the name
+    perhaps for type checking alone (its own import, or one `guarded` adds): one type, to value flow.
+
+    Returns:
+      Each group of two or more spellings.
+
+    """
+    target: Module | None
+    if path.suffix != SUFFIX or (target := catalog.modules.get(module_name(path))) is None:
+        return ()
+    # With what it imports for type checking alone: a module so imported spells its types too.
+    checking: dict[str, Origin] = {
+        **target.guarded,
+        **{name: found.origin for name, found in guarded.items()},
+    }
+    named: Module = replace(target, names={**checking, **target.names})
+    groups: dict[Origin, set[str]] = {}
+    kind: str
+    for kind in (project.CLASS, project.ALIAS):
+        name: str
+        origin: Origin
+        for name, origin in project.spellings(catalog, named, kind):
+            defined: tuple[Module, str] | None
+            if (defined := project.definition(catalog.modules, origin, kind)) is not None:
+                groups.setdefault((defined[0].name, defined[1]), set()).add(name)
+    return tuple(frozenset(group) for group in groups.values() if len(group) > 1)
+
+
+def values(catalog: Index, path: Path) -> frozenset[str]:
+    """Find the names the file at `path` imports that another checked module binds by assignment.
+
+    `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.
+
+    Returns:
+      Them, as the file binds them; none for a file `catalog` doesn't have.
+
+    """
+    target: Module | None
+    if path.suffix != SUFFIX or (target := catalog.modules.get(module_name(path))) is None:
+        return frozenset()
+    found: set[str] = set()
+    local: str
+    origin: Origin
+    for local, origin in target.names.items():
+        where: Origin = project.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:
+            found.add(local)
+    return frozenset(found)
+
+
+def with_returned(catalog: Index, found: Mapping[str, Returns]) -> Index:
+    """Record what checked modules' unannotated functions return (`found`, by module name).
+
+    A module's names from an earlier check are kept: once `--fix` has written an import it added,
+    a later check no longer exports the name, and the index doesn't have the new import.
+
+    Returns:
+      The index, with them.
+
+    """
+    modules: dict[str, Module] = dict(catalog.modules)
+    name: str
+    returns: Returns
+    for name, returns in found.items():
+        if name in modules:
+            names: dict[str, Origin] = {**modules[name].returned.names, **returns.names}
+            modules[name] = replace(modules[name], returned=returns._replace(names=names))
+    return catalog._replace(modules=modules)
+
+
+def needs(catalog: Index, module: Module) -> set[str]:
+    """Find the other modules whose unannotated functions `module` calls (see `_spelled`).
+
+    Returns:
+      Their names.
+
+    """
+    found: set[str] = set()
+    key: str
+    origin: Origin
+    for key, origin in project.spellings(catalog, module, project.UNANNOTATED):
+        defined: tuple[Module, str] | None
+        if (
+            key in module.called
+            and (defined := project.definition(catalog.modules, origin, project.UNANNOTATED)) is not None
+        ):
+            found.add(defined[0].name)
+    found.discard(module.name)
+    return found
+
+
+def untyped(catalog: Index, path: Path) -> frozenset[str]:
+    """Find the other checked files' functions the file at `path` calls that declare no return.
+
+    A plain `def` (see `returned.unannotated`), no `# type:` comment declaring its return, and no
+    fixture: what a type checker reading no body takes each call of for anything.
+
+    Returns:
+      Each, as the file spells its call (`helper`, `u.helper`); none for a file `catalog` doesn't have.
+
+    """
+    target: Module | None
+    if path.suffix != SUFFIX or (target := catalog.modules.get(module_name(path))) is None:
+        return frozenset()
+    found: set[str] = set()
+    key: str
+    origin: Origin
+    for key, origin in project.spellings(catalog, target, project.UNANNOTATED):
+        defined: tuple[Module, str] | None
+        if (
+            key in target.called
+            and (defined := project.definition(catalog.modules, origin, project.UNANNOTATED)) is not None
+            and not defined[0].installed
+            and defined[1] not in defined[0].returns
+            and defined[1] not in defined[0].fixtures
+        ):
+            found.add(key)
+    return frozenset(found)

constricter/fix/index/loose.py

@@ -0,0 +1,103 @@
+# SPDX-License-Identifier: MIT
+"""What another checked file's unannotated methods return, for the files calling them.
+
+A module's functions' `return`s type their calls in the files importing them (see
+`project.returned`); its classes' methods' type `self.method()` under a base of another file's, and
+a call on an instance of an imported class, the same way: as guesses, since a subclass may
+override one. A file is checked after the modules whose classes it names that have such a method
+it calls (`needs`).
+"""
+
+from collections.abc import Iterator
+from pathlib import Path
+
+from constricter.fix.core.known import Guarded, Returns
+from constricter.fix.core.signatures import AWAIT
+from constricter.fix.index import crossed, project
+from constricter.fix.index.modules import SUFFIX, Index, Module, module_name
+
+
+def _classes(catalog: Index, target: Module) -> Iterator[tuple[str, tuple[Module, str]]]:
+    """Find the classes `target` names whose module has a method it calls that only `return`s could type.
+
+    Yields:
+      Each, as it spells it, and the module defining it and its name there.
+
+    """
+    called: frozenset[str] = _called(target)  # once: a file may name thousands of classes
+    key: str
+    defined: tuple[Module, str]
+    for key, defined in crossed.spelled_classes(catalog, target, (target.names, target.attributes), set()):
+        if defined[0].name != target.name and not defined[0].loose.isdisjoint(called):
+            yield key, defined
+
+
+def _called(target: Module) -> frozenset[str]:
+    """Name the methods `target` calls on anything, and (after `AWAIT`) those it awaits a call of.
+
+    Returns:
+      Them, as `Module.loose` names a class's.
+
+    """
+    return target.method_calls | {name for name in target.attributes if name.startswith(AWAIT)}
+
+
+def needs(catalog: Index, module: Module) -> set[str]:
+    """Find the other modules whose classes' unannotated methods `module` may call.
+
+    Returns:
+      Their names.
+
+    """
+    return {defined[0].name for _, defined in _classes(catalog, module)}
+
+
+def returned(
+    catalog: Index,
+    path: Path,
+    guarded: dict[str, Guarded] | None = None,
+    functions: Returns | None = None,
+) -> Returns:
+    """Return, for the file at `path`, what `project.returned` does, and the methods it calls too.
+
+    Those of the classes it names, in modules already checked, by each class as it spells it; a
+    guessed one's origins as `C.m`. `functions`: `project.returned`'s, if it's worked out already.
+
+    Returns:
+      Them; `project.returned`'s alone for a file `catalog` doesn't have.
+
+    """
+    found: Returns = functions or project.returned(catalog, path, guarded)
+    target: Module | None
+    if (target := catalog.modules.get(module_name(path)) if path.suffix == SUFFIX else None) is None:
+        return found
+    methods: dict[str, dict[str, str]] = {}
+    guesses: dict[str, frozenset[str]] = dict(found.guesses)
+    called: frozenset[str] = _called(target)
+    key: str
+    defined: tuple[Module, str]
+    for key, defined in _classes(catalog, target):
+        wanted: dict[str, str] = {
+            name: each
+            for name, each in defined[0].returned.methods.get(defined[1], {}).items()
+            if name in called
+        }
+        kept: dict[str, str] = (
+            project.portable(
+                catalog.modules,
+                (target, defined),
+                key,
+                wanted,
+                {} if guarded is None else guarded,
+            )
+            if wanted
+            else {}
+        )
+        if kept:
+            methods[key] = kept
+        name: str
+        for name in kept:
+            rests: frozenset[str] | None
+            if (rests := defined[0].returned.guesses.get(f"{defined[1]}.{name}")) is not None:
+                guesses[f"{key}.{name}"] = rests
+    return found._replace(guesses=guesses, methods=methods) if methods else found

constricter/fix/index/managed.py

@@ -0,0 +1,63 @@
+# SPDX-License-Identifier: MIT
+"""Cross-module `--fix` for `with` on a call to another checked file's `@contextmanager` function.
+
+Found through the calling file's imports and the re-exports between them (`with temp_dir() as d`,
+`with helper.temp_dir() as d`); what it declares it yields types the target where the file can
+write it (see `project.portable`), or else what its `yield`s give, once its file is checked (see
+`constricter.fix.values.entered`).
+"""
+
+from pathlib import Path
+
+from constricter.fix.core.known import Guarded, Passed
+from constricter.fix.index import project, sides
+from constricter.fix.index.modules import SUFFIX, Index, Module, module_name
+from constricter.fix.values.entered import ENTERED
+
+
+def calls(catalog: Index, path: Path, guarded: dict[str, Guarded]) -> dict[str, Passed]:
+    """Type what `with` gives of the calls the file at `path` makes to other checked files' managers.
+
+    `guarded`: the names its imported types need imported for type checking (see `Guarded`), which
+    these types' are added to.
+
+    Returns:
+      Each call's name as written (`temp_dir`, `helper.temp_dir`), mapped to its type and what that
+      rests on if it's a guess; none for a file `catalog` doesn't have.
+
+    """
+    found: dict[str, Passed] = {}
+    target: Module | None
+    if (target := catalog.modules.get(module_name(path)) if path.suffix == SUFFIX else None) is None:
+        return found
+    spelled: str
+    defined: tuple[Module, str]
+    for spelled, defined in sides.called(catalog.modules, target, _manages):
+        key: str = f"{ENTERED}{defined[1]}"
+        yielded: str | None = defined[0].managers[defined[1]] or defined[0].returned.calls.get(key)
+        kept: dict[str, str] = (
+            {}
+            if yielded is None
+            else project.portable(catalog.modules, (target, defined), spelled, {spelled: yielded}, guarded)
+        )
+        if kept:
+            found[spelled] = (kept[spelled], defined[0].returned.guesses.get(key, frozenset()))
+    return found
+
+
+def needs(catalog: Index, module: Module) -> set[str]:
+    """Find the other modules whose managers `module` calls that only their `yield`s could type.
+
+    Returns:
+      Their names: checked before it, what they yield is known.
+
+    """
+    return {
+        defined[0].name
+        for _, defined in sides.called(catalog.modules, module, _manages)
+        if not defined[0].managers[defined[1]]
+    } - {module.name}
+
+
+def _manages(module: Module, name: str) -> bool:  # whether it defines a manager of the name
+    return name in module.managers