sqbyl-runtime 0.1.0__py3-none-any.whl

sqbyl_runtime/__init__.py

@@ -0,0 +1,40 @@
+"""sqbyl-runtime — the minimal, shippable sqbyl runtime.
+
+Contains only what a production app needs to embed a released agent: release
+``load()``, ``ask()``, the ``LLMClient`` seam, and structured logging. None of
+the dev toolkit (eval, synth, Coach, judges, console) lives here or is importable
+from here — that one-way dependency arrow is enforced by import-linter in CI.
+
+    from sqbyl_runtime import load
+    agent = load("revenue-analytics.v3.json", db=DATABASE_URL, model="claude-opus-4-8")
+    agent.ask("How many orders shipped last month?")   # → AgentResult
+"""
+
+from sqbyl_runtime.export import (
+    McpServer,
+    answer_dict,
+    as_callable,
+    langchain_tool,
+    serve_mcp_stdio,
+)
+from sqbyl_runtime.runtime import (
+    Agent,
+    ModelMismatchWarning,
+    SchemaMismatchWarning,
+    load,
+)
+
+__version__ = "0.0.0"
+
+__all__ = [
+    "Agent",
+    "McpServer",
+    "ModelMismatchWarning",
+    "SchemaMismatchWarning",
+    "answer_dict",
+    "as_callable",
+    "langchain_tool",
+    "load",
+    "serve_mcp_stdio",
+    "__version__",
+]

sqbyl_runtime/context.py

