update

README.md

@@ -7,4 +7,41 @@ sdk: docker
 pinned: false
 ---
 
+Based on your uploaded dataset and deployed API, here are example API calls for your Kotlin client:
+
+1. **Find Nearby Stores (JSON Response)**
+```
+https://maps-yiv5.onrender.com/api/stores/nearby?lat=18.9695&lon=72.8320&radius=1
+```
+Use this to get store details near Market Road area within 1km
+
+2. **View Basic Store Map**
+```
+https://maps-yiv5.onrender.com/api/stores/map?lat=18.9701&lon=72.8330&radius=0.5
+```
+Shows map centered at Main Street with 500m radius
+
+3. **View All Store Locations with Color Coding**
+```
+https://maps-yiv5.onrender.com/api/stores/locations?lat=18.9685&lon=72.8325&radius=2
+```
+Shows detailed map with color-coded stores within 2km
+
+4. **Get Route Between Points**
+Example routes:
+```
+# Route from Park Avenue to Hill Road stores
+https://maps-yiv5.onrender.com/api/stores/route?user_lat=18.9710&user_lon=72.8335&store_lat=18.9705&store_lon=72.8345&viz_type=simple
+
+# Route from Main Street to Market Road stores
+https://maps-yiv5.onrender.com/api/stores/route?user_lat=18.9701&user_lon=72.8330&store_lat=18.9695&store_lon=72.8320&viz_type=simple
+```
+
+Key Location Points in Dataset:
+- Main Street Area: 18.9701, 72.8330
+- Park Avenue: 18.9710, 72.8335
+- Market Road: 18.9695, 72.8320
+- Shopping Center: 18.9670, 72.8300
+- Commercial Street: 18.9690, 72.8340
+
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,7 +1,889 @@
-from fastapi import FastAPI
+from fastapi import FastAPI, Request, Query, HTTPException, Response
+from fastapi.responses import JSONResponse, HTMLResponse, FileResponse
+from fastapi.middleware.cors import CORSMiddleware
+import pandas as pd
+import numpy as np
+from geopy.distance import geodesic
+import folium
+from folium import plugins
+import osmnx as ox
+import networkx as nx
+from datetime import datetime
+import json
+import matplotlib.pyplot as plt
+import plotly.express as px
+import os
+import time
+from functools import lru_cache
+from rtree import index
+import gc
+import shutil
+from typing import Optional, List, Dict, Any, Union
+from pydantic import BaseModel, Field
 
-app = FastAPI()
+app = FastAPI(title="falcao-maps API", description="Store locator and route planning API")
 
