app.py

import json
import os
import tempfile
from pathlib import Path

import gradio as gr
import pandas as pd
import requests

from agent import GaiaAgent
from answer_normalize import normalize_answer

DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
CACHE_FILENAME = "gaia_answers_cache.json"


def _cache_path() -> Path:
    return Path(__file__).resolve().parent / CACHE_FILENAME


def _question_cache_tag(question: str) -> str:
    """Bind cached answers to question text so task_id alone cannot serve stale rows."""
    s = " ".join(str(question).split())
    return s[:280]


def _load_cache() -> dict[str, dict]:
    p = _cache_path()
    if not p.is_file():
        return {}
    try:
        raw = json.loads(p.read_text(encoding="utf-8"))
    except json.JSONDecodeError:
        return {}
    if not isinstance(raw, dict):
        return {}
    out: dict[str, dict] = {}
    for k, v in raw.items():
        if not isinstance(k, str):
            continue
        if isinstance(v, dict) and isinstance(v.get("a"), str) and isinstance(v.get("qtag"), str):
            out[k] = v
        # Legacy format task_id -> plain string (unsafe if questions rotate): ignore.
    return out


def _save_cache(cache: dict[str, dict]) -> None:
    _cache_path().write_text(json.dumps(cache, indent=2), encoding="utf-8")


def _cache_get(cache: dict[str, dict], task_id: str, question_text: str) -> str | None:
    entry = cache.get(str(task_id))
    if not entry:
        return None
    if entry.get("qtag") != _question_cache_tag(question_text):
        return None
    return entry.get("a")


def _cache_set(
    cache: dict[str, dict], task_id: str, question_text: str, answer: str
) -> None:
    cache[str(task_id)] = {
        "qtag": _question_cache_tag(question_text),
        "a": answer,
    }


def _download_attachment(api_url: str, task_id: str, file_name: str) -> str | None:
    """Save task attachment to a temp file; return path or None."""
    if not file_name or not str(file_name).strip():
        return None
    url = f"{api_url}/files/{task_id}"
    try:
        r = requests.get(
            url,
            timeout=120,
            allow_redirects=True,
            headers={
                "User-Agent": "GAIA-Agent/1.0 (HuggingFace-Space; +https://huggingface.co)"
            },
        )
    except requests.RequestException:
        return None
    if r.status_code != 200:
        return None
    ctype = (r.headers.get("Content-Type") or "").lower()
    if "application/json" in ctype:
        try:
            data = r.json()
            if isinstance(data, dict) and data.get("detail"):
                return None
        except json.JSONDecodeError:
            pass
    suffix = Path(file_name).suffix or ""
    fd, path = tempfile.mkstemp(suffix=suffix, prefix=f"gaia_{task_id[:8]}_")
    try:
        with os.fdopen(fd, "wb") as f:
            f.write(r.content)
    except OSError:
        return None
    return path


def run_and_submit_all(profile: gr.OAuthProfile | None):
    space_id = os.getenv("SPACE_ID")
    use_cache = os.getenv("GAIA_USE_CACHE", "0").lower() in ("1", "true", "yes")

    if profile:
        username = f"{profile.username}"
        print(f"User logged in: {username}")
    else:
        print("User not logged in.")
        return "Please Login to Hugging Face with the button.", None

    api_url = os.getenv("GAIA_API_URL", DEFAULT_API_URL)
    questions_url = f"{api_url}/questions"
    submit_url = f"{api_url}/submit"

    try:
        agent = GaiaAgent()
    except Exception as e:
        print(f"Error instantiating agent: {e}")
        return f"Error initializing agent: {e}", None

    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
    print(agent_code)

    print(f"Fetching questions from: {questions_url}")
    try:
        response = requests.get(questions_url, timeout=60)
        response.raise_for_status()
        questions_data = response.json()
        if not questions_data:
            return "Fetched questions list is empty or invalid format.", None
        print(f"Fetched {len(questions_data)} questions.")
    except requests.exceptions.RequestException as e:
        return f"Error fetching questions: {e}", None
    except json.JSONDecodeError as e:
        return f"Error decoding server response for questions: {e}", None

    cache = _load_cache() if use_cache else {}
    results_log = []
    answers_payload = []

    print(f"Running agent on {len(questions_data)} questions...")
    for item in questions_data:
        task_id = item.get("task_id")
        question_text = item.get("question")
        file_name = item.get("file_name") or ""

        if not task_id or question_text is None:
            print(f"Skipping item with missing task_id or question: {item}")
            continue

        cache_key = str(task_id)
        cached_raw = _cache_get(cache, cache_key, str(question_text)) if use_cache else None
        if cached_raw is not None:
            submitted_answer = normalize_answer(
                cached_raw, context_question=str(question_text)
            )
            print(f"Cache hit for {task_id}")
        else:
            local_path: str | None = None
            try:
                if file_name and str(file_name).strip():
                    local_path = _download_attachment(api_url, str(task_id), str(file_name))
                    if local_path:
                        print(f"Downloaded attachment for {task_id} -> {local_path}")
                submitted_answer = agent(
                    str(question_text),
                    attachment_path=local_path,
                    task_id=str(task_id),
                )
                submitted_answer = normalize_answer(
                    submitted_answer, context_question=str(question_text)
                )
                if use_cache:
                    _cache_set(
                        cache,
                        cache_key,
                        str(question_text),
                        submitted_answer
                        if isinstance(submitted_answer, str)
                        else str(submitted_answer),
                    )
                    _save_cache(cache)
            except Exception as e:
                print(f"Error running agent on task {task_id}: {e}")
                submitted_answer = f"AGENT ERROR: {e}"
            finally:
                if local_path and Path(local_path).is_file():
                    try:
                        Path(local_path).unlink(missing_ok=True)
                    except OSError:
                        pass

        answers_payload.append(
            {
                "task_id": task_id,
                "submitted_answer": submitted_answer,
            }
        )
        results_log.append(
            {
                "Task ID": task_id,
                "Question": question_text,
                "Submitted Answer": submitted_answer,
            }
        )

    if not answers_payload:
        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)

    submission_data = {
        "username": username.strip(),
        "agent_code": agent_code,
        "answers": answers_payload,
    }
    status_update = (
        f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
    )
    print(status_update)

    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
    try:
        response = requests.post(submit_url, json=submission_data, timeout=600)
        response.raise_for_status()
        result_data = response.json()
        final_status = (
            f"Submission Successful!\n"
            f"User: {result_data.get('username')}\n"
            f"Overall Score: {result_data.get('score', 'N/A')}% "
            f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
            f"Message: {result_data.get('message', 'No message received.')}"
        )
        print("Submission successful.")
        results_df = pd.DataFrame(results_log)
        return final_status, results_df
    except requests.exceptions.HTTPError as e:
        error_detail = f"Server responded with status {e.response.status_code}."
        try:
            error_json = e.response.json()
            error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
        except json.JSONDecodeError:
            error_detail += f" Response: {e.response.text[:500]}"
        status_message = f"Submission Failed: {error_detail}"
        print(status_message)
        return status_message, pd.DataFrame(results_log)
    except requests.exceptions.Timeout:
        status_message = "Submission Failed: The request timed out."
        print(status_message)
        return status_message, pd.DataFrame(results_log)
    except requests.exceptions.RequestException as e:
        status_message = f"Submission Failed: Network error - {e}"
        print(status_message)
        return status_message, pd.DataFrame(results_log)
    except Exception as e:
        status_message = f"An unexpected error occurred during submission: {e}"
        print(status_message)
        return status_message, pd.DataFrame(results_log)


