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 web_search import DuckDuckGoSearchTool
from forex_python.converter import CurrencyRates
import os
from huggingface_hub import login
login(token = os.getenv('HF_TOKEN'))

from Gradio_UI import GradioUI

# Below is an example of a tool that does nothing. Amaze us with your creativity !
@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 
    Args:
        arg1: the first argument
        arg2: the second argument
    """
    return "What magic will you build ?"

@tool
def get_quote_in_euros(query: str, currency: str = "USD") -> str:
    """
    Searches DuckDuckGo for a company's stock quote or reference price
    (assumed in the specified currency) and attempts to parse & convert 
    the price into EUR.

    Args:
        query: The stock ticker or company name (e.g., "AAPL" or "Tesla").
        currency: The presumed currency code of the quote (default is "USD").

    Returns:
        A string displaying the approximate price in the original currency 
        and its equivalent in EUR, or an error message if not found.
    """
    try:
        # 1. Search for the query (e.g. "AAPL stock price USD").
        duck_tool = DuckDuckGoSearchTool(max_results=5)
        results = duck_tool.forward(f"{query} stock price {currency}")

        # 2. Try to naively parse a price from the search results.
        #    This example is specifically looking for something like: $123.45
        #    If you're not dealing with USD, adapt the pattern accordingly.
        match = re.search(r"[\$€£]([\d.,]+)", results)
        if not match:
            return (
                f"Could not find a recognizable stock/quote price for '{query}' in the results."
            )

        # 3. Convert the extracted price string to a float.
        #    Remove any commas (e.g., "1,234.56" -> 1234.56).
        price_str = match.group(1).replace(",", "")
        original_price = float(price_str)

        # 4. Use forex_python to convert from the original currency to EUR.
        c = CurrencyRates()
        # get_rate("USD", "EUR") -> float (example: 0.90 means 1 USD = 0.90 EUR)
        rate = c.get_rate(currency.upper(), "EUR")
        price_in_euros = original_price * rate

        return (
            f"The approximate price of '{query}' is {currency.upper()} {original_price:.2f}, "
            f"which is about EUR {price_in_euros:.2f}."
        )

    except Exception as e:
        return f"An error occurred: {str(e)}"

@tool
def get_sunrise_sunset_times(city: str) -> str:
    """
    Fetches sunrise and sunset times for a given city, using free OpenStreetMap
    (Nominatim) for geocoding and sunrise-sunset.org for the actual times.

    Args:
        city: Name of the city (e.g., "Berlin" or "Los Angeles").

    Returns:
        A human-readable string describing sunrise and sunset times for that city,
        or an error message if something goes wrong.
    """
    try:
        # 1. Geocode the city name to get latitude/longitude
        geocode_url = "https://nominatim.openstreetmap.org/search"
        geocode_params = {
            "q": city,
            "format": "json",
            "limit": 1
        }
        geocode_resp = requests.get(geocode_url, params=geocode_params, timeout=15)
        geocode_data = geocode_resp.json()
        
        if not geocode_data:
            return f"Could not find location for '{city}'. Check spelling or try a different query."

        lat = geocode_data[0]["lat"]
        lon = geocode_data[0]["lon"]

        # 2. Use sunrise-sunset.org to get sunrise/sunset times
        sun_api_url = "https://api.sunrise-sunset.org/json"
        sun_api_params = {
            "lat": lat,
            "lng": lon,
            "formatted": 0  # return times in ISO 8601, which includes UTC offsets
        }
        sun_resp = requests.get(sun_api_url, params=sun_api_params, timeout=15)
        sun_data = sun_resp.json()

        if sun_data["status"] != "OK":
            return f"Sunrise-sunset API error for location '{city}'."

        sunrise = sun_data["results"]["sunrise"]
        sunset = sun_data["results"]["sunset"]

        return (
            f"For '{city}':\n"
            f"  • Sunrise (local time): {sunrise}\n"
            f"  • Sunset  (local time): {sunset}\n"
            "Times shown in UTC-based format; actual local times may vary by time zone."
        )

    except Exception as e:
        return f"An error occurred while fetching sunrise/sunset times: {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()

# 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,
)


# 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,
          image_generation_tool], ## 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()