Update app.py

app.py

@@ -3,29 +3,40 @@ import os
 import asyncio
 import json
 import datetime
+import requests # For making HTTP requests to external APIs like Perplexity AI
 from dotenv import load_dotenv
 
 # --- Langchain Imports ---
+# These libraries are essential for interacting with language models and parsing their outputs.
 from langchain_core.prompts import ChatPromptTemplate
 from langchain_core.output_parsers import JsonOutputParser
 from langchain_core.pydantic_v1 import BaseModel, Field
 from langchain_openai import ChatOpenAI
-from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_google_genai import ChatGoogleGenerativeAI # Kept for potential future use or redundancy
 from langchain_core.messages import SystemMessage, HumanMessage
 
-# Load environment variables from .env file (for local testing)
-# On Hugging Face Spaces, secrets are automatically available as env vars.
+# Load environment variables from .env file (for local testing).
+# On Hugging Face Spaces, secrets are automatically available as environment variables.
 load_dotenv()
 
 # --- 1. API KEY CHECK ---
-# This will make the app fail early if the key isn't set
+# This block ensures that the necessary API keys are set before the application starts.
+# This makes the app "fail early" if a critical dependency is missing.
 try:
     openai_api_key = os.environ["OPENAI_API_KEY"]
 except KeyError:
+    # If the key is not found, an error is raised, prompting the user to set it up.
     raise EnvironmentError("Missing OPENAI_API_KEY. Please set it in a .env file locally, or in Hugging Face Space secrets.")
 
+# Perplexity AI API Key Check
+perplexity_api_key = None # Initialize to None
+try:
+    perplexity_api_key = os.environ["PERPLEXITY_API_KEY"]
+except KeyError:
+    print("Warning: PERPLEXITY_API_KEY not found. Perplexity AI web search will not function. Please add it to your .env file or Hugging Face Space secrets for live web search.")
+
+
 # --- 2. PYDANTIC DATA STRUCTURE DEFINITION ---
-# Defines the JSON structure we want the LLM to output
 class TravelRequest(BaseModel):
     departure_city: str = Field(description="The city or airport of departure. Infer if not specified.")
     destination_city: str = Field(description="The city or airport of the travel destination.")
@@ -38,110 +49,190 @@ class TravelRequest(BaseModel):
     number_of_travelers: int = Field(description="Number of adults traveling. Default to 1 if not specified.")
     activity_interests: str = Field(description="Specific interests for activities (e.g., 'museums', 'hiking').")
 
-# --- 3. CONCEPTUAL ASYNC SEARCH FUNCTIONS ---
-# You will implement the real logic for each of these. For now, they simulate a delay.
+# --- 3. ASYNC SEARCH FUNCTIONS (Some Simulated, Some Live) ---
+# All these functions are designed to return a LIST of dictionaries,
+# even if only one dictionary is returned. This is crucial for `all_results.extend()`.
+
 async def search_skyscanner(details):
-    # Simulate network delay and return mock data for a flight
+    """Simulates searching for flights on Skyscanner."""
     print(f"Searching Skyscanner for: {details['destination_city']}")
-    await asyncio.sleep(2)
+    await asyncio.sleep(2) # Simulate network delay
     return [{"source": "Skyscanner", "type": "flight", "details": "Flight to Paris", "price": 850.00, "link": "https://www.skyscanner.com"}]
 
 async def search_expedia(details):
-    # Simulate network delay and return mock data for a hotel
+    """Simulates searching for hotels on Expedia."""
     print(f"Searching Expedia for: {details['destination_city']}")
-    await asyncio.sleep(1.5)
+    await asyncio.sleep(1.5) # Simulate network delay
     return [{"source": "Expedia", "type": "hotel", "details": "Hotel in Paris", "price": 150.00, "link": "https://www.expedia.com"}]
 
 async def scrape_Google_Flights(details):
-    # Simulate network delay and return mock data for a scraped flight
+    """Simulates scraping flight data from Google Flights."""
     print(f"Scraping Google Flights for: {details['destination_city']}")
-    await asyncio.sleep(3)
+    await asyncio.sleep(3) # Simulate network delay
     return [{"source": "Google Flights (Scraped)", "type": "flight", "details": "Cheaper Flight to Paris", "price": 814.00, "link": "https://www.google.com/flights"}]
 
 async def search_get_your_guide(details):
-    # Simulate network delay and return mock data for an activity
+    """Simulates searching for activities on GetYourGuide."""
     print(f"Searching GetYourGuide for: {details['activity_interests']}")
-    await asyncio.sleep(1)
+    await asyncio.sleep(1) # Simulate network delay
     return [{"source": "GetYourGuide", "type": "activity", "details": "Eiffel Tower Tour", "price": 50.00, "link": "https://www.getyourguide.com"}]
 
