Update app.py

app.py

@@ -1,72 +1,71 @@
-# app.py  –  async + progress, keine Cache-Logik
-# ------------------------------------------------
-import os, asyncio, concurrent.futures, functools
+# ------------------------------------------------------------
+# fast async app.py  (korrekte Zuordnung + Gemini-Throttle)
+# ------------------------------------------------------------
+import os, asyncio, concurrent.futures, functools, json
+from pathlib import Path
 import gradio as gr, requests, pandas as pd
 from langchain_core.messages import HumanMessage
-from agent import agent_executor     # dein LangGraph-Agent
-
+from agent import agent_executor
 
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-MAX_PAR_TASKS   = 5                  # wie viele Fragen parallel laufen
-
+MAX_PAR_LLM     = 3                      # 3 gleichz. Requests stay < 15/min
+SEMAPHORE       = asyncio.Semaphore(MAX_PAR_LLM)
 
-# ------------------------------------------------------------------
-# Sync-Wrapper um den Agent
-# ------------------------------------------------------------------
+# ---------- synchroner Agent-Aufruf ---------------------------------
 def run_agent_sync(task_id: str, question: str) -> str:
-    llm_input = {
+    payload = {
         "messages": [HumanMessage(content=question)],
-        "task_id":  task_id,
+        "task_id": task_id,
     }
     try:
-        result = agent_executor.invoke(llm_input)
-        return result["messages"][-1].content.strip()
+        res = agent_executor.invoke(payload)
+        return res["messages"][-1].content.strip()
     except Exception as e:
         return f"AGENT ERROR: {e}"
 
-
+# ---------- async Wrapper + Throttle --------------------------------
 async def run_agent_async(executor, task_id: str, question: str) -> str:
     loop = asyncio.get_event_loop()
-    return await loop.run_in_executor(
-        executor, functools.partial(run_agent_sync, task_id, question)
-    )
-
+    async with SEMAPHORE:                       # Gemini-Quota Guard
+        return await loop.run_in_executor(
+            executor, functools.partial(run_agent_sync, task_id, question)
+        )
 
-# ------------------------------------------------------------------
-# Haupt-Callback (async)  –  holt Fragen, verarbeitet parallel
-# ------------------------------------------------------------------
+# ---------- Main Gradio Callback ------------------------------------
 async def run_and_submit_all(profile: gr.OAuthProfile | None, progress=gr.Progress()):
     if not profile:
         return "Please login with your HF account.", None
     username = profile.username
 
-    # 1) GAIA-Fragen holen
-    q_url = f"{DEFAULT_API_URL}/questions"
+    # 1) Fragen laden
     try:
-        q_data = requests.get(q_url, timeout=15).json()
+        questions = requests.get(f"{DEFAULT_API_URL}/questions", timeout=15).json()
     except Exception as e:
         return f"Error fetching questions: {e}", None
 
-    progress(0, desc=f"Fetched {len(q_data)} questions – processing …")
+    progress(0, desc=f"Fetched {len(questions)} questions – processing …")
 
-    # 2) Parallel ausführen
-    answers, log_rows = [], []
-    with concurrent.futures.ThreadPoolExecutor(max_workers=MAX_PAR_TASKS) as ex:
-        tasks = [
-            run_agent_async(ex, itm["task_id"], itm["question"])
-            for itm in q_data
-        ]
-        for i, coro in enumerate(asyncio.as_completed(tasks), 1):
+    answers, logs = [], []
+    work = [(q["task_id"], q["question"]) for q in questions]
+
+    # 2) Parallel-Ausführung mit korrekt gemappten Tasks
+    with concurrent.futures.ThreadPoolExecutor(max_workers=MAX_PAR_LLM) as ex:
+        task_map = {
+            asyncio.create_task(run_agent_async(ex, tid, qst)): (tid, qst)
+            for tid, qst in work
+        }
+        done_total = 0
+        for coro in asyncio.as_completed(task_map):
             answer = await coro
-            task_id = q_data[i-1]["task_id"]
-            question = q_data[i-1]["question"]
+            tid, qst = task_map[coro]
 
-            answers.append({"task_id": task_id, "submitted_answer": answer})
-            log_rows.append({"Task ID": task_id, "Question": question, "Answer": answer})
+            answers.append({"task_id": tid, "submitted_answer": answer})
+            logs.append({"Task ID": tid, "Question": qst, "Answer": answer})
 
-            progress(i / len(q_data), desc=f"{i}/{len(q_data)} done")
+            done_total += 1
+            progress(done_total / len(work), desc=f"{done_total}/{len(work)} done")
 
-    # 3) Antworten submitten
+    # 3) Submit
     submit_url = f"{DEFAULT_API_URL}/submit"
     payload = {
         "username": username,
@@ -75,27 +74,20 @@ async def run_and_submit_all(profile: gr.OAuthProfile | None, progress=gr.Progre
     }
     try:
         res = requests.post(submit_url, json=payload, timeout=60).json()
-        status = (
-            f"Submission OK – Score: {res.get('score','?')} % "
-            f"({res.get('correct_count','?')}/{res.get('total_attempted','?')})"
-        )
+        status = (f"Submission OK – Score {res.get('score','?')} % "
+                  f"({res.get('correct_count','?')}/{res.get('total_attempted','?')})")
     except Exception as e:
         status = f"Submission failed: {e}"
 
-    return status, pd.DataFrame(log_rows)
-
+    return status, pd.DataFrame(logs)
 
-# ------------------------------------------------------------------
-# Gradio-UI
-# ------------------------------------------------------------------
+# ---------- Gradio UI -----------------------------------------------
 with gr.Blocks() as demo:
-    gr.Markdown("# Fast GAIA Agent Runner  (Async + Progress)")
+    gr.Markdown("# Fast GAIA Agent Runner  (async × progress)")
     gr.LoginButton()
     run_btn = gr.Button("Run & Submit")
-
-    out_status = gr.Textbox(label="Status / Score", lines=3, interactive=False)
+    out_status = gr.Textbox(label="Status / Score", lines=3)
     out_table  = gr.DataFrame(label="Answers", wrap=True)
-
     run_btn.click(run_and_submit_all, outputs=[out_status, out_table])
 
 if __name__ == "__main__":