updates

app.py

@@ -1,5 +1,5 @@
-from fastapi import FastAPI, Request, Query, HTTPException, Response
-from fastapi.responses import JSONResponse, HTMLResponse, FileResponse
+from fastapi import FastAPI, HTTPException, Query, Request, Response
+from fastapi.responses import HTMLResponse, JSONResponse, FileResponse
 from fastapi.middleware.cors import CORSMiddleware
 import pandas as pd
 import numpy as np
@@ -16,12 +16,11 @@ 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
+from typing import List, Dict, Any, Optional
 
-app = FastAPI(title="falcao-maps API", description="Store locator and route planning API")
+# Create app instance
+app = FastAPI(title="Store Locator API")
 
 # Add CORS middleware
 app.add_middleware(
@@ -35,8 +34,11 @@ app.add_middleware(
 # Create temp directory for files
 os.makedirs('temp', exist_ok=True)
 
-# Custom JSON encoder for NumPy types
-class NumpyEncoder(json.JSONEncoder):
+# Load and prepare the store data
+stores_df = pd.read_csv('dataset of 50 stores.csv')
+
+# Custom JSON encoder for numpy types
+class NumpyJSONEncoder(json.JSONEncoder):
     def default(self, obj):
         if isinstance(obj, np.integer):
             return int(obj)
@@ -44,13 +46,10 @@ class NumpyEncoder(json.JSONEncoder):
             return float(obj)
         elif isinstance(obj, np.ndarray):
             return obj.tolist()
-        return super(NumpyEncoder, self).default(obj)
+        return super().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):
+# Pydantic models for response validation
+class StoreLocation(BaseModel):
     lat: float
     lon: float
 
@@ -61,7 +60,7 @@ class Store(BaseModel):
     distance: float
     estimated_delivery_time: int
     product_categories: str
-    location: Location
+    location: StoreLocation
 
 class StoresResponse(BaseModel):
     status: str
@@ -70,7 +69,7 @@ class StoresResponse(BaseModel):
 class ErrorResponse(BaseModel):
     status: str
     message: str
-
+    
 class StoreLocator:
     def __init__(self, stores_dataframe):
         self.stores_df = stores_dataframe
@@ -79,30 +78,16 @@ class StoreLocator:
         self.spatial_index = self._build_spatial_index()
 
     @lru_cache(maxsize=50)     
-    def initialize_graph(self, center_point, dist=30000):  # Reduced distance for memory optimization
+    def initialize_graph(self, center_point, dist=20000):
         """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.graph_from_point(center_point, dist=dist, network_type="drive")
             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)}")
@@ -137,7 +122,7 @@ class StoreLocator:
             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 = []
@@ -167,24 +152,20 @@ class StoreLocator:
         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 an interactive map with store locations"""
         # Create base map
-        m = folium.Map(
-            location=[center_lat, center_lon], 
-            zoom_start=13,
-            tiles="cartodbpositron"
-        )
+        m = folium.Map(location=[center_lat, center_lon], 
+                      zoom_start=13,
+                      tiles="cartodbpositron",
+                      prefer_canvas=True
+                      )
         
         # 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]:
+        for store in nearby_stores:
             # Prepare popup content
             popup_content = f"""
             <div style='width: 200px'>
@@ -203,15 +184,14 @@ class StoreLocator:
                 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 line to show distance from center
+            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(
@@ -220,16 +200,84 @@ class StoreLocator:
             icon=folium.Icon(color='green', icon='home')
         ).add_to(m)
         
-        # Add layer control only
+        # Add fullscreen option
+        plugins.Fullscreen().add_to(m)
+        
+        # Add layer control
         folium.LayerControl().add_to(m)
         
         return m
-
-# Initialize store locator
+    
+    # Initialize store locator
 store_locator = StoreLocator(stores_df)
 
-# Helper functions for cleaning temporary files
-def cleanup_temp_files():
+def create_animated_route(G, path, color, weight=3):
+    """Create an animated route visualization"""
+    features = []
+    timestamps = []
+        
+    # Convert path nodes to coordinates
+    route_coords = [
+        (G.nodes[node]['y'], G.nodes[node]['x']) 
+        for node in path
+    ]
+        
+    # Create features for each segment of the route
+    for i in range(len(route_coords) - 1):
+        segment = {
+                'type': 'Feature',
+                'geometry': {
+                    'type': 'LineString',
+                    'coordinates': [
+                        [route_coords[i][1], route_coords[i][0]],
+                        [route_coords[i+1][1], route_coords[i+1][0]]
+                    ]
+                },
+                'properties': {
+                    'times': [datetime.now().isoformat()],
+                    'style': {
+                        'color': color,
+                        'weight': weight,
+                        'opacity': 0.8
+                    }
+                }
+            }
+        features.append(segment)
+        timestamps.append(datetime.now().isoformat())
+        
+    return features
+
+def create_route_animation_data(G, path_time, path_length):
+    """Create animation data for route visualization"""
+    lst_start, lst_end = [], []
+    start_x, start_y = [], []
+    end_x, end_y = [], []
+    lst_length, lst_time = [], []
+    
+    # Process time-based path
+    for a, b in zip(path_time[:-1], path_time[1:]):
+        lst_start.append(a)
+        lst_end.append(b)
+        lst_length.append(round(G.edges[(a,b,0)]['length']))
+        lst_time.append(round(G.edges[(a,b,0)]['travel_time']))
+        start_x.append(G.nodes[a]['x'])
+        start_y.append(G.nodes[a]['y'])
+        end_x.append(G.nodes[b]['x'])
+        end_y.append(G.nodes[b]['y'])
+    
+    # Create DataFrame
+    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"})
+    
+    return df
+
+# Function to clean up temporary files
+@app.middleware("http")
+async def cleanup_temp_files(request: Request, call_next):
     temp_dir = 'temp'
     if os.path.exists(temp_dir):
         for file in os.listdir(temp_dir):
@@ -241,24 +289,13 @@ def cleanup_temp_files():
                         os.remove(file_path)
             except Exception as e:
                 print(f"Error cleaning up temp files: {e}")
+    
+    response = await call_next(request)
+    return response
 
-# 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"""
+    """API documentation homepage"""
     html_content = f"""
     <!DOCTYPE html>
     <html lang="en">
@@ -288,30 +325,30 @@ async def home():
 
         <h2>1. Find Nearby Stores (JSON Response)</h2>
         <pre>
-/api/stores/nearby?lat=18.9695&lon=72.8320&radius=1
+https://maps-yiv5.onrender.com/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
+https://maps-yiv5.onrender.com/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
+https://maps-yiv5.onrender.com/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 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
-/api/stores/route?user_lat=18.9701&user_lon=72.8330&store_lat=18.9695&store_lon=72.8320&viz_type=simple
+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
         </pre>
 
         <h2>Key Location Points in Dataset:</h2>
@@ -322,21 +359,20 @@ async def home():
             <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
+    return HTMLResponse(content=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")
+    radius: float = Query(5, description="Search radius in kilometers")
 ):
-    """Get nearby stores based on user location"""
+    """
+    Get nearby stores based on user location
+    """
     try:
         nearby_stores = store_locator.find_nearby_stores(lat, lon, radius)
         return {"status": "success", "stores": nearby_stores}
@@ -347,13 +383,12 @@ async def get_nearby_stores(
 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")
+    radius: float = Query(5, description="Search radius in kilometers")
 ):
-    """Get HTML map with store locations"""
+    """
+    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
@@ -396,31 +431,26 @@ async def get_stores_map(
         with open(file_path, 'w', encoding='utf-8') as f:
             f.write(html_content)
         
-        # Return the file as HTML response
-        return html_content
+        # Return the file
+        return FileResponse(file_path, media_type='text/html')
         
     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)")
+    user_lat: float = Query(..., description="Latitude of user location"),
+    user_lon: float = Query(..., description="Longitude of user location"),
+    store_lat: float = Query(..., description="Latitude of store location"),
+    store_lon: float = Query(..., description="Longitude of store location")
 ):
