Update main.py

main.py

@@ -16,7 +16,7 @@ from flask import Flask, request, jsonify
 from flask_cors import CORS
 
 # LLM
-import google.generativeai as genai  # target 0.4.1 semantics
+import google.generativeai as genai
 
 # OR-Tools
 from ortools.constraint_solver import pywrapcp, routing_enums_pb2
@@ -37,8 +37,8 @@ logger = logging.getLogger(__name__)
 # -----------------------------------------------------------------------------
 PORT = int(os.environ.get("PORT", "7860"))
 GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY") or os.environ.get("Gemini") or ""
-GEMINI_MODEL = os.environ.get("GEMINI_MODEL", "gemini-2.0-flash")
-MODEL_FALLBACK = os.environ.get("GEMINI_MODEL_FALLBACK", "gemini-1.5-flash")
+GEMINI_MODEL = os.environ.get("GEMINI_MODEL", "gemini-2.0-flash-exp")
+MODEL_FALLBACK = os.environ.get("GEMINI_MODEL_FALLBACK", "gemini-2.0-flash")
 RANDOM_SEED = int(os.environ.get("VRP_SEED", "42"))
 np.random.seed(RANDOM_SEED)
 
@@ -67,10 +67,6 @@ MARKETS = [
 FLEET = [
     {"id":"V1","hub_id":"H2","type":"insulated","cap_kg":1400,"cost_per_km":13.5,"co2_per_km":1.1,"max_route_min":8*60},
     {"id":"V2","hub_id":"H2","type":"non_insulated","cap_kg":1200,"cost_per_km":12.0,"co2_per_km":1.2,"max_route_min":8*60},
-
-    # NEW: give Pretoria North trucks so its 1,307 kg isn’t stranded
-    {"id":"V3","hub_id":"H1","type":"insulated","cap_kg":1400,"cost_per_km":13.5,"co2_per_km":1.1,"max_route_min":8*60},
-    {"id":"V4","hub_id":"H1","type":"non_insulated","cap_kg":1200,"cost_per_km":12.0,"co2_per_km":1.2,"max_route_min":8*60},
 ]
 
 FRESHNESS_MIN = {
@@ -191,7 +187,7 @@ def configure_gemini_model() -> genai.GenerativeModel:
 def extract_json_from_response(response_text: str) -> Any:
     if not response_text:
         raise ValueError("Empty LLM response")
-    m = re.search(r"```json\s*($begin:math:display$[\\s\\S]*?$end:math:display$|\{[\s\S]*?\})\s*```", response_text, re.IGNORECASE)
+    m = re.search(r"```json\s*(\[[\s\S]*?\]|\{[\s\S]*?\})\s*```", response_text, re.IGNORECASE)
     if m:
         return json.loads(m.group(1).strip())
     m = re.search(r"\[[\s\S]*\]", response_text)
@@ -361,7 +357,6 @@ def extract():
             logger.error(f"[extract] missing columns: {missing}")
             return jsonify({"error": f"missing required columns: {missing}"}), 400
 
-        # Configure Gemini model (with fallback)
         try:
             model = configure_gemini_model()
         except Exception as e:
@@ -388,7 +383,6 @@ def extract():
 
             try:
                 parsed = call_gemini_with_retry_extract(model, user_payload, retries=3)
-                # debug preview
                 try:
                     preview = json.dumps(parsed)[:300]
                     logger.debug(f"[extract] batch parsed preview: {preview}")
@@ -526,7 +520,7 @@ def plan():
         return jsonify({"error":"Internal server error"}), 500
 
 # -----------------------------------------------------------------------------
-# OR-Tools VRP (hub -> markets)
+# OR-Tools VRP (hub -> markets) - FIXED VERSION
 # -----------------------------------------------------------------------------
 def solve_hub_to_markets(hub, fleet, markets, supply_kg, rainy=False):
     nodes = [hub] + markets
@@ -546,7 +540,7 @@ def solve_hub_to_markets(hub, fleet, markets, supply_kg, rainy=False):
             dist_km[i, j] = d
             time_min[i, j] = travel_min(d, rainy=rainy)
 
-    # Demand scaling (simple proportional split)
+    # Demand scaling
     dem = [0.0] + [sum(m["demand"].values()) for m in markets]
     total_dem = sum(dem)
     if total_dem <= 0:
@@ -567,34 +561,42 @@ def solve_hub_to_markets(hub, fleet, markets, supply_kg, rainy=False):
     transit_idx = routing.RegisterTransitCallback(time_cb)
     routing.SetArcCostEvaluatorOfAllVehicles(transit_idx)
 
-    # ---- FIX: large horizon + per-vehicle route-duration cap via dimension span ----
-    HORIZON = 24 * 60  # full day
+    # FIX: Use earliest market start as depot start, latest as overall horizon
+    earliest_start = min(m["open_start"] for m in markets)
+    latest_end = max(m["open_end"] for m in markets)
+    DEPOT_START = max(0, earliest_start - 60)  # depot opens 1hr before first market
+    HORIZON = latest_end + 60  # extend 1hr past last market close
+    
+    # Time dimension with proper horizon
     routing.AddDimension(
         transit_idx,
-        30,          # waiting/slack allowance
-        HORIZON,     # big horizon so market windows up to 17:00 are feasible
-        False,       # don't force start at zero
+        60,          # slack for waiting/service time
+        HORIZON,     # overall horizon
+        False,       # don't force cumul to zero at start
         "Time",
     )
     time_dim = routing.GetDimensionOrDie("Time")
 
-    # Depot (hub) windows for ALL vehicles
+    # Depot windows: vehicles can leave anytime from DEPOT_START to HORIZON
     for v_id in range(len(vehs)):
-        time_dim.CumulVar(routing.Start(v_id)).SetRange(0, HORIZON)
-        time_dim.CumulVar(routing.End(v_id)).SetRange(0, HORIZON)
+        depot_start_idx = routing.Start(v_id)
+        depot_end_idx = routing.End(v_id)
+        time_dim.CumulVar(depot_start_idx).SetRange(DEPOT_START, HORIZON)
+        time_dim.CumulVar(depot_end_idx).SetRange(DEPOT_START, HORIZON)
+        
+        # Per-vehicle route duration limit (from depot departure to depot return)
+        max_route = vehs[v_id]["max_route_min"]
+        time_dim.SetSpanCostCoefficientForVehicle(10000, v_id)  # penalize long routes
+        time_dim.SetSpanUpperBoundForVehicle(max_route, v_id)
 
-    # Market time windows (e.g., 08:00–17:00)
+    # Market time windows
     for node in range(1, n):
+        idx = manager.NodeToIndex(node)
         s = markets[node - 1]["open_start"]
         e = markets[node - 1]["open_end"]
-        time_dim.CumulVar(manager.NodeToIndex(node)).SetRange(int(s), int(e))
-
-    # Cap each vehicle's working time using the dimension's span bound (CORRECT API)
-    max_route = int(max(v["max_route_min"] for v in vehs))
-    for v_id in range(len(vehs)):
-        time_dim.SetSpanUpperBoundForVehicle(max_route, v_id)
+        time_dim.CumulVar(idx).SetRange(int(s), int(e))
 
-    # Capacity (kg)
+    # Capacity dimension (kg)
     def demand_cb(from_idx):
         i = manager.IndexToNode(from_idx)
         return int(demand_deliver[i])
@@ -602,32 +604,35 @@ def solve_hub_to_markets(hub, fleet, markets, supply_kg, rainy=False):
     dem_idx = routing.RegisterUnaryTransitCallback(demand_cb)
     routing.AddDimensionWithVehicleCapacity(
         dem_idx,
-        0,
+        0,  # no slack
         [int(v["cap_kg"]) for v in vehs],
         True,
         "Capacity",
     )
 
-    # Search params
+    # Search params - optimized for faster solving
     params = pywrapcp.DefaultRoutingSearchParameters()
     params.first_solution_strategy = routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC
     params.local_search_metaheuristic = routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH
-    params.time_limit.FromSeconds(10)
+    params.time_limit.FromSeconds(15)  # increased from 10s for better solutions
     params.log_search = False
 
-    # Extra debug to diagnose feasibility quickly
-    try:
-        tws = [(m["open_start"], m["open_end"]) for m in markets]
-        logging.debug(f"[vrp] HORIZON={HORIZON}, max_route={max_route}, windows={tws}")
-    except Exception:
-        pass
+    logger.debug(f"[vrp] hub={hub['id']} DEPOT_START={DEPOT_START} HORIZON={HORIZON} vehicles={len(vehs)}")
 
     sol = routing.SolveWithParameters(params)
     if not sol:
-        return _empty_hub_result(
-            hub["id"],
-            note=f"No solution in time limit (HORIZON={HORIZON}, max_route={max_route})."
-        )
+        # Try with relaxed constraints if initial solve fails
+        logger.warning(f"[vrp] No solution for hub {hub['id']}, trying with dropped visits")
+        for node in range(1, n):
+            idx = manager.NodeToIndex(node)
+            routing.AddDisjunction([idx], 10000)  # allow dropping with penalty
+        
+        sol = routing.SolveWithParameters(params)
+        if not sol:
+            return _empty_hub_result(
+                hub["id"],
+                note=f"No feasible solution found (depot_start={DEPOT_START}, horizon={HORIZON})"
+            )
 
     # Build routes & KPIs
     total_km = 0.0
@@ -641,6 +646,7 @@ def solve_hub_to_markets(hub, fleet, markets, supply_kg, rainy=False):
         idx = routing.Start(v_id)
         rnodes = []
         route_km = 0.0
+        
         while not routing.IsEnd(idx):
             node = manager.IndexToNode(idx)
             tmin = sol.Value(time_dim.CumulVar(idx))
@@ -650,8 +656,14 @@ def solve_hub_to_markets(hub, fleet, markets, supply_kg, rainy=False):
                 nxt = manager.IndexToNode(next_idx)
                 route_km += dist_km[node, nxt]
             idx = next_idx
+        
+        # Add final depot return
         rnodes.append((manager.IndexToNode(idx), sol.Value(time_dim.CumulVar(idx))))
 
+        # Skip empty routes
+        if len(rnodes) <= 2:  # only depot start and end
+            continue
+
         route_cost = route_km * veh["cost_per_km"]
         route_em = route_km * veh["co2_per_km"]
         total_km += route_km
@@ -659,12 +671,16 @@ def solve_hub_to_markets(hub, fleet, markets, supply_kg, rainy=False):
         total_em += route_em
 
         insulated = (veh["type"] == "insulated")
+        
+        # Calculate delivery and freshness violations
         for node, arriv in rnodes:
-            if node == 0:
+            if node == 0:  # skip depot
                 continue
             mk = markets[node - 1]
             qty = demand_deliver[node]
             delivered += qty
+            
+            # Freshness calculation
             totm = sum(mk["demand"].values()) + 1e-6
             viol_share = 0.0
             for crop, demc in mk["demand"].items():
@@ -674,10 +690,21 @@ def solve_hub_to_markets(hub, fleet, markets, supply_kg, rainy=False):
                     viol_share += share
             freshness_viol += qty * viol_share
 
+        # Build pretty route for output
         pretty = []
         for node, arriv in rnodes:
+            h = arriv // 60
+            m = arriv % 60
+            time_str = f"{int(h):02d}:{int(m):02d}"
+            
             if node == 0:
-                pretty.append({"type": "hub", "id": hub["id"], "name": hub["name"], "arrive_min": int(arriv)})
+                pretty.append({
+                    "type": "hub",
+                    "id": hub["id"],
+                    "name": hub["name"],
+                    "arrive_min": int(arriv),
+                    "arrive_time": time_str
+                })
             else:
                 mk = markets[node - 1]
                 pretty.append({
@@ -685,6 +712,7 @@ def solve_hub_to_markets(hub, fleet, markets, supply_kg, rainy=False):
                     "id": mk["id"],
                     "name": mk["name"],
                     "arrive_min": int(arriv),
+                    "arrive_time": time_str,
                     "deliver_kg": round(demand_deliver[node], 1)
                 })
 
@@ -735,4 +763,4 @@ if __name__ == "__main__":
         logger.warning("[boot] GEMINI_API_KEY not set")
 
     logger.info(f"[boot] starting Flask on 0.0.0.0:{PORT}")
-    app.run(host="0.0.0.0", port=PORT, debug=True)
+    app.run(host="0.0.0.0", port=PORT, debug=True)