try 4

app.py

@@ -1,211 +1,166 @@
-import re, io, subprocess, requests, pandas as pd, gradio as gr
-from smolagents import CodeAgent, InferenceClientModel, DuckDuckGoSearchTool, VisitWebpageTool, PythonInterpreterTool
+import os
+import gradio as gr
+import requests
+import pandas as pd
 
-SPACE_ID = "marjanns/Final_Assignment_Template"
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-
-def postprocess_exact(s):
-    if s is None:
-        return ""
-    s = str(s).strip()
-    if (s.startswith('"') and s.endswith('"')) or (s.startswith("'") and s.endswith("'")):
-        s = s[1:-1].strip()
-    s = re.sub(r"\s+", " ", s)
-    s = re.sub(r"\.(\s*)$", "", s)
-    return s
-
-def fetch_files(task_id):
-    try:
-        r = requests.get(f"{DEFAULT_API_URL}/files/{task_id}", timeout=30)
-        r.raise_for_status()
-        data = r.json()
-        if isinstance(data, dict) and "files" in data:
-            return data["files"]
-        if isinstance(data, dict) and "file_url" in data:
-            return [data]
-        return []
-    except Exception:
-        return []
-
-def solve_reverse_sentence(q):
-    if ".rewsna" in q:
-        try:
-            m = re.search(r'"(.*)"', q, re.S)
-            src = m.group(1) if m else q
-            rev = src[::-1]
-            if "opposite of the word 'left'" in rev or 'opposite of the word "left"' in rev:
-                return "right"
-        except Exception:
-            pass
-    return None
-
-def solve_vegetables(q):
-    if "I'm making a grocery list" in q and "alphabetize the list of vegetables" in q:
-        m = re.search(r"list I have so far:\s*(.*?)\s*I need to make headings", q, re.I | re.S)
-        if not m:
-            return ""
-        items = [x.strip().lower() for x in re.split(r",\s*", m.group(1))]
-        botanical_fruits = {"tomato","zucchini","courgette","bell pepper","pepper","cucumber","eggplant","aubergine","green beans","beans","corn","maize","rice","plums","peanuts","acorns","whole allspice","allspice","coffee","whole bean coffee"}
-        non_produce = {"milk","eggs","flour","oreos","whole allspice","whole bean coffee","peanuts","acorns","plums","rice"}
-        veg = set()
-        for it in items:
-            if it in botanical_fruits or it in non_produce:
-                continue
-            if it in {"fresh basil","basil"}:
-                veg.add("fresh basil")
-            elif it in {"sweet potato","sweet potatoes"}:
-                veg.add("sweet potatoes")
-            elif it in {"broccoli","celery","lettuce"}:
-                veg.add(it)
-        return ", ".join(sorted(veg))
-    return None
-
-def parse_md_table_block(q):
-    m = re.search(r"\|\*\|.*?\n(\|[-|]+\n)?(.*?)\n\n", q, re.S | re.I)
-    return m.group(0) if m else None
-
-def solve_non_commutative_subset(q):
-    if "define * on the set S" in q and "not commutative" in q:
-        block = parse_md_table_block(q)
-        if not block:
-            return ""
-        lines = [ln.strip() for ln in block.strip().splitlines() if ln.strip().startswith("|")]
-        header = [h.strip() for h in lines[0].strip("|").split("|")]
-        elems = [e.strip() for e in header[1:]]
-        tbl = {}
-        for row in lines[2:]:
-            cells = [c.strip() for c in row.strip("|").split("|")]
-            r = cells[0]
-            tbl[r] = {elems[i]: cells[i+1] for i in range(len(elems))}
-        bad = set()
-        for x in elems:
-            for y in elems:
-                if tbl[x][y] != tbl[y][x]:
-                    bad.add(x); bad.add(y)
-        return ", ".join(sorted(bad))
-    return None
+SPACE_ID = "marjanns/Final_Assignment_Template"
 
 class BasicAgent:
     def __init__(self):
-        self.model = InferenceClientModel(model_id="Qwen/Qwen2.5-7B-Instruct")
-        self.agent = CodeAgent(
-            model=self.model,
-            tools=[DuckDuckGoSearchTool(), VisitWebpageTool(), PythonInterpreterTool()],
-            add_base_tools=True,
-            system_prompt="Answer GAIA L1 questions using tools. Output only the final answer string.",
-            stream_outputs=False,
-        )
+        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 solve_with_files(self, question, task_id):
-        files = fetch_files(task_id)
-        for f in files:
-            url = f.get("file_url") or f.get("url") or ""
-            name = (f.get("filename") or f.get("name") or "").lower()
-            if not url:
-                continue
-            try:
-                data = requests.get(url, timeout=60).content
-            except Exception:
-                continue
-            if name.endswith((".xlsx",".xls")):
-                try:
-                    df = pd.read_excel(io.BytesIO(data))
-                    if "Category" in df.columns:
-                        food = df[df["Category"].astype(str).str.lower().eq("food")]
-                        if "Sales" in food.columns:
-                            total = float(food["Sales"].sum())
-                        else:
-                            total = float(food.select_dtypes(include="number").sum().sum())
-                        return f"{total:.2f}"
-                    scols = df.select_dtypes(include="number")
-                    total = float(scols.sum().sum())
-                    return f"{total:.2f}"
-                except Exception:
-                    pass
-            if name.endswith(".py"):
-                try:
-                    p = subprocess.run(["python","-"], input=data, capture_output=True, text=True, timeout=10)
-                    out = p.stdout.strip()
-                    if out:
-                        return postprocess_exact(out.splitlines()[-1])
-                except Exception:
-                    pass
-            if name.endswith((".mp3",".wav",".m4a",".flac")):
-                return ""
-        return None
-
-    def __call__(self, question, task_id=None):
-        s = solve_reverse_sentence(question)
-        if s is not None:
-            return s
-        s = solve_vegetables(question)
-        if s is not None:
-            return s
-        s = solve_non_commutative_subset(question)
-        if s is not None:
-            return s
-        if task_id is not None:
-            s = self.solve_with_files(question, task_id)
-            if s is not None:
-                return s
-        out = self.agent.run("Return only the final answer string.\nQuestion: " + question)
-        return postprocess_exact(out)
-
-def run_and_submit_all(evt=None, *, request: gr.Request):
-    profile = getattr(request, "user", None)
-    if not profile:
+def run_and_submit_all(profile: gr.OAuthProfile | None):
+    space_id = SPACE_ID
+    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
-    username = f"{profile.username}".strip()
+
+    api_url = DEFAULT_API_URL
+    questions_url = f"{api_url}/questions"
+    submit_url = f"{api_url}/submit"
+
     try:
-        qresp = requests.get(f"{DEFAULT_API_URL}/questions", timeout=30)
-        qresp.raise_for_status()
-        questions = qresp.json()
-        if not isinstance(questions, list) or not questions:
-            return "Fetched questions list is empty or invalid.", None
+        agent = BasicAgent()
     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=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
-    agent = BasicAgent()
-    agent_code = f"https://huggingface.co/spaces/{SPACE_ID}/tree/main"
-    results_log, answers_payload = [], []
-    for item in questions:
-        tid = item.get("task_id")
-        q = item.get("question")
-        if not tid or q is 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
+    except Exception as e:
+        print(f"An unexpected error occurred fetching questions: {e}")
+        return f"An unexpected error occurred fetching questions: {e}", None
+
+    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")
+        if not task_id or question_text is None:
+            print(f"Skipping item with missing task_id or question: {item}")
             continue
         try:
-            ans = agent(q, tid)
+            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
+            })
         except Exception as e:
-            ans = f"AGENT ERROR: {e}"
-        answers_payload.append({"task_id": tid, "submitted_answer": ans})
-        results_log.append({"Task ID": tid, "Question": q, "Submitted Answer": ans})
+            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}"
+            })
+
     if not answers_payload:
-        return "No answers produced.", pd.DataFrame(results_log)
-    payload = {"username": username, "agent_code": agent_code, "answers": answers_payload}
+        print("Agent did not produce any answers to submit.")
+        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:
-        sresp = requests.post(f"{DEFAULT_API_URL}/submit", json=payload, timeout=120)
-        sresp.raise_for_status()
-        res = sresp.json()
-        msg = f"Submission Successful!\nUser: {res.get('username', username)}\nOverall Score: {res.get('score','N/A')}% ({res.get('correct_count','?')}/{res.get('total_attempted','?')} correct)\nMessage: {res.get('message','') or ''}"
-        return msg, pd.DataFrame(results_log)
+        response = requests.post(submit_url, json=submission_data, timeout=60)
+        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:
-            detail = e.response.json().get("detail", e.response.text)
-        except Exception:
-            detail = e.response.text
-        return f"Submission Failed: HTTP {e.response.status_code}. Detail: {detail[:500]}", pd.DataFrame(results_log)
+            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:
-        return "Submission Failed: The request timed out.", pd.DataFrame(results_log)
+        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
     except Exception as e:
-        return f"Submission Failed: {e}", pd.DataFrame(results_log)
+        status_message = f"An unexpected error occurred during submission: {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
 
 with gr.Blocks() as demo:
     gr.Markdown("# Basic Agent Evaluation Runner")
-    gr.Markdown("1. Ensure requirements are installed.\n2. Log in.\n3. Click the button to run and submit.\nScoring is EXACT MATCH: output only the final answer string.")
-    gr.LoginButton()
+    gr.Markdown(
+        """
+**Instructions:**
+1) Clone this space, then modify the code to define your agent's logic.
+2) Log in to your Hugging Face account using the button below.
+3) Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
+        """
+    )
+
+    login = gr.LoginButton()
+    user_state = gr.State()
+    login.click(lambda p: p, inputs=login, outputs=user_state)
+
     run_button = gr.Button("Run Evaluation & Submit All Answers")
-    status_output = gr.Textbox(label="Run Status / Submission Result", lines=6, interactive=False)
+    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, outputs=[status_output, results_table])
+
+    run_button.click(fn=run_and_submit_all, inputs=[user_state], outputs=[status_output, results_table])
 
 if __name__ == "__main__":
+    print("\n" + "-"*30 + " App Starting " + "-"*30)
+    space_host_startup = os.getenv("SPACE_HOST")
+    print(f"Repo URL: https://huggingface.co/spaces/{SPACE_ID}")
+    print(f"Repo Tree URL: https://huggingface.co/spaces/{SPACE_ID}/tree/main")
+    if space_host_startup:
+        print(f"Runtime URL should be: https://{space_host_startup}.hf.space")
+    else:
+        print("SPACE_HOST not found (running locally?).")
+    print("-"*(60 + len(" App Starting ")) + "\n")
     demo.launch(debug=True, share=False)