run_eval_openai.py

"""Run SawBench evaluation against an OpenAI-compatible API endpoint.

Usage:
    # OpenAI
    export OPENAI_API_KEY="sk-..."
    python run_eval_openai.py --model gpt-4o-mini

    # Any OpenAI-compatible endpoint (vLLM, Ollama, Together, etc.)
    python run_eval_openai.py \
        --base-url http://localhost:8000/v1 \
        --model my-model \
        --api-key dummy

    # Specific tasks + limited items
    python run_eval_openai.py --model gpt-4o-mini --tasks spell,reverse --max-items 20
"""
import argparse, json, os, re, sys, time
from pathlib import Path
from collections import defaultdict
from datasets import load_dataset


def load_items(tasks=None, max_items=None):
    ds = load_dataset("omneity-labs/spellbench", split="test")
    items = list(ds)
    
    if tasks:
        items = [item for item in items if item["task"] in tasks]
        
    if max_items:
        by_task = defaultdict(list)
        for item in items:
            by_task[item["task"]].append(item)
        items = []
        for task_items in by_task.values():
            items.extend(task_items[:max_items])
    return items


def load_prompts(data_dir):
    with open(data_dir / "prompts.json") as f:
        return json.load(f)


def format_prompt(item, prompt_templates):
    task = item["task"]
    tmpl_info = prompt_templates.get(task)
    if not tmpl_info:
        return f"Task: {task}\nInput: {item['input']}"

    tmpl = tmpl_info["prompts"][0]
    input_val = item["input"]

    if " | " in input_val:
        parts = input_val.split(" | ")
        main_input = parts[0]
        params = {}
        for p in parts[1:]:
            if ": " in p:
                k, v = p.split(": ", 1)
                params[k.strip()] = v.strip()
        fmt = {"input": main_input, "word": main_input, "sentence": main_input}
        fmt.update(params)
        if "position" in params:
            fmt["n"] = params["position"]
        if "word number" in params:
            fmt["n"] = params["word number"]
        for p in parts[1:]:
            m = re.match(r"word (\d+) vs word (\d+)", p.strip())
            if m:
                fmt["n"] = m.group(1)
                fmt["m"] = m.group(2)
    else:
        fmt = {"input": input_val, "word": input_val, "sentence": input_val}

    try:
        return tmpl.format(**fmt)
    except KeyError:
        return f"Task: {task}\nInput: {item['input']}"


def extract_answer(response, task):
    response = response.strip()
    json_match = re.search(r'\{[^}]+\}', response)
    if json_match:
        try:
            data = json.loads(json_match.group())
            if "answer" in data:
                return str(data["answer"])
            if "result" in data:
                return str(data["result"])
        except json.JSONDecodeError:
            pass

    if task in ("word_length", "vowel_count", "consonant_count", "count_letter",
                "word_count", "total_letters", "nth_word_length"):
        nums = re.findall(r'\b(\d+)\b', response)
        if nums:
            return nums[-1]

    if task in ("is_palindrome", "contains_letter"):
        lower = response.lower()
        if "true" in lower or "yes" in lower:
            return "true"
        if "false" in lower or "no" in lower:
            return "false"

    if task == "compare_lengths":
        lower = response.lower()
        if "equal" in lower:
            return "equal"
        if "first" in lower:
            return "first"
        if "second" in lower:
            return "second"

    if task in ("first_letter", "last_letter", "nth_letter"):
        m = re.search(r"['\"](.)['\"]", response)
        if m:
            return m.group(1)
        m = re.search(r'\b([a-zA-Z])\b', response)
        if m:
            return m.group(1)

    lines = response.strip().split("\n")
    return lines[-1].strip()


def check_answer(predicted, expected, task):
    predicted = str(predicted).strip().lower()
    expected = str(expected).strip().lower()

    if task in ("unique_letters", "double_letters", "all_first_letters", "letter_positions"):
        pred_norm = re.sub(r'\s*,\s*', ', ', predicted)
        exp_norm = re.sub(r'\s*,\s*', ', ', expected)
        return pred_norm == exp_norm

    return predicted == expected


def call_api(client, model, prompt, max_tokens=128, temperature=0):
    """Call the chat completions API."""
    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        max_tokens=max_tokens,
        temperature=temperature,
    )
    return response.choices[0].message.content


