Update app.py

app.py

@@ -1,164 +1,208 @@
-import os
 import requests
 import pandas as pd
 import re
+
 import textwrap
 from transformers import AutoTokenizer, AutoModelForCausalLM
 import torch
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+DOCS_URL = f"{DEFAULT_API_URL}/docs"  # or perhaps /openapi.json if exposed
+
 
-# --- Local LLM Agent ---
 class BasicAgent:
     """
-    Loads and runs a small LLM *locally* instead of using the remote API.
-    The model answers concisely (number, word, or phrase only).
+    Loads and runs a small LLM *locally* inside the Hugging Face Space
+    instead of calling the Hugging Face Inference API (which might be blocked).
     """
     def __init__(self):
+
         model_id = "HuggingFaceTB/SmolLM2-1.7B-Instruct"
         print(f"🚀 Loading model locally: {model_id}")
         
+
         self.tokenizer = AutoTokenizer.from_pretrained(model_id)
         self.model = AutoModelForCausalLM.from_pretrained(
             model_id,
-            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-            device_map="auto",
-        )
         print("✅ Local model ready.")
 
     def _clean(self, raw: str) -> str:
-        """Cleans raw model output to return just the concise final value."""
+
         txt = raw.strip()
         lines = [l.strip() for l in txt.splitlines() if l.strip()]
         if lines:
-            txt = lines[-1]
-        txt = re.sub(r"^(final answer|answer|prediction)\s*[:\-]\s*", "", txt, flags=re.I)
-        txt = txt.strip("`'\" \t\n\r")
-        txt = re.sub(r"[ \t]*[.;,:-]+$", "", txt)
-        return txt[:200]
 
     def __call__(self, question: str) -> str:
-        print(f"🧠 Question: {question[:100]}...")
+        print(f"🧠 Agent received question: {question[:120]}...")
+
+
         prompt = textwrap.dedent(f"""
         You must answer the question with a single, concise value
         (number, word, date, or short phrase) and nothing else.
-
         Question: {question}
         Final answer:
         """).strip()
+
         inputs = self.tokenizer(prompt, return_tensors="pt").to(self.model.device)
+
+
         with torch.no_grad():
             outputs = self.model.generate(
                 **inputs,
-                max_new_tokens=50,
-                temperature=0.7,
                 do_sample=True,
                 pad_token_id=self.tokenizer.eos_token_id,
             )
+
         generated_ids = outputs[0][inputs["input_ids"].shape[1]:]
         raw_answer = self.tokenizer.decode(generated_ids, skip_special_tokens=True)
         clean_ans = self._clean(raw_answer)
-        print(f"💡 Cleaned answer: {clean_ans}")
+        print(f"💡 Agent raw: '{raw_answer[:80]}' → clean: '{clean_ans}'")
         return clean_ans
 
+def fetch_questions_from_docs() -> list[dict]:
+
+
+
+
+
+
+
+
+
 
-# --- Fetch Questions from API ---
-def fetch_questions() -> list[dict]:
     """
-    Calls the /questions endpoint to retrieve evaluation questions.
-    Returns a list of dicts with keys: task_id, question.
+    Try to fetch question & expected answer pairs from the API docs / spec.
+    Returns a list of dicts: {"question": ..., "expected": ...} if available.
     """
+    # Try to fetch OpenAPI spec
     try:
-        resp = requests.get(f"{DEFAULT_API_URL}/questions", timeout=60)
+        resp = requests.get(f"{DEFAULT_API_URL}/openapi.json", timeout=30)
         resp.raise_for_status()
-        data = resp.json()
-        if isinstance(data, list):
-            print(f"✅ Retrieved {len(data)} questions from API.")
-            return data
-        else:
-            print("⚠️ Unexpected response format from /questions.")
-            return []
+        spec = resp.json()
     except Exception as e:
-        print(f"❌ Failed to fetch questions: {e}")
+        print(f"⚠️ Failed to fetch OpenAPI spec: {e}")
         return []
-
-
-# --- Submit Answers ---
-def submit_answers(answers: list[dict], username: str, code_link: str, token: str) -> dict:
-    """
-    Submit answers to the scoring API.
-    answers = [{"task_id": ..., "submitted_answer": ...}]
-    """
-    payload = {
-        "username": username,
-        "agent_code": code_link,
-        "answers": answers,
-    }
-
-    headers = {"Authorization": f"Bearer {token}"} if token else {}
+    
+    # Example: maybe there's a component schema "QuestionAnswer" or an endpoint returning the list
+    questions = []
+    # This part depends heavily on how the spec is structured.
+    # For instance, spec["components"]["schemas"]["QuestionAnswer"]["example"] might exist.
+    comp = spec.get("components", {}).get("schemas", {})
+    qa_schema = comp.get("QuestionAnswer")
+    if qa_schema:
+        example = qa_schema.get("example") or qa_schema.get("examples")
+        if example:
+            # If example is a list or single object
+            if isinstance(example, list):
+                for ex in example:
+                    questions.append({"question": ex.get("question", ""), "expected": ex.get("expected", "")})
+            elif isinstance(example, dict):
+                # maybe contains multiple
+                # Or maybe there's a property which is list
+                if "questions" in example and isinstance(example["questions"], list):
+                    for ex in example["questions"]:
+                        questions.append({"question": ex.get("question", ""), "expected": ex.get("expected", "")})
+                else:
+                    questions.append({"question": example.get("question", ""), "expected": example.get("expected", "")})
+    # Fallback: look for paths that look like "/questions" or similar
+    for path, methods in spec.get("paths", {}).items():
+        if "questions" in path.lower():
+            get_op = methods.get("get")
+            if get_op and "responses" in get_op:
+                # attempt to fetch via the actual endpoint
+                try:
+                    resp2 = requests.get(DEFAULT_API_URL + path, timeout=30)
+                    resp2.raise_for_status()
+                    data = resp2.json()
+                    # assume list of {question, expected}
+                    if isinstance(data, list):
+                        for q in data:
+                            questions.append({"question": q.get("question",""), "expected": q.get("expected","")})
+                except Exception as e:
+                    print(f"⚠️ Failed to fetch questions from path {path}: {e}")
+    return questions
+
+def submit_answers(answers: list, token: str) -> dict:
     try:
-        resp = requests.post(f"{DEFAULT_API_URL}/submit", json=payload, headers=headers, timeout=60)
-        resp.raise_for_status()
-        print("✅ Submission successful!")
-        return resp.json()
+        space_host = os.getenv("SPACE_HOST", "")
+        space_id = os.getenv("SPACE_ID", "")
+
+        payload = {
+            "answers": answers,
+            "space_host": space_host,
+            "space_id": space_id,
+        }
+
+        headers = {"Authorization": f"Bearer {token}"}
+        resp = requests.post(
+            f"{DEFAULT_API_URL}/submit",
     except Exception as e:
         return {"success": False, "message": str(e)}
 
 
-# --- Run & Submit ---
-def run_and_submit_all(username: str, code_link: str, token: str):
-    if not username or not code_link or not token:
-        return "❌ Missing username, code link, or token.", pd.DataFrame()
-
-    questions = fetch_questions()
+def run_and_submit_all(token: str):
+    if not token:
+        return "❌ You must provide a valid Hugging Face token.", pd.DataFrame()
+    
+    questions = fetch_questions_from_docs()
     if not questions:
-        return "❌ Could not fetch questions from API.", pd.DataFrame()
-
-    # Initialize model
+        # fallback to some default or error
+        return "❌ Could not fetch questions from docs/spec.", pd.DataFrame()
+    
+    agent = None
     try:
         agent = BasicAgent()
     except Exception as e:
-        return f"❌ Failed to load model: {e}", pd.DataFrame()
+        return f"❌ Error instantiating agent: {e}", pd.DataFrame()
+    
 
-    # Run through all questions
     results = []
-    for q in questions:
-        task_id = q.get("task_id")
-        question_text = q.get("question", "")
+    for qa in questions:
+        q = qa.get("question", "")
+        expected = qa.get("expected", "")
         try:
-            answer = agent(question_text)
+            answer = agent(q)
         except Exception as e:
             answer = f"[Error: {e}]"
-        results.append({"task_id": task_id, "question": question_text, "submitted_answer": answer})
+        results.append({"question": q, "answer": answer, "expected": expected})
+    
 
     df = pd.DataFrame(results)
 
-    # Prepare submission payload
-    answers_payload = [{"task_id": r["task_id"], "submitted_answer": r["submitted_answer"]} for r in results]
 
-    # Submit
-    result = submit_answers(answers_payload, username, code_link, token)
-    success = result.get("success", False)
-    message = result.get("message", "No response message.")
+    answers_list = [r["answer"] for r in results]
+    submission_result = submit_answers(answers_list, token)
+    
+        msg = submission_result.get("message", "Unknown error")
+        return f"❌ Submission failed: {msg}", df
 
-    if success:
-        return f"✅ Submission successful: {message}", df
-    else:
-        return f"❌ Submission failed: {message}", df
 
 
-# --- CLI Entry Point ---
 if __name__ == "__main__":
-    print("\n" + "-" * 30 + " CLI MODE " + "-" * 30 + "\n")
-    token = os.getenv("HF_TOKEN") or input("🔑 Enter your Hugging Face token: ").strip()
-    username = os.getenv("HF_USERNAME") or input("👤 Enter your Hugging Face username: ").strip()
-    code_link = os.getenv("CODE_LINK") or input("🔗 Enter your Hugging Face Space repo link (.../tree/main): ").strip()
+    print("\n" + "-" * 30 + " CLI Mode " + "-" * 30 + "\n")
 
-    print("\n⚙️ Running agent evaluation and submission...\n")
-    status, df = run_and_submit_all(username, code_link, token)
+    space_host = os.getenv("SPACE_HOST")
+    space_id = os.getenv("SPACE_ID")
+
+    if space_host:
+        print(f"✅ SPACE_HOST found: {space_host}")
+        print(f"   Runtime URL should be: https://{space_host}.hf.space")
+    else:
+        print("ℹ️  SPACE_HOST not found.")
+
+    if space_id:
+        print(f"✅ SPACE_ID found: {space_id}")
+        print(f"   Repo URL: https://huggingface.co/spaces/{space_id}")
+        print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id}/tree/main")
+    else:
+        print("ℹ️  SPACE_ID not found.")
+
+    print("-" * (60 + len(" CLI Mode ")) + "\n")
+    
+    token = os.getenv("HF_TOKEN") or input("🔑 Enter your Hugging Face token: ").strip()
+    status, df = run_and_submit_all(token)
 
     print("\n" + "=" * 80)
     print(status)
-    print("=" * 80)
-    print(df)
+    print("=" * 80)