Update app.py

updated app.py to customize it for Travel Catalogue Creator

app.py

@@ -1,69 +1,457 @@
-from smolagents import CodeAgent,DuckDuckGoSearchTool, HfApiModel,load_tool,tool
-import datetime
+#!/usr/bin/env python
+# coding=utf-8
+import os
+import re
 import requests
+import datetime
 import pytz
-import yaml
+import json
+from typing import List, Dict, Optional
+from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, tool
 from tools.final_answer import FinalAnswerTool
-
 from Gradio_UI import GradioUI
+import yaml
+
+# ======================
+# CUSTOM TRAVEL TOOLS
+# ======================
 
-# 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 
+def get_weather_forecast(location: str, travel_dates: str) -> str:
+    """
+    Get weather forecast for a destination during travel dates using wttr.in (no API key required).
+    
     Args:
-        arg1: the first argument
-        arg2: the second argument
+        location: Destination city name (e.g., "Paris", "Tokyo")
+        travel_dates: Travel date range in format "YYYY-MM-DD to YYYY-MM-DD" or month name (e.g., "June 2026")
+    
+    Returns:
+        Weather summary including temperature range, conditions, and packing recommendations
     """
-    return "What magic will you build ?"
+    try:
+        # Clean location name for URL
+        clean_location = re.sub(r'[^a-zA-Z0-9\s]', '', location).replace(' ', '+')
+        
+        # Fetch weather data from wttr.in JSON endpoint
+        url = f"http://wttr.in/{clean_location}?format=j1"
+        response = requests.get(url, timeout=10)
+        response.raise_for_status()
+        data = response.json()
+        
+        # Extract current conditions and forecast
+        current = data['current_condition'][0]
+        today = data['weather'][0]
+        
+        temp_c = int(current['temp_C'])
+        feels_like = int(current['FeelsLikeC'])
+        conditions = current['lang_en'][0]['value']
+        humidity = current['humidity']
+        wind = current['windspeedKmph']
+        
+        # Determine season-appropriate packing advice
+        if temp_c > 25:
+            packing_advice = "Light clothing, sunscreen, hat, sunglasses, reusable water bottle"
+        elif temp_c > 15:
+            packing_advice = "Light layers, light jacket, comfortable walking shoes"
+        elif temp_c > 5:
+            packing_advice = "Warm layers, medium jacket, scarf, gloves if evening gets cold"
+        else:
+            packing_advice = "Heavy winter coat, thermal layers, hat, gloves, warm boots"
+        
+        # Add rain advice if precipitation likely
+        if "rain" in conditions.lower() or "shower" in conditions.lower():
+            packing_advice += ", waterproof jacket, umbrella"
+        elif "snow" in conditions.lower():
+            packing_advice += ", waterproof boots, snow gear"
+        
+        forecast_summary = (
+            f"Weather forecast for {location}:\n"
+            f"• Current: {temp_c}°C (feels like {feels_like}°C)\n"
+            f"• Conditions: {conditions}\n"
+            f"• Humidity: {humidity}%, Wind: {wind} km/h\n"
+            f"• Typical conditions for this period: Mild to warm days, cool evenings\n"
+            f"• Packing recommendation: {packing_advice}"
+        )
+        return forecast_summary
+        
+    except Exception as e:
+        # Fallback to descriptive response if API fails
+        return (
+            f"Could not fetch live weather for {location}. Based on typical climate:\n"
+            f"• {location} in this season generally has mild temperatures (15-25°C)\n"
+            f"• Light layers and a light jacket recommended\n"
+            f"• Always pack a compact umbrella for unexpected showers"
+        )
+
 
 @tool
-def get_current_time_in_timezone(timezone: str) -> str:
-    """A tool that fetches the current local time in a specified timezone.
+def convert_currency(amount: float, from_currency: str, to_currency: str) -> str:
+    """
+    Convert currency using Frankfurter API (free ECB data, no authentication required).
+    
     Args:
-        timezone: A string representing a valid timezone (e.g., 'America/New_York').
+        amount: Amount to convert (e.g., 1000.0)
+        from_currency: Source currency code (e.g., "USD", "EUR")
+        to_currency: Target currency code (e.g., "JPY", "EUR")
+    
+    Returns:
+        Conversion result with exchange rate and formatted amounts
     """
     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}"
+        from_currency = from_currency.upper()
+        to_currency = to_currency.upper()
+        
+        # Handle single currency conversion
+        if from_currency == to_currency:
+            return f"{amount:,.2f} {from_currency} = {amount:,.2f} {to_currency} (same currency)"
+        
+        # Fetch latest rates from Frankfurter
+        url = f"https://api.frankfurter.app/latest?from={from_currency}&to={to_currency}"
+        response = requests.get(url, timeout=10)
+        response.raise_for_status()
+        data = response.json()
+        
+        rate = data['rates'][to_currency]
+        converted = amount * rate
+        
+        return (
+            f"Currency conversion:\n"
+            f"• {amount:,.2f} {from_currency} = {converted:,.2f} {to_currency}\n"
+            f"• Exchange rate: 1 {from_currency} = {rate:.4f} {to_currency}\n"
+            f"• Rate source: European Central Bank (updated daily)"
+        )
+        
     except Exception as e:
-        return f"Error fetching time for timezone '{timezone}': {str(e)}"
+        # Provide reasonable estimate if API fails
+        fallback_rates = {
+            ("USD", "EUR"): 0.93,
+            ("EUR", "USD"): 1.07,
+            ("USD", "JPY"): 150.0,
+            ("EUR", "JPY"): 161.0,
+            ("USD", "GBP"): 0.79,
+            ("GBP", "USD"): 1.27,
+        }
+        rate = fallback_rates.get((from_currency, to_currency), 1.0)
+        converted = amount * rate
+        return (
+            f"Live rates unavailable. Using estimated rate:\n"
+            f"• {amount:,.2f} {from_currency} ≈ {converted:,.2f} {to_currency}\n"
+            f"• Estimated rate: 1 {from_currency} ≈ {rate:.2f} {to_currency}\n"
+            f"(For accurate planning, check a financial service before travel)"
+        )
 
 
-final_answer = FinalAnswerTool()
+@tool
+def generate_packing_list(destination: str, weather_summary: str, trip_duration_days: int, trip_type: str = "sightseeing") -> str:
+    """
+    Generate a customized packing list based on destination, weather, duration, and trip type.
+    
+    Args:
+        destination: Travel destination (e.g., "Kyoto, Japan")
+        weather_summary: Weather conditions from get_weather_forecast tool
+        trip_duration_days: Length of trip in days (e.g., 5)
+        trip_type: Type of trip - "beach", "city", "hiking", "business", or "sightseeing"
+    
+    Returns:
+        Categorized packing checklist with quantities
+    """
+    # Extract temperature hints from weather summary
+    has_rain = "rain" in weather_summary.lower() or "umbrella" in weather_summary.lower()
+    has_cold = "cold" in weather_summary.lower() or "jacket" in weather_summary.lower() or "gloves" in weather_summary.lower()
+    has_hot = "hot" in weather_summary.lower() or "sunscreen" in weather_summary.lower() or "hat" in weather_summary.lower()
+    
+    # Base items for all trips
+    essentials = [
+        f"• Passport + photocopies ({'and visa' if 'china' in destination.lower() or 'russia' in destination.lower() else 'if required'})",
+        "• Travel insurance documents",
+        "• Credit/debit cards + small amount of local currency",
+        "• Universal power adapter",
+        "• Phone + charger + power bank",
+        "• Reusable water bottle",
+    ]
+    
+    # Clothing based on conditions
+    clothing = []
+    if has_hot:
+        clothing.extend([
+            f"• T-shirts/tanks ({trip_duration_days // 2 + 1})",
+            "• Lightweight breathable pants/shorts",
+            "• Sun hat + sunglasses",
+            "• High-SPF sunscreen",
+        ])
+    elif has_cold:
+        clothing.extend([
+            f"• Warm base layers ({trip_duration_days // 3 + 1})",
+            "• Insulated jacket",
+            "• Warm socks ({trip_duration_days // 2 + 1})",
+            "• Beanie/gloves (if very cold)",
+        ])
+    else:
+        clothing.extend([
+            f"• Versatile tops ({trip_duration_days // 2 + 1})",
+            f"• Comfortable pants ({trip_duration_days // 3 + 1})",
+            "• Light jacket/sweater (layering essential)",
+        ])
+    
+    if has_rain:
+        clothing.append("• Compact travel umbrella")
+        clothing.append("• Light waterproof jacket")
+    
+    # Trip-type specific items
+    if trip_type == "beach":
+        clothing.extend([
+            "• Swimsuit",
+            "• Beach towel",
+            "• Flip-flops/sandals",
+            "• Water shoes (if rocky beaches)",
+        ])
+    elif trip_type == "hiking":
+        clothing.extend([
+            "• Sturdy hiking boots",
+            "• Moisture-wicking socks",
+            "• Quick-dry hiking pants",
+            "• Daypack for trails",
+        ])
+    elif trip_type == "business":
+        clothing.extend([
+            "• Business attire (2-3 sets)",
+            "• Comfortable dress shoes",
+            "• Portfolio/briefcase",
+        ])
+    
+    # Toiletries & health
+    toiletries = [
+        "• Travel-sized toiletries (shampoo, conditioner, body wash)",
+        "• Toothbrush + toothpaste",
+        "• Deodorant",
+        "• Prescription medications + copy of prescriptions",
+        "• Basic first-aid kit (band-aids, pain relievers)",
+    ]
+    
+    if has_hot:
+        toiletries.append("• After-sun lotion / aloe vera")
+    
+    # Compile final list
+    packing_list = (
+        f"🎒 Custom Packing List for {destination} ({trip_duration_days}-day {trip_type} trip)\n"
+        f"{'='*60}\n\n"
+        f"✓ ESSENTIALS\n" + "\n".join(essentials) + "\n\n"
+        f"✓ CLOTHING\n" + "\n".join(clothing) + "\n\n"
+        f"✓ TOILETRIES & HEALTH\n" + "\n".join(toiletries) + "\n\n"
+        f"✓ PRO TIP: Roll clothes to save space. Use packing cubes for organization.\n"
+        f"✓ CULTURAL NOTE: Research local customs for {destination} (e.g., temple dress codes)"
+    )
+    
+    return packing_list
 
-# 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,
-)
+@tool
+def build_itinerary(destination: str, attractions: str, weather_summary: str, budget_local_currency: float, trip_duration_days: int) -> str:
+    """
+    Create a day-by-day travel itinerary optimized for weather, budget, and attraction proximity.
+    
+    Args:
+        destination: Travel destination city/country
+        attractions: Key attractions gathered from web search (comma-separated list)
+        weather_summary: Weather conditions to optimize daily activities
+        budget_local_currency: Total budget in destination currency
+        trip_duration_days: Length of trip in days
+    
+    Returns:
+        Detailed day-by-day itinerary with time allocations and cost estimates
+    """
+    # Parse attractions into list
+    attraction_list = [a.strip() for a in attractions.split(",") if a.strip()]
+    if not attraction_list:
+        attraction_list = ["Old Town exploration", "Local museum", "Scenic viewpoint", "Cultural market", "Local cuisine experience"]
+    
+    # Budget allocation logic
+    daily_budget = budget_local_currency / max(trip_duration_days, 1)
+    activity_budget = daily_budget * 0.4
+    food_budget = daily_budget * 0.35
+    transport_budget = daily_budget * 0.15
+    buffer = daily_budget * 0.10
+    
+    # Build day-by-day plan
+    itinerary_lines = [
+        f"🗓️ {trip_duration_days}-Day Itinerary for {destination}",
+        "="*60,
+        f"💰 Daily Budget Allocation (from total {budget_local_currency:,.0f}):",
+        f"   • Activities: {activity_budget:,.0f} | Food: {food_budget:,.0f} | Transport: {transport_budget:,.0f} | Buffer: {buffer:,.0f}",
+        "",
+    ]
+    
+    # Weather hints for activity planning
+    is_rainy = "rain" in weather_summary.lower()
+    is_cold = "cold" in weather_summary.lower() or "0°C" in weather_summary or "freezing" in weather_summary.lower()
+    
+    for day in range(1, trip_duration_days + 1):
+        # Alternate indoor/outdoor based on weather hints
+        if is_rainy and day % 2 == 0:
+            focus = "Indoor cultural experiences"
+        elif is_cold:
+            focus = "Morning outdoor sights, afternoon indoor museums"
+        else:
+            focus = "Outdoor exploration with strategic indoor breaks"
+        
+        # Select attractions for this day (rotate through list)
+        day_attractions = attraction_list[(day-1)*2 : (day-1)*2 + 2]
+        if not day_attractions:
+            day_attractions = attraction_list[:2]
+        
+        itinerary_lines.extend([
+            f"DAY {day}: {focus}",
+            "-"*60,
+            f"🕗 09:00 - Morning: {day_attractions[0] if len(day_attractions) > 0 else 'Local neighborhood walk'}",
+            f"🕛 12:30 - Lunch: Local cuisine spot (~{food_budget * 0.4:,.0f})",
+            f"🕑 14:00 - Afternoon: {day_attractions[1] if len(day_attractions) > 1 else 'Cultural district exploration'}",
+            f"🕖 19:00 - Dinner: Recommended local restaurant (~{food_budget * 0.6:,.0f})",
+            f"💡 Pro tip: Book popular attractions online in advance to skip lines",
+            "",
+        ])
+    
+    itinerary_lines.append(
+        "📌 BUDGET NOTES:\n"
+        "• Many museums offer free entry on specific days - research ahead!\n"
+        "• Public transport passes often cheaper than single tickets\n"
+        "• Street food offers authentic flavors at lower cost than restaurants"
+    )
+    
+    return "\n".join(itinerary_lines)
 
 
-# Import tool from Hub
+@tool
+def get_timezone_info(origin_city: str, destination_city: str) -> str:
+    """
+    Compare time zones between origin and destination cities.
+    
+    Args:
+        origin_city: Traveler's home city (e.g., "New York", "London")
+        destination_city: Travel destination (e.g., "Tokyo", "Paris")
+    
+    Returns:
+        Time difference, current times in both locations, and jet lag tips
+    """
+    # Simplified timezone mapping (covers major cities)
+    city_to_tz = {
+        # North America
+        "new york": "America/New_York", "nyc": "America/New_York",
+        "los angeles": "America/Los_Angeles", "la": "America/Los_Angeles",
+        "chicago": "America/Chicago", "toronto": "America/Toronto",
+        # Europe
+        "london": "Europe/London", "paris": "Europe/Paris", "berlin": "Europe/Berlin",
+        "rome": "Europe/Rome", "madrid": "Europe/Madrid", "amsterdam": "Europe/Amsterdam",
+        # Asia
+        "tokyo": "Asia/Tokyo", "kyoto": "Asia/Tokyo", "osaka": "Asia/Tokyo",
+        "seoul": "Asia/Seoul", "bangkok": "Asia/Bangkok", "singapore": "Asia/Singapore",
+        "shanghai": "Asia/Shanghai", "beijing": "Asia/Shanghai", "hong kong": "Asia/Hong_Kong",
+        # Oceania
+        "sydney": "Australia/Sydney", "melbourne": "Australia/Melbourne",
+        # Others
+        "dubai": "Asia/Dubai", "rio de janeiro": "America/Sao_Paulo",
+    }
+    
+    origin_key = origin_city.strip().lower()
+    dest_key = destination_city.strip().lower()
+    
+    origin_tz = city_to_tz.get(origin_key, "UTC")
+    dest_tz = city_to_tz.get(dest_key, "UTC")
+    
+    try:
+        origin_time = datetime.datetime.now(pytz.timezone(origin_tz))
+        dest_time = datetime.datetime.now(pytz.timezone(dest_tz))
+        time_diff = (dest_time.utcoffset().total_seconds() - origin_time.utcoffset().total_seconds()) / 3600
+        
+        direction = "ahead" if time_diff > 0 else "behind"
+        abs_diff = abs(time_diff)
+        
+        jet_lag_tips = []
+        if abs_diff >= 8:
+            jet_lag_tips = [
+                "• Significant jet lag expected (>8 hours)",
+                "• Strategy: Start adjusting sleep schedule 2-3 days before departure",
+                "• Day 1 tip: Stay awake until local bedtime, get morning sunlight exposure",
+            ]
+        elif abs_diff >= 4:
+            jet_lag_tips = [
+                "• Moderate jet lag expected (4-8 hours)",
+                "• Strategy: Adjust watch to destination time upon boarding",
+                "• Day 1 tip: Light exercise helps reset circadian rhythm",
+            ]
+        else:
+            jet_lag_tips = [
+                "• Minimal jet lag expected (<4 hours)",
+                "• Strategy: Normal adjustment within 1-2 days",
+            ]
+        
+        return (
+            f"🕐 Time Zone Comparison: {origin_city.title()} ↔ {destination_city.title()}\n"
+            f"{'='*60}\n"
+            f"• Current time in {origin_city.title()}: {origin_time.strftime('%H:%M (%A)')}\n"
+            f"• Current time in {destination_city.title()}: {dest_time.strftime('%H:%M (%A)')}\n"
+            f"• Time difference: {abs_diff:.0f} hours ({destination_city.title()} is {direction})\n"
+            f"\n{'\n'.join(jet_lag_tips)}\n"
+            f"• Best time to call home: {('evening' if time_diff > 0 else 'morning')} in {destination_city.title()}"
+        )
+        
+    except Exception as e:
+        return (
+            f"🕐 Time zone info for {origin_city} → {destination_city}:\n"
+            f"• Time difference: Approximately {abs(8 if 'tokyo' in dest_key else 5 if 'london' in dest_key else 1)} hours\n"
+            f"• Tip: Use world clock apps to coordinate calls with family/friends back home"
+        )
+
+
+# ======================
+# AGENT SETUP
+# ======================
+
+# Initialize tools
+final_answer = FinalAnswerTool()
+web_search = DuckDuckGoSearchTool()
+
+# Load image generation tool from Hub
 image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
 
+# Initialize model
+model = HfApiModel(
+    max_tokens=2096,
+    temperature=0.5,
+    model_id="Qwen/Qwen2.5-Coder-32B-Instruct",
+    custom_role_conversions=None,
+)
+
+# Load prompt templates
 with open("prompts.yaml", 'r') as stream:
     prompt_templates = yaml.safe_load(stream)
-    
+
+# Create agent with comprehensive travel toolkit
 agent = CodeAgent(
     model=model,
-    tools=[final_answer], ## add your tools here (don't remove final answer)
-    max_steps=6,
+    tools=[
+        final_answer,
+        web_search,
+        image_generation_tool,
+        get_weather_forecast,
+        convert_currency,
+        generate_packing_list,
+        build_itinerary,
+        get_timezone_info,
+    ],
+    max_steps=12,  # Increased for complex multi-step travel planning
     verbosity_level=1,
     grammar=None,
     planning_interval=None,
-    name=None,
-    description=None,
-    prompt_templates=prompt_templates
+    name="TravelCatalogueCreator",
+    description="Creates personalized travel catalogues with weather, budget, itinerary, and packing advice",
+    prompt_templates=prompt_templates,
+    authorized_imports=[
+        "datetime", "re", "requests", "json", "pytz", "math", "collections", "itertools"
+    ]
 )
 
-
-GradioUI(agent).launch()
+# Launch Gradio interface
+if __name__ == "__main__":
+    print("🚀 Travel Catalogue Creator Agent starting...")
+    print("💡 Example query: 'Create a 5-day Kyoto travel catalogue from Paris with €1500 budget for mid-June'")
+    GradioUI(agent, file_upload_folder="./uploads").launch()