def run_eval(client, model, data_dir, tasks=None, max_items=None,
             max_tokens=128, delay=0):
    prompts_data = load_prompts(data_dir)
    items = load_items(tasks, max_items)
    print(f"Loaded {len(items)} items across {len(set(i['task'] for i in items))} tasks")

    results = []
    task_scores = defaultdict(lambda: {"correct": 0, "total": 0})
    t0 = time.time()

    for i, item in enumerate(items):
        prompt_text = format_prompt(item, prompts_data)

        try:
            response = call_api(client, model, prompt_text, max_tokens)
        except Exception as e:
            print(f"  Error on {item['id']}: {e}")
            response = ""

        predicted = extract_answer(response, item["task"])
        correct = check_answer(predicted, item["expected"], item["task"])

        task_scores[item["task"]]["total"] += 1
        if correct:
            task_scores[item["task"]]["correct"] += 1

        results.append({
            "id": item["id"],
            "task": item["task"],
            "input": item["input"],
            "expected": item["expected"],
            "predicted": predicted,
            "raw_response": response,
            "correct": correct,
            "metadata": item["metadata"]
        })

        if (i + 1) % 50 == 0:
            elapsed = time.time() - t0
            print(f"  [{i+1}/{len(items)}] {elapsed:.1f}s elapsed")

        if delay > 0:
            time.sleep(delay)

    elapsed = time.time() - t0

    summary = {
        "model": model,
        "total_items": len(items),
        "total_correct": sum(1 for r in results if r["correct"]),
        "accuracy": sum(1 for r in results if r["correct"]) / len(items) if items else 0,
        "elapsed_seconds": round(elapsed, 1),
        "per_task": {},
    }
    for task, scores in sorted(task_scores.items()):
        acc = scores["correct"] / scores["total"] if scores["total"] else 0
        summary["per_task"][task] = {
            "correct": scores["correct"],
            "total": scores["total"],
            "accuracy": round(acc, 4),
        }

    return summary, results


def main():
    parser = argparse.ArgumentParser(description="Run SawBench evaluation via OpenAI API")
    parser.add_argument("--model", required=True, help="Model name")
    parser.add_argument("--base-url", default=None,
                        help="API base URL (default: OpenAI)")
    parser.add_argument("--api-key", default=None,
                        help="API key (default: OPENAI_API_KEY env var)")
    parser.add_argument("--data-dir", default=str(Path(__file__).parent / "data"))
    parser.add_argument("--tasks", default=None,
                        help="Comma-separated task names (default: all)")
    parser.add_argument("--max-items", type=int, default=None,
                        help="Max items per task")
    parser.add_argument("--max-tokens", type=int, default=128)
    parser.add_argument("--delay", type=float, default=0,
                        help="Delay between requests in seconds (rate limiting)")
    parser.add_argument("--output", default="results.json")
    args = parser.parse_args()

    try:
        from openai import OpenAI
    except ImportError:
        print("Please install the openai package: uv pip install openai")
        sys.exit(1)

    api_key = args.api_key or os.environ.get("OPENAI_API_KEY")
    if not api_key and not args.base_url:
        print("Set OPENAI_API_KEY or provide --api-key and --base-url")
        sys.exit(1)

    client_kwargs = {}
    if args.base_url:
        client_kwargs["base_url"] = args.base_url
    if api_key:
        client_kwargs["api_key"] = api_key

    client = OpenAI(**client_kwargs)
    tasks = args.tasks.split(",") if args.tasks else None
    data_dir = Path(args.data_dir)

    summary, results = run_eval(
        client, args.model, data_dir, tasks, args.max_items,
        args.max_tokens, args.delay,
    )

    print(f"\n{'='*60}")
    print(f"Model: {summary['model']}")
    print(f"Overall: {summary['total_correct']}/{summary['total_items']} "
          f"({summary['accuracy']:.1%})")
    print(f"Time: {summary['elapsed_seconds']}s")
    print(f"{'='*60}")
    print(f"{'Task':<25} {'Correct':>8} {'Total':>6} {'Accuracy':>9}")
    print(f"{'-'*25} {'-'*8} {'-'*6} {'-'*9}")
    for task, info in summary["per_task"].items():
        print(f"{task:<25} {info['correct']:>8} {info['total']:>6} {info['accuracy']:>8.1%}")

    output_path = Path(args.output)
    with open(output_path, "w") as f:
        json.dump({"summary": summary, "results": results}, f, indent=2, ensure_ascii=False)
    print(f"\nDetailed results saved to {output_path}")


if __name__ == "__main__":
    main()