examples/evaluate_predictions.py

"""Compute Execution Accuracy (EX) of a predictions file against SCM-SQL.

Expected input: a JSONL file where each line is
  {"id": "L1-001", "pred_sql": "SELECT ..."}

Usage:
  python examples/evaluate_predictions.py path/to/predictions.jsonl

Requires:
  * The Odoo 17 demo database running on localhost:5432 (see
    https://github.com/AniruddhaPKawarase/scm-nl2sql for the compose file).
  * psycopg  (`pip install psycopg[binary]`)

Emits a per-level table + overall EX / Soft-EX.

Row-multiset equality is order-agnostic and column-name-agnostic (Soft-EX
mode) or column-name-strict (EX mode).
"""
from __future__ import annotations

import argparse
import json
import os
import sys
from collections import Counter, defaultdict
from pathlib import Path

import yaml
import psycopg


HERE = Path(__file__).resolve().parent
DATA = HERE.parent / "data" / "pilot_500.yaml"


def load_pairs() -> dict[str, dict]:
    doc = yaml.safe_load(DATA.read_text(encoding="utf-8"))
    return {p["id"]: p for p in doc["pairs"]}


def load_predictions(path: Path) -> dict[str, str]:
    preds: dict[str, str] = {}
    for raw in path.read_text(encoding="utf-8").splitlines():
        line = raw.strip()
        if not line:
            continue
        rec = json.loads(line)
        preds[rec["id"]] = rec.get("pred_sql", "")
    return preds


def execute(conn: psycopg.Connection, sql: str) -> tuple[list[tuple], str]:
    try:
        with conn.cursor() as cur:
            cur.execute("SET LOCAL statement_timeout = 15000")
            cur.execute(sql)
            rows = cur.fetchall()
        return rows, ""
    except Exception as exc:
        conn.rollback()
        return [], str(exc)[:200]


def rows_equal(pred: list[tuple], gold: list[tuple], soft: bool = False) -> bool:
    """Order-agnostic row-multiset equality."""
    if soft:
        p = sorted(tuple(r) for r in pred)
        g = sorted(tuple(r) for r in gold)
        return p == g
    return sorted(pred) == sorted(gold)


def main() -> int:
    ap = argparse.ArgumentParser()
    ap.add_argument("predictions", type=Path, help="JSONL with lines like {id, pred_sql}")
    ap.add_argument("--host", default=os.environ.get("POSTGRES_HOST", "localhost"))
    ap.add_argument("--db",   default=os.environ.get("POSTGRES_DB", "odoo"))
    ap.add_argument("--user", default=os.environ.get("POSTGRES_USER", "odoo"))
    ap.add_argument("--password", default=os.environ.get("POSTGRES_PASSWORD", "odoo_dev_pwd"))
    args = ap.parse_args()

    pairs = load_pairs()
    preds = load_predictions(args.predictions)

    conn = psycopg.connect(
        host=args.host, dbname=args.db, user=args.user, password=args.password,
    )

    per_level: dict[int, dict[str, int]] = defaultdict(lambda: {"n": 0, "ex": 0, "soft": 0})
    total_n = total_ex = total_soft = 0

    for pid, pair in pairs.items():
        pred_sql = preds.get(pid, "")
        if not pred_sql:
            continue  # not predicted — skip
        # Gold: for L6 we evaluate the LAST turn only in this simple demo
        gold_sql = pair.get("gold_sql") or pair["turns"][-1]["gold_sql"]

        gold_rows, gold_err = execute(conn, gold_sql)
        if gold_err:
            continue
        pred_rows, pred_err = execute(conn, pred_sql)
        ex = 0 if pred_err else int(rows_equal(pred_rows, gold_rows))
        soft = 0 if pred_err else int(rows_equal(pred_rows, gold_rows, soft=True))

        lvl = pair["level"]
        per_level[lvl]["n"] += 1
        per_level[lvl]["ex"] += ex
        per_level[lvl]["soft"] += soft
        total_n += 1
        total_ex += ex
        total_soft += soft

    conn.close()

    print("Per-level results:")
    for lvl in sorted(per_level):
        s = per_level[lvl]
        ex_pct = 100 * s["ex"] / s["n"] if s["n"] else 0
        sf_pct = 100 * s["soft"] / s["n"] if s["n"] else 0
        print(f"  L{lvl}  n={s['n']:4d}  EX={ex_pct:5.1f}%  Soft-EX={sf_pct:5.1f}%")
    if total_n:
        print(f"\nOverall  n={total_n:4d}  "
              f"EX={100*total_ex/total_n:5.1f}%  "
              f"Soft-EX={100*total_soft/total_n:5.1f}%")
    else:
        print("\nNo predictions overlapped with the dataset. Nothing to score.")
    return 0


if __name__ == "__main__":
    sys.exit(main())