Update app.py

app.py

@@ -3,20 +3,20 @@ import gradio as gr
 import requests
 import pandas as pd
 import re
+import json
 from datetime import datetime
-import time
 import tempfile
 import atexit
 import sys  # Für sys.exit bei Importfehlern
 
-# --- Smol Agents und HF Imports (angepasst an Beispiel) ---
+# --- Smol Agents und HF Imports ---
 try:
     from smolagents import CodeAgent, tool, HfApiModel
     print("Successfully imported CodeAgent, tool, HfApiModel from 'smolagents'")
 except ImportError as e:
     print(f"Error importing from smolagents: {e}")
     print("Please ensure 'smolagents[huggingface]' is listed correctly in requirements.txt")
-    sys.exit(f"Fatal Error: Could not import smolagents components. Check requirements.txt and rebuild/restart the Space. Original error: {e}")
+    sys.exit(f"Fatal Error: Could not import smolagents components. Original error: {e}")
 
 from huggingface_hub import HfApi
 
@@ -43,216 +43,159 @@ try:
     PDF_READER_AVAILABLE = True
 except ImportError:
     PDF_READER_AVAILABLE = False
-    print("WARNUNG: PyPDF2 nicht installiert. PDF-Lesefunktion ist deaktiviert.")
+    print("WARNUNG: PyPDF2 nicht installiert. PDF-Lesefunktion deaktiviert.")
 
-# --- Konstanten ---
+# --- Konstanten & Globals ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 HF_MODEL_ID = os.getenv("HF_MODEL_ID", "meta-llama/Meta-Llama-3-8B-Instruct")
-
-# --- Globale Variablen ---
 search_client = None
 agent_instance = None
 
 temp_files_to_clean = set()
 
 def cleanup_temp_files():
-    print("Cleaning up temporary files...")
-    for file_path in list(temp_files_to_clean):
+    for path in list(temp_files_to_clean):
         try:
-            if os.path.exists(file_path):
-                os.remove(file_path)
-                print(f"Removed temporary file: {file_path}")
-            temp_files_to_clean.discard(file_path)
-        except Exception as e:
-            print(f"Error removing temporary file {file_path}: {e}")
-
+            if os.path.exists(path): os.remove(path)
+        except OSError:
+            pass
+        temp_files_to_clean.discard(path)
 atexit.register(cleanup_temp_files)
 
-# --- Tool Definitionen ---
+# --- Tool Definitions ---
 @tool
 def search_web(query: str, max_results: int = 3) -> str:
     """
-    Sucht im Web nach der angegebenen Query und gibt eine Zusammenfassung der obersten Ergebnisse zurück.
-    Args:
-        query (str): Der Suchbegriff.
-        max_results (int): Maximale Anzahl an Ergebnissen (Standard 3).
-    Returns:
-        str: Konsolidierte Ergebnisliste oder Fehlermeldung.
+    Websuche via Tavily oder DuckDuckGo.
     """
-    print(f"Tool: search_web(query='{query}', max_results={max_results})")
     if not search_client:
-        return "Search tool is not available/configured."
+        return "Search tool not configured."
     try:
         if USE_TAVILY and isinstance(search_client, TavilyClient):
-            response = search_client.search(query=query, search_depth="basic", max_results=max_results)
-            context = response.get('results', [])
-            if not context:
-                return "No search results found."
-            return "\n".join(
-                [f"URL: {c['url']}\nContent: {c['content'][:500]}..." for c in context]
-            )
+            res = search_client.search(query=query, search_depth="basic", max_results=max_results)
+            items = res.get('results', [])
+            return "\n".join([f"URL: {i['url']}\n{ i['content'][:200] }..." for i in items])
         elif USE_DUCKDUCKGO and isinstance(search_client, DDGS):
             results = search_client.text(query, max_results=max_results)
-            if not results:
-                return "No search results found."
-            return "\n".join(
-                [f"Title: {r['title']}\nURL: {r['href']}\nSnippet: {r['body'][:500]}..." for r in results]
-            )
-        else:
-            return "No compatible search client configured or available."
+            return "\n".join([f"Title: {r['title']}\nURL: {r['href']}\n{r['body'][:200]}..." for r in results])
     except Exception as e:
-        print(f"Search API Error ({type(e).__name__}): {e}")
         return f"Error during search: {e}"
+    return "No results."
 
 @tool
 def download_task_file(task_id: str) -> str:
-    """
-    Lädt eine Datei vom Evaluation-Server für die gegebene Task ID herunter.
-    Args:
-        task_id (str): Eindeutige Kennung der Aufgabe.
-    Returns:
-        str: Lokaler Pfad der heruntergeladenen Datei oder Fehlermeldung.
-    """
-    print(f"Tool: download_task_file(task_id='{task_id}')")
-    file_url = f"{DEFAULT_API_URL}/files/{task_id}"
+    """Download einer Datei zur Task ID vom Server."""
+    url = f"{DEFAULT_API_URL}/files/{task_id}"
     try:
