Create app.py

app.py

@@ -0,0 +1,541 @@
+import sys
+import logging
+import gradio as gr
+import faiss
+import numpy as np
+import pandas as pd
+import requests
+from geopy.geocoders import Nominatim
+from sentence_transformers import SentenceTransformer
+from typing import Tuple, Optional
+import os
+from huggingface_hub import hf_hub_download
+import geonamescache
+
+logging.basicConfig(level=logging.INFO)
+
+from huggingface_hub import login
+
+token = os.getenv('HF_TOKEN')
+
+df_path = hf_hub_download(
+    repo_id='MrSimple07/raggg',
+    filename='17_rag_data.csv',
+    repo_type='dataset',
+    token = token
+)
+embeddings_path = hf_hub_download(
+    repo_id='MrSimple07/raggg',
+    filename='rag_embeddings_3.npy',
+    repo_type='dataset',
+    token = token
+)
+
+df = pd.read_csv(df_path)
+embeddings = np.load(embeddings_path, mmap_mode='r')
+
+
+MISTRAL_API_KEY = "TeX7Cs30zMCAi0A90w4pGhPbOGrYzQkj"
+MISTRAL_API_URL = "https://api.mistral.ai/v1/chat/completions"
+
+category_synonyms = {
+    "museum": [
+        "museums", "art galleries", "natural museums", "modern art museums"
+    ],
+    "cafe": [
+        "coffee shops", ""
+    ],
+    "restaurant": [
+        "local dining spots", "fine dining", "casual eateries",
+        "family-friendly restaurants", "street food places"
+    ],
+    "parks": [
+        "national parks", "urban green spaces", "botanical gardens",
+        "recreational parks", "wildlife reserves"
+    ],
+        "park": [
+        "national parks", "urban green spaces", "botanical gardens",
+        "recreational parks", "wildlife reserves"
+    ],
+    "spa": ['bath', 'swimming', 'pool']
+}
+
+def extract_location_geonames(query: str) -> dict:
+    gc = geonamescache.GeonamesCache()
+    countries = {c['name'].lower(): c['name'] for c in gc.get_countries().values()}
+    cities = {c['name'].lower(): c['name'] for c in gc.get_cities().values()}
+
+    words = query.split()
+
+    for i in range(len(words)):
+        for j in range(i+1, len(words)+1):
+            potential_location = ' '.join(words[i:j]).lower()
+
+            # Check if it's a city first
+            if potential_location in cities:
+                return {
+                    'city': cities[potential_location],
+                }
+
+            # Then check if it's a country
+            if potential_location in countries:
+                return {
+                    'city': ' '.join(words[:i] + words[j:]) if i+j < len(words) else None,
+                    'country': countries[potential_location]
+                }
+
+    return {'city': query}
+
+
+
+def expand_category_once(query, target_category):
+    """
+    Expand the target category term in absthe query only once with synonyms and related phrases.
+    """
+    target_lower = target_category.lower()
+    if target_lower in query.lower():
+        synonyms = category_synonyms.get(target_lower, [])
+        if synonyms:
+            expanded_term = f"{target_category} ({', '.join(synonyms)})"
+            query = query.replace(target_category, expanded_term, 1)  # Replace only the first occurrence
+    return query
+
+CATEGORY_FILTER_WORDS = [
+    'museum', 'art', 'gallery', 'tourism', 'historical',
+    'bar', 'cafe', 'restaurant', 'park', 'landmark',
+    'beach', 'mountain', 'theater', 'church', 'monument',
+    'garden', 'library', 'university', 'shopping', 'market',
+    'hotel', 'resort', 'cultural', 'natural', 'science',
+    'educational', 'entertainment', 'sports', 'memorial', 'historic',
+    'spa', 'landmarks', 'sleep', 'coffee shops', 'shops', 'buildings',
+    'gothic', 'castle', 'fortress', 'aquarium', 'zoo', 'wildlife',
+    'adventure', 'hiking', 'lighthouse', 'vineyard', 'brewery',
+    'winery', 'pub', 'nightclub', 'observatory', 'theme park',
+    'botanical', 'sanctuary', 'heritage', 'island', 'waterfall',
+    'canyon', 'valley', 'desert', 'artisans', 'crafts', 'music hall',
+    'dance clubs', 'opera house', 'skyscraper', 'bridge', 'fountain',
+    'temple', 'shrine', 'archaeological', 'planetarium', 'marketplace',
+    'street art', 'local cuisine', 'eco-tourism', 'carnival', 'festival', 'film'
+]
+
+
+def extract_category_from_query(query: str) -> Optional[str]:
+    query_lower = query.lower()
+    for word in CATEGORY_FILTER_WORDS:
+        if word in query_lower:
+            return word
+
+    return None
+
+def get_location_details(min_lat, max_lat, min_lon, max_lon):
+    """Get detailed location information for a bounding box with improved city detection and error handling"""
+    geolocator = Nominatim(user_agent="location_finder", timeout=10)
+
+    try:
+        # Strategy 1: Try multiple points within the bounding box
+        sample_points = [
+            ((float(min_lat) + float(max_lat)) / 2,
+             (float(min_lon) + float(max_lon)) / 2),
+            (float(min_lat), float(min_lon)),
+            (float(max_lat), float(min_lon)),
+            (float(min_lat), float(max_lon)),
+            (float(max_lat), float(max_lon))
+        ]
+
+        # Collect unique cities from all points
+        cities = set()
+        full_addresses = []
+
+        for lat, lon in sample_points:
+            try:
+                # Add multiple retry attempts with exponential backoff
+                for attempt in range(3):
+                    try:
+                        location = geolocator.reverse(f"{lat}, {lon}", language='en')
+                        break
+                    except Exception as retry_error:
+                        if attempt == 2:  # Last attempt
+                            print(f"Failed to retrieve location for {lat}, {lon} after 3 attempts")
+                            continue
+                        time.sleep(2 ** attempt)  # Exponential backoff
+
+                if location:
+                    address = location.raw.get('address', {})
+
+                    # Extract city with multiple fallback options
+                    city = (
+                        address.get('city') or
+                        address.get('town') or
+                        address.get('municipality') or
+                        address.get('county') or
+                        address.get('state')
+                    )
+
+                    if city:
+                        cities.add(city)
+                        full_addresses.append(location.address)
+
+            except Exception as point_error:
+                print(f"Error processing point {lat}, {lon}: {point_error}")
+                continue
+
+        # If no cities found, try alternative geocoding service or return default
+        if not cities:
+            print("No cities detected. Returning default location information.")
+            return {
+                'location_parts': [],
+                'full_address_parts': '',
+                'full_address': '',
+                'city': [],
+                'state': '',
+                'country': '',
+                'cities_or_query': ''
+            }
+
+        # Prioritize cities, keeping all detected cities
+        city_list = list(cities)
+
+        # Use the last processed address for state and country
+        state = address.get('state', '')
+        country = address.get('country', '')
+
+        # Create a formatted list of cities for query
+        cities_or_query = " or ".join(city_list)
+
+        location_parts = [part for part in [cities_or_query, state, country] if part]
+        full_address_parts = ', '.join(location_parts)
+
+        print(f"Detected Cities: {cities}")
+        print(f"Cities for Query: {cities_or_query}")
+        print(f"Full Address Parts: {full_address_parts}")
+
+        return {
+            'location_parts': city_list,
+            'full_address_parts': full_address_parts,
+            'full_address': full_addresses[0] if full_addresses else '',
+            'city': city_list,
+            'state': state,
+            'country': country,
+            'cities_or_query': cities_or_query
+        }
+
+    except Exception as e:
+        print(f"Comprehensive error in location details retrieval: {e}")
+        import traceback
+        traceback.print_exc()
+
+    return None
+
+def rag_query(
+    query: str,
+    df: pd.DataFrame,
+    model: SentenceTransformer,
+    precomputed_embeddings: np.ndarray,
+    index: faiss.IndexFlatL2,
+    min_lat: str = None,
+    max_lat: str = None,
+    min_lon: str = None,
+    max_lon: str = None,
+    category: str = None,
+    city: str = None,
+) -> Tuple[str, str]:
+    """Enhanced RAG function with prioritized location extraction"""
+    print("\n=== Starting RAG Query ===")
+    print(f"Initial DataFrame size: {len(df)}")
+
+    # Prioritized location extraction
+    location_info = None
+    location_names = []
+
+    # Priority 1: Explicitly provided city name
+    if city:
+        location_names = [city]
+        print(f"Using explicitly provided city: {city}")
+
+    # Priority 2: Coordinates (Nominatim)
+    elif all(coord is not None and coord != "" for coord in [min_lat, max_lat, min_lon, max_lon]):
+        try:
+            location_info = get_location_details(
+                float(min_lat),
+                float(max_lat),
+                float(min_lon),
+                float(max_lon)
+            )
+
+            # Extract location names from Nominatim result
+            if location_info:
+                if location_info.get('city'):
+                    location_names.extend(location_info['city'] if isinstance(location_info['city'], list) else [location_info['city']])
+                if location_info.get('state'):
+                    location_names.append(location_info['state'])
+                if location_info.get('country'):
+                    location_names.append(location_info['country'])
+
+            print(f"Using coordinates-based location: {location_names}")
+        except Exception as e:
+            print(f"Location details error: {e}")
+
+    # Priority 3: Extract from query using GeoNames only if no previous methods worked
+    if not location_names:
+        geonames_info = extract_location_geonames(query)
+        if geonames_info.get('city'):
+            location_names = [geonames_info['city']]
+            print(f"Using GeoNames-extracted city: {location_names}")
+
+    # Start with a copy of the original DataFrame
+    filtered_df = df.copy()
+
+    # Filter DataFrame by location names
+    if location_names:
+        # Create a case-insensitive filter
+        location_filter = (
+            filtered_df['city'].str.lower().isin([name.lower() for name in location_names]) |
+            filtered_df['city'].apply(lambda x: any(name.lower() in str(x).lower() for name in location_names)) |
+            filtered_df['combined_field'].apply(lambda x: any(name.lower() in str(x).lower() for name in location_names))
+        )
+
+        filtered_df = filtered_df[location_filter]
+
+        print(f"Location Names Used for Filtering: {location_names}")
+        print(f"Results after location filtering: {len(filtered_df)}")
+
+
+
+    enhanced_query_parts = []
+    if query:
+        enhanced_query_parts.append(query)
+    if category:
+        enhanced_query_parts.append(f"{category} category")
+    if city:
+        enhanced_query_parts.append(f" in {city}")
+
+    if min_lat is not None and max_lat is not None and min_lon is not None and max_lon is not None:
+        enhanced_query_parts.append(f"within latitudes {min_lat} to {max_lat} and longitudes {min_lon} to {max_lon}")
+
+    # Add location context
+    if location_info:
+        location_context = " ".join(filter(None, [
+            ", ".join(location_info.get('city', [])),
+            location_info.get('state', ''),
+            # location_info.get('country', '')
+        ]))
+        if location_context:
+            enhanced_query_parts.append(f"in {location_context}")
+
+
+
+    enhanced_query = " ".join(enhanced_query_parts)
+
+    if enhanced_query:
+        enhanced_query = expand_category_once(enhanced_query, category)
+        print(f"Filtered by city '{city}': {len(filtered_df)} results")
+
+    print(f"Enhanced Query: {enhanced_query}")
+
+    detected_category = extract_category_from_query(enhanced_query)
+    if detected_category:
+        category_filter = (
+            filtered_df['category'].str.contains(detected_category, case=False, na=False) |
+            filtered_df['combined_field'].str.contains(detected_category, case=False, na=False)
+        )
+        filtered_df = filtered_df[category_filter]
+
+        print(f"Filtered by query words '{detected_category}': {len(filtered_df)} results")
+
+
+    try:
+        query_vector = model.encode([enhanced_query])[0]
+
+        # Compute embeddings for the filtered DataFrame
+        filtered_embeddings = precomputed_embeddings[filtered_df.index]
+
+        # Create FAISS index with filtered embeddings
+        filtered_index = faiss.IndexFlatL2(filtered_embeddings.shape[1])
+        filtered_index.add(filtered_embeddings.astype(np.float32))
+
+        # Perform semantic search on filtered results
+        k = min(20, len(filtered_df))
+        distances, local_indices = filtered_index.search(
+            np.array([query_vector]).astype(np.float32),
+            k
+        )
+
+        # Get the top results
+        results_df = filtered_df.iloc[local_indices[0]]
+
+        # Format results
+        formatted_results = []
+        for i, (_, row) in enumerate(results_df.iterrows(), 1):
+            formatted_results.append(
+                f"\n=== Result {i} ===\n"
+                f"Name: {row['name']}\n"
+                f"Category: {row['category']}\n"
+                f"City: {row['city']}\n"
+                f"Address: {row['address']}\n"
+                f"Description: {row['description']}\n"
+                f"Latitude: {row['latitude']}\n"
+                f"Longitude: {row['longitude']}\n"
+            )
+
+        search_results = "\n".join(formatted_results) if formatted_results else "No matching locations found."
+
+        # Optional: Use Mistral for further refinement
+        try:
+            answer = query_mistral(enhanced_query, search_results)
+        except Exception as e:
+            print(f"Error in Mistral query: {e}")
+            answer = "Unable to generate additional insights."
+
+        return search_results, answer
+
+    except Exception as e:
+        print(f"Error in semantic search: {e}")
+        return f"Error performing search: {str(e)}", ""
+
+
+def query_mistral(prompt: str, context: str, max_retries: int = 3) -> str:
+    """
+    Robust Mistral verification with exponential backoff
+    """
+    import time
+
+    # Early return if no context
+    if not context or context.strip() == "No matching locations found.":
+        return context
+
+    verification_prompt = f"""Precise Location Curation Task:
+REQUIREMENTS:
+- Source Query: {prompt}
+- Current Context: {context}
+DETAILED INSTRUCTIONS:
+1. Write the min, max latitude and min, max longitude in the beginning taking from the query
+2. Curate a comprehensive list of 15 locations inside of these coordinates and strictly relevant to place.
+3. Take STRICTLY ONLY relevant places to Source Query.
+4. Add a short description about the place (2-3 sentences)
+5. Add coordinates (lat and long) if there are in the Current Context.
+6. If no coordinates in the Current Context, then give only name and description
+7. Add address for the place
+8. Remove any duplicate entries in the list
+9. If places > 10, quick generation a new places relevant to Source Query and inside of the coordinates
+CRITICAL: Do NOT use placeholder. Quick and fast response required
+"""
+
+    for attempt in range(max_retries):
+        try:
+            # Robust API configuration
+            response = requests.post(
+                MISTRAL_API_URL,
+                headers={
+                    "Authorization": f"Bearer {MISTRAL_API_KEY}",
+                    "Content-Type": "application/json"
+                },
+                json={
+                    "model": "mistral-large-latest",
+                    "messages": [
+                        {"role": "system", "content": "You are a precise location curator specializing in comprehensive travel information."},
+                        {"role": "user", "content": verification_prompt}
+                    ],
+                    "temperature": 0.1,
+                    "max_tokens": 5000
+                },
+                timeout=100  # Increased timeout
+            )
+
+            # Enhanced error handling
+            response.raise_for_status()
+
+            # Extract verified response
+            verified_response = response.json()['choices'][0]['message']['content']
+
+            # Validate response length and complexity
+            if len(verified_response.strip()) < 100:
+                if attempt == max_retries - 1:
+                    return context
+                time.sleep(2 ** attempt)  # Exponential backoff
+                continue
+
+            return verified_response
+
+        except requests.Timeout:
+            logging.warning(f"Mistral API timeout (Attempt {attempt + 1}/{max_retries})")
+            if attempt < max_retries - 1:
+                time.sleep(2 ** attempt)  # Exponential backoff
+            else:
+                logging.error("Mistral API consistently timing out")
+                return context
+
+        except requests.RequestException as e:
+            logging.error(f"Mistral API request error: {e}")
+            if attempt < max_retries - 1:
+                time.sleep(2 ** attempt)
+            else:
+                return context
+
+        except Exception as e:
+            logging.error(f"Unexpected error in Mistral verification: {e}")
+            if attempt < max_retries - 1:
+                time.sleep(2 ** attempt)
+            else:
+                return context
+
+    return context
+
+
+
+def create_interface(
+    df: pd.DataFrame,
+    model: SentenceTransformer,
+    precomputed_embeddings: np.ndarray,
+    index: faiss.IndexFlatL2
+):
+    """Create Gradio interface with 4 bounding box inputs"""
+    return gr.Interface(
+        fn=lambda q, min_lat, max_lat, min_lon, max_lon, city, cat: rag_query(
+            query=q,
+            df=df,
+            model=model,
+            precomputed_embeddings=precomputed_embeddings,
+            index=index,
+            min_lat=min_lat,
+            max_lat=max_lat,
+            min_lon=min_lon,
+            max_lon=max_lon,
+            city=city,
+            category=cat
+        )[1],
+        inputs=[
+            gr.Textbox(lines=2, label="Question"),
+            gr.Textbox(label="Min Latitude"),
+            gr.Textbox(label="Max Latitude"),
+            gr.Textbox(label="Min Longitude"),
+            gr.Textbox(label="Max Longitude"),
+            gr.Textbox(label="City"),
+            gr.Textbox(label="Category")
+        ],
+        outputs=[
+            gr.Textbox(label="Locations Found"),
+        ],
+        title="Tourist Information System with Bounding Box Search",
+        examples=[
+            ["Museums in area", "40.71", "40.86", "-74.0", "-74.1", "", "museum"],
+            ["Restaurants", "48.8575", "48.9", "2.3514", "2.4", "Paris", "restaurant"],
+            ["Coffee shops", "51.5", "51.6", "-0.2", "-0.1", "London", "cafe"],
+            ["Spa places", "", "", "", "", "Budapest", ""],
+            ["Lambic brewery", "50.84211068618749", "50.849274898691244","4.339536387173865", "4.361188801802462", "", ""],
+            ["Art nouveau architecture buildings", "44.42563381188614", "44.43347927669681","26.008709832230608", "26.181744493414488", "", ""],
+            ["Harry Potter filming locations", "51.52428877891333", "51.54738884423489", "-0.1955164690977472", "-0.05082973945560466", "", ""]
+
+        ]
+    )
+if __name__ == "__main__":
+    try:
+        model = SentenceTransformer('all-MiniLM-L6-v2')
+        precomputed_embeddings = embeddings
+        index = faiss.IndexFlatL2(precomputed_embeddings.shape[1])
+        index.add(precomputed_embeddings.astype(np.float32))
+
+        iface = create_interface(df, model, precomputed_embeddings, index)
+        iface.launch(share=True, debug=True)
+    except Exception as e:
+        logging.error(f"Startup error: {e}")
+        sys.exit(1)