generator/engine.py

"""Run the Blueprint through the Misata Studio engine and keep what the engine says about its own output."""
from __future__ import annotations

import json
import time
from dataclasses import dataclass
from pathlib import Path
from typing import Any

import pandas as pd

from . import blueprint as B


@dataclass
class EngineRun:
    tables: dict[str, pd.DataFrame]
    design: dict[str, Any]
    report: dict[str, Any]
    clickhouse_ddl: str = ""


DELIVERED = ("stores", "products", "customers", "orders", "order_lines", "returns")


def engine_clickhouse_ddl(bp: Any, tables: dict[str, pd.DataFrame]) -> str:
    """The DDL the engine's own ClickHouse export writes for these tables, kept to compare with clickhouse/ddl.sql."""
    import tempfile

    from misata_engine.export import ParquetSource, sql_ddl

    with tempfile.TemporaryDirectory() as tmp:
        for name in DELIVERED:
            (Path(tmp) / name).mkdir()
            tables[name][[c for c in tables[name].columns if not c.startswith("_")]].to_parquet(Path(tmp) / name / "part-0.parquet")
        return sql_ddl(bp, ParquetSource(tmp), "clickhouse")


def _plain(x: Any) -> Any:
    """A certificate or finding as JSON: numpy numbers, timestamps and sets made ordinary."""
    return json.loads(json.dumps(x, default=lambda o: o.item() if hasattr(o, "item") else str(o)))


def engine_commit() -> str:
    """The Misata Studio commit the engine came from (git, or MISATA_ENGINE_COMMIT for a copy of the tree), whether its
    files had changes, and a digest of its source files, which names the engine exactly either way."""
    import hashlib
    import os
    import subprocess

    import misata_engine

    here = Path(misata_engine.__file__).resolve().parent
    digest = hashlib.sha256()
    for f in sorted(here.rglob("*.py")):
        digest.update(f.relative_to(here).as_posix().encode() + b"\0" + f.read_bytes())
    files = f"source digest {digest.hexdigest()[:16]}"
    try:
        sha = subprocess.run(["git", "rev-parse", "HEAD"], cwd=here, capture_output=True, text=True, check=True).stdout.strip()
        dirty = subprocess.run(["git", "status", "--porcelain", "--", "."], cwd=here, capture_output=True, text=True, check=True).stdout.strip()
        return f"{sha}{' with uncommitted engine changes' if dirty else ''}, {files}"
    except (OSError, subprocess.CalledProcessError):
        return f"{os.environ.get('MISATA_ENGINE_COMMIT', 'commit unknown')}, {files}"


def run(seed: int, scale: float = 1.0) -> EngineRun:
    import misata_engine as me
    from misata_engine.blueprint.guide import lint, parse
    from misata_engine.oracle import scorecard

    design = B.build(scale=scale, seed=seed)
    bp, problems = parse(design)
    if bp is None:
        raise SystemExit("the Blueprint does not parse:\n  " + "\n  ".join(problems))
    started = time.time()
    res = me.run("", blueprint=bp, seed=seed)
    seconds = round(time.time() - started, 1)
    cert = res.certificate or {}
    if not res.passed or not cert.get("passed", True):
        said = [f.message for f in res.verdict.findings[:20]] + [w["text"] for w in cert.get("withdrawn_claims") or []]
        raise SystemExit("the engine did not pass the build:\n  " + "\n  ".join(said))
    tables = dict(res.tables)
    card = scorecard.score({k: v for k, v in tables.items() if k in ("customers", "products", "orders", "order_lines", "returns")})
    report = {
        "engine": "misata_engine (Misata Studio)",
        "engine_commit": engine_commit(),
        "seed": seed,
        "scale": scale,
        "seconds": seconds,
        "passed": bool(res.passed and cert.get("passed", True)),
        "lint": [str(w) for w in lint(bp)],
        "planned": list(bp.levers.get("_planned") or []),
        "notes": [str(n) for n in res.notes],
        "findings": [{"severity": str(f.severity), "message": f.message} for f in res.verdict.findings],
        "certificate": _plain(res.certificate),
        "realism_scorecard": scorecard.render(card),
        "rows": {k: len(v) for k, v in tables.items()},
    }
    return EngineRun(tables=tables, design=design, report=report, clickhouse_ddl=engine_clickhouse_ddl(bp, tables))


def score_delivered(parquet_dir: Path) -> str:
    """The engine's realism scorecard read on the delivered files, after every step that follows the engine; decimals are
    read as numbers."""
    import pyarrow as pa
    import pyarrow.parquet as pq

    from misata_engine.oracle import scorecard

    tables = {}
    for name in ("dim_product", "dim_customer", "dim_store", "orders", "order_lines", "returns"):
        t = pq.read_table(parquet_dir / f"{name}.parquet")
        cast = pa.schema([pa.field(f.name, pa.float64()) if pa.types.is_decimal(f.type) else f for f in t.schema])
        tables[name] = t.cast(cast).to_pandas()
    return scorecard.render(scorecard.score(tables))


def save_report(er: EngineRun, out: Path) -> None:
    out.mkdir(parents=True, exist_ok=True)
    (out / "blueprint.json").write_text(json.dumps(er.design, indent=1, ensure_ascii=False))
    (out / "engine_report.json").write_text(json.dumps(er.report, indent=1, ensure_ascii=False))
    (out / "realism_scorecard.txt").write_text(er.report["realism_scorecard"])
    (out / "engine_clickhouse_ddl.sql").write_text(er.clickhouse_ddl)