previous codes

app.py

@@ -1,206 +1,64 @@
-import os, io, re, json, subprocess, requests, pandas as pd, gradio as gr
-from smolagents import CodeAgent, InferenceClientModel, 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: str | None) -> str:
-    s = "" if s is None else str(s)
-    s = 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).strip()
-    s = re.sub(r"\.(\s*)$", "", s)
-    return s
-
-def fetch_files(task_id: str):
-    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: str) -> str | None:
-    if ".rewsna" in q:
-        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"
-    return None
-
-def solve_non_commutative_subset(q: str) -> str | None:
-    if "define * on the set S" in q and "not commutative" in q:
-        lines = [ln.strip() for ln in q.splitlines() if ln.strip().startswith("|")]
-        if not lines:
-            return ""
-        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("|")]
-            if not cells or len(cells) < len(elems) + 1:
-                continue
-            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:
-                try:
-                    if tbl[x][y] != tbl[y][x]:
-                        bad.add(x); bad.add(y)
-                except Exception:
-                    pass
-        return ", ".join(sorted(bad)) if bad else ""
-    return None
-
-def solve_vegetables(q: str) -> str | None:
-    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 solve_with_files(task_id: str) -> str | None:
-    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 or "").strip()
-                if out:
-                    return postprocess_exact(out.splitlines()[-1])
-            except Exception:
-                pass
-        if name.endswith((".mp3",".wav",".m4a",".flac",".png",".jpg",".jpeg",".gif",".webp",".pdf",".txt",".csv",".json")):
-            return ""
-    return None
-
-class QwenAgent:
-    def __init__(self):
-        self.model = InferenceClientModel(model_id="Qwen/Qwen2.5-7B-Instruct")
-        self.agent = CodeAgent(
-            model=self.model,
-            tools=[PythonInterpreterTool()],
-            add_base_tools=False,
-            system_prompt=(
-                "You solve short questions. If you are unsure or need web/audio/image access you cannot use, "
-                "return an empty string. Otherwise return ONLY the final answer string—no extra words."
-            ),
-            stream_outputs=False,
-        )
-
-    def run(self, question: str) -> str:
-        try:
-            out = self.agent.run("Return only the final answer string.\nQuestion: " + question)
-            return postprocess_exact(out)
-        except Exception as e:
-            return ""
+SPACE_ID = "marjanns/Final_Assignment_Template"
 
 class BasicAgent:
     def __init__(self):
-        self.llm_agent = QwenAgent()
-
-    def __call__(self, question: str, task_id: str | None = None) -> str:
-        for solver in (solve_reverse_sentence, solve_non_commutative_subset, solve_vegetables):
-            s = solver(question)
-            if s is not None:
-                return s
-        if task_id:
-            s = solve_with_files(task_id)
-            if s is not None:
-                return s
-        return self.llm_agent.run(question)
+        print("BasicAgent initialized.")
+    def __call__(self, question: str) -> str:
+        print(f"Agent received question (first 50 chars): {question[:50]}...")
+        return "This is a default answer."
 
 def _username_from_profile(p):
     if p is None:
-        return ""
+        return None
+    # object with attribute
     u = getattr(p, "username", None)
     if u:
         return str(u)
+    # dict-style
     if isinstance(p, dict):
         return str(p.get("username") or "")
-    return ""
-
-def store_profile_as_dict(p):
-    u = _username_from_profile(p)
-    msg = f"✅ Logged in as **{u}**" if u else "❌ Not logged in"
-    return ({"username": u} if u else None), msg
+    return None
 
-def run_and_submit_all(profile_dict, evt=None, username_fallback=""):
-    username = (profile_dict or {}).get("username", "").strip() or username_fallback.strip()
+def run_and_submit_all(profile, evt=None):
+    space_id = SPACE_ID
+    username = _username_from_profile(profile)
     if not username:
-        return "Please Login to Hugging Face or type a username.", None
+        return "Please Login to Hugging Face with the button.", None
 
-    questions_url = f"{DEFAULT_API_URL}/questions"
-    submit_url = f"{DEFAULT_API_URL}/submit"
-    agent_code = f"https://huggingface.co/spaces/{SPACE_ID}/tree/main"
+    api_url = DEFAULT_API_URL
+    questions_url = f"{api_url}/questions"
+    submit_url = f"{api_url}/submit"
 
     try:
-        r = requests.get(questions_url, timeout=20)
-        r.raise_for_status()
-        questions = r.json()
-        if not isinstance(questions, list) or not questions:
+        agent = BasicAgent()
+    except Exception as e:
+        return f"Error initializing agent: {e}", None
+
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+
+    try:
+        response = requests.get(questions_url, timeout=15)
+        response.raise_for_status()
+        questions_data = response.json()
+        if not questions_data:
             return "Fetched questions list is empty or invalid format.", None
     except Exception as e:
         return f"Error fetching questions: {e}", None
 
-    agent = BasicAgent()
     results_log, answers_payload = [], []
