PyVRP

https://pyvrp.org
Admin
PyVRP is an open-source, state-of-the-art vehicle routing problem (VRP) solver that supports various...
Tokens:23,703
Snippets:316
Trust Score:5.4
Update:2 months ago
Show doc for...
Tokens:
Raw
### Set up PyVRP Example Environment

Source: https://pyvrp.org/setup/installation.html

Navigate into the cloned PyVRP directory and use 'uv sync' to install all dependencies required for running the example notebooks, including the 'examples' optional dependency group.

```bash
cd PyVRP
uv sync --group examples

```

--------------------------------

### Run the test suite

Source: https://pyvrp.org/dev/contributing.html

Execute the project tests to verify the installation.

```bash
uv run pytest
```

--------------------------------

### Install PyVRP from GitHub Source

Source: https://pyvrp.org/setup/installation.html

Install PyVRP directly from its GitHub repository to get the latest development version. This is useful for accessing updates not yet released on PyPI.

```bash
pip install 'pyvrp @ git+https://github.com/PyVRP/PyVRP'

```

--------------------------------

### Defining coordinates and groups

Source: https://pyvrp.org/notebooks/mutually_exclusive_groups.html

Setup of location coordinates and group assignments for the demonstration.

```python
COORDS = [(456, 320), (312, 418), (114, 80), (570, 160), (684, 240)]
GROUPS = [0, 0, 1, 1]
```

--------------------------------

### Install PyVRP via pip

Source: https://pyvrp.org/index.html

Use this command to install the PyVRP package and its pre-compiled binaries.

```bash
pip install pyvrp
```

--------------------------------

### Install pre-commit hooks

Source: https://pyvrp.org/dev/contributing.html

Configure pre-commit to automatically check style and typing on every commit.

```bash
pre-commit install
```

--------------------------------

### Run Jupyter Notebooks Locally

Source: https://pyvrp.org/setup/installation.html

Launch Jupyter Notebook using 'uv run' after setting up the environment. This command opens a web interface in your browser, allowing you to access and run the example notebooks located in the 'examples/' folder.

```bash
uv run jupyter notebook

```

--------------------------------

### Install and Upgrade uv

Source: https://pyvrp.org/setup/installation.html

Install or upgrade the 'uv' package manager, which is recommended for managing dependencies and running commands within the PyVRP project.

```bash
pip install --upgrade uv

```

--------------------------------

### Print route schedule

Source: https://pyvrp.org/notebooks/duration_constraints.html

Iterate through the best solution routes to display service start times and durations.

```python
def print_schedule(res):
    for idx, route in enumerate(res.best.routes()):
        print(f"Route #{idx + 1}:")
        for activity in route:
            if activity.is_depot():
                loc = m.depots[activity.idx]
            else:
                loc = m.clients[activity.idx]

            start = activity.start_time
            dur = activity.duration
            print(f"- [t = {start:>02}] Service at {loc} takes time = {dur}.")


print_schedule(res)
```

--------------------------------

### Define problem data

Source: https://pyvrp.org/notebooks/duration_constraints.html

Setup coordinates, time windows, service durations, and travel duration matrix for the VRP instance.

```python
COORDS = [(456, 320), (228, 0), (912, 0), (0, 80), (114, 80)]
TIME_WINDOWS = [(0, 30), (7, 12), (10, 15), (16, 18), (10, 13)]
SERVICE_DURATION = [2, 3, 3, 4, 1]

TRAVEL_DURATION_MATRIX = [
    [0, 6, 9, 8, 7],
    [6, 0, 8, 3, 2],
    [9, 8, 0, 11, 10],
    [8, 3, 11, 0, 1],
    [7, 2, 10, 1, 0],
]
```

--------------------------------

### Clone PyVRP Repository

Source: https://pyvrp.org/setup/installation.html

Clone the PyVRP GitHub repository to your local machine to access the source code and example notebooks.

```bash
git clone https://github.com/PyVRP/PyVRP.git

```

--------------------------------

### Initialize the development environment

Source: https://pyvrp.org/dev/contributing.html

Navigate to the project directory and synchronize the virtual environment using uv.

```bash
cd PyVRP
uv sync
```

--------------------------------

### Display PyVRP CLI Help

Source: https://pyvrp.org/dev/benchmarking.html

Run this command to see all available options for the PyVRP command-line interface.

```bash
pyvrp --help

```

--------------------------------

### View build script help

Source: https://pyvrp.org/dev/contributing.html

Display available command-line arguments for the extension build script.

```bash
uv run buildtools/build_extensions.py --help
```

--------------------------------

### Initialize Git Submodule for Instances

Source: https://pyvrp.org/dev/benchmarking.html

Use this command to initialize and clone the PyVRP instances repository as a submodule, making benchmark instances available locally.

```bash
git submodule init instances

```

--------------------------------

### Configure and solve the model

Source: https://pyvrp.org/notebooks/duration_constraints.html

Initialize the model, add vehicle types, depots, clients, and edges, then solve with a runtime limit.

