0
# Google Maps Route Optimization
1

2
A Python client library for Google's Route Optimization API that assigns tasks and routes to vehicle fleets while optimizing against custom objectives and constraints. This library provides comprehensive fleet management capabilities including route planning, task assignment, vehicle constraints handling, and optimization algorithms that consider factors like delivery windows, vehicle capacities, driver schedules, and traffic conditions.
3

4
## Package Information
5

6
- **Package Name**: google-maps-routeoptimization
7
- **Language**: Python
8
- **Installation**: `pip install google-maps-routeoptimization`
9

10
## Core Imports
11

12
```python
13
from google.maps import routeoptimization_v1
14
```
15

16
Alternative import (equivalent):
17

18
```python
19
from google.maps import routeoptimization
20
```
21

22
Specific component imports:
23

24
```python
25
from google.maps.routeoptimization_v1 import (
26
    RouteOptimizationClient,
27
    RouteOptimizationAsyncClient,
28
    OptimizeToursRequest,
29
    OptimizeToursResponse,
30
    BatchOptimizeToursRequest
31
)
32
from google.maps.routeoptimization_v1.types import (
33
    Shipment,
34
    Vehicle,
35
    ShipmentModel,
36
    Location,
37
    TimeWindow
38
)
39
```
40

41
## Basic Usage
42

43
```python
44
from google.maps import routeoptimization_v1
45

46
# Create a client
47
client = routeoptimization_v1.RouteOptimizationClient()
48

49
# Create a simple optimization request
50
request = routeoptimization_v1.OptimizeToursRequest(
51
    parent="projects/your-project-id",
52
    model=routeoptimization_v1.ShipmentModel(
53
        shipments=[
54
            routeoptimization_v1.Shipment(
55
                display_name="Package 1",
56
                pickups=[{
57
                    "location": {"lat_lng": {"latitude": 37.7749, "longitude": -122.4194}},
58
                    "time_windows": [{"start_time": {"seconds": 0}, "end_time": {"seconds": 86400}}]
59
                }],
60
                deliveries=[{
61
                    "location": {"lat_lng": {"latitude": 37.7849, "longitude": -122.4094}},
62
                    "time_windows": [{"start_time": {"seconds": 0}, "end_time": {"seconds": 86400}}]
63
                }]
64
            )
65
        ],
66
        vehicles=[
67
            routeoptimization_v1.Vehicle(
68
                display_name="Vehicle 1",
69
                start_location={"lat_lng": {"latitude": 37.7649, "longitude": -122.4294}},
70
                end_location={"lat_lng": {"latitude": 37.7649, "longitude": -122.4294}}
71
            )
72
        ]
73
    )
74
)
75

76
# Make the request
77
response = client.optimize_tours(request=request)
78

79
# Process the optimized routes
80
for route in response.routes:
81
    print(f"Vehicle {route.vehicle_index}: {len(route.visits)} stops")
82
```
83

84
## Architecture
85

86
The API follows Google Cloud client library patterns:
87

88
- **Client Classes**: Synchronous (`RouteOptimizationClient`) and asynchronous (`RouteOptimizationAsyncClient`) clients
89
- **Request/Response Pattern**: Strongly-typed proto message classes for all API calls
90
- **Data Model**: Rich type system representing optimization problems through `ShipmentModel`, `Shipment`, `Vehicle`, and related classes
91
- **Long Running Operations**: Batch operations return LRO handles for monitoring large-scale optimizations
92
- **Authentication**: Integrates with Google Cloud authentication (service accounts, application default credentials)
93
- **Error Handling**: Uses `google.api_core.exceptions` for standardized error handling
94

95
## Capabilities
96

97
### Route Optimization
98

99
Core single-request route optimization functionality for optimizing vehicle tours against custom objectives and constraints.
100

101
```python { .api }
102
def optimize_tours(
103
    request: OptimizeToursRequest,
104
    *,
105
    retry: Optional[Retry] = gapic_v1.method.DEFAULT,
106
    timeout: Union[float, object] = gapic_v1.method.DEFAULT,
107
    metadata: Sequence[Tuple[str, Union[str, bytes]]] = ()
108
) -> OptimizeToursResponse: ...
109
```
110

111
[Route Optimization](./route-optimization.md)
112

113
### Batch Operations
114

115
Batch processing capabilities for optimizing multiple route optimization requests as long-running operations with Cloud Storage integration.
116

117
```python { .api }
118
def batch_optimize_tours(
119
    request: BatchOptimizeToursRequest,
120
    *,
121
    retry: Optional[Retry] = gapic_v1.method.DEFAULT,
122
    timeout: Union[float, object] = gapic_v1.method.DEFAULT,
123
    metadata: Sequence[Tuple[str, Union[str, bytes]]] = ()
124
) -> operation.Operation: ...
125
```
126

127
[Batch Operations](./batch-operations.md)
128

129
### Data Model
130

131
Comprehensive data model for representing route optimization problems including shipments, vehicles, constraints, time windows, and optimization parameters.
132

133
```python { .api }
134
class ShipmentModel: ...
135
class Shipment: ...
136
class Vehicle: ...
137
class Location: ...
138
class TimeWindow: ...
139
class BreakRule: ...
140
class DistanceLimit: ...
141
```
142

143
[Data Model](./data-model.md)
144

145
### Client Configuration
146

147
Client instantiation, authentication, and configuration options for both synchronous and asynchronous operation modes.
148

149
```python { .api }
150
class RouteOptimizationClient:
151
    def __init__(self, *, credentials: Optional[ga_credentials.Credentials] = None, ...): ...
152
    @classmethod
153
    def from_service_account_info(cls, info: dict, *args, **kwargs): ...
154
    @classmethod
155
    def from_service_account_file(cls, filename: str, *args, **kwargs): ...
156

157
class RouteOptimizationAsyncClient:
158
    def __init__(self, *, credentials: Optional[ga_credentials.Credentials] = None, ...): ...
159
```
160

161
[Client Configuration](./client-configuration.md)