app.py

from smolagents import CodeAgent,DuckDuckGoSearchTool, HfApiModel,load_tool,tool
import datetime
import requests
import pytz
import yaml
from tools.final_answer import FinalAnswerTool


from Gradio_UI import GradioUI

@tool
def get_random_fun_fact() -> str:
    """Fetches a random fun fact from an API."""

    try:
        response = requests.get("https://uselessfacts.jsph.pl/random.json?language=en")
        if response.status_code == 200:
            fact = response.json().get("text", "No fun fact available.")
            return f"Fun Fact: {fact}"
        else:
            return "Error fetching fun fact."
    except Exception as e:
        return f"Error: {str(e)}"



@tool
def days_until_event(event_date: str) -> str:
    """Calculates the number of days until a given event.

    Args:
        event_date: The target date in YYYY-MM-DD format.
    """

    try:
        event_date_obj = datetime.datetime.strptime(event_date, "%Y-%m-%d")
        today = datetime.datetime.today()
        delta = event_date_obj - today

        if delta.days < 0:
            return f"The event on {event_date} has already passed!"
        return f"There are {delta.days} days left until {event_date}."
    except ValueError:
        return "Invalid date format. Please use YYYY-MM-DD."


@tool
def get_country_info(country: str) -> str:
    """Retrieves basic information about a given country.

    Args:
        country: The name of the country (e.g., "France").
    """

    try:
        url = f"https://restcountries.com/v3.1/name/{country}"
        response = requests.get(url)
        if response.status_code == 200:
            data = response.json()[0]
            name = data.get("name", {}).get("common", "Unknown")
            capital = data.get("capital", ["Unknown"])[0]
            population = data.get("population", "Unknown")
            currency = list(data.get("currencies", {}).keys())[0] if "currencies" in data else "Unknown"

            return f"Country: {name}\nCapital: {capital}\nPopulation: {population}\nCurrency: {currency}"
        else:
            return "Error fetching country information."
    except Exception as e:
        return f"Error: {str(e)}"


@tool
def convert_currency(amount: float, from_currency: str, to_currency: str) -> str:
    """Converts an amount from one currency to another.

    Args:
        amount: The amount to convert.
        from_currency: The currency to convert from (e.g., "USD").
        to_currency: The currency to convert to (e.g., "EUR").
    """

    try:
        url = f"https://api.exchangerate-api.com/v4/latest/{from_currency.upper()}"
        response = requests.get(url)
        if response.status_code == 200:
            rates = response.json().get("rates", {})
            conversion_rate = rates.get(to_currency.upper())

            if conversion_rate:
                converted_amount = amount * conversion_rate
                return f"{amount} {from_currency.upper()} is equal to {converted_amount:.2f} {to_currency.upper()}."
            else:
                return "Currency not found."
        else:
            return "Error fetching exchange rates."
    except Exception as e:
        return f"Error: {str(e)}"



@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)}"


final_answer = FinalAnswerTool()
model = HfApiModel(
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)

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)
    max_steps=6,
    verbosity_level=1,
    grammar=None,
    planning_interval=None,
    name=None,
    description=None,
    prompt_templates=prompt_templates
)


GradioUI(agent).launch()