```python
m = pyvrp.Model()
m.add_vehicle_type(2, unit_distance_cost=0, unit_duration_cost=1)

m.add_depot(
    location=m.add_location(x=COORDS[0][0], y=COORDS[0][1]),
    tw_early=TIME_WINDOWS[0][0],
    tw_late=TIME_WINDOWS[0][1],
    service_duration=SERVICE_DURATION[0],
    name="Depot",
)

for idx in range(1, len(COORDS)):
    m.add_client(
        location=m.add_location(x=COORDS[idx][0], y=COORDS[idx][1]),
        tw_early=TIME_WINDOWS[idx][0],
        tw_late=TIME_WINDOWS[idx][1],
        service_duration=SERVICE_DURATION[idx],
        name=f"Client {idx}",
    )

for frm_idx, frm in enumerate(m.locations):
    for to_idx, to in enumerate(m.locations):
        duration = TRAVEL_DURATION_MATRIX[frm_idx][to_idx]
        m.add_edge(frm, to, distance=duration, duration=duration)

res = m.solve(stop=pyvrp.stop.MaxRuntime(1))
```

--------------------------------

### Build Distribution

Source: https://pyvrp.org/dev/releasing.html

Build the source distribution and wheel files for the release. Ensure the version in the dist/ directory is correct.

```bash
uv build
```

--------------------------------

### Configure Model with Release Times

Source: https://pyvrp.org/notebooks/duration_constraints.html

Initialize the PyVRP model and add clients with specific release times to enforce delivery constraints.

```python
m = pyvrp.Model()
m.add_vehicle_type(2, unit_distance_cost=0, unit_duration_cost=1)

m.add_depot(
    location=m.add_location(x=COORDS[0][0], y=COORDS[0][1]),
    tw_early=TIME_WINDOWS[0][0],
    tw_late=TIME_WINDOWS[0][1],
    service_duration=SERVICE_DURATION[0],
    name="Depot",
)

for idx in range(1, len(COORDS)):
    m.add_client(
        location=m.add_location(x=COORDS[idx][0], y=COORDS[idx][1]),
        tw_early=TIME_WINDOWS[idx][0],
        tw_late=TIME_WINDOWS[idx][1],
        service_duration=SERVICE_DURATION[idx],
        release_time=RELEASE_TIMES[idx - 1],
        name=f"Client {idx}",
    )

for frm_idx, frm in enumerate(m.locations):
    for to_idx, to in enumerate(m.locations):
        duration = TRAVEL_DURATION_MATRIX[frm_idx][to_idx]
        m.add_edge(frm, to, distance=duration, duration=duration)

res = m.solve(stop=pyvrp.stop.MaxRuntime(1))
```

--------------------------------

### Configure and Solve Model with Pickups and Deliveries

Source: https://pyvrp.org/notebooks/load.html

Initializes a PyVRP model, adds vehicle types, depots, and clients with specific pickup and delivery requirements, then solves the instance.

```python
m = pyvrp.Model()
m.add_vehicle_type(2, capacity=10)

m.add_depot(location=m.add_location(x=COORDS[0][0], y=COORDS[0][1]))

for idx in [1, 2]:
    m.add_client(
        location=m.add_location(x=COORDS[idx][0], y=COORDS[idx][1]),
        delivery=DELIVERIES[idx - 1],
        pickup=PICKUPS[idx - 1],
    )

for frm in m.locations:
    for to in m.locations:
        if frm != to:
            m.add_edge(frm, to, distance=1)  # unit distances

res = m.solve(stop=pyvrp.stop.MaxRuntime(1))  # one second of runtime
```

--------------------------------

### Configuring the model with profiles

Source: https://pyvrp.org/notebooks/profiles.html

Sets up the model, adds vehicle types with different profiles, and applies edge constraints to restrict access to the zone.

```python
m = pyvrp.Model()

depot = m.add_depot(location=m.add_location(COORDS[0][0], COORDS[0][1]))

regular = m.add_profile(name="regular")
m.add_vehicle_type(1, profile=regular, unit_distance_cost=10)

restricted = m.add_profile(name="restricted")
m.add_vehicle_type(1, profile=restricted, unit_distance_cost=1)

for idx in range(1, len(COORDS)):
    m.add_client(location=m.add_location(COORDS[idx][0], COORDS[idx][1]))

for frm in m.locations:
    for to in m.locations:
        # Edges created without a specific profile argument are added
        # to all profiles, unless a profile-specific edge overrides it.
        dist = abs(frm.x - to.x) + abs(frm.y - to.y)
        m.add_edge(frm, to, distance=dist)

        if frm != to and in_zone(to):
            # Here we specify an edge with a high distance for the
            # restricted profile. This ensures vehicles with that
            # profile do not travel over this edge.
            m.add_edge(
                frm,
                to,
                distance=10_000,
                profile=restricted,
            )

res = m.solve(stop=pyvrp.stop.MaxRuntime(1), display=False)
```

--------------------------------

### Print Solution Schedule

Source: https://pyvrp.org/notebooks/duration_constraints.html

Display the resulting route schedule to verify that release times are respected.

```python
print_schedule(res)
```

--------------------------------

### Configure and Solve the Model

Source: https://pyvrp.org/notebooks/quick_start.html

Initialize the PyVRP model with the defined constraints, add locations, vehicles, and edges, then solve with a runtime limit.