@@ -0,0 +1,319 @@
+"""The context compiler (spec §5 steps 1-2, plan 2.1).
+
+Turn a project's knowledge (semantics + examples + trusted assets + instructions)
+plus a question into the prompt the agent runtime sends to Claude. Two halves:
+
+* a **stable system block** — instructions, annotated schema/semantics, trusted
+  assets, and few-shot examples. It does not vary with the question, so it is the
+  prompt-cache unit (``cache_system=True`` downstream).
+* a **question turn** — the one varying part, sent as the user message.
+
+This lives in ``sqbyl-runtime`` because ``ask()`` compiles context at inference
+time (the same compiler runs in dev and in a shipped release). The small-project
+path is "include everything"; large-schema shortlisting (Phase 9) runs as a
+separate :mod:`~sqbyl_runtime.selection` step *before* this renderer and hands the
+narrowed table set in — so the renderer itself stays a pure function of its inputs
+(deterministic, snapshot-testable): no clocks, no IDs, no LLM calls, stable ordering.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+from pydantic import BaseModel, Field
+
+from sqbyl_runtime.llm.base import LLMClient, Usage
+from sqbyl_runtime.models import (
+    Column,
+    Dialect,
+    Example,
+    Profile,
+    ReleaseArtifact,
+    ScalarBound,
+    SelectionConfig,
+    TableSemantics,
+    TrustedAsset,
+)
+from sqbyl_runtime.selection import LLMCallHook, ValueMatch, select_context
+
+# Past this many tables "include everything" stops being viable and Phase 9's
+# LLM/lexical shortlisting is needed; until then we still include all but flag it.
+_INCLUDE_ALL_TABLE_LIMIT = 30
+
+
+class CompiledContext(BaseModel):
+    """The compiled prompt plus what went into it (for citation + caching).
+
+    ``usage`` carries any tokens the *selection* step spent (LLM shortlisting on a
+    large schema); the pipeline folds it into the run's total so it's metered and
+    budgeted like generation (invariant 5). It is ``Usage()`` for the include-all /
+    lexical paths, which spend nothing.
+    """
+
+    system: str
+    user: str
+    selected_tables: list[str] = Field(default_factory=list)
+    offered_assets: list[str] = Field(default_factory=list)
+    notes: list[str] = Field(default_factory=list)
+    usage: Usage = Field(default_factory=Usage)
+    # The selection strategy that actually ran (rewritten to ``include_all`` on a fallback)
+    # and whether a narrowing strategy degraded to include-all — carried out so the pipeline
+    # can put the drop rationale on the run's trace/result (invariant 7, transparency).
+    selection_strategy: str = "include_all"
+    selection_fell_back: bool = False
+
+
+class ProjectKnowledge(BaseModel):
+    """Everything the agent reasons over, decoupled from where it came from.
+
+    Both a dev project (loaded from files) and a shipped ``ReleaseArtifact`` produce
+    one of these, so the runtime pipeline is identical in dev and in production.
+    """
+
+    dialect: Dialect
+    semantics: list[TableSemantics] = Field(default_factory=list)
+    instructions: str = ""
+    examples: list[Example] = Field(default_factory=list)
+    trusted_assets: list[TrustedAsset] = Field(default_factory=list)
+    selection: SelectionConfig = Field(default_factory=SelectionConfig)
+
+    @classmethod
+    def from_release(cls, release: ReleaseArtifact) -> ProjectKnowledge:
+        return cls(
+            dialect=release.dialect,
+            semantics=release.semantics,
+            instructions=release.instructions,
+            examples=release.examples,
+            trusted_assets=release.trusted_assets,
+            selection=release.selection,
+        )
+
+    def compile(
+        self,
+        question: str,
+        *,
+        llm: LLMClient | None = None,
+        model: str | None = None,
+        on_llm_call: LLMCallHook | None = None,
+    ) -> CompiledContext:
+        """Select the relevant subset (LLM/lexical for large schemas) then render it.
+
+        ``llm`` and ``model`` power the ``llm``/``llm_lexical`` selection strategies;
+        without them (or on the include-all/lexical strategies) selection spends nothing
+        and this is a pure function of the project's files. ``on_llm_call`` lets a caller
+        (the pipeline) trace the shortlisting call as its own GenAI span.
+        """
+        return compile_context(
+            question,
+            dialect=self.dialect,
+            semantics=self.semantics,
+            instructions=self.instructions,
+            examples=self.examples,
+            trusted_assets=self.trusted_assets,
+            selection=self.selection,
+            llm=llm,
+            model=model,
+            on_llm_call=on_llm_call,
+        )
+
+
+def compile_context(
+    question: str,
+    *,
+    dialect: Dialect,
+    semantics: Sequence[TableSemantics],
+    instructions: str = "",
+    examples: Sequence[Example] = (),
+    trusted_assets: Sequence[TrustedAsset] = (),
+    selection: SelectionConfig | None = None,
+    llm: LLMClient | None = None,
+    model: str | None = None,
+    on_llm_call: LLMCallHook | None = None,
+) -> CompiledContext:
+    """Compile the question + project knowledge into a system/user prompt pair.
+
+    Runs the :mod:`~sqbyl_runtime.selection` step first (include-all for small
+    projects; lexical/LLM shortlisting past ``max_tables``), then renders only the
+    surviving tables and the examples that reference them, plus any value-match hints.
+    """
+    selection = selection or SelectionConfig()
+    picked = select_context(
+        question,
+        semantics=semantics,
+        config=selection,
+        llm=llm,
+        model=model,
+        on_llm_call=on_llm_call,
+    )
+
+    chosen_names = set(picked.tables)
+    selected = [t for t in semantics if t.table in chosen_names]
+    notes = list(picked.notes)
+    if len(semantics) > _INCLUDE_ALL_TABLE_LIMIT and selection.strategy == "include_all":
+        notes.append(
+            f"{len(semantics)} tables exceeds the include-everything limit "
+            f"({_INCLUDE_ALL_TABLE_LIMIT}); set selection.strategy to lexical/llm to narrow"
+        )
+
+    # When selection narrowed the schema, keep only examples that reference a surviving
+    # table (an example about a dropped table is noise for this question). Include-all
+    # keeps every example.
+    shown_examples = _relevant_examples(examples, selected, narrowed=len(selected) < len(semantics))
+
+    system = _render_system(
+        dialect=dialect,
+        instructions=instructions,
+        semantics=selected,
+        trusted_assets=trusted_assets,
+        examples=shown_examples,
+        value_matches=picked.value_matches,
+    )
+    return CompiledContext(
+        system=system,
+        user=_render_question(question),
+        selected_tables=[t.table for t in selected],
+        offered_assets=[a.name for a in trusted_assets],
+        notes=notes,
+        usage=picked.usage,
+        selection_strategy=picked.strategy,
+        selection_fell_back=picked.fell_back,
+    )
+
+
+def _relevant_examples(
+    examples: Sequence[Example], selected: Sequence[TableSemantics], *, narrowed: bool
+) -> list[Example]:
+    """Keep examples whose SQL names a selected table; on include-all keep them all.
+
+    Best-effort substring match on table names — an example that mentions none of the
+    surviving tables is dropped only when we actually narrowed, so a project that never
+    narrows behaves exactly as before.
+    """
+    if not narrowed:
+        return list(examples)
+    names = [t.table for t in selected]
+    kept = [ex for ex in examples if any(_names_table(ex.sql, name) for name in names)]
+    # Never strip every example to zero on a narrow — keep the originals if none match,
+    # since a few-shot example is cheap and dropping all of them helps nothing.
+    return kept or list(examples)
+
+
+def _names_table(sql: str, table: str) -> bool:
+    """Whether ``sql`` references ``table`` as a whole word (case-insensitive)."""
+    import re
+
+    return re.search(rf"\b{re.escape(table)}\b", sql, re.IGNORECASE) is not None
+
+
+# --- rendering (deterministic) --------------------------------------------------
+
+
+def _render_system(
+    *,
+    dialect: Dialect,
+    instructions: str,
+    semantics: Sequence[TableSemantics],
+    trusted_assets: Sequence[TrustedAsset],
+    examples: Sequence[Example],
+    value_matches: Sequence[ValueMatch] = (),
+) -> str:
+    blocks: list[str] = [
+        f"You are a careful {dialect.value} SQL analyst. Answer questions by writing a "
+        "single read-only SELECT, grounded in the semantic layer below. Prefer measures, "
+        "filters, and trusted assets over ad-hoc arithmetic.",
+    ]
+    if instructions.strip():
+        # Rendered verbatim: instructions.md is author-owned markdown (it brings its
+        # own headings), so we don't wrap it in another.
+        blocks.append(instructions.strip())
+    blocks.append(_render_tables(semantics))
+    if value_matches:
+        blocks.append(_render_value_matches(value_matches))
+    if trusted_assets:
+        blocks.append(_render_trusted_assets(trusted_assets))
+    if examples:
+        blocks.append(_render_examples(examples))
+    return "\n\n".join(blocks).strip() + "\n"
+
+
+def _render_value_matches(value_matches: Sequence[ValueMatch]) -> str:
+    """Grounding hints mapping question literals to canonical declared values (§5.1)."""
+    lines = ["# Value hints (question terms mapped to declared column values)"]
+    for match in value_matches:
+        lines.append(f'- "{match.term}" → {match.table}.{match.column} = {match.value!r}')
+    return "\n".join(lines)
+
+
+def _render_tables(semantics: Sequence[TableSemantics]) -> str:
+    lines = ["# Schema"]
+    for table in semantics:
+        header = f"## {table.table}"
+        if table.description:
+            header += f" — {table.description}"
+        lines.append(header)
+        if table.synonyms:
+            lines.append(f"synonyms: {', '.join(table.synonyms)}")
+        lines.append("columns:")
+        for col in table.columns:
+            lines.append(_render_column(col))
+        for join in table.joins:
+            conf = "" if join.confidence is None else f"  [confidence {join.confidence:.2f}]"
+            lines.append(f"join: {join.type} -> {join.to} ON {join.on}{conf}")
+        for measure in table.measures:
+            desc = f"  — {measure.description}" if measure.description else ""
+            lines.append(f"measure {measure.name}: {measure.sql}{desc}")
+        for filt in table.filters:
+            desc = f"  — {filt.description}" if filt.description else ""
+            lines.append(f"filter {filt.name}: {filt.sql}{desc}")
+    return "\n".join(lines)
+
+
+def _render_column(col: Column) -> str:
+    parts = [f"- {col.name} ({col.type})"]
+    if col.description:
+        parts.append(f" — {col.description}")
+    if col.synonyms:
+        parts.append(f" [synonyms: {', '.join(col.synonyms)}]")
+    hint = _profile_hint(col.profile, col.sample_values)
+    if hint:
+        parts.append(f" {hint}")
+    return "".join(parts)
+
+
+def _profile_hint(profile: Profile | bool | None, sample_values: list[ScalarBound] | None) -> str:
+    """A compact grounding hint a human would eyeball: range or representative values."""
+    if sample_values:
+        shown = ", ".join(str(v) for v in sample_values)
+        return f"[values: {shown}]"
+    if isinstance(profile, Profile) and profile.min is not None and profile.max is not None:
+        return f"[range: {profile.min}..{profile.max}]"
+    return ""
+
+
+def _render_trusted_assets(assets: Sequence[TrustedAsset]) -> str:
+    lines = ["# Trusted assets (prefer these over ad-hoc SQL; cite the one you use)"]
+    for asset in assets:
+        params = ", ".join(f"{p.name} {p.type}" for p in asset.params)
+        header = f"## {asset.name}({params})"
+        if asset.description:
+            header += f" — {asset.description}"
+        lines.append(header)
+        lines.append(asset.sql.strip())
+    return "\n".join(lines)
+
+
+def _render_examples(examples: Sequence[Example]) -> str:
+    lines = ["# Examples"]
+    for ex in examples:
+        lines.append(f"Q: {ex.question}")
+        lines.append("SQL:")
+        lines.append(ex.sql.strip())
+    return "\n".join(lines)
+
+
+def _render_question(question: str) -> str:
+    return (
+        f"Question: {question.strip()}\n\n"
+        "Write a single read-only SELECT that answers it. Think briefly about which "
+        "tables, measures, and trusted assets apply, then give the SQL."
+    )

sqbyl_runtime/cost.py

@@ -0,0 +1,265 @@
+"""Token pricing + cost estimation + the live spend meter (invariant 5).
+
+This module is the single place that turns a :class:`Usage` (or a planned call
+count) into dollars, and the single place that *tracks* dollars as they're spent:
+
+  * :func:`price_usage` / :func:`estimate_cost` — the pricing primitives.
+  * :class:`CostEstimate` — the structured up-front estimate a paid command prints
+    (and ``--dry-run`` returns without spending a cent).
+  * :class:`SpendMeter` — the live tally a command runs work against: it meters every
+    call to ``.sqbyl/usage.db`` and enforces a ``--budget`` cap (hard-stop in ``--auto``,
+    pause-and-ask in guided mode via the CLI).
+
+Rates are list prices in USD per **million** tokens. They are approximate and easy
+to update; treat them as estimates, not invoices.
+"""
+
+from __future__ import annotations
+
+import threading
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel
+
+from sqbyl_runtime.llm.base import Usage
+
+if TYPE_CHECKING:
+    from sqbyl_runtime.state.usage import UsageStore
+
+# Costs are floats; a hair of tolerance keeps a cap from tripping on rounding noise
+# (e.g. an estimate of exactly the budget must be allowed to run).
+_EPSILON = 1e-9
+
+
+@dataclass(frozen=True)
+class ModelRate:
+    """USD per million tokens for one model."""
+
+    input: float
+    output: float
+    cache_write: float
+    cache_read: float
+
+
+# Approximate list prices (USD / 1M tokens). Update as pricing changes.
+# OpenAI caches automatically with no separate cache-*write* charge, so cache_write == input
+# for those rows; cache_read is the discounted cached-input rate.
+MODEL_RATES: dict[str, ModelRate] = {
+    # Anthropic
+    "claude-opus-4-8": ModelRate(input=15.0, output=75.0, cache_write=18.75, cache_read=1.5),
+    "claude-sonnet-4-6": ModelRate(input=3.0, output=15.0, cache_write=3.75, cache_read=0.3),
+    "claude-haiku-4-5-20251001": ModelRate(input=1.0, output=5.0, cache_write=1.25, cache_read=0.1),
+    # OpenAI (gpt-5 family)
+    "gpt-5": ModelRate(input=1.25, output=10.0, cache_write=1.25, cache_read=0.125),
+    "gpt-5-mini": ModelRate(input=0.25, output=2.0, cache_write=0.25, cache_read=0.025),
+    "gpt-5-nano": ModelRate(input=0.05, output=0.4, cache_write=0.05, cache_read=0.005),
+}
+# Fallback when a model id isn't in the table — priced as the flagship so estimates never
+# silently read as $0. Note this same rate prices *actual* metered spend too, so a real call
+# on an unrecognized (often cheaper) model is billed in usage.db as an upper bound, not an
+# exact invoice — add the model to MODEL_RATES to reconcile it precisely.
+_DEFAULT_RATE = MODEL_RATES["claude-opus-4-8"]
+
+
+def rate_for(model: str) -> ModelRate:
+    return MODEL_RATES.get(model, _DEFAULT_RATE)
+
+
+def price_usage(usage: Usage, model: str) -> float:
+    """Dollar cost of one metered call's :class:`Usage`."""
+    rate = rate_for(model)
+    return (
+        usage.input_tokens * rate.input
+        + usage.output_tokens * rate.output
+        + usage.cache_creation_input_tokens * rate.cache_write
+        + usage.cache_read_input_tokens * rate.cache_read
+    ) / 1_000_000.0
+
+
+def estimate_cost(
+    *,
+    model: str,
+    calls: int,
+    avg_input_tokens: int,
+    avg_output_tokens: int,
+) -> float:
+    """A rough up-front estimate for a planned batch of ``calls`` (no cache assumed)."""
+    rate = rate_for(model)
+    per_call = (avg_input_tokens * rate.input + avg_output_tokens * rate.output) / 1_000_000.0
+    return per_call * calls
+
+
+# ── the structured up-front estimate (spec §5.5, §9) ────────────────────────────────────
+
+
+class EstimateItem(BaseModel):
+    """One planned step in a command's cost estimate — the rows of the SAM-style plan."""
+
+    label: str
+    model: str
+    calls: int
+    avg_input_tokens: int
+    avg_output_tokens: int
+
+    @property
+    def cost_usd(self) -> float:
+        return estimate_cost(
+            model=self.model,
+            calls=self.calls,
+            avg_input_tokens=self.avg_input_tokens,
+            avg_output_tokens=self.avg_output_tokens,
+        )
+
+
+class CostEstimate(BaseModel):
+    """A planned batch of paid work, itemized. Printed before spending and returned by
+    ``--dry-run`` / ``sqbyl cost`` — the "here's the plan and the estimate" of spec §5.5.
+
+    It is an *estimate*, not an invoice: no prompt-cache savings are assumed, so the real
+    metered spend should come in at or under it.
+    """
+
+    items: list[EstimateItem] = []
+
+    @property
+    def total_usd(self) -> float:
+        return sum(item.cost_usd for item in self.items)
+
+    @property
+    def calls(self) -> int:
+        return sum(item.calls for item in self.items)
+
+    def render(self, *, indent: str = "  ") -> str:
+        """The itemized plan as a right-aligned ``label … ~$cost`` table."""
+        if not self.items:
+            return f"{indent}(no paid work planned)"
+        width = max(len(item.label) for item in self.items)
+        lines = [
+            f"{indent}{item.label.ljust(width)}   ~${item.cost_usd:.4f}  "
+            f"({item.calls}× {item.model})"
+            for item in self.items
+        ]
+        lines.append(f"{indent}{'─' * (width + 20)}")
+        lines.append(f"{indent}{'estimated total'.ljust(width)}   ~${self.total_usd:.4f}")
+        return "\n".join(lines)
+
+
+# ── the live spend meter + budget cap (invariant 5) ─────────────────────────────────────
+
+
+class BudgetError(RuntimeError):
+    """A planned paid step would push spend past the hard cap.
+
+    Raised by :meth:`SpendMeter.guard` in ``--auto``/hard mode so a headless run stops
+    at the cap rather than silently overspending (spec §9). In guided mode the CLI checks
+    :meth:`SpendMeter.would_exceed` first and pauses to ask instead.
+    """
+
+    def __init__(self, *, spent: float, budget: float, attempted: float) -> None:
+        self.spent = spent
+        self.budget = budget
+        self.attempted = attempted
+        super().__init__(
+            f"budget ${budget:.4f} would be exceeded: ${spent:.4f} spent + "
+            f"~${attempted:.4f} planned"
+        )
+
+
+class SpendMeter:
+    """A running tally of paid spend, capped by an optional ``--budget`` (spec §9).
+
+    One meter spans a whole command. Every call is priced, added to the tally, and — when a
+    store is attached — durably recorded to ``.sqbyl/usage.db``, so the ledger total always
+    reconciles with the meter exactly. The cap is advisory via :meth:`would_exceed` (for a
+    guided pause) and enforced via :meth:`guard` (a hard stop that raises :class:`BudgetError`).
+
+    **Concurrency.** The lock makes each *field access* atomic — :meth:`record` and
+    :attr:`spent` are safe to call from many threads and the ledger stays exact. It does
+    **not** make the cap a concurrency-safe admission gate: :meth:`guard`/:meth:`would_exceed`
+    and the later :meth:`record` are separate steps, so N threads can each pass the check
+    before any records and collectively overshoot by up to N−1 calls. Serial callers (the CLI
+    commands) are fine; a parallel fan-out must bound dispatch with the orchestrator's own
+    pre-dispatch budget gate (Phase 6.1) rather than trusting :meth:`guard` alone.
+    """
+
+    def __init__(
+        self,
+        *,
+        budget: float | None = None,
+        store: UsageStore | None = None,
+        command: str | None = None,
+        content_hash: str | None = None,
+    ) -> None:
+        self._budget = budget
+        self._store = store
+        self._command = command
+        self._content_hash = content_hash
+        self._spent = 0.0
+        self._lock = threading.Lock()
+
+    @property
+    def budget(self) -> float | None:
+        return self._budget
+
+    @property
+    def spent(self) -> float:
+        with self._lock:
+            return self._spent
+
+    @property
+    def remaining(self) -> float | None:
+        """Dollars left under the cap, or ``None`` when uncapped."""
+        if self._budget is None:
+            return None
+        with self._lock:
+            return self._budget - self._spent
+
+    def would_exceed(self, next_cost: float) -> bool:
+        """Would spending ``next_cost`` more push past the cap? (Never True when uncapped.)"""
+        if self._budget is None:
+            return False
+        with self._lock:
+            return self._spent + next_cost > self._budget + _EPSILON
+
+    def guard(self, next_cost: float) -> None:
+        """Hard-stop precondition: raise :class:`BudgetError` if the next step won't fit."""
+        if self.would_exceed(next_cost):
+            with self._lock:
+                spent = self._spent
+            assert self._budget is not None
+            raise BudgetError(spent=spent, budget=self._budget, attempted=next_cost)
+
+    def record(
+        self,
+        usage: Usage,
+        *,
+        model: str,
+        role: str | None = None,
+        run_id: str | None = None,
+    ) -> float:
+        """Price one completed call's ``usage``, add it to the tally, and persist it.
+
+        Returns the call's dollar cost. This is metering *after* a call — the cap is
+        enforced *before* dispatch via :meth:`guard`/:meth:`would_exceed`, so a recorded
+        call can legitimately carry the tally over budget by one call's worth.
+        """
+        cost = price_usage(usage, model)
+        with self._lock:
+            self._spent += cost
+            store = self._store
+        if store is not None:
+            from sqbyl_runtime.state.usage import UsageRecord
+
+            store.record(
+                UsageRecord.from_usage(
+                    usage,
+                    model=model,
+                    command=self._command,
+                    role=role,
+                    cost_usd=cost,
+                    run_id=run_id,
+                    content_hash=self._content_hash,
+                )
+            )
+        return cost

