Update app.py

app.py

@@ -1,81 +1,182 @@
-import asyncio
+from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, tool
 import datetime
 import requests
 import pytz
 import yaml
-from bs4 import BeautifulSoup  # For web scraping
-from PIL import Image  # For image processing
-from io import BytesIO
-from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, tool
 from tools.final_answer import FinalAnswerTool
 from Gradio_UI import GradioUI
+import bs4
+from PIL import Image
+import io
+import base64
 
-# Load image generation tool
-image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
-
-# Weather Tool (using wttr.in API, no API key needed)
+# Weather tool
 @tool
-def get_weather(city: str) -> str:
-    """Fetches the current weather for a given city.
+def get_weather(location: str) -> str:
+    """Fetch current weather information for a specified location.
+    
     Args:
-        city: The name of the city (e.g., 'London').
+        location: A string representing the city, state, or country.
     """
     try:
-        url = f"https://wttr.in/{city}?format=%C+%t+%w"
+        # Using OpenWeatherMap API (you'll need an API key)
+        api_key = "YOUR_OPENWEATHERMAP_API_KEY"  # Replace with your API key
+        url = f"https://api.openweathermap.org/data/2.5/weather?q={location}&appid={api_key}&units=metric"
         response = requests.get(url)
-        return f"Weather in {city}: {response.text}"
+        data = response.json()
+        
+        if response.status_code == 200:
+            weather_description = data['weather'][0]['description']
+            temperature = data['main']['temp']
+            humidity = data['main']['humidity']
+            wind_speed = data['wind']['speed']
+            
+            return f"Weather in {location}:\n" \
+                   f"Description: {weather_description}\n" \
+                   f"Temperature: {temperature}°C\n" \
+                   f"Humidity: {humidity}%\n" \
+                   f"Wind Speed: {wind_speed} m/s"
+        else:
+            return f"Error fetching weather for {location}: {data.get('message', 'Unknown error')}"
     except Exception as e:
-        return f"Error fetching weather: {str(e)}"
+        return f"Error fetching weather for {location}: {str(e)}"
 
-# Web Scraping Tool (Extracts headlines and articles from a given news website)
+# Web scraping tool
 @tool
-def scrape_news(url: str) -> str:
-    """Scrapes headlines and article text from a news website.
+def web_scrape(url: str, selector: str = None) -> str:
+    """Scrape content from a webpage.
+    
     Args:
-        url: The URL of the news site.
+        url: The URL of the webpage to scrape.
+        selector: Optional CSS selector to extract specific elements (default: None, returns full page text).
     """
     try:
-        headers = {'User-Agent': 'Mozilla/5.0'}
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+        }
         response = requests.get(url, headers=headers)
-        soup = BeautifulSoup(response.text, 'html.parser')
         
-        # Extracting headlines
-        headlines = [h.get_text() for h in soup.find_all('h1')][:5]
-        articles = [p.get_text() for p in soup.find_all('p')][:5]
+        if response.status_code != 200:
+            return f"Failed to access the URL. Status code: {response.status_code}"
         
-        return f"Headlines:\n" + "\n".join(headlines) + "\n\nArticles:\n" + "\n".join(articles)
+        soup = bs4.BeautifulSoup(response.text, 'html.parser')
+        
+        # Remove script and style elements
+        for script in soup(["script", "style"]):
+            script.extract()
+        
+        if selector:
+            elements = soup.select(selector)
+            if not elements:
+                return f"No elements found matching selector: {selector}"
+            content = "\n".join([elem.get_text(strip=True) for elem in elements])
+        else:
+            # Get all text
+            content = soup.get_text(separator='\n', strip=True)
+        
+        # Truncate if too long
+        if len(content) > 5000:
+            content = content[:5000] + "... (content truncated)"
+        
+        return content
     except Exception as e:
-        return f"Error scraping news: {str(e)}"
+        return f"Error scraping {url}: {str(e)}"
 
-# Image Generation Tool (uses existing text-to-image tool)
+# Image processing tool
 @tool
-def generate_image(prompt: str) -> str:
-    """Generates an image based on the given text prompt.
+def process_image(image_url: str, operation: str = "info") -> str:
+    """Process an image with various operations.
+    
     Args:
