Update app.py

regreso a la versión anterior porque la nueva no funciono :'/

app.py

@@ -5,12 +5,11 @@ import geopandas as gpd
 from shapely.geometry import LineString, Point
 import folium
 from streamlit_folium import st_folium
-import networkx as nx
-from collections import defaultdict  # Add this line if missing
+
 import os, sys
 import traceback
 
-print(">>> Ejecutando archivo:", os.path.abspath(__file__))
+print(">>> Ejecutando archivo:", os.path.abspath(_file_))
 print("Python ejecutado:", sys.executable)
 
 # Cargar shapes.txt manteniendo la precisión
@@ -32,191 +31,108 @@ shapes_gdf.columns = ["shape_id", "geometry"]
 crs_obj = CRS.from_epsg(4326)  # Crea el objeto CRS correctamente
 shapes_gdf = gpd.GeoDataFrame(shapes_gdf, geometry="geometry", crs=crs_obj)
 
-# Precompute graph for routing
-route_short = routes.set_index('route_id')['route_short_name'].to_dict()
-stops_routes = defaultdict(set)
-G = nx.DiGraph()
-
-# Group by route_id and shape_id to capture variants/directions
-group_cols = ['route_id', 'shape_id']
-trips_grouped = trips.groupby(group_cols)
-
-transfer_penalty = 20
-
-for name, group in trips_grouped:
-    if group.empty:
-        continue
-    route_id, shape_id = name
-    trip_id_sample = group['trip_id'].iloc[0]
-    stops_trip = stop_times[stop_times['trip_id'] == trip_id_sample].sort_values('stop_sequence')
-    stop_ids = stops_trip['stop_id'].tolist()
-    
-    # Add routes to stops
-    for stop_id in stop_ids:
-        stops_routes[stop_id].add(route_id)
-    
-    # Add ride edges
-    for i in range(len(stop_ids) - 1):
-        stop1 = stop_ids[i]
-        stop2 = stop_ids[i + 1]
-        G.add_edge((stop1, route_id), (stop2, route_id), weight=1)
-
-# Add transfer edges
-for stop_id, routes_set in stops_routes.items():
-    routes_list = list(routes_set)
-    for i in range(len(routes_list)):
-        for j in range(len(routes_list)):
-            if i != j:
-                G.add_edge((stop_id, routes_list[i]), (stop_id, routes_list[j]), weight=transfer_penalty)
-
-# UI
+# =========================
+#   UI
+# =========================
 st.title("🚍 Planificador inteligente — TransMilenio")
-st.write("Esta app detecta si la ruta **en la que ya vas** te sirve para llegar al destino, y sugiere transbordos si es necesario.")
 
-# Inputs
+st.write("Esta app detecta si la ruta *en la que ya vas* te sirve para llegar al destino.")
+
+
+# =========================
+#   INPUTS DEL USUARIO
+# =========================
+
 st.header("1️⃣ ¿En qué ruta vas?")
-ruta_seleccionada = st.selectbox("Selecciona tu ruta", routes.route_short_name.unique())
+ruta_seleccionada = st.selectbox(
+    "Selecciona tu ruta",
+    routes.route_short_name.unique(),
+)
 
 st.header("2️⃣ ¿Dónde estás?")
 col1, col2 = st.columns(2)
 with col1:
     modo_origen = st.radio("Selecciona cómo indicar dónde estás:", ["Parada", "Coordenadas"])
 
-route_id = routes.loc[routes.route_short_name == ruta_seleccionada, "route_id"].iloc[0]
-trips_ruta = trips[trips.route_id == route_id]
-
-if trips_ruta.empty:
-    st.error("No se encontraron viajes para esta ruta.")
-    st.stop()
-
-# Get all unique stops for the route across all trips
-trip_ids = trips_ruta['trip_id'].unique()
-all_stops_route = stop_times[stop_times['trip_id'].isin(trip_ids)].merge(stops, on="stop_id")['stop_name'].unique()
-
 if modo_origen == "Parada":
-    parada_origen = st.selectbox("Selecciona tu parada actual", all_stops_route)
+    parada_origen = st.selectbox("Selecciona tu parada actual", stops.stop_name.unique())
     stop_actual = stops[stops.stop_name == parada_origen].iloc[0]
-    current_stop_id = stop_actual['stop_id']
+
 else:
     lat = st.number_input("Latitud", value=4.65)
     lon = st.number_input("Longitud", value=-74.1)
