cached answers

app.py

@@ -1,34 +1,39 @@
 import os
-import gradio as gr
-import requests
-import pandas as pd
+import time
 from pathlib import Path
+from typing import Optional
 
+import gradio as gr
+import pandas as pd
+import requests
 
 from core.agent import GaiaAgent, Attachment
+from utils.cache_answers import AnswersCache
 from utils.dependencies_checker import check_dependencies
 
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
+
 # --- Basic Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
 class BasicAgent:
     agent: GaiaAgent
+
     def __init__(self):
         self.agent = GaiaAgent()
-    def __call__(self, question: str, attached_content: bytes|None, attached_file_name: str|None ) -> str:
+
+    def __call__(self, question: str, attachment: Optional[Attachment] = None) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
-        attachment = None
-        if attached_content:
-            attachment =Attachment(attached_content, attached_file_name)
+        if attachment:
+            print(f"Agent received an attachment : {attachment.file_path}...")
+
         answer = self.agent.__call__(question, attachment)
         print(f"Agent returning fixed answer: {answer}")
         return answer
 
 
-def get_question_attached_file(task_id, file_name) -> bytes:
+def get_question_attached_file(task_id, file_name) -> Attachment:
     api_url = DEFAULT_API_URL
     attachment_url = f"{api_url}/files/{task_id}"
 
@@ -41,7 +46,7 @@ def get_question_attached_file(task_id, file_name) -> bytes:
         print(f"Retrieved {file_name} attachment from: {attachment_url}")
 
         # Save to disk
-        file_path = Path(f"attachments\{task_id}\{file_name}")
+        file_path = Path("attachments") / f"{task_id}" / f"{file_name}"
         content = response.content
 
         # Create parent directories if they don't exist
@@ -50,24 +55,22 @@ def get_question_attached_file(task_id, file_name) -> bytes:
         # Write the file
         file_path.write_bytes(content)
 
-        return content
+        return Attachment(content, file_path.as_posix())
 
     except Exception as e:
         print(f"An unexpected error occurred fetching attachment for taskid{task_id}: {e}")
 
 
-
-
-def run_and_submit_all( profile: gr.OAuthProfile | None):
+def run_and_submit_all(profile: gr.OAuthProfile | None):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,
     and displays the results.
     """
     # --- Determine HF Space Runtime URL and Repo URL ---
-    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
+    space_id = os.getenv("SPACE_ID")  # Get the SPACE_ID for sending link to the code
 
     if profile:
-        username= f"{profile.username}"
+        username = f"{profile.username}"
         print(f"User logged in: {username}")
     else:
         print("User not logged in.")
@@ -94,16 +97,16 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         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("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
+        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
@@ -112,22 +115,34 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     results_log = []
     answers_payload = []
     print(f"Running agent on {len(questions_data)} questions...")
+    cache = AnswersCache()
     for item in questions_data:
         task_id = item.get("task_id")
         question_text = item.get("question")
         attached_file_name = item.get("file_name")
+        attachment = None
         if attached_file_name:
-            file_content = get_question_attached_file(task_id, attached_file_name)
+            attachment = get_question_attached_file(task_id, attached_file_name)
         if not task_id or question_text is None:
             print(f"Skipping item with missing task_id or question: {item}")
             continue
+
+        if task_id in ["a1e91b78-d3d8-4675-bb8d-62741b4b68a6"]:
+            print(f"Skipping question. Not handled for the moment: {item}")
+            cache.set(task_id, "NAN")
+            continue
         try:
-            submitted_answer = agent(question_text, file_content)
+            # check if the answer is cached, if not invoke the agent
+            submitted_answer = cache.get(task_id)
+            if submitted_answer is None:
+                submitted_answer = agent(question_text, attachment)
+                time.sleep(20)
+                cache.set(task_id, submitted_answer)
             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:
-             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}"})
+            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:
         print("Agent did not produce any answers to submit.")
@@ -214,10 +229,10 @@ with gr.Blocks() as demo:
     )
 
 if __name__ == "__main__":
-    print("\n" + "-"*30 + " App Starting " + "-"*30)
+    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
+    space_id_startup = os.getenv("SPACE_ID")  # Get SPACE_ID at startup
 
     if space_host_startup:
         print(f"✅ SPACE_HOST found: {space_host_startup}")
@@ -225,16 +240,16 @@ if __name__ == "__main__":
     else:
         print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
 
-    if space_id_startup: # Print repo URLs if SPACE_ID is found
+    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("-"*(60 + len(" Check dependencies ")) + "\n")
+    print("-" * (60 + len(" App Starting ")) + "\n")
+    print("-" * (60 + len(" Check dependencies ")) + "\n")
     check_dependencies()
 
     print("Launching Gradio Interface for Basic Agent Evaluation...")
-    demo.launch(debug=True, share=False)
+    demo.launch(debug=True, share=False)

tools/python_executor.py

@@ -39,7 +39,7 @@ def subprocess_python_exec(file_reference: str) -> str:
             [sys.executable, file_reference],
             capture_output=True,
             text=True,
-            timeout=60
+            timeout=90
         )
 
         if result.returncode == 0:

utils/cache_answers.py

@@ -0,0 +1,74 @@
+import json
+import os
+import time
+from typing import Optional, Dict, Any
+
+
+class AnswersCache:
+    def __init__(self, filename: str = "cache.json", max_size: int = 1000):
+        self.filename = filename
+        self.max_size = max_size
+        self.cache: Dict[str, Dict[str, Any]] = {}
+        self._load_cache()
+
+    def _load_cache(self):
+        """Load cache from file if it exists"""
+        if os.path.exists(self.filename):
+            try:
+                with open(self.filename, 'r') as f:
+                    self.cache = json.load(f)
+            except (json.JSONDecodeError, FileNotFoundError):
+                self.cache = {}
+
+    def _save_cache(self):
+        """Save cache to file"""
+        with open(self.filename, 'w') as f:
+            json.dump(self.cache, f, indent=2)
+
+    def set(self, key: str, value: str, ttl: Optional[int] = None):
+        """Set a key-value pair with optional TTL (time to live in seconds)"""
+        if len(self.cache) >= self.max_size:
+            self._evict_oldest()
+
+        cache_entry = {
+            'value': value,
+            'created_at': time.time(),
+            'ttl': ttl
+        }
+        self.cache[key] = cache_entry
+        self._save_cache()
+
+    def get(self, key: str) -> Optional[str]:
+        """Get value for key, returns None if not found or expired"""
+        if key not in self.cache:
+            return None
+
+        entry = self.cache[key]
+
+        # Check if entry has expired
+        if entry['ttl'] is not None:
+            if time.time() - entry['created_at'] > entry['ttl']:
+                self.delete(key)
+                return None
+
+        return entry['value']
+
+    def delete(self, key: str):
+        """Delete a key from cache"""
+        if key in self.cache:
+            del self.cache[key]
+            self._save_cache()
+
+    def clear(self):
+        """Clear all cache entries"""
+        self.cache = {}
+        self._save_cache()
+
+    def _evict_oldest(self):
+        """Remove the oldest entry when cache is full"""
+        if not self.cache:
+            return
+
+        oldest_key = min(self.cache.keys(),
+                         key=lambda k: self.cache[k]['created_at'])
+        del self.cache[oldest_key]