Adds answer caching and user score types

_types.py

@@ -1,10 +1,23 @@
-from typing import TypedDict, Optional, List
+from typing import TypedDict, Optional, List, Dict
+
+class AnswerCacheEntry(TypedDict):
+    answer: str
+    isCorrect: bool
+
+AnswerCache = Dict[str, AnswerCacheEntry]
 
 class Question(TypedDict):
     task_id: str
     question: str
     file_name: Optional[str] = None
     
-    
-# A list of questions based on Question type
-Questions = List[Question]
+class UserScore(TypedDict):
+    username: str
+    score: int
+    correct_count: int
+    total_attempted: int
+    message: str
+    timestamp: str
+
+Questions = List[Question]
+ 

app.py

@@ -1,12 +1,14 @@
+
 import os
 import gradio as gr
 import requests
 import pandas as pd
-from _types import Questions, Question
+from _types import Questions, Question, UserScore
 from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI
 from llama_index.core.agent.workflow import AgentWorkflow
 from _tools import tools
 import asyncio
+from utils import cache_answers, update_cache_answer, get_cached_answer
 
 # (Keep Constants as is)
 # --- Constants ---
@@ -54,11 +56,19 @@ class BasicAgent:
         as you want. The file name is: {file_name}.\n
         """
 
+
+        # Retrieve the answer from the cache if it exists
+        cached = get_cached_answer(task_id)
+        if cached and cached.get("isCorrect") and cached.get("answer"):
+            print(f"Returning cached correct answer for task_id {task_id}: {cached['answer']}")
+            
+            return str(cached["answer"])
+
         answer = await self.agent.run(prompt)
 
         print(f"Agent returning answer: {answer}")
         
-        return answer
+        return str(answer)
 
 def instantiate_agent():
     try:
@@ -124,13 +134,15 @@ async def fetch_file(question: Question) -> str | None:
 async def run_agent_on_questions(agent: BasicAgent, questions_data: Questions):
     results_log = []
     answers_payload = []
-    
     print(f"Running agent on {len(questions_data)} questions...")
-    
+
+    # Inicializa o cache com todas as respostas erradas (se ainda não existir)
+    cache_answers(questions_data)
+
     for item in questions_data:
         task_id = item.get("task_id")
         question_text = item.get("question")
-        
+
         if not task_id or question_text is None:
             print(f"Skipping item with missing task_id or question: {item}")
             continue
@@ -139,11 +151,15 @@ async def run_agent_on_questions(agent: BasicAgent, questions_data: Questions):
             submitted_answer = await agent.run(item)
             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})
+            # Update the cache with the answer
+            update_cache_answer(task_id, submitted_answer, is_correct=False)
             
         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}"})
             
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
+            update_cache_answer(task_id, f"AGENT ERROR: {e}", is_correct=False)
+
     return answers_payload, results_log
 
 def submit_answers(submit_url, submission_data, results_log):
@@ -152,7 +168,7 @@ def submit_answers(submit_url, submission_data, results_log):
     try:
         response = requests.post(submit_url, json=submission_data, timeout=60)
         response.raise_for_status()
-        result_data = response.json()
+        result_data: UserScore = response.json() 
         
         final_status = (
             f"Submission Successful!\n"
@@ -245,7 +261,6 @@ async def run_and_submit_all(profile: gr.OAuthProfile | None):
     return submit_answers(submit_url, submission_data, results_log)
 
 
-
 async def main():
     await run_and_submit_all(profile=None)
 

utils.py

@@ -0,0 +1,43 @@
+
+import json
+import os
+from typing import Optional
+from _types import AnswerCacheEntry, AnswerCache
+
+CACHE_FILE = "answers_cache.json"
+
+def load_cache(cache_path: str = CACHE_FILE) -> AnswerCache:
+    if not os.path.exists(cache_path):
+        return {}
+    with open(cache_path, "r", encoding="utf-8") as f:
+        try:
+            return json.load(f)
+        except json.JSONDecodeError:
+            return {}
+
+def save_cache(cache: AnswerCache, cache_path: str = CACHE_FILE) -> None:
+    with open(cache_path, "w", encoding="utf-8") as f:
+        json.dump(cache, f, ensure_ascii=False, indent=2)
+
+def cache_answers(questions, cache_path: str = CACHE_FILE) -> AnswerCache:
+    """
+    Initializes the cache with all answers as incorrect.
+    Structure: { task_id: { answer: '', isCorrect: False } }
+    """
+    cache: AnswerCache = {}
+    for q in questions:
+        task_id = q.get("task_id")
+        if task_id:
+            cache[task_id] = {"answer": "", "isCorrect": False}
+    save_cache(cache, cache_path)
+    return cache
+
+def update_cache_answer(task_id: str, answer: str, is_correct: bool = False, cache_path: str = CACHE_FILE):
+    cache = load_cache(cache_path)
+    cache[task_id] = {"answer": answer, "isCorrect": is_correct}
+    save_cache(cache, cache_path)
+
+
+def get_cached_answer(task_id: str, cache_path: str = CACHE_FILE) -> Optional[AnswerCacheEntry]:
+    cache = load_cache(cache_path)
+    return cache.get(task_id)