plm-sql 0.1.0__py3-none-any.whl

plm_sql/__init__.py

@@ -0,0 +1 @@
+"""SQL pack: SQLite queries written by a model, checked by running them on the task's own schema."""

plm_sql/claims.py

@@ -0,0 +1,100 @@
+"""Which tasks the SQL pack claims: a schema to query, or a request for a query against a table.
+
+Certain (inf) on either, so SQL wins over the numeric packs, whose term counts a
+schema's column names can trip. Software's certain claim on "write a ... function"
+ties it, and software's higher priority keeps a Python function that happens to use
+SQLite. Questions about SQL that ask for no query ("What is SQL injection?",
+"INNER vs LEFT JOIN") claim nothing and go to the general pack.
+
+With a database set (PLM_SQL_DB, as the server reads it), a question with no schema
+in it can still be about that data: "How many singers do we have?" The pack then
+claims a data question (one starting what, which, how many, list, show ...; none that
+asks for prose or advice: write, explain, why, how do I ...) that names a table of the
+database, two of its columns, or one column that isn't a generic word like "name" or
+"year". Names match word by word, plurals either way ("Pets" ~ "pet", "movies" ~ "movie").
+The claim is the number of names used minus a half, so a numeric problem whose own
+pack counts as many terms ("A stadium speaker draws 8 A at 230 V") stays with that pack.
+Designed on Spider train questions and databases; judged once on held-out cases by
+evals/test_sqldb_routing.py (SQLDB_RULE, 2026-11-04): 115/120 Spider dev questions and
+18/20 casual ones to sql; 30/34 look-alikes and 9855/9860 other routing texts unmoved.
+"""
+
+import math
+import os
+import re
+import sqlite3
+from functools import lru_cache
+
+SCHEMA = re.compile(r"\bcreate\s+table\b", re.IGNORECASE)
+QUERY = re.compile(r"\b(?:quer(?:y|ies)|select\s+statement)\b|\bselect\b.{1,80}?\bfrom\b", re.IGNORECASE | re.DOTALL)
+TABLE = re.compile(r"\bsql(?:ite)?\b|\btables?\b|\b\w+\(\s*\w+(?:\s*,\s*\w+)+\s*\)", re.IGNORECASE)
+
+WORD = re.compile(r"[A-Za-z]+")
+PART = re.compile(r"[A-Z]+(?![a-z])|[A-Z]?[a-z]+")  # "AirportName" -> Airport, Name; "MPG" -> MPG
+DATA = re.compile(r"^\s*(?:please\s+)?(?:what|which|who|whose|whom|when|where|how\s+(?:many|much|old|long)|list|show|find|"
+                  r"give|return|count|tell\s+me|sort|order|rank|top|for\s+each|select|get|display|compute|calculate|"
+                  r"number\s+of|average|total|names?\s+of)\b", re.IGNORECASE)
+PROSE = re.compile(r"\b(?:write|explain|why|recommend|suggest|plan|draft|summari[sz]e|translate|describe|compose|"
+                   r"how\s+(?:do|can|should|would|could)\s+(?:i|you|we)|what\s+(?:makes|should|does|do)\b|"
+                   r"what\s+(?:is|are)\s+(?:a|an|the\s+(?:best|history|rules?|difference))\b)", re.IGNORECASE)
+
+
+GENERIC = {"id", "name", "year", "date", "age", "type", "level", "code", "day", "time", "number", "title", "price",
+           "amount", "weight", "height", "period", "rank", "result", "status", "note", "details", "description", "location",
+           "city", "country", "state", "address", "first", "last", "count", "total", "average", "size", "color", "sex",
+           "gender", "place", "position", "area", "value", "rating", "score", "share"}
+
+
+def forms(word):
+    """The word and each singular it could be: "movies" -> movies, movie, movy; "wines" -> wines, wine, win."""
+    w = word.lower()
+    out = {w}
+    if len(w) > 3 and w.endswith("s") and not w.endswith("ss"):
+        out.add(w[:-1])
+        if w.endswith("es"):
+            out.add(w[:-2])
+        if w.endswith("ies"):
+            out.add(w[:-3] + "y")
+    return out
+
+
+def parts(name):
+    return tuple(p.lower() for w in WORD.findall(name) for p in PART.findall(w))
+
+
+@lru_cache(maxsize=8)
+def schema_names(path, mtime):
+    """(table names, other column names) of the database, each name as its lowercase parts (mtime only keys the cache)."""
+    con = sqlite3.connect(f"file:{path}?mode=ro", uri=True)
+    try:
+        tables, columns = set(), set()
+        for (table,) in con.execute("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'"):
+            tables.add(parts(table))
+            quoted = table.replace('"', '""')
+            columns.update(parts(r[1]) for r in con.execute(f'PRAGMA table_info("{quoted}")'))
+        return frozenset(n for n in tables if n), frozenset(n for n in columns - tables if n)
+    finally:
+        con.close()
+
+
+def db_claim(text, path):
+    """How many of the database's names a data question uses (0 when it isn't one, or names none)."""
+    if not DATA.search(text) or PROSE.search(text):
+        return 0
+    try:
+        names = schema_names(path, os.path.getmtime(path))
+    except (OSError, sqlite3.Error):  # unreadable or not SQLite: the server checked it exists, nothing more
+        return 0
+    words = set().union(*(forms(w) for w in WORD.findall(text)))
+    hit = [[n for n in group if all(forms(p) & words for p in n)] for group in names]
+    tables, columns = len(hit[0]), len(hit[1])
+    distinctive = any(len(n) > 1 or n[0] not in GENERIC for n in hit[1])
+    # half a point down, so a pack whose own terms count as many wins the tie (SQL's priority would)
+    return tables + columns - 0.5 if tables or columns >= 2 or distinctive else 0
+
+
+def claims(text):
+    if SCHEMA.search(text) or (QUERY.search(text) and TABLE.search(text)):
+        return math.inf
+    db = os.environ.get("PLM_SQL_DB")
+    return db_claim(text, os.path.expanduser(db)) if db else 0

