Update app.py

app.py

@@ -14,7 +14,7 @@ from playwright.async_api import async_playwright
 # --- Langchain Imports ---
 from langchain_core.prompts import ChatPromptTemplate
 from langchain_core.output_parsers import JsonOutputParser
-from langchain_core.pydantic_v1 import BaseModel, Field
+from pydantic import BaseModel, Field
 from langchain_openai import ChatOpenAI
 from langchain_google_genai import ChatGoogleGenerativeAI
 from langchain_core.messages import SystemMessage, HumanMessage
@@ -23,34 +23,37 @@ from langchain_core.messages import SystemMessage, HumanMessage
 # On Hugging Face Spaces, secrets are automatically available as environment variables.
 load_dotenv()
 
-# --- Playwright Browser Installation Workaround for Hugging Face Spaces ---
-# This block ensures Playwright browsers are installed when the app starts.
-# Assumes system dependencies are handled by packages.txt during the build.
-PLAYWRIGHT_BROWSERS_PATH = os.path.expanduser("~/.cache/ms-playwright")
-PLAYWRIGHT_INSTALLED_FLAG = "PLAYWRIGHT_BROWSERS_INSTALLED"
-
-# Check if installation has been attempted during this container's lifetime
-if not os.path.exists(os.path.join(PLAYWRIGHT_BROWSERS_PATH, "chromium")) and \
-   os.environ.get(PLAYWRIGHT_INSTALLED_FLAG, "false") == "false":
-    print("Playwright browsers not found. Attempting to install them now (this might take a moment)...")
+# --- Improved Playwright Browser Installation for Hugging Face Spaces ---
+async def ensure_playwright_browsers():
+    """Ensures Playwright browsers are installed and available."""
     try:
-        # Run the playwright install command for the browsers themselves.
-        # This should now succeed if the system dependencies from packages.txt are met.
-        result = subprocess.run([sys.executable, "-m", "playwright", "install"], check=True, capture_output=True, text=True)
-        os.environ[PLAYWRIGHT_INSTALLED_FLAG] = "true" # Mark as installed for this session
-        print("Playwright browsers installed successfully!")
+        # First, install Playwright browsers
+        print("Installing Playwright browsers...")
+        result = subprocess.run([
+            sys.executable, "-m", "playwright", "install", "chromium"
+        ], check=True, capture_output=True, text=True)
+        
         if result.stdout:
             print("Playwright Install STDOUT:\n", result.stdout)
         if result.stderr:
             print("Playwright Install STDERR:\n", result.stderr)
             
+        print("Playwright browsers installed successfully!")
+        return True
+        
     except subprocess.CalledProcessError as e:
-        print(f"Error during Playwright browser installation: {e}. STDOUT: {e.stdout.decode()} STDERR: {e.stderr.decode()}")
+        print(f"Error during Playwright browser installation: {e}")
+        if e.stdout:
+            print("STDOUT:", e.stdout)
+        if e.stderr:
+            print("STDERR:", e.stderr)
+        return False
     except Exception as e:
         print(f"Unexpected error during Playwright browser installation: {e}")
-else:
-    print("Playwright browsers already appear to be installed or installation skipped.")
+        return False
 
+# Initialize browsers on startup
+browsers_ready = False
 
 # --- 1. API KEY CHECK ---
 # This block ensures that the necessary API keys are set before the application starts.
@@ -59,9 +62,6 @@ try:
 except KeyError:
     raise EnvironmentError("Missing OPENAI_API_KEY. Please set it in a .env file locally, or in Hugging Face Space secrets.")
 
-# Removed PERPLEXITY_API_KEY check as it's no longer used.
-
-
 # --- 2. PYDANTIC DATA STRUCTURE DEFINITION ---
 class TravelRequest(BaseModel):
     departure_city: str = Field(description="The city or airport of departure. Infer if not specified.")
@@ -76,9 +76,6 @@ class TravelRequest(BaseModel):
     activity_interests: str = Field(description="Specific interests for activities (e.g., 'museums', 'hiking').")
 
 # --- 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):
     """Simulates searching for flights on Skyscanner."""
     print(f"Searching Skyscanner for: {details['destination_city']}")
@@ -105,115 +102,107 @@ async def search_get_your_guide(details):
 
 async def scrape_flight_vouchers(details):
     """
-    Performs real web scraping for flight vouchers and promo codes using Playwright.
-    This function navigates to common deal sites and attempts to extract voucher information.
-    Note: Web scraping is highly dependent on website structure and may require frequent updates.
+    Performs web scraping for flight vouchers with better error handling for Hugging Face Spaces.
     """
