Update app.py

app.py

@@ -1,23 +1,382 @@
 import os
 import gradio as gr
 import requests
-import inspect
 import pandas as pd
+from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, tool
+import re
+import json
+import math
+import tempfile
+from pathlib import Path
+from urllib.parse import urlparse, parse_qs
+import yt_dlp
+from PIL import Image
+import pytesseract
 
-# (Keep Constants as is)
-# --- Constants ---
+hf_token = os.getenv("HF_TOKEN")
+SPACE_ID = os.getenv("SPACE_ID")
+SPACE_HOST = os.getenv("SPACE_HOST")
+# --- OUTILS CRITIQUES POUR GAIA ---
+@tool
+def web_browser(url: str) -> str:
+    """
+    Fetches content from a web URL.
+    
+    Args:
+        url: The URL to fetch content from.
+        
+    Returns:
+        Text content from the webpage.
+    """
+    try:
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        }
+        response = requests.get(url, headers=headers, timeout=10)
+        response.raise_for_status()
+        
+        # Simple text extraction (you might want to use BeautifulSoup for better parsing)
+        content = response.text
+        # Basic cleaning
+        content = re.sub(r'<[^>]+>', ' ', content)  # Remove HTML tags
+        content = re.sub(r'\s+', ' ', content).strip()  # Clean whitespace
+        
+        return content[:2000] + "..." if len(content) > 2000 else content
+        
+    except Exception as e:
+        return f"Error accessing URL: {str(e)}"
+
+@tool
+def youtube_transcript_extractor(url: str) -> str:
+    """
+    Extracts transcript or information from YouTube videos.
+    
+    Args:
+        url: YouTube URL.
+        
+    Returns:
+        Video information and transcript if available.
+    """
+    try:
+        # Extract video ID from URL
+        if "youtube.com/watch" in url:
+            video_id = parse_qs(urlparse(url).query).get('v', [None])[0]
+        elif "youtu.be/" in url:
+            video_id = urlparse(url).path[1:]
+        else:
+            return "Invalid YouTube URL format"
+            
+        if not video_id:
+            return "Could not extract video ID from URL"
+        
+        # Use youtube-dl to get video info
+        ydl_opts = {
+            'quiet': True,
+            'no_warnings': True,
+            'writesubtitles': True,
+            'writeautomaticsub': True,
+        }
+        
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            info = ydl.extract_info(f"https://www.youtube.com/watch?v={video_id}", download=False)
+            
+            result = f"Title: {info.get('title', 'N/A')}\n"
+            result += f"Description: {info.get('description', 'N/A')[:500]}...\n"
+            result += f"Duration: {info.get('duration', 'N/A')} seconds\n"
+            result += f"View count: {info.get('view_count', 'N/A')}\n"
+            
+            # Try to get subtitles/transcript
+            if 'subtitles' in info and info['subtitles']:
+                result += "\n--- Transcript Available ---\n"
+                # This is a simplified approach - you'd need more complex logic for full transcript
+                
+            return result
+            
+    except Exception as e:
+        return f"Error extracting YouTube content: {str(e)}"
+
+@tool
+def image_ocr_analyzer(image_path: str) -> str:
+    """
+    Performs OCR on images to extract text.
+    
+    Args:
+        image_path: Path to the image file.
+        
+    Returns:
+        Extracted text from the image.
+    """
+    try:
+        # Open image with PIL
+        image = Image.open(image_path)
+        
+        # Perform OCR
+        extracted_text = pytesseract.image_to_string(image)
+        
+        if not extracted_text.strip():
+            return "No text found in the image"
+            
+        return f"Extracted text:\n{extracted_text.strip()}"
+        
+    except Exception as e:
+        return f"Error performing OCR: {str(e)}"
+
+@tool
+def pdf_text_extractor(file_path: str) -> str:
+    """
+    Extracts text from PDF files.
+    
+    Args:
+        file_path: Path to the PDF file.
+        
+    Returns:
+        Extracted text from PDF.
+    """
+    try:
+        import PyPDF2
+        
+        with open(file_path, 'rb') as file:
+            pdf_reader = PyPDF2.PdfReader(file)
+            text = ""
+            
+            for page_num in range(len(pdf_reader.pages)):
+                page = pdf_reader.pages[page_num]
+                text += page.extract_text() + "\n"
+                
+        return text[:3000] + "..." if len(text) > 3000 else text
+        
+    except Exception as e:
+        return f"Error extracting PDF text: {str(e)}"
+
+@tool
+def veterinary_document_analyzer(text: str) -> str:
+    """
+    Analyzes veterinary documents to extract specific information like names.
+    
+    Args:
+        text: Document text to analyze.
+        
+    Returns:
+        Extracted veterinary information.
+    """
+    try:
+        # Look for veterinarian names and surnames
+        vet_patterns = [
+            r"Dr\.?\s+([A-Z][a-z]+)\s+([A-Z][a-z]+)",  # Dr. First Last
+            r"Doctor\s+([A-Z][a-z]+)\s+([A-Z][a-z]+)",  # Doctor First Last
+            r"veterinarian\s+([A-Z][a-z]+)\s+([A-Z][a-z]+)",  # veterinarian First Last
+            r"DVM\s+([A-Z][a-z]+)\s+([A-Z][a-z]+)",  # DVM First Last
+        ]
+        
+        found_vets = []
+        for pattern in vet_patterns:
+            matches = re.findall(pattern, text, re.IGNORECASE)
+            for match in matches:
+                full_name = f"{match[0]} {match[1]}"
+                if full_name not in found_vets:
+                    found_vets.append(full_name)
+        
+        if found_vets:
+            return f"Found veterinarian(s): {', '.join(found_vets)}"
+        else:
+            return "No veterinarian names found in the document"
+            
+    except Exception as e:
+        return f"Error analyzing veterinary document: {str(e)}"
+
+# --- Outils existants améliorés ---
+@tool
+def analyze_excel_file(file_path: str, analysis_type: str = "general") -> str:
+    """
+    Analyzes Excel files with multiple analysis types.
+    """
+    try:
+        df = pd.read_excel(file_path)
+
+        if analysis_type == "general":
+            return f"Excel file contains {len(df)} rows and {len(df.columns)} columns. Columns: {list(df.columns)}"
+
+        elif analysis_type == "food_sales":
+            if 'category' in df.columns and 'price' in df.columns and 'quantity' in df.columns:
+                food_df = df[df['category'].str.lower() == 'food']
+                total_sales = (food_df['price'] * food_df['quantity']).sum()
+                return f"Total food sales: ${total_sales:.2f}"
+            else:
+                return "Required columns (category, price, quantity) not found"
+
+        elif analysis_type == "summary":
+            summary = df.describe(include='all').to_string()
+            return f"Data summary:\n{summary}"
+
+        elif analysis_type == "categories":
+            if 'category' in df.columns:
+                categories = df['category'].value_counts()
+                return f"Categories breakdown:\n{categories.to_string()}"
+            else:
+                return "No category column found"
+
+        return "Unknown analysis type"
+
+    except Exception as e:
+        return f"Error analyzing Excel file: {str(e)}"
+
+@tool
+def advanced_calculator(expression: str) -> str:
+    """
+    Evaluates mathematical expressions safely, including advanced functions.
+    """
+    try:
+        expression = expression.replace('^', '**')
+        allowed_functions = {
+            'abs': abs, 'round': round, 'min': min, 'max': max,
+            'sum': sum, 'len': len,
+            'sqrt': math.sqrt, 'pow': math.pow, 'log': math.log,
+            'sin': math.sin, 'cos': math.cos, 'tan': math.tan,
+            'pi': math.pi, 'e': math.e,
+            'floor': math.floor, 'ceil': math.ceil
+        }
+        result = eval(expression, {"__builtins__": {}}, allowed_functions)
+        return str(result)
+
+    except Exception as e:
+        return f"Error in calculation: {str(e)}"
+
+@tool
+def smart_text_analyzer(text: str, task_type: str = "general") -> str:
+    """
+    Analyzes text with focus on GAIA-specific tasks.
+    
+    Args:
+        text: Text to analyze.
+        task_type: 'general', 'names', 'dates', 'numbers', 'veterinary'.
+        
+    Returns:
+        Analysis results.
+    """
+    try:
+        if task_type == "names":
+            # Extract proper names
+            name_pattern = r'\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*\b'
+            names = re.findall(name_pattern, text)
+            return f"Found names: {list(set(names))}"
+            
+        elif task_type == "veterinary":
+            return veterinary_document_analyzer(text)
+            
+        elif task_type == "dates":
+            date_patterns = [
+                r'\d{1,2}/\d{1,2}/\d{4}',  # MM/DD/YYYY
+                r'\d{4}-\d{2}-\d{2}',      # YYYY-MM-DD
+                r'\b\w+\s+\d{1,2},\s+\d{4}\b'  # Month DD, YYYY
+            ]
+            dates = []
+            for pattern in date_patterns:
+                dates.extend(re.findall(pattern, text))
+            return f"Found dates: {dates}"
+            
+        elif task_type == "numbers":
+            numbers = re.findall(r'-?\d+\.?\d*', text)
+            return f"Found numbers: {[float(n) for n in numbers if n]}"
+            
+        else:
+            return f"Characters: {len(text)}, Words: {len(text.split())}, Lines: {len(text.splitlines())}"
+
+    except Exception as e:
+        return f"Error in text analysis: {str(e)}"
+
+# --- Configuration du modèle OPTIMISÉE ---
+# Changer pour un modèle plus léger qui ne dépasse pas ton quota
+model = HfApiModel(
+    max_tokens=2048,  # Réduit pour économiser le quota
+    temperature=0.1,
+    model_id='microsoft/DialoGPT-medium',  # Modèle plus léger
+    # Ou essaye: 'HuggingFaceH4/zephyr-7b-beta' si disponible
+)
+
+# --- Initialisation des outils ---
+search_tool = DuckDuckGoSearchTool()
+
+# IMPORTANT: Ajouter TOUS les outils à la liste
+tools = [
+    search_tool,  # ⚠️ TU AVAIS OUBLIÉ ÇA !
+    web_browser,
+    youtube_transcript_extractor,
+    image_ocr_analyzer,
+    pdf_text_extractor,
+    veterinary_document_analyzer,
+    smart_text_analyzer,
+    advanced_calculator,
+    analyze_excel_file,
+]
+
+# Agent avec plus d'étapes pour les tâches complexes
+agent_code = CodeAgent(
+    tools=tools,
+    model=model,
+    max_steps=15,  # Augmenté pour les tâches complexes GAIA
+    additional_authorized_imports=[
+        "os", "tempfile", "pathlib", "re", "json", "math", "pandas",
+        "requests", "PIL", "pytesseract", "PyPDF2", "yt_dlp"
+    ]
+)
 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.")
