Update app.py

app.py

@@ -1,17 +1,22 @@
 import streamlit as st
-import requests
-import osmnx as ox
-import geopandas as gpd
-import folium
-from shapely.ops import unary_union, polygonize
-import pandas as pd
-import numpy as np
-from matplotlib.colors import LinearSegmentedColormap, to_hex
-import networkx as nx
-from streamlit_folium import st_folium
-
-def fetch_station_data(station: str, time_limit: int) -> gpd.GeoDataFrame:
+import logging
+import warnings
+
+# Disable usage statistics collection message
+st.set_option('browser.gatherUsageStats', False)
+# Suppress Streamlit missing ScriptRunContext warnings
+logging.getLogger("streamlit.runtime.scriptrunner_utils").setLevel(logging.ERROR)
+# Suppress all warnings for a cleaner output
+warnings.filterwarnings("ignore")
+
+# Lazy import heavy libraries inside functions to speed up startup
+
+def fetch_station_data(station: str, time_limit: int):
     """Fetch station travel-time data via API and return as GeoDataFrame."""
+    import requests
+    import pandas as pd
+    import geopandas as gpd
+
     api_url = (
         f"https://api.nearby-map.com/search_stations"
         f"?station={station}&time_limit={time_limit}&max_transfer=2"
@@ -34,61 +39,75 @@ def fetch_station_data(station: str, time_limit: int) -> gpd.GeoDataFrame:
         crs="EPSG:4326",
     )
 
-def build_isochrone_polygons(
-    stations_gdf: gpd.GeoDataFrame,
-    travel_speeds_kmh: float,
-    time_limits: list[int]
-) -> gpd.GeoDataFrame:
-    """Generate isochrone polygons for each time limit."""
-    cmap = LinearSegmentedColormap.from_list("iso", ["green", "yellow", "orange", "red"], N=len(time_limits))
+
+def build_isochrone_polygons(stations_gdf, travel_speeds_kmh, time_limits):
+    """Generate isochrone polygons using a single pre-fetched graph to limit map data retrieval."""
+    # Lazy imports
+    import pandas as pd
+    import numpy as np
+    from matplotlib.colors import LinearSegmentedColormap, to_hex
+    import networkx as nx
+    import osmnx as ox
+    import geopandas as gpd
+    from shapely.ops import unary_union, polygonize
+
+    # Determine global max remaining time
+    min_travel = stations_gdf['travel_time'].min()
+    max_time_lim = max(time_limits)
+    max_remaining = max_time_lim - min_travel
+    if max_remaining <= 0:
+        return gpd.GeoDataFrame(columns=['time','color','geometry'], crs='EPSG:4326')
+
+    # Compute max distance (meters)
+    max_distance = max_remaining * travel_speeds_kmh * 1000 / 60
+    # Center at mean coordinates
+    center_lat = stations_gdf.geometry.y.mean()
+    center_lon = stations_gdf.geometry.x.mean()
+
+    # Prefetch graph once within bounding radius
+    G = ox.graph_from_point((center_lat, center_lon), dist=max_distance * 1.2, network_type='walk')
+    # Project and set edge travel time attribute
+    G = ox.project_graph(G)
+    mpm = travel_speeds_kmh * 1000 / 60
+    for u, v, k, data in G.edges(keys=True, data=True):
+        data['time'] = data['length'] / mpm
+
+    # Prepare colormap
+    cmap = LinearSegmentedColormap.from_list('iso', ['green','yellow','orange','red'], N=len(time_limits))
     colors = [to_hex(cmap(i)) for i in np.linspace(0, 1, len(time_limits))]
 
-    def single_isochrone(total_min: int) -> gpd.GeoDataFrame | None:
-        """Generate a single isochrone for a total travel time."""
+    iso_list = []
+    # Generate isochrones for each time limit
+    for total_min in time_limits:
         polys = []
         for _, row in stations_gdf.iterrows():
-            remaining = total_min - row["travel_time"]
-            if remaining <= 0:
-                continue
-            max_distance = remaining * travel_speeds_kmh * 1000 / 60
-            graph = ox.graph_from_point(
-                (row["latitude"], row["longitude"]),
-                dist=max_distance * 1.2,
-                network_type="walk"
-            )
-            if not graph.edges:
+            rem = total_min - row['travel_time']
+            if rem <= 0:
                 continue
-            center_node = ox.nearest_nodes(graph, row["longitude"], row["latitude"])
-            graph = ox.project_graph(graph)
-            meters_per_minute = travel_speeds_kmh * 1000 / 60
-            for u, v, k, data in graph.edges(keys=True, data=True):
-                data["time"] = data["length"] / meters_per_minute
-            subgraph = nx.ego_graph(graph, center_node, radius=remaining, distance="time")
-            if not subgraph.edges:
+            # Find nearest node in pre-fetched graph
+            node = ox.nearest_nodes(G, row['longitude'], row['latitude'])
+            # Extract subgraph reachable within 'rem' minutes
+            sub = nx.ego_graph(G, node, radius=rem, distance='time')
+            if not sub.edges:
                 continue
-            edges_gdf = ox.graph_to_gdfs(subgraph, nodes=False, edges=True)
+            edges_gdf = ox.graph_to_gdfs(sub, nodes=False, edges=True)
             if edges_gdf.empty:
                 continue
-            merged_lines = edges_gdf["geometry"].unary_union
-            polygons = list(polygonize(merged_lines))
-            if not polygons:
-                continue
-            polys.extend(polygons)
+            merged = edges_gdf['geometry'].unary_union
+            polys.extend(polygonize(merged))
         if polys:
             unified = unary_union(polys)
             gdf_iso = gpd.GeoDataFrame(
-                {"time": [total_min], "color": [colors[time_limits.index(total_min)]]},
+                {'time': [total_min], 'color': [colors[time_limits.index(total_min)]]},
                 geometry=[unified],
-                crs=graph.graph["crs"]
-            )
-            return gdf_iso.to_crs(epsg=4326)
-        return None
+                crs=G.graph['crs']
+            ).to_crs(epsg=4326)
+            iso_list.append(gdf_iso)
+
+    if iso_list:
+        return gpd.GeoDataFrame(pd.concat(iso_list, ignore_index=True), crs='EPSG:4326')
+    return gpd.GeoDataFrame(columns=['time','color','geometry'], crs='EPSG:4326')
 
-    iso_list = [single_isochrone(t) for t in time_limits]
-    gdfs = [g for g in iso_list if g is not None]
-    if gdfs:
-        return gpd.GeoDataFrame(pd.concat(gdfs, ignore_index=True), crs="EPSG:4326")
-    return gpd.GeoDataFrame(columns=["time","color","geometry"], crs="EPSG:4326")
 
 def main():
     """Streamlit application entrypoint."""
@@ -103,9 +122,15 @@ def main():
                 st.warning("No station data.")
                 return
             time_values = list(range(step, max_time + 1, step))
-            iso_gdf = build_isochrone_polygons(stations, travel_speeds_kmh=4.8, time_limits=time_values)
-            map_center = [stations.geometry.y.mean(), stations.geometry.x.mean()]
-            fmap = folium.Map(location=map_center, zoom_start=12)
+            iso_gdf = build_isochrone_polygons(
+                stations, travel_speeds_kmh=4.8, time_limits=time_values
+            )
+            # Lazy import folium and streamlit_folium
+            import folium
+            from streamlit_folium import st_folium
+
+            center = [stations.geometry.y.mean(), stations.geometry.x.mean()]
+            fmap = folium.Map(location=center, zoom_start=12)
             for _, row in iso_gdf.iterrows():
                 folium.GeoJson(
                     row.geometry,