app.py

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='15_rag_data.csv',
    repo_type='dataset',
    token = token
)
embeddings_path = hf_hub_download(
    repo_id='MrSimple07/raggg',
    filename='rag_embeddings.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)