Update app.py

app.py

@@ -1,208 +1,209 @@
+import os
+import gradio as gr
 import requests
+import inspect
 import pandas as pd
 import re
-
+import json
 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
-
 
+# --- Enhanced BasicAgent (local model version) ---
 class BasicAgent:
     """
     Loads and runs a small LLM *locally* inside the Hugging Face Space
-    instead of calling the Hugging Face Inference API (which might be blocked).
+    instead of calling the Hugging Face Inference API (which is blocked).
     """
     def __init__(self):
-
+        # ✅ Small model to fit free Spaces — change to another instruct model if needed
         model_id = "HuggingFaceTB/SmolLM2-1.7B-Instruct"
         print(f"🚀 Loading model locally: {model_id}")
         
-
+        # Load tokenizer and model
         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:
-
+        """Post-process the model output to a short, exact 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"🧠 Agent received question: {question[:120]}...")
-
-
+        
+        # Simple concise prompt
         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)
-
-
+        
+        # Generate
         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"💡 Agent raw: '{raw_answer[:80]}' → clean: '{clean_ans}'")
         return clean_ans
 
-def fetch_questions_from_docs() -> list[dict]:
-
-
-
-
-
-
-
-
-
+# --- Test Questions & Expected Answers ---
+QUESTIONS_AND_ANSWERS = [
+    {"question": "What is the capital of France?", "expected": "Paris"},
+    {"question": "What is 5 + 7?", "expected": "12"},
+    {"question": "In what year did World War II end?", "expected": "1945"},
+    {"question": "What is the largest planet in our solar system?", "expected": "Jupiter"},
+    {"question": "Who wrote 'Romeo and Juliet'?", "expected": "Shakespeare"},
+]
 
+# --- Submission Function ---
+def submit_answers(answers: list, token: str) -> dict:
     """
-    Try to fetch question & expected answer pairs from the API docs / spec.
-    Returns a list of dicts: {"question": ..., "expected": ...} if available.
+    Submit answers to the scoring API.
     """
-    # Try to fetch OpenAPI spec
-    try:
-        resp = requests.get(f"{DEFAULT_API_URL}/openapi.json", timeout=30)
-        resp.raise_for_status()
-        spec = resp.json()
-    except Exception as e:
-        print(f"⚠️ Failed to fetch OpenAPI spec: {e}")
-        return []
-    
-    # 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:
         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",
+            json=payload,
+            headers=headers,
+            timeout=60,
+        )
+        resp.raise_for_status()
+        return resp.json()
     except Exception as e:
         return {"success": False, "message": str(e)}
 
-
-def run_and_submit_all(token: str):
-    if not token:
-        return "❌ You must provide a valid Hugging Face token.", pd.DataFrame()
+# --- Main Run Function ---
+def run_and_submit_all(profile: gr.OAuthProfile | None = None):
+    if not profile:
+        return "❌ You must log in first.", pd.DataFrame()
     
-    questions = fetch_questions_from_docs()
-    if not questions:
-        # fallback to some default or error
-        return "❌ Could not fetch questions from docs/spec.", pd.DataFrame()
+    # Try to get the token using multiple approaches
+    token = None
+    # Try direct attributes
+    if hasattr(profile, '_oauth_token'):
+        token = profile._oauth_token
+    elif hasattr(profile, 'oauth_token'):
+        token_obj = profile.oauth_token
+        if hasattr(token_obj, 'access_token'):
+            token = token_obj.access_token
+        elif isinstance(token_obj, dict) and 'access_token' in token_obj:
+            token = token_obj['access_token']
+        else:
+            token = token_obj
     
-    agent = None
+    if not token:
+        # Debug: print what attributes the profile actually has
+        attrs = [attr for attr in dir(profile) if not attr.startswith('__')]
+        print(f"🔍 Profile attributes: {attrs}")
+        return f"❌ No token found. Profile type: {type(profile).__name__}. Available attributes: {', '.join(attrs[:10])}", pd.DataFrame()
+    
+    # Instantiate the agent
     try:
         agent = BasicAgent()
     except Exception as e:
         return f"❌ Error instantiating agent: {e}", pd.DataFrame()
     
-
+    # Collect answers
     results = []
-    for qa in questions:
-        q = qa.get("question", "")
-        expected = qa.get("expected", "")
+    for qa in QUESTIONS_AND_ANSWERS:
+        q = qa["question"]
+        expected = qa["expected"]
         try:
             answer = agent(q)
         except Exception as e:
             answer = f"[Error: {e}]"
         results.append({"question": q, "answer": answer, "expected": expected})
     
-
+    # Build DataFrame
     df = pd.DataFrame(results)
-
-
+    
+    # Submit
     answers_list = [r["answer"] for r in results]
     submission_result = submit_answers(answers_list, token)
     
+    if submission_result.get("success"):
+        msg = submission_result.get("message", "✅ Submission successful")
+        return f"✅ {msg}", df
+    else:
         msg = submission_result.get("message", "Unknown error")
         return f"❌ Submission failed: {msg}", df
 
+# --- Gradio Interface ---
+with gr.Blocks() as demo:
+    gr.Markdown("# Basic Agent Evaluation Runner")
+    gr.Markdown(
+        """
+        **Instructions:**
+        1. Log in to your Hugging Face account.
+        2. Click 'Run Evaluation & Submit All Answers'.
+        ---
+        The agent now runs *locally* inside the Space instead of using the API.
+        """
+    )
+    login_button = gr.LoginButton()
+    run_button = gr.Button("Run Evaluation & Submit All Answers")
+    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
+    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
+    
+    run_button.click(fn=run_and_submit_all, inputs=[login_button], outputs=[status_output, results_table])
 
-
+# --- Launch ---
 if __name__ == "__main__":
-    print("\n" + "-" * 30 + " CLI Mode " + "-" * 30 + "\n")
-
+    print("\n" + "-" * 30 + " App Starting " + "-" * 30)
+    
     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.")
-
+        print("ℹ️  SPACE_HOST not found (running locally?).")
+    
     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")
+        print("ℹ️  SPACE_ID not found (running locally?).")
     
-    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("-" * (60 + len(" App Starting ")) + "\n")
+    print("Launching Gradio Interface for Basic Agent Evaluation...")
+    demo.launch(debug=True, share=False)