app.py

import gradio as gr
from huggingface_hub import InferenceClient
import json
from typing import Dict, List, Tuple

# Hotel data
HOTELS = [
    {
        "name": "Azure Haven",
        "pricingPerDay": 250,
        "roomTypes": ["Single Room", "Double Room", "Suite"],
        "description": "Azure Haven is a tranquil getaway offering breathtaking ocean views and luxurious amenities. Ideal for a peaceful escape or a romantic retreat."
    },
    {
        "name": "Golden Sands Resort",
        "pricingPerDay": 300,
        "roomTypes": ["Standard Room", "Deluxe Room", "Family Suite"],
        "description": "Nestled on a pristine beach, Golden Sands Resort is perfect for family vacations and adventure seekers. Enjoy watersports, beachside dining, and more."
    },
    {
        "name": "Mountain Bliss Lodge",
        "pricingPerDay": 220,
        "roomTypes": ["Cabin", "Deluxe Cabin", "Mountain Suite"],
        "description": "Mountain Bliss Lodge offers cozy cabins and stunning mountain views. A perfect destination for nature lovers and outdoor enthusiasts."
    },
    {
        "name": "Urban Oasis Hotel",
        "pricingPerDay": 280,
        "roomTypes": ["Single Room", "Double Room", "Executive Suite"],
        "description": "Located in the heart of the city, Urban Oasis Hotel combines modern luxury with convenient access to top attractions, dining, and entertainment."
    },
    {
        "name": "Lakeside Retreat",
        "pricingPerDay": 270,
        "roomTypes": ["Single Room", "Double Room", "Lakeside Suite"],
        "description": "Lakeside Retreat offers serene lakeside accommodations with a focus on relaxation and rejuvenation. Enjoy spa treatments, boating, and picturesque views."
    }
]

# Cost constants
COST_FACTORS = {
    "local_transport_per_day": {
        "Budget Backpacking": 10,
        "Cultural & Sightseeing": 20,
        "Adventure & Outdoor": 25,
        "Food & Culinary": 20,
        "Relaxation & Wellness": 15,
        "Luxury & High-End": 50,
        "Family-Friendly": 30
    },
    "food_cost_per_day": {
        "Budget Backpacking": 30,
        "Cultural & Sightseeing": 50,
        "Adventure & Outdoor": 45,
        "Food & Culinary": 80,
        "Relaxation & Wellness": 60,
        "Luxury & High-End": 120,
        "Family-Friendly": 70
    },
    "activities_cost_per_day": {
        "Budget Backpacking": 20,
        "Cultural & Sightseeing": 40,
        "Adventure & Outdoor": 60,
        "Food & Culinary": 45,
        "Relaxation & Wellness": 80,
        "Luxury & High-End": 150,
        "Family-Friendly": 70
    }
}

client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")

def calculate_flight_cost(origin: str, destination: str, budget: int) -> float:
    """Estimate flight cost based on budget and journey type."""
    # Basic estimation - can be enhanced with actual flight data API
    if budget < 2000:
        return budget * 0.3  # 30% of budget for budget trips
    elif budget < 5000:
        return budget * 0.35  # 35% for mid-range trips
    else:
        return budget * 0.4  # 40% for luxury trips

def calculate_daily_costs(holiday_type: str) -> Dict[str, float]:
    """Calculate daily costs based on holiday type."""
    return {
        "local_transport": COST_FACTORS["local_transport_per_day"][holiday_type],
        "food": COST_FACTORS["food_cost_per_day"][holiday_type],
        "activities": COST_FACTORS["activities_cost_per_day"][holiday_type]
    }

def get_suitable_hotels(budget_per_day: float, holiday_type: str) -> List[Dict]:
    """Get suitable hotels based on daily budget and holiday type."""
    max_hotel_budget = budget_per_day * 0.4  # 40% of daily budget for accommodation
    
    suitable_hotels = []
    for hotel in HOTELS:
        if hotel["pricingPerDay"] <= max_hotel_budget:
            match_score = 0
            # Score hotels based on type match
            if holiday_type == "Relaxation & Wellness" and ("Haven" in hotel["name"] or "Retreat" in hotel["name"]):
                match_score += 2
            elif holiday_type == "Adventure & Outdoor" and ("Mountain" in hotel["name"] or "Sands" in hotel["name"]):
                match_score += 2
            elif holiday_type == "Cultural & Sightseeing" and "Urban" in hotel["name"]:
                match_score += 2
            elif holiday_type == "Family-Friendly" and "Family" in str(hotel["roomTypes"]):
                match_score += 2
            
            suitable_hotels.append({"hotel": hotel, "match_score": match_score})
    
    # Sort by match score and then price
    sorted_hotels = sorted(suitable_hotels, key=lambda x: (-x["match_score"], x["hotel"]["pricingPerDay"]))
    return [hotel["hotel"] for hotel in sorted_hotels]

