gatewaysdk 0.3.2__py3-none-any.whl

gatewaysdk/environment/schema/data.py

@@ -0,0 +1,593 @@
+"""Rows into a world, through the world's own gate.
+
+Any agent that holds data — a vendor export, a real run's call log, a hand-made
+fixture — should be able to put it into a world without knowing the world's
+layout. This module is that door. It reads rows from files in one of three
+shapes, works out what kind of world it is looking at, and writes the rows the
+way that kind seeds:
+
+* a **schema** world (``gateway-world/1``) seeds from ``data/initial.json``, an
+  ``apply_batch`` payload. Rows become a new batch version appended to the
+  existing mutations, applied in a scratch copy first exactly as
+  :func:`connector.ingest` does, so a row the contract refuses is refused
+  with the store's own diagnostic and nothing on disk changes;
+* a **mock-tools** world seeds from ``db/schema.sql`` + ``db/seed.sql``. Rows
+  become ``INSERT`` statements appended to the seed, columns checked against
+  the schema, and the seed is proven to load in a scratch database first;
+* an **api** world's ``seed/base.json`` and a **harbor** tree's task fixtures
+  are generated or per-task; the import refuses and names what to edit.
+
+The same row planning seeds a *live* session: :func:`seed_batch` builds the
+batch a running store applies atomically, and :func:`seed_sqlite` executes
+the inserts against a task's live sqlite.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import shutil
+import sqlite3
+import tempfile
+import uuid
+from pathlib import Path
+from typing import Any, Iterable
+
+from .compiler import bundle_mode, check_bundle, compile_bundle
+from .store import SQLiteStore
+from .validation import ContractError, digest, encoded, fail, journal_paths, read_json
+
+MODES = ("append", "replace")
+MERGES = ("upsert", "fill")
+#: The inline lane's caps (the platform's seed and import calls share them): a local
+#: directory import above either is refused; larger data is a platform batch.
+INLINE_ROWS = 5000
+INLINE_BYTES = 4 * 1024 * 1024
+KIND_SCHEMA = "schema"
+KIND_MOCK_TOOLS = "mock-tools"
+KIND_API = "api"
+KIND_HARBOR = "harbor"
+KIND_UNKNOWN = "unknown"
+MAPPING = {"id": "data-import", "version": "1"}
+#: Left out of scratch copies: captures, caches, and the snapshots (rebuilt from the data).
+SCRATCH_IGNORE = ("captures", "__pycache__", ".gateway", "state.sqlite", "state.json", ".state.sqlite.*")
+
+Rows = dict[str, list[dict]]
+
+
+# ---------------------------------------------------------------- rows files
+
+
+def parse_rows(paths: Iterable[str | Path], *, entity: str | None = None) -> Rows:
+    """Read rows from files into ``{entity: [row, …]}``.
+
+    Each file is one of: a JSON object ``{"<entity>": [row, …]}``; JSONL where
+    every line is ``{"entity": "<name>", "row": {…}}``; or — only with
+    ``entity`` — a JSON array or JSONL of bare rows. Several files merge in
+    order. A file that fits none of these is refused, naming the file. The
+    files are streamed (:func:`batch.iter_rows`); this holds the result.
+    """
+    from .batch import iter_rows
+
+    rows: Rows = {}
+    seen: dict[str, int] = {}
+    for name, row in iter_rows([str(path) for path in paths], entity=entity, seen=seen):
+        rows.setdefault(name, []).append(row)
+    for name in seen:
+        rows.setdefault(name, [])  # an entity named with no rows: a replace empties it
+    return rows
+
+
+# ---------------------------------------------------------------- world kinds
+
+
+def world_kind(root: str | Path) -> str:
+    """``schema`` (gateway-world/1), ``mock-tools``, ``api``, ``harbor`` or ``unknown``."""
+    root = Path(root)
+    if bundle_mode(root) is not None:
+        return KIND_SCHEMA
+    if (root / "gateway-api-world.toml").is_file():
+        return KIND_API
+    if (root / "gateway-env.toml").is_file():
+        return KIND_MOCK_TOOLS
+    if list(root.glob("tasks/*/task.toml")) or list(root.glob("*/task.toml")):
+        return KIND_HARBOR
+    return KIND_UNKNOWN
+
+
+def _refuse_kind(kind: str, root: Path) -> None:
+    if kind == KIND_API:
+        fail(
+            "kind",
+            "This is an api world: its seed/base.json is generated from the authoring world's "
+            "data/initial.json. Import into the world directory that holds connector.toml, then "
+            "`gateway bench push` it again",
+            str(root),
+        )
+    if kind == KIND_HARBOR:
+        fail(
+            "kind",
+            "This is a harbor task tree: each task seeds from its own fixtures under "
+            "tasks/<task>/environment/ (schema.sql, seed.sql, files). Edit those",
+            str(root),
+        )
+    fail(
+        "kind",
+        f"{root} is not a world this command knows: no gateway-env.toml, gateway-api-world.toml "
+        "or tasks/*/task.toml",
+        str(root),
+    )
+
+
+# ---------------------------------------------------------------- import
+
+
+def import_rows(root: str | Path, rows: Rows, *, mode: str = "append", batch_id: str | None = None) -> dict:
+    """Write ``rows`` into the world at ``root`` the way its kind seeds.
+
+    ``append`` adds rows, upserting by primary key; ``replace`` replaces the
+    named entities wholesale. Nothing is written until the result has been
+    proven to load in a scratch copy.
+    """
+    root = Path(root)
+    if mode not in MODES:
+        fail("mode", f"mode must be one of {', '.join(MODES)}", "/mode")
+    if not isinstance(rows, dict) or not all(isinstance(v, list) for v in rows.values()):
+        fail("rows", "rows must map entity names to arrays of rows", "/rows")
+    kind = world_kind(root)
+    if kind == KIND_SCHEMA:
+        return _import_schema(root, rows, mode, batch_id)
+    if kind == KIND_MOCK_TOOLS:
+        return _import_mock_tools(root, rows, mode)
+    _refuse_kind(kind, root)
+
+
+def _import_schema(root: Path, rows: Rows, mode: str, batch_id: str | None) -> dict:
+    """Rows into a schema world, landing after everything the world already replays.
+
+    With only ``data/initial.json`` the import folds into it (``w.initial.v2``,
+    ``v3``, ...). Once refresh journals exist under ``data/batches/`` they are
+    immutable and replay *after* the initial batch, so the import is written as
+    the next journal instead: a replace deletes rows those journals hold, and
+    an append upserts against them, rather than being overwritten on replay.
+    """
+    from .snapshot import pin_path
+
+    if pin_path(root).is_file():
+        fail(
+            "snapshot_pinned",
+            "This world's data is a hosted snapshot (db/snapshot.json), which its data files "
+            "cannot reproduce: import rows through the platform (`gateway worlds data import "
+            "<slug>` or import_world_data) instead of into the checkout",
+            "/db/snapshot.json",
+        )
+    contract = compile_bundle(root)
+    journals = journal_paths(root)
+    initial_path = root / "data/initial.json"
+    previous = read_json(initial_path) if initial_path.is_file() else None
+    prior = list(previous["mutations"]) if previous else []
+    prior_id = previous["id"] if previous else f"{contract.metadata['package']['id']}.initial.v0"
+    refreshed = [m for path in journals[1:] for m in read_json(path)["mutations"]] if previous else []
+    fresh = _plan(contract, rows, mode, _held(contract, prior + refreshed))
+    if not fresh:
+        return {"kind": KIND_SCHEMA, "batch": prior_id, "entity_counts": entity_counts(root), "changed": False}
+    if mode == "replace" and not refreshed:
+        # Folded into initial.json, a replace is written compactly: the named
+        # entities' old mutations are dropped and the rows inserted afresh.
+        prior = [m for m in prior if m.get("entity") not in rows]
+        fresh = _plan(contract, rows, mode, _held(contract, prior))
+    match = re.search(r"\.v(\d+)$", prior_id)
+    version = int(match.group(1)) + 1 if match else 1
+    package = contract.metadata["package"]["id"]
+    if refreshed:
+        batch = {
+            "id": batch_id or f"{package}.import.{len(journals):06d}",
+            "target": contract.target,
+            "mapping": MAPPING,
+            "coverage": "partial",
+            "mutations": fresh,
+        }
+        written = Path("data/batches") / f"{len(journals):06d}-{digest(batch['id'].encode())[:16]}.json"
+        payload = encoded(batch)
+    else:
+        batch = {
+            "id": batch_id or f"{package}.initial.v{version}",
+            "target": contract.target,
+            "mapping": MAPPING,
+            "coverage": "partial",
+            "mutations": prior + fresh,
+        }
+        written = Path("data/initial.json")
+        payload = (json.dumps(batch, sort_keys=True, indent=1) + "\n").encode("utf-8")
+    from .snapshot import build_default, default_snapshot, sidecar_path
+
+    with tempfile.TemporaryDirectory(prefix="gateway-import-") as scratch:
+        staged = Path(scratch) / "world"
+        shutil.copytree(root, staged, ignore=shutil.ignore_patterns(*SCRATCH_IGNORE))
+        (staged / written).parent.mkdir(parents=True, exist_ok=True)
+        (staged / written).write_bytes(payload)
+        # Building the staged snapshot is the proof: every row goes through the store.
+        counts = build_default(staged, compile_bundle(staged, snapshots=False))["entityCounts"]
+        (root / written).parent.mkdir(parents=True, exist_ok=True)
+        (root / written).write_bytes(payload)
+        # The proven snapshot moves into the world; compile finds it current and only
+        # rebuilds the scenario snapshots on top of it.
+        target = default_snapshot(root)
+        target.parent.mkdir(parents=True, exist_ok=True)
+        shutil.move(str(default_snapshot(staged)), str(target))
+        shutil.move(str(sidecar_path(default_snapshot(staged))), str(sidecar_path(target)))
+    compile_bundle(root)
+    check_bundle(root)
+    return {"kind": KIND_SCHEMA, "batch": batch["id"], "entity_counts": counts, "changed": True}
+
+
+def _held(contract: Any, mutations: list[dict]) -> dict[tuple[str, tuple], dict]:
+    """What the batch journal leaves in each entity, keyed the way the store keys it."""
+    held: dict[tuple[str, tuple], dict] = {}
+    for mutation in mutations:
+        entity = mutation.get("entity")
+        if mutation.get("op") == "delete" and isinstance(mutation.get("key"), dict):
+            key = _key(contract, entity, mutation["key"])
+            if key is not None:
+                held.pop((entity, key), None)
+            continue
+        if mutation.get("op") not in ("insert", "update"):
+            continue
+        value = mutation.get("value")
+        if mutation["op"] == "update" and isinstance(mutation.get("key"), dict):
+            key = _key(contract, entity, mutation["key"])
+            if key is not None and (entity, key) in held and isinstance(value, dict):
+                held[(entity, key)] = {**held[(entity, key)], **value}
+            continue
+        if isinstance(value, dict):
+            key = _key(contract, entity, value)
+            if key is not None:
+                held[(entity, key)] = value
+    return held
+
+
+def _key(contract: Any, entity: str, row: dict) -> tuple | None:
+    fields = contract.entities.get(entity, {}).get("primary_key", [])
+    if not fields or any(field not in row for field in fields):
+        return None
+    return tuple(json.dumps(row[field], sort_keys=True) for field in fields)
+
+
+def _plan(contract: Any, rows: Rows, mode: str, held: dict[tuple[str, tuple], dict]) -> list[dict]:
+    """The mutations that take the world from ``held`` to ``held`` + ``rows``.
+
+    ``append`` inserts what is new and updates what changed at an existing key;
+    ``replace`` first deletes every held row of the named entities that the
+    rows do not carry, so replacing an entity with what it already holds is a
+    no-op. A row that lacks a primary-key field is refused here, naming the
+    field, before the store sees it.
+    """
+    mutations: list[dict] = []
+    if mode == "replace":
+        incoming = {
+            (entity, _key(contract, entity, row))
+            for entity, listed in rows.items()
+            if entity in contract.entities
+            for row in listed
+            if isinstance(row, dict)
+        }
+        for (entity, key), value in list(held.items()):
+            if entity in rows and (entity, key) not in incoming:
+                fields = contract.entities[entity]["primary_key"]
+                mutations.append(
+                    {
+                        "op": "delete",
+                        "entity": entity,
+                        "key": {field: value[field] for field in fields},
+                        "source": {"record": f"data-import:{entity}:replace"},
+                    }
+                )
+                del held[(entity, key)]
+    for entity, listed in rows.items():
+        if entity not in contract.entities:
+            fail(
+                "entity", f"Unknown entity {entity}; the world has {', '.join(sorted(contract.entities))}", f"/{entity}"
+            )
+        fields = contract.entities[entity]["primary_key"]
+        for index, row in enumerate(listed):
+            if not isinstance(row, dict):
+                fail("rows", "A row must be an object", f"/{entity}/{index}")
+            missing = [field for field in fields if field not in row]
+            if missing:
+                fail("primary_key", f"Row is missing primary key field {missing[0]!r}", f"/{entity}/{index}")
+            key = _key(contract, entity, row)
+            assert key is not None
+            existing = held.get((entity, key))
+            if existing == row:
+                continue
+            identity = hashlib.sha256(json.dumps(row, sort_keys=True).encode()).hexdigest()[:16]
+            mutation = {
+                "op": "update" if existing is not None else "insert",
+                "entity": entity,
+                "value": row,
+                "source": {"record": f"data-import:{entity}:{identity}"},
+            }
+            if existing is not None:
+                mutation["key"] = {field: row[field] for field in fields}
+            mutations.append(mutation)
+            held[(entity, key)] = row
+    return mutations
+
+
+def seed_batch(store: Any, contract: Any, rows: Rows, mode: str = "append", *, batch_id: str | None = None) -> dict:
+    """The batch that seeds a *live* store with ``rows``; apply it with ``store.apply_batch``.
+
+    The store answers atomically, so a refused row leaves the session as it was.
+    ``store`` needs only ``list(entity)``; the contract supplies the keys.
+    """
+    if mode not in MODES:
+        fail("mode", f"mode must be one of {', '.join(MODES)}", "/mode")
+    if not isinstance(rows, dict) or not all(isinstance(v, list) for v in rows.values()):
+        fail("rows", "rows must map entity names to arrays of rows", "/rows")
+    held: dict[tuple[str, tuple], dict] = {}
+    for entity, listed in rows.items():
+        if entity not in contract.entities:
+            continue
+        if mode == "replace":
+            # Every held row of a replaced entity goes; the plan needs them all.
+            for value in store.list(entity):
+                key = _key(contract, entity, value)
+                if key is not None:
+                    held[(entity, key)] = value
+            continue
+        # An append only needs the rows at the keys it names, however large the entity.
+        fields = contract.entities[entity]["primary_key"]
+        for row in listed:
+            if not isinstance(row, dict) or any(field not in row for field in fields):
+                continue
+            key = _key(contract, entity, row)
+            if key is None or (entity, key) in held:
+                continue
+            try:
+                value = store.get(entity, {field: row[field] for field in fields})
+            except ContractError:
+                continue  # a key the contract refuses is refused by the plan, with the field named
+            if value is not None:
+                held[(entity, key)] = value
+    mutations = _plan(contract, rows, mode, held)
+    return {
+        "id": batch_id or f"seed-{uuid.uuid4().hex}",
+        "target": contract.target,
+        "mapping": MAPPING,
+        "coverage": "partial",
+        "mutations": mutations,
+    }
+
+
+# ---------------------------------------------------------------- mock-tools
+
+
+def _import_mock_tools(root: Path, rows: Rows, mode: str) -> dict:
+    schema = root / "db/schema.sql"
+    if not schema.is_file():
+        fail("schema", "mock-tools world has no db/schema.sql to read tables from", "db/schema.sql")
+    with sqlite3.connect(":memory:") as probe:
+        try:
+            probe.executescript(schema.read_text(encoding="utf-8"))
+        except sqlite3.Error as error:
+            fail("schema", f"db/schema.sql does not load: {error}", "db/schema.sql")
+        columns = sqlite_columns(probe)
+    statements = sqlite_statements(columns, rows, mode)
+    if not statements:
+        return {"kind": KIND_MOCK_TOOLS, "entity_counts": entity_counts(root), "changed": False}
+    seed = root / "db/seed.sql"
+    existing = seed.read_text(encoding="utf-8") if seed.is_file() else ""
+    if existing and not existing.endswith("\n"):
+        existing += "\n"
+    appended = existing + "\n".join(statements) + "\n"
+    from .._materialize import materialize_template
+
+    with tempfile.TemporaryDirectory(prefix="gateway-import-") as scratch:
+        staged = Path(scratch) / "world"
+        shutil.copytree(root, staged, ignore=shutil.ignore_patterns(*SCRATCH_IGNORE))
+        (staged / "db/seed.sql").write_text(appended, encoding="utf-8")
+        database = Path(scratch) / "world.db"
+        materialize_template(staged, database, require_sql=True)
+        counts = _sqlite_counts(database)
+    seed.write_text(appended, encoding="utf-8")
+    return {"kind": KIND_MOCK_TOOLS, "entity_counts": counts, "changed": True, "statements": len(statements)}
+
+
+def sqlite_columns(conn: sqlite3.Connection) -> dict[str, list[str]]:
+    """Every user table's columns, in declaration order."""
+    tables = [
+        row[0]
+        for row in conn.execute("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'")
+    ]
+    return {table: [row[1] for row in conn.execute(f"PRAGMA table_info({sql_ident(table)})")] for table in tables}
+
+
+def sql_ident(name: str) -> str:
+    """A SQLite identifier, quoted: a table or column named by a schema is a
+    name, never SQL, whatever characters it carries."""
+    return '"' + name.replace('"', '""') + '"'
+
+
+def _check_sqlite_rows(columns: dict[str, list[str]], rows: Rows) -> None:
+    for table, listed in rows.items():
+        if table not in columns:
+            fail(
+                "table",
+                f"No table {table} in db/schema.sql; tables: {', '.join(sorted(columns)) or 'none'}",
+                f"/{table}",
+            )
+        for index, row in enumerate(listed):
+            if not isinstance(row, dict):
+                fail("rows", "A row must be an object", f"/{table}/{index}")
+            for column, value in row.items():
+                if column not in columns[table]:
+                    fail(
+                        "column",
+                        f"Column {column} is not in table {table}; columns: {', '.join(columns[table])}",
+                        f"/{table}/{index}/{column}",
+                    )
+                if not isinstance(value, (str, int, float, bool, type(None))):
+                    fail(
+                        "value",
+                        f"Column {column} of {table} takes a scalar; encode nested values as text yourself",
+                        f"/{table}/{index}/{column}",
+                    )
+
+
+def sqlite_statements(columns: dict[str, list[str]], rows: Rows, mode: str = "append") -> list[str]:
+    """SQL text that seeds ``rows`` into tables with these ``columns``.
+
+    ``append`` writes ``INSERT OR REPLACE`` (an upsert by the table's own
+    primary key); ``replace`` prefixes ``DELETE FROM`` for each named table and
+    writes plain inserts.
+    """
+    if mode not in MODES:
+        fail("mode", f"mode must be one of {', '.join(MODES)}", "/mode")
+    _check_sqlite_rows(columns, rows)
+    statements: list[str] = []
+    verb = "INSERT" if mode == "replace" else "INSERT OR REPLACE"
+    for table, listed in rows.items():
+        if mode == "replace":
+            statements.append(f"DELETE FROM {sql_ident(table)};")
+        for row in listed:
+            if not row:
+                statements.append(f"{verb} INTO {sql_ident(table)} DEFAULT VALUES;")
+                continue
+            names = ", ".join(sql_ident(column) for column in row)
+            values = ", ".join(_sql_literal(value) for value in row.values())
+            statements.append(f"{verb} INTO {sql_ident(table)} ({names}) VALUES ({values});")
+    return statements
+
+
+def _sql_literal(value: Any) -> str:
+    if value is None:
+        return "NULL"
+    if isinstance(value, bool):
+        return "1" if value else "0"
+    if isinstance(value, (int, float)):
+        return repr(value)
+    return "'" + str(value).replace("'", "''") + "'"
+
+
+def seed_sqlite(conn: sqlite3.Connection, rows: Rows, mode: str = "append") -> dict[str, int]:
+    """Execute the seed for ``rows`` against a live sqlite, in one transaction.
+
+    Columns come from the live database itself. A refused row rolls the whole
+    seed back. Returns the row count of every touched table afterwards.
+    """
+    statements = sqlite_statements(sqlite_columns(conn), rows, mode)
+    try:
+        conn.execute("BEGIN")
+        for statement in statements:
+            conn.execute(statement)
+        conn.commit()
+    except sqlite3.Error as error:
+        conn.rollback()
+        fail("sqlite", f"seed refused by the database: {error}", "/rows")
+    return {table: conn.execute(f"SELECT COUNT(*) FROM {sql_ident(table)}").fetchone()[0] for table in rows}
+
+
+def _sqlite_counts(database: Path) -> dict[str, int]:
+    conn = sqlite3.connect(database)
+    try:
+        return {
+            table: conn.execute(f"SELECT COUNT(*) FROM {sql_ident(table)}").fetchone()[0]
+            for table in sqlite_columns(conn)
+        }
+    finally:
+        conn.close()
+
+
+# ---------------------------------------------------------------- show
+
+
+def entity_counts(root: str | Path) -> dict[str, int]:
+    """How many rows each entity (or table) of the world at ``root`` seeds with."""
+    root = Path(root)
+    kind = world_kind(root)
+    if kind == KIND_API:
+        base = root / "seed/base.json"
+        seed = read_json(base) if base.is_file() else {}
+        return {entity: len(listed) for entity, listed in seed.items() if isinstance(listed, list)}
+    if kind not in (KIND_SCHEMA, KIND_MOCK_TOOLS):
+        _refuse_kind(kind, root)
+    if kind == KIND_SCHEMA:
+        from .snapshot import current_default
+
+        contract = check_bundle(root)
+        snapshot = current_default(root, contract)
+        if snapshot is not None:
+            return dict(snapshot["entityCounts"])
+    from .._materialize import materialize_template
+
+    with tempfile.TemporaryDirectory(prefix="gateway-show-") as scratch:
+        database = Path(scratch) / "world.db"
+        materialize_template(root, database, require_sql=kind == KIND_MOCK_TOOLS)
+        if kind == KIND_SCHEMA:
+            with SQLiteStore.open(database, contract) as store:
+                return store.counts()
+        return _sqlite_counts(database)
+
+
+def entity_rows(root: str | Path, entity: str) -> list[dict]:
+    """The seeded rows of one entity (or table) of the world at ``root``."""
+    root = Path(root)
+    kind = world_kind(root)
+    if kind == KIND_API:
+        base = root / "seed/base.json"
+        seed = read_json(base) if base.is_file() else {}
+        if entity not in seed:
+            fail("entity", f"Unknown entity {entity}; the seed has {', '.join(sorted(seed)) or 'none'}", f"/{entity}")
+        return list(seed[entity])
+    if kind not in (KIND_SCHEMA, KIND_MOCK_TOOLS):
+        _refuse_kind(kind, root)
+    if kind == KIND_SCHEMA:
+        from .snapshot import current_default, default_snapshot
+
+        contract = check_bundle(root)
+        if entity not in contract.entities:
+            fail(
+                "entity",
+                f"Unknown entity {entity}; the world has {', '.join(sorted(contract.entities))}",
+                f"/{entity}",
+            )
+        if current_default(root, contract) is not None:
+            # Reads only; the compiled snapshot answers in place.
+            with SQLiteStore.open(default_snapshot(root), contract, audit=False) as store:
+                return list(store.list(entity))
+    from .._materialize import materialize_template
+
+    with tempfile.TemporaryDirectory(prefix="gateway-show-") as scratch:
+        database = Path(scratch) / "world.db"
+        materialize_template(root, database, require_sql=kind == KIND_MOCK_TOOLS)
+        if kind == KIND_SCHEMA:
+            with SQLiteStore.open(database, contract) as store:
+                return list(store.list(entity))
+        conn = sqlite3.connect(database)
+        try:
+            columns = sqlite_columns(conn)
+            if entity not in columns:
+                fail("table", f"No table {entity}; tables: {', '.join(sorted(columns)) or 'none'}", f"/{entity}")
+            conn.row_factory = sqlite3.Row
+            return [dict(row) for row in conn.execute(f"SELECT * FROM {sql_ident(entity)}")]
+        finally:
+            conn.close()
+
+
+__all__ = [
+    "ContractError",
+    "INLINE_BYTES",
+    "INLINE_ROWS",
+    "MERGES",
+    "MODES",
+    "entity_counts",
+    "entity_rows",
+    "import_rows",
+    "parse_rows",
+    "seed_batch",
+    "seed_sqlite",
+    "sqlite_columns",
+    "sqlite_statements",
+    "world_kind",
+]