Delete src

src/vehicle_routing/__init__.py

@@ -1,16 +0,0 @@
-import uvicorn
-
-from .rest_api import app as app
-
-
-def main():
-    config = uvicorn.Config("vehicle_routing:app",
-                            port=8082,
-                            log_config="logging.conf",
-                            use_colors=True)
-    server = uvicorn.Server(config)
-    server.run()
-
-
-if __name__ == "__main__":
-    main()

src/vehicle_routing/constraints.py

@@ -1,105 +0,0 @@
-from solverforge_legacy.solver.score import (
-    ConstraintFactory,
-    HardSoftScore,
-    constraint_provider,
-)
-
-from .domain import Vehicle, Visit
-
-VEHICLE_CAPACITY = "vehicleCapacity"
-MINIMIZE_TRAVEL_TIME = "minimizeTravelTime"
-SERVICE_FINISHED_AFTER_MAX_END_TIME = "serviceFinishedAfterMaxEndTime"
-MAX_ROUTE_DURATION = "maxRouteDuration"
-
-
-@constraint_provider
-def define_constraints(factory: ConstraintFactory):
-    return [
-        # Hard constraints
-        vehicle_capacity(factory),
-        service_finished_after_max_end_time(factory),
-        # max_route_duration(factory),  # Optional extension - disabled by default
-        # Soft constraints
-        minimize_travel_time(factory),
-    ]
-
-
-##############################################
-# Hard constraints
-##############################################
-
-
-def vehicle_capacity(factory: ConstraintFactory):
-    return (
-        factory.for_each(Vehicle)
-        .filter(lambda vehicle: vehicle.calculate_total_demand() > vehicle.capacity)
-        .penalize(
-            HardSoftScore.ONE_HARD,
-            lambda vehicle: vehicle.calculate_total_demand() - vehicle.capacity,
-        )
-        .as_constraint(VEHICLE_CAPACITY)
-    )
-
-
-def service_finished_after_max_end_time(factory: ConstraintFactory):
-    return (
-        factory.for_each(Visit)
-        .filter(lambda visit: visit.is_service_finished_after_max_end_time())
-        .penalize(
-            HardSoftScore.ONE_HARD,
-            lambda visit: visit.service_finished_delay_in_minutes(),
-        )
-        .as_constraint(SERVICE_FINISHED_AFTER_MAX_END_TIME)
-    )
-
-
-##############################################
-# Soft constraints
-##############################################
-
-
-def minimize_travel_time(factory: ConstraintFactory):
-    return (
-        factory.for_each(Vehicle)
-        .penalize(
-            HardSoftScore.ONE_SOFT,
-            lambda vehicle: vehicle.calculate_total_driving_time_seconds(),
-        )
-        .as_constraint(MINIMIZE_TRAVEL_TIME)
-    )
-
-
-##############################################
-# Optional constraints (disabled by default)
-##############################################
-
-
-def max_route_duration(factory: ConstraintFactory):
-    """
-    Hard constraint: Vehicle routes cannot exceed 8 hours total duration.
-
-    The limit of 8 hours is chosen based on typical driver shift limits:
-    - PHILADELPHIA: 55 visits across 6 vehicles, routes typically 4-6 hours
-    - FIRENZE: 77 visits across 6 vehicles, routes can approach 8 hours
-
-    Note: A limit that's too low may make the problem infeasible.
-    Always ensure your constraints are compatible with your data dimensions.
-    """
-    MAX_DURATION_SECONDS = 8 * 60 * 60  # 8 hours
-
-    return (
-        factory.for_each(Vehicle)
-        .filter(lambda vehicle: len(vehicle.visits) > 0)
-        .filter(lambda vehicle:
-            (vehicle.arrival_time - vehicle.departure_time).total_seconds()
-            > MAX_DURATION_SECONDS
-        )
-        .penalize(
-            HardSoftScore.ONE_HARD,
-            lambda vehicle: int(
-                ((vehicle.arrival_time - vehicle.departure_time).total_seconds()
-                 - MAX_DURATION_SECONDS) / 60
-            ),
-        )
-        .as_constraint(MAX_ROUTE_DURATION)
-    )

src/vehicle_routing/converters.py

@@ -1,228 +0,0 @@
-from typing import List
-from datetime import datetime, timedelta
-from . import domain
-
-
-# Conversion functions from domain to API models
-def location_to_model(location: domain.Location) -> List[float]:
-    return [location.latitude, location.longitude]
-
-
-def visit_to_model(visit: domain.Visit) -> domain.VisitModel:
-    return domain.VisitModel(
-        id=visit.id,
-        name=visit.name,
-        location=location_to_model(visit.location),
-        demand=visit.demand,
-        min_start_time=visit.min_start_time.isoformat(),
-        max_end_time=visit.max_end_time.isoformat(),
-        service_duration=int(visit.service_duration.total_seconds()),
-        vehicle=visit.vehicle.id if visit.vehicle else None,
-        previous_visit=visit.previous_visit.id if visit.previous_visit else None,
-        next_visit=visit.next_visit.id if visit.next_visit else None,
-        arrival_time=visit.arrival_time.isoformat() if visit.arrival_time else None,
-        start_service_time=visit.start_service_time.isoformat()
-        if visit.start_service_time
-        else None,
-        departure_time=visit.departure_time.isoformat()
-        if visit.departure_time
-        else None,
-        driving_time_seconds_from_previous_standstill=visit.driving_time_seconds_from_previous_standstill,
-    )
-
-
-def vehicle_to_model(vehicle: domain.Vehicle) -> domain.VehicleModel:
-    return domain.VehicleModel(
-        id=vehicle.id,
-        name=vehicle.name,
-        capacity=vehicle.capacity,
-        home_location=location_to_model(vehicle.home_location),
-        departure_time=vehicle.departure_time.isoformat(),
-        visits=[visit.id for visit in vehicle.visits],
-        total_demand=vehicle.total_demand,
-        total_driving_time_seconds=vehicle.total_driving_time_seconds,
-        arrival_time=vehicle.arrival_time.isoformat(),
-    )
-
-
-def plan_to_model(plan: domain.VehicleRoutePlan) -> domain.VehicleRoutePlanModel:
-    return domain.VehicleRoutePlanModel(
-        name=plan.name,
-        south_west_corner=location_to_model(plan.south_west_corner),
-        north_east_corner=location_to_model(plan.north_east_corner),
-        vehicles=[vehicle_to_model(v) for v in plan.vehicles],
-        visits=[visit_to_model(v) for v in plan.visits],
-        score=str(plan.score) if plan.score else None,
-        solver_status=plan.solver_status.name if plan.solver_status else None,
-        total_driving_time_seconds=plan.total_driving_time_seconds,
-        start_date_time=plan.start_date_time.isoformat()
-        if plan.start_date_time
-        else None,
-        end_date_time=plan.end_date_time.isoformat() if plan.end_date_time else None,
-    )
-
-
-# Conversion functions from API models to domain
-def model_to_location(model: List[float]) -> domain.Location:
-    return domain.Location(latitude=model[0], longitude=model[1])
-
-
-def model_to_visit(
-    model: domain.VisitModel, vehicle_lookup: dict, visit_lookup: dict
-) -> domain.Visit:
-    # Handle vehicle reference
-    vehicle = None
-    if model.vehicle:
-        if isinstance(model.vehicle, str):
-            vehicle = vehicle_lookup[model.vehicle]
-        else:
-            # This shouldn't happen in practice, but handle it for completeness
-            vehicle = vehicle_lookup[model.vehicle.id]
-
-    # Handle previous visit reference
-    previous_visit = None
-    if model.previous_visit:
-        if isinstance(model.previous_visit, str):
-            previous_visit = visit_lookup[model.previous_visit]
-        else:
-            previous_visit = visit_lookup[model.previous_visit.id]
-
-    # Handle next visit reference
-    next_visit = None
-    if model.next_visit:
-        if isinstance(model.next_visit, str):
-            next_visit = visit_lookup[model.next_visit]
-        else:
-            next_visit = visit_lookup[model.next_visit.id]
-
-    return domain.Visit(
-        id=model.id,
-        name=model.name,
-        location=model_to_location(model.location),
-        demand=model.demand,
-        min_start_time=datetime.fromisoformat(model.min_start_time),
-        max_end_time=datetime.fromisoformat(model.max_end_time),
-        service_duration=timedelta(seconds=model.service_duration),
-        vehicle=vehicle,
-        previous_visit=previous_visit,
-        next_visit=next_visit,
-        arrival_time=datetime.fromisoformat(model.arrival_time)
-        if model.arrival_time
-        else None,
-    )
-
-
-def model_to_vehicle(model: domain.VehicleModel, visit_lookup: dict) -> domain.Vehicle:
-    # Handle visits references
-    visits = []
-    for visit_ref in model.visits:
-        if isinstance(visit_ref, str):
-            visits.append(visit_lookup[visit_ref])
-        else:
-            visits.append(visit_lookup[visit_ref.id])
-
-    return domain.Vehicle(
-        id=model.id,
-        capacity=model.capacity,
-        home_location=model_to_location(model.home_location),
-        departure_time=datetime.fromisoformat(model.departure_time),
-        visits=visits,
-    )
-
-
-def model_to_plan(model: domain.VehicleRoutePlanModel) -> domain.VehicleRoutePlan:
-    # Convert basic collections first
-    vehicles = []
-    visits = []
-
-    # Convert visits first (they don't depend on vehicles)
-    for visit_model in model.visits:
-        visit = domain.Visit(
-            id=visit_model.id,
-            name=visit_model.name,
-            location=model_to_location(visit_model.location),
-            demand=visit_model.demand,
-            min_start_time=datetime.fromisoformat(visit_model.min_start_time),
-            max_end_time=datetime.fromisoformat(visit_model.max_end_time),
-            service_duration=timedelta(seconds=visit_model.service_duration),
-            vehicle=None,  # Will be set later
-            previous_visit=None,  # Will be set later
-            next_visit=None,  # Will be set later
-            arrival_time=datetime.fromisoformat(visit_model.arrival_time)
-            if visit_model.arrival_time
-            else None,
-        )
-        visits.append(visit)
-
-    # Create lookup dictionaries
-    visit_lookup = {v.id: v for v in visits}
-
-    # Convert vehicles
-    for vehicle_model in model.vehicles:
-        vehicle = domain.Vehicle(
-            id=vehicle_model.id,
-            name=vehicle_model.name,
-            capacity=vehicle_model.capacity,
-            home_location=model_to_location(vehicle_model.home_location),
-            departure_time=datetime.fromisoformat(vehicle_model.departure_time),
-            visits=[],
-        )
-        vehicles.append(vehicle)
-
-    # Create vehicle lookup
-    vehicle_lookup = {v.id: v for v in vehicles}
-
-    # Now set up the relationships
-    for i, visit_model in enumerate(model.visits):
-        visit = visits[i]
-
-        # Set vehicle reference
-        if visit_model.vehicle:
-            if isinstance(visit_model.vehicle, str):
-                visit.vehicle = vehicle_lookup[visit_model.vehicle]
-            else:
-                visit.vehicle = vehicle_lookup[visit_model.vehicle.id]
-
-        # Set previous/next visit references
-        if visit_model.previous_visit:
-            if isinstance(visit_model.previous_visit, str):
-                visit.previous_visit = visit_lookup[visit_model.previous_visit]
-            else:
-                visit.previous_visit = visit_lookup[visit_model.previous_visit.id]
-
-        if visit_model.next_visit:
-            if isinstance(visit_model.next_visit, str):
-                visit.next_visit = visit_lookup[visit_model.next_visit]
-            else:
-                visit.next_visit = visit_lookup[visit_model.next_visit.id]
-
-    # Set up vehicle visits lists
-    for vehicle_model in model.vehicles:
-        vehicle = vehicle_lookup[vehicle_model.id]
-        for visit_ref in vehicle_model.visits:
-            if isinstance(visit_ref, str):
-                vehicle.visits.append(visit_lookup[visit_ref])
-            else:
-                vehicle.visits.append(visit_lookup[visit_ref.id])
-
-    # Handle score
-    score = None
-    if model.score:
-        from solverforge_legacy.solver.score import HardSoftScore
-
-        score = HardSoftScore.parse(model.score)
-
-    # Handle solver status
-    solver_status = domain.SolverStatus.NOT_SOLVING
-    if model.solver_status:
-        solver_status = domain.SolverStatus[model.solver_status]
-
-    return domain.VehicleRoutePlan(
-        name=model.name,
-        south_west_corner=model_to_location(model.south_west_corner),
-        north_east_corner=model_to_location(model.north_east_corner),
-        vehicles=vehicles,
-        visits=visits,
-        score=score,
-        solver_status=solver_status,
-    )

src/vehicle_routing/demo_data.py

@@ -1,478 +0,0 @@
-from typing import Generator, TypeVar, Sequence, Optional
-from datetime import date, datetime, time, timedelta
-from enum import Enum
-from random import Random
-from dataclasses import dataclass, field
-
-from .domain import Location, Vehicle, VehicleRoutePlan, Visit
-
-
-FIRST_NAMES = ("Amy", "Beth", "Carl", "Dan", "Elsa", "Flo", "Gus", "Hugo", "Ivy", "Jay")
-LAST_NAMES = ("Cole", "Fox", "Green", "Jones", "King", "Li", "Poe", "Rye", "Smith", "Watt")
-
-
-# Real Philadelphia street addresses for demo data
-# These are actual locations on the road network for realistic routing
-PHILADELPHIA_REAL_LOCATIONS = {
-    "depots": [
-        {"name": "Central Depot - City Hall", "lat": 39.9526, "lng": -75.1652},
-        {"name": "South Philly Depot", "lat": 39.9256, "lng": -75.1697},
-        {"name": "University City Depot", "lat": 39.9522, "lng": -75.1932},
-        {"name": "North Philly Depot", "lat": 39.9907, "lng": -75.1556},
-        {"name": "Fishtown Depot", "lat": 39.9712, "lng": -75.1340},
-        {"name": "West Philly Depot", "lat": 39.9601, "lng": -75.2175},
-    ],
-    "visits": [
-        # Restaurants (for early morning deliveries)
-        {"name": "Reading Terminal Market", "lat": 39.9535, "lng": -75.1589, "type": "RESTAURANT"},
-        {"name": "Parc Restaurant", "lat": 39.9493, "lng": -75.1727, "type": "RESTAURANT"},
-        {"name": "Zahav", "lat": 39.9430, "lng": -75.1474, "type": "RESTAURANT"},
-        {"name": "Vetri Cucina", "lat": 39.9499, "lng": -75.1659, "type": "RESTAURANT"},
-        {"name": "Talula's Garden", "lat": 39.9470, "lng": -75.1709, "type": "RESTAURANT"},
-        {"name": "Fork", "lat": 39.9493, "lng": -75.1539, "type": "RESTAURANT"},
-        {"name": "Morimoto", "lat": 39.9488, "lng": -75.1559, "type": "RESTAURANT"},
-        {"name": "Vernick Food & Drink", "lat": 39.9508, "lng": -75.1718, "type": "RESTAURANT"},
-        {"name": "Friday Saturday Sunday", "lat": 39.9492, "lng": -75.1715, "type": "RESTAURANT"},
-        {"name": "Royal Izakaya", "lat": 39.9410, "lng": -75.1509, "type": "RESTAURANT"},
-        {"name": "Laurel", "lat": 39.9392, "lng": -75.1538, "type": "RESTAURANT"},
-        {"name": "Marigold Kitchen", "lat": 39.9533, "lng": -75.1920, "type": "RESTAURANT"},
-
-        # Businesses (for business hours deliveries)
-        {"name": "Comcast Center", "lat": 39.9543, "lng": -75.1690, "type": "BUSINESS"},
-        {"name": "Liberty Place", "lat": 39.9520, "lng": -75.1685, "type": "BUSINESS"},
-        {"name": "BNY Mellon Center", "lat": 39.9505, "lng": -75.1660, "type": "BUSINESS"},
-        {"name": "One Liberty Place", "lat": 39.9520, "lng": -75.1685, "type": "BUSINESS"},
-        {"name": "Aramark Tower", "lat": 39.9550, "lng": -75.1705, "type": "BUSINESS"},
-        {"name": "PSFS Building", "lat": 39.9510, "lng": -75.1618, "type": "BUSINESS"},
-        {"name": "Three Logan Square", "lat": 39.9567, "lng": -75.1720, "type": "BUSINESS"},
-        {"name": "Two Commerce Square", "lat": 39.9551, "lng": -75.1675, "type": "BUSINESS"},
-        {"name": "Penn Medicine", "lat": 39.9495, "lng": -75.1935, "type": "BUSINESS"},
-        {"name": "Children's Hospital", "lat": 39.9482, "lng": -75.1950, "type": "BUSINESS"},
-        {"name": "Drexel University", "lat": 39.9566, "lng": -75.1899, "type": "BUSINESS"},
-        {"name": "Temple University", "lat": 39.9812, "lng": -75.1554, "type": "BUSINESS"},
-        {"name": "Jefferson Hospital", "lat": 39.9487, "lng": -75.1577, "type": "BUSINESS"},
-        {"name": "Pennsylvania Hospital", "lat": 39.9445, "lng": -75.1545, "type": "BUSINESS"},
-        {"name": "FMC Tower", "lat": 39.9499, "lng": -75.1780, "type": "BUSINESS"},
-        {"name": "Cira Centre", "lat": 39.9560, "lng": -75.1822, "type": "BUSINESS"},
-
-        # Residential areas (for evening deliveries)
-        {"name": "Rittenhouse Square", "lat": 39.9496, "lng": -75.1718, "type": "RESIDENTIAL"},
-        {"name": "Washington Square West", "lat": 39.9468, "lng": -75.1545, "type": "RESIDENTIAL"},
-        {"name": "Society Hill", "lat": 39.9425, "lng": -75.1478, "type": "RESIDENTIAL"},
-        {"name": "Old City", "lat": 39.9510, "lng": -75.1450, "type": "RESIDENTIAL"},
-        {"name": "Northern Liberties", "lat": 39.9650, "lng": -75.1420, "type": "RESIDENTIAL"},
-        {"name": "Fishtown", "lat": 39.9712, "lng": -75.1340, "type": "RESIDENTIAL"},
-        {"name": "Queen Village", "lat": 39.9380, "lng": -75.1520, "type": "RESIDENTIAL"},
-        {"name": "Bella Vista", "lat": 39.9395, "lng": -75.1598, "type": "RESIDENTIAL"},
-        {"name": "Graduate Hospital", "lat": 39.9425, "lng": -75.1768, "type": "RESIDENTIAL"},
-        {"name": "Fairmount", "lat": 39.9680, "lng": -75.1750, "type": "RESIDENTIAL"},
-        {"name": "Spring Garden", "lat": 39.9620, "lng": -75.1620, "type": "RESIDENTIAL"},
-        {"name": "Art Museum Area", "lat": 39.9656, "lng": -75.1810, "type": "RESIDENTIAL"},
-        {"name": "Brewerytown", "lat": 39.9750, "lng": -75.1850, "type": "RESIDENTIAL"},
-        {"name": "East Passyunk", "lat": 39.9310, "lng": -75.1605, "type": "RESIDENTIAL"},
-        {"name": "Point Breeze", "lat": 39.9285, "lng": -75.1780, "type": "RESIDENTIAL"},
-        {"name": "Pennsport", "lat": 39.9320, "lng": -75.1450, "type": "RESIDENTIAL"},
-        {"name": "Powelton Village", "lat": 39.9610, "lng": -75.1950, "type": "RESIDENTIAL"},
-        {"name": "Spruce Hill", "lat": 39.9530, "lng": -75.2100, "type": "RESIDENTIAL"},
-        {"name": "Cedar Park", "lat": 39.9490, "lng": -75.2200, "type": "RESIDENTIAL"},
-        {"name": "Kensington", "lat": 39.9850, "lng": -75.1280, "type": "RESIDENTIAL"},
-        {"name": "Port Richmond", "lat": 39.9870, "lng": -75.1120, "type": "RESIDENTIAL"},
-        # Note: Removed distant locations (Manayunk, Roxborough, Chestnut Hill, Mount Airy, Germantown)
-        # to keep the bounding box compact for faster OSMnx downloads
-    ],
-}
-
-# Hartford real locations
-HARTFORD_REAL_LOCATIONS = {
-    "depots": [
-        {"name": "Downtown Hartford Depot", "lat": 41.7658, "lng": -72.6734},
-        {"name": "Asylum Hill Depot", "lat": 41.7700, "lng": -72.6900},
-        {"name": "South End Depot", "lat": 41.7400, "lng": -72.6750},
-        {"name": "West End Depot", "lat": 41.7680, "lng": -72.7100},
-        {"name": "Barry Square Depot", "lat": 41.7450, "lng": -72.6800},
-        {"name": "Clay Arsenal Depot", "lat": 41.7750, "lng": -72.6850},
-    ],
-    "visits": [
-        # Restaurants
-        {"name": "Max Downtown", "lat": 41.7670, "lng": -72.6730, "type": "RESTAURANT"},
-        {"name": "Trumbull Kitchen", "lat": 41.7650, "lng": -72.6750, "type": "RESTAURANT"},
-        {"name": "Salute", "lat": 41.7630, "lng": -72.6740, "type": "RESTAURANT"},
-        {"name": "Peppercorns Grill", "lat": 41.7690, "lng": -72.6680, "type": "RESTAURANT"},
-        {"name": "Feng Asian Bistro", "lat": 41.7640, "lng": -72.6725, "type": "RESTAURANT"},
-        {"name": "On20", "lat": 41.7655, "lng": -72.6728, "type": "RESTAURANT"},
-        {"name": "First and Last Tavern", "lat": 41.7620, "lng": -72.7050, "type": "RESTAURANT"},
-        {"name": "Agave Grill", "lat": 41.7580, "lng": -72.6820, "type": "RESTAURANT"},
-        {"name": "Bear's Smokehouse", "lat": 41.7550, "lng": -72.6780, "type": "RESTAURANT"},
-        {"name": "City Steam Brewery", "lat": 41.7630, "lng": -72.6750, "type": "RESTAURANT"},
-
-        # Businesses
-        {"name": "Travelers Tower", "lat": 41.7658, "lng": -72.6734, "type": "BUSINESS"},
-        {"name": "Hartford Steam Boiler", "lat": 41.7680, "lng": -72.6700, "type": "BUSINESS"},
-        {"name": "Aetna Building", "lat": 41.7700, "lng": -72.6900, "type": "BUSINESS"},
-        {"name": "Connecticut Convention Center", "lat": 41.7615, "lng": -72.6820, "type": "BUSINESS"},
-        {"name": "Hartford Hospital", "lat": 41.7547, "lng": -72.6858, "type": "BUSINESS"},
-        {"name": "Connecticut Children's", "lat": 41.7560, "lng": -72.6850, "type": "BUSINESS"},
-        {"name": "Trinity College", "lat": 41.7474, "lng": -72.6909, "type": "BUSINESS"},
-        {"name": "Connecticut Science Center", "lat": 41.7650, "lng": -72.6695, "type": "BUSINESS"},
-
-        # Residential
-        {"name": "West End Hartford", "lat": 41.7680, "lng": -72.7000, "type": "RESIDENTIAL"},
-        {"name": "Asylum Hill", "lat": 41.7720, "lng": -72.6850, "type": "RESIDENTIAL"},
-        {"name": "Frog Hollow", "lat": 41.7580, "lng": -72.6900, "type": "RESIDENTIAL"},
-        {"name": "Barry Square", "lat": 41.7450, "lng": -72.6800, "type": "RESIDENTIAL"},
-        {"name": "South End", "lat": 41.7400, "lng": -72.6750, "type": "RESIDENTIAL"},
-        {"name": "Blue Hills", "lat": 41.7850, "lng": -72.7050, "type": "RESIDENTIAL"},
-        {"name": "Parkville", "lat": 41.7650, "lng": -72.7100, "type": "RESIDENTIAL"},
-        {"name": "Behind the Rocks", "lat": 41.7550, "lng": -72.7050, "type": "RESIDENTIAL"},
-        {"name": "Charter Oak", "lat": 41.7495, "lng": -72.6650, "type": "RESIDENTIAL"},
-        {"name": "Sheldon Charter Oak", "lat": 41.7510, "lng": -72.6700, "type": "RESIDENTIAL"},
-        {"name": "Clay Arsenal", "lat": 41.7750, "lng": -72.6850, "type": "RESIDENTIAL"},
-        {"name": "Upper Albany", "lat": 41.7780, "lng": -72.6950, "type": "RESIDENTIAL"},
-    ],
-}
-
-# Florence real locations
-FIRENZE_REAL_LOCATIONS = {
-    "depots": [
-        {"name": "Centro Storico Depot", "lat": 43.7696, "lng": 11.2558},
-        {"name": "Santa Maria Novella Depot", "lat": 43.7745, "lng": 11.2487},
-        {"name": "Campo di Marte Depot", "lat": 43.7820, "lng": 11.2820},
-        {"name": "Rifredi Depot", "lat": 43.7950, "lng": 11.2410},
-        {"name": "Novoli Depot", "lat": 43.7880, "lng": 11.2220},
-        {"name": "Gavinana Depot", "lat": 43.7520, "lng": 11.2680},
-    ],
-    "visits": [
-        # Restaurants
-        {"name": "Trattoria Mario", "lat": 43.7750, "lng": 11.2530, "type": "RESTAURANT"},
-        {"name": "Buca Mario", "lat": 43.7698, "lng": 11.2505, "type": "RESTAURANT"},
-        {"name": "Il Latini", "lat": 43.7705, "lng": 11.2495, "type": "RESTAURANT"},
-        {"name": "Osteria dell'Enoteca", "lat": 43.7680, "lng": 11.2545, "type": "RESTAURANT"},
-        {"name": "Trattoria Sostanza", "lat": 43.7735, "lng": 11.2470, "type": "RESTAURANT"},
-        {"name": "All'Antico Vinaio", "lat": 43.7690, "lng": 11.2570, "type": "RESTAURANT"},
-        {"name": "Mercato Centrale", "lat": 43.7762, "lng": 11.2540, "type": "RESTAURANT"},
-        {"name": "Cibreo", "lat": 43.7702, "lng": 11.2670, "type": "RESTAURANT"},
-        {"name": "Ora d'Aria", "lat": 43.7710, "lng": 11.2610, "type": "RESTAURANT"},
-        {"name": "Buca Lapi", "lat": 43.7720, "lng": 11.2535, "type": "RESTAURANT"},
-        {"name": "Il Palagio", "lat": 43.7680, "lng": 11.2550, "type": "RESTAURANT"},
-        {"name": "Enoteca Pinchiorri", "lat": 43.7695, "lng": 11.2620, "type": "RESTAURANT"},
-        {"name": "La Giostra", "lat": 43.7745, "lng": 11.2650, "type": "RESTAURANT"},
-        {"name": "Fishing Lab", "lat": 43.7730, "lng": 11.2560, "type": "RESTAURANT"},
-        {"name": "Trattoria Cammillo", "lat": 43.7665, "lng": 11.2520, "type": "RESTAURANT"},
-
-        # Businesses
-        {"name": "Palazzo Vecchio", "lat": 43.7693, "lng": 11.2563, "type": "BUSINESS"},
-        {"name": "Uffizi Gallery", "lat": 43.7677, "lng": 11.2553, "type": "BUSINESS"},
-        {"name": "Gucci Garden", "lat": 43.7692, "lng": 11.2556, "type": "BUSINESS"},
-        {"name": "Ferragamo Museum", "lat": 43.7700, "lng": 11.2530, "type": "BUSINESS"},
-        {"name": "Ospedale Santa Maria", "lat": 43.7830, "lng": 11.2690, "type": "BUSINESS"},
-        {"name": "Universita degli Studi", "lat": 43.7765, "lng": 11.2555, "type": "BUSINESS"},
-        {"name": "Palazzo Strozzi", "lat": 43.7706, "lng": 11.2515, "type": "BUSINESS"},
-        {"name": "Biblioteca Nazionale", "lat": 43.7660, "lng": 11.2650, "type": "BUSINESS"},
-        {"name": "Teatro del Maggio", "lat": 43.7780, "lng": 11.2470, "type": "BUSINESS"},
-        {"name": "Palazzo Pitti", "lat": 43.7650, "lng": 11.2500, "type": "BUSINESS"},
-        {"name": "Accademia Gallery", "lat": 43.7768, "lng": 11.2590, "type": "BUSINESS"},
-        {"name": "Ospedale Meyer", "lat": 43.7910, "lng": 11.2520, "type": "BUSINESS"},
-        {"name": "Polo Universitario", "lat": 43.7920, "lng": 11.2180, "type": "BUSINESS"},
-
-        # Residential
-        {"name": "Santo Spirito", "lat": 43.7665, "lng": 11.2470, "type": "RESIDENTIAL"},
-        {"name": "San Frediano", "lat": 43.7680, "lng": 11.2420, "type": "RESIDENTIAL"},
-        {"name": "Santa Croce", "lat": 43.7688, "lng": 11.2620, "type": "RESIDENTIAL"},
-        {"name": "San Lorenzo", "lat": 43.7755, "lng": 11.2540, "type": "RESIDENTIAL"},
-        {"name": "San Marco", "lat": 43.7780, "lng": 11.2585, "type": "RESIDENTIAL"},
-        {"name": "Sant'Ambrogio", "lat": 43.7705, "lng": 11.2680, "type": "RESIDENTIAL"},
-        {"name": "Campo di Marte", "lat": 43.7820, "lng": 11.2820, "type": "RESIDENTIAL"},
-        {"name": "Novoli", "lat": 43.7880, "lng": 11.2220, "type": "RESIDENTIAL"},
-        {"name": "Rifredi", "lat": 43.7950, "lng": 11.2410, "type": "RESIDENTIAL"},
-        {"name": "Le Cure", "lat": 43.7890, "lng": 11.2580, "type": "RESIDENTIAL"},
-        {"name": "Careggi", "lat": 43.8020, "lng": 11.2530, "type": "RESIDENTIAL"},
-        {"name": "Peretola", "lat": 43.7960, "lng": 11.2050, "type": "RESIDENTIAL"},
-        {"name": "Isolotto", "lat": 43.7620, "lng": 11.2200, "type": "RESIDENTIAL"},
-        {"name": "Gavinana", "lat": 43.7520, "lng": 11.2680, "type": "RESIDENTIAL"},
-        {"name": "Galluzzo", "lat": 43.7400, "lng": 11.2480, "type": "RESIDENTIAL"},
-        {"name": "Porta Romana", "lat": 43.7610, "lng": 11.2560, "type": "RESIDENTIAL"},
-        {"name": "Bellosguardo", "lat": 43.7650, "lng": 11.2350, "type": "RESIDENTIAL"},
-        {"name": "Arcetri", "lat": 43.7500, "lng": 11.2530, "type": "RESIDENTIAL"},
-        {"name": "Fiesole", "lat": 43.8055, "lng": 11.2935, "type": "RESIDENTIAL"},
-        {"name": "Settignano", "lat": 43.7850, "lng": 11.3100, "type": "RESIDENTIAL"},
-    ],
-}
-
-# Map demo data enum names to their real location data
-REAL_LOCATION_DATA = {
-    "PHILADELPHIA": PHILADELPHIA_REAL_LOCATIONS,
-    "HARTFORT": HARTFORD_REAL_LOCATIONS,
-    "FIRENZE": FIRENZE_REAL_LOCATIONS,
-}
-
-# Vehicle names using phonetic alphabet for clear identification
-VEHICLE_NAMES = ("Alpha", "Bravo", "Charlie", "Delta", "Echo", "Foxtrot", "Golf", "Hotel", "India", "Juliet")
-
-
-class CustomerType(Enum):
-    """
-    Customer types with realistic time windows, demand patterns, and service durations.
-
-    Each customer type reflects real-world delivery scenarios:
-    - RESIDENTIAL: Evening deliveries when people are home from work (5-10 min unload)
-    - BUSINESS: Standard business hours with larger orders (15-30 min unload, paperwork)
-    - RESTAURANT: Early morning before lunch prep rush (20-40 min for bulk unload, inspection)
-    """
-    # (label, window_start, window_end, min_demand, max_demand, min_service_min, max_service_min)
-    RESIDENTIAL = ("residential", time(17, 0), time(20, 0), 1, 2, 5, 10)
-    BUSINESS = ("business", time(9, 0), time(17, 0), 3, 6, 15, 30)
-    RESTAURANT = ("restaurant", time(6, 0), time(10, 0), 5, 10, 20, 40)
-
-    def __init__(self, label: str, window_start: time, window_end: time,
-                 min_demand: int, max_demand: int, min_service_minutes: int, max_service_minutes: int):
-        self.label = label
-        self.window_start = window_start
-        self.window_end = window_end
-        self.min_demand = min_demand
-        self.max_demand = max_demand
-        self.min_service_minutes = min_service_minutes
-        self.max_service_minutes = max_service_minutes
-
-
-# Weighted distribution: 50% residential, 30% business, 20% restaurant
-CUSTOMER_TYPE_WEIGHTS = [
-    (CustomerType.RESIDENTIAL, 50),
-    (CustomerType.BUSINESS, 30),
-    (CustomerType.RESTAURANT, 20),
-]
-
-
-def random_customer_type(random: Random) -> CustomerType:
-    """Weighted random selection of customer type."""
-    total = sum(w for _, w in CUSTOMER_TYPE_WEIGHTS)
-    r = random.randint(1, total)
-    cumulative = 0
-    for ctype, weight in CUSTOMER_TYPE_WEIGHTS:
-        cumulative += weight
-        if r <= cumulative:
-            return ctype
-    return CustomerType.RESIDENTIAL  # fallback
-
-
-@dataclass
-class _DemoDataProperties:
-    seed: int
-    visit_count: int
-    vehicle_count: int
-    vehicle_start_time: time
-    min_vehicle_capacity: int
-    max_vehicle_capacity: int
-    south_west_corner: Location
-    north_east_corner: Location
-
-    def __post_init__(self):
-        if self.min_vehicle_capacity < 1:
-            raise ValueError(f"Number of minVehicleCapacity ({self.min_vehicle_capacity}) must be greater than zero.")
-        if self.max_vehicle_capacity < 1:
-            raise ValueError(f"Number of maxVehicleCapacity ({self.max_vehicle_capacity}) must be greater than zero.")
-        if self.min_vehicle_capacity >= self.max_vehicle_capacity:
-            raise ValueError(f"maxVehicleCapacity ({self.max_vehicle_capacity}) must be greater than "
-                             f"minVehicleCapacity ({self.min_vehicle_capacity}).")
-        if self.visit_count < 1:
-            raise ValueError(f"Number of visitCount ({self.visit_count}) must be greater than zero.")
-        if self.vehicle_count < 1:
-            raise ValueError(f"Number of vehicleCount ({self.vehicle_count}) must be greater than zero.")
-        if self.north_east_corner.latitude <= self.south_west_corner.latitude:
-            raise ValueError(f"northEastCorner.getLatitude ({self.north_east_corner.latitude}) must be greater than "
-                             f"southWestCorner.getLatitude({self.south_west_corner.latitude}).")
-        if self.north_east_corner.longitude <= self.south_west_corner.longitude:
-            raise ValueError(f"northEastCorner.getLongitude ({self.north_east_corner.longitude}) must be greater than "
-                             f"southWestCorner.getLongitude({self.south_west_corner.longitude}).")
-
-
-class DemoData(Enum):
-    # Bounding boxes tightened to ~5x5 km around actual location data
-    # for faster OSMnx network downloads (smaller area = faster download)
-
-    # Philadelphia: Center City area (~39.92 to 39.99 lat, -75.22 to -75.11 lng)
-    PHILADELPHIA = _DemoDataProperties(0, 55, 6, time(6, 0),
-                                       15, 30,
-                                       Location(latitude=39.92,
-                                                longitude=-75.23),
-                                       Location(latitude=40.00,
-                                                longitude=-75.11))
-
-    # Hartford: Downtown area (~41.69 to 41.79 lat, -72.75 to -72.60 lng)
-    HARTFORT = _DemoDataProperties(1, 50, 6, time(6, 0),
-                                   20, 30,
-                                   Location(latitude=41.69,
-                                            longitude=-72.75),
-                                   Location(latitude=41.79,
-                                            longitude=-72.60))
-
-    # Firenze: Historic center area
-    FIRENZE = _DemoDataProperties(2, 77, 6, time(6, 0),
-                                  20, 40,
-                                  Location(latitude=43.73,
-                                           longitude=11.17),
-                                  Location(latitude=43.81,
-                                           longitude=11.32))
-
-
-def doubles(random: Random, start: float, end: float) -> Generator[float, None, None]:
-    while True:
-        yield random.uniform(start, end)
-
-
-def ints(random: Random, start: int, end: int) -> Generator[int, None, None]:
-    while True:
-        yield random.randrange(start, end)
-
-
-T = TypeVar('T')
-
-
-def values(random: Random, sequence: Sequence[T]) -> Generator[T, None, None]:
-    start = 0
-    end = len(sequence) - 1
-    while True:
-        yield sequence[random.randint(start, end)]
-
-
-def generate_names(random: Random) -> Generator[str, None, None]:
-    while True:
-        yield f'{random.choice(FIRST_NAMES)} {random.choice(LAST_NAMES)}'
-
-
-def generate_demo_data(demo_data_enum: DemoData) -> VehicleRoutePlan:
-    """
-    Generate demo data for vehicle routing using real street addresses.
-
-    Uses actual locations on the road network for realistic routing:
-    - Residential (50%): Evening windows (17:00-20:00), small orders (1-2 units)
-    - Business (30%): Business hours (09:00-17:00), medium orders (3-6 units)
-    - Restaurant (20%): Early morning (06:00-10:00), large orders (5-10 units)
-
-    Args:
-        demo_data_enum: The demo data configuration to use
-    """
-    name = "demo"
-    demo_data = demo_data_enum.value
-    random = Random(demo_data.seed)
-
-    # Get real location data for this demo
-    real_locations = REAL_LOCATION_DATA.get(demo_data_enum.name)
-
-    vehicle_capacities = ints(random, demo_data.min_vehicle_capacity,
-                              demo_data.max_vehicle_capacity + 1)
-
-    if real_locations:
-        # Use real depot locations
-        depot_locations = real_locations["depots"]
-        vehicles = []
-        for i in range(demo_data.vehicle_count):
-            depot = depot_locations[i % len(depot_locations)]
-            vehicles.append(
-                Vehicle(
-                    id=str(i),
-                    name=VEHICLE_NAMES[i % len(VEHICLE_NAMES)],
-                    capacity=next(vehicle_capacities),
-                    home_location=Location(latitude=depot["lat"], longitude=depot["lng"]),
-                    departure_time=datetime.combine(
-                        date.today() + timedelta(days=1), demo_data.vehicle_start_time
-                    ),
-                )
-            )
-    else:
-        # Fallback to random locations within bounding box
-        latitudes = doubles(random, demo_data.south_west_corner.latitude, demo_data.north_east_corner.latitude)
-        longitudes = doubles(random, demo_data.south_west_corner.longitude, demo_data.north_east_corner.longitude)
-        vehicles = [
-            Vehicle(
-                id=str(i),
-                name=VEHICLE_NAMES[i % len(VEHICLE_NAMES)],
-                capacity=next(vehicle_capacities),
-                home_location=Location(latitude=next(latitudes), longitude=next(longitudes)),
-                departure_time=datetime.combine(
-                    date.today() + timedelta(days=1), demo_data.vehicle_start_time
-                ),
-            )
-            for i in range(demo_data.vehicle_count)
-        ]
-
-    tomorrow = date.today() + timedelta(days=1)
-    visits = []
-
-    if real_locations:
-        # Use real visit locations with their actual types
-        visit_locations = real_locations["visits"]
-        # Shuffle to get variety, but use seed for reproducibility
-        shuffled_visits = list(visit_locations)
-        random.shuffle(shuffled_visits)
-
-        for i in range(min(demo_data.visit_count, len(shuffled_visits))):
-            loc_data = shuffled_visits[i]
-            # Get customer type from location data
-            ctype_name = loc_data.get("type", "RESIDENTIAL")
-            ctype = CustomerType[ctype_name]
-            service_minutes = random.randint(ctype.min_service_minutes, ctype.max_service_minutes)
-
-            visits.append(
-                Visit(
-                    id=str(i),
-                    name=loc_data["name"],
-                    location=Location(latitude=loc_data["lat"], longitude=loc_data["lng"]),
-                    demand=random.randint(ctype.min_demand, ctype.max_demand),
-                    min_start_time=datetime.combine(tomorrow, ctype.window_start),
-                    max_end_time=datetime.combine(tomorrow, ctype.window_end),
-                    service_duration=timedelta(minutes=service_minutes),
-                )
-            )
-
-        # If we need more visits than we have real locations, generate additional random ones
-        if demo_data.visit_count > len(shuffled_visits):
-            names = generate_names(random)
-            latitudes = doubles(random, demo_data.south_west_corner.latitude, demo_data.north_east_corner.latitude)
-            longitudes = doubles(random, demo_data.south_west_corner.longitude, demo_data.north_east_corner.longitude)
-
-            for i in range(len(shuffled_visits), demo_data.visit_count):
-                ctype = random_customer_type(random)
-                service_minutes = random.randint(ctype.min_service_minutes, ctype.max_service_minutes)
-                visits.append(
-                    Visit(
-                        id=str(i),
-                        name=next(names),
-                        location=Location(latitude=next(latitudes), longitude=next(longitudes)),
-                        demand=random.randint(ctype.min_demand, ctype.max_demand),
-                        min_start_time=datetime.combine(tomorrow, ctype.window_start),
-                        max_end_time=datetime.combine(tomorrow, ctype.window_end),
-                        service_duration=timedelta(minutes=service_minutes),
-                    )
-                )
-    else:
-        # Fallback to fully random locations
-        names = generate_names(random)
-        latitudes = doubles(random, demo_data.south_west_corner.latitude, demo_data.north_east_corner.latitude)
-        longitudes = doubles(random, demo_data.south_west_corner.longitude, demo_data.north_east_corner.longitude)
-
-        for i in range(demo_data.visit_count):
-            ctype = random_customer_type(random)
-            service_minutes = random.randint(ctype.min_service_minutes, ctype.max_service_minutes)
-            visits.append(
-                Visit(
-                    id=str(i),
-                    name=next(names),
-                    location=Location(latitude=next(latitudes), longitude=next(longitudes)),
-                    demand=random.randint(ctype.min_demand, ctype.max_demand),
-                    min_start_time=datetime.combine(tomorrow, ctype.window_start),
-                    max_end_time=datetime.combine(tomorrow, ctype.window_end),
-                    service_duration=timedelta(minutes=service_minutes),
-                )
-            )
-
-    return VehicleRoutePlan(
-        name=name,
-        south_west_corner=demo_data.south_west_corner,
-        north_east_corner=demo_data.north_east_corner,
-        vehicles=vehicles,
-        visits=visits,
-    )
-
-
-def tomorrow_at(local_time: time) -> datetime:
-    return datetime.combine(date.today(), local_time)

