0
# Batch Operations
1

2
Batch processing capabilities for optimizing multiple route optimization requests as long-running operations with Cloud Storage integration. This allows processing large numbers of optimization requests asynchronously with results stored in Google Cloud Storage.
3

4
## Capabilities
5

6
### batch_optimize_tours
7

8
Optimizes vehicle tours for multiple requests as a batch Long Running Operation (LRO). Input and output files are read from and written to Cloud Storage.
9

10
```python { .api }
11
def batch_optimize_tours(
12
    request: BatchOptimizeToursRequest,
13
    *,
14
    retry: Optional[Retry] = gapic_v1.method.DEFAULT,
15
    timeout: Union[float, object] = gapic_v1.method.DEFAULT,
16
    metadata: Sequence[Tuple[str, Union[str, bytes]]] = ()
17
) -> operation.Operation: ...
18
```
19

20
**Parameters:**
21
- `request`: `BatchOptimizeToursRequest` - Batch optimization request with input/output configuration
22
- `retry`: Optional retry configuration for the request
23
- `timeout`: Optional timeout for the request (float seconds or object)
24
- `metadata`: Optional metadata sequence for the request
25

26
**Returns:** `operation.Operation` - Long Running Operation handle for monitoring progress
27

28
### Request/Response Types
29

30
#### BatchOptimizeToursRequest
31

32
```python { .api }
33
class BatchOptimizeToursRequest:
34
    parent: str  # Required. Format: "projects/{project-id}" or "projects/{project-id}/locations/{location-id}"
35
    model_configs: Sequence[AsyncModelConfig]  # Required. Input/output configuration for each model
36
    
37
    class AsyncModelConfig:
38
        display_name: str  # Optional. Display name for this model config
39
        input_config: InputConfig  # Required. Input file configuration
40
        output_config: OutputConfig  # Required. Output file configuration
41
```
42

43
#### BatchOptimizeToursResponse
44

45
```python { .api }
46
class BatchOptimizeToursResponse:
47
    # Empty message - results are written to Cloud Storage locations specified in the request
48
    pass
49
```
50

51
#### BatchOptimizeToursMetadata
52

53
```python { .api }
54
class BatchOptimizeToursMetadata:
55
    # Metadata for the batch optimization LRO
56
    pass
57
```
58

59
## File I/O Configuration
60

61
### InputConfig
62

63
```python { .api }
64
class InputConfig:
65
    gcs_source: Optional[GcsSource]  # Google Cloud Storage source
66
    data_format: Optional[DataFormat]  # File format (JSON or PROTO_TEXT)
67
```
68

69
### OutputConfig
70

71
```python { .api }
72
class OutputConfig:
73
    gcs_destination: Optional[GcsDestination]  # Google Cloud Storage destination
74
    data_format: Optional[DataFormat]  # File format (JSON or PROTO_TEXT)
75
```
76

77
### GcsSource
78

79
```python { .api }
80
class GcsSource:
81
    uri: str  # Required. GCS URI (e.g., "gs://bucket/input.json")
82
```
83

84
### GcsDestination
85

86
```python { .api }
87
class GcsDestination:
88
    uri: str  # Required. GCS URI (e.g., "gs://bucket/output.json")
89
```
90

91
### DataFormat
92

93
```python { .api }
94
class DataFormat(enum.Enum):
95
    DATA_FORMAT_UNSPECIFIED = 0  # Invalid value
96
    JSON = 1  # JavaScript Object Notation
97
    PROTO_TEXT = 2  # Protocol Buffers text format
98
```
99

100
## Usage Examples
101

102
### Basic Batch Operation
103

104
```python
105
from google.maps import routeoptimization_v1
106

107
client = routeoptimization_v1.RouteOptimizationClient()
108

109
# Create batch request with multiple input files
110
request = routeoptimization_v1.BatchOptimizeToursRequest(
111
    parent="projects/my-project",
112
    model_configs=[
113
        routeoptimization_v1.BatchOptimizeToursRequest.AsyncModelConfig(
114
            display_name="Route Set 1",
115
            input_config=routeoptimization_v1.InputConfig(
116
                gcs_source=routeoptimization_v1.GcsSource(
117
                    uri="gs://my-bucket/input/route_set_1.json"
118
                ),
119
                data_format=routeoptimization_v1.DataFormat.JSON
120
            ),
121
            output_config=routeoptimization_v1.OutputConfig(
122
                gcs_destination=routeoptimization_v1.GcsDestination(
123
                    uri="gs://my-bucket/output/route_set_1_result.json"
124
                ),
125
                data_format=routeoptimization_v1.DataFormat.JSON
126
            )
127
        ),
128
        routeoptimization_v1.BatchOptimizeToursRequest.AsyncModelConfig(
129
            display_name="Route Set 2",
130
            input_config=routeoptimization_v1.InputConfig(
131
                gcs_source=routeoptimization_v1.GcsSource(
132
                    uri="gs://my-bucket/input/route_set_2.json"
133
                ),
134
                data_format=routeoptimization_v1.DataFormat.JSON
135
            ),
136
            output_config=routeoptimization_v1.OutputConfig(
137
                gcs_destination=routeoptimization_v1.GcsDestination(
138
                    uri="gs://my-bucket/output/route_set_2_result.json"
139
                ),
140
                data_format=routeoptimization_v1.DataFormat.JSON
141
            )
142
        )
143
    ]
144
)
145

146
# Start batch operation
147
operation = client.batch_optimize_tours(request=request)
148

149
print(f"Batch operation started: {operation.name}")
150
```
151

