Update app.py

updates reled to image generation

app.py

@@ -1,151 +1,340 @@
 #!/usr/bin/env python
 # coding=utf-8
+import os
 import re
 import requests
+from datetime import datetime, timedelta
+from typing import Optional
 from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, tool
-from tools.final_answer import FinalAnswerTool
 from Gradio_UI import GradioUI
 
 # ======================
-# MINIMAL COMPLIANT TOOLS (Google-style docstrings REQUIRED)
+# TRAVEL TOOLS (PRODUCTION-GRADE)
 # ======================
 
 @tool
-def get_weather(location: str, dates: str) -> str:
+def get_weather_forecast(location: str, travel_dates: str) -> str:
     """
-    Get weather forecast for destination.
-    
+    Get weather forecast using OpenWeatherMap (fallback to wttr.in).
     Args:
         location: Destination city (e.g., "Barcelona")
-        dates: Travel dates (e.g., "October 15-19")
-    
+        travel_dates: Date range (e.g., "2026-10-15 to 2026-10-19")
     Returns:
-        Weather summary with temperature and packing advice
+        Weather summary with packing advice
     """
+    api_key = os.environ.get("OPENWEATHER_API_KEY")
     try:
-        clean = re.sub(r'[^a-zA-Z0-9\s]', '', location).replace(' ', '+')
-        data = requests.get(f"http://wttr.in/{clean}?format=j1", timeout=10).json()
-        temp = int(data['current_condition'][0]['temp_C'])
-        cond = data['current_condition'][0]['lang_en'][0]['value']
-        advice = "light layers + jacket" if temp < 22 else "light clothing + sunscreen"
-        if "rain" in cond.lower():
-            advice += " + umbrella"
-        return f"{location}: {temp}°C, {cond}. Pack: {advice}"
-    except:
-        return f"{location}: Typical 18-24°C in Oct. Pack light layers + light jacket + umbrella."
+        # Parse dates to get start date
+        start_date = re.search(r"(\d{4}-\d{2}-\d{2})", travel_dates)
+        if not start_date:
+            raise ValueError("Invalid date format")
+        
+        # Try OpenWeatherMap first (more reliable)
+        if api_key:
+            city = re.sub(r"[^a-zA-Z\s]", "", location).strip()
+            resp = requests.get(
+                f"https://api.openweathermap.org/data/2.5/forecast",
+                params={"q": city, "appid": api_key, "units": "metric"},
+                timeout=10
+            )
+            if resp.status_code == 200:
+                data = resp.json()
+                day1 = data["list"][0]
+                temp = day1["main"]["temp"]
+                cond = day1["weather"][0]["description"]
+                rain = "rain" in cond.lower() or day1.get("rain", {}).get("3h", 0) > 1
+                return _generate_packing_advice(location, temp, cond, rain)
+        
+        # Fallback to wttr.in
+        clean = re.sub(r"[^a-zA-Z0-9\s]", "", location).replace(" ", "+")
+        resp = requests.get(f"http://wttr.in/{clean}?format=j1", timeout=10)
+        if resp.status_code == 200:
+            data = resp.json()
+            cur = data["current_condition"][0]
+            temp = int(cur["temp_C"])
+            cond = cur["lang_en"][0]["value"]
+            rain = "rain" in cond.lower()
+            return _generate_packing_advice(location, temp, cond, rain)
+            
+    except Exception:
+        pass
+    
+    # Safe fallback
+    return f"{location} typical weather: 15-25°C. Pack light layers, light jacket, and compact umbrella."
 
+def _generate_packing_advice(location: str, temp: float, condition: str, rain: bool) -> str:
+    """Helper to generate weather-based packing advice"""
+    if temp > 25:
+        clothes = "Light clothing, shorts, breathable fabrics"
+    elif temp > 15:
+        clothes = "Light layers, long sleeves, light jacket"
+    else:
+        clothes = "Warm layers, jacket, beanie recommended"
+    
+    if rain:
+        clothes += " + waterproof jacket + compact umbrella"
+    
+    return f"{location} forecast: {temp:.0f}°C, {condition}. Packing: {clothes}"
 
 @tool
-def convert_currency(amount: float, from_curr: str, to_curr: str) -> str:
+def convert_currency(amount: float, from_currency: str, to_currency: str) -> str:
     """
-    Convert currency using Frankfurter API.
-    
+    Convert currency using Frankfurter API (no key required).
     Args:
-        amount: Amount to convert (e.g., 1200.0)
-        from_curr: Source currency code (e.g., "USD")
-        to_curr: Target currency code (e.g., "EUR")
-    
+        amount: Amount to convert
+        from_currency: Source currency (e.g., "USD")
+        to_currency: Target currency (e.g., "EUR")
     Returns:
         Formatted conversion result
     """
     try:
-        from_curr = from_curr.upper()
-        to_curr = to_curr.upper()
+        from_curr = from_currency.upper()[:3]
+        to_curr = to_currency.upper()[:3]
+        
         if from_curr == to_curr:
             return f"{amount:,.0f} {from_curr}"
-        rate = requests.get(
-            f"https://api.frankfurter.app/latest?from={from_curr}&to={to_curr}",
+        
+        resp = requests.get(
+            f"https://api.frankfurter.app/latest",
+            params={"from": from_curr, "to": to_curr},
             timeout=10
-        ).json()['rates'][to_curr]
-        return f"{amount:,.0f} {from_curr} = {amount*rate:,.0f} {to_curr}"
-    except:
-        return f"{amount:,.0f} {from_curr} (≈{amount*0.93:,.0f} EUR est.)"
+        )
+        if resp.status_code == 200:
+            rate = resp.json()["rates"][to_curr]
+            converted = amount * rate
+            return f"{amount:,.0f} {from_curr} = {converted:,.0f} {to_curr} (1 {from_curr} = {rate:.2f} {to_curr})"
+    except Exception:
+        pass
+    
+    return f"{amount:,.0f} {from_currency} (conversion rate unavailable)"
 
+@tool
+def get_time_difference(origin: str, destination: str) -> str:
+    """
+    Get time difference between origin and destination cities.
+    Args:
+        origin: Home city
+        destination: Travel destination
+    Returns:
+        Time difference description
+    """
+    try:
+        # Simple heuristic-based approach (no external API required)
+        major_cities = {
+            "new york": -5, "london": 0, "paris": 1, "tokyo": 9, "sydney": 10,
+            "los angeles": -8, "chicago": -6, "mumbai": 5.5, "dubai": 4,
+            "singapore": 8, "berlin": 1, "rome": 1, "barcelona": 1, "madrid": 1
+        }
+        
+        origin_tz = major_cities.get(origin.lower(), 0)
+        dest_tz = major_cities.get(destination.lower(), 0)
+        diff = dest_tz - origin_tz
+        
+        if diff == 0:
+            return f"No time difference between {origin} and {destination}"
+        elif diff > 0:
+            return f"{destination} is {diff} hours ahead of {origin} (adjust sleep schedule accordingly)"
+        else:
+            return f"{destination} is {abs(diff)} hours behind {origin} (prepare for jet lag)"
+    except:
+        return f"Time difference information unavailable. Check world clock apps before travel."
 
 @tool
-def build_catalogue(destination: str, origin: str, dates: str, budget: str, weather: str, image_url_1: str, image_url_2: str) -> str:
+def generate_packing_list(destination: str, weather_summary: str, trip_days: int, trip_type: str) -> str:
     """
-    Assemble final travel catalogue with embedded images.
-    
+    Generate customized packing list.
     Args:
-        destination: Destination city (e.g., "Barcelona")
-        origin: Home city (e.g., "New York")
-        dates: Travel dates (e.g., "Oct 15-19")
-        budget: Budget conversion result (e.g., "$1,200 = €1,116")
-        weather: Weather forecast summary
-        image_url_1: First generated image URL from image_generation_tool
-        image_url_2: Second generated image URL from image_generation_tool
+        destination: Destination name
+        weather_summary: Weather conditions
+        trip_days: Duration in days
+        trip_type: "city", "beach", "mountain", or "mixed"
+    Returns:
+        Formatted packing checklist
+    """
+    cold = any(w in weather_summary.lower() for w in ["cold", "cool", "jacket", "10°c", "11°c", "12°c", "13°c", "14°c"])
+    rain = any(w in weather_summary.lower() for w in ["rain", "shower", "umbrella", "drizzle"])
+    hot = any(w in weather_summary.lower() for w in ["hot", "warm", "25°c", "26°c", "27°c", "28°c", "29°c", "30°c"])
     
+    # Clothing calculations
+    tops = min(trip_days, trip_days // 2 + 2)
+    bottoms = min(trip_days // 2 + 1, 4)
+    
+    clothes = [f"• Tops ({tops})", f"• Bottoms ({bottoms})"]
+    if cold:
+        clothes.extend(["• Warm jacket", "• Long underwear (if very cold)"])
+    elif hot:
+        clothes.extend(["• Light breathable fabrics", "• Sun hat"])
+    else:
+        clothes.append("• Light jacket (essential)")
+    
+    if rain:
+        clothes.extend(["• Compact umbrella", "• Quick-dry clothing"])
+    
+    if trip_type == "beach":
+        clothes.extend(["• Swimsuit (x2)", "• Flip-flops", "• Reef-safe sunscreen"])
+    elif trip_type == "mountain":
+        clothes.extend(["• Sturdy hiking shoes", "• Moisture-wicking layers", "• Trekking poles (optional)"])
+    
+    return (
+        f"🎒 SMART PACKING LIST ({trip_days}-day {trip_type} trip to {destination})\n"
+        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
+        "ESSENTIALS\n"
+        "• Passport + photocopies + digital scans\n"
+        "• Credit/debit cards + local currency (small amount)\n"
+        "• Universal power adapter\n"
+        "• Phone + portable charger + cables\n"
+        "• Travel insurance documents\n"
+        "\nCLOTHING\n" + "\n".join(clothes) + "\n"
+        "\nHEALTH & HYGIENE\n"
+        "• Prescription medications (in original packaging)\n"
+        "• Basic first-aid kit\n"
+        "• Hand sanitizer + tissues\n"
+        "• Travel-sized toiletries\n"
+        "\n💡 Pro tip: Roll clothes to save space. Pack one versatile outfit per day + 1 extra."
+    )
+
+@tool
+def build_itinerary(destination: str, attractions: str, budget_local: float, days: int) -> str:
+    """
+    Create realistic day-by-day itinerary.
+    Args:
+        destination: City name
+        attractions: Comma-separated attractions
+        budget_local: Daily budget in local currency
+        days: Trip duration
     Returns:
-        Beautiful Markdown travel catalogue with embedded images
+        Formatted itinerary
+    """
+    atts = [a.strip() for a in attractions.split(",") if a.strip()]
+    if not atts:
+        atts = ["Old Town exploration", "Local museum", "Scenic viewpoint", "Local market"]
+    
+    daily_budget = budget_local / max(days, 1)
+    lines = [f"🗓️ {days}-DAY REALISTIC ITINERARY: {destination}", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"]
+    
+    for d in range(1, days + 1):
+        # Alternate between major and minor attractions
+        primary = atts[(d - 1) % len(atts)]
+        secondary = atts[d % len(atts)] if len(atts) > 1 else "Leisurely café break"
+        
+        lines.extend([
+            f"\nDAY {d} | Budget: ~{daily_budget:,.0f} local currency",
+            f"  09:00 - 12:00  {primary}",
+            f"  12:30 - 14:00  Lunch at local spot",
+            f"  14:30 - 17:00  {secondary}",
+            f"  19:00+         Dinner + evening stroll"
+        ])
+    
+    lines.append("\n💡 Book major attractions online in advance to skip lines!")
+    return "\n".join(lines)
+
+@tool
+def assemble_catalogue(
+    destination: str,
+    origin: str,
+    dates: str,
+    budget_summary: str,
+    weather: str,
+    timezone_info: str,
+    itinerary: str,
+    packing: str,
+    image_url_1: str,
+    image_url_2: str
+) -> str:
+    """
+    Compile final travel catalogue with embedded images.
     """
     return f"""# 🌍 {destination} Travel Catalogue
-*From {origin} • {dates} • Budget: {budget}*
+*From {origin} • {dates} • {budget_summary}*
+
+---
 
-## 🌤️ Weather
+## ⏰ Time Zone Adjustment
+{timezone_info}
+
+---
+
+## 🌤️ Weather & Packing Guidance
 {weather}
 
-## 📸 Destination Views
-![{destination} landmark]({image_url_1})
-*Generated landmark view*
+---
+
+## 🗓️ Your Personalized Itinerary
+{itinerary}
 
-![{destination} street scene]({image_url_2})
-*Generated street scene*
+---
 
-> 💡 Pro Tip: Book Sagrada Familia tickets online to skip 2-hour queues!
+## 🎒 Packing Checklist
+{packing}
+
+---
+
+## 📸 Visual Inspiration
+<div style="display: flex; gap: 20px; margin: 20px 0;">
+  <div style="flex: 1; text-align: center;">
+    <img src="{image_url_1}" alt="{destination} landmark" style="max-width: 100%; border-radius: 8px; box-shadow: 0 4px 8px rgba(0,0,0,0.1);">
+    <p><em>Iconic {destination} landmark</em></p>
+  </div>
+  <div style="flex: 1; text-align: center;">
+    <img src="{image_url_2}" alt="{destination} street scene" style="max-width: 100%; border-radius: 8px; box-shadow: 0 4px 8px rgba(0,0,0,0.1);">
+    <p><em>Vibrant street life</em></p>
+  </div>
+</div>
+
+---
+
+> 💡 **Travel Pro Tips**  
+> • Download offline maps before departure  
+> • Learn 5 basic phrases in the local language  
+> • Keep digital copies of important documents in cloud storage  
+> • Budget 10-15% extra for unexpected experiences  
+> • Public transport passes often save 30%+ vs single tickets
 """
 
 # ======================
-# AGENT SETUP (CRITICAL FIXES)
+# AGENT SETUP
 # ======================
-
-# Load tools
-final_answer = FinalAnswerTool()
-web_search = DuckDuckGoSearchTool()
-image_gen = load_tool("agents-course/text-to-image", trust_remote_code=True)
-
-# Use minimal system prompt that encourages CODE BLOCKS (not prose)
-system_prompt = (
-    "You are a travel assistant. ALWAYS respond with executable Python code blocks.\n"
-    "Workflow:\n"
-    "1. Use DuckDuckGoSearchTool to find attractions\n"
-    "2. Use get_weather for forecast\n"
-    "3. Use convert_currency for budget\n"
-    "4. CALL image_generation_tool TWICE:\n"
-    "   img1 = image_generation_tool('{destination} landmark photorealistic')\n"
-    "   img2 = image_generation_tool('{destination} vibrant street scene')\n"
-    "5. Use build_catalogue with BOTH image URLs\n"
-    "NEVER output natural language steps. ONLY output:\n"
-    "Thoughts: ...\n"
-    "Code:\n"
-    "```py\n"
-    "# executable code\n"
-    "```"
-)
-
-model = HfApiModel(
-    max_tokens=1500,  # Prevent token exhaustion
-    temperature=0.2,   # Lower = more deterministic code output
-    model_id="Qwen/Qwen2.5-Coder-32B-Instruct",
-)
-
-agent = CodeAgent(
-    model=model,
-    tools=[
-        final_answer,
-        web_search,
-        image_gen,  # MUST be in tool list to be callable in code blocks
-        get_weather,
-        convert_currency,
-        build_catalogue,
-    ],
-    max_steps=12,
-    verbosity_level=1,
-    name="TravelAgent",
-    description="Creates travel catalogues with images",
-    prompt_templates={"system_prompt": system_prompt},
-)
-
 if __name__ == "__main__":
-    print("🚀 Travel Agent with guaranteed image generation")
+    print("🚀 Initializing Travel Catalogue Creator...")
+    
+    # Load tools
+    try:
+        image_gen = load_tool("black-forest-labs/FLUX.1-schnell", trust_remote_code=True)
+    except:
+        # Fallback to stable tool
+        image_gen = load_tool("stabilityai/stable-diffusion-3-medium", trust_remote_code=True)
+    
+    web_search = DuckDuckGoSearchTool()
+    model = HfApiModel(
+        max_tokens=2048,
+        temperature=0.3,  # Lower for reliable tool usage
+        model_id="Qwen/Qwen2.5-Coder-32B-Instruct",
+    )
+    
+    # System prompt enforces strict workflow
+    with open("prompts.yaml", "r") as f:
+        import yaml
+        prompt_templates = yaml.safe_load(f)
+    
+    agent = CodeAgent(
+        model=model,
+        tools=[
+            web_search,
+            image_gen,
+            get_weather_forecast,
+            convert_currency,
+            get_time_difference,
+            generate_packing_list,
+            build_itinerary,
+            assemble_catalogue,
+        ],
+        max_steps=25,  # Allow room for image generation + retries
+        verbosity_level=1,
+        name="TravelCatalogueCreator",
+        description="Creates comprehensive, personalized travel catalogues with images",
+        prompt_templates=prompt_templates,
+    )
+    
+    # Launch UI
+    os.makedirs("./uploads", exist_ok=True)
     GradioUI(agent, file_upload_folder="./uploads").launch()