-    for item in questions:
+    for item in questions_data:
         tid = item.get("task_id")
         q = item.get("question")
         if not tid or q is None:
             continue
         try:
-            ans = agent(q, tid)
+            ans = agent(q)
         except Exception as e:
             ans = f"AGENT ERROR: {e}"
         answers_payload.append({"task_id": tid, "submitted_answer": ans})
@@ -209,19 +67,19 @@ def run_and_submit_all(profile_dict, evt=None, username_fallback=""):
     if not answers_payload:
         return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
 
-    payload = {"username": username, "agent_code": agent_code, "answers": answers_payload}
+    submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
     try:
-        sresp = requests.post(f"{DEFAULT_API_URL}/submit", json=payload, timeout=120)
-        sresp.raise_for_status()
-        res = sresp.json()
-        msg = (
+        resp = requests.post(submit_url, json=submission_data, timeout=60)
+        resp.raise_for_status()
+        data = resp.json()
+        status = (
             "Submission Successful!\n"
-            f"User: {res.get('username', username)}\n"
-            f"Overall Score: {res.get('score','N/A')}% "
-            f"({res.get('correct_count','?')}/{res.get('total_attempted','?')} correct)\n"
-            f"Message: {res.get('message','') or ''}"
+            f"User: {data.get('username')}\n"
+            f"Overall Score: {data.get('score','N/A')}% "
+            f"({data.get('correct_count','?')}/{data.get('total_attempted','?')} correct)\n"
+            f"Message: {data.get('message','No message received.')}"
         )
-        return msg, pd.DataFrame(results_log)
+        return status, pd.DataFrame(results_log)
     except requests.exceptions.HTTPError as e:
         try:
             detail = e.response.json().get("detail", e.response.text)
@@ -233,38 +91,25 @@ def run_and_submit_all(profile_dict, evt=None, username_fallback=""):
     except Exception as e:
         return f"Submission Failed: {e}", pd.DataFrame(results_log)
 
-def test_single(question_text, task_id):
-    agent = BasicAgent()
-    try:
-        return agent(question_text, task_id or None)
-    except Exception as e:
-        return f"AGENT ERROR: {e}"
-
 with gr.Blocks() as demo:
-    gr.Markdown("# Basic Agent Evaluation Runner — Qwen on Hugging Face (no OpenAI/Groq keys)")
-    gr.Markdown("Log in **or** type your HF username. Use **Quick Test** to try one question. Then submit all.")
+    gr.Markdown("# Basic Agent Evaluation Runner")
+    gr.Markdown("Click **Log in with Hugging Face** first. After you see your username below, press **Run**.")
 
     login = gr.LoginButton()
     user_state = gr.State()
     whoami = gr.Markdown()
-    login.click(store_profile_as_dict, inputs=login, outputs=[user_state, whoami])
 
-    with gr.Row():
-        username_box = gr.Textbox(label="HF Username (fallback if login fails)", placeholder="your-username")
+    def store_and_echo(p):
+        u = _username_from_profile(p) or "(not logged in)"
+        return p, f"✅ Logged in as **{u}**" if u and u != "(not logged in)" else "❌ Not logged in"
 
-    gr.Markdown("### Quick Test")
-    with gr.Row():
-        q_inp = gr.Textbox(label="Question", lines=4)
-        tid_inp = gr.Textbox(label="Task ID (optional)")
-    test_btn = gr.Button("Run Quick Test")
-    test_out = gr.Textbox(label="Agent Answer", lines=3, interactive=False)
-    test_btn.click(fn=test_single, inputs=[q_inp, tid_inp], outputs=test_out)
+    login.click(store_and_echo, inputs=login, outputs=[user_state, whoami])
 
-    gr.Markdown("---")
     run_button = gr.Button("Run Evaluation & Submit All Answers")
-    status_output = gr.Textbox(label="Run Status / Submission Result", lines=7, 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, inputs=[user_state, run_button, username_box], outputs=[status_output, results_table])
+
+    run_button.click(fn=run_and_submit_all, inputs=[user_state], outputs=[status_output, results_table])
 
 if __name__ == "__main__":
-    demo.launch(debug=True, share=False)
+    demo.launch(debug=True, share=True)  

requirements.txt

@@ -34,9 +34,24 @@
 # python-dotenv
 # protobuf==3.20.*
 # chromadb
+# gradio[oauth]>=4.44.0
+# requests>=2.31.0
+# pandas>=2.2.0
+# openpyxl>=3.1.2
+# smolagents>=0.0.23
+# duckduckgo-search>=6.1.0
+# gradio[oauth]>=4.44.0
+# requests
+# smolagents>=0.0.23
+# duckduckgo-search>=6.1.0
+# pandas>=2.2.0
+# python-dotenv>=1.0.1
+# gradio
+# requests
+# smolagents
+# smolagents[openai]
 gradio[oauth]>=4.44.0
 requests>=2.31.0
 pandas>=2.2.0
-openpyxl>=3.1.2
-smolagents>=0.0.23
-duckduckgo-search>=6.1.0
+itsdangerous>=2.1.2
+authlib>=1.3.0