Update app.py

app.py

@@ -1,107 +1,213 @@
 import os
 import gradio as gr
 import requests
-import inspect
 import pandas as pd
+import time
+from typing import Optional, List, Dict
 
-# (Keep Constants as is)
-# --- Constants ---
+# Optional: import openai (pip install openai)
+import openai
+
+# Constants
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+# Default model - you can change to "gpt-4o" or "gpt-4.1" if available
+OPENAI_MODEL = os.getenv("OPENAI_MODEL", "gpt-4o")  # or "gpt-4.1"
+
+if not OPENAI_API_KEY:
+    print("WARNING: OPENAI_API_KEY not set. Set it in Space secrets before running.")
+
+openai.api_key = OPENAI_API_KEY
 
-# --- Basic Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-class BasicAgent:
-    def __init__(self):
-        print("BasicAgent initialized.")
-    def __call__(self, question: str) -> str:
-        print(f"Agent received question (first 50 chars): {question[:50]}...")
-        fixed_answer = "This is a default answer."
-        print(f"Agent returning fixed answer: {fixed_answer}")
-        return fixed_answer
-
-def run_and_submit_all( profile: gr.OAuthProfile | None):
+# -----------------------------
+# Agent implementation (OpenAI-based)
+# -----------------------------
+class OpenAIAgent:
     """
-    Fetches all questions, runs the BasicAgent on them, submits all answers,
-    and displays the results.
+    Minimal agent that uses OpenAI chat completion to answer each question.
+    It is tuned to return *only* the final answer (no extra commentary) so
+    that it matches the EXACT-MATCH submission requirement.
     """
-    # --- Determine HF Space Runtime URL and Repo URL ---
-    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
+
+    def __init__(self, model: str = OPENAI_MODEL, temperature: float = 0.0):
+        self.model = model
+        self.temperature = temperature
+
+    def _build_prompt_messages(self, question_text: str, file_summaries: Optional[List[str]] = None) -> List[Dict]:
+        """
+        Build messages for chat completion. We instruct the model to output
+        the answer ONLY (single-line), nothing else. No 'Final Answer' phrase.
+        """
+        system = (
+            "You are an assistant that MUST produce a single concise answer only. "
+            "When asked a question, respond with the exact answer text only — nothing else. "
+            "Do NOT include explanation, reasoning steps, or any extra punctuation beyond the answer. "
+            "If the question requires a short phrase or number, output that. "
+            "If you do not know, output 'I don't know'."
+        )
+        user_parts = [f"Question: {question_text}"]
+        if file_summaries:
+            # attach file summaries if provided
+            user_parts.append("File summaries (use these to answer):")
+            user_parts.extend(file_summaries)
+
+        user = "\n".join(user_parts)
+        return [
+            {"role": "system", "content": system},
+            {"role": "user", "content": user},
+        ]
+
+    def _call_openai(self, messages: List[Dict], max_tokens: int = 60) -> str:
+        """
+        Call OpenAI ChatCompletion API (supports gpt-4o / gpt-4.1). Return assistant text.
+        """
+        if not OPENAI_API_KEY:
+            raise RuntimeError("OPENAI_API_KEY not set in environment.")
+
+        try:
+            response = openai.ChatCompletion.create(
+                model=self.model,
+                messages=messages,
+                temperature=self.temperature,
+                max_tokens=max_tokens,
+                top_p=1.0,
+                n=1,
+            )
+            # Extract text (handles typical response structure)
+            text = ""
+            # openai returns choices list with message
+            choices = response.get("choices", [])
+            if choices and "message" in choices[0]:
+                text = choices[0]["message"].get("content", "")
+            else:
+                # fallback for older/newer SDK response shapes
+                text = response["choices"][0]["text"]
+            # trim
+            return text.strip()
+        except Exception as e:
+            # bubble up informative exception for logging
+            raise RuntimeError(f"OpenAI API error: {e}")
+
+    def summarize_file(self, file_url: str) -> Optional[str]:
+        """
+        Simple downloader + summarizer placeholder.
+        For text files, fetch content and truncate. For images or other binary files,
+        just return a placeholder note (could be extended).
+        """
+        try:
+            r = requests.get(file_url, timeout=10)
+            r.raise_for_status()
+            content_type = r.headers.get("Content-Type", "")
+            if "text" in content_type or file_url.lower().endswith((".txt", ".md", ".csv")):
+                text = r.text
+                # keep first 1000 chars to avoid huge prompts
+                summary = text[:1000].replace("\n", " ")
+                return f"[file content preview] {summary}"
+            else:
+                # For non-text file, just inform the model of the file name
+                return f"[file] downloaded from {file_url} (type: {content_type})"
+        except Exception as e:
+            print(f"Warning: Unable to fetch or summarize file {file_url}: {e}")
+            return None
+
+    def answer(self, question_text: str, files: Optional[List[str]] = None) -> str:
+        """
+        Main entry: prepare prompt, call model, and return answer string.
+        Ensures we strip quotes/newlines to produce a concise single-line answer.
+        """
+        file_summaries = []
+        if files:
+            for furl in files:
+                s = self.summarize_file(furl)
+                if s:
+                    file_summaries.append(s)
+
+        messages = self._build_prompt_messages(question_text, file_summaries if file_summaries else None)
+
+        raw = self._call_openai(messages, max_tokens=80)
+        # Post-process: keep single-line, strip surrounding quotes, remove trailing punctuation if it's just noise
+        ans = " ".join(raw.splitlines()).strip()
+        # remove wrapping quotes
+        if (ans.startswith('"') and ans.endswith('"')) or (ans.startswith("'") and ans.endswith("'")):
+            ans = ans[1:-1].strip()
+        # final safety: if empty, return "I don't know"
+        if not ans:
+            ans = "I don't know"
+        return ans
+
+
+# -----------------------------
+# Runner / UI glue (kept similar to original)
+# -----------------------------
+def run_and_submit_all(profile: gr.OAuthProfile | None):
+    """
+    Fetches all questions, runs the OpenAIAgent on them, submits all answers,
+    and returns status string and results DataFrame.
+    """
+    space_id = os.getenv("SPACE_ID")
 
     if profile:
-        username= f"{profile.username}"
-        print(f"User logged in: {username}")
+        username = f"{profile.username}"
     else:
-        print("User not logged in.")
         return "Please Login to Hugging Face with the button.", None
 
     api_url = DEFAULT_API_URL
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    # 1. Instantiate Agent ( modify this part to create your agent)
+    # instantiate agent
     try:
-        agent = BasicAgent()
+        agent = OpenAIAgent()
     except Exception as e:
-        print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
-    # In the case of an app running as a hugging Face space, this link points toward your codebase ( usefull for others so please keep it public)
-    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
-    print(agent_code)
 
-    # 2. Fetch Questions
-    print(f"Fetching questions from: {questions_url}")
+    # agent_code repo URL
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else ""
+
+    # fetch questions
     try:
-        response = requests.get(questions_url, timeout=15)
-        response.raise_for_status()
-        questions_data = response.json()
-        if not questions_data:
-             print("Fetched questions list is empty.")
-             return "Fetched questions list is empty or invalid format.", None
-        print(f"Fetched {len(questions_data)} questions.")
-    except requests.exceptions.RequestException as e:
-        print(f"Error fetching questions: {e}")
-        return f"Error fetching questions: {e}", None
-    except requests.exceptions.JSONDecodeError as e:
-         print(f"Error decoding JSON response from questions endpoint: {e}")
-         print(f"Response text: {response.text[:500]}")
-         return f"Error decoding server response for questions: {e}", None
+        resp = requests.get(questions_url, timeout=15)
+        resp.raise_for_status()
+        questions_data = resp.json()
     except Exception as e:
-        print(f"An unexpected error occurred fetching questions: {e}")
-        return f"An unexpected error occurred fetching questions: {e}", None
+        return f"Error fetching questions: {e}", None
+
+    if not questions_data:
+        return "No questions returned from server.", None
 
-    # 3. Run your Agent
     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")
+        files = item.get("files") or []
         if not task_id or question_text is None:
-            print(f"Skipping item with missing task_id or question: {item}")
             continue
+
         try:
-            submitted_answer = agent(question_text)
-            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})
+            ans = agent.answer(question_text, files)
         except Exception as e:
-             print(f"Error running agent on task {task_id}: {e}")
-             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
+            ans = "I don't know"
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
+        else:
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": ans})
+
+        answers_payload.append({"task_id": task_id, "submitted_answer": ans})
+
+        # small sleep to avoid rate limits
+        time.sleep(0.5)
 
     if not answers_payload:
-        print("Agent did not produce any answers to submit.")
-        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
+        return "Agent produced no answers.", pd.DataFrame(results_log)
 
-    # 4. Prepare Submission 
     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)
 
-    # 5. Submit
-    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
+    # submit
     try:
-        response = requests.post(submit_url, json=submission_data, timeout=60)
-        response.raise_for_status()
-        result_data = response.json()
+        r = requests.post(submit_url, json=submission_data, timeout=60)
+        r.raise_for_status()
+        result_data = r.json()
         final_status = (
             f"Submission Successful!\n"
             f"User: {result_data.get('username')}\n"
@@ -109,88 +215,37 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
             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
+        return final_status, pd.DataFrame(results_log)
     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 requests.exceptions.JSONDecodeError:
-            error_detail += f" Response: {e.response.text[:500]}"
-        status_message = f"Submission Failed: {error_detail}"
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
-    except requests.exceptions.Timeout:
-        status_message = "Submission Failed: The request timed out."
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
-    except requests.exceptions.RequestException as e:
-        status_message = f"Submission Failed: Network error - {e}"
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
+            text = e.response.text
+        except:
+            text = str(e)
+        return f"Submission failed: {text}", pd.DataFrame(results_log)
     except Exception as e:
-        status_message = f"An unexpected error occurred during submission: {e}"
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
+        return f"Submission failed: {e}", pd.DataFrame(results_log)
 
 
-# --- Build Gradio Interface using Blocks ---
+# -----------------------------
+# Build Gradio Interface
+# -----------------------------
 with gr.Blocks() as demo:
-    gr.Markdown("# Basic Agent Evaluation Runner")
+    gr.Markdown("# Basic Agent Evaluation Runner (OpenAI-based)")
+
     gr.Markdown(
         """
-        **Instructions:**
-
-        1.  Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ...
-        2.  Log in to your Hugging Face account using the button below. This uses your HF username for submission.
-        3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
-
-        ---
-        **Disclaimers:**
-        Once clicking on the "submit button, it can take quite some time ( this is the time for the agent to go through all the questions).
-        This space provides a basic setup and is intentionally sub-optimal to encourage you to develop your own, more robust solution. For instance for the delay process of the submit button, a solution could be to cache the answers and submit in a seperate action or even to answer the questions in async.
+        Instructions:
+        1. Add your OpenAI key as a secret named `OPENAI_API_KEY` in this Space.
+        2. Ensure requirements.txt contains `openai`.
+        3. Login, then click 'Run Evaluation & Submit All Answers'.
         """
     )
-
     gr.LoginButton()
-
     run_button = gr.Button("Run Evaluation & Submit All Answers")
-
     status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
-    # Removed max_rows=10 from DataFrame constructor
     results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
 
-    run_button.click(
-        fn=run_and_submit_all,
-        outputs=[status_output, results_table]
-    )
+    run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])
 
 if __name__ == "__main__":
-    print("\n" + "-"*30 + " App Starting " + "-"*30)
-    # Check for SPACE_HOST and SPACE_ID at startup for information
-    space_host_startup = os.getenv("SPACE_HOST")
-    space_id_startup = os.getenv("SPACE_ID") # Get SPACE_ID at startup
-
-    if space_host_startup:
-        print(f"✅ SPACE_HOST found: {space_host_startup}")
-        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
-    else:
-        print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
-
-    if space_id_startup: # Print repo URLs if SPACE_ID is found
-        print(f"✅ SPACE_ID found: {space_id_startup}")
-        print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
-        print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
-    else:
-        print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
-
-    print("-"*(60 + len(" App Starting ")) + "\n")
-
-    print("Launching Gradio Interface for Basic Agent Evaluation...")
-    demo.launch(debug=True, share=False)
+    demo.launch(debug=True, share=False)