plm_sql/controller.py

@@ -0,0 +1,175 @@
+"""SQL pack: a question about tables becomes a SQLite query, checked by running it on the task's schema.
+
+The task's CREATE TABLE statements (and any INSERTs) are loaded into a throwaway
+read-only database (plm_sql.sandbox) and the query must run there: that catches
+syntax errors, misspelt tables and columns, and non-SQLite dialect. It can't see a
+query that runs but answers a different question; with no schema in the task
+there is nothing to run, and the answer is reported unchecked.
+
+Policies and rules were fixed before each run (evals/run_sql.py, evals/bench_sql.py). Our own
+sets (45 eval tasks, then 48 harder fresh ones) settled on always 8B, with the coder tied (42/48).
+The public benchmarks, written by others and larger, disagreed:
+
+                          Spider (299 dev)      BIRD mini-dev (496)    compute vs always-coder
+    always coder 14B      228 (76%, 72-81%)     254 (51%, 47-56%)      100%
+    cascade 8B -> coder   209 (70%)             207 (42%)              70-80%
+    always 8B             201 (67%, 62-73%)     172 (35%, 30-39%)      55-66%
+
+BENCH_RULE capped extra compute at +10 points, so it kept always 8B; the coder beats it on both
+benchmarks with paired 95% intervals well above 0 (+15 to +40, +62 to +105). On 2026-10-24 the user
+chose accuracy over compute for SQL: every level goes to the coder alone, about 1.5-1.8x the 8B's
+compute. A query that doesn't run is reported, not escalated (the check caught 38 of 242 of the
+coder's wrong BIRD queries). Budgets are 2.9-3.7x the coder's longest answer at each level over
+every set and benchmark (268, 321 and 210 tokens; none hit a cap).
+
+With the user's database (`plm --sql-db <file>`, or PLM_SQL_DB for the server; opened read-only, and
+its schema is read from the file when the task gives none), the query also runs on the real data and
+plm_sql.flags reads the result. When the coder's query is flagged, the 4B answers too, and its query
+is used iff it raises no flag; otherwise the coder's is kept and reported with its flags. FLAGS_RULE
+(evals/bench_sql_check.py), fixed before, adopted this on 2880 unseen Spider questions on 2026-10-29:
+2230 vs 2212 for the coder alone (+7 to +30, paired 95%), at 105% compute. Without a database the
+pack is as above.
+
+Model names can be overridden with PLM_CODER_MODEL and PLM_SMALL_MODEL.
+"""
+
+import os
+import sqlite3
+import time
+from pathlib import Path
+
+from plm.ollama import ask
+
+from plm_sql.flags import HUGE_ROWS, named_tables, result_flags
+from plm_sql.levels import classify
+from plm_sql.sandbox import run_query
+from plm_sql.sqlgen import build_prompt, extract_sql, split_task
+
+MODELS = {"coder": os.environ.get("PLM_CODER_MODEL", "qwen2.5-coder:14b"),
+          "small": os.environ.get("PLM_SMALL_MODEL", "hf.co/bartowski/Qwen_Qwen3-4B-GGUF:Q4_K_M")}
+SECOND_OPINION = "small"  # asked only when the coder's query is flagged on the user's database
+LEVELS = {
+    "calm": {"num_predict": 768, "chain": ["coder"]},
+    "alert": {"num_predict": 1024, "chain": ["coder"]},
+    "intensive": {"num_predict": 768, "chain": ["coder"]},
+}
+
+
+def check(task, query):
+    """Issues with a query: none if it runs on the task's schema. (issues, run result or None)."""
+    if query is None:
+        return ["no SQL query in the reply"], None
+    if not task["setup"]:
+        return [], None
+    ran = run_query(task["setup"], query)
+    if ran["setup_error"]:
+        return [], None
+    return ([f"doesn't run on the schema: {ran['error']}"] if ran["error"] else []), ran
+
+
+def open_db(path):
+    """(resolved path, schema SQL, table names) of a database file, read-only. Raises ValueError if it can't be read."""
+    path = Path(path).expanduser().resolve()
+    if not path.is_file():
+        raise ValueError(f"no database file at {path}")
+    try:
+        con = sqlite3.connect(f"file:{path}?mode=ro", uri=True)
+        try:
+            rows = con.execute("SELECT name, sql FROM sqlite_master WHERE type = 'table' AND sql IS NOT NULL "
+                               "AND name NOT LIKE 'sqlite_%' ORDER BY rowid").fetchall()
+        finally:
+            con.close()
+    except sqlite3.Error as e:
+        raise ValueError(f"{path} isn't a readable SQLite database: {e}") from None
+    if not rows:
+        raise ValueError(f"{path} has no tables")
+    return str(path), ";\n".join(r[1].strip() for r in rows) + ";", [r[0] for r in rows]
+
+
+FLAG_TEXT = {"empty": "returns no rows on the database", "huge": f"returns more than {HUGE_ROWS} rows on the database",
+             "nulls": "returns only NULLs on the database"}
+
+
+def db_issues(task, query, db):
+    """Flags for a query on the user's database, as issues, and its run there (or None)."""
+    path, _, tables = db
+    ran = run_query("", query, seconds=30, db_path=path) if query else None
+    issues = []
+    for f in result_flags(task["question"], query, ran, tables):
+        if f == "error":
+            issues.append(f"doesn't run on the database: {ran['error']}" if ran else "no SQL query in the reply")
+        elif f == "tables":
+            issues.append("uses none of the tables the question names (" + ", ".join(named_tables(task["question"], tables)) + ")")
+        else:
+            issues.append(FLAG_TEXT[f])
+    return issues, ran
+
+
+def attempt(task, text, model, num_predict, timeout, db=None):
+    start = time.time()
+    r = ask(model, build_prompt(text), False, num_predict, timeout)
+    query = extract_sql(r["response"])
+    issues, ran = check(task, query)
+    on_db = None
+    if db:  # the run on the real data replaces the run on the bare schema, as in the benchmark that judged it
+        issues, ran_db = db_issues(task, query, db)
+        on_db = ran_db and {k: ran_db[k] for k in ("columns", "n_rows", "error")}
+    return {"model": model, "tokens": r["eval_tokens"], "prompt_tokens": r["prompt_tokens"],
+            "model_text": r["response"], "capped": r["done_reason"] == "length", "code": query,
+            "ran": ran and {k: ran[k] for k in ("columns", "n_rows", "error")}, "on_db": on_db, "issues": issues,
+            "seconds": time.time() - start}
+
+
+def solve(text, level=None, timeout=300, db=None):
+    """Write one query. Returns it plus a record of every model call.
+
+    db: a SQLite file to check the query on (read-only); defaults to PLM_SQL_DB. Its schema is put
+    in front of the task when the task has no CREATE TABLE statements of its own.
+    """
+    start = time.time()
+    db = db or os.environ.get("PLM_SQL_DB") or None
+    db = open_db(db) if db else None
+    asked = text
+    if db and not split_task(text)["setup"]:
+        text = f"{db[1]}\n\n{text.strip()}"
+    task = split_task(text)
+    if level:
+        reason = "set by caller"
+    else:
+        level, reason = classify(text)
+    plan = LEVELS[level]
+    steps = []
+    for model_key in plan["chain"]:
+        steps.append(attempt(task, text, MODELS[model_key], plan["num_predict"], timeout, db))
+        if not steps[-1]["issues"]:
+            break
+    final = steps[-1]
+    if db and final["issues"]:
+        # FLAGS_RULE's policy: a second opinion, used only if it raises no flag
+        steps.append(attempt(task, text, MODELS[SECOND_OPINION], plan["num_predict"], timeout, db))
+        if not steps[-1]["issues"]:
+            final = steps[-1]
+    if db:
+        unchecked = None
+    elif not task["setup"]:
+        unchecked = "no CREATE TABLE statements given, so the query couldn't be run"
+    elif final["code"] is not None and final["ran"] is None:
+        unchecked = "the schema given doesn't load in SQLite, so the query couldn't be run"
+    else:
+        unchecked = None
+    return {
+        "pack": "sql",
+        "task": asked,
+        "level": level,
+        "reason": reason,
+        "answer": {"code": final["code"], "language": "sql"} if final["code"] else None,
+        "checked": unchecked is None,
+        "unchecked_reason": unchecked,
+        "trusted": unchecked is None and not final["issues"],
+        "final_step": steps.index(final) + 1,
+        "database": db and db[0],
+        "chosen_note": "the second opinion was flagged too, so the coder's query is kept" if db else None,
+        "steps": steps,
+        "tokens": sum(s["tokens"] for s in steps),
+        "seconds": time.time() - start,
+    }