```python
m = pyvrp.Model()

depot = m.add_depot(
    location=m.add_location(DEPOT_COORDINATES[0], DEPOT_COORDINATES[1]),
    name="Depot",
)

vehicles = m.add_vehicle_type(
    num_available=2,
    capacity=20,
    shift_duration=SHIFT_DURATION,
)

for idx in range(len(COORDINATES)):
    m.add_client(
        location=m.add_location(COORDINATES[idx][0], COORDINATES[idx][1]),
        delivery=DEMANDS[idx],
        tw_early=TIME_WINDOWS[idx][0],
        tw_late=TIME_WINDOWS[idx][1],
        name=f"Client {idx + 1}",
    )

for frm in m.locations:
    for to in m.locations:
        dist = int(abs(frm.x - to.x) + abs(frm.y - to.y))
        m.add_edge(frm, to, distance=dist, duration=dist)

res = m.solve(stop=pyvrp.stop.MaxRuntime(1))  # one second of runtime
```

--------------------------------

### Construct Initial Solution

Source: https://pyvrp.org/notebooks/pyvrp_implementation.html

Generates an initial solution using the random constructor.

```python
init_sol = Solution.make_random(INSTANCE, rng)
```

--------------------------------

### Configure and solve the model with reloading

Source: https://pyvrp.org/notebooks/reloading.html

Sets up a vehicle type with reload depots and solves the model.

```python
m = pyvrp.Model()


depot = m.add_depot(location=m.add_location(COORDS[0][0], COORDS[0][1]))
m.add_vehicle_type(
    1,
    capacity=15,
    reload_depots=[depot],  # where reloads may take place
    max_reloads=2,  # maximum number of reload depot visits on a route
)

for idx in range(1, len(COORDS)):
    m.add_client(
        location=m.add_location(x=COORDS[idx][0], y=COORDS[idx][1]),
        delivery=DEMANDS[idx - 1],
    )

for frm in m.locations:
    for to in m.locations:
        distance = abs(frm.x - to.x) + abs(frm.y - to.y)
        m.add_edge(frm, to, distance=distance)

res = m.solve(stop=pyvrp.stop.MaxRuntime(1))
```

--------------------------------

### Building and solving the model

Source: https://pyvrp.org/notebooks/mutually_exclusive_groups.html

Constructs a model with client groups, adds edges, and solves the instance with a runtime limit.

```python
m = pyvrp.Model()

depot = m.add_depot(location=m.add_location(COORDS[0][0], COORDS[0][1]))
m.add_vehicle_type(2)

# Create the client groups. Clients are assigned to their group below.
groups = [m.add_client_group(required=True) for _ in range(2)]

for idx in range(1, len(COORDS)):
    m.add_client(
        location=m.add_location(x=COORDS[idx][0], y=COORDS[idx][1]),
        group=groups[GROUPS[idx - 1]],  # assign group
        required=False,
    )

for frm in m.locations:
    for to in m.locations:
        distance = abs(frm.x - to.x) + abs(frm.y - to.y)
        m.add_edge(frm, to, distance=distance)

res = m.solve(stop=pyvrp.stop.MaxRuntime(1))
```

--------------------------------

### Building and solving the model

Source: https://pyvrp.org/notebooks/optional_clients.html

Constructing the model with optional clients and solving it with a runtime limit.

```python
m = pyvrp.Model()

m.add_depot(location=m.add_location(x=COORDS[0][0], y=COORDS[0][1]))
m.add_vehicle_type(1)

for idx in range(1, len(COORDS)):
    m.add_client(
        location=m.add_location(x=COORDS[idx][0], y=COORDS[idx][1]),
        prize=PRIZES[idx - 1],
        required=False,
    )

for frm in m.locations:
    for to in m.locations:
        distance = abs(frm.x - to.x) + abs(frm.y - to.y)
        m.add_edge(frm, to, distance=distance)

res = m.solve(stop=pyvrp.stop.MaxRuntime(1))
```

--------------------------------

### Configure and solve the delivery model

Source: https://pyvrp.org/notebooks/load.html

Constructs the VRP model, adds vehicle types, locations, clients, and edges, then solves with a runtime limit.

```python
m = pyvrp.Model()
m.add_vehicle_type(2, capacity=10)
m.add_depot(location=m.add_location(x=COORDS[0][0], y=COORDS[0][1]))

m.add_client(
    location=m.add_location(x=COORDS[1][0], y=COORDS[1][1]),
    delivery=DELIVERIES[0],
)

m.add_client(
    location=m.add_location(x=COORDS[2][0], y=COORDS[2][1]),
    delivery=DELIVERIES[1],
)

for idx_frm, frm in enumerate(m.locations):
    for idx_to, to in enumerate(m.locations):
        if idx_frm != idx_to:
            m.add_edge(frm, to, distance=1)  # unit distances

res = m.solve(stop=pyvrp.stop.MaxRuntime(1))  # one second of runtime
```

--------------------------------

### show_versions()

Source: https://pyvrp.org/api/pyvrp.html

Prints version information for PyVRP and its dependencies.

```APIDOC
## show_versions()

### Description
Prints version information that is useful when filing bug reports.
```

--------------------------------

### Initialize Solution and CostEvaluator

Source: https://pyvrp.org/notebooks/pyvrp_implementation.html