src/vehicle_routing/domain.py

@@ -1,371 +0,0 @@
-from solverforge_legacy.solver import SolverStatus
-from solverforge_legacy.solver.score import HardSoftScore
-from solverforge_legacy.solver.domain import (
-    planning_entity,
-    planning_solution,
-    PlanningId,
-    PlanningScore,
-    PlanningListVariable,
-    PlanningEntityCollectionProperty,
-    ValueRangeProvider,
-    InverseRelationShadowVariable,
-    PreviousElementShadowVariable,
-    NextElementShadowVariable,
-    CascadingUpdateShadowVariable,
-)
-
-from datetime import datetime, timedelta
-from typing import Annotated, Optional, List, Union, ClassVar, TYPE_CHECKING
-from dataclasses import dataclass, field
-from .json_serialization import JsonDomainBase
-from pydantic import Field
-
-if TYPE_CHECKING:
-    from .routing import DistanceMatrix
-
-
-@dataclass
-class Location:
-    """
-    Represents a geographic location with latitude and longitude.
-
-    Driving times can be computed using either:
-    1. A precomputed distance matrix (if set) - uses real road network data
-    2. The Haversine formula (fallback) - uses great-circle distance
-    """
-    latitude: float
-    longitude: float
-
-    # Class-level distance matrix (injected at problem load time)
-    _distance_matrix: ClassVar[Optional["DistanceMatrix"]] = None
-
-    # Earth radius in meters
-    _EARTH_RADIUS_M = 6371000
-    _TWICE_EARTH_RADIUS_M = 2 * _EARTH_RADIUS_M
-    # Average driving speed assumption: 50 km/h
-    _AVERAGE_SPEED_KMPH = 50
-
-    @classmethod
-    def set_distance_matrix(cls, matrix: "DistanceMatrix") -> None:
-        """Inject a precomputed distance matrix for real road routing."""
-        cls._distance_matrix = matrix
-
-    @classmethod
-    def clear_distance_matrix(cls) -> None:
-        """Clear the distance matrix (reverts to haversine fallback)."""
-        cls._distance_matrix = None
-
-    @classmethod
-    def get_distance_matrix(cls) -> Optional["DistanceMatrix"]:
-        """Get the current distance matrix, if any."""
-        return cls._distance_matrix
-
-    def driving_time_to(self, other: "Location") -> int:
-        """
-        Get driving time in seconds to another location.
-
-        Uses the precomputed distance matrix if available, otherwise
-        falls back to haversine calculation.
-        """
-        if self._distance_matrix is not None:
-            return self._distance_matrix.get_driving_time(self, other)
-        return self._calculate_driving_time_haversine(other)
-
-    def _calculate_driving_time_haversine(self, other: "Location") -> int:
-        """
-        Calculate driving time in seconds using Haversine distance.
-
-        Algorithm:
-        1. Convert lat/long to 3D Cartesian coordinates on a unit sphere
-        2. Calculate Euclidean distance between the two points
-        3. Use the arc sine formula to get the great-circle distance
-        4. Convert meters to driving seconds assuming average speed
-        """
-        if self.latitude == other.latitude and self.longitude == other.longitude:
-            return 0
-
-        from_cartesian = self._to_cartesian()
-        to_cartesian = other._to_cartesian()
-        distance_meters = self._calculate_distance(from_cartesian, to_cartesian)
-        return self._meters_to_driving_seconds(distance_meters)
-
-    def _to_cartesian(self) -> tuple[float, float, float, float]:
-        """Convert latitude/longitude to 3D Cartesian coordinates on a unit sphere."""
-        import math
-        lat_rad = math.radians(self.latitude)
-        lon_rad = math.radians(self.longitude)
-        # Cartesian coordinates, normalized for a sphere of diameter 1.0
-        x = 0.5 * math.cos(lat_rad) * math.sin(lon_rad)
-        y = 0.5 * math.cos(lat_rad) * math.cos(lon_rad)
-        z = 0.5 * math.sin(lat_rad)
-        return (x, y, z)
-
-    def _calculate_distance(self, from_c: tuple[float, float, float, float], to_c: tuple[float, float, float, float]) -> int:
-        """Calculate great-circle distance in meters between two Cartesian points."""
-        import math
-        dx = from_c[0] - to_c[0]
-        dy = from_c[1] - to_c[1]
-        dz = from_c[2] - to_c[2]
-        r = math.sqrt(dx * dx + dy * dy + dz * dz)
-        return round(self._TWICE_EARTH_RADIUS_M * math.asin(r))
-
-    @classmethod
-    def _meters_to_driving_seconds(cls, meters: int) -> int:
-        """Convert distance in meters to driving time in seconds."""
-        # Formula: seconds = meters / (km/h) * 3.6
-        # This is equivalent to: seconds = meters / (speed_m_per_s)
-        # where speed_m_per_s = km/h / 3.6
-        return round(meters / cls._AVERAGE_SPEED_KMPH * 3.6)
-
-    def __str__(self):
-        return f"[{self.latitude}, {self.longitude}]"
-
-    def __repr__(self):
-        return f"Location({self.latitude}, {self.longitude})"
-
-
-@planning_entity
-@dataclass
-class Visit:
-    id: Annotated[str, PlanningId]
-    name: str
-    location: Location
-    demand: int
-    min_start_time: datetime
-    max_end_time: datetime
-    service_duration: timedelta
-    vehicle: Annotated[
-        Optional["Vehicle"],
-        InverseRelationShadowVariable(source_variable_name="visits"),
-    ] = None
-    previous_visit: Annotated[
-        Optional["Visit"], PreviousElementShadowVariable(source_variable_name="visits")
-    ] = None
-    next_visit: Annotated[
-        Optional["Visit"], NextElementShadowVariable(source_variable_name="visits")
-    ] = None
-    arrival_time: Annotated[
-        Optional[datetime],
-        CascadingUpdateShadowVariable(target_method_name="update_arrival_time"),
-    ] = None
-
-    def update_arrival_time(self):
-        if self.vehicle is None or (
-            self.previous_visit is not None and self.previous_visit.arrival_time is None
-        ):
-            self.arrival_time = None
-        elif self.previous_visit is None:
-            self.arrival_time = self.vehicle.departure_time + timedelta(
-                seconds=self.vehicle.home_location.driving_time_to(self.location)
-            )
-        else:
-            self.arrival_time = (
-                self.previous_visit.calculate_departure_time()
-                + timedelta(
-                    seconds=self.previous_visit.location.driving_time_to(self.location)
-                )
-            )
-
-    def calculate_departure_time(self):
-        if self.arrival_time is None:
-            return None
-
-        return max(self.arrival_time, self.min_start_time) + self.service_duration
-
-    @property
-    def departure_time(self) -> Optional[datetime]:
-        return self.calculate_departure_time()
-
-    @property
-    def start_service_time(self) -> Optional[datetime]:
-        if self.arrival_time is None:
-            return None
-        return max(self.arrival_time, self.min_start_time)
-
-    def is_service_finished_after_max_end_time(self) -> bool:
-        return (
-            self.arrival_time is not None
-            and self.calculate_departure_time() > self.max_end_time
-        )
-
-    def service_finished_delay_in_minutes(self) -> int:
-        if self.arrival_time is None:
-            return 0
-        # Round up to next minute using the negative division trick:
-        # ex: 30 seconds / -1 minute = -0.5,
-        # so 30 seconds // -1 minute = -1,
-        # and negating that gives 1
-        return -(
-            (self.calculate_departure_time() - self.max_end_time)
-            // timedelta(minutes=-1)
-        )
-
-    @property
-    def driving_time_seconds_from_previous_standstill(self) -> Optional[int]:
-        if self.vehicle is None:
-            return None
-
-        if self.previous_visit is None:
-            return self.vehicle.home_location.driving_time_to(self.location)
-        else:
-            return self.previous_visit.location.driving_time_to(self.location)
-
-    def __str__(self):
-        return self.id
-
-    def __repr__(self):
-        return f"Visit({self.id})"
-
-
-@planning_entity
-@dataclass
-class Vehicle:
-    id: Annotated[str, PlanningId]
-    name: str
-    capacity: int
-    home_location: Location
-    departure_time: datetime
-    visits: Annotated[list[Visit], PlanningListVariable] = field(default_factory=list)
-
-    @property
-    def arrival_time(self) -> datetime:
-        if len(self.visits) == 0:
-            return self.departure_time
-        return self.visits[-1].departure_time + timedelta(
-            seconds=self.visits[-1].location.driving_time_to(self.home_location)
-        )
-
-    @property
-    def total_demand(self) -> int:
-        return self.calculate_total_demand()
-
-    @property
-    def total_driving_time_seconds(self) -> int:
-        return self.calculate_total_driving_time_seconds()
-
-    def calculate_total_demand(self) -> int:
-        total_demand = 0
-        for visit in self.visits:
-            total_demand += visit.demand
-        return total_demand
-
-    def calculate_total_driving_time_seconds(self) -> int:
-        if len(self.visits) == 0:
-            return 0
-        total_driving_time_seconds = 0
-        previous_location = self.home_location
-
-        for visit in self.visits:
-            total_driving_time_seconds += previous_location.driving_time_to(
-                visit.location
-            )
-            previous_location = visit.location
-
-        total_driving_time_seconds += previous_location.driving_time_to(
-            self.home_location
-        )
-        return total_driving_time_seconds
-
-    def __str__(self):
-        return self.name
-
-    def __repr__(self):
-        return f"Vehicle({self.id}, {self.name})"
-
-
-@planning_solution
-@dataclass
-class VehicleRoutePlan:
-    name: str
-    south_west_corner: Location
-    north_east_corner: Location
-    vehicles: Annotated[list[Vehicle], PlanningEntityCollectionProperty]
-    visits: Annotated[list[Visit], PlanningEntityCollectionProperty, ValueRangeProvider]
-    score: Annotated[Optional[HardSoftScore], PlanningScore] = None
-    solver_status: SolverStatus = SolverStatus.NOT_SOLVING
-
-    @property
-    def total_driving_time_seconds(self) -> int:
-        out = 0
-        for vehicle in self.vehicles:
-            out += vehicle.total_driving_time_seconds
-        return out
-
-    @property
-    def start_date_time(self) -> Optional[datetime]:
-        """Earliest vehicle departure time - for timeline window."""
-        if not self.vehicles:
-            return None
-        return min(v.departure_time for v in self.vehicles)
-
-    @property
-    def end_date_time(self) -> Optional[datetime]:
-        """Latest vehicle arrival time - for timeline window."""
-        if not self.vehicles:
-            return None
-        return max(v.arrival_time for v in self.vehicles)
-
-    def __str__(self):
-        return f"VehicleRoutePlan(name={self.name}, vehicles={self.vehicles}, visits={self.visits})"
-
-
-# Pydantic REST models for API (used for deserialization and context)
-class LocationModel(JsonDomainBase):
-    latitude: float
-    longitude: float
-
-
-class VisitModel(JsonDomainBase):
-    id: str
-    name: str
-    location: List[float]  # [lat, lng] array
-    demand: int
-    min_start_time: str = Field(..., alias="minStartTime")  # ISO datetime string
-    max_end_time: str = Field(..., alias="maxEndTime")  # ISO datetime string
-    service_duration: int = Field(..., alias="serviceDuration")  # Duration in seconds
-    vehicle: Union[str, "VehicleModel", None] = None
-    previous_visit: Union[str, "VisitModel", None] = Field(None, alias="previousVisit")
-    next_visit: Union[str, "VisitModel", None] = Field(None, alias="nextVisit")
-    arrival_time: Optional[str] = Field(
-        None, alias="arrivalTime"
-    )  # ISO datetime string
-    start_service_time: Optional[str] = Field(
-        None, alias="startServiceTime"
-    )  # ISO datetime string
-    departure_time: Optional[str] = Field(
-        None, alias="departureTime"
-    )  # ISO datetime string
-    driving_time_seconds_from_previous_standstill: Optional[int] = Field(
-        None, alias="drivingTimeSecondsFromPreviousStandstill"
-    )
-
-
-class VehicleModel(JsonDomainBase):
-    id: str
-    name: str
-    capacity: int
-    home_location: List[float] = Field(..., alias="homeLocation")  # [lat, lng] array
-    departure_time: str = Field(..., alias="departureTime")  # ISO datetime string
-    visits: List[Union[str, VisitModel]] = Field(default_factory=list)
-    total_demand: int = Field(0, alias="totalDemand")
-    total_driving_time_seconds: int = Field(0, alias="totalDrivingTimeSeconds")
-    arrival_time: Optional[str] = Field(
-        None, alias="arrivalTime"
-    )  # ISO datetime string
-
-
-class VehicleRoutePlanModel(JsonDomainBase):
-    name: str
-    south_west_corner: List[float] = Field(
-        ..., alias="southWestCorner"
-    )  # [lat, lng] array
-    north_east_corner: List[float] = Field(
-        ..., alias="northEastCorner"
-    )  # [lat, lng] array
-    vehicles: List[VehicleModel]
-    visits: List[VisitModel]
-    score: Optional[str] = None
-    solver_status: Optional[str] = None
-    total_driving_time_seconds: int = Field(0, alias="totalDrivingTimeSeconds")
-    start_date_time: Optional[str] = Field(None, alias="startDateTime")
-    end_date_time: Optional[str] = Field(None, alias="endDateTime")

src/vehicle_routing/json_serialization.py

@@ -1,85 +0,0 @@
-from solverforge_legacy.solver.score import HardSoftScore
-
-from typing import Any
-from datetime import timedelta
-from pydantic import (
-    BaseModel,
-    ConfigDict,
-    PlainSerializer,
-    BeforeValidator,
-    ValidationInfo,
-)
-from pydantic.alias_generators import to_camel
-
-
-class JsonDomainBase(BaseModel):
-    model_config = ConfigDict(
-        alias_generator=to_camel,
-        populate_by_name=True,
-        from_attributes=True,
-    )
-
-
-def make_id_item_validator(key: str):
-    def validator(v: Any, info: ValidationInfo) -> Any:
-        if v is None:
-            return None
-
-        if not isinstance(v, str) or not info.context:
-            return v
-
-        return info.context.get(key)[v]
-
-    return BeforeValidator(validator)
-
-
-def make_id_list_item_validator(key: str):
-    def validator(v: Any, info: ValidationInfo) -> Any:
-        if v is None:
-            return None
-
-        if isinstance(v, (list, tuple)):
-            out = []
-            for item in v:
-                if not isinstance(v, str) or not info.context:
-                    return v
-                out.append(info.context.get(key)[item])
-            return out
-
-        return v
-
-    return BeforeValidator(validator)
-
-
-LocationSerializer = PlainSerializer(
-    lambda location: [
-        location.latitude,
-        location.longitude,
-    ],
-    return_type=list[float],
-)
-ScoreSerializer = PlainSerializer(lambda score: str(score), return_type=str)
-IdSerializer = PlainSerializer(
-    lambda item: item.id if item is not None else None, return_type=str | None
-)
-IdListSerializer = PlainSerializer(
-    lambda items: [item.id for item in items], return_type=list
-)
-DurationSerializer = PlainSerializer(
-    lambda duration: duration // timedelta(seconds=1), return_type=int
-)
-
-VisitListValidator = make_id_list_item_validator("visits")
-VisitValidator = make_id_item_validator("visits")
-VehicleValidator = make_id_item_validator("vehicles")
-
-
-def validate_score(v: Any, info: ValidationInfo) -> Any:
-    if isinstance(v, HardSoftScore) or v is None:
-        return v
-    if isinstance(v, str):
-        return HardSoftScore.parse(v)
-    raise ValueError('"score" should be a string')
-
-
-ScoreValidator = BeforeValidator(validate_score)