sqbyl_runtime/db/__init__.py

@@ -0,0 +1,49 @@
+"""Read-only database access — the dialect seam, the SQL guard, and the connection.
+
+This is the only door to a SQL database in sqbyl. It lives in ``sqbyl-runtime``
+because the shipped agent executes its generated SQL through exactly this layer
+(spec §5 step 5), so read-only enforcement travels with the runtime.
+"""
+
+from __future__ import annotations
+
+from sqbyl_runtime.db.connection import Database, QueryResult, resolve_url
+from sqbyl_runtime.db.dialects import (
+    BigQueryAdapter,
+    DialectAdapter,
+    DuckDBAdapter,
+    MySQLAdapter,
+    PostgresAdapter,
+    PrivilegeReport,
+    SnowflakeAdapter,
+    SQLiteAdapter,
+    adapter_for,
+)
+from sqbyl_runtime.db.errors import (
+    StaticValidationError,
+    UnparseableSqlError,
+    WritablePrivilegeWarning,
+    WriteAttemptError,
+)
+from sqbyl_runtime.db.guard import assert_read_only, is_read_only
+
+__all__ = [
+    "BigQueryAdapter",
+    "Database",
+    "DialectAdapter",
+    "DuckDBAdapter",
+    "MySQLAdapter",
+    "PostgresAdapter",
+    "PrivilegeReport",
+    "QueryResult",
+    "SQLiteAdapter",
+    "SnowflakeAdapter",
+    "StaticValidationError",
+    "UnparseableSqlError",
+    "WritablePrivilegeWarning",
+    "WriteAttemptError",
+    "adapter_for",
+    "assert_read_only",
+    "is_read_only",
+    "resolve_url",
+]