+async def scrape_flight_vouchers(details):
+    """
+    This function currently simulates searching for flight vouchers and promo codes.
+    You will implement real web crawling logic here using Playwright later.
+    """
+    print(f"Searching for flight vouchers related to: {details.get('destination_city', 'general travel')}")
+    await asyncio.sleep(4) # Simulate a longer crawl time due to web scraping complexity
+    return [{
+        "source": "VoucherSiteExample",
+        "type": "voucher",
+        "details": "20% off selected Summer Flights!",
+        "price": "N/A", # Vouchers typically don't have a direct price, but a discount amount/code
+        "link": "https://www.example-vouchers.com/summer-deal"
+    },
+    {
+        "source": "AirlineDeals",
+        "type": "voucher",
+        "details": "Flat $50 off on flights to Europe with code EUROFLY",
+        "price": "N/A",
+        "link": "https://www.airline-deals.com/europe-promo"
+    }]
+
+async def search_perplexity_web(details):
+    """
+    Performs a live web search using Perplexity AI API based on the user's travel request.
+    This demonstrates fetching real-time general information from the web.
+    """
+    if not perplexity_api_key:
+        return [] # Return an empty list if API key is not set.
+
+    search_query = (
+        f"Best travel tips for {details.get('destination_city', 'general travel')}. "
+        f"Budget: {details.get('budget_preference', 'any')}. "
+        f"Travel dates: {details.get('departure_date', 'any')} to {details.get('return_date', 'any')}. "
+        f"Interests: {details.get('activity_interests', 'any activities')}."
+    )
+
+    url = "https://api.perplexity.ai/chat/completions" # Perplexity AI's chat completions endpoint for web search
+    headers = {
+        "Authorization": f"Bearer {perplexity_api_key}",
+        "Content-Type": "application/json"
+    }
+    payload = {
+        "model": "llama-3-sonar-small-32k-online",
+        "messages": [
+            {"role": "system", "content": "You are a helpful assistant that performs web searches and provides concise, travel-related summaries or tips."},
+            {"role": "user", "content": search_query}
+        ],
+        "temperature": 0.2,
+        "max_tokens": 500
+    }
+
+    print(f"Searching Perplexity AI for: '{search_query}'")
+    try:
+        response = await asyncio.to_thread(requests.post, url, headers=headers, json=payload, timeout=20)
+        response.raise_for_status()
+        data = response.json()
+
+        if data and data.get("choices") and data["choices"][0].get("message"):
+            content = data["choices"][0]["message"]["content"]
+            # Corrected to always return a list of dictionaries.
+            return [{
+                "source": "Perplexity AI Web Search",
+                "type": "insight",
+                "details": content,
+                "link": "https://www.perplexity.ai/"
+            }]
+        else:
+            print("Perplexity AI response was empty or malformed.")
+            return [] # Returns an empty list
+    except requests.exceptions.Timeout:
+        print("Perplexity AI request timed out after 20 seconds.")
+        # Corrected to always return a list of dictionaries.
+        return [{"source": "Perplexity AI Web Search", "type": "insight", "details": "Web search timed out. Please try again.", "link": "https://www.perplexity.ai/"}]
+    except requests.exceptions.RequestException as e:
+        print(f"Error calling Perplexity AI: {e}")
+        # Corrected to always return a list of dictionaries.
+        return [{"source": "Perplexity AI Web Search", "type": "insight", "details": f"Failed to get web insights: {e}", "link": "https://www.perplexity.ai/"}]
+
+
 async def search_llm_redundancy(details, llm, llm_name):
-    # Query another LLM for additional, general travel ideas
+    """
+    Queries another LLM for additional, general travel ideas or insights.
+    This function was the main cause of the TypeError, now fixed to return a list.
+    """
     print(f"Querying {llm_name} for additional ideas...")
     prompt = f"""As a helpful travel assistant, provide some brief travel suggestions for a trip based on these details: {details}.
     Focus on general tips, hidden gems, or activity ideas. Do not suggest specific prices or flights."""
     messages = [SystemMessage(content=prompt), HumanMessage(content="What are your suggestions?")]
     response = await llm.ainvoke(messages)
-    return {"source": llm_name, "type": "insight", "details": response.content}
+    # FIX: Ensure this always returns a list of dictionaries, even if it's just one item.
+    return [{"source": llm_name, "type": "insight", "details": response.content}]
 
-# --- 4. MAIN BOT LOGIC ---
+# --- 4. MAIN BOT LOGIC (ask_bot function) ---
 async def ask_bot(question):
     """
     This is the main ASYNCHRONOUS function for the bot.
-    It orchestrates the extraction, search, and output formatting.
+    It orchestrates the extraction of user intent, concurrent searching,
+    data processing, and final output formatting.
     """