+        print("Enhanced GAIA Agent initialized with web browsing capabilities.")
+        self.agent = agent_code
+
     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
+        try:
+            # Prompt amélioré spécifiquement pour GAIA
+            enhanced_question = self._create_gaia_prompt(question)
+            
+            result = self.agent.run(enhanced_question)
+            
+            # Post-processing pour GAIA
+            cleaned_result = self._clean_gaia_result(result)
+            
+            return cleaned_result if cleaned_result else "No response generated."
+        
+        except Exception as e:
+            print(f"Agent error: {e}")
+            # Fallback strategy
+            try:
+                fallback_prompt = f"""
+                CRITICAL GAIA TASK: {question}
+                
+                Use available tools to find the answer. If it's a YouTube video, use youtube_transcript_extractor.
+                If it's about documents, use appropriate analyzers.
+                Be precise and direct in your final answer.
+                """
+                simple_result = self.agent.run(fallback_prompt)
+                return simple_result if simple_result else f"Error: {e}"
+            except:
+                return f"Error: {e}"
+    
+    def _create_gaia_prompt(self, question: str) -> str:
+        """Crée un prompt optimisé pour GAIA."""
+        return f"""
+        GAIA EVALUATION TASK - ANSWER PRECISELY
+        
+        Question: {question}
+        
+        INSTRUCTIONS:
+        1. If this involves a YouTube video, use youtube_transcript_extractor tool
+        2. If this involves web content, use web_browser tool  
+        3. If this involves documents/PDFs, use appropriate analyzers
+        4. If this involves images, use image_ocr_analyzer
+        5. If this needs search, use the search tool
+        6. For calculations, use advanced_calculator
+        7. Be EXACT and SPECIFIC in your final answer
+        8. Don't provide explanations unless asked - just the answer
+        
+        Work step by step and use the right tools for this task.
+        """
+
+
+
+
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """