Update app.py

app.py

@@ -11,14 +11,7 @@ import networkx as nx
 from streamlit_folium import st_folium
 
 def fetch_station_data(station: str, time_limit: int) -> gpd.GeoDataFrame:
-    """
-    Fetch station travel-time data via API and return as GeoDataFrame.
-    Args:
-        station (str): Station name to query.
-        time_limit (int): Maximum travel time (minutes).
-    Returns:
-        gpd.GeoDataFrame: station points with 'travel_time' and geometry.
-    """
+    """Fetch station travel-time data via API and return as GeoDataFrame."""
     api_url = (
         f"https://api.nearby-map.com/search_stations"
         f"?station={station}&time_limit={time_limit}&max_transfer=2"
@@ -29,15 +22,12 @@ def fetch_station_data(station: str, time_limit: int) -> gpd.GeoDataFrame:
         return gpd.GeoDataFrame()
     items = res.json().get("data", [])
     df = pd.DataFrame(items)
-    df.rename(
-        columns={
-            "name": "station_name",
-            "time": "travel_time",
-            "lat": "latitude",
-            "lon": "longitude",
-        },
-        inplace=True,
-    )
+    df.rename(columns={
+        "name": "station_name",
+        "time": "travel_time",
+        "lat": "latitude",
+        "lon": "longitude",
+    }, inplace=True)
     return gpd.GeoDataFrame(
         df,
         geometry=gpd.points_from_xy(df.longitude, df.latitude),
@@ -49,68 +39,73 @@ def build_isochrone_polygons(
     travel_speeds_kmh: float,
     time_limits: list[int]
 ) -> gpd.GeoDataFrame:
-    """
-    Generate isochrone polygons for each time limit.
-    Args:
-        stations_gdf (gpd.GeoDataFrame): Stations with travel_time.
-        travel_speeds_kmh (float): Walking speed in km/h.
-        time_limits (list[int]): List of total travel times (min).
-    Returns:
-        gpd.GeoDataFrame: Polygons with 'time' and 'color'.
-    """
-    # 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))]
+    """Generate isochrone polygons for each time limit."""
+    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):
+    def single_isochrone(total_min: int) -> gpd.GeoDataFrame | None:
+        """Generate a single isochrone for a total travel time."""
         polys = []
         for _, row in stations_gdf.iterrows():
-            rem = total_min - row["travel_time"]
-            if rem <= 0:
+            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:
+                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:
                 continue
-            maxd = rem * travel_speeds_kmh*1000/60  # meters
-            G = ox.graph_from_point((row["latitude"], row["longitude"]), dist=maxd*1.2, network_type="walk")
-            if not G.edges:
+            edges_gdf = ox.graph_to_gdfs(subgraph, nodes=False, edges=True)
+            if edges_gdf.empty:
                 continue
-            center = ox.nearest_nodes(G, row["longitude"], row["latitude"])
-            G = ox.project_graph(G)
-            mpm = travel_speeds_kmh*1000/60
-            for u,v,k,d in G.edges(keys=True, data=True):
-                d["time"] = d["length"]/mpm
-            sub = nx.ego_graph(G, center, radius=rem, distance="time")
-            if not sub.edges:
+            merged_lines = edges_gdf["geometry"].unary_union
+            polygons = list(polygonize(merged_lines))
+            if not polygons:
                 continue
-            edges = ox.graph_to_gdfs(sub, nodes=False, edges=True)["geometry"]
-            merged = unary_union(edges.unary_union)
-            polys += list(polygonize(merged))
+            polys.extend(polygons)
         if polys:
-            uni = unary_union(polys)
-            g = gpd.GeoDataFrame(
+            unified = unary_union(polys)
+            gdf_iso = gpd.GeoDataFrame(
                 {"time": [total_min], "color": [colors[time_limits.index(total_min)]]},
-                geometry=[uni],
-                crs=G.graph["crs"]
-                )
-
-            return g.to_crs(epsg=4326)
+                geometry=[unified],
+                crs=graph.graph["crs"]
+            )
+            return gdf_iso.to_crs(epsg=4326)
         return None
 
     iso_list = [single_isochrone(t) for t in time_limits]
-    return gpd.GeoDataFrame(pd.concat([g for g in iso_list if g is not None], ignore_index=True))
+    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."""
     st.title("Isochrone Map Demo")
-    station = st.text_input("Station name", "溜池山王")
+    station_name = st.text_input("Station name", "溜池山王")
     max_time = st.slider("Max travel time (min)", 10, 60, 30, 10)
-    step = st.selectbox("Time step (min)", [5,10,15], index=1)
-    if st.button("Generate Map"):
+    step = st.selectbox("Time step (min)", [5, 10, 15], index=1)
+    if st.button("Generate Map"]):
         with st.spinner("Calculating…"):
-            stations = fetch_station_data(station, max_time)
+            stations = fetch_station_data(station_name, max_time)
             if stations.empty:
                 st.warning("No station data.")
                 return
-            times = list(range(step, max_time+1, step))
-            iso_gdf = build_isochrone_polygons(stations, travel_speeds_kmh=4.8, time_limits=times)
-            m = folium.Map(location=[stations.geometry.y.mean(), stations.geometry.x.mean()], zoom_start=12)
+            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)
             for _, row in iso_gdf.iterrows():
                 folium.GeoJson(
                     row.geometry,
@@ -120,13 +115,18 @@ def main():
                         "weight": 2,
                         "fillOpacity": 0.2,
                     },
-                ).add_to(m)
+                ).add_to(fmap)
             for _, row in stations.iterrows():
                 folium.Marker(
                     [row["latitude"], row["longitude"]],
                     popup=f"{row['station_name']} ({int(row['travel_time'])}分)"
-                ).add_to(m)
-            st_folium(m, width=700, height=500)
+                ).add_to(fmap)
+            st_folium(fmap, width=700, height=500)
 
+# Allow script to be run directly with "python app.py"
 if __name__ == "__main__":
-    main()
+    import sys
+    from streamlit.web import cli as stcli
+
+    sys.argv = ["streamlit", "run", sys.argv[0]]
+    sys.exit(stcli.main())