python-constricter 0.4.1__cp311-cp311-win32.whl

constricter/cli/lsp/connection.py

@@ -0,0 +1,475 @@
+# SPDX-License-Identifier: MIT
+"""A running language server, and the JSON-RPC conversation with it (`Connection`), for `hints`.
+
+The files it has open, the hint requests sent and not yet answered, and what it has said.
+"""
+
+import contextlib
+import itertools
+import json
+import os
+import queue
+import re
+import shutil
+import subprocess  # starts the type checker's language server
+import sys
+import threading
+import time
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass, field
+from functools import partial
+from pathlib import Path
+from typing import IO, Final, NamedTuple, TypeAlias, cast
+
+from constricter.cli.lsp import edits, guard, protocol
+from constricter.cli.lsp.protocol import HintError, HungError
+from constricter.fix.core.known import Offered
+
+_Json: TypeAlias = protocol.Json
+_Object: TypeAlias = protocol.Object
+# A file's hints, by where each name ends: its text, and what its edits would write (see `edits`).
+FileHints: TypeAlias = dict[tuple[int, int], tuple[str, Offered | None]]
+Found: TypeAlias = dict[Path, FileHints]  # each file's
+
+
+# Seconds without a word from a server before it's taken for hung. Not an answer's wait: pandas'
+# first answer took basedpyright 410s, but it reports its progress (`$/progress`) all the while.
+_TIMEOUT: Final = 120.0
+_POLL: Final = 1.0  # seconds between looks at how long it's been silent, while waiting
+
+
+# The guard's interpreter: the one a venv's is made from, if it's one. A Windows venv's `python.exe`
+# is a launcher that starts that one as a child, which then outlives a kill of the launcher.
+_GUARD_PYTHON: Final = str(getattr(sys, "_base_executable", "") or sys.executable)
+_SILENCE: Final[_Object] = {}  # no message yet, while waiting for one (compared by identity)
+_LINE_BREAK: Final = re.compile(r"\r\n|\r|\n")  # the lines positions count, as the protocol has them
+_UTF16: Final = "utf-16"
+_UTF8: Final = "utf-8"
+_METHOD_NOT_FOUND: Final = -32601
+# A request the server dropped because a document changed under it, as later files open (ty's
+# "content modified", pyrefly's "request cancelled"): the client is to ask again.
+_DROPPED: Final = frozenset({-32801, -32800})
+_ASK_AGAIN: Final = 5  # how many times a hint request is asked again after that, at most
+_HINTS: Final = "textDocument/inlayHint"
+_MODIFIED: Final[_Object] = {}  # a hint request's answer, when it's to be asked again (by identity)
+_ID: Final = "id"
+_METHOD: Final = "method"
+_ERROR: Final = "error"
+_CONFIGURATION: Final = "workspace/configuration"
+_UTF16_UNITS: Final = "utf-16-le"  # UTF-16's code units, two bytes each, without a byte-order mark
+
+
+@dataclass
+class _Inbox:
+    """What a server has said: its messages still to read, when it last said anything, and early answers.
+
+    An early answer came while another request's were awaited (see `Connection._wanted`).
+    """
+
+    messages: queue.Queue[_Object | None] = field(default_factory=queue.Queue[_Object | None])
+    heard: float = field(default_factory=time.monotonic)
+    early: dict[int, _Object] = field(default_factory=dict[int, _Object])
+
+
+@dataclass
+class _Documents:
+    """The files a server has open: each one's version and text, as the server has them, by URI."""
+
+    versions: dict[str, int] = field(default_factory=dict[str, int])
+    texts: dict[str, str] = field(default_factory=dict[str, str])
+
+
+class _Asked(NamedTuple):
+    """Hint requests sent, not yet answered: each request's file, and each file's lines."""
+
+    numbers: dict[int, Path]
+    lines: dict[Path, list[str]]
+
+
+Sent: TypeAlias = tuple[dict[Path, str], _Asked]  # a batch of files, and its hint requests
+
+
+class Connection:
+    """A running language server, and the JSON-RPC conversation with it."""
+
+    def __init__(self, argv: Sequence[str], root: Path) -> None:
+        """Start the server (`argv`) and initialize it, with `root` as its one workspace folder.
+
+        Raises:
+          HintError: It can't be started, or fails to initialize.
+
+        """
+        self.name: str = Path(argv[0]).name
+        if shutil.which(argv[0]) is None:
+            message: str = f"{self.name} couldn't be started: {argv[0]} isn't a program"
+            raise HintError(message)
+        # Closing it closes its pipes and waits for it, as leaving a `with` would.
+        self.stack: contextlib.ExitStack = contextlib.ExitStack()
+        # Through `guard`, which stops the server when constricter stops, however it does. Run by
+        # its path, not as a module: it needs only the standard library, and this Python needn't be
+        # able to import constricter from the server's working directory.
+        self.process: subprocess.Popen[bytes] = self.stack.enter_context(
+            subprocess.Popen(
+                [_GUARD_PYTHON, guard.__file__, str(guard.GRACE), *argv],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.DEVNULL,
+                cwd=root,
+            ),
+        )
+        self.inbox: _Inbox = _Inbox()
+        self.writing: threading.Lock = threading.Lock()  # the reader answers the server as it asks
+        self.last: int = 0
+        self.documents: _Documents = _Documents()
+        self.reader: threading.Thread = threading.Thread(
+            target=self._listen,
+            daemon=True,
+        )
+        self.reader.start()
+        self.encoding: str = _UTF16
+        try:
+            self._initialize(root)
+        except HintError:
+            self.close(graceful=False)
+            raise
+
+    def _initialize(self, root: Path) -> None:
+        """Initialize the server, with `root` as its workspace folder, and learn how it counts positions."""
+        uri: str = root.resolve().as_uri()
+        result: _Json = self.request(
+            "initialize",
+            {
+                "processId": os.getpid(),
+                "rootUri": uri,
+                "workspaceFolders": [{"uri": uri, "name": root.resolve().name}],
+                "capabilities": {
+                    "general": {"positionEncodings": [_UTF8, _UTF16]},
+                    "textDocument": {"inlayHint": {"dynamicRegistration": False}},
+                    "workspace": {"configuration": True, "workspaceFolders": True},
+                    # Its progress, as it works: a server busy for minutes isn't taken for hung.
+                    "window": {"workDoneProgress": True},
+                },
+            },
+        )
+        capabilities: _Object = cast("_Object", cast("_Object", result)["capabilities"])
+        self.encoding = str(capabilities.get("positionEncoding") or _UTF16)
+        self.notify("initialized", {})
+
+    def close(self, *, graceful: bool = True) -> None:
+        """Shut the server down (or, not `graceful`, stop it); stop it anyway if it won't shut down.
+
+        Stopping it ends its input: its guard kills it if it doesn't exit then, and exits itself.
+        """
+        if not (graceful and self._stopped()):
+            with self.writing, contextlib.suppress(OSError):  # it may have gone: then so has its input
+                cast("IO[bytes]", self.process.stdin).close()
+            try:
+                _ = self.process.wait(timeout=2 * guard.GRACE)
+            except subprocess.TimeoutExpired:  # the guard itself is stuck: the server goes with its input
+                self.process.kill()
+                _ = self.process.wait()
+        self.reader.join()  # its output has ended with it, and so has reading it
+        with contextlib.suppress(OSError):  # what's left to write can't be: it has gone
+            self.stack.close()
+
+    def _stopped(self) -> bool:
+        """Ask the server to shut down and exit, and wait for it to.
+
+        Returns:
+          Whether it did.
+
+        """
+        with contextlib.suppress(HintError):  # it's gone, or won't answer: waiting says which
+            _ = self.request("shutdown", None)
+            self.notify("exit", None)
+        try:
+            _ = self.process.wait(timeout=guard.GRACE)
+        except subprocess.TimeoutExpired:
+            return False
+        return True
+
+    def ask(self, files: Mapping[Path, str]) -> "_Asked":
+        """Open each file (or send its new text), and ask for its hints over the whole of it.
+
+        It doesn't wait for them. Each file is left open: basedpyright (1.40) fails the next file's
+        hints when that file imports one just closed, and the server is shut down after the last
+        file anyway.
+
+        Returns:
+          The requests, to collect their answers with `answers`.
+
+        """
+        lines: dict[Path, list[str]] = {path: _LINE_BREAK.split(text) for path, text in files.items()}
+        path: Path
+        text: str
+        for path, text in files.items():
+            self._opened(path.resolve().as_uri(), text)
+        return _Asked({self._ask_hints(path, lines[path]): path for path in files}, lines)
+
+    def _ask_hints(self, path: Path, lines: Sequence[str]) -> int:
+        """Ask for an open file's hints over the whole of it, without waiting for them.
+
+        Returns:
+          The request's number.
+
+        """
+        return self._ask(
+            _HINTS,
+            {
+                "textDocument": {"uri": path.resolve().as_uri()},
+                "range": {"start": {"line": 0, "character": 0}, "end": {"line": len(lines), "character": 0}},
+            },
+        )
+
+    def answers(self, asked: "_Asked") -> Found:
+        """Wait for the answers to hint requests `ask` sent, asking again for those the server dropped.
+
+        Returns:
+          Each file's variable-type hints' texts, by where the name each types ends.
+
+        Raises:
+          HintError: The server dropped one `_ASK_AGAIN` times more (see `_DROPPED`).
+
+        """
+        found: Found = {}
+        waiting: dict[int, Path] = asked.numbers
+        for _ in range(_ASK_AGAIN + 1):
+            answers: dict[int, _Json] = self._collect(set(waiting), _HINTS)
+            found.update(
+                (path, self._found(answers[number], asked.lines[path]))
+                for number, path in waiting.items()
+                if answers[number] is not _MODIFIED
+            )
+            waiting = {
+                self._ask_hints(path, asked.lines[path]): path
+                for number, path in waiting.items()
+                if answers[number] is _MODIFIED
+            }
+            if not waiting:
+                return found
+        error: str = f"{self.name} failed `{_HINTS}`: dropped {_ASK_AGAIN + 1} times"
+        raise HintError(error)
+
+    def _opened(self, uri: str, text: str) -> None:
+        """Send a file's text: opening it, or (open already) replacing its whole text, if it's changed."""
+        if self.documents.texts.get(uri) == text:
+            return
+        self.documents.texts[uri] = text
+        version: int
+        if (version := self.documents.versions.get(uri, 0) + 1) == 1:
+            self.notify(
+                "textDocument/didOpen",
+                {"textDocument": {"uri": uri, "languageId": "python", "version": version, "text": text}},
+            )
+        else:
+            self.notify(
+                "textDocument/didChange",
+                {"textDocument": {"uri": uri, "version": version}, "contentChanges": [{"text": text}]},
+            )
+        self.documents.versions[uri] = version
+
+    def _found(self, answer: _Json, lines: Sequence[str]) -> FileHints:
+        """Read one file's hints.
+
+        Returns:
+          Each variable-type hint's text and what its edits would write, by where the name it types ends.
+
+        """
+        found: FileHints = {}
+        existing: edits.FromImports = edits.FromImports(lines)
+        locate: Callable[[_Object], tuple[int, int] | None] = partial(self._where, lines=lines)
+        hint: _Json
+        for hint in cast("list[_Json]", answer or []):
+            where: tuple[int, int] | None
+            label: str | None
+            if (label := protocol.label(cast("_Object", hint))) is not None and (
+                where := locate(cast("_Object", cast("_Object", hint)["position"]))
+            ) is not None:
+                _ = found.setdefault(
+                    where,
+                    (label, edits.offered(cast("_Object", hint), label, locate, existing)),
+                )
+        return found
+
+    def _where(self, position: _Object, lines: Sequence[str]) -> tuple[int, int] | None:
+        """Turn a position into a line (from 1) and a UTF-8 byte column, as `ast` counts.
+
+        Returns:
+          It, or `None` for a position past the file's end.
+
+        """
+        line: int = int(cast("int", position["line"]))
+        character: int = int(cast("int", position["character"]))
+        if line >= len(lines):
+            return None
+        text: str = lines[line]
+        if self.encoding == _UTF8:
+            return line + 1, character
+        # The first `character` UTF-16 code units, two bytes each.
+        before: str = text.encode(_UTF16_UNITS)[: 2 * character].decode(_UTF16_UNITS, errors="ignore")
+        return line + 1, len(before.encode())
+
+    def request(self, method: str, params: _Json) -> _Json:
+        """Send a request and wait for its answer.
+
+        Returns:
+          Its result.
+
+        """
+        number: int = self._ask(method, params)
+        return self._collect({number}, method)[number]
+
+    def _ask(self, method: str, params: _Json) -> int:
+        """Send a request, without waiting for its answer.
+
+        Returns:
+          Its number, which its answer carries.
+
+        """
+        self.last += 1
+        self._send({"jsonrpc": "2.0", _ID: self.last, _METHOD: method, "params": params})
+        return self.last
+
+    def _collect(self, numbers: set[int], method: str) -> dict[int, _Json]:
+        """Wait for the answers to requests `numbers` (to `method`), in whatever order they come.
+
+        Raises `HintError` if the server exits, takes too long, or answers one with an error.
+
+        Returns:
+          Each request's result.
+
+        """
+        return dict(self._answer_to(numbers, method) for _ in numbers)
+
+    def _answer_to(self, numbers: set[int], method: str) -> tuple[int, _Json]:
+        """Wait for the next answer to one of requests `numbers`, passing over any other message.
+
+        Returns:
+          Its request's number, and its result.
+
+        Raises:
+          HintError: The server exited, took too long, or answered with an error.
+
+        """
+        early: set[int] = numbers & self.inbox.early.keys()
+        # `_next` raises rather than end: there is always a next message, or an error.
+        answer: _Object = (
+            self.inbox.early.pop(early.pop())
+            if early
+            else next(
+                message
+                for message in iter(partial(self._next, method), None)
+                if self._wanted(message, numbers)
+            )
+        )
+        if _ERROR in answer:
+            failure: _Object = cast("_Object", answer[_ERROR])
+            if method == _HINTS and failure.get("code") in _DROPPED:
+                return cast("int", answer[_ID]), _MODIFIED
+            error: str = f"{self.name} failed `{method}`: {failure.get('message')}"
+            raise HintError(error)
+        return cast("int", answer[_ID]), answer.get("result")
+
+    def _wanted(self, message: _Object, numbers: set[int]) -> bool:
+        """Check whether `message` answers one of requests `numbers`, keeping it if it answers another.
+
+        With a second batch asked before the first's answers are in, the second's can come first.
+
+        Returns:
+          Whether it answers one of `numbers`.
+
+        """
+        number: _Json = message.get(_ID)
+        if isinstance(number, int) and number not in numbers and number <= self.last:
+            self.inbox.early[number] = message
+        return number in numbers
+
+    def _next(self, method: str) -> _Object:
+        """Wait for the server's next message, while waiting for its answer to `method`.
+
+        Returns:
+          It.
+
+        Raises:
+          HintError: The server exited, or took too long.
+
+        """
+        # `_waited` raises rather than end: there is always a next message, or an error.
+        message: _Object | None = next(
+            waited for waited in (self._waited(method) for _ in itertools.count()) if waited is not _SILENCE
+        )
+        if message is None:
+            error: str = f"{self.name} exited while answering `{method}`"
+            raise HintError(error)
+        return message
+
+    def _waited(self, method: str) -> _Object | None:
+        """Wait a moment for the server's next message.
+
+        Returns:
+          It (`None` at the end of its output), or `_SILENCE` if none came yet.
+
+        Raises:
+          HungError: It has said nothing at all for `_TIMEOUT` seconds.
+
+        """
+        try:
+            return self.inbox.messages.get(timeout=_POLL)
+        except queue.Empty:
+            if time.monotonic() - self.inbox.heard >= _TIMEOUT:
+                error: str = f"{self.name} said nothing for {_TIMEOUT:.0f}s while answering `{method}`"
+                raise HungError(error) from None
+            return _SILENCE
+
+    def _listen(self) -> None:
+        """Read the server's messages until it closes its output (then queue `None`).
+
+        Its own requests are answered at once, here: a server may wait for the answer before it
+        reads anything more, while a batch of requests is still being written to it. The rest are
+        queued for the requests waiting on them.
+        """
+        stdout: IO[bytes] = cast("IO[bytes]", self.process.stdout)
+        message: _Object
+        for message in iter(partial(protocol.message, stdout), None):
+            self.inbox.heard = time.monotonic()  # a word, of any kind: it's working
+            if _METHOD in message and _ID in message:
+                with contextlib.suppress(HintError):  # it has gone: its output ends next
+                    self._answer(message)
+            else:
+                self.inbox.messages.put(message)
+        self.inbox.messages.put(None)
+
+    def _answer(self, message: _Object) -> None:
+        """Answer one of the server's own requests: its settings, and nothing else it asks for."""
+        method: str = str(message[_METHOD])
+        reply: _Object = {"jsonrpc": "2.0", _ID: message[_ID]}
+        if method == _CONFIGURATION:
+            items: list[_Json] = cast("list[_Json]", cast("_Object", message["params"])["items"])
+            reply["result"] = [protocol.settings(cast("_Object", item).get("section")) for item in items]
+        elif method in {"client/registerCapability", "window/workDoneProgress/create"}:
+            reply["result"] = None
+        else:
+            reply[_ERROR] = {"code": _METHOD_NOT_FOUND, "message": f"not supported: {method}"}
+        self._send(reply)
+
+    def notify(self, method: str, params: _Json) -> None:
+        """Send a notification: no answer comes."""
+        self._send({"jsonrpc": "2.0", "method": method, "params": params})
+
+    def _send(self, message: _Object) -> None:
+        """Frame and send one message.
+
+        Raises:
+          HintError: The server has exited.
+
+        """
+        body: bytes = json.dumps(message).encode()
+        with self.writing:  # one message at a time: the reader answers the server's own meanwhile
+            try:
+                protocol.write(
+                    cast("IO[bytes]", self.process.stdin),
+                    f"Content-Length: {len(body)}\r\n\r\n".encode() + body,
+                )
+            except (OSError, ValueError) as error:  # it has gone, or its input was closed to stop it
+                failure: str = f"{self.name} exited: {error}"
+                raise HintError(failure) from error

