Final fix

tools/__init__.py

@@ -4,13 +4,11 @@ Contains implementations of various tools used by the agent to process different
 """
 
 from .base_tool import EnhancedTool
-from .file_tools import FileOpenerTool
-from .task_file_downloader_tool import TaskFileDownloaderTool
+from .file_download_tool import TaskFileDownloaderTool, FileOpenerTool
 from .image_analysis_tool import ImageAnalysisTool
 from .youtube_tool import YouTubeTranscriptTool
 from .excel_analysis_tool import ExcelAnalysisTool
 from .text_processing_tool import TextProcessingTool
-from .code_interpreter_tool import CodeInterpreterTool
 from .math_tool import MathematicalReasoningTool
 
 __all__ = [
@@ -21,6 +19,5 @@ __all__ = [
     "YouTubeTranscriptTool",
     "ExcelAnalysisTool",
     "TextProcessingTool",
-    "CodeInterpreterTool",
     "MathematicalReasoningTool"
 ] 

tools/code_interpreter_tool.py

@@ -1,174 +0,0 @@
-"""
-Enhanced code interpreter tool for the AI agent project.
-Handles Python code execution safely with proper error handling.
-"""
-
-import os
-import sys
-import io
-import traceback
-from typing import Optional
-from .base_tool import EnhancedTool
-
-class CodeInterpreterTool(EnhancedTool):
-    """Tool for executing and analyzing code files."""
-    
-    name = "CodeInterpreterTool"
-    description = "Execute Python code from a file and return the output. Useful for determining what a code snippet outputs."
-    inputs = {
-        "task_id": {
-            "type": "string",
-            "description": "Task ID for which the code file has been downloaded"
-        },
-        "query": {
-            "type": "string",
-            "description": "Specific question about the code output",
-            "nullable": True
-        }
-    }
-    output_type = "string"
-    
-    def forward(self, task_id: str, query: Optional[str] = None) -> str:
-        """
-        Execute Python code and return its output.
-        
-        Args:
-            task_id: Task ID for which the code file has been downloaded
-            query: Question about the code (optional)
-            
-        Returns:
-            Execution result or error message
-        """
-        filename = f"{task_id}_downloaded_file"
-        
-        if not os.path.exists(filename):
-            return f"Error: Code file {filename} does not exist. Please download it first."
-        
-        try:
-            # Read the file content
-            with open(filename, 'r', encoding='utf-8') as file:
-                code = file.read()
-            
-            # Capture stdout/stderr to get the output
-            old_stdout = sys.stdout
-            old_stderr = sys.stderr
-            redirected_output = io.StringIO()
-            redirected_error = io.StringIO()
-            sys.stdout = redirected_output
-            sys.stderr = redirected_error
-            
-            # Create a namespace to capture variables
-            exec_namespace = {}
-            
-            try:
-                # Execute the code
-                exec(code, exec_namespace)
-                
-                # Get output
-                output = redirected_output.getvalue()
-                error = redirected_error.getvalue()
-                
-                # Get the final variable value if needed
-                final_value = None
-                if query and "final" in query.lower() and "output" in query.lower():
-                    # Look for 'result' or a final print statement
-                    if "result" in exec_namespace:
-                        final_value = str(exec_namespace["result"])
-                    elif "answer" in exec_namespace:
-                        final_value = str(exec_namespace["answer"])
-                    elif "output" in exec_namespace:
-                        final_value = str(exec_namespace["output"])
-                    elif output.strip():
-                        # Get the last line of output as final value
-                        final_value = output.strip().split('\n')[-1]
-                    else:
-                        # Analyze globals for potential final values
-                        final_vars = [v for k, v in exec_namespace.items() 
-                                    if not k.startswith('__') and k not in ['__builtins__']]
-                        if final_vars:
-                            final_value = str(final_vars[-1])
-                
-                # Compile the result based on what was requested
-                if final_value:
-                    return final_value
-                elif output:
-                    return output
-                elif error:
-                    return f"Code execution produced errors: {error}"
-                else:
-                    return "Code executed without output."
-                    
-            except Exception as exec_error:
-                error_msg = f"Error executing code: {str(exec_error)}\n{traceback.format_exc()}"
-                return error_msg
-            
-            finally:
-                # Reset stdout/stderr
-                sys.stdout = old_stdout
-                sys.stderr = old_stderr
-            
-        except Exception as e:
-            return f"Error processing code file: {str(e)}"
-    
-    def _simulate_code_analysis(self, query: Optional[str] = None) -> str:
-        """
-        Simulate code analysis.
-        
-        Args:
-            query: Analysis query
-            
-        Returns:
-            Simulated analysis results
-        """
-        if not query:
-            # Default analysis
-            return """
-Code Analysis:
-- Language: Python
-- 5 functions defined
-- 2 classes defined
-- Dependencies: os, sys, numpy, pandas
-- Complexity: Moderate
-"""
-        
-        query_lower = query.lower()
-        
-        if "explain" in query_lower or "what does" in query_lower:
-            return """
-Explanation:
-This code defines a data processing pipeline that:
-1. Reads data from input files
-2. Performs various cleaning operations (handling missing values, normalization)
-3. Applies a machine learning algorithm (appears to be a simple regression model)
-4. Outputs predictions to a file
-
-The main function orchestrates the pipeline, while helper functions handle individual tasks.
-"""
-        elif "complexity" in query_lower or "efficiency" in query_lower:
-            return """
-Complexity Analysis:
-- Time Complexity: O(n²) due to nested loops in the data processing function
-- Space Complexity: O(n) as it stores the entire dataset in memory
-- Potential Optimization: The nested loop could be vectorized using NumPy operations to improve performance
-"""
-        elif "bug" in query_lower or "error" in query_lower or "fix" in query_lower:
-            return """
-Issues Identified:
-1. Potential division by zero in line 42 when denominator is zero
-2. Unclosed file in read_data function (missing 'with' statement)
-3. Variable 'result' might be referenced before assignment in some code paths
-"""
-        elif "test" in query_lower or "execute" in query_lower or "run" in query_lower:
-            return """
-Execution Result:
-The code ran successfully with the following output:
-- Processed 1000 records
-- Applied transformation to 950 valid entries
-- Output saved to 'results.txt'
-- Execution time: 1.24 seconds
-"""
-        else:
-            return """
-General Code Assessment:
-The code appears to be a Python script that performs data processing and analysis. It follows standard coding practices but could benefit from better error handling and documentation. The main functionality seems sound, but there are opportunities for optimization and improved structure.
-""" 

tools/excel_analysis_tool.py

@@ -44,8 +44,20 @@ class ExcelAnalysisTool(EnhancedTool):
             if not os.path.exists(filename):
                 return f"Error: File for task {task_id} does not exist. Please download it first."
             
-            # Read the Excel file
-            df = pd.read_excel(filename, engine="openpyxl")
+            # Try to determine file type and read accordingly
+            try:
+                # First try Excel format
+                df = pd.read_excel(filename, engine="openpyxl")
+            except Exception as excel_error:
+                # If Excel reading fails, try CSV
+                try:
+                    df = pd.read_csv(filename)
+                except Exception as csv_error:
+                    # If CSV reading fails, try TSV
+                    try:
+                        df = pd.read_csv(filename, sep='\t')
+                    except Exception as tsv_error:
+                        return f"Error: Unable to read file as Excel, CSV, or TSV. Original error: {str(excel_error)}"
             
             # Basic analysis if no specific query
             if not query:

tools/file_tools.py

@@ -1,110 +0,0 @@
-"""
-File-related tools for the AI agent project.
-"""
-
-import os
-import requests
-from typing import Optional
-from .base_tool import EnhancedTool
-
-# Constants
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-
-class FileDownloaderTool(EnhancedTool):
-    """Tool for downloading files associated with a task ID."""
-    
-    name = "FileDownloaderTool"
-    description = "Download a specific file associated with a given task ID and save it locally"
-    inputs = {
-        "task_id": {
-            "type": "string",
-            "description": "Task ID for which to download the associated file"
-        }
-    }
-    output_type = "string"
-    
-    def forward(self, task_id: str) -> str:
-        """
-        Download a file associated with a task ID.
-        
-        Args:
-            task_id: Task ID for which to download the file
-            
-        Returns:
-            Status message
-        """
-        try:
-            # Construct the download URL
-            download_url = f"{DEFAULT_API_URL}/files/{task_id}"
-            
-            # Send the request to download the file
-            response = requests.get(download_url, timeout=30)
-            response.raise_for_status()
-            
-            # Save the file
-            filename = f"{task_id}_downloaded_file"
-            with open(filename, "wb") as f:
-                f.write(response.content)
-            
-            return f"File downloaded successfully and saved as: {filename}"
-            
-        except requests.exceptions.RequestException as e:
-            return f"Error downloading file: {str(e)}"
-        except Exception as e:
-            return f"Unexpected error: {str(e)}"
-
-
-class FileOpenerTool(EnhancedTool):
-    """Tool for opening and reading downloaded files."""
-    
-    name = "FileOpenerTool"
-    description = "Open a downloaded file associated with a task ID and read its contents as plain text."
-    inputs = {
-        "task_id": {
-            "type": "string",
-            "description": "Task ID for which the file has been downloaded"
-        },
-        "num_lines": {
-            "type": "integer",
-            "description": "Number of lines to read from the file",
-            "nullable": True
-        }
-    }
-    output_type = "string"
-    
-    def forward(self, task_id: str, num_lines: int = None) -> str:
-        """
-        Open and read a downloaded file.
-        
-        Args:
-            task_id: Task ID for which the file has been downloaded
-            num_lines: Number of lines to read
-            
-        Returns:
-            File contents
-        """
-        # Construct the filename
-        filename = f"{task_id}_downloaded_file"
-        
-        # Check if file exists
-        if not os.path.exists(filename):
-            return f"Error: File {filename} does not exist."
-            
-        try:
-            # Try to read the file as text
-            with open(filename, "r", encoding="utf-8", errors="ignore") as file:
-                if num_lines:
-                    # Read specified number of lines
-                    lines = []
-                    for i in range(num_lines):
-                        line = file.readline()
-                        if not line:
-                            break
-                        lines.append(line.strip())
-                    return "\n".join(lines)
-                else:
-                    # Read the entire file
-                    return file.read()
-                    
-        except Exception as e:
-            return f"Error reading file: {str(e)}" 

tools/task_file_downloader_tool.py

@@ -1,60 +0,0 @@
-"""
-Simple file downloader tool for the AI agent project.
-Uses the approach from the course example.
-"""
-
-import os
-import requests
-from .base_tool import EnhancedTool
-
-# Constants
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-
-class TaskFileDownloaderTool(EnhancedTool):
-    """Tool for downloading files associated with a task ID."""
-    
-    name = "TaskFileDownloaderTool"
-    description = "Download a specific file associated with a given task ID and save it locally."
-    inputs = {
-        "task_id": {
-            "type": "string",
-            "description": "Task ID for which to download the associated file"
-        },
-        "file_name": {
-            "type": "string",
-            "description": "Optional file name to download",
-            "nullable": True
-        }
-    }
-    output_type = "string"
-    
-    def forward(self, task_id: str, file_name: str = None) -> str:
-        """
-        Download a file associated with a task ID.
-        
-        Args:
-            task_id: Task ID of the task
-            file_name: Optional file name to download
-            
-        Returns:
-            Status message
-        """
-        try:
-            # Determine which identifier to use for download
-            download_id = file_name if file_name else task_id
-            
-            download_url = f"{DEFAULT_API_URL}/files/{download_id}"
-            response = requests.get(download_url, timeout=30)
-            
-            if response.status_code == 200:
-                # Save the file with a consistent naming scheme
-                filename = f"{task_id}_downloaded_file"
-                with open(filename, "wb") as f:
-                    f.write(response.content)
-                
-                return f"File downloaded successfully and saved as: {filename}"
-            else:
-                return f"Failed to download file. Status code: {response.status_code}"
-                
-        except Exception as e:
-            return f"Error downloading file: {str(e)}"