Update app.py

app.py

@@ -1,211 +1,210 @@
-from smolagents import CodeAgent, DuckDuckGoSearchTool, InferenceClientModel, load_tool, tool
+from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, tool
 import datetime
 import requests
 import pytz
 import yaml
-from tools.final_answer import FinalAnswerTool
+import json
+from tools.final_answer import FinalAnswerTool 
 from Gradio_UI import GradioUI
 
-# Weather Tool
+# Web Search Tool
 @tool
-def get_weather(city: str) -> str:
-    """Fetches current weather information for a specified city.
+def web_search(query: str) -> str:
+    """Search the web using DuckDuckGo for current information.
+    
     Args:
-        city: The name of the city to get weather for (e.g., 'London', 'New York')
+        query: The search query string
     """
     try:
-        # Using wttr.in API which doesn't require authentication
-        response = requests.get(f"https://wttr.in/{city}?format=j1", timeout=10)
-        if response.status_code == 200:
-            data = response.json()
-            current = data['current_condition'][0]
-            weather_desc = current['weatherDesc'][0]['value']
-            temp_c = current['temp_C']
-            feels_like = current['FeelsLikeC']
-            humidity = current['humidity']
-            wind_speed = current['windspeedKmph']
-            
-            return f"Weather in {city}: {weather_desc}, Temperature: {temp_c}°C (feels like {feels_like}°C), Humidity: {humidity}%, Wind: {wind_speed} km/h"
-        else:
-            return f"Could not fetch weather data for {city}"
+        search_tool = DuckDuckGoSearchTool()
+        results = search_tool(query)
+        return results
     except Exception as e:
-        return f"Error fetching weather: {str(e)}"
+        return f"Error performing web search: {str(e)}"
+
+# Time and Date Tool
+@tool
+def get_current_time_in_timezone(timezone: str) -> str:
+    """Get the current local time in a specified timezone.
+    
+    Args:
+        timezone: A valid timezone string (e.g., 'America/New_York', 'Europe/London', 'Asia/Tokyo')
+    """
+    try:
+        tz = pytz.timezone(timezone)
+        local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S %Z")
+        return f"The current local time in {timezone} is: {local_time}"
+    except Exception as e:
+        return f"Error: Invalid timezone '{timezone}'. {str(e)}"
 
 # Calculator Tool
 @tool
 def calculate(expression: str) -> str:
-    """Evaluates a mathematical expression safely.
+    """Evaluate a mathematical expression safely.
+    
     Args:
         expression: A mathematical expression as a string (e.g., '2 + 2', '10 * 5 + 3')
     """
     try:
-        # Safe evaluation of mathematical expressions
+        # Safe evaluation using only numbers and basic operators
         allowed_chars = set('0123456789+-*/(). ')
         if not all(c in allowed_chars for c in expression):
-            return "Error: Expression contains invalid characters. Only numbers and basic operators (+, -, *, /, parentheses) are allowed."
+            return "Error: Expression contains invalid characters"
         
         result = eval(expression, {"__builtins__": {}}, {})
         return f"Result: {result}"
     except Exception as e:
         return f"Error calculating expression: {str(e)}"
 
-# Currency Converter Tool
+# Weather Tool
 @tool
-def convert_currency(amount: float, from_currency: str, to_currency: str) -> str:
-    """Converts an amount from one currency to another using live exchange rates.
+def get_weather(city: str) -> str:
+    """Get current weather information for a city using wttr.in service.
+    
     Args:
