Update app.py

app.py

@@ -1,62 +1,162 @@
 import gradio as gr
 import pandas as pd
 import numpy as np
+import requests
+from geopy.geocoders import Nominatim
+from geopy.extra.rate_limiter import RateLimiter
 from ortools.constraint_solver import pywrapcp, routing_enums_pb2
+import folium
+from folium.plugins import AntPath
 
-def optimize_route(address_text):
+# -------------------------------------------
+# 1. Geocoding Function (Address -> Lat/Lon)
+# -------------------------------------------
 
-    # Parse addresses
-    addresses = [a.strip() for a in address_text.split("\n") if a.strip()]
-    if len(addresses) < 2:
-        return "❌ Please enter at least two locations.", None
+geolocator = Nominatim(user_agent="procelevate_route_planner")
+geocode = RateLimiter(geolocator.geocode, min_delay_seconds=1)
+
+def get_coordinates(address):
+    loc = geocode(address)
+    if loc:
+        return (loc.latitude, loc.longitude)
+    return None
+
+
+# -------------------------------------------
+# 2. OSRM Distance API
+# -------------------------------------------
+
+def osrm_distance(coord1, coord2):
+    url = f"http://router.project-osrm.org/route/v1/driving/{coord1[1]},{coord1[0]};{coord2[1]},{coord2[0]}?overview=false"
+    res = requests.get(url).json()
+    if "routes" in res:
+        d = res["routes"][0]["distance"]  # meters
+        t = res["routes"][0]["duration"]  # seconds
+        return d, t
+    return None, None
+
+
+# -------------------------------------------
+# 3. Build Distance & Time Matrix
+# -------------------------------------------
 
-    # Generate fake symmetric distance matrix (Phase 1 demo)
-    n = len(addresses)
-    np.random.seed(42)
-    distance_matrix = np.random.randint(5, 50, size=(n, n))
-    np.fill_diagonal(distance_matrix, 0)
+def build_matrices(coords):
+    n = len(coords)
+    dist_mat = np.zeros((n, n))
+    time_mat = np.zeros((n, n))
 
-    # OR-Tools Manager
+    for i in range(n):
+        for j in range(n):
+            if i == j:
+                continue
+            d, t = osrm_distance(coords[i], coords[j])
+            if d is None:
+                return None, None
+            dist_mat[i][j] = int(d)
+            time_mat[i][j] = int(t)
+
+    return dist_mat, time_mat
+
+
+# -------------------------------------------
+# 4. OR-Tools Route Optimization
+# -------------------------------------------
+
+def optimize_route(dist_matrix):
+    n = len(dist_matrix)
     manager = pywrapcp.RoutingIndexManager(n, 1, 0)
     routing = pywrapcp.RoutingModel(manager)
 
-    def distance_callback(from_idx, to_idx):
-        return distance_matrix[manager.IndexToNode(from_idx)][manager.IndexToNode(to_idx)]
+    def callback(from_index, to_index):
+        return int(dist_matrix[manager.IndexToNode(from_index)][manager.IndexToNode(to_index)])
 
-    callback_idx = routing.RegisterTransitCallback(distance_callback)
-    routing.SetArcCostEvaluatorOfAllVehicles(callback_idx)
+    transit_idx = routing.RegisterTransitCallback(callback)
+    routing.SetArcCostEvaluatorOfAllVehicles(transit_idx)
 
-    search_params = pywrapcp.DefaultRoutingSearchParameters()
-    search_params.first_solution_strategy = (
-        routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC
-    )
+    search = pywrapcp.DefaultRoutingSearchParameters()
+    search.first_solution_strategy = routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC
 
-    solution = routing.SolveWithParameters(search_params)
-    if not solution:
-        return "❌ Route optimization failed.", None
+    sol = routing.SolveWithParameters(search)
+    if not sol:
+        return None
 
-    # Extract route
     index = routing.Start(0)
-    ordered_stops = []
+    route = []
     while not routing.IsEnd(index):
-        ordered_stops.append(manager.IndexToNode(index))
-        index = solution.Value(routing.NextVar(index))
+        route.append(manager.IndexToNode(index))
+        index = sol.Value(routing.NextVar(index))
+
+    return route
+
+
+# -------------------------------------------
+# 5. Build Folium Map
+# -------------------------------------------
+
+def build_map(coords, addresses, route_order):
+    start = coords[route_order[0]]
+    m = folium.Map(location=start, zoom_start=12)
+
+    # Add markers
+    for i, idx in enumerate(route_order):
+        folium.Marker(coords[idx], tooltip=f"{i+1}. {addresses[idx]}").add_to(m)
+
+    # Draw lines between points
+    path = [coords[idx] for idx in route_order]
+    AntPath(path, color="blue", weight=4).add_to(m)
+
+    return m._repr_html_()
+
+
+# -------------------------------------------
+# MAIN FUNCTION
+# -------------------------------------------
+
+def run_planner(address_text):
+
+    addresses = [a.strip() for a in address_text.split("\n") if a.strip()]
+    if len(addresses) < 2:
+        return "❌ Enter at least two locations.", None, None, None
+
+    # 1. Geocode
+    coords = []
+    for a in addresses:
+        c = get_coordinates(a)
+        if not c:
+            return f"❌ Unable to geocode: {a}", None, None, None
+        coords.append(c)
+
+    # 2. Build matrices
+    dist_mat, time_mat = build_matrices(coords)
+    if dist_mat is None:
+        return "❌ Failed to fetch OSRM distances.", None, None, None
+
+    # 3. Optimize route
+    route_order = optimize_route(dist_mat)
+    if route_order is None:
+        return "❌ Route optimization failed.", None, None, None
+
+    # 4. Format output text
+    route_text = "🚚 **Optimized Real Route (OSRM):**\n\n"
+    for i, idx in enumerate(route_order):
+        route_text += f"**{i+1}. {addresses[idx]}**\n"
 
-    ordered_addresses = [addresses[i] for i in ordered_stops]
+    # 5. Build map
+    map_html = build_map(coords, addresses, route_order)
 
-    # Build readable text
-    route_text = "🚚 **Optimized Route:**\n\n"
-    for i, loc in enumerate(ordered_addresses):
-        route_text += f"**{i+1}. {loc}**\n"
+    # 6. Convert matrices to DataFrames
+    df_dist = pd.DataFrame(dist_mat, columns=addresses, index=addresses)
+    df_time = pd.DataFrame(time_mat, columns=addresses, index=addresses)
 
-    df = pd.DataFrame(distance_matrix, columns=addresses, index=addresses)
+    return route_text, df_dist, df_time, map_html
 
-    return route_text, df
 
+# -------------------------------------------
+# GRADIO UI
+# -------------------------------------------
 
-# Gradio interface
 interface = gr.Interface(
-    fn=optimize_route,
+    fn=run_planner,
     inputs=gr.Textbox(
         lines=8,
         label="Enter addresses (one per line):",
@@ -64,10 +164,12 @@ interface = gr.Interface(
     ),
     outputs=[
         gr.Markdown(label="Optimized Route"),
-        gr.Dataframe(label="Distance Matrix (Demo Mode)")
+        gr.Dataframe(label="Distance (meters)"),
+        gr.Dataframe(label="Time (seconds)"),
+        gr.HTML(label="Route Map"),
     ],
     title="Procelevate AI Route Planner",
-    description="AI-powered optimization for logistics & 3PL route planning.",
+    description="Real logistics routing using OSRM, OR-Tools, and AI-driven insights.",
 )
 
 interface.launch()