add travel utils

app/api/routes.py

@@ -32,6 +32,7 @@ from app.services.preprocessing import (
 from app.services.postprocessing import agent_response_to_dict
 from app.utils.helpers import utc_now_iso
 from app.core.config import settings
+from app.utils.travel_utils import adjust_itinerary_times
 
 logger = logging.getLogger(__name__)
 
@@ -179,10 +180,25 @@ async def chat_structured(request: ChatRequest) -> Dict[str, Any]:
 @router.post("/plan", response_model=AgentResponse, tags=["Planning"])
 async def plan(request: PlanRequest) -> AgentResponse:
     """
-    Generate a day-by-day itinerary from a fixed list of places.
+    Generate a day-by-day itinerary from a fixed list of places,
+    calculate travel times, and adjust the schedules accordingly.
     """
     try:
-        return generate_plan(request)
+        # 1. Run the core planning logic/agents
+        agent_response = generate_plan(request)
+
+        # 2. Convert response to a dictionary for modifications
+        # Use model_dump() for Pydantic v2, or dict() for Pydantic v1
+        if hasattr(agent_response, "model_dump"):
+            response_dict = agent_response.model_dump()
+        else:
+            response_dict = agent_response.dict()
+
+        # 3. Adjust time ranges based on spatial travel times
+        adjusted_dict = adjust_itinerary_times(response_dict)
+
+        # 4. Reconstruct the response model with modified data
+        return AgentResponse(**adjusted_dict)
 
     except Exception as exc:
         logger.exception("Error in /plan: %s", exc)

app/utils/travel_utils.py

@@ -0,0 +1,125 @@
+import math
+from datetime import datetime, timedelta
+import requests
+
+
+# ----------------------------------------------------
+# 1. TRAVEL TIME CALCULATION
+# ----------------------------------------------------
+def get_travel_time_minutes(lat1, lon1, lat2, lon2):
+    """
+    Calculates travel time using OSRM Routing API, with a fallback
+    to Haversine (straight-line) distance if the API call fails.
+    """
+    # Try using OSRM API (Free road-routing service)
+    url = f"http://router.project-osrm.org/route/v1/driving/{lon1},{lat1};{lon2},{lat2}?overview=false"
+    try:
+        response = requests.get(url, timeout=3)
+        if response.status_code == 200:
+            data = response.json()
+            if data.get("code") == "Ok":
+                duration_seconds = data["routes"][0]["duration"]
+                return round(duration_seconds / 60)
+    except Exception:
+        pass  # Fail silently to trigger the mathematical fallback
+
+    # Fallback: Haversine Formula with an assumed average speed of 30 km/h
+    R = 6371.0  # Earth's radius in km
+    phi1, phi2 = math.radians(lat1), math.radians(lat2)
+    delta_phi = math.radians(lat2 - lat1)
+    delta_lambda = math.radians(lon2 - lon1)
+
+    a = (
+        math.sin(delta_phi / 2.0) ** 2
+        + math.cos(phi1) * math.cos(phi2) * math.sin(delta_lambda / 2.0) ** 2
+    )
+
+    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
+    distance_km = R * c
+
+    avg_speed_kmh = 30.0
+    time_minutes = (distance_km / avg_speed_kmh) * 60
+    return max(5, round(time_minutes))  # Ensure a minimum of 5 minutes travel time
+
+
+# ----------------------------------------------------
+# 2. TIME FORMATTING AND PARSING HELPERS
+# ----------------------------------------------------
+def parse_time_str(time_str: str) -> datetime:
+    """Parses time strings like '9:00 PM' or '10:30 AM' into a datetime object."""
+    clean_str = time_str.strip().upper()
+    return datetime.strptime(clean_str, "%I:%M %p")
+
+
+def format_time_obj(dt: datetime) -> str:
+    """Formats datetime objects back to '9:00 PM' style string."""
+    return dt.strftime("%I:%M %p").lstrip("0")
+
+
+# ----------------------------------------------------
+# 3. ITINERARY ADJUSTMENT ENGINE
+# ----------------------------------------------------
+def adjust_itinerary_times(itinerary_dict: dict) -> dict:
+    """
+    Iterates through each day in the itinerary, calculates travel times,
+    and updates the 'time_range' fields for all activities.
+    """
+    daily_itinerary = (
+        itinerary_dict.get("active_trip", {})
+        .get("itinerary", {})
+        .get("daily_itinerary", [])
+    )
+
+    for day in daily_itinerary:
+        activities = day.get("activities", [])
+        if not activities:
+            continue
+
+        # Step 1: Process the first activity
+        first_act = activities[0]
+        duration_hours = first_act.get("estimated_duration_hours", 1.0)
+
+        # Extract initial start time
+        time_range = first_act.get("time_range", "09:00 AM - 10:00 AM")
+        try:
+            start_time_str = time_range.split("-")[0].strip()
+            current_start = parse_time_str(start_time_str)
+        except Exception:
+            current_start = parse_time_str("09:00 AM")
+
+        current_end = current_start + timedelta(hours=duration_hours)
+        first_act["time_range"] = (
+            f"{format_time_obj(current_start)} - {format_time_obj(current_end)}"
+        )
+
+        # Step 2: Sequentially process subsequent activities
+        for i in range(1, len(activities)):
+            prev_act = activities[i - 1]
+            curr_act = activities[i]
+
+            # Extract coordinates (Note spelling: 'late' and 'long' from your JSON structure)
+            prev_loc = prev_act.get("place", {}).get("location", {})
+            curr_loc = curr_act.get("place", {}).get("location", {})
+
+            lat1, lon1 = prev_loc.get("late"), prev_loc.get("long")
+            lat2, lon2 = curr_loc.get("late"), curr_loc.get("long")
+
+            # Calculate travel time (default to 15 minutes if coordinates are missing)
+            if None not in (lat1, lon1, lat2, lon2):
+                travel_minutes = get_travel_time_minutes(lat1, lon1, lat2, lon2)
+            else:
+                travel_minutes = 15
+
+            # Current activity starts after previous ends + travel time
+            curr_start = current_end + timedelta(minutes=travel_minutes)
+            curr_duration = curr_act.get("estimated_duration_hours", 1.0)
+            curr_end = curr_start + timedelta(hours=curr_duration)
+
+            curr_act["time_range"] = (
+                f"{format_time_obj(curr_start)} - {format_time_obj(curr_end)}"
+            )
+
+            # Advance pointers
+            current_end = curr_end
+
+    return itinerary_dict