-        amount: The amount to convert
-        from_currency: Source currency code (e.g., 'USD', 'EUR', 'GBP')
-        to_currency: Target currency code (e.g., 'USD', 'EUR', 'GBP')
+        city: Name of the city to get weather for
     """
     try:
-        # Using exchangerate-api.com free tier
-        url = f"https://api.exchangerate-api.com/v4/latest/{from_currency.upper()}"
+        url = f"https://wttr.in/{city}?format=j1"
         response = requests.get(url, timeout=10)
-        
         if response.status_code == 200:
             data = response.json()
-            if to_currency.upper() in data['rates']:
-                rate = data['rates'][to_currency.upper()]
-                converted = amount * rate
-                return f"{amount} {from_currency.upper()} = {converted:.2f} {to_currency.upper()} (Rate: {rate:.4f})"
-            else:
-                return f"Currency code '{to_currency}' not found"
+            current = data['current_condition'][0]
+            temp_c = current['temp_C']
+            temp_f = current['temp_F']
+            weather_desc = current['weatherDesc'][0]['value']
+            humidity = current['humidity']
+            wind_speed = current['windspeedKmph']
+            
+            return f"Weather in {city}: {weather_desc}, Temperature: {temp_c}°C ({temp_f}°F), Humidity: {humidity}%, Wind Speed: {wind_speed} km/h"
         else:
-            return "Error fetching exchange rates"
+            return f"Could not fetch weather for {city}"
     except Exception as e:
-        return f"Error converting currency: {str(e)}"
+        return f"Error fetching weather: {str(e)}"
 
-# Text Analysis Tool
+# File Reader Tool
 @tool
-def analyze_text(text: str) -> str:
-    """Analyzes text and provides statistics like word count, character count, and reading time.
+def read_file(filepath: str) -> str:
+    """Read and return the contents of a text file.
+    
     Args:
-        text: The text to analyze
+        filepath: Path to the file to read
     """
     try:
-        words = text.split()
-        word_count = len(words)
-        char_count = len(text)
-        char_count_no_spaces = len(text.replace(' ', ''))
-        sentence_count = text.count('.') + text.count('!') + text.count('?')
-        
-        # Average reading speed is ~200 words per minute
-        reading_time_minutes = word_count / 200
-        
-        return f"""Text Analysis:
-- Words: {word_count}
-- Characters (with spaces): {char_count}
-- Characters (without spaces): {char_count_no_spaces}
-- Sentences: {sentence_count}
-- Estimated reading time: {reading_time_minutes:.1f} minutes"""
+        with open(filepath, 'r', encoding='utf-8') as f:
+            content = f.read()
+        return f"File content:\n{content}"
     except Exception as e:
-        return f"Error analyzing text: {str(e)}"
+        return f"Error reading file: {str(e)}"
 
-# Random Fact Generator
+# File Writer Tool
 @tool
-def get_random_fact() -> str:
-    """Fetches a random interesting fact."""
+def write_file(filepath: str, content: str) -> str:
+    """Write content to a text file.
+    
+    Args:
+        filepath: Path where the file should be written
+        content: Content to write to the file
+    """
     try:
-        response = requests.get("https://uselessfacts.jsph.pl/random.json?language=en", timeout=10)
-        if response.status_code == 200:
-            fact = response.json()['text']
-            return f"Random Fact: {fact}"
-        else:
-            return "Could not fetch a random fact at this time."
+        with open(filepath, 'w', encoding='utf-8') as f:
+            f.write(content)
+        return f"Successfully wrote to {filepath}"
     except Exception as e:
-        return f"Error fetching random fact: {str(e)}"
+        return f"Error writing file: {str(e)}"
 
-# Timezone Converter
+# Currency Converter Tool
 @tool
-def convert_time_between_timezones(time_str: str, from_timezone: str, to_timezone: str) -> str:
-    """Converts a time from one timezone to another.
+def convert_currency(amount: float, from_currency: str, to_currency: str) -> str:
+    """Convert an amount from one currency to another using live exchange rates.
+    
     Args:
-        time_str: Time in format 'HH:MM' (24-hour format)
-        from_timezone: Source timezone (e.g., 'America/New_York')
-        to_timezone: Target timezone (e.g., 'Asia/Tokyo')
+        amount: The amount to convert
+        from_currency: The source currency code (e.g., 'USD', 'EUR', 'GBP')
+        to_currency: The target currency code (e.g., 'USD', 'EUR', 'GBP')
     """
     try:
-        # Parse time
-        time_obj = datetime.datetime.strptime(time_str, "%H:%M").time()
-        
-        # Get current date
-        today = datetime.datetime.now().date()
-        
-        # Create datetime object with source timezone
-        from_tz = pytz.timezone(from_timezone)
-        dt_from = from_tz.localize(datetime.datetime.combine(today, time_obj))
-        
-        # Convert to target timezone
-        to_tz = pytz.timezone(to_timezone)
-        dt_to = dt_from.astimezone(to_tz)
-        
-        return f"{time_str} in {from_timezone} is {dt_to.strftime('%H:%M')} in {to_timezone}"
+        url = f"https://api.exchangerate-api.com/v4/latest/{from_currency.upper()}"
+        response = requests.get(url, timeout=10)
+        if response.status_code == 200:
+            data = response.json()
+            rate = data['rates'].get(to_currency.upper())
+            if rate:
+                converted = amount * rate
+                return f"{amount} {from_currency.upper()} = {converted:.2f} {to_currency.upper()}"
+            else:
+                return f"Currency code '{to_currency}' not found"
+        else:
+            return "Error fetching exchange rates"
     except Exception as e:
-        return f"Error converting time: {str(e)}"
+        return f"Error converting currency: {str(e)}"
 
-# URL Shortener (using is.gd)
+# Wikipedia Summary Tool
 @tool
-def shorten_url(url: str) -> str:
-    """Shortens a long URL using a URL shortening service.
+def get_wikipedia_summary(topic: str) -> str:
+    """Get a brief summary from Wikipedia about a topic.
+    
     Args:
-        url: The URL to shorten
+        topic: The topic to search for on Wikipedia
     """
     try:
-        response = requests.get(f"https://is.gd/create.php?format=simple&url={url}", timeout=10)
+        url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{topic.replace(' ', '_')}"
+        response = requests.get(url, timeout=10)
         if response.status_code == 200:
-            short_url = response.text
-            return f"Shortened URL: {short_url}"
+            data = response.json()
+            return f"Wikipedia Summary: {data.get('extract', 'No summary available')}"
         else:
-            return "Error shortening URL"
+            return f"Could not find Wikipedia article for '{topic}'"
     except Exception as e:
-        return f"Error: {str(e)}"
+        return f"Error fetching Wikipedia summary: {str(e)}"
 
+# List Available Timezones Tool
 @tool
-def get_current_time_in_timezone(timezone: str) -> str:
-    """A tool that fetches the current local time in a specified timezone.
+def list_common_timezones(region: str = "all") -> str:
+    """List common timezones, optionally filtered by region.
+    
     Args:
-        timezone: A string representing a valid timezone (e.g., 'America/New_York').
+        region: Region to filter by (e.g., 'America', 'Europe', 'Asia', 'all')
     """
     try:
-        tz = pytz.timezone(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}"
+        if region.lower() == "all":
+            timezones = pytz.common_timezones[:20]  # First 20 for brevity
+            return f"Common timezones (first 20): {', '.join(timezones)}"
+        else:
+            filtered = [tz for tz in pytz.common_timezones if tz.startswith(region)]
+            return f"Timezones in {region}: {', '.join(filtered[:30])}"
     except Exception as e:
-        return f"Error fetching time for timezone '{timezone}': {str(e)}"
+        return f"Error listing timezones: {str(e)}"
 
-# Initialize tools
 final_answer = FinalAnswerTool()
-search_tool = DuckDuckGoSearchTool()
 
-model = InferenceClientModel(
+model = HfApiModel(
     max_tokens=2096,
     temperature=0.5,
     model_id='Qwen/Qwen2.5-Coder-32B-Instruct',
     custom_role_conversions=None,
 )
 
-# Import tool from Hub
+# Load image generation tool from Hub
 image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
 
-# Load system prompt from prompt.yaml file
 with open("prompts.yaml", 'r') as stream:
     prompt_templates = yaml.safe_load(stream)
-    
+
 agent = CodeAgent(
     model=model,
     tools=[
         final_answer,
-        search_tool,
-        get_weather,
+        web_search,
+        get_current_time_in_timezone,
         calculate,
+        get_weather,
+        read_file,
+        write_file,
         convert_currency,
-        analyze_text,
-        get_random_fact,
-        get_current_time_in_timezone,
-        convert_time_between_timezones,
-        shorten_url,
-        image_generation_tool
+        get_wikipedia_summary,
+        list_common_timezones,
+        image_generation_tool,
     ],
     max_steps=6,
     verbosity_level=1,