simple_api.py

from flask import Flask, request, jsonify
import weaviate
from geopy.geocoders import Nominatim
from geopy.exc import GeocoderTimedOut
import time
import math

# Import the setup_weaviate_client function
from simple_schema import setup_weaviate_client

app = Flask(__name__)
client = setup_weaviate_client()

def geocode_address(address, attempt=1, max_attempts=3):
    """Convert an address to geocoordinates using Nominatim."""
    # Initialize the geolocator
    geolocator = Nominatim(user_agent="hotel_finder")
    
    try:
        # Try to geocode the address
        location = geolocator.geocode(address)
        if location:
            return {
                "latitude": location.latitude,
                "longitude": location.longitude,
                "address": location.address
            }
        else:
            print(f"Could not geocode address: {address}")
            return None
    except GeocoderTimedOut:
        if attempt <= max_attempts:
            print(f"Timeout geocoding {address}. Attempt {attempt} of {max_attempts}")
            time.sleep(1)  # Wait for 1 second before retrying
            return geocode_address(address, attempt + 1, max_attempts)
        else:
            print(f"Failed to geocode {address} after {max_attempts} attempts")
            return None
    except Exception as e:
        print(f"Error geocoding {address}: {e}")
        return None

def haversine_distance(lat1, lon1, lat2, lon2):
    """Calculate the great circle distance between two points on earth (specified in decimal degrees)"""
    # Convert decimal degrees to radians
    lat1, lon1, lat2, lon2 = map(math.radians, [lat1, lon1, lat2, lon2])
    
    # Haversine formula
    dlon = lon2 - lon1
    dlat = lat2 - lat1
    a = math.sin(dlat/2)**2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon/2)**2
    c = 2 * math.asin(math.sqrt(a))
    r = 6371  # Radius of earth in kilometers
    return c * r

def find_nearest_hotels(client, lat, lon, limit=2):
    """Find the nearest hotels using Weaviate's nearVector search."""
    # Use nearObject to find hotels near the specified coordinates
    result = client.query.get(
        "Hotel", ["name", "address", "phoneNumber"]
    ).with_near_vector({
        "vector": client.query.get(
            "Hotel", ["name"]
        ).with_near_object({
            "className": "Hotel",
            "distance": 0.8,  # Adjust this threshold as needed
            "properties": [
                {"path": ["location"], "value": {
                    "latitude": lat, 
                    "longitude": lon
                }}
            ]
        }).do()['data']['Get']['Hotel'][0]['_additional']['vector'] if client.query.get(
            "Hotel", ["name"]
        ).with_near_object({
            "className": "Hotel",
            "distance": 0.8,
            "properties": [
                {"path": ["location"], "value": {
                    "latitude": lat, 
                    "longitude": lon
                }}
            ]
        }).do()['data']['Get']['Hotel'] else None
    }).with_limit(limit).do()
    
    if result and 'data' in result and 'Get' in result['data'] and 'Hotel' in result['data']['Get']:
        return result['data']['Get']['Hotel']
    
    # Fallback: If nearObject search doesn't work, get all hotels and calculate distances manually
    all_hotels = client.query.get(
        "Hotel", ["name", "address", "phoneNumber", "location"]
    ).do()
    
    if all_hotels and 'data' in all_hotels and 'Get' in all_hotels['data'] and 'Hotel' in all_hotels['data']['Get']:
        hotels = all_hotels['data']['Get']['Hotel']
        
        # Calculate distance for each hotel
        hotels_with_distance = []
        for hotel in hotels:
            if hotel.get("location"):
                hotel_lat = hotel["location"]["latitude"]
                hotel_lon = hotel["location"]["longitude"]
                distance = haversine_distance(lat, lon, hotel_lat, hotel_lon)
                hotel["distance"] = distance
                hotels_with_distance.append(hotel)
            
        # Sort by distance
        hotels_with_distance.sort(key=lambda x: x.get("distance", float('inf')))
        
        # Return the closest hotels
        return hotels_with_distance[:limit]
    
    return []

@app.route('/api/findhotels', methods=['POST'])
def find_hotels():
    data = request.json
    address = data.get('address', '')
    
    if not address:
        return jsonify({
            "message": "Address is required",
            "count": 0,
            "hotels": []
        })
    
    print(f"User address: {address}")
    
    # Geocode the address
    coordinates = geocode_address(address)
    if not coordinates:
        return jsonify({
            "message": "Could not geocode the provided address",
            "count": 0,
            "hotels": []
        })
    
    print(f"Geocoded to: {coordinates['latitude']}, {coordinates['longitude']}")
    
    # Find nearest hotels
    hotels = find_nearest_hotels(client, coordinates['latitude'], coordinates['longitude'], limit=2)
    
    # Prepare response
    response = {
        "message": f"Found {len(hotels)} nearby hotels.",
        "count": len(hotels),
        "address": coordinates.get("address", address),
        "hotels": hotels
    }
    
    if not hotels:
        response["message"] = "No hotels found near the provided address."
    
    return jsonify(response)

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=6001)