constricter/cli/lsp/edits.py

@@ -0,0 +1,188 @@
+# SPDX-License-Identifier: MIT
+"""`--infer-with`: what a hint's own edits would write (see `Offered`).
+
+An editor that accepts an inlay hint applies its `textEdits`: the annotation, spelled as the file can
+write it, and the imports its names take. An import comes as a statement to add
+(`from shapes import Shape`), or as names inserted into a `from` import the file has (`, Shape`).
+
+A hint with no edits (pyrefly's, for a loop's or an unpacking's names) may say where each class in
+its label is defined instead: the import is from the module that file is.
+"""
+
+import ast
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Final, TypeAlias, cast
+from urllib.parse import urlsplit
+from urllib.request import url2pathname
+
+from constricter.cli.lsp.protocol import Json, Object
+from constricter.fix.core.known import Offered
+from constricter.fix.index.modules import SUFFIX, module_name
+from constricter.rules import parsed
+
+_Where: TypeAlias = tuple[int, int]  # a line (from 1) and a UTF-8 byte column, as `ast` counts
+_Locate: TypeAlias = Callable[[Object], _Where | None]  # a position's, or `None` past the file's end
+_SITE: Final = "site-packages"
+_BUNDLED: Final = "pyrefly_bundled_typeshed"  # how the folders pyrefly unpacks its stubs into start
+_STUBS: Final = "-stubs"  # a stub package's folder, after the package's name
+_PACKAGE: Final = "__init__"
+_BUILTINS: Final = "builtins"
+
+
+@dataclass
+class FromImports:
+    """A file's `from` imports (`found`), read from its `lines` when one is first looked for."""
+
+    lines: Sequence[str]
+    found: list[ast.ImportFrom] | None = None
+
+    def at(self, where: _Where) -> ast.ImportFrom | None:
+        """Find the `from` import `where` is in.
+
+        Returns:
+          It, or `None` (always, for a file that doesn't parse).
+
+        """
+        if self.found is None:
+            self.found = _from_imports(self.lines)
+        return next(
+            (
+                node
+                for node in self.found
+                if (node.lineno, node.col_offset)
+                <= where
+                <= (node.end_lineno or node.lineno, node.end_col_offset or 0)
+            ),
+            None,
+        )
+
+
+def _from_imports(lines: Sequence[str]) -> list[ast.ImportFrom]:
+    """Read a file's `from` imports, wherever they are.
+
+    Returns:
+      Them; none for a file that doesn't parse.
+
+    """
+    try:
+        tree: ast.Module = parsed.parse("\n".join(lines))
+    except (SyntaxError, ValueError):  # a null byte is a `ValueError` before Python 3.12
+        return []
+    return [node for node in ast.walk(tree) if isinstance(node, ast.ImportFrom)]
+
+
+def offered(hint: Object, label: str, locate: _Locate, existing: FromImports) -> Offered | None:
+    """Read what a variable-type hint (showing `label`) would write: its annotation and its imports.
+
+    Returns:
+      Them; `None` for a hint whose edits say no more than its label, one with an edit that is
+      neither, or one with no edits whose label doesn't say where a class in it is defined.
+
+    """
+    edits: list[Json]
+    if not (edits := cast("list[Json]", hint.get("textEdits") or [])):
+        located: tuple[str, ...] = _located(hint.get("label"))
+        return Offered(label, located) if located else None
+    text: str = ""
+    imports: list[str] = []
+    edit: Json
+    for edit in edits:
+        new: str = str(cast("Object", edit).get("newText", ""))
+        start: Object = cast("Object", cast("Object", cast("Object", edit)["range"])["start"])
+        if start == hint["position"] and new.startswith(":"):
+            text = new[1:].strip()
+            continue
+        found: list[str] | None
+        if (found := _imports(new.strip(), start, locate, existing)) is None:
+            return None
+        imports += found
+    return Offered(text, tuple(imports)) if text and (imports or text != label) else None
+
+
+def _located(label: Json) -> tuple[str, ...]:
+    """Read the imports a label's parts take: each class a part names, from the module its file is.
+
+    Returns:
+      A statement for each class whose defining file's module can be named, once; not a builtin's.
+
+    """
+    found: dict[str, None] = {}
+    part: Json
+    for part in label if isinstance(label, list) else []:
+        name: str = str(cast("Object", part).get("value", ""))
+        location: Json = cast("Object", part).get("location")
+        if location is None or not name.isidentifier():
+            continue
+        uri: str = str(cast("Object", location)["uri"])
+        module: str | None = _defined_in(Path(url2pathname(urlsplit(uri).path)))
+        if module and module != _BUILTINS:
+            found[f"from {module} import {name}"] = None
+    return tuple(found)
+
+
+def _defined_in(path: Path) -> str | None:
+    """Name the module a file is: an installed one, one of pyrefly's own stubs, or a project's.
+
+    Returns:
+      It, by the folders after `site-packages` or pyrefly's stubs' folder, else by its package
+      folders as the project index names it; `None` for a stub anywhere else, or no file at all.
+
+    """
+    if not path.name:  # a location that isn't a file's (`untitled:`)
+        return None
+    parts: tuple[str, ...] = path.with_suffix("").parts
+    index: int
+    part: str
+    for index, part in enumerate(parts[:-1]):
+        if part == _SITE or part.startswith(_BUNDLED):
+            after: int = index + 2
+            inside: list[str] = [parts[index + 1].removesuffix(_STUBS), *parts[after:]]
+            return ".".join(inside[:-1] if inside[-1] == _PACKAGE and len(inside) > 1 else inside)
+    return module_name(path) if path.suffix == SUFFIX else None
+
+
+def _imports(new: str, start: Object, locate: _Locate, existing: FromImports) -> list[str] | None:
+    """Read an edit that adds imports: whole statements, or names into a `from` import at `start`.
+
+    Returns:
+      Each name's import, as a statement of its own; `None` for any other edit.
+
+    """
+    try:
+        body: list[ast.stmt] = ast.parse(new).body
+    except SyntaxError:  # `, Shape`: names for an import the file has
+        body = []
+    if body and all(isinstance(stmt, ast.Import | ast.ImportFrom) for stmt in body):
+        return [statement for stmt in body for statement in _statements(stmt)]
+    where: _Where | None = locate(start)
+    node: ast.ImportFrom | None = None if where is None else existing.at(where)
+    names: list[str] = [name.strip() for name in new.split(",") if name.strip()]
+    if node is None or not names or not all(name.isidentifier() for name in names):
+        return None
+    return [f"from {_module(node)} import {name}" for name in names]
+
+
+def _statements(stmt: ast.stmt) -> list[str]:
+    """Write an import as one statement per name it binds.
+
+    Returns:
+      Them.
+
+    """
+    prefix: str = f"from {_module(stmt)} import " if isinstance(stmt, ast.ImportFrom) else "import "
+    return [
+        prefix + alias.name + (f" as {alias.asname}" if alias.asname else "")
+        for alias in cast("ast.Import | ast.ImportFrom", stmt).names
+    ]
+
+
+def _module(node: ast.ImportFrom) -> str:
+    """Write the module a `from` import names.
+
+    Returns:
+      It, a relative one with its dots.
+
+    """
+    return "." * node.level + (node.module or "")