Creates a random solution and a CostEvaluator with specific penalty parameters for load and time windows.

```python
from pyvrp import CostEvaluator, Solution

sol = Solution.make_random(INSTANCE, rng)
cost_evaluator = CostEvaluator(
    load_penalties=[20],
    tw_penalty=20,
    dist_penalty=0,
)
```

--------------------------------

### Build PyVRP extensions

Source: https://pyvrp.org/dev/contributing.html

Use the build script to compile native extensions. This command builds everything in release mode by default.

```bash
uv run buildtools/build_extensions.py
```

--------------------------------

### Extend Model with New Depot and Clients

Source: https://pyvrp.org/notebooks/quick_start.html

Add a new depot, configure associated vehicle types, register new clients, and compute edges before solving the model.

```python
# We extend the previous model with the new data.
new_depot = m.add_depot(
    location=m.add_location(x=40.0, y=70.0),
    name="New depot",
)

new_vehicles = m.add_vehicle_type(
    num_available=1,
    capacity=20,
    start_depot=new_depot,
    end_depot=new_depot,
    shift_duration=SHIFT_DURATION,
)

for idx in range(len(NEW_COORDINATES)):
    loc = m.add_location(NEW_COORDINATES[idx][0], NEW_COORDINATES[idx][1])
    m.add_client(
        location=loc,
        delivery=NEW_DEMANDS[idx],
        tw_early=NEW_TIME_WINDOWS[idx][0],
        tw_late=NEW_TIME_WINDOWS[idx][1],
        name=f"New client {idx + 1}",
    )

for frm in m.locations:
    for to in m.locations:
        dist = int(abs(frm.x - to.x) + abs(frm.y - to.y))
        m.add_edge(frm, to, distance=dist, duration=dist)

res = m.solve(stop=pyvrp.stop.MaxRuntime(1))  # one second of runtime
```

--------------------------------

### Print best solution

Source: https://pyvrp.org/notebooks/reloading.html

Displays the best route found, where reload depots are indicated by a pipe character.

```python
print(res.best)
```

--------------------------------

### Initialize PenaltyManager

Source: https://pyvrp.org/notebooks/pyvrp_implementation.html

Sets up a PenaltyManager to dynamically manage penalty terms during the search.

```python
from pyvrp import PenaltyManager

pen_manager = PenaltyManager(initial_penalties=([20], 6, 6))
cost_evaluator = pen_manager.cost_evaluator()
```

--------------------------------

### Iterate and Print Route Details

Source: https://pyvrp.org/notebooks/quick_start.html

Access the best solution routes and print the timing and location of each activity.

```python
for idx, route in enumerate(res.best.routes()):
    print(f"Route #{idx} [duration = {route.duration()}]:")

    for activity in route:
        if activity.is_depot():
            where = m.depots[activity.idx]
        else:
            where = m.clients[activity.idx]

        print(f" - [t = {activity.start_time:>03}] At {where}.")
```

--------------------------------

### read_solution(where, data)

Source: https://pyvrp.org/api/pyvrp.html

Reads a solution in VRPLIB format from a file.

```APIDOC
## read_solution(where, data)

### Description
Reads a solution in VRPLIB format from the given file location and returns the corresponding Solution object.

### Parameters
- **where** (str | Path) - Required - File location to read.
- **data** (ProblemData) - Required - Problem data instance that the solution is based on.

### Returns
- **Solution** - Solution object constructed from the read data.
```

--------------------------------

### Model and Solve Routing Problem

Source: https://pyvrp.org/notebooks/quick_start.html

Construct the model by adding depots, vehicles, clients, and edges, then solve with a one-second runtime limit.

```python
m = pyvrp.Model()

depot = m.add_depot(
    location=m.add_location(DEPOT_COORDINATES[0], DEPOT_COORDINATES[1]),
    name="Depot",
)

vehicles = m.add_vehicle_type(num_available=2, capacity=20)

for idx in range(len(COORDINATES)):
    m.add_client(
        location=m.add_location(COORDINATES[idx][0], COORDINATES[idx][1]),
        delivery=DEMANDS[idx],
        name=f"Client {idx + 1}",
    )

for frm in m.locations:
    for to in m.locations:
        dist = int(abs(frm.x - to.x) + abs(frm.y - to.y))
        m.add_edge(frm, to, distance=dist)

res = m.solve(stop=pyvrp.stop.MaxRuntime(1))  # one second of runtime
```

--------------------------------

### Configure the local search method

Source: https://pyvrp.org/notebooks/pyvrp_implementation.html

Sets up the local search object with default operators and computed neighborhoods for a given instance.

```python
from pyvrp.search import OPERATORS, LocalSearch, compute_neighbours

neighbours = compute_neighbours(INSTANCE)
ls = LocalSearch(INSTANCE, rng, neighbours)

for op in OPERATORS:
    ls.add_operator(op(INSTANCE))
```

--------------------------------

### Plot the solution

Source: https://pyvrp.org/notebooks/reloading.html

Visualizes the routing and reloading decisions.

```python
pyvrp.plotting.plot_solution(res.best, m.data(), plot_clients=True)
```

--------------------------------

### Inspect Route Activities

Source: https://pyvrp.org/notebooks/load.html

Iterates through the best solution's route to print loading, delivery, and unloading activities.

```python
route = res.best.routes()[0]

for idx, activity in enumerate(route):
    if idx == 0:
        print(f"- Loading {route.delivery()} at depot.")
    elif idx == len(route) - 1:
        print(f"- Unloading {route.pickup()} at depot.")
    else:
        client = m.clients[activity.idx]
        delivery = client.delivery
        pickup = client.pickup
        print(f"- Delivering {delivery} at client, picking up {pickup}.")
```

--------------------------------

### Display Route Details

Source: https://pyvrp.org/notebooks/quick_start.html

Iterate through the best solution routes to print the sequence of visits for each vehicle.

```python
for idx, route in enumerate(res.best.routes()):
    print(f"Route #{idx}:")

    for activity in route:
        if activity.is_depot():
            where = m.depots[activity.idx]
        else:
            where = m.clients[activity.idx]

        print(f" - At {where}.")
```

--------------------------------

### Define Pickup and Delivery Demands

Source: https://pyvrp.org/notebooks/load.html

Sets up the pickup and delivery arrays for the model.

```python
PICKUPS = [6, 0]
```

--------------------------------

### Defining coordinates and prizes

Source: https://pyvrp.org/notebooks/optional_clients.html

Setting up location coordinates and associated prize values for the clients.

```python
COORDS = [(456, 320), (312, 418), (114, 80), (570, 160), (684, 240)]
PRIZES = [500, 300, 500, 300]
```

--------------------------------

### Checkout Git Tag

Source: https://pyvrp.org/dev/releasing.html

Use this command to checkout a specific Git tag for release.

```bash
git checkout v0.12.0
```

--------------------------------

### Plotting Instance Details

Source: https://pyvrp.org/api/plotting.html

Plots client coordinates, time windows, and demand data for a problem instance.

```APIDOC
## plot_instance

### Description
Plots client coordinate, time window and demand data of the given instance.

### Method
`plot_instance`

### Parameters
#### Path Parameters
- **data** (ProblemData) - Required - Data instance.
- **fig** (Figure | None) - Optional - Figure to draw on. One will be created if not provided.

### Request Example
```python
plot_instance(data)
plot_instance(data, fig=my_figure)
```

### Response
This function does not return a value, but modifies the provided Figure object or creates a new one.
```

--------------------------------

### Visualizing the solution

Source: https://pyvrp.org/notebooks/mutually_exclusive_groups.html

Plots the resulting solution and annotates each client with its group label.

```python
_, ax = plt.subplots(figsize=(8, 8))
pyvrp.plotting.plot_solution(res.best, m.data(), plot_clients=True, ax=ax)

for client in m.clients:  # annotate client group label
    location = m.locations[client.location]
    ax.text(location.x + 10, location.y + 10, f"{client.group}")
```

--------------------------------

### Printing solution results

Source: https://pyvrp.org/notebooks/profiles.html

Displays the summary of the optimization results.

```python
print(res)
```

--------------------------------

### Define Release Times

Source: https://pyvrp.org/notebooks/duration_constraints.html

Set the release times for clients as a list where each index corresponds to a client.

```python
RELEASE_TIMES = [0, 4, 0, 0]
```

--------------------------------

### Initialize Iterated Local Search

Source: https://pyvrp.org/notebooks/pyvrp_implementation.html

Creates an IteratedLocalSearch algorithm instance with the provided instance, penalty manager, local search, and initial solution.

```python
from pyvrp import IteratedLocalSearch

algo = IteratedLocalSearch(INSTANCE, pen_manager, ls, init_sol)
```

--------------------------------

### Define New Client Data

Source: https://pyvrp.org/notebooks/quick_start.html

Define coordinates, demands, and time windows for new clients to be added to the model.

```python
NEW_COORDINATES = [(30, 80), (50, 90), (38.5, 82)]
NEW_DEMANDS = [5, 3, 7]
NEW_TIME_WINDOWS = [(0, 80), (0, 80), (80, 120)]
```

--------------------------------

### Visualizing the solution

Source: https://pyvrp.org/notebooks/profiles.html

Plots the optimized routes and highlights the restricted zone on the map.

```python
_, ax = plt.subplots(figsize=(8, 8))
pyvrp.plotting.plot_solution(res.best, m.data(), ax=ax, plot_clients=True)

# Highlight the restricted zone.
ax.fill_between(
    [ZONE[0][0], ZONE[1][0]],
    ZONE[0][1],
    ZONE[1][1],
    color="red",
    alpha=0.15,
);
```

--------------------------------

### Define instance data

Source: https://pyvrp.org/notebooks/reloading.html

Coordinates and demands for the routing instance.

```python
COORDS = [(456, 320), (312, 418), (114, 80), (570, 160), (684, 240)]
DEMANDS = [5, 8, 7, 6]
```

--------------------------------

### Defining client coordinates

Source: https://pyvrp.org/notebooks/profiles.html

Sets the list of coordinates for the depot and clients.

```python
COORDS = [(456, 320), (312, 418), (114, 80), (570, 160), (684, 240)]
```

--------------------------------

### Solution Class

Source: https://pyvrp.org/api/pyvrp.html

Constructor for the Solution class used to encode VRP solutions.

