sqlakit 0.18.0__tar.gz → 0.20.0__tar.gz

{sqlakit-0.18.0 → sqlakit-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlakit
-Version: 0.18.0
+Version: 0.20.0
 Summary: A toolkit for SQLAlchemy applications.
 Keywords: sqlalchemy,database,orm,sql,asyncio
 Author: Anton Ruhlov
@@ -249,16 +249,20 @@ project has `rich`, the output is colored too.
 
 ### The debug server
 
-`sqlakit debugserver` serves a page that fills as the recordings arrive:
+[`sqlakit-debugserver`](https://github.com/sqlakit/sqlakit-debugserver) serves a page that fills as the recordings
+arrive. It is a package of its own:
 
 ```console
-$ sqlakit debugserver
+$ pip install sqlakit-debugserver
+$ sqlakit-debugserver
 
 SQLAKit debug server on http://localhost:5555
 
 Send recordings to it:
 
-  │  with db.recording("GET /users", debugserver=("localhost", 5555)):
+  │  from sqlakit_debugserver import DebugServer
+  │
+  │  with db.recording("GET /users", send_to=DebugServer("localhost", 5555)):
   │      list_users()
 ```
 
@@ -429,10 +433,11 @@ On shutdown, `dispose()` closes the pool.
 
 [Getting started](docs/getting-started.md) builds a database, a model and a
 test from an empty file. The rest is under [`docs/`](docs/):
-[queries](docs/queries.md), [SQL templates](docs/sql.md),
-[models](docs/models.md), [testing](docs/testing.md),
-[debugging](docs/debugging.md), [multiple databases](docs/routing.md) and
-[the reference](docs/reference.md). Complete example apps live in
-[`examples/`](examples/), and each one is run by the test suite.
+[compared to SQLAlchemy](docs/comparison.md), [queries](docs/queries.md),
+[SQL templates](docs/sql.md), [models](docs/models.md),
+[testing](docs/testing.md), [debugging](docs/debugging.md),
+[multiple databases](docs/routing.md) and [the reference](docs/reference.md).
+Complete example apps live in [`examples/`](examples/), and each one is run by
+the test suite.
 
 What changed in each version is in the [changelog](CHANGELOG.md).

{sqlakit-0.18.0 → sqlakit-0.20.0}/README.md

@@ -216,16 +216,20 @@ project has `rich`, the output is colored too.
 
 ### The debug server
 
-`sqlakit debugserver` serves a page that fills as the recordings arrive:
+[`sqlakit-debugserver`](https://github.com/sqlakit/sqlakit-debugserver) serves a page that fills as the recordings
+arrive. It is a package of its own:
 
 ```console
-$ sqlakit debugserver
+$ pip install sqlakit-debugserver
+$ sqlakit-debugserver
 
 SQLAKit debug server on http://localhost:5555
 
 Send recordings to it:
 
-  │  with db.recording("GET /users", debugserver=("localhost", 5555)):
+  │  from sqlakit_debugserver import DebugServer
+  │
+  │  with db.recording("GET /users", send_to=DebugServer("localhost", 5555)):
   │      list_users()
 ```
 
@@ -396,10 +400,11 @@ On shutdown, `dispose()` closes the pool.
 
 [Getting started](docs/getting-started.md) builds a database, a model and a
 test from an empty file. The rest is under [`docs/`](docs/):
-[queries](docs/queries.md), [SQL templates](docs/sql.md),
-[models](docs/models.md), [testing](docs/testing.md),
-[debugging](docs/debugging.md), [multiple databases](docs/routing.md) and
-[the reference](docs/reference.md). Complete example apps live in
-[`examples/`](examples/), and each one is run by the test suite.
+[compared to SQLAlchemy](docs/comparison.md), [queries](docs/queries.md),
+[SQL templates](docs/sql.md), [models](docs/models.md),
+[testing](docs/testing.md), [debugging](docs/debugging.md),
+[multiple databases](docs/routing.md) and [the reference](docs/reference.md).
+Complete example apps live in [`examples/`](examples/), and each one is run by
+the test suite.
 
 What changed in each version is in the [changelog](CHANGELOG.md).

{sqlakit-0.18.0 → sqlakit-0.20.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlakit"
-version = "0.18.0"
+version = "0.20.0"
 description = "A toolkit for SQLAlchemy applications."
 readme = "README.md"
 license = "MIT"
@@ -35,9 +35,6 @@ dependencies = [
 name = "Anton Ruhlov"
 email = "antonruhlov@gmail.com"
 
-[project.scripts]
-sqlakit = "sqlakit._cli:main"
-
 [project.entry-points.pytest11]
 sqlakit = "sqlakit.pytest_plugin"
 
@@ -178,7 +175,7 @@ default_item_type = "cmd"
 
 [tool.codespell]
 ignore-words-list = "froms"
-skip = "./.venv,./site,./uv.lock,./.git,./debugserver/node_modules,./debugserver/bun.lock,./sqlakit/debugserver.html"
+skip = "./.venv,./site,./uv.lock,./.git"
 
 [dependency-groups]
 dev = [

{sqlakit-0.18.0 → sqlakit-0.20.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "sqlakit"
-version = "0.18.0"
+version = "0.20.0"
 description = "A toolkit for SQLAlchemy applications."
 readme = "README.md"
 license = "MIT"
@@ -26,9 +26,6 @@ dependencies = [
     "typing-extensions>=4.13",
 ]
 
-[project.scripts]
-sqlakit = "sqlakit._cli:main"
-
 [project.entry-points.pytest11]
 sqlakit = "sqlakit.pytest_plugin"
 
@@ -211,4 +208,4 @@ default_item_type = "cmd"
 [tool.codespell]
 # `froms` is SQLAlchemy's own word for what a SELECT selects from.
 ignore-words-list = "froms"
-skip = "./.venv,./site,./uv.lock,./.git,./debugserver/node_modules,./debugserver/bun.lock,./sqlakit/debugserver.html"
+skip = "./.venv,./site,./uv.lock,./.git"

{sqlakit-0.18.0 → sqlakit-0.20.0}/sqlakit/__init__.py

@@ -1,6 +1,5 @@
 from ._base import DEFAULT_ENGINE_ARGS, DEFAULT_SESSION_ARGS
 from ._db import Database, RetryingTransaction, Transaction
-from ._debugserver import DebugServer
 from ._discovery import import_models, import_string
 from ._query import (
     CASE_INSENSITIVE_COLLATIONS,
@@ -24,6 +23,7 @@ from .exceptions import (
     DatabaseNotConfiguredError,
     DefaultAliasError,
     DetachedInstanceError,
+    DuplicateKeyError,
     InstanceNotFoundError,
     InvalidCursorError,
     InvalidDatabaseConfigError,
@@ -80,9 +80,9 @@ __all__ = [
     "DatabaseConfig",
     "DatabaseNotConfiguredError",
     "Databases",
-    "DebugServer",
     "DefaultAliasError",
     "DetachedInstanceError",
+    "DuplicateKeyError",
     "EngineArgs",
     "InstanceNotFoundError",
     "InvalidCursorError",

{sqlakit-0.18.0 → sqlakit-0.20.0}/sqlakit/_base.py

@@ -24,7 +24,6 @@ import sqlalchemy as sa
 import sqlalchemy.event
 from typing_extensions import Unpack
 
-from ._debugserver import DebugServer, send_recording
 from ._discovery import import_string
 from ._recording import (
     KEEP,
@@ -358,7 +357,7 @@ class BaseDatabase(Generic[ConnectionT, SessionT]):
         stacks: bool = False,
         skip_queries_from: Sequence[str | PathLike[str]] = (),
         into: Recording | None = None,
-        debugserver: DebugServer | tuple[str, int] | None = None,
+        send_to: Callable[[Recording], object] | None = None,
     ) -> Iterator[Recording]:
         """Record the statements of this block, and what they add up to.
 
@@ -373,8 +372,8 @@ class BaseDatabase(Generic[ConnectionT, SessionT]):
 
         ``logger`` writes a summary when the block ends, at a level the numbers
         choose. ``echo`` prints the statements instead, coloured where `rich` is
-        installed. ``debugserver`` sends the recording to a `sqlakit debugserver`
-        listening there, and says nothing when none is. ``stacks`` has every
+        installed. ``send_to`` is called with the recording, to hand it on:
+        `sqlakit_debugserver.DebugServer` is one. ``stacks`` has every
         statement remember the frames that led to it, at the cost of a stack walk
         each time. ``skip_queries_from`` names the files whose statements are none of
         your business: what those run is not recorded at all, which leaves a test's
@@ -403,8 +402,8 @@ class BaseDatabase(Generic[ConnectionT, SessionT]):
                 recording.log(logger)
             if echo:
                 recording.echo()
-            if debugserver is not None:
-                send_recording(recording, debugserver)
+            if send_to is not None:
+                send_to(recording)
 
     @contextmanager
     def assert_queries(
@@ -886,7 +885,7 @@ class _DatabaseRegistryMixin(BaseDatabase[Any, Any], Generic[DatabaseT]):
         stacks: bool = False,
         skip_queries_from: Sequence[str | PathLike[str]] = (),
         into: Recording | None = None,
-        debugserver: DebugServer | tuple[str, int] | None = None,
+        send_to: Callable[[Recording], object] | None = None,
         using: str | DatabaseT | Sequence[str | DatabaseT] | None = None,
     ) -> Iterator[Recording]:
         """Record every database this registry has, not the default one alone.
@@ -936,8 +935,8 @@ class _DatabaseRegistryMixin(BaseDatabase[Any, Any], Generic[DatabaseT]):
                     together.log(logger)
                 if echo:
                     together.echo()
-                if debugserver is not None:
-                    send_recording(together, debugserver)
+                if send_to is not None:
+                    send_to(together)
 
     @contextmanager
     def unbound(self) -> Iterator[None]:

{sqlakit-0.18.0 → sqlakit-0.20.0}/sqlakit/_query.py

@@ -43,6 +43,7 @@ from ._model import resolve_alias, soft_delete_column
 from .exceptions import (
     BulkQueryError,
     ConflictingJoinError,
+    DuplicateKeyError,
     InstanceNotFoundError,
     InvalidCursorError,
     InvalidNullsError,
@@ -53,6 +54,7 @@ from .exceptions import (
     PageItemsMismatchError,
     RawStatementError,
     UncomparableOrderingError,
+    UnknownFieldError,
     UnknownOrderFieldError,
     UnorderedPageError,
 )
@@ -734,9 +736,13 @@ class BaseQuery(Generic[ModelT]):
         ```
 
         The attribute holds what this statement selects into it, so a count or
-        a window function arrives on the instance rather than beside it.
+        a window function arrives on the instance rather than beside it. An
+        instance the session already holds is read again, so the value follows
+        the expression given this time rather than the one it was loaded with.
         """
-        return self.options(with_expression(key, expression))
+        return self.options(with_expression(key, expression)).execution_options(
+            populate_existing=True
+        )
 
     def with_for_update(
         self,
@@ -1518,6 +1524,59 @@ class _Rows(Protocol[RowT_co]):
     def one_or_none(self) -> RowT_co | None: ...
 
 
+def key_names(model: type[Any], keys: Sequence[Any]) -> list[str]:
+    """Return the attribute names `in_bulk` keys by, checked against the model.
+
+    With no columns the key is the primary key. A key has to be a column
+    attribute of the model itself: an expression cannot be read off a row, and
+    a column of another table with the same name would read the wrong value.
+
+    Raises:
+        UnknownFieldError: if a key is not a column of the model.
+
+    """
+    mapper = sa.inspect(model, raiseerr=True)
+    if not keys:
+        return [
+            mapper.get_property_by_column(column).key for column in mapper.primary_key
+        ]
+    names = []
+    for key in keys:
+        name = getattr(key, "key", None)
+        owner = getattr(key, "class_", None)
+        if (
+            name is None
+            or owner is None
+            or not issubclass(model, owner)
+            or name not in mapper.column_attrs
+        ):
+            raise UnknownFieldError(model.__name__, str(key))
+        names.append(name)
+    return names
+
+
+def keyed(
+    rows: Iterable[Any], model: type[Any], names: Sequence[str]
+) -> dict[Any, Any]:
+    """Return the rows under the value each has in these attributes, one row per key.
+
+    One name keys by its value, several by the tuple of theirs, in the order
+    the rows arrived.
+
+    Raises:
+        DuplicateKeyError: if two rows share a key.
+
+    """
+    result: dict[Any, Any] = {}
+    for row in rows:
+        values = tuple(getattr(row, name) for name in names)
+        key = values[0] if len(values) == 1 else values
+        if key in result:
+            raise DuplicateKeyError(model.__name__, names, key)
+        result[key] = row
+    return result
+
+
 def one_row(rows: _Rows[RowT], name: str) -> RowT:
     """Return the single row, saying what had none or too many.
 

{sqlakit-0.18.0 → sqlakit-0.20.0}/sqlakit/asyncio/orm.py

@@ -31,6 +31,8 @@ from sqlakit._query import (
     BaseQuery,
     CursorPage,
     Page,
+    key_names,
+    keyed,
     merged,
     one_row,
     one_row_or_none,
@@ -152,6 +154,61 @@ class Query(BaseQuery[ModelT]):
         result = await self._rows(self._executable())
         return result.all()
 
+    @overload
+    async def in_bulk(self) -> dict[Any, ModelT]: ...
+
+    @overload
+    async def in_bulk(
+        self, key: _TypedColumnClauseArgument[C0], /
+    ) -> dict[C0, ModelT]: ...
+
+    @overload
+    async def in_bulk(
+        self,
+        key: _TypedColumnClauseArgument[C0],
+        other: _TypedColumnClauseArgument[C1],
+        /,
+    ) -> dict[tuple[C0, C1], ModelT]: ...
+
+    @overload
+    async def in_bulk(
+        self,
+        key: _TypedColumnClauseArgument[C0],
+        other: _TypedColumnClauseArgument[C1],
+        third: _TypedColumnClauseArgument[C2],
+        /,
+    ) -> dict[tuple[C0, C1, C2], ModelT]: ...
+
+    @overload
+    async def in_bulk(
+        self, *keys: _TypedColumnClauseArgument[Any]
+    ) -> dict[Any, ModelT]: ...
+
+    async def in_bulk(
+        self, *keys: _TypedColumnClauseArgument[Any]
+    ) -> dict[Any, ModelT]:
+        """Return every matching row, under the value it has in these columns.
+
+        ```python
+        User.query.where(User.id.in_(ids)).in_bulk()  # dict[int, User], by key
+        User.query.in_bulk(User.email)  # dict[str, User]
+        Seat.query.in_bulk(Seat.row, Seat.col)  # dict[tuple[int, str], Seat]
+        ```
+
+        One column keys by its value and several by the tuple of theirs, so
+        the checker knows the key's type. The rows keep the query's order, and
+        a key column the query defers is loaded with the row.
+
+        Raises:
+            DuplicateKeyError: if two rows share a key.
+            UnknownFieldError: if a key is not a column of the model.
+
+        """
+        # A key the model defers is read with the row rather than one row at a time.
+        names = key_names(self.model, keys)
+        rows = await self.undefer(*keys).all()
+        return keyed(rows, self.model, names)
+
     async def first(self) -> ModelT | None:
         """Return the first matching row, or None."""
         # A raw statement takes no limit; the first row is read off the result.

{sqlakit-0.18.0 → sqlakit-0.20.0}/sqlakit/exceptions.py

@@ -479,6 +479,22 @@ class InvalidNullsError(SQLAKitError, ValueError):
         super().__init__(f"`nulls` is `first` or `last`, not `{nulls!r}`.")
 
 
+class DuplicateKeyError(SQLAKitError, ValueError):
+    """Raised when `in_bulk` finds two rows under one key."""
+
+    def __init__(
+        self, model: str, key: Iterable[str] = (), value: object = None
+    ) -> None:
+        super().__init__(
+            f"`in_bulk` keys {model} rows by {', '.join(key) or 'the primary key'}, "
+            f"and two rows share {value!r}. Key by something unique, or narrow "
+            f"the query to one row per key."
+        )
+        self.model = model
+        self.key = tuple(key)
+        self.value = value
+
+
 class KeyLookupError(SQLAKitError, TypeError):
     """Raised when a lookup by primary key is asked to honour what it cannot."""
 

{sqlakit-0.18.0 → sqlakit-0.20.0}/sqlakit/orm.py

@@ -32,6 +32,8 @@ from ._query import (
     BaseQuery,
     CursorPage,
     Page,
+    key_names,
+    keyed,
     merged,
     one_row,
     one_row_or_none,
@@ -148,6 +150,55 @@ class Query(BaseQuery[ModelT]):
         """Return every matching row."""
         return self._rows(self._executable()).all()
 
+    @overload
+    def in_bulk(self) -> dict[Any, ModelT]: ...
+
+    @overload
+    def in_bulk(self, key: _TypedColumnClauseArgument[C0], /) -> dict[C0, ModelT]: ...
+
+    @overload
+    def in_bulk(
+        self,
+        key: _TypedColumnClauseArgument[C0],
+        other: _TypedColumnClauseArgument[C1],
+        /,
+    ) -> dict[tuple[C0, C1], ModelT]: ...
+
+    @overload
+    def in_bulk(
+        self,
+        key: _TypedColumnClauseArgument[C0],
+        other: _TypedColumnClauseArgument[C1],
+        third: _TypedColumnClauseArgument[C2],
+        /,
+    ) -> dict[tuple[C0, C1, C2], ModelT]: ...
+
+    @overload
+    def in_bulk(self, *keys: _TypedColumnClauseArgument[Any]) -> dict[Any, ModelT]: ...
+
+    def in_bulk(self, *keys: _TypedColumnClauseArgument[Any]) -> dict[Any, ModelT]:
+        """Return every matching row, under the value it has in these columns.
+
+        ```python
+        User.query.where(User.id.in_(ids)).in_bulk()  # dict[int, User], by key
+        User.query.in_bulk(User.email)  # dict[str, User]
+        Seat.query.in_bulk(Seat.row, Seat.col)  # dict[tuple[int, str], Seat]
+        ```
+
+        One column keys by its value and several by the tuple of theirs, so
+        the checker knows the key's type. The rows keep the query's order, and
+        a key column the query defers is loaded with the row.
+
+        Raises:
+            DuplicateKeyError: if two rows share a key.
+            UnknownFieldError: if a key is not a column of the model.
+
+        """
+        # A key the model defers is read with the row rather than one row at a time.
+        names = key_names(self.model, keys)
+        rows = self.undefer(*keys).all()
+        return keyed(rows, self.model, names)
+
     def first(self) -> ModelT | None:
         """Return the first matching row, or None."""
         # A raw statement takes no limit; the first row is read off the result.

{sqlakit-0.18.0 → sqlakit-0.20.0}/sqlakit/pytest_plugin.py

@@ -38,6 +38,7 @@ Every other test connects to nothing, and reaching for a session there raises
 from __future__ import annotations
 
 import asyncio
+import importlib.util
 import inspect
 import pathlib
 import time
@@ -48,7 +49,6 @@ from typing import TYPE_CHECKING, Any
 
 import pytest
 
-from ._debugserver import as_payload, write_report
 from ._recording import Recording, check, require_expectation
 from ._registry import db as importable_db
 from .exceptions import UnknownDatabaseError
@@ -63,7 +63,7 @@ if TYPE_CHECKING:
 MARKER = "db"
 SYNC_FIXTURE = "_sqlakit_transaction"
 ASYNC_FIXTURE = "_sqlakit_async_transaction"
-REPORT = pytest.StashKey[list[dict[str, Any]]]()
+REPORT = pytest.StashKey[list[tuple[Recording, str, list[str]]]]()
 WHERE = pytest.StashKey["pathlib.Path | None"]()
 NAMED_BY_THE_CLOCK = ""
 """What `--sqlakit-report` with no path means."""
@@ -114,9 +114,18 @@ def pytest_terminal_summary(
 ) -> None:
     """Write the report at the end, and say where it went."""
     where = config.stash.get(WHERE, None)
-    records = config.stash.get(REPORT, [])
-    if where is None or not records:
+    reported = config.stash.get(REPORT, [])
+    if where is None or not reported:
         return
+    # Installed apart from `sqlakit`, and only when a report is asked for.
+    from sqlakit_debugserver import (  # noqa: PLC0415  # ty: ignore[unresolved-import]
+        as_payload,
+        write_report,
+    )
+
+    records = [
+        as_payload(recording, app=app, tags=tags) for recording, app, tags in reported
+    ]
     tests = len({record["app"] + record["label"] for record in records})
     queries = sum(record["count"] for record in records)
     written = write_report(where, records, about=f"{tests} tests · {queries} queries")
@@ -133,9 +142,8 @@ def _report_path(config: pytest.Config) -> pathlib.Path | None:
     if asked is None:
         return None
     if asked == NAMED_BY_THE_CLOCK:
-        return config.rootpath / time.strftime("sqlakit-%Y%m%d-%H%M%S.html")
-    where = pathlib.Path(asked)
-    if where.is_dir():
+        where = config.rootpath / time.strftime("sqlakit-%Y%m%d-%H%M%S.html")
+    elif (where := pathlib.Path(asked)).is_dir():
         # `--sqlakit-report tests/unit` reads as the path to write to.
         message = (
             f"--sqlakit-report was given `{asked}`, which is a directory. "
@@ -143,6 +151,12 @@ def _report_path(config: pytest.Config) -> pathlib.Path | None:
             f"for a name with the time in it."
         )
         raise pytest.UsageError(message)
+    if importlib.util.find_spec("sqlakit_debugserver") is None:
+        message = (
+            "--sqlakit-report writes the debug server's page, which comes with "
+            "it: pip install sqlakit-debugserver"
+        )
+        raise pytest.UsageError(message)
     return where
 
 
@@ -388,10 +402,10 @@ def _reported(request: pytest.FixtureRequest, db: Any) -> Iterator[None]:  # noq
             )
         yield
     request.config.stash[REPORT].append(
-        as_payload(
+        (
             recording,
-            app=str(node.path.relative_to(request.config.rootpath)),
-            tags=[mark.name for mark in node.iter_markers() if mark.name != MARKER],
+            str(node.path.relative_to(request.config.rootpath)),
+            [mark.name for mark in node.iter_markers() if mark.name != MARKER],
         )
     )
 

sqlakit-0.18.0/sqlakit/_cli.py

@@ -1,101 +0,0 @@
-"""`sqlakit`, the command line."""
-
-from __future__ import annotations
-
-import argparse
-import os
-import sys
-
-from ._debugserver import create_server
-
-
-def main(argv: list[str] | None = None) -> int:
-    """Run a command, and return what the shell should make of it."""
-    parser = argparse.ArgumentParser(prog="sqlakit", description="SQLAKit.")
-    commands = parser.add_subparsers(dest="command", required=True)
-
-    debugserver = commands.add_parser(
-        "debugserver", help="watch the recordings an application sends"
-    )
-    debugserver.add_argument("-H", "--host", default="localhost")
-    debugserver.add_argument("-p", "--port", type=int, default=5555)
-
-    arguments = parser.parse_args(argv)
-    if arguments.command == "debugserver":
-        return _debugserver(arguments.host, arguments.port)
-    return 1
-
-
-def _debugserver(host: str, port: int) -> int:
-    """Serve the recordings until the terminal says otherwise."""
-    try:
-        server = create_server(host, port)
-    except OSError as error:
-        _say(f"\n{_paint('cannot listen', BOLD, RED)} on {host}:{port} — {error}\n")
-        return 1
-    _greeting(host, port)
-    try:
-        server.serve_forever()
-    except KeyboardInterrupt:
-        _say(_paint("\nstopped", DIM))
-    finally:
-        server.server_close()
-    return 0
-
-
-BOLD = "1"
-DIM = "2"
-TEAL = "36"
-RED = "31"
-GREEN = "32"
-VIOLET = "35"
-
-
-def _colours() -> bool:
-    """Whether to paint: a terminal that wants it, and was not told otherwise."""
-    if os.environ.get("NO_COLOR"):
-        return False
-    if os.environ.get("FORCE_COLOR"):
-        return True
-    return sys.stdout.isatty()
-
-
-def _paint(text: str, *codes: str) -> str:
-    """Return the text in those colours, or as it is where colour is unwanted."""
-    if not codes or not _colours():
-        return text
-    return f"\033[{';'.join(codes)}m{text}\033[0m"
-
-
-def _say(text: str) -> None:
-    """Print, and flush: the server then blocks, and a pipe would hold this."""
-    print(text, flush=True)  # noqa: T201
-
-
-def _block(*lines: str) -> str:
-    """Return these lines set off by a rule, the way a page sets off code."""
-    rule = _paint("│", DIM)
-    return "".join(f"\n  {rule}  {line}" for line in lines) + "\n"
-
-
-def _greeting(host: str, port: int) -> None:
-    """Print where the page is, and the block that fills it."""
-    where = _paint(f"http://{host}:{port}", TEAL, BOLD)
-    label = _paint('"GET /users"', GREEN)
-    named = _paint(f'"{host}"', GREEN)
-    number = _paint(str(port), VIOLET)
-    _say(
-        f"\nSQLAKit debug server on {where}\n\n"
-        + _paint(
-            "Send recordings to it:\n",
-            DIM,
-        )
-        + _block(
-            f"with db.recording({label}, debugserver=({named}, {number})):",
-            "    list_users()",
-        )
-    )
-
-
-if __name__ == "__main__":
-    sys.exit(main())