-        response = requests.get(file_url, stream=True, timeout=30)
-        response.raise_for_status()
-        content_type = response.headers.get('content-type', '').lower()
-        suffix = ".tmp"
-        if 'pdf' in content_type: suffix = ".pdf"
-        elif 'png' in content_type: suffix = ".png"
-        elif 'jpeg' in content_type or 'jpg' in content_type: suffix = ".jpg"
-        elif 'csv' in content_type: suffix = ".csv"
-        temp_dir = tempfile.gettempdir()
-        safe_id = re.sub(r'[^\w\-]+', '_', task_id)
-        timestamp = datetime.now().strftime("%Y%m%d%H%M%S%f")
-        path = os.path.join(temp_dir, f"gaia_task_{safe_id}_{timestamp}{suffix}")
+        r = requests.get(url, stream=True, timeout=30)
+        r.raise_for_status()
+        ct = r.headers.get('content-type', '')
+        suffix = '.pdf' if 'pdf' in ct else '.tmp'
+        tmp = tempfile.gettempdir()
+        name = f"task_{task_id}_{datetime.now().strftime('%Y%m%d%H%M%S')}{suffix}"
+        path = os.path.join(tmp, name)
         with open(path, 'wb') as f:
-            for chunk in response.iter_content(8192):
-                f.write(chunk)
+            for chunk in r.iter_content(8192): f.write(chunk)
         temp_files_to_clean.add(path)
         return path
-    except requests.exceptions.HTTPError as e:
-        if e.response.status_code == 404:
-            return "Error: No file found for this task ID."
-        return f"Error: Failed to download file (HTTP {e.response.status_code})."
     except Exception as e:
-        return f"Error: Unexpected error during file download: {e}"
+        return f"Error: {e}"
 
 @tool
 def read_file_content(file_path: str) -> str:
-    """
-    Liest den Text einer heruntergeladenen Datei (PDF oder Text).
-    Args:
-        file_path (str): Absoluter Pfad zur Datei.
-    Returns:
-        str: Extrahierter Text oder Fehlermeldung.
-    """
-    print(f"Tool: read_file_content(file_path='{file_path}')")
-    if not os.path.isabs(file_path) or not file_path.startswith(tempfile.gettempdir()):
-        return "Error: Invalid file path provided."
-    if not os.path.exists(file_path):
-        return f"Error: File not found '{file_path}'."
+    """Liest Text aus einer heruntergeladenen Datei."""
+    if not file_path.startswith(tempfile.gettempdir()):
+        return "Error: Invalid path."
     try:
-        if file_path.lower().endswith('.pdf'):
-            if not PDF_READER_AVAILABLE:
-                return "Error: PyPDF2 not installed."
-            text = ""
+        if file_path.endswith('.pdf'):
+            if not PDF_READER_AVAILABLE: return "Error: PyPDF2 fehlt."
+            txt = ''
             with open(file_path, 'rb') as f:
-                reader = PyPDF2.PdfReader(f)
-                for p in reader.pages:
-                    text += p.extract_text() or ''
-                    if len(text) > 7000:
-                        text = text[:7000] + "\n... (truncated)"
-                        break
-            return f"Content of '{os.path.basename(file_path)}':\n{text}"
+                rdr = PyPDF2.PdfReader(f)
+                for p in rdr.pages:
+                    txt += p.extract_text() or ''
+                    if len(txt) > 5000: break
+            return txt
         else:
-            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
-                content = f.read(7000)
-            return f"Content of '{os.path.basename(file_path)}':\n{content}"
+            return open(file_path, 'r', encoding='utf-8', errors='ignore').read(5000)
     except Exception as e:
-        return f"Error: Failed to read file: {e}"
+        return f"Error: {e}"
 
-# --- Agent Initialisierung ---
+# --- Agent Setup ---
 def initialize_agent():
     global search_client, agent_instance
     if search_client is None:
         if USE_TAVILY:
-            key = os.getenv("TAVILY_API_KEY")
-            if key:
-                try: search_client = TavilyClient(api_key=key)
-                except: search_client = False
-            else:
-                search_client = False
+            key = os.getenv('TAVILY_API_KEY')
+            search_client = TavilyClient(api_key=key) if key else False
         elif USE_DUCKDUCKGO:
-            try: search_client = DDGS()
-            except: search_client = False
+            search_client = DDGS()
         else:
             search_client = False
-    token = os.getenv("HUGGINGFACE_TOKEN")
+    token = os.getenv('HUGGINGFACE_TOKEN')
     if not token:
-        raise ValueError("HUGGINGFACE_TOKEN Secret nicht gefunden!")
+        raise ValueError("HUGGINGFACE_TOKEN fehlt.")
     hf_model = HfApiModel()
     tools = [search_web, download_task_file, read_file_content]
-    if search_client is False:
-        tools = [t for t in tools if t != search_web]
+    if not search_client: tools = [t for t in tools if t != search_web]
     agent_instance = CodeAgent(tools=tools, model=hf_model)
 
-# --- Hauptfunktion run_and_submit_all ---
+# --- Hauptfunktion ---
 def run_and_submit_all(profile, progress=gr.Progress(track_tqdm=True)):
-    if not profile:
-        return "Bitte zuerst mit Hugging Face einloggen.", None
-    username = profile.username if hasattr(profile, 'username') else profile['username']
-    api_url = DEFAULT_API_URL
+    # Profil parsen (evtl. JSON-String)
+    if isinstance(profile, str):
+        try: profile = json.loads(profile)
+        except: return "Ungültiges Profilformat.", None
+    if not profile or 'username' not in profile:
+        return "Bitte zuerst einloggen.", None
+    username = profile['username']
     try:
         initialize_agent()
     except Exception as e:
-        return f"Fehler bei der Agent-Initialisierung: {e}", None
-    questions = requests.get(f"{api_url}/questions", timeout=30).json()
-    answers_log = []
-    payload = []
-    for item in progress.tqdm(questions, desc="Bearbeite Fragen"):
-        task_id = item.get("task_id")
-        question = item.get("question")
-        if not task_id or question is None:
-            continue
-        prompt = f"... Task {task_id}: {question}"
+        return f"Init-Error: {e}", None
+
+    # Fragen holen
+    questions = requests.get(f"{DEFAULT_API_URL}/questions").json()
+    logs, payload = [], []
+    for item in progress.tqdm(questions, desc="Bearbeite" ):
+        tid, q = item.get('task_id'), item.get('question')
+        if not tid or not q: continue
+        prompt = f"Task {tid}: {q}"
         try:
-            resp = agent_instance.run(prompt=prompt)
-            ans = re.sub(r"^(Answer:|Final Answer:)", "", resp or "").strip()
+            res = agent_instance.run(prompt=prompt)
+            ans = re.sub(r"^(Answer:|Final Answer:)", "", res or "").strip()
         except Exception as e:
             ans = f"ERROR: {e}"
-        answers_log.append({"Task ID": task_id, "Question": question, "Submitted Answer": ans})
-        payload.append({"task_id": task_id, "submitted_answer": ans})
-    df = pd.DataFrame(answers_log)
-    submission = {"username": username, "agent_code": "...", "answers": payload}
+        logs.append({'Task ID': tid, 'Question': q, 'Submitted Answer': ans})
+        payload.append({'task_id': tid, 'submitted_answer': ans})
+    df = pd.DataFrame(logs)
+
+    # Submission
+    sub = {'username': username, 'agent_code': '...', 'answers': payload}
     try:
-        r = requests.post(f"{api_url}/submit", json=submission, timeout=180)
+        r = requests.post(f"{DEFAULT_API_URL}/submit", json=sub, timeout=180)
         r.raise_for_status()
-        res = r.json()
-        status = f"Erfolg! Score: {res.get('score', 0):.2f}%"
+        status = f"Erfolg: {r.json().get('score',0):.2f}%"
     except Exception as e:
-        status = f"Fehler bei der Submission: {e}"
+        status = f"Submit-Error: {e}"
     cleanup_temp_files()
     return status, df
 
-# --- Gradio Interface ---
+# --- Gradio UI ---
 with gr.Blocks() as demo:
     gr.Markdown("# Smol CodeAgent Evaluation Runner")
     gr.Markdown("Bitte einloggen und dann auf Ausführen klicken.")
-    with gr.Row():
-        login_button = gr.LoginButton()
-    run_button = gr.Button("Run Evaluation & Submit All Answers")
-    status_output = gr.Textbox(label="Status", lines=5)
-    results_table = gr.DataFrame(label="Ergebnisse")
+    with gr.Row(): login_btn = gr.LoginButton()
+    run_btn = gr.Button("Run Evaluation & Submit All Answers")
+    out_status = gr.Textbox(label="Status", lines=5)
+    out_table = gr.DataFrame(label="Ergebnisse")
 
-    run_button.click(
+    run_btn.click(
         fn=run_and_submit_all,
-        inputs=[login_button],
-        outputs=[status_output, results_table],
+        inputs=[login_btn],
+        outputs=[out_status, out_table],
         api_name="run_evaluation_smol_codeagent"
     )
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     demo.queue().launch(debug=False, share=False)