```APIDOC
## Solution(data, routes)

### Description
Encodes VRP solutions based on provided problem data and route configurations.

### Parameters
- **data** (ProblemData) - The data instance for the problem.
- **routes** (list[Route] | list[list[int]]) - A list of Route objects or lists of client visits.
```

--------------------------------

### Run PyVRP for macOS Instruments profiling

Source: https://pyvrp.org/dev/contributing.html

Executes a PyVRP instance with a sufficient runtime to allow attaching the Instruments profiler.

```bash
uv run pyvrp instances/VRPTW/RC2_10_5.vrp --seed 6 --round_func dimacs --max_runtime 60
```

--------------------------------

### Record performance data with perf on Linux

Source: https://pyvrp.org/dev/contributing.html

Uses the perf tool to record execution data for a specific PyVRP instance.

```bash
uv run perf record pyvrp instances/VRPTW/RC2_10_5.vrp --seed 6 --round_func dimacs --max_runtime 5
```

--------------------------------

### Display PyVRP version information

Source: https://pyvrp.org/api/pyvrp.html

Prints environment and dependency versions for debugging purposes.

```python
>>> import pyvrp
>>> pyvrp.show_versions()
INSTALLED VERSIONS
------------------
     pyvrp: 1.0.0
     numpy: 1.24.2
matplotlib: 3.7.0
    vrplib: 1.0.1
      tqdm: 4.64.1
    Python: 3.9.13
```

--------------------------------

### Initialize a random number generator

Source: https://pyvrp.org/notebooks/pyvrp_implementation.html

Creates a random number generator instance with a fixed seed for reproducibility.

```python
from pyvrp import RandomNumberGenerator

rng = RandomNumberGenerator(seed=42)
```

--------------------------------

### Import plotting utilities

Source: https://pyvrp.org/notebooks/pyvrp_implementation.html

Imports matplotlib and the PyVRP plotting module.

```python
import matplotlib.pyplot as plt

from pyvrp.plotting import plot_result
```

--------------------------------

### read(where, round_func='none')

Source: https://pyvrp.org/api/pyvrp.html

Reads a VRPLIB file and returns a ProblemData instance.

```APIDOC
## read(where, round_func='none')

### Description
Reads the VRPLIB file at the given location and returns a ProblemData instance.

### Parameters
- **where** (str | Path) - Required - File location to read.
- **round_func** (str | Callable) - Optional - Rounding function applied to data values. Options: 'round', 'trunc', 'dimacs', 'exact', 'none'.

### Returns
- **ProblemData** - Data instance constructed from the read data.
```

--------------------------------

### Create Temporary Branch

Source: https://pyvrp.org/dev/releasing.html

Create a new temporary branch for patch releases. Replace <BRANCH NAME> with a descriptive name.

```bash
git checkout -b <BRANCH NAME>
```

--------------------------------

### Visualize Solution

Source: https://pyvrp.org/notebooks/quick_start.html

Generate a visual representation of the calculated routes using the PyVRP plotting module.

```python
pyvrp.plotting.plot_solution(res.best, m.data())
```

--------------------------------

### Define Problem Data

Source: https://pyvrp.org/notebooks/quick_start.html

Set up the coordinates for the depot and clients, along with the delivery demands for each client.

```python
DEPOT_COORDINATES = (51.0, 51.0)
COORDINATES = [(39, 76.5), (64.2, 47), (73, 61), (32, 38.8)]
DEMANDS = [5, 3, 7, 2]
```

--------------------------------

### Visualize route schedule

Source: https://pyvrp.org/notebooks/duration_constraints.html

Plot the schedule of the first route to inspect timing and wait durations.

```python
route = res.best.routes()[0]
pyvrp.plotting.plot_route_schedule(m.data(), route)
```

--------------------------------

### Load a VRP instance

Source: https://pyvrp.org/notebooks/pyvrp_implementation.html

Reads a VRP instance file using the DIMACS rounding convention.

```python
from pyvrp import read

INSTANCE = read("data/RC208.vrp", round_func="dimacs")
```

--------------------------------

### solve(stop, seed=0, collect_stats=True, display=True, params=SolveParams(), missing_value=MAX_VALUE, initial_solution=None)

Source: https://pyvrp.org/api/pyvrp.html

Solves the defined routing model using the specified stopping criterion and parameters.

```APIDOC
## solve(stop, seed=0, collect_stats=True, display=True, params=SolveParams(), missing_value=MAX_VALUE, initial_solution=None)

### Description
Solve this model and return a Result object containing statistics and the best found solution.

### Parameters
- **stop** (StoppingCriterion) - Required - Stopping criterion to use.
- **seed** (int) - Optional - Seed value for random stream (default: 0).
- **collect_stats** (bool) - Optional - Whether to collect progress statistics (default: True).
- **display** (bool) - Optional - Whether to display progress (default: True).
- **params** (SolveParams) - Optional - Solver parameters.
- **initial_solution** (Solution | None) - Optional - Warm start solution.
```

--------------------------------

### Execute the solve function

Source: https://pyvrp.org/notebooks/pyvrp_implementation.html

Runs the solver with a specified stopping criterion and seed.

```python
res = solve(stop=MaxIterations(2000), seed=1)
print(res)
```

