app.py

from smolagents import CodeAgent, tool
import datetime
import pytz
import yaml
import requests
import json
from tools.final_answer import FinalAnswerTool
from Gradio_UI import GradioUI

# Text Analyzer Tool
@tool
def text_analyzer(text: str) -> str:
    """Analyzes text and returns statistics about it.
    
    Args:
        text: The text to analyze.
    """
    try:
        # Simple word count
        words = text.split()
        word_count = len(words)
        
        # Character count
        char_count = len(text)
        
        # Unique words
        unique_words = len(set(word.lower() for word in words))
        
        # Average word length
        avg_word_length = sum(len(word) for word in words) / max(1, word_count)
        
        # Most common words (top 5)
        word_freq = {}
        for word in words:
            word_lower = word.lower()
            word_freq[word_lower] = word_freq.get(word_lower, 0) + 1
        
        common_words = sorted(word_freq.items(), key=lambda x: x[1], reverse=True)[:5]
        common_words_str = ", ".join(f"{word} ({count})" for word, count in common_words)
        
        return f"""Text Analysis Results:
- Word count: {word_count}
- Character count: {char_count}
- Unique words: {unique_words}
- Average word length: {avg_word_length:.2f}
- Most common words: {common_words_str}
"""
    except Exception as e:
        return f"Error analyzing text: {str(e)}"

# Timezone Tool
@tool
def get_current_time_in_timezone(timezone: str) -> str:
    """A tool that fetches the current local time in a specified timezone.
    
    Args:
        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)}"

# Weather Forecast Tool
@tool
def weather_forecast(location: str) -> str:
    """Fetches weather forecast for a specified location.
    
    Args:
        location: The location to get weather forecast for (city name or coordinates).
    """
    try:
        # Connect to a public weather API
        api_url = f"https://wttr.in/{location}?format=j1"
        
        # Make the API request
        response = requests.get(api_url, timeout=10)
        response.raise_for_status()  # Raise an exception for HTTP errors
        
        # Parse the JSON response
        weather_data = response.json()
        
        # Extract relevant information
        current_condition = weather_data.get("current_condition", [{}])[0]
        weather_desc = current_condition.get("weatherDesc", [{}])[0].get("value", "Unknown")
        temp_c = current_condition.get("temp_C", "Unknown")
        temp_f = current_condition.get("temp_F", "Unknown")
        feels_like_c = current_condition.get("FeelsLikeC", "Unknown")
        humidity = current_condition.get("humidity", "Unknown")
        wind_speed = current_condition.get("windspeedKmph", "Unknown")
        wind_dir = current_condition.get("winddir16Point", "Unknown")
        
        # Get forecast for upcoming days
        forecast = weather_data.get("weather", [])
        forecast_info = ""
        
        if forecast:
            forecast_info = "\n\nForecast for the next few days:\n"
            for day in forecast[:3]:  # Limit to 3 days
                date = day.get("date", "Unknown")
                max_temp_c = day.get("maxtempC", "Unknown")
                min_temp_c = day.get("mintempC", "Unknown")
                desc = day.get("hourly", [{}])[0].get("weatherDesc", [{}])[0].get("value", "Unknown")
                
                forecast_info += f"- {date}: {desc}, Max: {max_temp_c}°C, Min: {min_temp_c}°C\n"
        
        # Format the response
        weather_report = f"""
Weather for {location}:
Current Conditions: {weather_desc}
Temperature: {temp_c}°C / {temp_f}°F (Feels like: {feels_like_c}°C)
Humidity: {humidity}%
Wind: {wind_speed} km/h, Direction: {wind_dir}
{forecast_info}
"""
        
        return weather_report.strip()
        
    except requests.exceptions.RequestException as e:
        return f"Error fetching weather for {location}: Connection error - {str(e)}"
    except json.JSONDecodeError:
        return f"Error fetching weather for {location}: Invalid response from weather service"
    except Exception as e:
        return f"Error fetching weather for {location}: {str(e)}"

# Set up the agent with our tools
final_answer = FinalAnswerTool()

with open("prompts.yaml", 'r') as stream:
    prompt_templates = yaml.safe_load(stream)

from smolagents import HfApiModel
    
model = HfApiModel(
    max_tokens=2096,
    temperature=0.5,
    model_id='Qwen/Qwen2.5-Coder-32B-Instruct',
    custom_role_conversions=None,
)

# Create agent with our tools (now 4 including final_answer)
agent = CodeAgent(
    model=model,
    tools=[text_analyzer, get_current_time_in_timezone, weather_forecast, final_answer],
    max_steps=6,
    verbosity_level=1,
    grammar=None,
    planning_interval=None,
    name=None,
    description=None,
    prompt_templates=prompt_templates
)

# Launch the Gradio UI
GradioUI(agent).launch()