-        prompt: A description of the image to generate.
+        image_url: URL of the image to process.
+        operation: The operation to perform (options: "info", "resize", "grayscale", "blur").
     """
     try:
-        return image_generation_tool.invoke(prompt)  # Change run() to invoke()
+        response = requests.get(image_url)
+        if response.status_code != 200:
+            return f"Failed to download image. Status code: {response.status_code}"
+        
+        image = Image.open(io.BytesIO(response.content))
+        
+        if operation == "info":
+            info = {
+                "format": image.format,
+                "mode": image.mode,
+                "width": image.width,
+                "height": image.height,
+                "size_kb": len(response.content) / 1024
+            }
+            return f"Image information:\n" + "\n".join([f"{k}: {v}" for k, v in info.items()])
+        
+        elif operation == "resize":
+            # Resize to 50% of original size
+            new_size = (image.width // 2, image.height // 2)
+            resized = image.resize(new_size)
+            
+            # Convert to base64 for return
+            buffered = io.BytesIO()
+            resized.save(buffered, format=image.format if image.format else "JPEG")
+            img_str = base64.b64encode(buffered.getvalue()).decode()
+            
+            return f"Resized image (now {new_size[0]}x{new_size[1]}):\ndata:image/{image.format.lower() if image.format else 'jpeg'};base64,{img_str}"
+        
+        elif operation == "grayscale":
+            grayscale = image.convert('L')
+            
+            # Convert to base64 for return
+            buffered = io.BytesIO()
+            grayscale.save(buffered, format=image.format if image.format else "JPEG")
+            img_str = base64.b64encode(buffered.getvalue()).decode()
+            
+            return f"Grayscale image:\ndata:image/{image.format.lower() if image.format else 'jpeg'};base64,{img_str}"
+        
+        elif operation == "blur":
+            from PIL import ImageFilter
+            blurred = image.filter(ImageFilter.GaussianBlur(radius=5))
+            
+            # Convert to base64 for return
+            buffered = io.BytesIO()
+            blurred.save(buffered, format=image.format if image.format else "JPEG")
+            img_str = base64.b64encode(buffered.getvalue()).decode()
+            
+            return f"Blurred image:\ndata:image/{image.format.lower() if image.format else 'jpeg'};base64,{img_str}"
+        
+        else:
+            return f"Unknown operation: {operation}. Available operations: info, resize, grayscale, blur"
+    
     except Exception as e:
-        return f"Error generating image: {str(e)}"
+        return f"Error processing image: {str(e)}"
 
+# Keeping your existing custom tools
+@tool
+def my_custom_tool(arg1:str, arg2:int)-> str:
+    """A tool that does nothing yet
+    
+    Args:
+        arg1: the first argument
+        arg2: the second argument
+    """
+    return "What magic will you build ?"
 
-# Timezone Tool (already in your code)
 @tool
 def get_current_time_in_timezone(timezone: str) -> str:
-    """Fetches the current local time in a specified timezone.
+    """A tool that fetches the current local time in a specified timezone.
+    
     Args:
-        timezone: A valid timezone (e.g., 'America/New_York').
+        timezone: A string representing a valid timezone (e.g., 'America/New_York').
     """
     try:
+        # Create timezone object
         tz = pytz.timezone(timezone)
+        # Get current time in that timezone
         local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
         return f"The current local time in {timezone} is: {local_time}"
     except Exception as e:
-        return f"Error fetching time: {str(e)}"
+        return f"Error fetching time for timezone '{timezone}': {str(e)}"
 
 final_answer = FinalAnswerTool()
 
+# Model setup
 model = HfApiModel(
     max_tokens=2096,
     temperature=0.5,
@@ -83,13 +184,23 @@ model = HfApiModel(
     custom_role_conversions=None,
 )
 
-# Load prompt templates
+# Import tool from Hub
+image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
+
 with open("prompts.yaml", 'r') as stream:
     prompt_templates = yaml.safe_load(stream)
 
 agent = CodeAgent(
     model=model,
-    tools=[final_answer, get_weather, scrape_news, generate_image],
+    tools=[
+        final_answer,
+        get_weather,
+        web_scrape,
+        process_image,
+        get_current_time_in_timezone,
+        my_custom_tool,
+        image_generation_tool
+    ],  # Added the new tools here
     max_steps=6,
     verbosity_level=1,
     grammar=None,
@@ -99,4 +210,4 @@ agent = CodeAgent(
     prompt_templates=prompt_templates
 )
 
-GradioUI(agent).launch()
+GradioUI(agent).launch()