--------------------------------

### Model.add_client

Source: https://pyvrp.org/api/pyvrp.html

Adds a client to the model with specific delivery, pickup, and time window requirements.

```APIDOC
## Model.add_client(location, delivery=[], pickup=[], service_duration=0, tw_early=0, tw_late=np.iinfo(np.int64).max, release_time=0, prize=0, required=True, group=None, *, name='')

### Description
Adds a client with the given attributes to the model. Returns the created Client instance.

### Parameters
- **location** (Location) - Required - The location associated with this client.
- **delivery** (int | list[int]) - Optional - Delivery demands.
- **pickup** (int | list[int]) - Optional - Pickup demands.
- **service_duration** (int) - Optional - Duration of service at this client.
- **tw_early** (int) - Optional - Earliest start time.
- **tw_late** (int) - Optional - Latest start time.
- **release_time** (int) - Optional - Time when the client becomes available.
- **prize** (int) - Optional - Prize for visiting this client.
- **required** (bool) - Optional - Whether the client must be visited.
- **group** (ClientGroup | None) - Optional - The client group this client belongs to.
- **name** (str) - Optional - Name of the client.
```

--------------------------------

### Model.from_data

Source: https://pyvrp.org/api/pyvrp.html

Constructs a model instance from existing ProblemData.

```APIDOC
## Model.from_data(data)

### Description
Constructs a model instance from the given data. Only use this method if you intend to change the data using the model interface.

### Parameters
- **data** (ProblemData) - Required - Problem data to feed into the model.
```

--------------------------------

### Define delivery problem coordinates and demands

Source: https://pyvrp.org/notebooks/load.html

Sets up the spatial coordinates and delivery requirements for the clients.

```python
COORDS = [(0, 0), (0, 1), (2.5, 0)]
DELIVERIES = [4, 5]
```

--------------------------------

### solve(data, stop, seed, collect_stats, display, params, initial_solution)

Source: https://pyvrp.org/api/pyvrp.html

Solves the given problem data instance using the specified parameters and stopping criteria.

```APIDOC
## solve(data, stop, seed, collect_stats, display, params, initial_solution)

### Description
Solves the given problem data instance. Returns a Result object containing statistics and the best found solution.

### Parameters
- **data** (ProblemData) - Required - Problem data instance to solve.
- **stop** (StoppingCriterion) - Required - Stopping criterion to use.
- **seed** (int) - Optional - Seed value to use for the random number stream. Default 0.
- **collect_stats** (bool) - Optional - Whether to collect statistics about the solver’s progress. Default True.
- **display** (bool) - Optional - Whether to display information about the solver progress. Default False.
- **params** (SolveParams) - Optional - Solver parameters to use. Default SolveParams().
- **initial_solution** (Solution | None) - Optional - Optional solution to use as a warm start.
```

--------------------------------

### Display PyVRP version information

Source: https://pyvrp.org/setup/getting_help.html

Use this to provide environment details when reporting bugs. It can be run within a Python script or directly from the command line.

```python
import pyvrp
pyvrp.show_versions()
```

```bash
python -c 'import pyvrp; pyvrp.show_versions()'
```

--------------------------------

### Model.add_depot

Source: https://pyvrp.org/api/pyvrp.html

Adds a depot to the model with specific time window and service duration constraints.

```APIDOC
## Model.add_depot(location, tw_early=0, tw_late=np.iinfo(np.int64).max, service_duration=0, *, name='')

### Description
Adds a depot with the given attributes to the model. Returns the created Depot instance.

### Parameters
- **location** (Location) - Required - The location of the depot.
- **tw_early** (int) - Optional - Earliest start time.
- **tw_late** (int) - Optional - Latest start time.
- **service_duration** (int) - Optional - Service duration at the depot.
- **name** (str) - Optional - Name of the depot.
```

--------------------------------

### Plotting Solution

Source: https://pyvrp.org/api/plotting.html

Plots a given solution, optionally including all clients.

```APIDOC
## plot_solution

### Description
Plots the given solution.

### Method
`plot_solution`

### Parameters
#### Path Parameters
- **solution** (Solution) - Required - Solution to plot.
- **data** (ProblemData) - Required - Data instance underlying the solution.
- **plot_clients** (bool) - Optional - Whether to plot all clients as dots. Defaults to False.
- **ax** (Axes | None) - Optional - Axes object to draw the plot on. One will be created if not provided.

### Request Example
```python
plot_solution(solution, data)
plot_solution(solution, data, plot_clients=True, ax=my_axes)
```

### Response
This function does not return a value, but modifies the provided Axes object or creates a new one.
```

--------------------------------

### Run Algorithm with Stopping Criteria

Source: https://pyvrp.org/notebooks/pyvrp_implementation.html

Executes the algorithm using iteration-based or time-based stopping criteria.

```python
from pyvrp.stop import MaxIterations, MaxRuntime

iter_res = algo.run(stop=MaxIterations(2000))
time_res = algo.run(stop=MaxRuntime(1))  # seconds
```

--------------------------------

### Define Time Windows and Shift Duration

Source: https://pyvrp.org/notebooks/quick_start.html

Set the constraints for client delivery windows and vehicle shift limits.