src/vehicle_routing/rest_api.py

@@ -1,524 +0,0 @@
-from fastapi import FastAPI, HTTPException, Query
-from fastapi.staticfiles import StaticFiles
-from fastapi.responses import StreamingResponse
-from uuid import uuid4
-from typing import Dict, List, Optional
-from dataclasses import asdict
-from enum import Enum
-import logging
-import json
-import asyncio
-
-from .domain import VehicleRoutePlan, Location
-from .converters import plan_to_model, model_to_plan
-from .domain import VehicleRoutePlanModel
-from .score_analysis import ConstraintAnalysisDTO, MatchAnalysisDTO
-from .demo_data import generate_demo_data, DemoData
-from .solver import solver_manager, solution_manager
-from .routing import compute_distance_matrix_with_progress, DistanceMatrix
-from pydantic import BaseModel, Field
-
-
-class RoutingMode(str, Enum):
-    """Routing mode for distance calculations."""
-    HAVERSINE = "haversine"  # Fast, straight-line estimation
-    REAL_ROADS = "real_roads"  # Slower, uses OSMnx for real road routes
-
-logger = logging.getLogger(__name__)
-
-app = FastAPI(docs_url='/q/swagger-ui')
-
-data_sets: Dict[str, VehicleRoutePlan] = {}
-
-
-# Request/Response models for recommendation endpoints
-class VehicleRecommendation(BaseModel):
-    """Recommendation for assigning a visit to a vehicle at a specific index."""
-    vehicle_id: str = Field(..., alias="vehicleId")
-    index: int
-
-    class Config:
-        populate_by_name = True
-
-
-class RecommendedAssignmentResponse(BaseModel):
-    """Response from the recommendation API."""
-    proposition: VehicleRecommendation
-    score_diff: str = Field(..., alias="scoreDiff")
-
-    class Config:
-        populate_by_name = True
-
-
-class RecommendationRequest(BaseModel):
-    """Request for visit assignment recommendations."""
-    solution: VehicleRoutePlanModel
-    visit_id: str = Field(..., alias="visitId")
-
-    class Config:
-        populate_by_name = True
-
-
-class ApplyRecommendationRequest(BaseModel):
-    """Request to apply a recommendation."""
-    solution: VehicleRoutePlanModel
-    visit_id: str = Field(..., alias="visitId")
-    vehicle_id: str = Field(..., alias="vehicleId")
-    index: int
-
-    class Config:
-        populate_by_name = True
-
-
-def json_to_vehicle_route_plan(json_data: dict) -> VehicleRoutePlan:
-    """Convert JSON data to VehicleRoutePlan using the model converters."""
-    plan_model = VehicleRoutePlanModel.model_validate(json_data)
-    return model_to_plan(plan_model)
-
-
-@app.get("/demo-data")
-async def get_demo_data():
-    """Get available demo data sets."""
-    return [demo.name for demo in DemoData]
-
-def _extract_all_locations(plan: VehicleRoutePlan) -> list[Location]:
-    """Extract all unique locations from a route plan."""
-    locations = []
-    seen = set()
-
-    for vehicle in plan.vehicles:
-        key = (vehicle.home_location.latitude, vehicle.home_location.longitude)
-        if key not in seen:
-            locations.append(vehicle.home_location)
-            seen.add(key)
-
-    for visit in plan.visits:
-        key = (visit.location.latitude, visit.location.longitude)
-        if key not in seen:
-            locations.append(visit.location)
-            seen.add(key)
-
-    return locations
-
-
-def _extract_route_geometries(plan: VehicleRoutePlan) -> Dict[str, List[Optional[str]]]:
-    """
-    Extract route geometries from the distance matrix for all vehicles.
-    Returns empty dict if no distance matrix is available.
-    """
-    distance_matrix = Location.get_distance_matrix()
-    if distance_matrix is None:
-        return {}
-
-    geometries: Dict[str, List[Optional[str]]] = {}
-
-    for vehicle in plan.vehicles:
-        segments: List[Optional[str]] = []
-
-        if not vehicle.visits:
-            geometries[vehicle.id] = segments
-            continue
-
-        # Segment from depot to first visit
-        prev_location = vehicle.home_location
-        for visit in vehicle.visits:
-            geometry = distance_matrix.get_geometry(prev_location, visit.location)
-            segments.append(geometry)
-            prev_location = visit.location
-
-        # Segment from last visit back to depot
-        geometry = distance_matrix.get_geometry(prev_location, vehicle.home_location)
-        segments.append(geometry)
-
-        geometries[vehicle.id] = segments
-
-    return geometries
-
-
-def _initialize_distance_matrix(
-    plan: VehicleRoutePlan,
-    use_real_roads: bool = False,
-    progress_callback=None
-) -> Optional[DistanceMatrix]:
-    """
-    Initialize the distance matrix for a route plan.
-
-    Args:
-        plan: The route plan with locations
-        use_real_roads: If True, use OSMnx for real road routing (slower)
-                       If False, use haversine estimation (fast, default)
-        progress_callback: Optional callback for progress updates
-
-    Returns the computed matrix, or None if routing failed.
-    """
-    locations = _extract_all_locations(plan)
-    if not locations:
-        return None
-
-    logger.info(f"Computing distance matrix for {len(locations)} locations (mode: {'real_roads' if use_real_roads else 'haversine'})...")
-
-    # Compute bounding box from the plan
-    bbox = (
-        plan.north_east_corner.latitude,
-        plan.south_west_corner.latitude,
-        plan.north_east_corner.longitude,
-        plan.south_west_corner.longitude,
-    )
-
-    try:
-        matrix = compute_distance_matrix_with_progress(
-            locations,
-            bbox=bbox,
-            use_osm=use_real_roads,
-            progress_callback=progress_callback
-        )
-        Location.set_distance_matrix(matrix)
-        logger.info("Distance matrix computed and set successfully")
-        return matrix
-    except Exception as e:
-        logger.warning(f"Failed to compute distance matrix: {e}")
-        return None
-
-
-@app.get("/demo-data/{demo_name}", response_model=VehicleRoutePlanModel)
-async def get_demo_data_by_name(
-    demo_name: str,
-    routing: RoutingMode = Query(
-        default=RoutingMode.HAVERSINE,
-        description="Routing mode: 'haversine' (fast, default) or 'real_roads' (slower, accurate)"
-    )
-) -> VehicleRoutePlanModel:
-    """
-    Get a specific demo data set.
-
-    Args:
-        demo_name: Name of the demo dataset (PHILADELPHIA, HARTFORT, FIRENZE)
-        routing: Routing mode - 'haversine' (fast default) or 'real_roads' (slower, accurate)
-
-    When routing=real_roads, computes the distance matrix using real road network
-    data (OSMnx) for accurate routing. The first call may take 5-15 seconds
-    to download the OSM network (cached for subsequent calls).
-    """
-    try:
-        demo_data = DemoData[demo_name]
-        domain_plan = generate_demo_data(demo_data)
-
-        # Initialize distance matrix with selected routing mode
-        use_real_roads = routing == RoutingMode.REAL_ROADS
-        _initialize_distance_matrix(domain_plan, use_real_roads=use_real_roads)
-
-        return plan_to_model(domain_plan)
-    except KeyError:
-        raise HTTPException(status_code=404, detail=f"Demo data '{demo_name}' not found")
-
-
-# Progress tracking for SSE
-_progress_queues: Dict[str, asyncio.Queue] = {}
-
-
-@app.get("/demo-data/{demo_name}/stream")
-async def get_demo_data_with_progress(
-    demo_name: str,
-    routing: RoutingMode = Query(
-        default=RoutingMode.HAVERSINE,
-        description="Routing mode: 'haversine' (fast, default) or 'real_roads' (slower, accurate)"
-    )
-):
-    """
-    Get demo data with Server-Sent Events (SSE) progress updates.
-
-    This endpoint streams progress updates while computing the distance matrix,
-    then returns the final solution. Use this when routing=real_roads and you
-    want to show progress to the user.
-
-    Events emitted:
-    - progress: {phase, message, percent, detail}
-    - complete: {solution: VehicleRoutePlanModel}
-    - error: {message}
-    """
-    async def generate():
-        try:
-            demo_data = DemoData[demo_name]
-            domain_plan = generate_demo_data(demo_data)
-
-            use_real_roads = routing == RoutingMode.REAL_ROADS
-
-            if not use_real_roads:
-                # Fast path - no progress needed for haversine
-                yield f"data: {json.dumps({'event': 'progress', 'phase': 'computing', 'message': 'Computing distances...', 'percent': 50})}\n\n"
-                _initialize_distance_matrix(domain_plan, use_real_roads=False)
-                yield f"data: {json.dumps({'event': 'progress', 'phase': 'complete', 'message': 'Ready!', 'percent': 100})}\n\n"
-                result = plan_to_model(domain_plan)
-                # Include geometries (straight lines in haversine mode)
-                geometries = _extract_route_geometries(domain_plan)
-                yield f"data: {json.dumps({'event': 'complete', 'solution': result.model_dump(by_alias=True), 'geometries': geometries})}\n\n"
-            else:
-                # Slow path - stream progress for OSMnx
-                progress_events = []
-
-                def progress_callback(phase: str, message: str, percent: int, detail: str = ""):
-                    progress_events.append({
-                        'event': 'progress',
-                        'phase': phase,
-                        'message': message,
-                        'percent': percent,
-                        'detail': detail
-                    })
-
-                # Run computation in thread pool to not block
-                import concurrent.futures
-                with concurrent.futures.ThreadPoolExecutor() as executor:
-                    future = executor.submit(
-                        _initialize_distance_matrix,
-                        domain_plan,
-                        use_real_roads=True,
-                        progress_callback=progress_callback
-                    )
-
-                    # Stream progress events while waiting
-                    last_sent = 0
-                    while not future.done():
-                        await asyncio.sleep(0.1)
-                        while last_sent < len(progress_events):
-                            yield f"data: {json.dumps(progress_events[last_sent])}\n\n"
-                            last_sent += 1
-
-                    # Send any remaining progress events
-                    while last_sent < len(progress_events):
-                        yield f"data: {json.dumps(progress_events[last_sent])}\n\n"
-                        last_sent += 1
-
-                    # Get result (will raise if exception occurred)
-                    future.result()
-
-                yield f"data: {json.dumps({'event': 'progress', 'phase': 'complete', 'message': 'Ready!', 'percent': 100})}\n\n"
-                result = plan_to_model(domain_plan)
-
-                # Include geometries in response for real roads mode
-                geometries = _extract_route_geometries(domain_plan)
-                yield f"data: {json.dumps({'event': 'complete', 'solution': result.model_dump(by_alias=True), 'geometries': geometries})}\n\n"
-
-        except KeyError:
-            yield f"data: {json.dumps({'event': 'error', 'message': f'Demo data not found: {demo_name}'})}\n\n"
-        except Exception as e:
-            logger.exception(f"Error in SSE stream: {e}")
-            yield f"data: {json.dumps({'event': 'error', 'message': str(e)})}\n\n"
-
-    return StreamingResponse(
-        generate(),
-        media_type="text/event-stream",
-        headers={
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive",
-            "X-Accel-Buffering": "no"
-        }
-    )
-
-
-@app.get("/route-plans/{problem_id}", response_model=VehicleRoutePlanModel, response_model_exclude_none=True)
-async def get_route(problem_id: str) -> VehicleRoutePlanModel:
-    route = data_sets.get(problem_id)
-    if not route:
-        raise HTTPException(status_code=404, detail="Route plan not found")
-    route.solver_status = solver_manager.get_solver_status(problem_id)
-    return plan_to_model(route)
-
-@app.post("/route-plans")
-async def solve_route(plan_model: VehicleRoutePlanModel) -> str:
-    job_id = str(uuid4())
-    # Convert to domain model for solver
-    domain_plan = model_to_plan(plan_model)
-    data_sets[job_id] = domain_plan
-    solver_manager.solve_and_listen(
-        job_id,
-        domain_plan,
-        lambda solution: data_sets.update({job_id: solution})
-    )
-    return job_id
-
-@app.put("/route-plans/analyze")
-async def analyze_route(plan_model: VehicleRoutePlanModel) -> dict:
-    domain_plan = model_to_plan(plan_model)
-    analysis = solution_manager.analyze(domain_plan)
-    constraints = []
-    for constraint in getattr(analysis, 'constraint_analyses', []) or []:
-        matches = [
-            MatchAnalysisDTO(
-                name=str(getattr(getattr(match, 'constraint_ref', None), 'constraint_name', "")),
-                score=str(getattr(match, 'score', "0hard/0soft")),
-                justification=str(getattr(match, 'justification', ""))
-            )
-            for match in getattr(constraint, 'matches', []) or []
-        ]
-        constraints.append(ConstraintAnalysisDTO(
-            name=str(getattr(constraint, 'constraint_name', "")),
-            weight=str(getattr(constraint, 'weight', "0hard/0soft")),
-            score=str(getattr(constraint, 'score', "0hard/0soft")),
-            matches=matches
-        ))
-    return {"constraints": [asdict(constraint) for constraint in constraints]}
-
-@app.get("/route-plans")
-async def list_route_plans() -> List[str]:
-    """List the job IDs of all submitted route plans."""
-    return list(data_sets.keys())
-
-
-@app.get("/route-plans/{problem_id}/status")
-async def get_route_status(problem_id: str) -> dict:
-    """Get the route plan status and score for a given job ID."""
-    route = data_sets.get(problem_id)
-    if not route:
-        raise HTTPException(status_code=404, detail="Route plan not found")
-    solver_status = solver_manager.get_solver_status(problem_id)
-    return {
-        "name": route.name,
-        "score": str(route.score) if route.score else None,
-        "solverStatus": solver_status.name if solver_status else None,
-    }
-
-
-@app.delete("/route-plans/{problem_id}")
-async def stop_solving(problem_id: str) -> VehicleRoutePlanModel:
-    """Terminate solving for a given job ID. Returns the best solution so far."""
-    solver_manager.terminate_early(problem_id)
-    route = data_sets.get(problem_id)
-    if not route:
-        raise HTTPException(status_code=404, detail="Route plan not found")
-    route.solver_status = solver_manager.get_solver_status(problem_id)
-    return plan_to_model(route)
-
-
-@app.post("/route-plans/recommendation")
-async def recommend_assignment(request: RecommendationRequest) -> List[RecommendedAssignmentResponse]:
-    """
-    Request recommendations for assigning a visit to vehicles.
-
-    Returns a list of recommended assignments sorted by score impact.
-    """
-    domain_plan = model_to_plan(request.solution)
-
-    # Find the visit by ID
-    visit = None
-    for v in domain_plan.visits:
-        if v.id == request.visit_id:
-            visit = v
-            break
-
-    if visit is None:
-        raise HTTPException(status_code=404, detail=f"Visit {request.visit_id} not found")
-
-    # Get recommendations using solution_manager
-    try:
-        recommendations = solution_manager.recommend_assignment(
-            domain_plan,
-            visit,
-            lambda v: VehicleRecommendation(vehicle_id=v.vehicle.id, index=v.vehicle.visits.index(v))
-        )
-
-        # Convert to response format (limit to top 5)
-        result = []
-        for rec in recommendations[:5]:
-            result.append(RecommendedAssignmentResponse(
-                proposition=rec.proposition,
-                score_diff=str(rec.score_diff) if hasattr(rec, 'score_diff') else "0hard/0soft"
-            ))
-        return result
-    except Exception:
-        # If recommend_assignment is not available, return empty list
-        return []
-
-
-@app.post("/route-plans/recommendation/apply")
-async def apply_recommendation(request: ApplyRecommendationRequest) -> VehicleRoutePlanModel:
-    """
-    Apply a recommendation to assign a visit to a vehicle at a specific index.
-
-    Returns the updated solution.
-    """
-    domain_plan = model_to_plan(request.solution)
-
-    # Find the vehicle by ID
-    vehicle = None
-    for v in domain_plan.vehicles:
-        if v.id == request.vehicle_id:
-            vehicle = v
-            break
-
-    if vehicle is None:
-        raise HTTPException(status_code=404, detail=f"Vehicle {request.vehicle_id} not found")
-
-    # Find the visit by ID
-    visit = None
-    for v in domain_plan.visits:
-        if v.id == request.visit_id:
-            visit = v
-            break
-
-    if visit is None:
-        raise HTTPException(status_code=404, detail=f"Visit {request.visit_id} not found")
-
-    # Insert visit at the specified index
-    vehicle.visits.insert(request.index, visit)
-
-    # Update the solution to recalculate shadow variables
-    solution_manager.update(domain_plan)
-
-    return plan_to_model(domain_plan)
-
-
-class RouteGeometryResponse(BaseModel):
-    """Response containing encoded polyline geometries for all vehicle routes."""
-    geometries: Dict[str, List[Optional[str]]]
-
-
-@app.get("/route-plans/{problem_id}/geometry", response_model=RouteGeometryResponse)
-async def get_route_geometry(problem_id: str) -> RouteGeometryResponse:
-    """
-    Get route geometries for all vehicle routes in a problem.
-
-    Returns encoded polylines (Google polyline format) for each route segment.
-    Each vehicle's route is represented as a list of encoded polylines:
-    - First segment: depot -> first visit
-    - Middle segments: visit -> visit
-    - Last segment: last visit -> depot
-
-    These can be decoded on the frontend to display actual road routes
-    instead of straight lines.
-    """
-    route = data_sets.get(problem_id)
-    if not route:
-        raise HTTPException(status_code=404, detail="Route plan not found")
-
-    distance_matrix = Location.get_distance_matrix()
-    if distance_matrix is None:
-        # No distance matrix available - return empty geometries
-        return RouteGeometryResponse(geometries={})
-
-    geometries: Dict[str, List[Optional[str]]] = {}
-
-    for vehicle in route.vehicles:
-        segments: List[Optional[str]] = []
-
-        if not vehicle.visits:
-            # No visits assigned to this vehicle
-            geometries[vehicle.id] = segments
-            continue
-
-        # Segment from depot to first visit
-        prev_location = vehicle.home_location
-        for visit in vehicle.visits:
-            geometry = distance_matrix.get_geometry(prev_location, visit.location)
-            segments.append(geometry)
-            prev_location = visit.location
-
-        # Segment from last visit back to depot
-        geometry = distance_matrix.get_geometry(prev_location, vehicle.home_location)
-        segments.append(geometry)
-
-        geometries[vehicle.id] = segments
-
-    return RouteGeometryResponse(geometries=geometries)
-
-
-app.mount("/", StaticFiles(directory="static", html=True), name="static")