-    # Part 1: Extract structured data from user request using an LLM
+    # Part 1: Extract structured data from the user's natural language request using an LLM.
     try:
-        # Initialize the LLM for extraction (GPT-4o for precise JSON output)
         llm_extractor = ChatOpenAI(model="gpt-4o", temperature=0)
-        # Define the parser for the Pydantic data model
         parser = JsonOutputParser(pydantic_object=TravelRequest)
-        # Create the prompt template for extraction, including format instructions
         extraction_prompt = ChatPromptTemplate.from_messages([
             ("system", "You are a helpful travel assistant. Your goal is to accurately extract travel details from a user's natural language request and output them as a JSON object, following the specified schema. Be precise and infer intelligently. The current date is {current_date}."),
             ("human", "Extract travel details from this request:\n\n{format_instructions}\n\nUser request: {request}"),
         ]).partial(format_instructions=parser.get_format_instructions())
-        # Create the LangChain expression language chain
         extraction_chain = extraction_prompt | llm_extractor | parser
-        # Get the current date to help the LLM with date parsing
         current_date_str = datetime.date.today().strftime("%Y-%m-%d")
-        # Invoke the chain to get the structured request
         structured_request = await extraction_chain.ainvoke({"request": question, "current_date": current_date_str})
     except Exception as e:
-        # Handle errors during the extraction phase
         return f"Error extracting request details: {e}. Please try rephrasing your request."
 
-    # Part 2: Gather all search tasks to run concurrently
-    # Initialize LLM instances for redundancy search (e.g., creative suggestions)
+    # Part 2: Gather all search tasks to run concurrently.
     llm_openai_creative = ChatOpenAI(model="gpt-4o", temperature=0.7)
-    # To enable Gemini redundancy, uncomment the line below and ensure GOOGLE_API_KEY is set in your .env
+    # Uncomment the line below and ensure GOOGLE_API_KEY is set in your .env for Gemini redundancy.
     # llm_gemini_search = ChatGoogleGenerativeAI(model="gemini-1.5-flash", temperature=0.7)
 
+    # Compile all the asynchronous search functions into a list of tasks.
     tasks = [
-        search_skyscanner(structured_request),          # Flight search
-        search_expedia(structured_request),             # Hotel search
-        scrape_Google_Flights(structured_request),      # Another flight source (simulated scraping)
-        search_get_your_guide(structured_request),      # Activities search
-        search_llm_redundancy(structured_request, llm_openai_creative, "ChatGPT (Creative)"), # AI insights
+        search_skyscanner(structured_request),          # Flight search task (simulated)
+        search_expedia(structured_request),             # Hotel search task (simulated)
+        scrape_Google_Flights(structured_request),      # Another flight source task (simulated scraping)
+        search_get_your_guide(structured_request),      # Activities search task (simulated)
+        scrape_flight_vouchers(structured_request),     # Flight voucher search task (simulated)
+        search_llm_redundancy(structured_request, llm_openai_creative, "ChatGPT (Creative)"), # AI insights from OpenAI (LIVE)
+        search_perplexity_web(structured_request)       # Live Web Search from Perplexity AI (LIVE if key set)
         # search_llm_redundancy(structured_request, llm_gemini_search, "Gemini"), # Uncomment for Gemini insights
     ]
 
-    # Part 3: Run all tasks concurrently and collect results
+    # Part 3: Run all tasks concurrently and collect their results.
     results = await asyncio.gather(*tasks, return_exceptions=True)
 
-    # Part 4: Normalize, filter, and rank results
+    # Part 4: Normalize, filter, and rank the collected results.
     all_results = []
     for res in results:
         if isinstance(res, Exception):
-            # Log any exceptions from the concurrent tasks
             print(f"A search task failed: {res}")
-        elif res:
-            # Extend the combined results list if the task was successful
-            all_results.extend(res)
+        elif res: # This 'elif res' checks if res is not None and not empty.
+            all_results.extend(res) # res must be an iterable (like a list)
 
-    # Separate and sort results by type (e.g., flights by price)
     flights = sorted([r for r in all_results if r['type'] == 'flight'], key=lambda x: x['price'])
     hotels = sorted([r for r in all_results if r['type'] == 'hotel'], key=lambda x: x['price'])
     activities = [r for r in all_results if r['type'] == 'activity']
     insights = [r for r in all_results if r['type'] == 'insight']
+    vouchers = [r for r in all_results if r['type'] == 'voucher']
 