```python
TIME_WINDOWS = [(0, 60), (60, 120), (0, 60), (60, 120)]
SHIFT_DURATION = 120
```

--------------------------------

### DynamicBitset

Source: https://pyvrp.org/api/pyvrp.html

A simple dynamic bitset implementation for fast membership checks on integers.

```APIDOC
## class DynamicBitset(num_bits: int)

### Description
A fast set for membership checks on integers in the range [0, num_bits). Useful for tracking client inclusion in solutions.

### Parameters
- **num_bits** (int) - Required - Number of integers the bitset must store.

### Methods
- **all()** -> bool: Returns True if all bits are set.
- **any()** -> bool: Returns True if any bit is set.
- **count()** -> int: Returns the number of set bits.
- **none()** -> bool: Returns True if no bits are set.
- **reset()** -> DynamicBitset: Resets all bits to zero.
- **set()** -> DynamicBitset: Sets all bits to one.
- **__getitem__(idx)** -> bool: Checks if the bit at index is set.
- **__setitem__(idx, value)**: Sets the bit at index to the specified boolean value.
```

--------------------------------

### Plotting Runtimes

Source: https://pyvrp.org/api/plotting.html

Plots the runtimes of each iteration.

```APIDOC
## plot_runtimes

### Description
Plots iteration runtimes.

### Method
`plot_runtimes`

### Parameters
#### Path Parameters
- **result** (Result) - Required - Result for which to plot runtimes.
- **ax** (Axes | None) - Optional - Axes object to draw the plot on. One will be created if not provided.

### Request Example
```python
plot_runtimes(result)
plot_runtimes(result, ax=my_axes)
```

### Response
This function does not return a value, but modifies the provided Axes object or creates a new one.
```

--------------------------------

### plot_time_windows

Source: https://pyvrp.org/api/plotting.html

Plots the time windows of clients in a problem instance.

```APIDOC
## plot_time_windows

### Description
Plots client time windows, as vertical bars sorted by time window.

### Method
(Not specified, likely a function call)

### Endpoint
(Not applicable, this is a function)

### Parameters
#### Path Parameters
(None)

#### Query Parameters
(None)

#### Request Body
(None)

### Request Example
(Not applicable, this is a function call)

### Response
#### Success Response (200)
(Not applicable, this is a function that generates a plot)

#### Response Example
(Not applicable)

### Parameters
- **_data** (ProblemData) - Required - Data instance.
- **_title** (str) - Optional - Title to add to the plot. Defaults to 'Time windows'.
- **_ax** (Axes | None) - Optional - Axes object to draw the plot on. One will be created if not provided.
```

--------------------------------

### ProblemData

Source: https://pyvrp.org/api/pyvrp.html

Constructor for creating a problem data instance containing all necessary information to solve a vehicle routing problem.

```APIDOC
## ProblemData

### Description
Initializes a new ProblemData instance, which aggregates all locations, clients, depots, vehicle types, and matrices required for the routing problem.

### Parameters
- **locations** (list[Location]) - Required - List of physical locations.
- **clients** (list[Client]) - Required - List of clients to visit.
- **depots** (list[Depot]) - Required - List of depots (at least one required).
- **vehicle_types** (list[VehicleType]) - Required - List of vehicle types.
- **distance_matrices** (list[ndarray[int]]) - Required - Distance matrices per routing profile.
- **duration_matrices** (list[ndarray[int]]) - Required - Duration matrices per routing profile.
- **groups** (list[ClientGroup]) - Optional - List of client groups.
```

--------------------------------

### Build extensions in debug mode

Source: https://pyvrp.org/dev/contributing.html

Compile the C++ extensions with debug symbols enabled for easier troubleshooting.

```bash
uv run buildtools/build_extensions.py --build_type debug
```

--------------------------------

### Importing PyVRP modules

Source: https://pyvrp.org/notebooks/mutually_exclusive_groups.html

Standard imports required for running PyVRP models and plotting results.

```python
import matplotlib.pyplot as plt

import pyvrp
import pyvrp.plotting
import pyvrp.stop
```

--------------------------------

### Improve Solution with Local Search

Source: https://pyvrp.org/notebooks/pyvrp_implementation.html

Applies local search to improve the solution and evaluates the new penalized cost.

```python
new_sol = ls(sol, cost_evaluator, exhaustive=True)

assert not sol.is_feasible()
print(cost_evaluator.penalised_cost(new_sol))
```

--------------------------------

### Build PyVRP with debug symbols

Source: https://pyvrp.org/dev/contributing.html

Compiles the C++ extensions with debug symbols enabled to ensure profiling output contains meaningful information.

```bash
uv run buildtools/build_extensions.py --build_type debugoptimized
```

--------------------------------

### Inspect route trip details

Source: https://pyvrp.org/notebooks/reloading.html

Iterates through the route to display the trip index for each activity.

```python
route = res.best.routes()[0]

print("Route plan:")
for activity in route:
    print(f" - At {activity}, on trip {activity.trip}.")
```

--------------------------------

### Push Git Tag

Source: https://pyvrp.org/dev/releasing.html

Push the newly created local tag to the remote repository (GitHub).

```bash
git push origin tag v0.12.0
```
Tokens:
Raw