src/vehicle_routing/routing.py

@@ -1,622 +0,0 @@
-"""
-Real-world routing service using OSMnx for road network data.
-
-This module provides:
-- OSMnxRoutingService: Downloads OSM network, caches locally, computes routes
-- DistanceMatrix: Precomputes all pairwise routes with times and geometries
-- Haversine fallback when OSMnx is unavailable
-"""
-
-from __future__ import annotations
-
-import logging
-import math
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import TYPE_CHECKING, Optional
-
-import polyline
-
-if TYPE_CHECKING:
-    from .domain import Location
-
-logger = logging.getLogger(__name__)
-
-# Cache directory for OSM network data
-CACHE_DIR = Path(__file__).parent.parent.parent / ".osm_cache"
-
-
-@dataclass
-class RouteResult:
-    """Result from a routing query."""
-
-    duration_seconds: int
-    distance_meters: int
-    geometry: Optional[str] = None  # Encoded polyline
-
-
-@dataclass
-class DistanceMatrix:
-    """
-    Precomputed distance/time matrix for all location pairs.
-
-    Stores RouteResult for each (origin, destination) pair,
-    enabling O(1) lookup during solver execution.
-    """
-
-    _matrix: dict[tuple[tuple[float, float], tuple[float, float]], RouteResult] = field(
-        default_factory=dict
-    )
-
-    def _key(
-        self, origin: "Location", destination: "Location"
-    ) -> tuple[tuple[float, float], tuple[float, float]]:
-        """Create hashable key from two locations."""
-        return (
-            (origin.latitude, origin.longitude),
-            (destination.latitude, destination.longitude),
-        )
-
-    def set_route(
-        self, origin: "Location", destination: "Location", result: RouteResult
-    ) -> None:
-        """Store a route result in the matrix."""
-        self._matrix[self._key(origin, destination)] = result
-
-    def get_route(
-        self, origin: "Location", destination: "Location"
-    ) -> Optional[RouteResult]:
-        """Get a route result from the matrix."""
-        return self._matrix.get(self._key(origin, destination))
-
-    def get_driving_time(self, origin: "Location", destination: "Location") -> int:
-        """Get driving time in seconds between two locations."""
-        result = self.get_route(origin, destination)
-        if result is None:
-            # Fallback to haversine if not in matrix
-            return _haversine_driving_time(origin, destination)
-        return result.duration_seconds
-
-    def get_geometry(
-        self, origin: "Location", destination: "Location"
-    ) -> Optional[str]:
-        """Get encoded polyline geometry for a route segment."""
-        result = self.get_route(origin, destination)
-        return result.geometry if result else None
-
-
-def _haversine_driving_time(origin: "Location", destination: "Location") -> int:
-    """
-    Calculate driving time using haversine formula (fallback).
-
-    Uses 50 km/h average speed assumption.
-    """
-    if (
-        origin.latitude == destination.latitude
-        and origin.longitude == destination.longitude
-    ):
-        return 0
-
-    EARTH_RADIUS_M = 6371000
-    AVERAGE_SPEED_KMPH = 50
-
-    lat1 = math.radians(origin.latitude)
-    lon1 = math.radians(origin.longitude)
-    lat2 = math.radians(destination.latitude)
-    lon2 = math.radians(destination.longitude)
-
-    # Haversine formula
-    dlat = lat2 - lat1
-    dlon = lon2 - lon1
-    a = math.sin(dlat / 2) ** 2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon / 2) ** 2
-    c = 2 * math.asin(math.sqrt(a))
-    distance_meters = EARTH_RADIUS_M * c
-
-    # Convert to driving time
-    return round(distance_meters / AVERAGE_SPEED_KMPH * 3.6)
-
-
-class OSMnxRoutingService:
-    """
-    Routing service using OSMnx for real road network data.
-
-    Downloads the OSM network for a given bounding box, caches it locally,
-    and computes shortest paths using NetworkX.
-    """
-
-    def __init__(self, cache_dir: Path = CACHE_DIR):
-        self.cache_dir = cache_dir
-        self.cache_dir.mkdir(parents=True, exist_ok=True)
-        self._graph = None
-        self._graph_bbox = None
-
-    def _get_cache_path(
-        self, north: float, south: float, east: float, west: float
-    ) -> Path:
-        """Generate cache file path for a bounding box."""
-        # Round to 2 decimal places for cache key
-        key = f"osm_{north:.2f}_{south:.2f}_{east:.2f}_{west:.2f}.graphml"
-        return self.cache_dir / key
-
-    def load_network(
-        self, north: float, south: float, east: float, west: float, padding: float = 0.01
-    ) -> bool:
-        """
-        Load OSM road network for the given bounding box.
-
-        Args:
-            north, south, east, west: Bounding box coordinates
-            padding: Extra padding around the bbox (in degrees)
-
-        Returns:
-            True if network loaded successfully, False otherwise
-        """
-        try:
-            import osmnx as ox
-
-            # Add padding to ensure we have roads outside the strict bbox
-            north += padding
-            south -= padding
-            east += padding
-            west -= padding
-
-            cache_path = self._get_cache_path(north, south, east, west)
-
-            if cache_path.exists() and cache_path.stat().st_size > 0:
-                logger.info(f"Loading cached OSM network from {cache_path}")
-                self._graph = ox.load_graphml(cache_path)
-
-                # Check if the cached graph already has travel_time
-                # (we now save enriched graphs)
-                sample_edge = next(iter(self._graph.edges(data=True)), None)
-                has_travel_time = sample_edge and "travel_time" in sample_edge[2]
-
-                if not has_travel_time:
-                    logger.info("Adding edge speeds and travel times to cached graph...")
-                    self._graph = ox.add_edge_speeds(self._graph)
-                    self._graph = ox.add_edge_travel_times(self._graph)
-                    # Re-save with travel times included
-                    ox.save_graphml(self._graph, cache_path)
-                    logger.info("Updated cache with travel times")
-            else:
-                logger.info(
-                    f"Downloading OSM network for bbox: N={north:.4f}, S={south:.4f}, E={east:.4f}, W={west:.4f}"
-                )
-                # OSMnx 2.x uses bbox as tuple: (left, bottom, right, top) = (west, south, east, north)
-                bbox_tuple = (west, south, east, north)
-                self._graph = ox.graph_from_bbox(
-                    bbox=bbox_tuple,
-                    network_type="drive",
-                    simplify=True,
-                )
-
-                # Add edge speeds and travel times BEFORE caching
-                logger.info("Computing edge speeds and travel times...")
-                self._graph = ox.add_edge_speeds(self._graph)
-                self._graph = ox.add_edge_travel_times(self._graph)
-
-                # Save enriched graph to cache
-                ox.save_graphml(self._graph, cache_path)
-                logger.info(f"Saved enriched OSM network to cache: {cache_path}")
-
-            self._graph_bbox = (north, south, east, west)
-            logger.info(
-                f"OSM network loaded: {self._graph.number_of_nodes()} nodes, "
-                f"{self._graph.number_of_edges()} edges"
-            )
-            return True
-
-        except ImportError:
-            logger.warning("OSMnx not installed, falling back to haversine")
-            return False
-        except Exception as e:
-            logger.warning(f"Failed to load OSM network: {e}, falling back to haversine")
-            return False
-
-    def get_nearest_node(self, location: "Location") -> Optional[int]:
-        """Get the nearest graph node for a location."""
-        if self._graph is None:
-            return None
-        try:
-            import osmnx as ox
-            return ox.nearest_nodes(self._graph, location.longitude, location.latitude)
-        except Exception:
-            return None
-
-    def compute_all_routes(
-        self,
-        locations: list["Location"],
-        progress_callback=None
-    ) -> dict[tuple[int, int], RouteResult]:
-        """
-        Compute all pairwise routes efficiently using batch shortest paths.
-
-        Returns a dict mapping (origin_idx, dest_idx) to RouteResult.
-        """
-        import networkx as nx
-
-        if self._graph is None:
-            return {}
-
-        results = {}
-        n = len(locations)
-
-        # Map locations to nearest nodes (batch operation)
-        if progress_callback:
-            progress_callback("routes", "Finding nearest road nodes...", 30, f"{n} locations")
-
-        nodes = []
-        for loc in locations:
-            node = self.get_nearest_node(loc)
-            nodes.append(node)
-
-        # Compute shortest paths from each origin to ALL destinations at once
-        # This is MUCH faster than individual shortest_path calls
-        total_origins = sum(1 for node in nodes if node is not None)
-        processed = 0
-
-        for i, origin_node in enumerate(nodes):
-            if origin_node is None:
-                continue
-
-            # Compute shortest paths from this origin to all nodes at once
-            # Using Dijkstra's algorithm with single-source
-            try:
-                lengths, paths = nx.single_source_dijkstra(
-                    self._graph, origin_node, weight="travel_time"
-                )
-            except nx.NetworkXError:
-                continue
-
-            for j, dest_node in enumerate(nodes):
-                if dest_node is None:
-                    continue
-
-                origin_loc = locations[i]
-                dest_loc = locations[j]
-
-                if i == j or origin_node == dest_node:
-                    # Same location
-                    results[(i, j)] = RouteResult(
-                        duration_seconds=0,
-                        distance_meters=0,
-                        geometry=polyline.encode(
-                            [(origin_loc.latitude, origin_loc.longitude)], precision=5
-                        ),
-                    )
-                elif dest_node in paths:
-                    path = paths[dest_node]
-                    travel_time = lengths[dest_node]
-
-                    # Calculate distance and extract geometry
-                    total_distance = 0
-                    coordinates = []
-
-                    for k in range(len(path) - 1):
-                        u, v = path[k], path[k + 1]
-                        edge_data = self._graph.get_edge_data(u, v)
-                        if edge_data:
-                            edge = edge_data[0] if isinstance(edge_data, dict) else edge_data
-                            total_distance += edge.get("length", 0)
-
-                    for node in path:
-                        node_data = self._graph.nodes[node]
-                        coordinates.append((node_data["y"], node_data["x"]))
-
-                    results[(i, j)] = RouteResult(
-                        duration_seconds=round(travel_time),
-                        distance_meters=round(total_distance),
-                        geometry=polyline.encode(coordinates, precision=5),
-                    )
-
-            processed += 1
-            if progress_callback and processed % max(1, total_origins // 10) == 0:
-                percent = 30 + int((processed / total_origins) * 65)
-                progress_callback(
-                    "routes",
-                    "Computing routes...",
-                    percent,
-                    f"{processed}/{total_origins} origins processed"
-                )
-
-        return results
-
-    def get_route(
-        self, origin: "Location", destination: "Location"
-    ) -> Optional[RouteResult]:
-        """
-        Compute route between two locations.
-
-        Returns:
-            RouteResult with duration, distance, and geometry, or None if routing fails
-        """
-        if self._graph is None:
-            return None
-
-        try:
-            import osmnx as ox
-
-            # Find nearest nodes to origin and destination
-            origin_node = ox.nearest_nodes(
-                self._graph, origin.longitude, origin.latitude
-            )
-            dest_node = ox.nearest_nodes(
-                self._graph, destination.longitude, destination.latitude
-            )
-
-            # Same node means same location (or very close)
-            if origin_node == dest_node:
-                return RouteResult(
-                    duration_seconds=0,
-                    distance_meters=0,
-                    geometry=polyline.encode(
-                        [(origin.latitude, origin.longitude)], precision=5
-                    ),
-                )
-
-            # Compute shortest path by travel time
-            route = ox.shortest_path(
-                self._graph, origin_node, dest_node, weight="travel_time"
-            )
-
-            if route is None:
-                logger.warning(
-                    f"No route found between {origin} and {destination}"
-                )
-                return None
-
-            # Extract route attributes
-            total_time = 0
-            total_distance = 0
-            coordinates = []
-
-            for i in range(len(route) - 1):
-                u, v = route[i], route[i + 1]
-                edge_data = self._graph.get_edge_data(u, v)
-                if edge_data:
-                    # Get the first edge if multiple exist
-                    edge = edge_data[0] if isinstance(edge_data, dict) else edge_data
-                    total_time += edge.get("travel_time", 0)
-                    total_distance += edge.get("length", 0)
-
-            # Get node coordinates for geometry
-            for node in route:
-                node_data = self._graph.nodes[node]
-                coordinates.append((node_data["y"], node_data["x"]))
-
-            # Encode geometry as polyline
-            encoded_geometry = polyline.encode(coordinates, precision=5)
-
-            return RouteResult(
-                duration_seconds=round(total_time),
-                distance_meters=round(total_distance),
-                geometry=encoded_geometry,
-            )
-
-        except Exception as e:
-            logger.warning(f"Routing failed: {e}")
-            return None
-
-
-def compute_distance_matrix(
-    locations: list["Location"],
-    routing_service: Optional[OSMnxRoutingService] = None,
-    bbox: Optional[tuple[float, float, float, float]] = None,
-) -> DistanceMatrix:
-    """
-    Compute distance matrix for all location pairs.
-
-    Args:
-        locations: List of Location objects
-        routing_service: Optional pre-configured routing service
-        bbox: Optional (north, south, east, west) tuple for network download
-
-    Returns:
-        DistanceMatrix with precomputed routes
-    """
-    return compute_distance_matrix_with_progress(
-        locations, routing_service, bbox, use_osm=True, progress_callback=None
-    )
-
-
-def compute_distance_matrix_with_progress(
-    locations: list["Location"],
-    bbox: Optional[tuple[float, float, float, float]] = None,
-    use_osm: bool = True,
-    progress_callback=None,
-    routing_service: Optional[OSMnxRoutingService] = None,
-) -> DistanceMatrix:
-    """
-    Compute distance matrix for all location pairs with progress reporting.
-
-    Args:
-        locations: List of Location objects
-        bbox: Optional (north, south, east, west) tuple for network download
-        use_osm: If True, try to use OSMnx for real routing. If False, use haversine.
-        progress_callback: Optional callback(phase, message, percent, detail) for progress updates
-        routing_service: Optional pre-configured routing service
-
-    Returns:
-        DistanceMatrix with precomputed routes
-    """
-    matrix = DistanceMatrix()
-
-    if not locations:
-        return matrix
-
-    def report_progress(phase: str, message: str, percent: int, detail: str = ""):
-        if progress_callback:
-            progress_callback(phase, message, percent, detail)
-        logger.info(f"[{phase}] {message} ({percent}%) {detail}")
-
-    # Compute bounding box from locations if not provided
-    if bbox is None:
-        lats = [loc.latitude for loc in locations]
-        lons = [loc.longitude for loc in locations]
-        bbox = (max(lats), min(lats), max(lons), min(lons))
-
-    osm_loaded = False
-
-    if use_osm:
-        # Create routing service if not provided
-        if routing_service is None:
-            routing_service = OSMnxRoutingService()
-
-        report_progress("network", "Checking for cached road network...", 5)
-
-        # Check if cached
-        north, south, east, west = bbox
-        north += 0.01  # padding
-        south -= 0.01
-        east += 0.01
-        west -= 0.01
-
-        cache_path = routing_service._get_cache_path(north, south, east, west)
-        is_cached = cache_path.exists()
-
-        if is_cached:
-            report_progress("network", "Loading cached road network...", 10, str(cache_path.name))
-        else:
-            report_progress(
-                "network",
-                "Downloading OpenStreetMap road network...",
-                10,
-                f"Area: {abs(north-south):.2f}° × {abs(east-west):.2f}°"
-            )
-
-        # Try to load OSM network
-        osm_loaded = routing_service.load_network(
-            north=bbox[0], south=bbox[1], east=bbox[2], west=bbox[3]
-        )
-
-        if osm_loaded:
-            node_count = routing_service._graph.number_of_nodes()
-            edge_count = routing_service._graph.number_of_edges()
-            report_progress(
-                "network",
-                "Road network loaded",
-                25,
-                f"{node_count:,} nodes, {edge_count:,} edges"
-            )
-        else:
-            report_progress("network", "OSMnx unavailable, using haversine", 25)
-    else:
-        report_progress("network", "Using fast haversine mode", 25)
-
-    # Compute all pairwise routes
-    total_pairs = len(locations) * len(locations)
-
-    if osm_loaded and routing_service:
-        # Use batch routing for OSMnx (MUCH faster than individual calls)
-        report_progress(
-            "routes",
-            f"Computing {total_pairs:,} routes (batch mode)...",
-            30,
-            f"{len(locations)} locations"
-        )
-
-        batch_results = routing_service.compute_all_routes(
-            locations,
-            progress_callback=report_progress
-        )
-
-        # Transfer batch results to matrix, with haversine fallback for missing routes
-        computed = 0
-        for i, origin in enumerate(locations):
-            for j, destination in enumerate(locations):
-                if (i, j) in batch_results:
-                    matrix.set_route(origin, destination, batch_results[(i, j)])
-                else:
-                    # Fallback to haversine for routes not found
-                    matrix.set_route(
-                        origin,
-                        destination,
-                        RouteResult(
-                            duration_seconds=_haversine_driving_time(origin, destination),
-                            distance_meters=_haversine_distance_meters(origin, destination),
-                            geometry=_straight_line_geometry(origin, destination),
-                        ),
-                    )
-                computed += 1
-
-        report_progress("complete", "Distance matrix ready", 100, f"{computed:,} routes computed")
-    else:
-        # Use haversine fallback for all routes
-        report_progress(
-            "routes",
-            f"Computing {total_pairs:,} route pairs...",
-            30,
-            f"{len(locations)} locations"
-        )
-
-        computed = 0
-        for origin in locations:
-            for destination in locations:
-                if origin is destination:
-                    matrix.set_route(
-                        origin,
-                        destination,
-                        RouteResult(
-                            duration_seconds=0,
-                            distance_meters=0,
-                            geometry=polyline.encode(
-                                [(origin.latitude, origin.longitude)], precision=5
-                            ),
-                        ),
-                    )
-                else:
-                    matrix.set_route(
-                        origin,
-                        destination,
-                        RouteResult(
-                            duration_seconds=_haversine_driving_time(origin, destination),
-                            distance_meters=_haversine_distance_meters(origin, destination),
-                            geometry=_straight_line_geometry(origin, destination),
-                        ),
-                    )
-                computed += 1
-
-                # Report progress every 5%
-                if total_pairs > 0 and computed % max(1, total_pairs // 20) == 0:
-                    percent_complete = int(30 + (computed / total_pairs) * 65)
-                    report_progress(
-                        "routes",
-                        f"Computing routes...",
-                        percent_complete,
-                        f"{computed:,}/{total_pairs:,} pairs"
-                    )
-
-        report_progress("complete", "Distance matrix ready", 100, f"{computed:,} routes computed")
-
-    return matrix
-
-
-def _haversine_distance_meters(origin: "Location", destination: "Location") -> int:
-    """Calculate haversine distance in meters."""
-    if (
-        origin.latitude == destination.latitude
-        and origin.longitude == destination.longitude
-    ):
-        return 0
-
-    EARTH_RADIUS_M = 6371000
-
-    lat1 = math.radians(origin.latitude)
-    lon1 = math.radians(origin.longitude)
-    lat2 = math.radians(destination.latitude)
-    lon2 = math.radians(destination.longitude)
-
-    dlat = lat2 - lat1
-    dlon = lon2 - lon1
-    a = math.sin(dlat / 2) ** 2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon / 2) ** 2
-    c = 2 * math.asin(math.sqrt(a))
-
-    return round(EARTH_RADIUS_M * c)
-
-
-def _straight_line_geometry(origin: "Location", destination: "Location") -> str:
-    """Generate a straight-line encoded polyline between two points."""
-    return polyline.encode(
-        [(origin.latitude, origin.longitude), (destination.latitude, destination.longitude)],
-        precision=5,
-    )

src/vehicle_routing/score_analysis.py

@@ -1,20 +0,0 @@
-from dataclasses import dataclass
-from typing import Annotated
-
-from solverforge_legacy.solver.score import HardSoftScore
-from .json_serialization import ScoreSerializer
-
-
-@dataclass
-class MatchAnalysisDTO:
-    name: str
-    score: Annotated[HardSoftScore, ScoreSerializer]
-    justification: object
-
-
-@dataclass
-class ConstraintAnalysisDTO:
-    name: str
-    weight: Annotated[HardSoftScore, ScoreSerializer]
-    matches: list[MatchAnalysisDTO]
-    score: Annotated[HardSoftScore, ScoreSerializer]

src/vehicle_routing/solver.py

@@ -1,23 +0,0 @@
-from solverforge_legacy.solver import SolverManager, SolutionManager
-from solverforge_legacy.solver.config import (
-    SolverConfig,
-    ScoreDirectorFactoryConfig,
-    TerminationConfig,
-    Duration,
-)
-
-from .domain import Vehicle, VehicleRoutePlan, Visit
-from .constraints import define_constraints
-
-
-solver_config = SolverConfig(
-    solution_class=VehicleRoutePlan,
-    entity_class_list=[Vehicle, Visit],
-    score_director_factory_config=ScoreDirectorFactoryConfig(
-        constraint_provider_function=define_constraints
-    ),
-    termination_config=TerminationConfig(spent_limit=Duration(seconds=30)),
-)
-
-solver_manager = SolverManager.create(solver_config)
-solution_manager = SolutionManager.create(solver_manager)