Update app.py

app.py

@@ -1,22 +1,165 @@
-from smolagents import CodeAgent,DuckDuckGoSearchTool, HfApiModel,load_tool,tool
+from smolagents import CodeAgent, DuckDuckGoSearchTool, InferenceClientModel, load_tool, tool
 import datetime
 import requests
 import pytz
 import yaml
 from tools.final_answer import FinalAnswerTool
-
 from Gradio_UI import GradioUI
 
-# Below is an example of a tool that does nothing. Amaze us with your creativity !
+# Weather Tool
 @tool
-def my_custom_tool(arg1:str, arg2:int)-> str: #it's import to specify the return type
-    #Keep this format for the description / args / args description but feel free to modify the tool
-    """A tool that does nothing yet 
+def get_weather(city: str) -> str:
+    """Fetches current weather information for a specified city.
     Args:
-        arg1: the first argument
-        arg2: the second argument
+        city: The name of the city to get weather for (e.g., 'London', 'New York')
     """
-    return "What magic will you build ?"
+    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}"
+    except Exception as e:
+        return f"Error fetching weather: {str(e)}"
+
+# Calculator Tool
+@tool
+def calculate(expression: str) -> str:
+    """Evaluates 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
+        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."
+        
+        result = eval(expression, {"__builtins__": {}}, {})
+        return f"Result: {result}"
+    except Exception as e:
+        return f"Error calculating expression: {str(e)}"
+
+# Currency Converter 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.
+    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')
+    """
+    try:
+        # Using exchangerate-api.com free tier
+        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()
+            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"
+        else:
+            return "Error fetching exchange rates"
+    except Exception as e:
+        return f"Error converting currency: {str(e)}"
+
+# Text Analysis Tool
+@tool
+def analyze_text(text: str) -> str:
+    """Analyzes text and provides statistics like word count, character count, and reading time.
+    Args:
+        text: The text to analyze
+    """
+    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"""
+    except Exception as e:
+        return f"Error analyzing text: {str(e)}"
+
+# Random Fact Generator
+@tool
+def get_random_fact() -> str:
+    """Fetches a random interesting fact."""
+    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."
+    except Exception as e:
+        return f"Error fetching random fact: {str(e)}"
+
+# Timezone Converter
+@tool
+def convert_time_between_timezones(time_str: str, from_timezone: str, to_timezone: str) -> str:
+    """Converts a time from one timezone to another.
+    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')
+    """
+    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}"
+    except Exception as e:
+        return f"Error converting time: {str(e)}"
+
+# URL Shortener (using is.gd)
+@tool
+def shorten_url(url: str) -> str:
+    """Shortens a long URL using a URL shortening service.
+    Args:
+        url: The URL to shorten
+    """
+    try:
+        response = requests.get(f"https://is.gd/create.php?format=simple&url={url}", timeout=10)
+        if response.status_code == 200:
+            short_url = response.text
+            return f"Shortened URL: {short_url}"
+        else:
+            return "Error shortening URL"
+    except Exception as e:
+        return f"Error: {str(e)}"
 
 @tool
 def get_current_time_in_timezone(timezone: str) -> str:
@@ -25,37 +168,45 @@ def get_current_time_in_timezone(timezone: str) -> str:
         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 for timezone '{timezone}': {str(e)}"
 
-
+# Initialize tools
 final_answer = FinalAnswerTool()
+search_tool = DuckDuckGoSearchTool()
 
-# If the agent does not answer, the model is overloaded, please use another model or the following Hugging Face Endpoint that also contains qwen2.5 coder:
-# model_id='https://pflgm2locj2t89co.us-east-1.aws.endpoints.huggingface.cloud' 
-
-model = HfApiModel(
-max_tokens=2096,
-temperature=0.5,
-model_id='Qwen/Qwen2.5-Coder-32B-Instruct',# it is possible that this model may be overloaded
-custom_role_conversions=None,
+model = InferenceClientModel(
+    max_tokens=2096,
+    temperature=0.5,
+    model_id='Qwen/Qwen2.5-Coder-32B-Instruct',
+    custom_role_conversions=None,
 )
 
-
 # Import 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], ## add your tools here (don't remove final answer)
+    tools=[
+        final_answer,
+        search_tool,
+        get_weather,
+        calculate,
+        convert_currency,
+        analyze_text,
+        get_random_fact,
+        get_current_time_in_timezone,
+        convert_time_between_timezones,
+        shorten_url,
+        image_generation_tool
+    ],
     max_steps=6,
     verbosity_level=1,
     grammar=None,
@@ -65,5 +216,4 @@ agent = CodeAgent(
     prompt_templates=prompt_templates
 )
 
-
 GradioUI(agent).launch()