Update app.py

app.py

@@ -3,41 +3,92 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
-
-from smolagents import CodeAgent, InferenceClientModel, DuckDuckGoSearchTool
-
+import time
+from smolagents import CodeAgent, WikipediaSearchTool, DuckDuckGoSearchTool, OpenAIServerModel
+from PIL import Image
+from io import BytesIO
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-
+GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-class BasicAgent:
-    def __init__(self):
-        print("BasicAgent initialized.")
-    def __call__(self, question: str) -> str:
-        print(f"Agent received question (first 50 chars): {question[:50]}...")
-        fixed_answer = "This is a default answer."
-        print(f"Agent returning fixed answer: {fixed_answer}")
-        return fixed_answer
+# class BasicAgent:
+#     def __init__(self):
+#         print("BasicAgent initialized.")
+#     def __call__(self, question: str) -> str:
+#         print(f"Agent received question (first 50 chars): {question[:50]}...")
+#         fixed_answer = "This is a default answer."
+#         print(f"Agent returning fixed answer: {fixed_answer}")
+#         return fixed_answer
 
+def is_valid_image_pillow(file_name):
+    try:
+        with Image.open(file_name) as img:
+            img.verify()  # Verify the image file
+        return True
+    except (IOError, SyntaxError):
+        return False
 
 class myAgent:
     def __init__(self):
         print("myAgent initialized.")
         
         self.agent = CodeAgent(
-            model=InferenceClientModel(provider='novita'),
-            tools=[DuckDuckGoSearchTool()],#, WikipediaSearchTool(), SpeechToTextTool(), ExcelToTextTool()],
+            model = OpenAIServerModel(
+                model_id="gemini-2.0-flash-lite",
+                api_base="https://generativelanguage.googleapis.com/v1beta/openai/",
+                api_key=GEMINI_API_KEY,
+            ),
+            tools=[DuckDuckGoSearchTool(), WikipediaSearchTool()],
             add_base_tools=True,
-            additional_authorized_imports=['pandas','numpy','csv']
+            # additional_authorized_imports=['pandas','numpy','csv']
         )
         
-    def __call__(self, question: str) -> str:
+    def __call__(self, question: str, file_data=None) -> str: # Renamed img to file_data
         print(f"Agent received question (first 50 chars): {question[:50]}...")
-        fixed_answer = self.agent.run(question)
-        print(f"Agent returning fixed answer: {fixed_answer}")
-        return fixed_answer
+        
+        images_for_agent = [] # List to hold image objects
+        text_from_file = "" # String to hold text content from files
+
+        if file_data:
+            print(f"Agent received file data of size: {len(file_data)} bytes")
+            # Attempt to open as an image
+            try:
+                img_obj = Image.open(BytesIO(file_data))
+                img_obj.verify() # Verify if it's a valid image
+                images_for_agent.append(img_obj)
+                print("File identified as an image.")
+            except (IOError, SyntaxError):
+                print("File is not an image, attempting to decode as text.")
+                # If not an image, try to decode as text
+                try:
+                    text_from_file = file_data.decode('utf-8')
+                    # You might want to add more sophisticated parsing here for CSV/JSON/etc.
+                    # For example, if it's a CSV:
+                    # df = pd.read_csv(StringIO(text_from_file))
+                    # text_from_file = df.to_string() # Convert DataFrame to string for agent
+                    print(f"File decoded as text (first 200 chars): {text_from_file[:200]}...")
+                except UnicodeDecodeError:
+                    text_from_file = f"Could not decode file as UTF-8 text. Raw bytes size: {len(file_data)}"
+                    print("File could not be decoded as UTF-8 text.")
+            except Exception as e:
+                print(f"Unexpected error processing file data: {e}")
+                text_from_file = f"Error processing file: {e}"
+
+        # Combine question with file content if available
+        if text_from_file:
+            # You might want to prepend or append, or format this more intelligently
+            question_with_file_context = f"{question}\n\n[FILE CONTENT START]\n{text_from_file}\n[FILE CONTENT END]"
+        else:
+            question_with_file_context = question
+
+        # Pass images and the possibly augmented question to the CodeAgent
+        answer = self.agent.run(question_with_file_context, images=images_for_agent if images_for_agent else None)
+        
+        time.sleep(5)
+        print(f"Agent returning answer: {answer}")
+        return answer
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
@@ -56,6 +107,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
     api_url = DEFAULT_API_URL
     questions_url = f"{api_url}/questions"
+    files_url = f"{api_url}/files"
     submit_url = f"{api_url}/submit"
 
     # 1. Instantiate Agent ( modify this part to create your agent)
@@ -96,20 +148,51 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     for item in questions_data:
         task_id = item.get("task_id")
         question_text = item.get("question")
+        file_name = item.get("file_name")
+        
+        file_content_to_pass = None # Initialize to None
+
+        if file_name:
+            # Fetch files
+            print(f"Fetching file '{file_name}' for task_id: {task_id}")
+            try:
+                response = requests.get(f'{files_url}/{task_id}', timeout=15, allow_redirects=True)
+                print("Response status code:", response.status_code)
+                if response.status_code == 404:
+                    print(f"File not found for task_id {task_id}. Skipping file processing for this task.")
+                    # Continue without a file, agent will still receive the question
+                else:
+                    response.raise_for_status()
+                    file_content_to_pass = response.content # Store the raw content
+                    print(f"Fetched file for task_id {task_id}: {file_name} (size: {len(file_content_to_pass)} bytes)")
+                    
+                    # Optional: Add specific handling for image files if your agent needs them
+                    # The `img` parameter in `myAgent.__call__` suggests it's designed for images.
+                    # If you want to pass image objects for image files, and raw content for others,
+                    # you'll need to adapt how `myAgent` uses the `img` parameter.
+                    # For now, we'll just pass the raw content.
+                    
+            except requests.exceptions.RequestException as e:
+                print(f"Error fetching file for task {task_id}: {e}. Agent will run without file.")
+                # Do not return here, allow agent to run with just the question if file fetch fails
+            except Exception as e:
+                print(f"An unexpected error occurred fetching file for task {task_id}: {e}. Agent will run without file.")
+                # Do not return here, allow agent to run with just the question if file fetch fails
+
         if not task_id or question_text is None:
             print(f"Skipping item with missing task_id or question: {item}")
             continue
         try:
-            submitted_answer = agent(question_text)
+            # Pass file_content_to_pass to the agent.
+            # Your agent's __call__ method needs to be ready to handle
+            # raw byte content for the 'img' parameter, or you might
+            # rename it to something more generic like 'file_data'.
+            submitted_answer = agent(question_text, file_content_to_pass)
             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})
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer, "File Name": file_name if file_name else "N/A"})
         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}"})
-
-    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)
+             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}", "File Name": file_name if file_name else "N/A"})
 
     # 4. Prepare Submission 
     submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}