Add python api

Author: hlinsen

python/cuopt/cuopt/routing/__init__.py

@@ -9,5 +9,5 @@
     update_routes_and_vehicles,
 )
 from cuopt.routing.utils_wrapper import DatasetDistribution
-from cuopt.routing.vehicle_routing import DataModel, Solve, SolverSettings
+from cuopt.routing.vehicle_routing import BatchSolve, DataModel, Solve, SolverSettings
 from cuopt.routing.vehicle_routing_wrapper import ErrorStatus, Objective

python/cuopt/cuopt/routing/vehicle_routing.py

@@ -1540,3 +1540,44 @@ def Solve(data_model, solver_settings=None):
             solver_settings.get_config_file_name(),
         )
     return solution
+
+
+@catch_cuopt_exception
+def BatchSolve(data_model_list, solver_settings=None):
+    """
+    Solves multiple routing problems in batch mode using parallel execution.
+
+    Parameters
+    ----------
+    data_model_list: list of DataModel
+        List of data model objects representing routing problems to solve.
+    solver_settings: SolverSettings
+        Settings to configure solver configurations.
+        By default, it uses default solver settings to solve.
+
+    Returns
+    -------
+    tuple
+        A tuple containing:
+        - list of Assignment: Solutions for each routing problem
+        - float: Total solve time in seconds
+
+    Examples
+    --------
+    >>> from cuopt import routing
+    >>> import cudf
+    >>> # Create multiple data models
+    >>> data_models = []
+    >>> for i in range(5):
+    ...     cost_matrix = cudf.DataFrame([[0, 1, 2], [1, 0, 3], [2, 3, 0]])
+    ...     dm = routing.DataModel(3, 1)
+    ...     dm.add_cost_matrix(cost_matrix)
+    ...     data_models.append(dm)
+    >>> settings = routing.SolverSettings()
+    >>> settings.set_time_limit(1.0)
+    >>> solutions, solve_time = routing.BatchSolve(data_models, settings)
+    """
+    if solver_settings is None:
+        solver_settings = SolverSettings()
+
+    return vehicle_routing_wrapper.BatchSolve(data_model_list, solver_settings)

python/cuopt/cuopt/tests/routing/test_batch_solve.py

@@ -0,0 +1,113 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+import cudf
+import numpy as np
+
+from cuopt import routing
+
+
+def create_tsp_cost_matrix(n_locations):
+    """Creates a simple symmetric cost matrix for TSP."""
+    cost_matrix = np.zeros((n_locations, n_locations), dtype=np.float32)
+    for i in range(n_locations):
+        for j in range(n_locations):
+            cost_matrix[i, j] = abs(i - j)
+    return cudf.DataFrame(cost_matrix)
+
+
+def test_batch_solve_varying_sizes():
+    """Test batch solving TSPs of varying sizes."""
+    tsp_sizes = [5, 8, 10, 6, 7, 9]
+
+    # Create data models for each TSP
+    data_models = []
+    for n_locations in tsp_sizes:
+        cost_matrix = create_tsp_cost_matrix(n_locations)
+        dm = routing.DataModel(n_locations, 1)
+        dm.add_cost_matrix(cost_matrix)
+        data_models.append(dm)
+
+    # Configure solver settings
+    settings = routing.SolverSettings()
+    settings.set_time_limit(5.0)
+
+    # Call batch solve
+    solutions, solve_time = routing.BatchSolve(data_models, settings)
+
+    # Verify results
+    assert len(solutions) == len(tsp_sizes)
+    for i, solution in enumerate(solutions):
+        assert solution.get_status() == routing.SolutionStatus.SUCCESS, (
+            f"TSP {i} (size {tsp_sizes[i]}) failed"
+        )
+        assert solution.get_vehicle_count() == 1, (
+            f"TSP {i} (size {tsp_sizes[i]}) used multiple vehicles"
+        )
+
+    # Verify solve time is reasonable
+    assert solve_time > 0.0, "Solve time should be positive"
+
+
+def test_batch_solve_same_size():
+    """Test batch solving multiple TSPs of the same size."""
+    n_problems = 10
+    n_locations = 6
+
+    # Create data models
+    data_models = []
+    for _ in range(n_problems):
+        cost_matrix = create_tsp_cost_matrix(n_locations)
+        dm = routing.DataModel(n_locations, 1)
+        dm.add_cost_matrix(cost_matrix)
+        data_models.append(dm)
+
+    # Configure solver settings
+    settings = routing.SolverSettings()
+    settings.set_time_limit(2.0)
+
+    # Call batch solve
+    solutions, solve_time = routing.BatchSolve(data_models, settings)
+
+    # Verify all solutions succeeded
+    assert len(solutions) == n_problems
+    for i, solution in enumerate(solutions):
+        assert solution.get_status() == routing.SolutionStatus.SUCCESS, (
+            f"TSP {i} failed"
+        )
+
+
+def test_batch_solve_single_problem():
+    """Test batch solve with a single problem."""
+    n_locations = 5
+
+    cost_matrix = create_tsp_cost_matrix(n_locations)
+    dm = routing.DataModel(n_locations, 1)
+    dm.add_cost_matrix(cost_matrix)
+
+    settings = routing.SolverSettings()
+    settings.set_time_limit(2.0)
+
+    solutions, solve_time = routing.BatchSolve([dm], settings)
+
+    assert len(solutions) == 1
+    assert solutions[0].get_status() == routing.SolutionStatus.SUCCESS
+
+
+def test_batch_solve_default_settings():
+    """Test batch solve with default solver settings."""
+    tsp_sizes = [5, 6, 7]
+
+    data_models = []
+    for n_locations in tsp_sizes:
+        cost_matrix = create_tsp_cost_matrix(n_locations)
+        dm = routing.DataModel(n_locations, 1)
+        dm.add_cost_matrix(cost_matrix)
+        data_models.append(dm)
+
+    # Call batch solve without explicit settings
+    solutions, solve_time = routing.BatchSolve(data_models)
+
+    assert len(solutions) == len(tsp_sizes)
+    for solution in solutions:
+        assert solution.get_status() == routing.SolutionStatus.SUCCESS