plm_sql/flags.py

@@ -0,0 +1,58 @@
+"""Signs that a query which runs is still probably wrong, read from its result on a real database.
+
+The schema-only check (plm_sql.controller.check) catches a query that doesn't run; on empty
+tables it can't see one that runs and answers something else. With the user's database (opened
+read-only), the result itself says more:
+
+    error    the query doesn't run (or there is no query)
+    empty    it returns no rows
+    huge     it returns more than HUGE_ROWS rows
+    nulls    every value it returns is NULL
+    tables   the question names a table (every word of its name, plurals folded) and the query
+             uses none of the tables the question names
+
+Fixed on 2026-10-27 from the saved Spider (300) and BIRD mini-dev (496) answers, before any model
+answered the sets that judge them (evals/bench_sql_check.py, FLAGS_RULE).
+"""
+
+import re
+
+HUGE_ROWS = 100
+WORD = re.compile(r"[A-Za-z]+")
+
+
+def stem(word):
+    """Lowercase, with a plural ending folded: "singers" -> "singer", "countries" -> "country"."""
+    w = word.lower()
+    for suffix in ("ies", "es", "s"):
+        if w.endswith(suffix) and len(w) > len(suffix) + 2:
+            return w[: -len(suffix)] + ("y" if suffix == "ies" else "")
+    return w
+
+
+def named_tables(question, tables):
+    """The tables whose every name part (split on non-letters) appears in the question."""
+    words = {stem(w) for w in WORD.findall(question)}
+    return [t for t in tables if WORD.findall(t) and all(stem(p) in words for p in WORD.findall(t))]
+
+
+def used_tables(query, tables):
+    return [t for t in tables if re.search(rf"(?<![\w.]){re.escape(t)}(?![\w])", query, re.IGNORECASE)]
+
+
+def result_flags(question, query, ran, tables):
+    """Flags for one query: `ran` is plm_sql.sandbox.run_query's result on the real database (or None
+    when there was no query), `tables` the database's table names. An empty list means nothing looks wrong."""
+    if query is None or ran is None or ran["error"]:
+        return ["error"]
+    flags = []
+    if ran["n_rows"] == 0:
+        flags.append("empty")
+    if ran["n_rows"] > HUGE_ROWS:
+        flags.append("huge")
+    if ran["n_rows"] and all(v is None for row in ran["rows"] for v in row):
+        flags.append("nulls")
+    named = named_tables(question, tables)
+    if named and not set(named) & set(used_tables(query, tables)):
+        flags.append("tables")
+    return flags

