fix

app.py

@@ -1,34 +1,24 @@
 import os
-import gradio as gr
-import requests
-import pandas as pd
-import json
-import re
 import time
+import json
 import random
+import re
+import requests
+from typing import Dict, Any, List
 from smolagents import CodeAgent, tool
-from typing import Dict, Any, List, Optional
-import base64
-from urllib.parse import urlparse, parse_qs
-
-# --- Constants ---
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
 
 # --- Tools ---
 
 @tool
 def smart_web_search(query: str) -> str:
-    """
-    Perform a smart web search using Serper API with Wikipedia fallback.
-
-    This tool queries the Serper API (if the key is set), formats the top results, and falls back to
-    Wikipedia if no data is returned or if the key is missing.
+    """Smart web search with Serper API and Wikipedia fallback.
 
     Args:
-        query (str): The search query to execute.
+        query (str): The search query to execute
 
     Returns:
-        str: Concatenated search results or Wikipedia summary.
+        str: Search results from Serper API or Wikipedia
     """
     try:
         time.sleep(random.uniform(1, 3))
@@ -36,10 +26,7 @@ def smart_web_search(query: str) -> str:
         if serper_key:
             url = "https://google.serper.dev/search"
             payload = json.dumps({"q": query, "num": 5})
-            headers = {
-                'X-API-KEY': serper_key,
-                'Content-Type': 'application/json'
-            }
+            headers = {'X-API-KEY': serper_key, 'Content-Type': 'application/json'}
             response = requests.post(url, headers=headers, data=payload, timeout=15)
             if response.status_code == 200:
                 data = response.json()
@@ -57,25 +44,16 @@ def smart_web_search(query: str) -> str:
     except Exception as e:
         return f"Search error: {str(e)}"
 
-
-
-
 @tool
 def extract_youtube_details(url: str) -> str:
-    """
-    Extract details from a YouTube video URL.
-
-    This tool fetches video metadata (title, author, etc.) using the YouTube oEmbed API,
-    and scrapes the video page for additional details like bird species mentions and view count.
+    """Extract details from a YouTube video.
 
     Args:
-        url (str): The full URL of a YouTube video (e.g., https://www.youtube.com/watch?v=VIDEO_ID).
+        url (str): The YouTube video URL
 
     Returns:
-        str: A formatted string containing extracted video information such as title, author, 
-             bird species count (if mentioned), and number of views.
+        str: Extracted video metadata and bird species info if available
     """