def calculate_total_costs(
    origin: str,
    destination: str,
    budget: int,
    num_days: int,
    holiday_type: str,
    selected_hotel: Dict
) -> Dict[str, float]:
    """Calculate detailed cost breakdown."""
    flight_cost = calculate_flight_cost(origin, destination, budget)
    daily_costs = calculate_daily_costs(holiday_type)
    
    accommodation_cost = selected_hotel["pricingPerDay"] * num_days
    local_transport_cost = daily_costs["local_transport"] * num_days
    food_cost = daily_costs["food"] * num_days
    activities_cost = daily_costs["activities"] * num_days
    
    total_cost = (
        flight_cost +
        accommodation_cost +
        local_transport_cost +
        food_cost +
        activities_cost
    )
    
    return {
        "flight": flight_cost,
        "accommodation": accommodation_cost,
        "local_transport": local_transport_cost,
        "food": food_cost,
        "activities": activities_cost,
        "total": total_cost,
        "per_day": total_cost / num_days
    }

def format_cost_breakdown(costs: Dict[str, float]) -> str:
    """Format cost breakdown for display."""
    return f"""Cost Breakdown:
- Flight: ${costs['flight']:,.2f}
- Accommodation: ${costs['accommodation']:,.2f}
- Local Transportation: ${costs['local_transport']:,.2f}
- Food & Dining: ${costs['food']:,.2f}
- Activities & Entertainment: ${costs['activities']:,.2f}

Total Cost: ${costs['total']:,.2f}
Average Daily Cost: ${costs['per_day']:,.2f}"""

def generate_itinerary(
    destination: str,
    origin: str,
    budget: int,
    num_days: int,
    holiday_type: str,
    system_message: str,
    max_tokens: int,
    temperature: float,
    top_p: float,
) -> str:
    # Calculate initial costs and get hotel recommendations
    recommended_hotels = get_suitable_hotels(budget/num_days, holiday_type)
    if not recommended_hotels:
        return "Error: No suitable hotels found for your budget. Please increase your budget or reduce the number of days."
    
    selected_hotel = recommended_hotels[0]
    costs = calculate_total_costs(origin, destination, budget, num_days, holiday_type, selected_hotel)
    
    if costs["total"] > budget:
        return f"""Warning: The estimated total cost (${costs['total']:,.2f}) exceeds your budget (${budget:,.2f}).
Please consider:
1. Increasing your budget
2. Reducing the number of days
3. Choosing a more budget-friendly holiday type
4. Selecting different destinations

{format_cost_breakdown(costs)}"""
    
    # Construct prompt with accurate cost information
    prompt = f"""Create a detailed {num_days}-day travel itinerary for a trip:
From: {origin}
To: {destination}
Budget Breakdown: {format_cost_breakdown(costs)}
Holiday Type: {holiday_type}

Recommended Accommodation:
{selected_hotel['name']} (${selected_hotel['pricingPerDay']}/night)
{selected_hotel['description']}

Please provide:
1. Day-by-day itinerary with specific activities and timing
2. Daily budget allocation matching the cost breakdown above
3. Specific local transportation recommendations
4. Restaurant suggestions within the food budget (${costs['food']/num_days:.2f}/day)
5. Activity recommendations within the activities budget (${costs['activities']/num_days:.2f}/day)

Format as a clear day-by-day breakdown with budgets for each activity."""

    messages = [
        {"role": "system", "content": system_message},
        {"role": "user", "content": prompt}
    ]

    response = ""
    for message in client.chat_completion(
        messages,
        max_tokens=max_tokens,
        stream=True,
        temperature=temperature,
        top_p=top_p,
    ):
        token = message.choices[0].delta.content
        response += token
        yield response

# [Previous Gradio interface code remains the same, just update the button click handler to use the new generate_itinerary function]
# Create the Gradio interface
with gr.Blocks(theme=gr.themes.Soft()) as demo:
    gr.Markdown("# 🌎 AI Travel Itinerary Generator ✈️")
    gr.Markdown("Enter your travel details for a customized itinerary with accurate cost calculations!")
    
    with gr.Row():
        with gr.Column():
            origin = gr.Textbox(label="Starting Location", placeholder="e.g., New York, USA")
            destination = gr.Textbox(label="Destination", placeholder="e.g., Paris, France")
            budget = gr.Slider(minimum=1000, maximum=15000, value=3000, step=100, label="Total Budget (USD)")
            num_days = gr.Slider(minimum=1, maximum=14, value=3, step=1, label="Number of Days")
            holiday_type = gr.Dropdown(
                choices=list(COST_FACTORS["local_transport_per_day"].keys()),
                label="Type of Holiday",
                value="Cultural & Sightseeing"
            )
    
    with gr.Accordion("Advanced Settings", open=False):
        system_message = gr.Textbox(
            value="You are an experienced travel planner. Provide detailed itineraries that strictly adhere to the given budget constraints and cost breakdown.",
            label="System Message",
            lines=3
        )
        max_tokens = gr.Slider(minimum=1, maximum=2048, value=1024, step=1, label="Max Tokens")
        temperature = gr.Slider(minimum=0.1, maximum=1.0, value=0.7, step=0.1, label="Temperature")
        top_p = gr.Slider(minimum=0.1, maximum=1.0, value=0.95, step=0.05, label="Top-p")

    with gr.Row():
        generate_button = gr.Button("Generate Itinerary", variant="primary")
        output = gr.Textbox(label="Your Custom Itinerary", lines=20, show_copy_button=True)

    generate_button.click(
        fn=generate_itinerary,
        inputs=[
            destination,
            origin,
            budget,
            num_days,
            holiday_type,
            system_message,
            max_tokens,
            temperature,
            top_p,
        ],
        outputs=output,
    )

if __name__ == "__main__":
    demo.launch()