-    # Find nearest stop among all stops on the route
-    all_stops_route_df = stop_times[stop_times['trip_id'].isin(trip_ids)].merge(stops, on="stop_id").drop_duplicates('stop_id')
-    stops_route_gdf = gpd.GeoDataFrame(all_stops_route_df, geometry=gpd.points_from_xy(all_stops_route_df.stop_lon, all_stops_route_df.stop_lat), crs=4326)
-    user_point = Point(lon, lat)
-    distances = stops_route_gdf.geometry.distance(user_point)
-    nearest_idx = distances.argmin()
-    stop_actual = stops_route_gdf.iloc[nearest_idx]
-    current_stop_id = stop_actual['stop_id']
-    st.write(f"Parada más cercana detectada: {stop_actual.stop_name}")
+    stop_actual = {"stop_lat": lat, "stop_lon": lon}
+
 
 st.header("3️⃣ ¿A dónde vas?")
 destino = st.text_input("Escribe la parada o dirección de destino")
 
 calcular = st.button("Calcular ruta")
 
+# =========================
+#   PROCESAMIENTO
+# =========================
+
 if calcular:
-    # Find a trip that includes the current stop (to determine variant)
-    relevant_trips = stop_times[(stop_times['stop_id'] == current_stop_id) & (stop_times['trip_id'].isin(trip_ids))]['trip_id'].unique()
-    if len(relevant_trips) == 0:
-        st.error("La parada actual no está en esta ruta.")
+
+    # ---- 1. Filtrar rutas por route_short_name ----
+    route_id = routes.loc[routes.route_short_name == ruta_seleccionada, "route_id"].iloc[0]
+    trips_ruta = trips[trips.route_id == route_id]
+
+    if trips_ruta.empty:
+        st.error("No se encontraron viajes para esta ruta.")
         st.stop()
-    trip_id = relevant_trips[0]  # Pick first matching trip
-    st.write(f"Usando trip: `{trip_id}`")
 
-    stops_trip = stop_times[stop_times.trip_id == trip_id].merge(stops, on="stop_id").sort_values('stop_sequence')
+    # ---- 2. Seleccionar un trip (en GTFS cada ruta tiene varios) ----
+    trip_id = trips_ruta.iloc[0].trip_id
+    st.write(f"Usando trip: {trip_id}")
 
-    # Current sequence
-    current_sequence = stops_trip[stops_trip.stop_id == current_stop_id]['stop_sequence'].iloc[0]
+    stops_trip = stop_times[stop_times.trip_id == trip_id].merge(stops, on="stop_id")
 
-    # Find destination
-    destino_results = stops[stops.stop_name.str.contains(destino, case=False, na=False)]
-    if destino_results.empty:
-        st.error("No se encontró la parada de destino. Intenta con otro nombre.")
-        st.stop()
-    destino_stop = destino_results.iloc[0]
-    destination_id = destino_stop['stop_id']
-    st.write(f"Destino interpretado como: {destino_stop.stop_name}")
-
-    # Direct check
-    destino_in_trip = stops_trip[(stops_trip.stop_id == destination_id) & (stops_trip.stop_sequence > current_sequence)]
-    if not destino_in_trip.empty:
-        dest_seq = destino_in_trip['stop_sequence'].iloc[0]
-        num_paradas = dest_seq - current_sequence
-        st.success(f"Esta ruta **SÍ** te sirve directamente. Debes bajarte en {num_paradas} paradas: **{destino_stop.stop_name}**")
-        parada_destino = destino_stop
+    # ---- 3. Buscar destino por nombre aproximado ----
+    destino_results = stops_trip[stops_trip.stop_name.str.contains(destino, case=False, na=False)]
+
+    if not destino_results.empty:
+        parada_destino = destino_results.iloc[0]
+        st.success(f"Esta ruta *SÍ* te sirve. Debes bajarte en: *{parada_destino.stop_name}*")
     else:
-        # Graph routing
-        source = (current_stop_id, route_id)
-        targets = [(destination_id, r) for r in stops_routes[destination_id]]
-        
-        paths = {}
-        for t in targets:
-            try:
-                path = nx.shortest_path(G, source, t, weight='weight')
-                cost = nx.shortest_path_length(G, source, t, weight='weight')
-                paths[cost] = path
-            except nx.NetworkXNoPath:
-                pass
-        
-        if paths:
-            min_cost = min(paths.keys())
-            best_path = paths[min_cost]
-            
-            # Reconstruct legs
-            legs = []
-            current_leg_route = best_path[0][1]
-            start_stop_id = best_path[0][0]
-            leg_stops = 0
-            for i in range(1, len(best_path)):
-                next_stop_id, next_route = best_path[i]
-                if next_route != current_leg_route:
-                    from_name = stops[stops.stop_id == start_stop_id]['stop_name'].iloc[0]
-                    to_name = stops[stops.stop_id == best_path[i-1][0]]['stop_name'].iloc[0]
-                    legs.append({
-                        'route': route_short[current_leg_route],
-                        'from': from_name,
-                        'to': to_name,
-                        'num_paradas': leg_stops
-                    })
-                    start_stop_id = best_path[i-1][0]
-                    current_leg_route = next_route
-                    leg_stops = 0
-                leg_stops += 1
-            # Last leg
-            from_name = stops[stops.stop_id == start_stop_id]['stop_name'].iloc[0]
-            to_name = stops[stops.stop_id == best_path[-1][0]]['stop_name'].iloc[0]
-            legs.append({
-                'route': route_short[current_leg_route],
-                'from': from_name,
-                'to': to_name,
-                'num_paradas': leg_stops
-            })
-            
-            # Recommendation
-            rec = "Ruta recomendada:\n"
-            for idx, leg in enumerate(legs):
-                if idx == 0:
-                    rec += f"- Vas en {leg['route']} desde {leg['from']}, bájate en {leg['num_paradas']} paradas en {leg['to']}.\n"
-                else:
-                    rec += f"- Luego, en {leg['from']}, toma {leg['route']} y bájate en {leg['num_paradas']} paradas en {leg['to']}.\n"
-            st.success(rec)
-            parada_destino = destino_stop
-        else:
-            st.warning("No se encontró ruta con transbordos.")
-            parada_destino = None
-
-    # Map
+        st.warning("Esta ruta NO te lleva directamente al destino. (Transbordos: próximo paso)")
+        parada_destino = None
+
+    # =========================
+    #   MAPA
+    # =========================
+
     st.header("🗺️ Mapa de tu ruta y posición")
+
+    # Crear mapa centrado en la posición actual
     m = folium.Map(location=[stop_actual["stop_lat"], stop_actual["stop_lon"]], zoom_start=13)
-    folium.Marker([stop_actual["stop_lat"], stop_actual["stop_lon"]], tooltip="Estás aquí", icon=folium.Icon(color="blue")).add_to(m)
-    
-    # Draw shape
-    shape_id = trips[trips.trip_id == trip_id]['shape_id'].iloc[0]
+
+    # ---- Marcar posición actual ----
+    folium.Marker(
+        [stop_actual["stop_lat"], stop_actual["stop_lon"]],
+        tooltip="Estás aquí",
+        icon=folium.Icon(color="blue")
+    ).add_to(m)
+
+    # ---- Dibujar route shape ----
+    # Buscar shape_id asociado
+    shape_id = trips_ruta.iloc[0].shape_id
     shape_geom = shapes_gdf[shapes_gdf.shape_id == shape_id].geometry.iloc[0]
-    folium.PolyLine(locations=[(lat, lon) for lon, lat in zip(shape_geom.coords.xy[0], shape_geom.coords.xy[1])], weight=5, color="red", tooltip=f"Ruta {ruta_seleccionada}").add_to(m)
-    
+
+    folium.PolyLine(
+        locations=[(lat, lon) for lon, lat in zip(shape_geom.coords.xy[0], shape_geom.coords.xy[1])],
+        weight=5,
+        color="red",
+        tooltip=f"Ruta {ruta_seleccionada}"
+    ).add_to(m)
+
+    # ---- Marcar destino si existe----
     if parada_destino is not None:
-        folium.Marker([parada_destino.stop_lat, parada_destino.stop_lon], tooltip=f"Destino: {parada_destino.stop_name}", icon=folium.Icon(color="green")).add_to(m)
-    
+        folium.Marker(
+            [parada_destino.stop_lat, parada_destino.stop_lon],
+            tooltip=f"Destino: {parada_destino.stop_name}",
+            icon=folium.Icon(color="green")
+        ).add_to(m)
+
     st_folium(m, width=700, height=500)