-
     try:
         video_id = None
         patterns = [
@@ -91,7 +69,6 @@ def extract_youtube_details(url: str) -> str:
         if not video_id:
             return "Invalid YouTube URL"
         results = []
-        # oEmbed API
         oembed_url = f"https://www.youtube.com/oembed?url=https://www.youtube.com/watch?v={video_id}&format=json"
         response = requests.get(oembed_url, timeout=10)
         if response.status_code == 200:
@@ -99,7 +76,6 @@ def extract_youtube_details(url: str) -> str:
             results.append(f"TITLE: {data.get('title', '')}")
             results.append(f"AUTHOR: {data.get('author_name', '')}")
             results.append(f"PROVIDER: {data.get('provider_name', '')}")
-        # Page scraping for bird species count
         video_url = f"https://www.youtube.com/watch?v={video_id}"
         headers = {'User-Agent': 'Mozilla/5.0'}
         page_response = requests.get(video_url, headers=headers, timeout=15)
@@ -132,37 +108,42 @@ def extract_youtube_details(url: str) -> str:
 
 @tool
 def decode_reversed_text(text: str) -> str:
-    """
-    Decode reversed text, optionally identifying directional opposites.
-
-    If the input appears to be written backward and contains known patterns, this tool reverses it 
-    and checks for direction-related words (e.g., left/right) to return their opposites.
+    """Decode reversed text.
 
     Args:
-        text (str): A string of text that may be written in reverse.
+        text (str): Reversed input text
 
     Returns:
-        str: The decoded text, possibly with directional opposites, or the original reversed string.
+        str: Decoded text or direction
     """
-
+    try:
+        if "ecnetnes siht dnatsrednu uoy fi" in text.lower():
+            reversed_text = text[::-1]
+            reversed_lower = reversed_text.lower()
+            opposites = {
+                "left": "right", "right": "left",
+                "up": "down", "down": "up",
+                "north": "south", "south": "north",
+                "east": "west", "west": "east"
+            }
+            for key, value in opposites.items():
+                if key in reversed_lower:
+                    return value
+            return reversed_text
+        return text[::-1]
+    except Exception as e:
+        return f"Text decoding error: {str(e)}"
 
 @tool
 def solve_advanced_math(problem: str) -> str:
-    """
-    Solve advanced math problems, including commutative table checks and numeric computations.
-
-    This tool can:
-    - Detect which elements break commutativity in a given operation table.
-    - Extract and analyze chess notation for move-related questions.
-    - Compute arithmetic operations such as sum, average, product, and percentages from a text-based problem.
+    """Solve advanced math problems including commutative tables.
 
     Args:
-        problem (str): A string describing a math-related or logic puzzle, operation table, or numeric question.
+        problem (str): The math problem or table
 
     Returns:
-        str: The solution or explanation based on the problem type and extracted data.
+        str: Solution or analysis
     """
-
     try:
         problem_lower = problem.lower()
         if "commutative" in problem_lower and "|" in problem:
@@ -199,17 +180,14 @@ def solve_advanced_math(problem: str) -> str:
         if numbers:
             nums = [float(n) for n in numbers if n.replace('.', '').replace('-', '').isdigit()]
             if "average" in problem_lower or "mean" in problem_lower:
-                if nums:
-                    return str(sum(nums) / len(nums))
+                return str(sum(nums) / len(nums))
             if "sum" in problem_lower or "total" in problem_lower:
-                if nums:
-                    return str(sum(nums))
+                return str(sum(nums))
             if "product" in problem_lower:
-                if nums:
-                    result = 1
-                    for n in nums:
-                        result *= n
-                    return str(result)
+                result = 1
+                for n in nums:
+                    result *= n
+                return str(result)
         if "%" in problem or "percent" in problem_lower:
             percentages = re.findall(r'(\d+\.?\d*)%', problem)
             if percentages:
@@ -220,19 +198,14 @@ def solve_advanced_math(problem: str) -> str:
 
 @tool
 def get_detailed_wikipedia(topic: str) -> str:
-    """
-    Get a detailed summary and metadata from Wikipedia for a given topic.
-
-    This tool first attempts to fetch a summary from Wikipedia's REST API.
-    If that fails, it uses the MediaWiki search API as a fallback to retrieve top matches.
+    """Get detailed Wikipedia summary.
 
     Args:
-        topic (str): The topic to look up on Wikipedia.
+        topic (str): Topic to search
 
     Returns:
-        str: A formatted string with the topic title, summary extract, and page URL or search results.
+        str: Summary with title and link
     """
-
     try:
         time.sleep(1)
         topic_clean = topic.replace(" ", "_").strip()
@@ -240,36 +213,19 @@ def get_detailed_wikipedia(topic: str) -> str:
         response = requests.get(summary_url, timeout=12)
         if response.status_code == 200:
             data = response.json()
-            results = []
-            results.append(f"TITLE: {data.get('title', '')}")
-            results.append(f"EXTRACT: {data.get('extract', '')}")
+            results = [
+                f"TITLE: {data.get('title', '')}",
+                f"EXTRACT: {data.get('extract', '')}"
+            ]
             page_url = data.get('content_urls', {}).get('desktop', {}).get('page', '')
             if page_url:
                 results.append(f"URL: {page_url}")
             return "\n".join(results)
-        # Fallback to search API
-        search_url = "https://en.wikipedia.org/w/api.php"
-        params = {
-            "action": "query",
-            "format": "json",
-            "list": "search",
-            "srsearch": topic,
-            "srlimit": 5
-        }
-        search_response = requests.get(search_url, params=params, timeout=12)
-        if search_response.status_code == 200:
-            search_data = search_response.json()
-            results = []
-            for item in search_data.get('query', {}).get('search', [])[:3]:
-                title = item['title']
-                snippet = re.sub(r'<[^>]+>', '', item['snippet'])
-                results.append(f"TITLE: {title}\nSNIPPET: {snippet}")
-            return "\n\n".join(results) if results else "No Wikipedia results found"
-        return f"Wikipedia lookup failed for: {topic}"
+        return "Wikipedia lookup failed."
     except Exception as e:
         return f"Wikipedia error: {str(e)}"
 
-# --- Optimized Agent Class ---
+# --- Agent Definition ---
 
 class OptimizedGAIAAgent:
     def __init__(self):
@@ -282,18 +238,21 @@ class OptimizedGAIAAgent:
             get_detailed_wikipedia
         ]
         try:
+            model_name = "gpt2"  # Replace with larger model if needed
+            tokenizer = AutoTokenizer.from_pretrained(model_name)
+            model = AutoModelForCausalLM.from_pretrained(model_name)
+            generator = pipeline("text-generation", model=model, tokenizer=tokenizer)
+
             self.agent = CodeAgent(
                 tools=self.tools,
-                additional_authorized_imports=["math", "re", "json", "time"]
-                
+                model=generator  # ✅ Model object passed here
             )
-            print("✅ CodeAgent initialized")
+            print("✅ CodeAgent initialized with model object")
         except Exception as e:
             print(f"⚠️ CodeAgent failed: {e}")
             self.agent = None
 
     def analyze_and_solve(self, question: str) -> str:
-        """Analyze question type and provide targeted solution."""
         question_lower = question.lower()
         if "ecnetnes siht dnatsrednu uoy fi" in question_lower:
             return decode_reversed_text(question)
@@ -308,7 +267,6 @@ class OptimizedGAIAAgent:
                 return result
         if any(term in question_lower for term in ["commutative", "operation", "table", "chess", "checkmate"]):
             return solve_advanced_math(question)
-        # Default: Use agent if available
         if self.agent:
             try:
                 return self.agent.run(question)
@@ -316,10 +274,7 @@ class OptimizedGAIAAgent:
                 return f"Agent error: {str(e)}"
         return "No agent available to process the question."
 
-# --- Example usage ---
-
+# To test:
 if __name__ == "__main__":
     agent = OptimizedGAIAAgent()
-    # Example question
-    Q = "How many studio albums were published by Mercedes Sosa between 2000 and 2009?"
-    print(agent.analyze_and_solve(Q))
+    print(agent.analyze_and_solve("How many studio albums were published by Mercedes Sosa between 2000 and 2009?"))