%diff -u --color main.py cvrptw_pd.py
--- main.py	2024-07-04 16:11:07.524848863 +0200
+++ cvrptw_pd.py	2024-07-04 16:10:16.518365568 +0200
@@ -17,8 +17,12 @@
 """
 
 import numpy as np
-from ortools.constraint_solver import routing_enums_pb2
-from ortools.constraint_solver import pywrapcp
+from ortools.routing import enums_pb2
+from ortools.routing import pywraprouting
+
+FirstSolutionStrategy = enums_pb2.FirstSolutionStrategy
+LocalSearchMetaheuristic = enums_pb2.LocalSearchMetaheuristic
+RoutingSearchStatus = enums_pb2.RoutingSearchStatus
 
 
 def create_data_model():
@@ -86,47 +90,89 @@
     return data
 
 
-def print_solution(data, manager, routing, solution):
+def print_solution(manager, routing, solution):
     """Prints solution on console."""
+    status = routing.status()
+    print(f"Status: {RoutingSearchStatus.Value.Name(status)}")
+    if (
+        status != RoutingSearchStatus.ROUTING_OPTIMAL
+        and status != RoutingSearchStatus.ROUTING_SUCCESS
+    ):
+        print("No solution found!")
+        return
     print(f"Objective: {solution.ObjectiveValue()}")
+    # Display dropped nodes.
+    dropped_nodes = "Dropped nodes:"
+    for node in range(routing.Size()):
+        if routing.IsStart(node) or routing.IsEnd(node):
+            continue
+        if solution.Value(routing.NextVar(node)) == node:
+            dropped_nodes += f" {manager.IndexToNode(node)}"
+    print(dropped_nodes)
+    # Display routes.
+    time_dimension = routing.GetDimensionOrDie("Time")
+    capacity_dimension = routing.GetDimensionOrDie("Capacity")
     total_distance = 0
-    for vehicle_id in range(data["num_vehicles"]):
-        nodes_visited = []  # To Keep Track of Vehicles Visited by Vehicle
+    total_time = 0
+    total_load = 0
+    for vehicle_id in range(manager.GetNumberOfVehicles()):
+        nodes_visited = []  # To Keep Track of Node Visited by Vehicle
         index = routing.Start(vehicle_id)
         plan_output = f"Route for vehicle {vehicle_id}:\n"
         route_distance = 0
         nodes_visited.append(manager.IndexToNode(index))
         while not routing.IsEnd(index):
-            node = manager.IndexToNode(index)
-            plan_output += f" {node} -> "
+            time_var = time_dimension.CumulVar(index)
+            capacity_var = capacity_dimension.CumulVar(index)
+            plan_output += (
+                f"Node_{manager.IndexToNode(index)}"
+                f" {route_distance}m"
+                f" TW:[{time_var.Min()},{time_var.Max()}]"
+                f" Time({solution.Min(time_var)},{solution.Max(time_var)})"
+                f" Load({solution.Value(capacity_var)}/{capacity_var.Max()})"
+                " -> "
+            )
             previous_index = index
             index = solution.Value(routing.NextVar(index))
             nodes_visited.append(manager.IndexToNode(index))
             route_distance += routing.GetArcCostForVehicle(
                 previous_index, index, vehicle_id
             )
-        if (
-            len(nodes_visited) > 2
-        ):  # Condition does not prints vehicels that are not assigned
-            plan_output += f"{manager.IndexToNode(index)}\n"
+        if len(nodes_visited) > 2:  # Condition does not prints vehicels that are not assigned
+            time_var = time_dimension.CumulVar(index)
+            capacity_var = capacity_dimension.CumulVar(index)
+            plan_output += (
+                f"Node_{manager.IndexToNode(index)}"
+                f" {route_distance}m"
+                f" Time({solution.Min(time_var)},{solution.Max(time_var)})"
+                f" Load({solution.Value(capacity_var)}/{capacity_var.Max()})"
+                "\n"
+            )
             plan_output += f"Distance of the route: {route_distance}m\n"
+            plan_output += f"Time of the route: {solution.Min(time_var)}min\n"
+            plan_output += f"Load of the route: {solution.Value(capacity_var)}\n"
             print(plan_output)
             total_distance += route_distance
+            total_time += solution.Min(time_var)
+            total_load += solution.Value(capacity_var)
             print(nodes_visited)
+    print(f"Total distance of all routes: {total_distance}m")
+    print(f"Total time of all routes: {total_time}min")
+    print(f"Total load of all routes: {total_load}")
     # print(f"Total Distance of all routes: {total_distance}m")
 
 
 def main():
     data = create_data_model()
-    manager = pywrapcp.RoutingIndexManager(
+    manager = pywraprouting.RoutingIndexManager(
         data["num_Locations"], data["num_vehicles"], data["depot"]
     )
 
-    routing = pywrapcp.RoutingModel(manager)
+    routing = pywraprouting.RoutingModel(manager)
 
     def distance_callback(from_index, to_index):
         from_node = manager.IndexToNode(from_index)
-        to_node = manager.IndexToNode(to_node)
+        to_node = manager.IndexToNode(to_index)
         if from_node in range(data["duplicate_nodes"], data["num_Locations"]):
             from_node = 0
         if to_node in range(data["duplicate_nodes"], data["num_Locations"]):
@@ -148,9 +194,6 @@
     )
     capacity_dimension = routing.GetDimensionOrDie(capacity)
 
-    for node in range(data["num_Locations"]):
-        routing.AddDisjunction([manager.NodeToIndex(node)], 100)
-
     def time_callback(from_index, to_index):
         from_node = manager.IndexToNode(from_index)
         to_node = manager.IndexToNode(to_index)
@@ -165,8 +208,8 @@
     time_dim = "Time"
     routing.AddDimension(
         time_callback_index,
-        300,
-        100000000000,  # Some Big Number so that Model should not limit itself.
+        300_000,
+        100_000_000_000,  # Some Big Number so that Model should not limit itself.
         False,
         time_dim,
     )
@@ -214,24 +257,20 @@
         # Consraint End-----------
 
         routing.AddPickupAndDelivery(pickup_index, delivery_index)
-        search_parameters = pywrapcp.DefaultRoutingSearchParameters()
+        routing.AddDisjunction([pickup_index, delivery_index], 20_000, 2)
+
+    search_parameters = pywraprouting.DefaultRoutingSearchParameters()
     search_parameters.first_solution_strategy = (
-        routing_enums_pb2.FirstSolutionStrategy.PARALLEL_CHEAPEST_INSERTION
+        FirstSolutionStrategy.PARALLEL_CHEAPEST_INSERTION
     )
     search_parameters.local_search_metaheuristic = (
-        routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH
+        LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH
     )
-    search_parameters.time_limit.seconds = 30
+    search_parameters.time_limit.FromSeconds(3)
     # search_parameters.log_search = True
 
     solution = routing.SolveWithParameters(search_parameters)
-
-    if solution:
-        print("Solution Found")
-        print_solution(data, manager, routing, solution)
-
-    else:
-        print("NO SOLUTION")
+    print_solution(manager, routing, solution)
 
 
 if __name__ == "__main__":