app.py

from smolagents import CodeAgent, Tool, DuckDuckGoSearchTool, load_tool, tool
from models import OpenAIModel  # Import our local model
import datetime
import requests
import pytz
import yaml
from tools.final_answer import FinalAnswerTool
import re
import os
import logging
from jinja2 import Template, StrictUndefined

from Gradio_UI import GradioUI

# Configure logging
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)

# Below is an example of a tool that does nothing. Amaze us with your creativity !
@tool
def calculate_min_price(prices: list[float])-> str: #it's import to specify the return type
    """A tool that calculates the min price from list of product prices
    Args:
        prices: list of product prices of
    """
    min_price =min(prices)
    return f"The minimum price is {min_price}"

@tool
def extract_price_from_snippet(snippet: str) -> list[str]:
    """
    A simple function to extract prices from a text snippet using regex.
    You can enhance this function for more complex price extraction.
    Args:
        snippet: text of all prices
    """
    # A basic regular expression to detect common price formats like $29.99, 29.99 USD, etc.
    price_pattern = r'\$\d+(?:,\d{3})*(?:\.\d{2})?|\d+(?:,\d{3})*(?:\.\d{2})?\s*(USD|EUR|GBP|INR|AUD|CAD)?'
    matches = re.findall(price_pattern, snippet)
    matches = [str(x) for x in matches]
    return matches


@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()

# Load configuration from agent.json
with open("agent.json", 'r') as f:
    config = yaml.safe_load(f)

# Initialize OpenAI model using the configuration
model = OpenAIModel(
    model=config["model"]["data"]["model_id"],
    max_tokens=config["model"]["data"]["max_tokens"],
    temperature=config["model"]["data"]["temperature"],
    api_key=os.getenv("OPENAI_API_KEY")
)

# 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:
    yaml_content = yaml.safe_load(stream)
    if not isinstance(yaml_content, dict):
        raise ValueError("YAML content must be a dictionary")
    if 'prompt_templates' not in yaml_content:
        raise ValueError("YAML must contain 'prompt_templates' key")
    prompt_templates = yaml_content['prompt_templates']
    if not isinstance(prompt_templates, dict):
        raise ValueError("prompt_templates must be a dictionary")
    
    # Process templates to ensure they are valid Jinja2 templates
    def process_template(value):
        if isinstance(value, str):
            logger.debug(f"Processing template string: {value[:100]}...")
            try:
                # First, ensure we have valid template syntax
                if '{{' in value or '{%' in value:
                    # Ensure template variables are properly formatted
                    value = value.replace('{{', '{{ ').replace('}}', ' }}')
                    # Ensure template blocks are properly formatted
                    value = value.replace('{%', '{% ').replace('%}', ' %}')
                    # Ensure newlines are properly handled
                    value = value.replace('\n', '\\n')
                    # Add spaces around template expressions if missing
                    value = re.sub(r'{{([^{}]+)}}', r'{{ \1 }}', value)
                    value = re.sub(r'{%([^{}]+)%}', r'{% \1 %}', value)
                    logger.debug(f"Processed template string: {value[:100]}...")
                else:
                    logger.debug("No template syntax found in string")
            except Exception as e:
                logger.error(f"Error processing template string: {str(e)}")
                raise
            return value
        elif isinstance(value, dict):
            logger.debug(f"Processing template dictionary with keys: {list(value.keys())}")
            try:
                return {k: process_template(v) for k, v in value.items()}
            except Exception as e:
                logger.error(f"Error processing template dictionary: {str(e)}")
                raise
        return value
    
    logger.debug("Starting template processing...")
    try:
        prompt_templates = process_template(prompt_templates)
        logger.debug("Template processing completed")
        
        # Log the final processed templates
        logger.debug("Final processed templates:")
        for key, value in prompt_templates.items():
            if isinstance(value, dict):
                logger.debug(f"{key}: {list(value.keys())}")
            else:
                logger.debug(f"{key}: {str(value)[:100]}...")
    except Exception as e:
        logger.error(f"Error during template processing: {str(e)}")
        raise

    # Validate templates before creating agent
    logger.debug("Validating templates...")
    try:
        for key, value in prompt_templates.items():
            if isinstance(value, dict):
                for subkey, subvalue in value.items():
                    if isinstance(subvalue, str):
                        logger.debug(f"Validating template: {key}.{subkey}")
                        Template(subvalue, undefined=StrictUndefined)
            elif isinstance(value, str):
                logger.debug(f"Validating template: {key}")
                Template(value, undefined=StrictUndefined)
        logger.debug("Template validation completed successfully")
    except Exception as e:
        logger.error(f"Template validation failed: {str(e)}")
        raise

agent = CodeAgent(
    model=model,
    tools=[final_answer, DuckDuckGoSearchTool(), calculate_min_price, extract_price_from_snippet, get_current_time_in_timezone],
    max_steps=15,  # Increased max steps for more complex reasoning
    verbosity_level=2,  # Increased verbosity for better debugging
    grammar=None,
    planning_interval=1,  # Added planning interval to ensure proper planning
    name="question_answering_agent",
    description="An agent specialized in answering various types of questions using available tools. The agent must use the final_answer tool to submit its answer.",
    prompt_templates=prompt_templates
)

# Configure Gradio UI with sharing enabled
GradioUI(agent).launch(share=True)