152
### Monitoring Batch Operation
153

154
```python
155
from google.maps import routeoptimization_v1
156
import time
157

158
client = routeoptimization_v1.RouteOptimizationClient()
159

160
# Start batch operation (from previous example)
161
operation = client.batch_optimize_tours(request=request)
162

163
# Monitor progress
164
while not operation.done():
165
    print("Batch optimization in progress...")
166
    time.sleep(30)  # Wait 30 seconds
167
    operation = client.get_operation(name=operation.name)
168

169
# Check results
170
if operation.error:
171
    print(f"Batch operation failed: {operation.error}")
172
else:
173
    print("Batch optimization completed successfully")
174
    print("Results are available in the specified GCS output locations")
175
    
176
    # Access results from Cloud Storage
177
    # (Results are written to the GCS URIs specified in output_config)
178
```
179

180
### Multiple File Formats
181

182
```python
183
from google.maps import routeoptimization_v1
184

185
client = routeoptimization_v1.RouteOptimizationClient()
186

187
# Process different file formats
188
request = routeoptimization_v1.BatchOptimizeToursRequest(
189
    parent="projects/my-project",
190
    model_configs=[
191
        # JSON input/output
192
        routeoptimization_v1.BatchOptimizeToursRequest.AsyncModelConfig(
193
            display_name="JSON Processing",
194
            input_config=routeoptimization_v1.InputConfig(
195
                gcs_source=routeoptimization_v1.GcsSource(
196
                    uri="gs://my-bucket/input.json"
197
                ),
198
                data_format=routeoptimization_v1.DataFormat.JSON
199
            ),
200
            output_config=routeoptimization_v1.OutputConfig(
201
                gcs_destination=routeoptimization_v1.GcsDestination(
202
                    uri="gs://my-bucket/output.json"
203
                ),
204
                data_format=routeoptimization_v1.DataFormat.JSON
205
            )
206
        ),
207
        # Protocol Buffer text format
208
        routeoptimization_v1.BatchOptimizeToursRequest.AsyncModelConfig(
209
            display_name="Proto Text Processing",
210
            input_config=routeoptimization_v1.InputConfig(
211
                gcs_source=routeoptimization_v1.GcsSource(
212
                    uri="gs://my-bucket/input.pbtxt"
213
                ),
214
                data_format=routeoptimization_v1.DataFormat.PROTO_TEXT
215
            ),
216
            output_config=routeoptimization_v1.OutputConfig(
217
                gcs_destination=routeoptimization_v1.GcsDestination(
218
                    uri="gs://my-bucket/output.pbtxt"
219
                ),
220
                data_format=routeoptimization_v1.DataFormat.PROTO_TEXT
221
            )
222
        )
223
    ]
224
)
225

226
operation = client.batch_optimize_tours(request=request)
227
```
228

229
### Input File Format
230

231
Each input file should contain a single `OptimizeToursRequest` in the specified format:
232

233
**JSON format example:**
234
```json
235
{
236
  "parent": "projects/my-project",
237
  "model": {
238
    "shipments": [
239
      {
240
        "displayName": "Package 1",
241
        "deliveries": [
242
          {
243
            "location": {
244
              "latLng": {
245
                "latitude": 37.7749,
246
                "longitude": -122.4194
247
              }
248
            }
249
          }
250
        ]
251
      }
252
    ],
253
    "vehicles": [
254
      {
255
        "displayName": "Vehicle 1",
256
        "startLocation": {
257
          "latLng": {
258
            "latitude": 37.7649,
259
            "longitude": -122.4294
260
          }
261
        }
262
      }
263
    ]
264
  }
265
}
266
```
267

268
### Output File Format
269

270
Each output file will contain a single `OptimizeToursResponse` with the optimized routes and metrics in the requested format.