-    """Get route between user and store locations with visualization"""
+    """
+    Get route between user location and store
+    """
     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")
+            store_locator.initialize_graph((user_lat, user_lon))
         
         # Get nearest nodes
         start_node = ox.distance.nearest_nodes(
@@ -429,7 +459,7 @@ async def get_store_route(
             store_locator.network_graph, store_lon, store_lat)
         
         try:
-            # Calculate path using the travel_time weight
+            # Calculate paths
             path_time = nx.shortest_path(
                 store_locator.network_graph, 
                 start_node, 
@@ -437,285 +467,206 @@ async def get_store_route(
                 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(
+            # Create animation data
+            lst_start, lst_end = [], []
+            start_x, start_y = [], []
+            end_x, end_y = [], []
+            lst_length, lst_time = [], []
+
+            for a, b in zip(path_time[:-1], path_time[1:]):
+                lst_start.append(a)
+                lst_end.append(b)
+                lst_length.append(round(store_locator.network_graph.edges[(a,b,0)]['length']))
+                lst_time.append(round(store_locator.network_graph.edges[(a,b,0)]['travel_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
+            df_start = df[df["start"] == start_node]
+            df_end = df[df["end"] == end_node]
+
+            fig = px.scatter_mapbox(
+                data_frame=df, 
+                lon="start_x", 
+                lat="start_y",
+                zoom=15, 
+                width=1000, 
+                height=800,
+                animation_frame="id",
+                mapbox_style="carto-positron"
+            )
+
+            # Add driver marker
+            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",
-                    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
+                    lat="start_y"
+                ).data[0]
+            )
+
+            # Update layout with slower animation settings
+            fig.update_layout(
+                showlegend=False,
+                margin={"r":0,"t":0,"l":0,"b":0},
+                autosize=True,
+                height=None,
+                updatemenus=[{
+                    "type": "buttons",
+                    "showactive": False,
+                    "y": 0,
+                    "x": 0,
+                    "xanchor": "left",
+                    "yanchor": "bottom",
+                    "buttons": [
+                        {
+                            "label": "Play",
+                            "method": "animate",
+                            "args": [
+                                None,
+                                {
+                                    "frame": {"duration": 1000, "redraw": True},
+                                    "fromcurrent": True,
+                                    "transition": {"duration": 800}
+                                }
+                            ]
+                        },
+                        {
+                            "label": "Pause",
+                            "method": "animate",
+                            "args": [
+                                [None],
+                                {
+                                    "frame": {"duration": 0, "redraw": False},
+                                    "mode": "immediate",
+                                    "transition": {"duration": 0}
+                                }
+                            ]
+                        }
+                    ]
+                }],
+                sliders=[{
+                    "currentvalue": {"prefix": "Step: "},
+                    "pad": {"t": 20},
+                    "len": 0.9,
+                    "x": 0.1,
+                    "xanchor": "left",
+                    "y": 0.02,
+                    "yanchor": "bottom",
+                    "steps": [
+                        {
+                            "args": [
+                                [k],
+                                {
+                                    "frame": {"duration": 1000, "redraw": True},
+                                    "transition": {"duration": 500},
+                                    "mode": "immediate"
+                                }
+                            ],
+                            "label": str(k),
+                            "method": "animate"
+                        } 
+                        for k in range(len(df))
+                    ]
+                }]
+            )
+
+            # 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)}
+                </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 file
+            return FileResponse(file_path, media_type='text/html')
 
         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")
+    radius: float = Query(10, description="Search radius in kilometers")
 ):
-    """Get a map showing all stores in the given radius with colors based on distance"""
+    """
+    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],
@@ -740,14 +691,16 @@ async def get_all_store_locations(
             else:
                 color = 'blue'  # Further away
                 
-            # Create simplified popup content
+            # Create detailed popup content with mobile-friendly styling
             popup_content = f"""
             <div style='width: 200px; font-size: 14px;'>
                 <h4 style='color: {color}; margin: 0 0 8px 0;'>{store['store_name']}</h4>
+                <b>Address:</b> {store['address']}<br>
                 <b>Distance:</b> {store['distance']} km<br>
                 <b>Est. Delivery:</b> {store['estimated_delivery_time']} mins<br>
+                <b>Contact:</b> {store['contact']}<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'" 
+                <button onclick="window.location.href='/api/stores/route?user_lat={lat}&user_lon={lon}&store_lat={store['location']['lat']}&store_lon={store['location']['lon']}'" 
                         style='margin-top: 8px; padding: 8px; width: 100%; background-color: #007bff; color: white; border: none; border-radius: 4px;'>
                     Get Route
                 </button>
@@ -762,24 +715,24 @@ async def get_all_store_locations(
                 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 circle to show distance
+            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')]:
+        # Add distance circles from user location
+        for radius_circle, color in [(2000, 'red'), (5000, 'orange'), (radius * 1000, 'blue')]:
             folium.Circle(
                 location=[lat, lon],
-                radius=circle_radius,
+                radius=radius_circle,
                 color=color,
                 fill=False,
-                weight=1,dash_array='5, 5'
+                weight=1,
+                dash_array='5, 5'
             ).add_to(m)
         
         # Create mobile-friendly HTML content
@@ -854,36 +807,19 @@ async def get_all_store_locations(
         with open(file_path, 'w', encoding='utf-8') as f:
             f.write(html_content)
         
-        # Return the HTML content
-        return html_content
+        return FileResponse(file_path, media_type='text/html')
     
     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
+# Add swagger UI customization
+@app.on_event("startup")
+async def startup_event():
+    app.title = "Store Locator API"
+    app.description = "API for locating nearby stores and generating routes"
+    app.version = "1.0.0"
 
-# For running the application directly (development mode)
+# Entry point for running the application
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=8000)

dapp.py

@@ -0,0 +1,889 @@
+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(title="falcao-maps API", description="Store locator and route planning API")
+
+# 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=30000):  # 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)