-    print(f"Starting real web scraping for flight vouchers related to: {details.get('destination_city', 'general travel')}")
-    vouchers_found = []
+    global browsers_ready
+    
+    print(f"Starting web scraping for flight vouchers related to: {details.get('destination_city', 'general travel')}")
+    
+    # Check if browsers are ready, if not try to install them
+    if not browsers_ready:
+        browsers_ready = await ensure_playwright_browsers()
+    
+    if not browsers_ready:
+        return [{
+            "source": "Web Scraping (Disabled)",
+            "type": "voucher",
+            "details": "Web scraping is temporarily disabled due to browser installation issues. This is common on Hugging Face Spaces. The app will still work with simulated data.",
+            "price": "N/A",
+            "link": "#"
+        }]
     
-    # Define target websites. Removed Groupon due to persistent ERR_HTTP2_PROTOCOL_ERROR.
+    vouchers_found = []
     target_urls = [
         "https://www.retailmenot.com/coupons/flights",
     ]
 
-    browser = None # Initialize browser variable outside the try block
     try:
         async with async_playwright() as p:
-            # Launch a headless Chromium browser (runs in the background without a visual window).
-            browser = await p.chromium.launch(headless=True)
+            browser = await p.chromium.launch(
+                headless=True,
+                args=[
+                    '--no-sandbox',
+                    '--disable-setuid-sandbox',
+                    '--disable-dev-shm-usage',
+                    '--disable-accelerated-2d-canvas',
+                    '--no-first-run',
+                    '--no-zygote',
+                    '--disable-gpu',
+                    '--disable-web-security',
+                    '--disable-features=VizDisplayCompositor'
+                ]
+            )
             
-            # Add a human-like User-Agent to try and bypass basic bot detection.
             context = await browser.new_context(
-                user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+                user_agent="Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
             )
             page = await context.new_page()
 
             for url in target_urls:
                 try:
                     print(f"Navigating to: {url}")
-                    # Use 'domcontentloaded' or 'load' as 'networkidle' can sometimes wait indefinitely.
-                    await page.goto(url, wait_until='domcontentloaded', timeout=60000) 
-
-                    # --- Generic scraping strategy ---
-                    deals_locator = page.locator('div:has-text("coupon code"), div:has-text("promo code"), div:has-text("discount"), '
-                                                 'a[href*="deal"], a[href*="promo"], a[href*="discount"], '
-                                                 '[class*="deal"], [class*="promo"]')
+                    await page.goto(url, wait_until='domcontentloaded', timeout=30000)
                     
+                    # Simple scraping strategy
+                    deals_locator = page.locator('div:has-text("coupon"), div:has-text("promo"), div:has-text("discount")')
                     deals = await deals_locator.all()
 
-                    for i, deal_elem in enumerate(deals):
-                        if len(vouchers_found) >= 3: # Limit the number of vouchers found
-                            break
+                    for i, deal_elem in enumerate(deals[:3]):  # Limit to 3 deals
                         try:
                             text_content = await deal_elem.inner_text()
-                            link = await deal_elem.get_attribute('href') if await deal_elem.get_attribute('href') else url
-                            
-                            if len(text_content.strip()) > 20 and \
-                                ("flight" in text_content.lower() or \
-                                 "travel" in text_content.lower() or \
-                                 details.get('destination_city', '').lower() in text_content.lower()):
-                                
+                            if len(text_content.strip()) > 20:
                                 code_match = re.search(r'\b[A-Z0-9]{4,10}\b', text_content)
                                 code = code_match.group(0) if code_match else "N/A"
 
                                 vouchers_found.append({
                                     "source": f"Scraped from {url.split('/')[2]}",
                                     "type": "voucher",
-                                    "details": f"{text_content[:150]}..." if len(text_content) > 150 else text_content,
+                                    "details": f"{text_content[:100]}..." if len(text_content) > 100 else text_content,
                                     "price": f"Code: {code}",
-                                    "link": link
+                                    "link": url
                                 })
                         except Exception as e_deal:
-                            print(f"Error processing deal element on {url}: {e_deal}")
+                            print(f"Error processing deal element: {e_deal}")
                             continue
-                except Exception as e_url_nav: # Catching general Exception for Playwright errors
-                    print(f"Navigation error for {url}: {e_url_nav}")
-                    vouchers_found.append({
-                        "source": f"Scraper Error for {url.split('/')[2]}",
-                        "type": "voucher",
-                        "details": f"Could not retrieve vouchers from {url.split('/')[2]} due to navigation error. (Error: {e_url_nav})",
-                        "price": "N/A",
-                        "link": url
-                    })
+                            
+                except Exception as e_url:
+                    print(f"Navigation error for {url}: {e_url}")
                     continue
