Alpha version app

app.py

@@ -1,15 +1,10 @@
 import os
-import base64
-import mimetypes
-import gradio as gr
 import requests
-import inspect
 import pandas as pd
-from dotenv import load_dotenv
-from tools import agent_executor
+import gradio as gr
+from basic_agent import BasicAgent
+from utils.question_manager import QuestionManager
 
-# Load environment variables from .env file
-load_dotenv()
 
 # (Keep Constants as is)
 # --- Constants ---
@@ -17,119 +12,26 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-class BasicAgent:
-    def __init__(self):
-        print("BasicAgent initialized with LangChain tools.")
-        self.agent_executor = agent_executor
-    
-    def __call__(self, question_data: dict) -> str:
-        """
-        Process question with optional file attachment
-        question_data = {
-            'text': str,
-            'file_path': str (optional),
-            'file_name': str (optional)
-        }
-        """
-        question_text = question_data.get('text', '')
-        file_path = question_data.get('file_path')
-        
-        print(f"Agent received question (first 50 chars): {question_text[:50]}...")
-        
-        try:
-            # Prepare input for the agent
-            if file_path and os.path.exists(file_path):
-                # Handle file input - check if it's an image or other file type
-                file_extension = os.path.splitext(file_path)[1].lower()
-                
-                if file_extension in ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp']:
-                    # Handle image files - use LLM directly for vision, bypass ReAct agent
-                    with open(file_path, 'rb') as img_file:
-                        img_base64 = base64.b64encode(img_file.read()).decode()
-                    
-                    print(f"Processing question with image: {file_path}")
-                    
-                    # Use the LLM directly for vision tasks
-                    from langchain_core.messages import HumanMessage
-                    
-                    # Create image message for direct LLM call
-                    message = HumanMessage(
-                        content=[
-                            {"type": "text", "text": f"{question_text}\n\nPlease analyze this image and provide your answer in the format: FINAL ANSWER: [YOUR ANSWER]"},
-                            {
-                                "type": "image_url", 
-                                "image_url": {"url": f"data:image/{file_extension[1:]};base64,{img_base64}"}
-                            }
-                        ]
-                    )
-                    
-                    # Call LLM directly for vision tasks
-                    response = self.agent_executor.llm.invoke([message])
-                    answer = response.content if hasattr(response, 'content') else str(response)
-                    print(f"Agent generated answer: {answer}")
-                    return answer
-                
-                else:
-                    # Handle other file types (text, CSV, etc.) - use ReAct agent
-                    try:
-                        with open(file_path, 'r', encoding='utf-8') as f:
-                            file_content = f.read()
-                        combined_input = f"{question_text}\n\nFile content ({os.path.basename(file_path)}):\n{file_content}"
-                        agent_input = {"input": combined_input}
-                        print(f"Processing question with text file: {file_path}")
-                    except UnicodeDecodeError:
-                        # Binary file - provide file info only
-                        file_info = f"Binary file: {os.path.basename(file_path)} ({os.path.getsize(file_path)} bytes)"
-                        combined_input = f"{question_text}\n\nAttached file: {file_info}"
-                        agent_input = {"input": combined_input}
-                        print(f"Processing question with binary file: {file_path}")
-                    
-                    # Use ReAct agent for non-image files
-                    response = self.agent_executor.invoke(agent_input)
-                    answer = response.get('output', 'No answer generated.')
-                    print(f"Agent generated answer: {answer}")
-                    return answer
-            else:
-                # Text-only question - use ReAct agent
-                agent_input = {"input": question_text}
-                print("Processing text-only question")
-                response = self.agent_executor.invoke(agent_input)
-                answer = response.get('output', 'No answer generated.')
-                print(f"Agent generated answer: {answer}")
-                return answer
-            
-        except Exception as e:
-            error_msg = f"Agent error: {str(e)}"
-            print(f"Error in agent execution: {e}")
-            return error_msg
-        finally:
-            # Clean up downloaded file
-            if file_path and os.path.exists(file_path):
-                try:
-                    os.remove(file_path)
-                    print(f"Cleaned up file: {file_path}")
-                except Exception as e:
-                    print(f"Warning: Could not remove file {file_path}: {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
+    # Get the SPACE_ID for sending link to the code
+    space_id = os.getenv("SPACE_ID")
 
     if profile:
-        username= f"{profile.username}"
+        username = f"{profile.username}"
         print(f"User logged in: {username}")
     else:
         print("User not logged in.")
         return "Please Login to Hugging Face with the button.", None
 
     api_url = DEFAULT_API_URL
-    questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
-    file_url = f"{api_url}/files"
 
     # 1. Instantiate Agent ( modify this part to create your agent)
     try:
@@ -142,25 +44,10 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     print(agent_code)
 
     # 2. Fetch Questions
-    print(f"Fetching questions from: {questions_url}")
-    try:
-        response = requests.get(questions_url, timeout=15)
-        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(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
-    except Exception as e:
-        print(f"An unexpected error occurred fetching questions: {e}")
-        return f"An unexpected error occurred fetching questions: {e}", None
+    question_manager = QuestionManager(api_url)
+    questions = question_manager.fetch_questions()
+    # questions = question_manager.fetch_random_question()
+    questions_data = question_manager.prepare_questions_data(questions)
 
     # 3. Run your Agent
     results_log = []
@@ -168,63 +55,34 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     print(f"Running agent on {len(questions_data)} questions...")
     for item in questions_data:
         task_id = item.get("task_id")
-        question_text = item.get("question")
-        file_name = item.get("file_name")
-        
+        question_text = item.get("text")
+        file_name = item.get("file_url")
+
         if not task_id or question_text is None:
             print(f"Skipping item with missing task_id or question: {item}")
             continue
-        
-        # Prepare question data for the agent
-        question_data = {
-            'text': question_text,
-            'file_path': None,
-            'file_name': file_name
-        }
-        
-        # Download file if present
-        if file_name:
-            try:
-                print(f"Downloading file for task {task_id}: {file_name}")
-                file_response = requests.get(f"{file_url}/{task_id}", timeout=30)  # Increased timeout
-                file_response.raise_for_status()
-                
-                # Save file with a safe path
-                safe_file_path = os.path.join(os.getcwd(), f"temp_{task_id}_{file_name}")
-                with open(safe_file_path, "wb") as f:
-                    f.write(file_response.content)
-                
-                question_data['file_path'] = safe_file_path
-                print(f"File downloaded successfully: {safe_file_path}")
-                
-            except requests.exceptions.Timeout:
-                print(f"Timeout downloading file for task {task_id}: {file_name}")
-                question_data['file_path'] = None
-            except Exception as e:
-                print(f"Error downloading file for task {task_id}: {e}")
-                # Continue processing without file
-                question_data['file_path'] = None
-        
+
         # Process question with agent
         try:
-            submitted_answer = agent(question_data)
-            answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
-            
+            submitted_answer = agent(item)
+            answers_payload.append(
+                {"task_id": task_id, "submitted_answer": submitted_answer})
+
             # Log result with file info
             file_info = f" (with file: {file_name})" if file_name else ""
             results_log.append({
-                "Task ID": task_id, 
-                "Question": question_text + file_info, 
+                "Task ID": task_id,
+                "Question": question_text + file_info,
                 "Submitted Answer": submitted_answer
             })
             print(f"Task {task_id} completed successfully{file_info}")
-            
+
         except Exception as e:
             print(f"Error running agent on task {task_id}: {e}")
             file_info = f" (with file: {file_name})" if file_name else ""
             results_log.append({
-                "Task ID": task_id, 
-                "Question": question_text + file_info, 
+                "Task ID": task_id,
+                "Question": question_text + file_info,
                 "Submitted Answer": f"AGENT ERROR: {e}"
             })
 
@@ -232,8 +90,9 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         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}
+    # 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)
 
@@ -303,9 +162,11 @@ with gr.Blocks() as demo:
 
     run_button = gr.Button("Run Evaluation & Submit All Answers")
 
-    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
+    status_output = gr.Textbox(
+        label="Run Status / Submission Result", lines=5, interactive=False)
     # Removed max_rows=10 from DataFrame constructor
-    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
+    results_table = gr.DataFrame(
+        label="Questions and Agent Answers", wrap=True)
 
     run_button.click(
         fn=run_and_submit_all,
@@ -316,22 +177,24 @@ if __name__ == "__main__":
     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}")
-        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
+        print(
+            f"   Runtime URL should be: https://{space_host_startup}.hf.space")
     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")
+        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("Launching Gradio Interface for Basic Agent Evaluation...")
-    demo.launch(debug=True, share=False)
+    demo.launch(debug=True, share=False)

basic_agent.py

@@ -0,0 +1,24 @@
+from utils.agent_executor import create_agent_executor
+
+
+class BasicAgent:
+    def __init__(self):
+        print("BasicAgent initialized with LangChain tools.")
+        self.agent_executor = create_agent_executor()
+
+    def __call__(self, question_data: dict) -> str:
+        question_text = question_data.get('text', '')
+        file_url = question_data.get('file_url')
+        print(
+            f"Agent received question (task_id: {question_data.get('task_id')}) (first 50 chars): {question_text[:50]}...")
+        if file_url:
+            print(f"With attached file URL: {file_url}")
+
+        print(
+            f"Start processing question (task_id: {question_data.get('task_id')})")
+        response = self.agent_executor.invoke(
+            {"input": question_text, "file_url": file_url})
+        answer = response.get('output', 'No answer generated.')
+        print(
+            f"Agent generated answer (task_id: {question_data.get('task_id')}): {answer}")
+        return answer

utils/agent_executor.py

@@ -1,6 +1,7 @@
 from langchain.agents import AgentExecutor, create_react_agent
 from langchain_openai import ChatOpenAI
-from prompt import prompt_default
+from utils.prompt import prompt_default
+from utils.tools import tools_default
 
 
 def create_agent_executor(
@@ -22,7 +23,7 @@ def create_agent_executor(
         )
 
     if tools is None:
-        tools = []
+        tools = tools_default
 
     if prompt is None:
         prompt = prompt_default

utils/document_parser_tool.py

@@ -2,8 +2,7 @@ import os
 import pandas as pd
 from langchain_community.document_loaders import PyPDFLoader
 from langchain.tools import Tool
-from agent_executor import create_agent_executor
-from file_downloader import FileDownloader
+from utils.file_downloader import FileDownloader
 from dotenv import load_dotenv
 
 load_dotenv()
@@ -174,6 +173,9 @@ document_parser_url_tool = Tool(
 
 if __name__ == "__main__":
     print("Start testing document parser tool with file downloader integration")
+    
+    # Import here to avoid circular import
+    from utils.agent_executor import create_agent_executor
 
     # Initialize file downloader
     downloader = FileDownloader()

utils/question_manager.py

@@ -0,0 +1,78 @@
+import requests
+
+
+class QuestionManager:
+    def __init__(self, api_url: str):
+        self.api_url = api_url
+        self.questions_url = f"{api_url}/questions"
+        self.random_question_url = f"{api_url}/random_question"
+        self.files_url = f"{api_url}/files"
+        self.submit_url = f"{api_url}/submit"
+
+    def fetch_random_question(self):
+        print("Fetching random question")
+        try:
+            response = requests.get(self.random_question_url, timeout=15)
+            response.raise_for_status()
+            question_data = response.json()
+            return question_data
+        except requests.exceptions.RequestException as e:
+            print(f"Error fetching random question: {e}")
+        except requests.exceptions.JSONDecodeError as e:
+            print(
+                f"Error decoding JSON response from random question endpoint: {e}")
+            print(f"Response text: {response.text[:500]}")
+            return None
+        except Exception as e:
+            print(
+                f"An unexpected error occurred fetching random question: {e}")
+            return None
+
+    def fetch_question_by_id(self, question_id: str) -> dict | None:
+        print(f"Fetching question by id: {question_id}")
+        questions = self.fetch_questions()
+        for question in questions:
+            if question.get("task_id") == question_id:
+                return question
+        return None
+
+    def fetch_questions(self) -> list[dict]:
+        print(f"Fetching questions from: {self.questions_url}")
+        try:
+            response = requests.get(self.questions_url, timeout=15)
+            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(f"Fetched {len(questions_data)} questions.")
+            return questions_data
+        except requests.exceptions.RequestException as e:
+            print(f"Error fetching questions: {e}")
+            return []
+        except requests.exceptions.JSONDecodeError as e:
+            print(f"Error decoding JSON response from questions endpoint: {e}")
+            print(f"Response text: {response.text[:500]}")
+            return []
+        except Exception as e:
+            print(f"An unexpected error occurred fetching questions: {e}")
+            return []
+
+    def prepare_questions_data(self, questions: list[dict]) -> list[dict]:
+        print(f"Preparing question data for: {questions}")
+        questions_data = []
+        for item in questions:
+            task_id = item.get("task_id")
+            question_text = item.get("question")
+            file_url = f"{self.files_url}/{task_id}"
+            if not task_id or question_text is None:
+                print(
+                    f"Skipping item with missing task_id or question: {item}")
+                continue
+            question_data = {
+                'task_id': task_id,
+                'text': question_text,
+                'file_url': file_url
+            }
+            questions_data.append(question_data)
+        return questions_data

utils/search_tool.py

@@ -1,6 +1,5 @@
 from langchain_google_community import GoogleSearchRun, GoogleSearchAPIWrapper
 from dotenv import load_dotenv
-from agent_executor import create_agent_executor
 
 load_dotenv()
 
@@ -9,6 +8,9 @@ search_tool = GoogleSearchRun(api_wrapper=search_wrapper)
 
 if __name__ == "__main__":
     print("Start testing search tool with an example question")
+    
+    # Import here to avoid circular import
+    from utils.agent_executor import create_agent_executor
 
     tools = [search_tool]
     agent_executor = create_agent_executor(tools=tools)

utils/tools.py

@@ -1,4 +1,4 @@
-from search_tool import search_tool
-from document_parser_tool import document_parser_tool
+from utils.search_tool import search_tool
+from utils.document_parser_tool import document_parser_tool
 
-tools = [search_tool, document_parser_tool]
+tools_default = [search_tool, document_parser_tool]