plm_sql/levels.py

@@ -0,0 +1,56 @@
+"""Adrenaline level for a SQL task, from its question and the tables in its schema: rules only, no model.
+
+    calm      one table: filters, sorting, a single aggregate
+    alert     one join or one GROUP BY: the question names two of the schema's tables, or asks per group
+    intensive subqueries, window functions, rows that are missing, comparisons against an aggregate
+              or another row, the top row of each group, counts thresholded per group
+
+The cue families are written from those definitions (evals/sql/build_tasks.py), not fitted per task.
+Evaluate them with:  .venv/bin/python evals/eval_levels.py --pack sql
+"""
+
+import re
+
+from plm_sql.sqlgen import split_task
+
+INTENSIVE_CUES = {
+    "missing": r"\bnever\b|\bha(?:s|ve)n't\b|\bha(?:s|ve) no\b|\bnot (?:\w+ ){0,2}(?:to )?any\b|\bwithout (?:any|an?)\b",
+    "versus aggregate": r"\b(?:more|less|higher|lower|above|below|greater)\b.{0,30}\bthan (?:the |their |its )?"
+                        r"(?:average|overall|mean|manager|budget)\b",
+    "top of group": r"\b(?:which|who)\b.{0,60}\b(?:the most|most often|the highest|the lowest|the fewest|the largest"
+                    r"|most expensive|highest-paid)\b|\bfor each\b.{0,40}\b(?:most|highest|lowest)\b",
+    "all of a set": r"\bboth\b.{0,40}\band\b|\bby every\b|\bevery \w+ who\b",
+    "window": r"\branks?\b|\branking\b|\bprevious\b|\brunning (?:total|sum)\b|\bcumulative\b",
+    "group threshold": r"\bwith (?:at least|more than|fewer than) \d+\b",
+    "recursive": r"\brecursive\b|\beveryone under\b",
+}
+GROUP_CUE = re.compile(r"\beach\b|\bper\b", re.IGNORECASE)
+TABLE_NAME = re.compile(r"create\s+table\s+(?:if\s+not\s+exists\s+)?[\"`\[]?(\w+)", re.IGNORECASE)
+SORT_PHRASE = re.compile(r"\bin (?:\w+ )?order\b|\border(?:ed)? by\b", re.IGNORECASE)
+
+
+def stem(table):
+    """How a table is named in prose: the last word of its name, singular, cut to 6 letters ("enroll")."""
+    word = table.lower().rsplit("_", 1)[-1]
+    word = word[:-3] + "y" if word.endswith("ies") else word[:-1] if word.endswith("s") else word
+    return word[:6]
+
+
+def tables_named(question, setup):
+    prose = SORT_PHRASE.sub(" ", question.lower())
+    return sorted({t for t in TABLE_NAME.findall(setup) if re.search(rf"\b{stem(t)}", prose)})
+
+
+def classify(text):
+    """Return (level, reason)."""
+    task = split_task(text)
+    q = task["question"]
+    intensive = sorted(n for n, p in INTENSIVE_CUES.items() if re.search(p, q, re.IGNORECASE))
+    if intensive:
+        return "intensive", "cues: " + ", ".join(intensive)
+    named = tables_named(q, task["setup"])
+    if len(named) >= 2:
+        return "alert", "joins " + ", ".join(named)
+    if GROUP_CUE.search(q):
+        return "alert", "per-group cue"
+    return "calm", "one table, no group" if task["setup"] else "no schema, no join or group cues"