-    except Exception as e_browser_launch: # Catching general Exception for browser launch errors
-        print(f"Playwright browser launch error: {e_browser_launch}. Ensure `playwright install` was run and system dependencies are met.")
-        return [{
-            "source": "Scraper Initialization Error",
-            "type": "voucher",
-            "details": f"Failed to start web scraper: {e_browser_launch}. Please ensure Playwright browsers are installed locally and on Hugging Face.",
-            "price": "N/A",
-            "link": "#"
-        }]
-    except Exception as e_general:
-        print(f"An unexpected error occurred during scraping: {e_general}")
+                    
+            await browser.close()
+            
+    except Exception as e:
+        print(f"Playwright error: {e}")
         return [{
-            "source": "Scraper General Error",
+            "source": "Web Scraping (Error)",
             "type": "voucher",
-            "details": f"An unexpected error prevented voucher scraping: {e_general}",
+            "details": f"Web scraping encountered an error: {str(e)[:100]}... This is common on cloud platforms. Using simulated data instead.",
             "price": "N/A",
             "link": "#"
         }]
-    finally:
-        if browser:
-            await browser.close()
     
     if not vouchers_found:
-        print("No specific vouchers found during scraping.")
+        # Return some simulated voucher data as fallback
         return [{
-            "source": "Web Scraping",
+            "source": "Travel Deals (Simulated)",
             "type": "voucher",
-            "details": "No specific flight vouchers or codes were found matching your criteria on the browsed sites.",
-            "price": "N/A",
-            "link": "#"
+            "details": "Get 10% off your next flight booking with major airlines - check airline websites directly for current promotions",
+            "price": "Code: SAVE10",
+            "link": "https://www.google.com/flights"
         }]
+    
     return vouchers_found
 
-
-# search_perplexity_web function is removed
-
-
 async def search_llm_redundancy(details, llm, llm_name):
     """
     Queries another LLM for additional, general travel ideas or insights.
@@ -222,15 +211,18 @@ async def search_llm_redundancy(details, llm, llm_name):
     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}]
+    
+    try:
+        response = await llm.ainvoke(messages)
+        return [{"source": llm_name, "type": "insight", "details": response.content}]
+    except Exception as e:
+        print(f"Error querying {llm_name}: {e}")
+        return [{"source": f"{llm_name} (Error)", "type": "insight", "details": f"Unable to get insights from {llm_name} due to: {str(e)[:100]}"}]
 
 # --- 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 of user intent, concurrent searching,
-    data processing, and final output formatting.
     """
     # Part 1: Extract structured data from the user's natural language request using an LLM.
     try:
@@ -248,19 +240,15 @@ async def ask_bot(question):
 
     # Part 2: Gather all search tasks to run concurrently.
     llm_openai_creative = ChatOpenAI(model="gpt-4o", temperature=0.7)
-    # 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 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),     # NEW: Live Flight voucher search task (Playwright)
-        search_llm_redundancy(structured_request, llm_openai_creative, "ChatGPT (Creative)"), # AI insights from OpenAI (LIVE)
-        # search_perplexity_web(structured_request)       # Removed Perplexity AI task
-        # search_llm_redundancy(structured_request, llm_gemini_search, "Gemini"), # Uncomment for Gemini insights
+        search_skyscanner(structured_request),
+        search_expedia(structured_request),
+        scrape_Google_Flights(structured_request),
+        search_get_your_guide(structured_request),
+        scrape_flight_vouchers(structured_request),
+        search_llm_redundancy(structured_request, llm_openai_creative, "ChatGPT (Creative)"),
     ]
 
     # Part 3: Run all tasks concurrently and collect their results.
@@ -327,8 +315,8 @@ async def ask_bot(question):
         output_text += "_No specific flight vouchers or codes found at this time._\n"
     output_text += "\n"
 
-    # Format AI Insights section (from redundant LLMs)
-    output_text += "### 💡 Additional AI Insights (for Redundancy)\n"
+    # Format AI Insights section
+    output_text += "### 💡 Additional AI Insights\n"
     if insights:
         for insight in insights:
             output_text += f"* **{insight['source']} says:** {insight['details']}\n"
@@ -340,12 +328,17 @@ async def ask_bot(question):
 
     return output_text
 
+# Wrapper function to handle the async call
+def bot_wrapper(question):
+    """Synchronous wrapper for the async ask_bot function."""
+    return asyncio.run(ask_bot(question))
+
 # --- 5. DEFINE THE GRADIO INTERFACE ---
 with gr.Blocks(theme=gr.themes.Soft()) as iface:
     gr.Markdown(
         """
         # ✨ The Ultimate Global Travel Planner Bot - Bazinga Edition ✨
-        Your smart AI assistant for finding the best flights, hotels, and activities worldwide BAZINGA!
+        Your smart AI assistant for finding the best flights, hotels, and activities worldwide!
         """
     )
     with gr.Row():
@@ -364,8 +357,8 @@ with gr.Blocks(theme=gr.themes.Soft()) as iface:
         inputs=user_input
     )
     
-    submit_button.click(fn=ask_bot, inputs=user_input, outputs=output_display)
+    submit_button.click(fn=bot_wrapper, inputs=user_input, outputs=output_display)
 
 # --- 6. LAUNCH THE APP ---
 if __name__ == "__main__":
-    iface.launch()
+    iface.launch()