.

app.py

@@ -17,7 +17,7 @@ with gr.Blocks(
         with gr.Row() as header:
                 gr.Markdown(
                     """
-                    ## 🚀 Search For You Next Trip
+                    ## Search For You Next Trip
                     """,
                 )
 
@@ -26,8 +26,10 @@ with gr.Blocks(
 
         with gr.Row() as metainfo:
             limit = gr.Slider(minimum=1, maximum=5, step=1, label="Limit", interactive=True, value=3)
-            days = gr.Textbox(label="Day", placeholder="YYYY-MM-DD")
-            time = gr.Textbox(label="Time", placeholder="hh:mm")
+            days = gr.Textbox(label="📅 Day", placeholder="YYYY-MM-DD")
+            time = gr.Textbox(label="🕒 Time", placeholder="hh:mm")
+            sustainable = gr.Checkbox(label="🌎 Sustainable", value=False)
+            outage = gr.Checkbox(label="🚧 Outage", value=False)
 
         submit = gr.Button(value="Search", variant="primary")
 
@@ -35,17 +37,10 @@ with gr.Blocks(
         with gr.Column(visible=False) as output:
             route = gr.Markdown()
 
-        def search(A, B, limit, day, time):
+        def search(A, B, limit, day, time, sustainable, outage):
             """Search for the best route from A to B"""
-            md = f"""
-            ---
 
-            🚀 **{A}** to 🏁 **{B}** at ⌚ **{time}** on 📅 **{day}**
-            
-            ---
-            """
-
-            md = get_best_path(A, B, day, time, limit)
+            md = get_best_path(A, B, day, time, limit, outage, sustainable)
 
             return {
                 output: gr.Column(visible=True),
@@ -54,7 +49,7 @@ with gr.Blocks(
 
         submit.click(
             search,
-            inputs=[A, B, limit, days, time],
+            inputs=[A, B, limit, days, time, sustainable, outage],
             outputs=[route, output]
         )
 

utils.py

@@ -38,12 +38,7 @@ PENALITIES = {
 
 def get_penalties(sustainability: bool):
     if sustainability:
-        PENALITIES["bike"] *= 1.1
-        PENALITIES["train"] *= 1.2
         PENALITIES["car"] *= 5
-    else:
-        PENALITIES["car"] *= 2
-
     return PENALITIES
 
 
@@ -76,13 +71,6 @@ def get_args():
     parser.add_argument(
         "--limit", type=int, default=3, help="Number of journeys to return"
     )
-    parser.add_argument(
-        "--transportations",
-        type,
-        choices=transportation_types,
-        default=["train"],
-        help=transportation_help,
-    )
     parser.add_argument("--exact-travel-time", action="store_true", help=time_help)
     parser.add_argument(
         "--change-penalty", type=int, default=300, help="Change penalty"
@@ -199,6 +187,7 @@ def dijkstra(G, start, end, start_time, change_penalty=300, mode_penalties=PENAL
         node: {
             "distance": float("infinity"),
             "time": start_time,
+            "visited": False,
         }
         for node in list(G.nodes())
     }
@@ -207,7 +196,7 @@ def dijkstra(G, start, end, start_time, change_penalty=300, mode_penalties=PENAL
     edges_to = {node: None for node in list(G.nodes())}
 
     # Set the distance from the start node to itself to 0
-    distances[start]["distance"] = 0
+    distances[start] = {"distance": 0, "time": start_time, "visited": True}
     edges_to[start] = ("", "Start", {"type": "foot", "journey_id": None, "duration": 0})
 
     # Priority queue to keep track of nodes with their current distances
@@ -218,7 +207,7 @@ def dijkstra(G, start, end, start_time, change_penalty=300, mode_penalties=PENAL
         current_distance, current_node = heapq.heappop(priority_queue)
 
         if current_node == end:
-            return distances[end], edges_to
+            return distances, edges_to
 
         # Check if the current distance is smaller than the stored distance
         if current_distance > distances[current_node]["distance"]:
@@ -247,8 +236,11 @@ def dijkstra(G, start, end, start_time, change_penalty=300, mode_penalties=PENAL
                 train_departed = (
                     distances[current_node]["time"] > attributes["departure"]
                 )
+                train_too_far_away = (
+                    distances[current_node]["time"] - attributes["departure"]
+                ).total_seconds() > 60 * 60 * 1
 
-                if train_departed:
+                if train_departed or train_too_far_away:
                     continue
 
                 if prev_is_train:
@@ -263,24 +255,36 @@ def dijkstra(G, start, end, start_time, change_penalty=300, mode_penalties=PENAL
             # Add max of waiting time or changing penalty to current dist
             if changed_mode or changed_trip:
                 distance += max(wait, change_penalty)
+            elif next_is_train:
+                distance += wait
 
             # Overall dist (prev dist + dist to neighbor)
-            distance = current_distance + distance
+            total_distance = current_distance + distance
 
             # If the new distance is smaller, update the distance and add to the priority queue
-            if distance < distances[neighbor]["distance"]:
+            if total_distance < distances[neighbor]["distance"]:
                 # Update distance and time of arrival for neighbor
                 time_of_arrival = distances[current_node]["time"] + pd.Timedelta(
                     seconds=distance
                 )
-                distances[neighbor]["distance"] = distance
+                # print(f"Arrived at {neighbor} at {time_of_arrival}")
+                distances[neighbor]["distance"] = total_distance
                 distances[neighbor]["time"] = time_of_arrival
+                distances[neighbor]["visited"] = True
+
+                # for _, nneighbor, attributes in G.out_edges(neighbor, data=True):
+                #     if nneighbor != current_node:
+                #         distances[nneighbor]["visited"] = False
 
                 # Add edge that leads to neighbor
-                edges_to[neighbor] = (current_node, neighbor, attributes)
+                edges_to[neighbor] = (
+                    current_node,
+                    neighbor,
+                    attributes,
+                )
 
                 # Update priority queue
-                heapq.heappush(priority_queue, (distance, neighbor))
+                heapq.heappush(priority_queue, (total_distance, neighbor))
 
     print(f"Probably there is no path between {start} and {end}")
 
@@ -396,8 +400,16 @@ def pretty_print(edges, args):
             dst = args.end
 
         duration = pretty_time_delta(attr["duration"])
+        departure = attr.get("departure", None)
+        arrival = attr.get("arrival", None)
+
+        msg = f"{i+1}. Go by {attr['type']} from {src} to {dst} for {duration}."
+        if attr["type"] == "train":
+            msg += "\n   -> Take {} ({} - {})".format(
+                attr["trip_name"], departure, arrival
+            )
+        print(msg)
 
-        print(f"{i+1}. Go by {attr['type']} from {src} to {dst} for {duration}")
 
 """
     Remove all the trains from one station to another to simulate an outage.
@@ -419,10 +431,12 @@ def remove_all_trains(G, from_station, to_station):
 
 
 def get_final_path_md(edges, start, end, date, time, sustainability):
-    
     md = f"## Your Journey from {start} to {end}\n\n"
+
     md += f"📅 Date/ Time: {date} at {time}\n"
-    md += "### Travel Information\n"
+    md += f"🌍 Sustainable?: {sustainability}\n\n"
+
+    md += "\n### Travel Information\n"
 
     for i, (src, dst, attr) in enumerate(edges):
         if src == "Start":
@@ -431,23 +445,44 @@ def get_final_path_md(edges, start, end, date, time, sustainability):
             dst = end
 
         duration = pretty_time_delta(attr["duration"])
+        departure = attr.get("departure", None)
+        arrival = attr.get("arrival", None)
+
+        emoji = {
+            "foot": "🚶",
+            "bike": "🚴",
+            "car": "🚗",
+            "train": "🚆",
+        }
+
+        msg = f"{i+1}. {emoji[attr['type']]} Go by {attr['type']} from {src} to {dst} for {duration}.\n"
+        if attr["type"] == "train":
+            msg += "   -> Take {} ({} - {})\n".format(
+                attr["trip_name"], departure, arrival
+            )
 
-        travel_type = attr['type']
-        emoji = "🚉" if travel_type == "train" else "🚗" if travel_type == "car" else "🚶" if travel_type == "foot" else "🚀"
+        md += msg
 
-        md += f"{i+1}. {emoji} Go by {travel_type} from {src} to {dst} for {duration}\n\n"
-    
     return md
 
-def get_best_path(start, end, date, time, limit, exact_travel_time=False, outage=False, sustainability=False, change_penalty=300):
-    
+
+def get_best_path(
+    start,
+    end,
+    date,
+    time,
+    limit,
+    outage=False,
+    sustainability=False,
+    change_penalty=300,
+):
     # Load graph
     with open("graph.pkl", "rb") as f:
         G = pickle.load(f)
 
     if outage:
         # Remove all the edges from 2 stations to simulate an outage
-        remove_all_trains(G, from_station="St-Maurice", to_station="Martigny")
+        remove_all_trains(G, from_station="Renens VD", to_station="Lausanne")
 
     # Convert start and destination to location (lon, lat)
     start_loc = get_location(G, start)
@@ -463,36 +498,24 @@ def get_best_path(start, end, date, time, limit, exact_travel_time=False, outage
     for station, attr in G.nodes(data=True):
         try:
             station_pos = attr["pos"]
-            dists_from_start.append(
-                (station, get_distance(start_loc, station_pos))
-            )
+            dists_from_start.append((station, get_distance(start_loc, station_pos)))
             dists_to_end.append((station, get_distance(end_loc, station_pos)))
         except Exception as e:
             continue
 
     # Sort the distances in place
-    start_k_closest = sorted(dists_from_start, key=lambda x: x[1])[: limit]
-    end_k_closest = sorted(dists_to_end, key=lambda x: x[1])[: limit]
+    start_k_closest = sorted(dists_from_start, key=lambda x: x[1])[:limit]
+    end_k_closest = sorted(dists_to_end, key=lambda x: x[1])[:limit]
 
     # Compute travel time from start to k closest stations
     for mode in ["foot", "bike", "car"]:
         for station, dist in start_k_closest:
-            if exact_travel_time:
-                travel_time = get_exact_travel_time(
-                    start_loc, station, method=mode
-                )
-                G.add_edge("Start", station, duration=travel_time, type=mode)
-            else:
-                travel_time = get_approx_travel_time(dist, method=mode)
-                G.add_edge("Start", station, duration=travel_time, type=mode)
+            travel_time = get_approx_travel_time(dist, method=mode)
+            G.add_edge("Start", station, duration=travel_time, type=mode)
 
         for station, dist in end_k_closest:
-            if exact_travel_time:
-                travel_time = get_exact_travel_time(dist, method=mode)
-                G.add_edge(station, "End", duration=travel_time, type=mode)
-            else:
-                travel_time = get_approx_travel_time(dist, method=mode)
-                G.add_edge(station, "End", duration=travel_time, type=mode)
+            travel_time = get_approx_travel_time(dist, method=mode)
+            G.add_edge(station, "End", duration=travel_time, type=mode)
 
     # Run Dijkstra on graph
     start_time = pd.to_datetime(f"{date} {time}")
@@ -512,7 +535,6 @@ def get_best_path(start, end, date, time, limit, exact_travel_time=False, outage
     # Postprocess path
     path = postprocess_path(edges[:-1])
 
-    # Print journey
     md = get_final_path_md(path, start, end, date, time, sustainability)
 
-    return md
+    return md