plm_sql/manifest.py

@@ -0,0 +1,11 @@
+"""The SQL pack's manifest: what the router needs to know about it."""
+
+from plm.pack import Pack
+
+from plm_sql import controller
+from plm_sql.claims import claims
+
+# Priority below software's 100: both claim with certainty a Python function that runs SQL, and that
+# is a software task; above the numeric packs, which a schema's column names can trip.
+PACK = Pack(name="sql", version="0.1.0", claims=claims, priority=90, solve=controller.solve,
+            levels=controller.LEVELS, models=controller.MODELS, eval_set="evals/sql/tasks.jsonl")

plm_sql/sandbox.py

@@ -0,0 +1,76 @@
+"""Run one model-written query on a throwaway SQLite database, in an isolated process.
+
+The database is built in memory from setup SQL (the task's CREATE TABLE statements,
+and any INSERTs it gives), then made read-only: `PRAGMA query_only`, plus an
+authorizer that allows only reads, so ATTACH, PRAGMA and writes are refused. A
+progress handler stops a query that runs too long. It runs in a separate
+`python -I -S` process in an empty temp directory, like plm/numeric/calc.py; the
+point is to keep a runaway or hostile query away from this process and its files.
+"""
+
+import json
+import re
+import subprocess
+import sys
+import tempfile
+
+MAX_ROWS = 1000  # rows returned to the caller; the count is exact either way
+
+HARNESS = r"""
+import json, sqlite3, sys, time
+
+p = json.loads(sys.stdin.read())
+
+def out(**kw):
+    print("\n" + json.dumps(kw))
+    sys.exit(0)
+
+if p.get("db_path"):  # an existing database file, opened read-only
+    db = sqlite3.connect(f"file:{p['db_path']}?mode=ro", uri=True)
+else:
+    db = sqlite3.connect(":memory:")
+    try:
+        db.executescript(p["setup"])
+    except sqlite3.Error as e:
+        out(setup_error=f"{type(e).__name__}: {e}"[:300])
+db.execute("PRAGMA query_only = ON")
+READS = {sqlite3.SQLITE_SELECT, sqlite3.SQLITE_READ, sqlite3.SQLITE_FUNCTION, getattr(sqlite3, "SQLITE_RECURSIVE", 33)}
+db.set_authorizer(lambda action, *args: sqlite3.SQLITE_OK if action in READS else sqlite3.SQLITE_DENY)
+start = time.time()
+db.set_progress_handler(lambda: int(time.time() - start > p["seconds"]), 10000)
+try:
+    cur = db.execute(p["query"])
+    columns = [d[0] for d in cur.description or []]
+    rows = cur.fetchall()
+except Exception as e:
+    out(error=f"{type(e).__name__}: {e}"[:300])
+out(columns=columns, rows=[list(r) for r in rows[:p["max_rows"]]], n_rows=len(rows))
+"""
+
+READ_ONLY = re.compile(r"^\s*(?:--[^\n]*\n\s*)*(?:select|with|values)\b", re.IGNORECASE)
+
+
+def run_query(setup, query, seconds=5.0, db_path=None):
+    """{"error": str|None, "columns": [...], "rows": [[...]], "n_rows": int}; setup errors are reported as such.
+
+    With db_path, the query runs on that database file (opened read-only) instead of on `setup`.
+    """
+    result = {"error": None, "setup_error": None, "columns": [], "rows": [], "n_rows": 0}
+    if not READ_ONLY.match(query or ""):
+        return result | {"error": "refused: not a single read-only query (SELECT or WITH)"}
+    payload = json.dumps({"setup": setup, "query": query, "seconds": seconds, "max_rows": MAX_ROWS,
+                          "db_path": str(db_path) if db_path else None})
+    with tempfile.TemporaryDirectory() as cwd:
+        try:
+            proc = subprocess.run([sys.executable, "-I", "-S", "-c", HARNESS], input=payload, capture_output=True,
+                                  text=True, cwd=cwd, timeout=seconds + 10)
+        except subprocess.TimeoutExpired:
+            return result | {"error": "query process timed out"}
+    last = proc.stdout.strip().rsplit("\n", 1)[-1] if proc.stdout.strip() else ""
+    try:
+        got = json.loads(last)
+    except json.JSONDecodeError:
+        return result | {"error": f"query process failed: {proc.stderr.strip()[-200:]}"}
+    if got.get("error") == "OperationalError: interrupted":
+        got["error"] = f"query ran longer than {seconds:g} s"
+    return result | got