-@app.get("/")
-def greet_json():
-    return {"Hello": "World!"}
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Create temp directory for files
+os.makedirs('temp', exist_ok=True)
+
+# Custom JSON encoder for NumPy types
+class NumpyEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, np.integer):
+            return int(obj)
+        elif isinstance(obj, np.floating):
+            return float(obj)
+        elif isinstance(obj, np.ndarray):
+            return obj.tolist()
+        return super(NumpyEncoder, self).default(obj)
+
+# Load and prepare the store data
+stores_df = pd.read_csv('dataset of 50 stores.csv')
+
+# Define Pydantic models for API responses
+class Location(BaseModel):
+    lat: float
+    lon: float
+
+class Store(BaseModel):
+    store_name: str
+    address: str
+    contact: str
+    distance: float
+    estimated_delivery_time: int
+    product_categories: str
+    location: Location
+
+class StoresResponse(BaseModel):
+    status: str
+    stores: List[Store]
+
+class ErrorResponse(BaseModel):
+    status: str
+    message: str
+
+class StoreLocator:
+    def __init__(self, stores_dataframe):
+        self.stores_df = stores_dataframe
+        self.network_graph = None
+        self.graph_cache = {}  # Cache for network graphs
+        self.spatial_index = self._build_spatial_index()
+
+    @lru_cache(maxsize=50)     
+    def initialize_graph(self, center_point, dist=10000):  # Reduced distance for memory optimization
+        """Initialize road network graph with caching"""
+        cache_key = f"{center_point[0]}_{center_point[1]}"
+        if cache_key in self.graph_cache:
+            self.network_graph = self.graph_cache[cache_key]
+            return True
+        try:
+            # Use simplify=True and increased tolerance for lower memory usage
+            self.network_graph = ox.graph_from_point(
+                center_point, 
+                dist=dist, 
+                network_type="drive",
+                simplify=True,
+                retain_all=False
+            )
+            self.network_graph = ox.add_edge_speeds(self.network_graph)
+            self.network_graph = ox.add_edge_travel_times(self.network_graph)
+            
+            # Store in cache
+            self.graph_cache[cache_key] = self.network_graph
+            
+            # Force garbage collection
+            gc.collect()
+            
+            return True
+        except Exception as e:
+            print(f"Error initializing graph: {str(e)}")
+            return False
+        
+    def _build_spatial_index(self):
+        idx = index.Index()
+        for i, row in self.stores_df.iterrows():
+            idx.insert(i, (row['Latitude'], row['Longitude'], 
+                          row['Latitude'], row['Longitude']))
+        return idx
+
+    def calculate_distance(self, lat1, lon1, lat2, lon2):
+        """Calculate direct distance between two points"""
+        return geodesic((lat1, lon1), (lat2, lon2)).kilometers
+
+    def estimate_delivery_time(self, distance, current_time=None):
+        """Estimate delivery time based on distance and current time"""
+        if current_time is None:
+            current_time = datetime.now()
+
+        # Base time: 5 mins base + 2 mins per km
+        base_minutes = 5 + (distance * 2)
+        
+        # Apply traffic multiplier based on time of day
+        hour = current_time.hour
+        if hour in [8, 9, 10, 17, 18, 19]:  # Peak hours
+            multiplier = 1.5
+        elif hour in [23, 0, 1, 2, 3, 4]:   # Off-peak hours
+            multiplier = 0.8
+        else:                                # Normal hours
+            multiplier = 1.0
+            
+        return round(base_minutes * multiplier)
+
+    def find_nearby_stores(self, lat, lon, radius=5):
+        """Find stores within radius using spatial index"""
+        nearby_stores = []
+        bbox = (lat - radius/111.0, lon - radius/111.0, 
+               lat + radius/111.0, lon + radius/111.0)
+        
+        for store_id in self.spatial_index.intersection(bbox):
+            store = self.stores_df.iloc[store_id]
+            distance = self.calculate_distance(lat, lon, 
+                                            store['Latitude'], 
+                                            store['Longitude'])
+            if distance <= radius:
+                delivery_time = self.estimate_delivery_time(distance)
+                nearby_stores.append({
+                    'store_name': store['Store Name'],
+                    'address': store['Address'],
+                    'contact': str(store['Contact Number']),  # Convert to string to avoid int64 issues
+                    'distance': round(distance, 2),
+                    'estimated_delivery_time': int(delivery_time),  # Ensure integer type
+                    'product_categories': store['Product Categories'],
+                    'location': {
+                        'lat': float(store['Latitude']),  # Ensure float type
+                        'lon': float(store['Longitude'])  # Ensure float type
+                    }
+                })
+        
+        return sorted(nearby_stores, key=lambda x: x['distance'])
+
+    def create_store_map(self, center_lat, center_lon, radius=5):
+        """Create an interactive map with store locations - optimized for memory"""
+        # Create base map
+        m = folium.Map(
+            location=[center_lat, center_lon], 
+            zoom_start=13,
+            tiles="cartodbpositron"
+        )
+        
+        # Create marker cluster for better performance with many markers
+        marker_cluster = plugins.MarkerCluster().add_to(m)
+        
+        # Add stores to map
+        nearby_stores = self.find_nearby_stores(center_lat, center_lon, radius)
+        
+        # Limit the number of stores to reduce memory usage
+        max_stores = min(len(nearby_stores), 50)  # Cap at 50 stores
+        
+        for store in nearby_stores[:max_stores]:
+            # Prepare popup content
+            popup_content = f"""
+            <div style='width: 200px'>
+                <b>{store['store_name']}</b><br>
+                Address: {store['address']}<br>
+                Distance: {store['distance']} km<br>
+                Est. Delivery: {store['estimated_delivery_time']} mins<br>
+                Categories: {store['product_categories']}
+            </div>
+            """
+            
+            # Add store marker
+            folium.Marker(
+                location=[store['location']['lat'], store['location']['lon']],
+                popup=folium.Popup(popup_content, max_width=300),
+                icon=folium.Icon(color='red', icon='info-sign')
+            ).add_to(marker_cluster)
+            
+            # Add line to show distance from center (only for closer stores)
+            if store['distance'] <= nearby_stores[min(9, len(nearby_stores)-1)]['distance']:
+                folium.PolyLine(
+                    locations=[[center_lat, center_lon], 
+                            [store['location']['lat'], store['location']['lon']]],
+                    weight=2,
+                    color='blue',
+                    opacity=0.3
+                ).add_to(m)
+        
+        # Add current location marker
+        folium.Marker(
+            location=[center_lat, center_lon],
+            popup='Your Location',
+            icon=folium.Icon(color='green', icon='home')
+        ).add_to(m)
+        
+        # Add layer control only
+        folium.LayerControl().add_to(m)
+        
+        return m
+
+# Initialize store locator
+store_locator = StoreLocator(stores_df)
+
+# Helper functions for cleaning temporary files
+def cleanup_temp_files():
+    temp_dir = 'temp'
+    if os.path.exists(temp_dir):
+        for file in os.listdir(temp_dir):
+            file_path = os.path.join(temp_dir, file)
+            try:
+                if os.path.isfile(file_path) and file.endswith('.html'):
+                    # Delete files older than 1 hour
+                    if os.path.getmtime(file_path) < time.time() - 3600:
+                        os.remove(file_path)
+            except Exception as e:
+                print(f"Error cleaning up temp files: {e}")
+
+# Register cleanup on startup and shutdown
+@app.on_event("startup")
+async def startup_event():
+    cleanup_temp_files()
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    # Clean up all temporary files on shutdown
+    try:
+        shutil.rmtree('temp')
+    except Exception as e:
+        print(f"Error cleaning up temp directory: {e}")
+
+# Routes
+@app.get("/", response_class=HTMLResponse)
+async def home():
+    """API Documentation Homepage"""
+    html_content = f"""
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>falcao-maps API Documentation</title>
+        <style>
+            body {{
+                font-family: Arial, sans-serif;
+                margin: 20px;
+            }}
+            h1, h2 {{
+                color: #333;
+            }}
+            pre {{
+                background-color: #f4f4f4;
+                padding: 10px;
+                border: 1px solid #ddd;
+                border-radius: 5px;
+            }}
+        </style>
+    </head>
+    <body>
+        <h1>Welcome to falcao-maps</h1>
+        <p>Based on your uploaded dataset and deployed API, here are example API calls for your client:</p>
+
+        <h2>1. Find Nearby Stores (JSON Response)</h2>
+        <pre>
+/api/stores/nearby?lat=18.9695&lon=72.8320&radius=1
+        </pre>
+        <p>Use this to get store details near Market Road area within 1km</p>
+
+        <h2>2. View Basic Store Map</h2>
+        <pre>
+/api/stores/map?lat=18.9701&lon=72.8330&radius=0.5
+        </pre>
+        <p>Shows map centered at Main Street with 500m radius</p>
+
+        <h2>3. View All Store Locations with Color Coding</h2>
+        <pre>
+/api/stores/locations?lat=18.9685&lon=72.8325&radius=2
+        </pre>
+        <p>Shows detailed map with color-coded stores within 2km</p>
+
+        <h2>4. Get Route Between Points</h2>
+        <p>Example routes:</p>
+        <pre>
+# Route from Park Avenue to Hill Road stores (use simple visualization for memory optimization)
+/api/stores/route?user_lat=18.9710&user_lon=72.8335&store_lat=18.9705&store_lon=72.8345&viz_type=simple
+
+# Route from Main Street to Market Road stores
+/api/stores/route?user_lat=18.9701&user_lon=72.8330&store_lat=18.9695&store_lon=72.8320&viz_type=simple
+        </pre>
+
+        <h2>Key Location Points in Dataset:</h2>
+        <ul>
+            <li>Main Street Area: 18.9701, 72.8330</li>
+            <li>Park Avenue: 18.9710, 72.8335</li>
+            <li>Market Road: 18.9695, 72.8320</li>
+            <li>Shopping Center: 18.9670, 72.8300</li>
+            <li>Commercial Street: 18.9690, 72.8340</li>
+        </ul>
+        
+        <h2>API Documentation</h2>
+        <p>You can view the interactive API documentation at: <a href="/docs">/docs</a></p>
+    </body>
+    </html>
+    """
+    return html_content
+
+@app.get("/api/stores/nearby", response_model=StoresResponse, responses={400: {"model": ErrorResponse}})
+async def get_nearby_stores(
+    lat: float = Query(..., description="Latitude of user location"),
+    lon: float = Query(..., description="Longitude of user location"),
+    radius: float = Query(5.0, description="Search radius in kilometers")
+):
+    """Get nearby stores based on user location"""
+    try:
+        nearby_stores = store_locator.find_nearby_stores(lat, lon, radius)
+        return {"status": "success", "stores": nearby_stores}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@app.get("/api/stores/map", response_class=HTMLResponse, responses={400: {"model": ErrorResponse}})
+async def get_stores_map(
+    lat: float = Query(..., description="Latitude of center point"),
+    lon: float = Query(..., description="Longitude of center point"),
+    radius: float = Query(5.0, description="Search radius in kilometers")
+):
+    """Get HTML map with store locations"""
+    try:
+        # Clean up temp files before creating new ones
+        cleanup_temp_files()
+        
+        store_map = store_locator.create_store_map(lat, lon, radius)
+        
+        # Create complete HTML content
+        html_content = f"""
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <meta charset="utf-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" />
+            <title>Stores Map</title>
+            <style>
+                body {{
+                    margin: 0;
+                    padding: 0;
+                    width: 100vw;
+                    height: 100vh;
+                    overflow: hidden;
+                }}
+                #map {{
+                    width: 100%;
+                    height: 100%;
+                }}
+            </style>
+        </head>
+        <body>
+            {store_map.get_root().render()}
+            <script>
+                window.onload = function() {{
+                    setTimeout(function() {{
+                        window.dispatchEvent(new Event('resize'));
+                    }}, 1000);
+                }};
+            </script>
+        </body>
+        </html>
+        """
+        
+        # Save the HTML to a file
+        file_path = 'temp/stores_map.html'
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.write(html_content)
+        
+        # Return the file as HTML response
+        return html_content
+        
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@app.get("/api/stores/route", response_class=HTMLResponse, responses={400: {"model": ErrorResponse}, 404: {"model": ErrorResponse}})
+async def get_store_route(
+    user_lat: float = Query(..., description="User location latitude"),
+    user_lon: float = Query(..., description="User location longitude"),
+    store_lat: float = Query(..., description="Store location latitude"),
+    store_lon: float = Query(..., description="Store location longitude"),
+    viz_type: str = Query("simple", description="Visualization type (simple or advanced)")
+):
+    """Get route between user and store locations with visualization"""
+    try:
+        # Clean up temp files before creating new ones
+        cleanup_temp_files()
+        
+        # Initialize graph if not already initialized
+        # Use a smaller distance to reduce memory usage
+        if store_locator.network_graph is None:
+            success = store_locator.initialize_graph((user_lat, user_lon), dist=10000)
+            if not success:
+                raise HTTPException(status_code=400, detail="Unable to initialize graph, try a different location")
+        
+        # Get nearest nodes
+        start_node = ox.distance.nearest_nodes(
+            store_locator.network_graph, user_lon, user_lat)
+        end_node = ox.distance.nearest_nodes(
+            store_locator.network_graph, store_lon, store_lat)
+        
+        try:
+            # Calculate path using the travel_time weight
+            path_time = nx.shortest_path(
+                store_locator.network_graph, 
+                start_node, 
+                end_node, 
+                weight='travel_time'
+            )
+            
+            if viz_type == "simple":
+                # Create a simple folium map for low-resource environments
+                m = folium.Map(
+                    location=[(user_lat + store_lat) / 2, (user_lon + store_lon) / 2],
+                    zoom_start=15,
+                    tiles="cartodbpositron"
+                )
+                
+                # Add markers for start and end points
+                folium.Marker(
+                    [user_lat, user_lon],
+                    popup='Your Location',
+                    icon=folium.Icon(color='green', icon='home')
+                ).add_to(m)
+                
+                folium.Marker(
+                    [store_lat, store_lon],
+                    popup='Store Location',
+                    icon=folium.Icon(color='red', icon='info-sign')
+                ).add_to(m)
+                
+                # Extract coordinates from the path
+                path_coords = []
+                for node in path_time:
+                    x = store_locator.network_graph.nodes[node]['x']
+                    y = store_locator.network_graph.nodes[node]['y']
+                    path_coords.append([y, x])  # Note the y, x order for folium
+                
+                # Add the route line
+                folium.PolyLine(
+                    locations=path_coords,
+                    weight=5,
+                    color='blue',
+                    opacity=0.7
+                ).add_to(m)
+                
+                # Add distance and time estimate
+                total_distance = 0
+                total_time = 0
+                
+                for i in range(len(path_time) - 1):
+                    a, b = path_time[i], path_time[i + 1]
+                    total_distance += store_locator.network_graph.edges[(a, b, 0)]['length']
+                    total_time += store_locator.network_graph.edges[(a, b, 0)]['travel_time']
+                
+                # Convert to km and minutes
+                total_distance_km = round(total_distance / 1000, 2)
+                total_time_min = round(total_time / 60, 1)
+                
+                # Add info box
+                html_content = f"""
+                <div style="position: fixed; top: 10px; left: 50px; z-index: 9999; 
+                            background-color: white; padding: 10px; border-radius: 5px;
+                            box-shadow: 0 0 10px rgba(0,0,0,0.3);">
+                    <h4 style="margin: 0 0 5px 0;">Route Information</h4>
+                    <p><b>Distance:</b> {total_distance_km} km<br>
+                       <b>Est. Time:</b> {total_time_min} minutes</p>
+                </div>
+                """
+                
+                m.get_root().html.add_child(folium.Element(html_content))
+                
+                # Add layer control
+                folium.LayerControl().add_to(m)
+                
+                # Create complete HTML content
+                html_content = f"""
+                <!DOCTYPE html>
+                <html>
+                <head>
+                    <meta charset="utf-8">
+                    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" />
+                    <title>Simple Route Map</title>
+                    <style>
+                        body {{
+                            margin: 0;
+                            padding: 0;
+                            width: 100vw;
+                            height: 100vh;
+                            overflow: hidden;
+                        }}
+                        #map {{
+                            width: 100%;
+                            height: 100%;
+                        }}
+                    </style>
+                </head>
+                <body>
+                    {m.get_root().render()}
+                    <script>
+                        window.onload = function() {{
+                            setTimeout(function() {{
+                                window.dispatchEvent(new Event('resize'));
+                            }}, 1000);
+                        }};
+                    </script>
+                </body>
+                </html>
+                """
+                
+                # Save the HTML to a file
+                file_path = 'temp/simple_route_map.html'
+                with open(file_path, 'w', encoding='utf-8') as f:
+                    f.write(html_content)
+                
+                # Return the HTML content
+                return html_content
+                
+            else:
+                # WARNING: Advanced visualization - may cause memory issues on limited resources
+                
+                # Limit the path nodes to reduce memory usage
+                # Only include every Nth node
+                step = max(1, len(path_time) // 30)  # Maximum 30 points
+                simplified_path = path_time[::step]
+                if path_time[-1] not in simplified_path:
+                    simplified_path.append(path_time[-1])
+                
+                # Create animation data (simplified)
+                lst_start, lst_end = [], []
+                start_x, start_y = [], []
+                end_x, end_y = [], []
+                lst_length, lst_time = [], []
+
+                for a, b in zip(simplified_path[:-1], simplified_path[1:]):
+                    lst_start.append(a)
+                    lst_end.append(b)
+                    
+                    # Calculate accumulated length and time between simplified points
+                    segment_length = 0
+                    segment_time = 0
+                    path_segment = nx.shortest_path(
+                        store_locator.network_graph, a, b, weight='travel_time')
+                    
+                    for i in range(len(path_segment) - 1):
+                        u, v = path_segment[i], path_segment[i + 1]
+                        segment_length += store_locator.network_graph.edges[(u, v, 0)]['length']
+                        segment_time += store_locator.network_graph.edges[(u, v, 0)]['travel_time']
+                    
+                    lst_length.append(round(segment_length))
+                    lst_time.append(round(segment_time))
+                    start_x.append(store_locator.network_graph.nodes[a]['x'])
+                    start_y.append(store_locator.network_graph.nodes[a]['y'])
+                    end_x.append(store_locator.network_graph.nodes[b]['x'])
+                    end_y.append(store_locator.network_graph.nodes[b]['y'])
+
+                df = pd.DataFrame(
+                    list(zip(lst_start, lst_end, start_x, start_y, end_x, end_y, 
+                            lst_length, lst_time)),
+                    columns=["start", "end", "start_x", "start_y",
+                            "end_x", "end_y", "length", "travel_time"]
+                ).reset_index().rename(columns={"index": "id"})
+
+                # Create animation using plotly (reduced complexity)
+                df_start = df[df["start"] == lst_start[0]]
+                df_end = df[df["end"] == lst_end[-1]]
+
+                fig = px.scatter_mapbox(
+                    data_frame=df, 
+                    lon="start_x", 
+                    lat="start_y",
+                    zoom=15, 
+                    width=800,  # Reduced size
+                    height=600,  # Reduced size
+                    animation_frame="id",
+                    mapbox_style="carto-positron"
+                )
+
+                # Basic visualization elements only
+                fig.data[0].marker = {"size": 12}
+                
+                # Add start point
+                fig.add_trace(
+                    px.scatter_mapbox(
+                        data_frame=df_start, 
+                        lon="start_x", 
+                        lat="start_y"
+                    ).data[0]
+                )
+                fig.data[1].marker = {"size": 15, "color": "red"}
+
+                # Add end point
+                fig.add_trace(
+                    px.scatter_mapbox(
+                        data_frame=df_end, 
+                        lon="start_x", 
+                        lat="start_y"
+                    ).data[0]
+                )
+                fig.data[2].marker = {"size": 15, "color": "green"}
+
+                # Add route
+                fig.add_trace(
+                    px.line_mapbox(
+                        data_frame=df, 
+                        lon="start_x", 
+                        lat="start_y"
+                    ).data[0]
+                )
+
+                # Simplified layout with fewer options to reduce complexity
+                fig.update_layout(
+                    showlegend=False,
+                    margin={"r":0,"t":0,"l":0,"b":0},
+                    autosize=True,
+                    height=None
+                )
+
+                # Create complete HTML content
+                html_content = f"""
+                <!DOCTYPE html>
+                <html>
+                <head>
+                    <meta charset="utf-8">
+                    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" />
+                    <title>Route Map</title>
+                    <style>
+                        body {{
+                            margin: 0;
+                            padding: 0;
+                            width: 100vw;
+                            height: 100vh;
+                            overflow: hidden;
+                        }}
+                        #map-container {{
+                            width: 100%;
+                            height: 100%;
+                        }}
+                    </style>
+                </head>
+                <body>
+                    <div id="map-container">
+                        {fig.to_html(include_plotlyjs=True, full_html=False, config={'staticPlot': True})}
+                    </div>
+                    <script>
+                        window.onload = function() {{
+                            setTimeout(function() {{
+                                window.dispatchEvent(new Event('resize'));
+                            }}, 1000);
+                        }};
+                    </script>
+                </body>
+                </html>
+                """
+                
+                # Save the HTML to a file
+                file_path = 'temp/route_map.html'
+                with open(file_path, 'w', encoding='utf-8') as f:
+                    f.write(html_content)
+                
+                # Return the HTML content
+                return html_content
+
+        except nx.NetworkXNoPath:
+            raise HTTPException(status_code=404, detail="No route found")
+            
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@app.get("/api/stores/locations", response_class=HTMLResponse, responses={400: {"model": ErrorResponse}})
+async def get_all_store_locations(
+    lat: float = Query(..., description="Latitude of center point"),
+    lon: float = Query(..., description="Longitude of center point"),
+    radius: float = Query(10.0, description="Search radius in kilometers")
+):
+    """Get a map showing all stores in the given radius with colors based on distance"""
+    try:
+        # Clean up temp files before creating new ones
+        cleanup_temp_files()
+        
+        # Get nearby stores
+        nearby_stores = store_locator.find_nearby_stores(lat, lon, radius)
+        
+        # Limit number of stores for memory optimization
+        max_stores = min(len(nearby_stores), 50)
+        nearby_stores = nearby_stores[:max_stores]
+        
+        # Create base map centered on user location
+        m = folium.Map(
+            location=[lat, lon],
+            zoom_start=12,
+            tiles="cartodbpositron"
+        )
+        
+        # Add user location marker
+        folium.Marker(
+            [lat, lon],
+            popup='Your Location',
+            icon=folium.Icon(color='green', icon='home')
+        ).add_to(m)
+        
+        # Add markers for each store with color coding based on distance
+        for store in nearby_stores:
+            # Color code based on distance
+            if store['distance'] <= 2:
+                color = 'red'  # Very close
+            elif store['distance'] <= 5:
+                color = 'orange'  # Moderate distance
+            else:
+                color = 'blue'  # Further away
+                
+            # Create simplified popup content
+            popup_content = f"""
+            <div style='width: 200px; font-size: 14px;'>
+                <h4 style='color: {color}; margin: 0 0 8px 0;'>{store['store_name']}</h4>
+                <b>Distance:</b> {store['distance']} km<br>
+                <b>Est. Delivery:</b> {store['estimated_delivery_time']} mins<br>
+                <b>Categories:</b> {store['product_categories']}<br>
+                <button onclick="window.location.href='/api/stores/route?user_lat={lat}&user_lon={lon}&store_lat={store['location']['lat']}&store_lon={store['location']['lon']}&viz_type=simple'" 
+                        style='margin-top: 8px; padding: 8px; width: 100%; background-color: #007bff; color: white; border: none; border-radius: 4px;'>
+                    Get Route
+                </button>
+            </div>
+            """
+            
+            # Add store marker
+            folium.Marker(
+                location=[store['location']['lat'], store['location']['lon']],
+                popup=folium.Popup(popup_content, max_width=300),
+                icon=folium.Icon(color=color, icon='info-sign'),
+                tooltip=f"{store['store_name']} ({store['distance']} km)"
+            ).add_to(m)
+            
+            # Add circle to show distance - only for closer stores to reduce complexity
+            if store['distance'] <= 5:
+                folium.Circle(
+                    location=[store['location']['lat'], store['location']['lon']],
+                    radius=store['distance'] * 100,
+                    color=color,
+                    fill=True,
+                    opacity=0.1
+                ).add_to(m)
+        
+        # Add distance circles from user location - reduced to save memory
+        for circle_radius, color in [(2000, 'red'), (5000, 'orange')]:
+            folium.Circle(
+                location=[lat, lon],
+                radius=circle_radius,
+                color=color,
+                fill=False,
+                weight=1,dash_array='5, 5'
+            ).add_to(m)
+        
+        # Create mobile-friendly HTML content
+        html_content = f"""
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <meta charset="utf-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" />
+            <title>Nearby Stores</title>
+            <style>
+                body {{
+                    margin: 0;
+                    padding: 0;
+                    width: 100vw;
+                    height: 100vh;
+                    overflow: hidden;
+                }}
+                #map {{
+                    width: 100%;
+                    height: 100%;
+                }}
+                .legend {{
+                    position: fixed;
+                    bottom: 20px;
+                    right: 20px;
+                    background: white;
+                    padding: 10px;
+                    border-radius: 5px;
+                    box-shadow: 0 1px 5px rgba(0,0,0,0.2);
+                    font-size: 12px;
+                    z-index: 1000;
+                }}
+                .info-box {{
+                    position: fixed;
+                    top: 20px;
+                    left: 20px;
+                    background: white;
+                    padding: 10px;
+                    border-radius: 5px;
+                    box-shadow: 0 1px 5px rgba(0,0,0,0.2);
+                    font-size: 12px;
+                    z-index: 1000;
+                }}
+            </style>
+        </head>
+        <body>
+            {m.get_root().render()}
+            <div class="legend">
+                <b>Distance Zones</b><br>
+                <span style="color: red;">●</span> &lt; 2 km<br>
+                <span style="color: orange;">●</span> 2-5 km<br>
+                <span style="color: blue;">●</span> &gt; 5 km
+            </div>
+            <div class="info-box">
+                <b>Search Radius:</b> {radius} km<br>
+                <b>Stores Found:</b> {len(nearby_stores)}
+            </div>
+            <script>
+                window.onload = function() {{
+                    setTimeout(function() {{
+                        window.dispatchEvent(new Event('resize'));
+                    }}, 1000);
+                }};
+            </script>
+        </body>
+        </html>
+        """
+        
+        # Save and return the file
+        file_path = 'temp/locations_map.html'
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.write(html_content)
+        
+        # Return the HTML content
+        return html_content
+    
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+# Add endpoint to serve static files directly
+@app.get("/temp/{file_path:path}", response_class=FileResponse)
+async def get_temp_file(file_path: str):
+    """Serve temporary files like HTML maps"""
+    full_path = os.path.join("temp", file_path)
+    if not os.path.exists(full_path):
+        raise HTTPException(status_code=404, detail="File not found")
+    return FileResponse(full_path)
+
+# Add memory monitoring and management middleware
+@app.middleware("http")
+async def add_memory_management(request: Request, call_next):
+    # Cleanup before processing request
+    cleanup_temp_files()
+    
+    # Process the request
+    response = await call_next(request)
+    
+    # Cleanup after processing request
+    gc.collect()
+    
+    return response
+
+# For running the application directly (development mode)
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

dataset of 50 stores.csv

@@ -0,0 +1,36 @@
+Store Name,Address,Contact Number,Latitude,Longitude,Product Categories
+Kirana Store A,"123 Main Street, Mumbai",9876543210,18.9701,72.8330,"Groceries, Dairy, Beverages, Snacks"
+Kirana Store B,"456 Market Road, Mumbai",9876543211,18.9695,72.8320,"Groceries, Dairy, Beverages, Snacks, Household"
+Kirana Store C,"789 Shopping Center, Mumbai",9876543212,18.9670,72.8300,"Groceries, Dairy, Beverages, Snacks, Fruits, Vegetables"
+Kirana Store D,"1011 Commercial Street, Mumbai",9876543213,18.9690,72.8340,"Groceries, Dairy, Beverages, Snacks, Household, Electronics"
+Kirana Store E,"1213 Residential Lane, Mumbai",9876543214,18.9680,72.8290,"Groceries, Dairy, Beverages, Snacks, Fruits, Vegetables, Meat"
+Kirana Store F,"1415 Park Avenue, Mumbai",9876543215,18.9710,72.8335,"Groceries, Dairy, Beverages, Snacks, Bakery"
+Kirana Store G,"1617 Hill Road, Mumbai",9876543216,18.9705,72.8345,"Groceries, Dairy, Beverages, Snacks, Personal Care"
+Kirana Store H,"1819 Beach Road, Mumbai",9876543217,18.9675,72.8315,"Groceries, Dairy, Beverages, Snacks, Seafood"
+Kirana Store I,"2021 Market Lane, Mumbai",9876543218,18.9695,72.8325,"Groceries, Dairy, Beverages, Snacks, Pet Supplies"
+Kirana Store J,"2223 Station Road, Mumbai",9876543219,18.9685,72.8295,"Groceries, Dairy, Beverages, Snacks, Stationery"
+Kirana Store K,"2425 School Street, Mumbai",9876543220,18.9700,72.8340,"Groceries, Dairy, Beverages, Snacks, Toys"
+Kirana Store L,"2627 Hospital Road, Mumbai",9876543221,18.9675,72.8320,"Groceries, Dairy, Beverages, Snacks, Pharmaceuticals"
+Kirana Store M,"2829 College Street, Mumbai",9876543222,18.9690,72.8310,"Groceries, Dairy, Beverages, Snacks, Books"
+Kirana Store N,"3031 Library Road, Mumbai",9876543223,18.9710,72.8345,"Groceries, Dairy, Beverages, Snacks, Gifts"
+Kirana Store O,"3233 Park Lane, Mumbai",9876543224,18.9705,72.8355,"Groceries, Dairy, Beverages, Snacks, Flowers"
+Kirana Store P,"3435 River Road, Mumbai",9876543225,18.9680,72.8330,"Groceries, Dairy, Beverages, Snacks, Sweets"
+Kirana Store Q,"3637 Hill View, Mumbai",9876543226,18.9695,72.8340,"Groceries, Dairy, Beverages, Snacks, Organic Products"
+Kirana Store R,"3839 Ocean Drive, Mumbai",9876543227,18.9670,72.8290,"Groceries, Dairy, Beverages, Snacks, Seafood"
+Kirana Store S,"4041 Green Street, Mumbai",9876543228,18.9685,72.8335,"Groceries, Dairy, Beverages, Snacks, Home Decor"
+Kirana Store T,"4243 Market Place, Mumbai",9876543229,18.9700,72.8325,"Groceries, Dairy, Beverages, Snacks, Cosmetics"
+Kirana Store U,"4445 Town Square, Mumbai",9876543230,18.9665,72.8315,"Groceries, Dairy, Beverages, Snacks, Electronics"
+Kirana Store V,"4647 City Center, Mumbai",9876543231,18.9680,72.8305,"Groceries, Dairy, Beverages, Snacks, Furniture"
+Kirana Store W,"4849 Parkside Drive, Mumbai",9876543232,18.9695,72.8330,"Groceries, Dairy, Beverages, Snacks, Hardware"
+Kirana Store X,"5051 Riverside Lane, Mumbai",9876543233,18.9675,72.8300,"Groceries, Dairy, Beverages, Snacks, Bakery"
+Kirana Store Y,"5253 Hillcrest Road, Mumbai",9876543234,18.9705,72.8320,"Groceries, Dairy, Beverages, Snacks, Personal Care"
+Kirana Store Z,"5455 Beach Walk, Mumbai",9876543235,18.9680,72.8295,"Groceries, Dairy, Beverages, Snacks, Seafood"
+Kirana Store AA,"5657 Market Place, Mumbai",9876543236,18.9690,72.8335,"Groceries, Dairy, Beverages, Snacks, Pet Supplies"
+Kirana Store BB,"5859 Station Square, Mumbai",9876543237,18.9675,72.8305,"Groceries, Dairy, Beverages, Snacks, Stationery"
+Kirana Store CC,"6061 School Lane, Mumbai",9876543238,18.9700,72.8330,"Groceries, Dairy, Beverages, Snacks, Toys"
+Kirana Store DD,"6263 Hospital Way, Mumbai",9876543239,18.9670,72.8310,"Groceries, Dairy, Beverages, Snacks, Pharmaceuticals"
+Kirana Store EE,"6465 College Avenue, Mumbai",9876543240,18.9695,72.8320,"Groceries, Dairy, Beverages, Snacks, Books"
+Kirana Store FF,"6667 Library Lane, Mumbai",9876543241,18.9710,72.8335,"Groceries, Dairy, Beverages, Snacks, Gifts"
+Kirana Store GG,"6869 Parkside Drive, Mumbai",9876543242,18.9705,72.8345,"Groceries, Dairy, Beverages, Snacks, Flowers"
+Kirana Store HH,"7071 Riverview Road, Mumbai",9876543243,18.9680,72.8325,"Groceries, Dairy, Beverages, Snacks, Sweets"
+Kirana Store II,"7273 Hillside Drive, Mumbai",9876543244,18.9695,72.8330,"Groceries, Dairy, Beverages, Snacks, Organic Products"

requirements.txt

@@ -1,2 +1,13 @@
 fastapi
 uvicorn[standard]
+pandas
+numpy
+geopy
+folium
+osmnx
+networkx
+plotly
+requests
+python-dotenv
+rtree
+matplotlib