-    # Part 5: Generate the final formatted output in Markdown
+    # Part 5: Generate the final formatted output in Markdown.
     dest_city = structured_request['destination_city']
     output_text = f"## ✨ Your Personalized Travel Plan to {dest_city}! ✨\n\n"
 
     # Format Flights section
     output_text += f"### ✈️ Top Flights\n"
     if flights:
-        for flight in flights[:3]: # Display top 3 flights
+        for flight in flights[:3]:
             output_text += f"* **{flight['details']}** from **{flight['source']}**\n"
             output_text += f"  * Price: **C${flight['price']:,.2f}**\n"
             output_text += f"  * 🔗 [**View Deal**]({flight['link']})\n"
@@ -152,7 +243,7 @@ async def ask_bot(question):
     # Format Hotels section
     output_text += f"### 🏨 Top Accommodations\n"
     if hotels:
-        for hotel in hotels[:2]: # Display top 2 hotels
+        for hotel in hotels[:2]:
             output_text += f"* **{hotel['details']}** from **{hotel['source']}**\n"
             output_text += f"  * Price: **C${hotel['price']:,.2f}** / night\n"
             output_text += f"  * 🔗 [**View Deal**]({hotel['link']})\n"
@@ -163,7 +254,7 @@ async def ask_bot(question):
     # Format Activities section
     output_text += f"### 🎉 Fun Activities\n"
     if activities:
-        for activity in activities[:2]: # Display top 2 activities
+        for activity in activities[:2]:
             output_text += f"* **{activity['details']}** from **{activity['source']}**\n"
             output_text += f"  * Price: **C${activity['price']:,.2f}**\n"
             output_text += f"  * 🔗 [**View Activity**]({activity['link']})\n"
@@ -171,7 +262,17 @@ async def ask_bot(question):
         output_text += "_No specific activities found, but there's always something to explore!_\n"
     output_text += "\n"
 
-    # Format AI Insights section (from redundant LLMs)
+    # Format Flight Vouchers & Deals section
+    output_text += f"### 💰 Flight Vouchers & Deals\n"
+    if vouchers:
+        for voucher in vouchers[:2]:
+            output_text += f"* **{voucher['details']}** from **{voucher['source']}**\n"
+            output_text += f"  * 🔗 [**Claim Deal!**]({voucher['link']})\n"
+    else:
+        output_text += "_No specific flight vouchers or codes found at this time._\n"
+    output_text += "\n"
+
+    # Format AI Insights section (from redundant LLMs, now including Perplexity AI)
     output_text += "### 💡 Additional AI Insights (for Redundancy)\n"
     if insights:
         for insight in insights:
@@ -180,15 +281,12 @@ async def ask_bot(question):
         output_text += "_No additional AI insights available._\n"
     output_text += "\n"
 
-    # Add a disclaimer
     output_text += "> **Disclaimer:** Prices and availability change rapidly. Click the links for the most up-to-date information. Happy travels! 🚀"
 
     return output_text
 
 # --- 5. DEFINE THE GRADIO INTERFACE ---
-# Using gr.Blocks for a more customizable layout compared to gr.Interface
 with gr.Blocks(theme=gr.themes.Soft()) as iface:
-    # Main title for the application
     gr.Markdown(
         """
         # ✨ The Ultimate Global Travel Planner Bot ✨
@@ -196,29 +294,23 @@ with gr.Blocks(theme=gr.themes.Soft()) as iface:
         """
     )
     with gr.Row():
-        # User input text box with more lines and a guiding placeholder
         user_input = gr.Textbox(lines=5, label="✈️ Tell me about your dream trip!", placeholder="e.g., I wanna go to Paris from Halifax, maybe around August for a week or so. Cheap as possible, no crazy layovers!")
     with gr.Row():
-        # Submit button to trigger the bot's logic
         submit_button = gr.Button("Find My Trip!", variant="primary")
     with gr.Row():
-        # Area to display the Markdown formatted output
         output_display = gr.Markdown(label="🌟 Your Travel Plan:")
     
-    # Examples to help users understand how to phrase their requests
     gr.Examples(
         examples=[
             ["I need a cheap flight from Toronto to London around July for 5 days."],
             ["Looking for a beach resort in Mexico for 2 people in December, not too expensive."],
             ["Find me some cool things to do in Tokyo in spring."]
         ],
-        inputs=user_input # Connect examples to the user input box
+        inputs=user_input
     )
     
-    # Connect the submit button's click event to the ask_bot function
     submit_button.click(fn=ask_bot, inputs=user_input, outputs=output_display)
 
 # --- 6. LAUNCH THE APP ---
-# This block ensures the Gradio app runs when the script is executed
 if __name__ == "__main__":
     iface.launch()