plm_sql/sqlgen.py

@@ -0,0 +1,46 @@
+"""Prompting for SQL tasks, splitting the schema out of a task, and pulling the query out of a reply."""
+
+import re
+import sqlite3
+
+PROMPT_VERSION = 1
+SQL_FORMAT = (
+    "Reply with one ```sql code block containing a single SQLite query (SELECT, optionally with WITH). "
+    "Return exactly the columns the question asks for, in the order it names them, and nothing else."
+)
+
+STATEMENT_START = re.compile(r"^\s*(?:create\s+(?:table|view|index|unique\s+index)|insert\s+into)\b", re.IGNORECASE)
+SQL_RE = re.compile(r"```(?:sql|sqlite)?[ \t]*\n(.*?)```", re.DOTALL | re.IGNORECASE)
+BARE_QUERY = re.compile(r"^\s*(?:select|with)\b.*", re.IGNORECASE | re.DOTALL)
+
+
+def split_task(text):
+    """{"setup": the CREATE/INSERT statements in the text, "question": the rest, "has_rows": any INSERT}."""
+    setup, rest, buf = [], [], []
+    for line in text.splitlines():
+        if buf or STATEMENT_START.match(line):
+            buf.append(line)
+            if sqlite3.complete_statement("\n".join(buf)):
+                setup.append("\n".join(buf))
+                buf = []
+        else:
+            rest.append(line)
+    rest += buf  # an unterminated statement is left in the question
+    return {"setup": "\n".join(setup), "question": "\n".join(rest).strip(),
+            "has_rows": any(s.lstrip().lower().startswith("insert") for s in setup)}
+
+
+def build_prompt(text):
+    return f"{text.strip()}\n\n{SQL_FORMAT}"
+
+
+def extract_sql(text):
+    """The last fenced block; else the reply itself if it is a bare query. Trailing semicolons dropped."""
+    blocks = SQL_RE.findall(text or "")
+    if blocks:
+        query = blocks[-1]
+    elif BARE_QUERY.match(text or ""):
+        query = text
+    else:
+        return None
+    return query.strip().rstrip(";").strip() or None

