Update app.py

app.py

@@ -2,49 +2,95 @@ import streamlit as st
 import requests
 from bs4 import BeautifulSoup
 from geopy.geocoders import Nominatim
+from urllib.parse import urljoin, urlparse
+import re
 import os
+import pandas as pd
 import folium
 from streamlit_folium import folium_static
+from jsonschema import validate, ValidationError
 
 # Configure environment
 DEEPSEEK_API_KEY = os.getenv("DEEPSEEK_KEY")
 API_ENDPOINT = "https://api.deepseek.com/v1/chat/completions"
 
-# Docker-compatible settings
-st.set_page_config(layout="wide", page_icon="🏡")
-geolocator = Nominatim(user_agent="docker_neighborhood_finder")
+# JSON Schema for API response validation
+RESPONSE_SCHEMA = {
+    "type": "object",
+    "required": ["choices"],
+    "properties": {
+        "choices": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+                "type": "object",
+                "required": ["message"],
+                "properties": {
+                    "message": {
+                        "type": "object",
+                        "required": ["content"],
+                        "properties": {
+                            "content": {"type": "string"}
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
 
-@st.cache_data(show_spinner=False)
+@st.cache_data
 def scrape_location_data(query):
-    """Scrape location data with Docker-friendly timeout"""
-    try:
-        response = requests.get(
-            f"https://www.niche.com/places-to-live/search/{query}",
-            timeout=10
-        )
-        soup = BeautifulSoup(response.text, 'html.parser')
-        return [
-            item.find('h2').text.strip()
-            for item in soup.find_all('div', class_='search-results__list__item')[:3]
-        ]
-    except Exception:
-        return []
+    """Scrape location data with enhanced error handling"""
+    sources = {
+        "Niche": f"https://www.niche.com/places-to-live/search/{query}",
+    }
+    
+    results = []
+    for source, url in sources.items():
+        try:
+            response = requests.get(url, timeout=15)
+            response.raise_for_status()
+            soup = BeautifulSoup(response.text, 'html.parser')
+            
+            if source == "Niche":
+                listings = soup.find_all('div', class_='search-results__list__item')
+                for item in listings[:3]:
+                    results.append({
+                        'name': item.find('h2').text.strip(),
+                        'details': item.find('div', class_='search-result-tagline').text.strip(),
+                        'score': item.find('div', class_='search-result-grade').text.strip()
+                    })
+                    
+        except Exception as e:
+            st.error(f"Scraping error for {source}: {str(e)}")
+            continue
+            
+    return results
 
 def generate_recommendations(preferences):
-    """Docker-optimized API call"""
+    """Generate recommendations with robust error handling"""
+    if not DEEPSEEK_API_KEY:
+        st.error("Missing API key - check environment configuration")
+        return None
+
     headers = {
         "Authorization": f"Bearer {DEEPSEEK_API_KEY}",
         "Content-Type": "application/json"
     }
     
     prompt = f"""
-    Analyze these preferences: {preferences}
-    Recommend neighborhoods with:
-    - Top 3 matches
-    - 1 hidden gem
-    - Key amenities
-    - Safety insights
-    Format with markdown bullet points
+    Create a neighborhood recommendation report based on these preferences:
+    {preferences}
+    
+    Include these sections:
+    1. Top 5 Neighborhood Matches
+    2. Hidden Gem Recommendation
+    3. Key Amenities Analysis
+    4. Commute Times Overview
+    5. Safety & Community Insights
+    
+    Format with markdown headers and bullet points.
     """
     
     try:
@@ -54,54 +100,73 @@ def generate_recommendations(preferences):
                 "model": "deepseek-chat",
                 "messages": [{"role": "user", "content": prompt}],
                 "temperature": 0.7,
-                "max_tokens": 1000
+                "max_tokens": 1500
             },
             headers=headers,
-            timeout=20  # Docker-friendly timeout
+            timeout=30
         )
-        return response.json()["choices"][0]["message"]["content"]
+        
+        # Validate response status
+        if response.status_code != 200:
+            error_msg = response.json().get('error', {}).get('message', 'Unknown API error')
+            st.error(f"API Error {response.status_code}: {error_msg}")
+            return None
+        
+        # Validate response structure
+        response_data = response.json()
+        validate(instance=response_data, schema=RESPONSE_SCHEMA)
+        
+        return response_data["choices"][0]["message"]["content"]
+        
+    except ValidationError as ve:
+        st.error(f"Invalid API response format: {str(ve)}")
+        return None
     except Exception as e:
-        st.error(f"API Error: {str(e)}")
+        st.error(f"Connection Error: {str(e)}")
         return None
 
 # Streamlit UI
-st.title("🏡 Neighborhood Finder (Docker)")
+st.set_page_config(layout="wide", page_icon="🏡")
+st.title("Neighborhood Matchmaker")
 
-with st.form("preferences"):
-    col1, col2 = st.columns(2)
-    with col1:
-        city = st.text_input("City/Region", "New York, NY")
-        budget = st.slider("Monthly Budget ($)", 1000, 10000, 3000)
-    with col2:
-        commute = st.selectbox("Max Commute", ["15m", "30m", "45m", "1h"])
-        lifestyle = st.selectbox("Lifestyle", ["Family", "Urban", "Remote"])
-    
-    if st.form_submit_button("Find Neighborhoods"):
-        with st.spinner("Searching..."):
-            # Get data
-            locations = scrape_location_data(city)
-            preferences = {
-                "city": city,
-                "budget": budget,
-                "commute": commute,
-                "lifestyle": lifestyle
-            }
-            
-            # Generate report
-            report = generate_recommendations(preferences)
+with st.sidebar:
+    st.header("Search Preferences")
+    city = st.text_input("City/Region", "New York, NY")
+    budget = st.slider("Monthly Housing Budget ($)", 1000, 10000, 3000)
+    commute = st.selectbox("Max Commute Time", ["15 mins", "30 mins", "45 mins", "1 hour"])
+    amenities = st.multiselect("Must-Have Amenities", [
+        "Good Schools", "Parks", "Public Transport", 
+        "Nightlife", "Shopping", "Healthcare"
+    ])
+    lifestyle = st.selectbox("Lifestyle Preference", [
+        "Family-Friendly", "Urban Professional", "Retirement", 
+        "Student", "Remote Worker", "Outdoor Enthusiast"
+    ])
+
+if st.button("Find My Neighborhood"):
+    with st.spinner("Analyzing locations..."):
+        preferences = {
+            "city": city,
+            "budget": f"${budget}/mo",
+            "max_commute": commute,
+            "amenities": amenities,
+            "lifestyle": lifestyle
+        }
+        
+        location_data = scrape_location_data(city)
+        report = generate_recommendations(preferences)
+        
+        if report:
+            st.subheader("Your Personalized Neighborhood Report")
+            st.markdown(report)
             
-            # Show results
-            if report:
-                st.markdown(report)
-                
-                # Docker-compatible map
-                try:
-                    location = geolocator.geocode(city)
-                    m = folium.Map(
-                        location=[location.latitude, location.longitude],
-                        zoom_start=12,
-                        tiles="CartoDB positron"
-                    )
-                    folium_static(m, width=1000, height=400)
-                except Exception:
-                    st.warning("Map unavailable - location not found")
+            try:
+                geolocator = Nominatim(user_agent="neighborhood_finder")
+                location = geolocator.geocode(city)
+                m = folium.Map(location=[location.latitude, location.longitude], zoom_start=12)
+                folium_static(m, width=1200, height=500)
+            except Exception as e:
+                st.warning(f"Map visualization error: {str(e)}")
+
+st.markdown("---")
+st.caption("Note: Recommendations generated by AI. Verify with local experts.")