Implement cache directory management and update file fetching to use cache if no working directory is provided

.gitignore

@@ -201,3 +201,6 @@ __marimo__/
 
 # Streamlit
 .streamlit/secrets.toml
+
+# Cache directory for file operations
+cache/

app.py

@@ -5,11 +5,10 @@ import pandas as pd
 from os import getenv
 from dotenv import load_dotenv
 import asyncio
-import tempfile
 
 from agent.agent import OracleBot
-from config import start_phoenix, APP_NAME, DEFAULT_API_URL
-from utils import fetch_task_file, extract_task_id_from_question_data
+from utils import fetch_task_file
+from config import start_phoenix, APP_NAME, DEFAULT_API_URL, initialize_cache_directory, CACHE_DIR
 
 load_dotenv()
 
@@ -29,6 +28,7 @@ start_phoenix()
 # Simplified concurrent processor: launch all tasks immediately and await them together
 async def process_questions(agent: OracleBot, questions_data: list, working_dir: str):
     print(f"Running agent on {len(questions_data)} questions concurrently (simple fan-out)...")
+    print(f"Using working directory: {working_dir}")
 
     async def handle(item: dict):
         task_id = item.get("task_id")
@@ -114,66 +114,67 @@ async def run_and_submit_all( profile: gr.OAuthProfile | None):
         return f"An unexpected error occurred fetching questions: {e}", None
 
     # 3. Run your Agent concurrently (simple gather)
-    # Create a temporary working directory for this session
-    with tempfile.TemporaryDirectory() as working_dir:
-        results_log, answers_payload = await process_questions(agent, questions_data, working_dir)
-
-        # Remove everything before "FINAL ANSWER: " in submitted answers
-        for answer in answers_payload:
-            if "submitted_answer" in answer:
-                answer["submitted_answer"] = answer["submitted_answer"].split("FINAL ANSWER: ", 1)[-1].strip()
-
-        if not answers_payload:
-            print("Agent did not produce any answers to submit.")
-            return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
-
-        # 4. Prepare Submission 
-        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)
-
-        # 5. Submit
-        print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
+    # Use the cache directory for this session
+    working_dir = CACHE_DIR
+
+    results_log, answers_payload = await process_questions(agent, questions_data, working_dir)
+
+    # Remove everything before "FINAL ANSWER: " in submitted answers
+    for answer in answers_payload:
+        if "submitted_answer" in answer:
+            answer["submitted_answer"] = answer["submitted_answer"].split("FINAL ANSWER: ", 1)[-1].strip()
+
+    if not answers_payload:
+        print("Agent did not produce any answers to submit.")
+        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
+
+    # 4. Prepare Submission 
+    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)
+
+    # 5. Submit
+    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
+    try:
+        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:
-            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:
-                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:
-            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:
-            status_message = f"An unexpected error occurred during submission: {e}"
-            print(status_message)
-            results_df = pd.DataFrame(results_log)
-            return status_message, results_df
+            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:
+        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:
+        status_message = f"An unexpected error occurred during submission: {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
 
 
 # --- Build Gradio Interface using Blocks ---
@@ -209,6 +210,10 @@ with gr.Blocks() as demo:
 
 if __name__ == "__main__":
     print("\n" + "-"*30 + " App Starting " + "-"*30)
+    
+    # Initialize cache directory
+    cache_directory = initialize_cache_directory()
+    
     # 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

config.py

@@ -1,11 +1,30 @@
 """Phoenix tracing setup for the OracleBot application."""
 
 import logging
+import shutil
+from pathlib import Path
 from phoenix.otel import register
 
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 APP_NAME = "OracleBot"
 
+# Define cache directory path globally
+CACHE_DIR = Path(__file__).parent / "cache"
+
+def initialize_cache_directory():
+    """Initialize the cache directory for file operations."""
+    # Remove existing cache directory if it exists
+    if CACHE_DIR.exists():
+        print(f"Removing existing cache directory: {CACHE_DIR}")
+        shutil.rmtree(CACHE_DIR)
+    
+    # Create fresh cache directory
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    print(f"Created fresh cache directory: {CACHE_DIR}")
+    
+    return str(CACHE_DIR)
+
+
 def start_phoenix(project_name: str = APP_NAME) -> None:
     """Setup Phoenix tracing for the agent.
     

tools/code_interpreter.py

@@ -14,6 +14,7 @@ import pandas as pd
 import matplotlib.pyplot as plt
 from PIL import Image
 from langchain_core.tools import tool
+from config import CACHE_DIR
 
 @tool
 def execute_code_multilang(code: str, language: str = "python") -> str:
@@ -92,7 +93,8 @@ class CodeInterpreter:
             "cmath", "uuid", "tempfile", "requests", "urllib"
         ]
         self.max_execution_time = max_execution_time
-        self.working_directory = working_directory or os.path.join(os.getcwd()) 
+        # Use cache directory instead of current working directory
+        self.working_directory = working_directory or str(CACHE_DIR)
         if not os.path.exists(self.working_directory):
             os.makedirs(self.working_directory)
         

tools/files.py

@@ -1,5 +1,4 @@
 from langchain_community.agent_toolkits import FileManagementToolkit
-from tempfile import TemporaryDirectory
+from config import CACHE_DIR
 
-working_directory = TemporaryDirectory()
-file_management_toolkit = FileManagementToolkit(working_directory=working_directory)
+file_management_toolkit = FileManagementToolkit(root_dir=str(CACHE_DIR))

utils.py

@@ -1,21 +1,24 @@
 import os
 import requests
-import tempfile
 from pathlib import Path
-from config import DEFAULT_API_URL
+from config import DEFAULT_API_URL, CACHE_DIR
 
 
-def fetch_task_file(task_id: str, working_dir: str) -> str | None:
+def fetch_task_file(task_id: str, working_dir: str | None = None) -> str | None:
     """
     Fetch the file associated with a task_id from the API and save it to the working directory.
     
     Args:
         task_id: The task ID to fetch the file for
-        working_dir: The working directory to save the file to
+        working_dir: The working directory to save the file to. If None, uses the global cache directory.
         
     Returns:
         The path to the downloaded file, or None if no file exists or error occurred
     """
+    # Use cache directory if working_dir is not provided
+    if working_dir is None:
+        working_dir = str(CACHE_DIR)
+
     try:
         files_url = f"{DEFAULT_API_URL}/files/{task_id}"
         response = requests.get(files_url, timeout=30)