plm_sql-0.1.0.dist-info/METADATA

@@ -0,0 +1,20 @@
+Metadata-Version: 2.5
+Name: plm-sql
+Version: 0.1.0
+Summary: plm pack: SQLite queries, checked by running them on the schema given with the task
+Project-URL: Homepage, https://github.com/ro-rbl/plm-orchestrator
+Project-URL: Source, https://github.com/ro-rbl/plm-orchestrator
+Project-URL: Issues, https://github.com/ro-rbl/plm-orchestrator/issues
+Author: ro-rbl
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.13
+Requires-Dist: plm-core<0.2,>=0.1
+Description-Content-Type: text/markdown
+
+# plm-sql
+
+Plm pack: SQLite queries, checked by running them on the schema given with the task.
+
+A domain pack for [plm-core](https://github.com/ro-rbl/plm-orchestrator): install it with `plm packs install sql`, which also pulls the
+models it needs into Ollama. Documentation, benchmark results and caveats: https://github.com/ro-rbl/plm-orchestrator

plm_sql-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+plm_sql/__init__.py,sha256=OO0TIq7ZcyMFlMTS9WMqg97879UshYPnzu6z1PqfWbE,101
+plm_sql/claims.py,sha256=Vs1U0_u0D1E-RU94x_j7Zd0dZrAQIr4QXObrz0TEMYQ,5297
+plm_sql/controller.py,sha256=oKKm3t0OUOEhlsVB809yBoumJyHbki7fj5NeGPcfXJw,8246
+plm_sql/flags.py,sha256=UfV_vCm0qnlE-vWrClIqGnmD095oESd0UGeDLA1sJ5U,2384
+plm_sql/levels.py,sha256=27t8vhIeZRVoaYATv_BcZ0x2hXoaK4lOsCU79Evf8ks,2817
+plm_sql/manifest.py,sha256=jsibYtMPK4Os28TlYPVeFzM2OUkp66nTjEZ5O09ofuA,544
+plm_sql/sandbox.py,sha256=AakoiiQ5gB-A8rIxhSW5UVxsiqmAFpUWvrGXRq_C2FM,3323
+plm_sql/sqlgen.py,sha256=hlQtR_G7nE5mNquiTRLVGbG6HT2Xus5A5T12uD6hzRs,1767
+plm_sql-0.1.0.dist-info/METADATA,sha256=C5ubEspNnptvhlaLwGqI1ABFbTe5WvnJoArb9D4L3bo,856
+plm_sql-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+plm_sql-0.1.0.dist-info/entry_points.txt,sha256=Ex3pTwYwh1o7mBLxO0RVlC5qWPgxasaHR4gxrzjx4Dg,40
+plm_sql-0.1.0.dist-info/licenses/LICENSE,sha256=KcrxZgcJO8eG0MOaibWc_3Pxvh6U_KruTKPaGwV6-vA,1063
+plm_sql-0.1.0.dist-info/RECORD,,

plm_sql-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

plm_sql-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[plm.packs]
+sql = plm_sql.manifest:PACK

plm_sql-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ro-rbl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.