def crypto_btc_price() -> str:
    """Optional demo: live BTC/USD (not used for GAIA scoring)."""
    try:
        r = requests.get(
            "https://api.coingecko.com/api/v3/simple/price",
            params={"ids": "bitcoin", "vs_currencies": "usd"},
            timeout=20,
        )
        r.raise_for_status()
        data = r.json()
        usd = data.get("bitcoin", {}).get("usd")
        return f"Bitcoin (BTC) ~ ${usd:,.2f} USD (CoinGecko public API)."
    except Exception as e:
        return f"Could not fetch price: {e}"


with gr.Blocks() as demo:
    gr.Markdown("# GAIA Unit 4 — Agent Evaluation Runner")
    gr.Markdown(
        """
**Instructions**

1. Duplicate this Space from the course template (or push this repo) and set **Secrets**: `HF_TOKEN` (read access to Inference).
2. Optional env vars: `GAIA_TEXT_MODEL`, `GAIA_ASR_MODEL`, `GAIA_VISION_MODEL`, `GAIA_API_URL`, `GAIA_USE_CACHE` (default **`0`** — answers are keyed by `task_id` **and** question text; set `1` only to speed re-runs).
3. Log in with Hugging Face below (username is used for the leaderboard).
4. Run **Evaluate & Submit** to answer all questions and post scores.

Attachment tasks download `GET /files/{task_id}` automatically when `file_name` is set.

---
**Crypto demo (optional):** unrelated to GAIA; quick BTC spot check.
        """
    )

    gr.LoginButton()

    with gr.Tab("GAIA evaluation"):
        run_button = gr.Button("Run Evaluation & Submit All Answers")
        status_output = gr.Textbox(
            label="Run Status / Submission Result", lines=6, interactive=False
        )
        results_table = gr.DataFrame(
            label="Questions and Agent Answers", wrap=True
        )
        run_button.click(
            fn=run_and_submit_all,
            outputs=[status_output, results_table],
        )

    with gr.Tab("Crypto intelligence (demo)"):
        gr.Markdown(
            "This tab does not affect GAIA scores. It demonstrates a simple public market data fetch."
        )
        cp_btn = gr.Button("Fetch BTC / USD")
        cp_out = gr.Textbox(label="Output", interactive=False)
        cp_btn.click(fn=crypto_btc_price, outputs=cp_out)

if __name__ == "__main__":
    print("\n" + "-" * 30 + " App Starting " + "-" * 30)
    space_host_startup = os.getenv("SPACE_HOST")
    space_id_startup = os.getenv("SPACE_ID")

    if space_host_startup:
        print(f"SPACE_HOST found: {space_host_startup}")
    else:
        print("SPACE_HOST not set (local run?).")

    if space_id_startup:
        print(f"SPACE_ID found: {space_id_startup}")
        print(f"Repo tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
    else:
        print("SPACE_ID not set (local run?).")

    print("-" * 62 + "\n")
    demo.launch(debug=True, share=False)