0
# Batch Operations
1
2
High-volume batch processing including batch job management, offline user data jobs, and asynchronous operation handling for large-scale account management. The Google Ads API provides robust batch processing capabilities for handling thousands of operations efficiently.
3
4
## Capabilities
5
6
### Batch Job Operations
7
8
Batch job management operations for processing large numbers of mutate operations asynchronously with comprehensive error handling and progress tracking.
9
10
```python { .api }
11
def create_batch_job(
12
self,
13
request: Optional[CreateBatchJobRequest] = None,
14
customer_id: Optional[str] = None
15
) -> BatchJob:
16
"""
17
Create a new batch job for processing multiple operations.
18
19
Args:
20
request: The request object
21
customer_id: Required customer ID
22
23
Returns:
24
BatchJob resource with job details
25
"""
26
27
def mutate_batch_job(
28
self,
29
request: Optional[MutateBatchJobRequest] = None,
30
customer_id: Optional[str] = None,
31
operation: Optional[BatchJobOperation] = None
32
) -> MutateBatchJobResponse:
33
"""
34
Update batch job settings.
35
36
Args:
37
request: The request object
38
customer_id: Required customer ID
39
operation: Batch job operation
40
41
Returns:
42
MutateBatchJobResponse with results
43
"""
44
45
def get_batch_job(
46
self,
47
request: Optional[GetBatchJobRequest] = None,
48
resource_name: Optional[str] = None
49
) -> BatchJob:
50
"""
51
Retrieve batch job by resource name.
52
53
Args:
54
request: The request object
55
resource_name: Batch job resource name
56
57
Returns:
58
BatchJob resource object
59
"""
60
61
def list_batch_job_results(
62
self,
63
request: Optional[ListBatchJobResultsRequest] = None,
64
resource_name: Optional[str] = None,
65
page_size: Optional[int] = None,
66
page_token: Optional[str] = None
67
response_content_type: Optional[ResponseContentTypeEnum.ResponseContentType] = None
68
) -> ListBatchJobResultsResponse:
69
"""
70
List results from a completed batch job.
71
72
Args:
73
request: The request object
74
resource_name: Batch job resource name
75
page_size: Number of results per page
76
page_token: Pagination token
77
response_content_type: Response content type
78
79
Returns:
80
ListBatchJobResultsResponse with operation results
81
"""
82
83
def add_batch_job_operations(
84
self,
85
request: Optional[AddBatchJobOperationsRequest] = None,
86
resource_name: Optional[str] = None,
87
sequence_token: Optional[str] = None,
88
mutate_operations: Optional[Sequence[MutateOperation]] = None
89
) -> AddBatchJobOperationsResponse:
90
"""
91
Add operations to a batch job.
92
93
Args:
94
request: The request object
95
resource_name: Batch job resource name
96
sequence_token: Token for operation sequencing
97
mutate_operations: List of mutate operations to add
98
99
Returns:
100
AddBatchJobOperationsResponse with sequence token
101
"""
102
103
def run_batch_job(
104
self,
105
request: Optional[RunBatchJobRequest] = None,
106
resource_name: Optional[str] = None
107
) -> Operation:
108
"""
109
Start execution of a batch job.
110
111
Args:
112
request: The request object
113
resource_name: Batch job resource name
114
115
Returns:
116
Operation representing the batch job execution
117
"""
118
```
119
120
### Offline User Data Job Operations
121
122
Offline user data job operations for processing large-scale customer match uploads, user list updates, and audience data synchronization.
123
124
```python { .api }
125
def create_offline_user_data_job(
126
self,
127
request: Optional[CreateOfflineUserDataJobRequest] = None,
128
customer_id: Optional[str] = None,
129
job: Optional[OfflineUserDataJob] = None
130
) -> CreateOfflineUserDataJobResponse:
131
"""
132
Create an offline user data job for customer match operations.
133
134
Args:
135
request: The request object
136
customer_id: Required customer ID
137
job: Offline user data job configuration
138
139
Returns:
140
CreateOfflineUserDataJobResponse with job resource name
141
"""
142
143
def get_offline_user_data_job(
144
self,
145
request: Optional[GetOfflineUserDataJobRequest] = None,
146
resource_name: Optional[str] = None
147
) -> OfflineUserDataJob:
148
"""
149
Retrieve offline user data job by resource name.
150
151
Args:
152
request: The request object
153
resource_name: Offline user data job resource name
154
155
Returns:
156
OfflineUserDataJob resource object
157
"""
158
159
def add_offline_user_data_job_operations(
160
self,
161
request: Optional[AddOfflineUserDataJobOperationsRequest] = None,
162
resource_name: Optional[str] = None,
163
enable_partial_failure: Optional[bool] = None,
164
enable_warnings: Optional[bool] = None,
165
operations: Optional[Sequence[OfflineUserDataJobOperation]] = None
166
) -> AddOfflineUserDataJobOperationsResponse:
167
"""
168
Add operations to an offline user data job.
169
170
Args:
171
request: The request object
172
resource_name: Offline user data job resource name
173
enable_partial_failure: Continue on individual failures
174
enable_warnings: Enable warning messages
175
operations: List of user data operations
176
177
Returns:
178
AddOfflineUserDataJobOperationsResponse
179
"""
180
181
def run_offline_user_data_job(
182
self,
183
request: Optional[RunOfflineUserDataJobRequest] = None,
184
resource_name: Optional[str] = None,
185
validate_only: bool = False
186
) -> Operation:
187
"""
188
Start execution of an offline user data job.
189
190
Args:
191
request: The request object
192
resource_name: Offline user data job resource name
193
validate_only: Validate without executing
194
195
Returns:
196
Operation representing the job execution
197
"""
198
```
199
200
## Batch Job Examples
201
202
### Create and Execute Batch Job
203
204
```python
205
from google.ads.googleads.client import GoogleAdsClient
206
from google.ads.googleads.errors import GoogleAdsException
207
import time
208
209
def execute_batch_operations(client, customer_id, operations_list):
210
"""Execute a large number of operations using batch processing."""
211
212
batch_job_service = client.get_service("BatchJobService")
213
214
# Step 1: Create batch job
215
try:
216
batch_job = batch_job_service.create_batch_job(customer_id=customer_id)
217
batch_job_resource_name = batch_job.resource_name
218
print(f"Created batch job: {batch_job_resource_name}")
219
220
except GoogleAdsException as ex:
221
print(f"Failed to create batch job: {ex.error.code().name}")
222
return None
223
224
# Step 2: Add operations to batch job
225
try:
226
# Convert operations to MutateOperation format
227
mutate_operations = []
228
for operation in operations_list:
229
mutate_operation = client.get_type("MutateOperation")
230
231
# Set the appropriate operation type
232
if hasattr(operation, 'campaign'):
233
mutate_operation.campaign_operation = operation
234
elif hasattr(operation, 'ad_group'):
235
mutate_operation.ad_group_operation = operation
236
elif hasattr(operation, 'ad_group_ad'):
237
mutate_operation.ad_group_ad_operation = operation
238
elif hasattr(operation, 'ad_group_criterion'):
239
mutate_operation.ad_group_criterion_operation = operation
240
241
mutate_operations.append(mutate_operation)
242
243
# Add operations in chunks (max 10,000 per request)
244
chunk_size = 10000
245
sequence_token = ""
246
247
for i in range(0, len(mutate_operations), chunk_size):
248
chunk = mutate_operations[i:i + chunk_size]
249
250
response = batch_job_service.add_batch_job_operations(
251
resource_name=batch_job_resource_name,
252
sequence_token=sequence_token,
253
mutate_operations=chunk
254
)
255
256
sequence_token = response.next_sequence_token
257
print(f"Added chunk {i//chunk_size + 1}: {len(chunk)} operations")
258
259
except GoogleAdsException as ex:
260
print(f"Failed to add operations: {ex.error.code().name}")
261
return None
262
263
# Step 3: Run the batch job
264
try:
265
operation = batch_job_service.run_batch_job(
266
resource_name=batch_job_resource_name
267
)
268
print(f"Started batch job execution: {operation.name}")
269
270
except GoogleAdsException as ex:
271
print(f"Failed to run batch job: {ex.error.code().name}")
272
return None
273
274
# Step 4: Poll for completion
275
while True:
276
batch_job = batch_job_service.get_batch_job(
277
resource_name=batch_job_resource_name
278
)
279
280
status = batch_job.status
281
print(f"Batch job status: {status.name}")
282
283
if status == client.enums.BatchJobStatusEnum.DONE:
284
print("Batch job completed successfully!")
285
break
286
elif status == client.enums.BatchJobStatusEnum.FAILED:
287
print("Batch job failed!")
288
return None
289
elif status in [client.enums.BatchJobStatusEnum.PENDING, client.enums.BatchJobStatusEnum.RUNNING]:
290
print("Batch job still processing... waiting 30 seconds")
291
time.sleep(30)
292
else:
293
print(f"Unknown status: {status}")
294
return None
295
296
# Step 5: Retrieve results
297
try:
298
results_response = batch_job_service.list_batch_job_results(
299
resource_name=batch_job_resource_name
300
)
301
302
successful_operations = 0
303
failed_operations = 0
304
305
for result in results_response.results:
306
if result.status and result.status.code != 0:
307
failed_operations += 1
308
print(f"Operation failed: {result.status.message}")
309
else:
310
successful_operations += 1
311
312
print(f"Results: {successful_operations} successful, {failed_operations} failed")
313
return results_response.results
314
315
except GoogleAdsException as ex:
316
print(f"Failed to retrieve results: {ex.error.code().name}")
317
return None
318
319
# Example usage - batch create campaigns
320
def create_campaigns_batch(client, customer_id, campaign_data_list):
321
"""Create multiple campaigns using batch processing."""
322
323
operations = []
324
325
for campaign_data in campaign_data_list:
326
operation = client.get_type("CampaignOperation")
327
campaign = operation.create
328
329
campaign.name = campaign_data['name']
330
campaign.advertising_channel_type = campaign_data['channel_type']
331
campaign.status = client.enums.CampaignStatusEnum.PAUSED
332
campaign.campaign_budget = campaign_data['budget_resource_name']
333
334
# Set bidding strategy
335
if campaign_data.get('bidding_strategy') == 'manual_cpc':
336
campaign.manual_cpc.enhanced_cpc_enabled = True
337
elif campaign_data.get('bidding_strategy') == 'target_cpa':
338
campaign.target_cpa.target_cpa_micros = campaign_data.get('target_cpa_micros', 5000000)
339
340
operations.append(operation)
341
342
return execute_batch_operations(client, customer_id, operations)
343
```
344
345
### Large-Scale Keyword Management
346
347
```python
348
def batch_keyword_operations(client, customer_id, keyword_operations_data):
349
"""Perform batch keyword operations (add, update, remove)."""
350
351
operations = []
352
353
for keyword_data in keyword_operations_data:
354
operation = client.get_type("AdGroupCriterionOperation")
355
356
if keyword_data['action'] == 'create':
357
criterion = operation.create
358
criterion.ad_group = keyword_data['ad_group_resource_name']
359
criterion.status = client.enums.AdGroupCriterionStatusEnum.ENABLED
360
criterion.type_ = client.enums.CriterionTypeEnum.KEYWORD
361
criterion.keyword.text = keyword_data['keyword_text']
362
criterion.keyword.match_type = keyword_data['match_type']
363
criterion.cpc_bid_micros = keyword_data.get('cpc_bid_micros')
364
365
elif keyword_data['action'] == 'update':
366
criterion = operation.update
367
criterion.resource_name = keyword_data['resource_name']
368
criterion.cpc_bid_micros = keyword_data['new_cpc_bid_micros']
369
operation.update_mask = client.get_type("FieldMask", paths=["cpc_bid_micros"])
370
371
elif keyword_data['action'] == 'remove':
372
operation.remove = keyword_data['resource_name']
373
374
operations.append(operation)
375
376
return execute_batch_operations(client, customer_id, operations)
377
378
# Example usage
379
keyword_operations = [
380
{
381
'action': 'create',
382
'ad_group_resource_name': 'customers/123/adGroups/456',
383
'keyword_text': 'running shoes',
384
'match_type': client.enums.KeywordMatchTypeEnum.EXACT,
385
'cpc_bid_micros': 2000000
386
},
387
{
388
'action': 'update',
389
'resource_name': 'customers/123/adGroupCriteria/789',
390
'new_cpc_bid_micros': 2500000
391
},
392
{
393
'action': 'remove',
394
'resource_name': 'customers/123/adGroupCriteria/101112'
395
}
396
]
397
398
batch_keyword_operations(client, customer_id, keyword_operations)
399
```
400
401
## Offline User Data Job Examples
402
403
### Customer Match Email Upload
404
405
```python
406
import hashlib
407
408
def upload_customer_match_emails(client, customer_id, user_list_resource_name, email_addresses):
409
"""Upload email addresses to a customer match user list."""
410
411
offline_user_data_job_service = client.get_service("OfflineUserDataJobService")
412
413
# Step 1: Create offline user data job
414
job = client.get_type("OfflineUserDataJob")
415
job.type_ = client.enums.OfflineUserDataJobTypeEnum.CUSTOMER_MATCH_USER_LIST
416
job.customer_match_user_list_metadata.user_list = user_list_resource_name
417
418
try:
419
create_job_response = offline_user_data_job_service.create_offline_user_data_job(
420
customer_id=customer_id,
421
job=job
422
)
423
424
job_resource_name = create_job_response.resource_name
425
print(f"Created offline user data job: {job_resource_name}")
426
427
except GoogleAdsException as ex:
428
print(f"Failed to create job: {ex.error.code().name}")
429
return None
430
431
# Step 2: Add user data operations
432
try:
433
operations = []
434
435
for email in email_addresses:
436
operation = client.get_type("OfflineUserDataJobOperation")
437
user_data = operation.create
438
439
# Hash the email address for privacy
440
hashed_email = hashlib.sha256(email.lower().strip().encode()).hexdigest()
441
442
user_identifier = client.get_type("UserIdentifier")
443
user_identifier.hashed_email = hashed_email
444
445
user_data.user_identifiers.append(user_identifier)
446
operations.append(operation)
447
448
# Add operations in chunks
449
chunk_size = 100000 # Maximum per request
450
451
for i in range(0, len(operations), chunk_size):
452
chunk = operations[i:i + chunk_size]
453
454
offline_user_data_job_service.add_offline_user_data_job_operations(
455
resource_name=job_resource_name,
456
enable_partial_failure=True,
457
operations=chunk
458
)
459
460
print(f"Added chunk {i//chunk_size + 1}: {len(chunk)} email operations")
461
462
except GoogleAdsException as ex:
463
print(f"Failed to add operations: {ex.error.code().name}")
464
return None
465
466
# Step 3: Run the job
467
try:
468
operation = offline_user_data_job_service.run_offline_user_data_job(
469
resource_name=job_resource_name
470
)
471
print(f"Started user data job: {operation.name}")
472
473
except GoogleAdsException as ex:
474
print(f"Failed to run job: {ex.error.code().name}")
475
return None
476
477
# Step 4: Monitor job progress
478
while True:
479
job_status = offline_user_data_job_service.get_offline_user_data_job(
480
resource_name=job_resource_name
481
)
482
483
status = job_status.status
484
print(f"Job status: {status.name}")
485
486
if status == client.enums.OfflineUserDataJobStatusEnum.SUCCESS:
487
print("User data job completed successfully!")
488
print(f"Matched users: {job_status.customer_match_user_list_metadata.user_list_size_for_search}")
489
break
490
elif status == client.enums.OfflineUserDataJobStatusEnum.FAILED:
491
print(f"User data job failed: {job_status.failure_reason}")
492
break
493
elif status in [client.enums.OfflineUserDataJobStatusEnum.PENDING, client.enums.OfflineUserDataJobStatusEnum.RUNNING]:
494
print("Job still processing... waiting 60 seconds")
495
time.sleep(60)
496
else:
497
print(f"Unknown status: {status}")
498
break
499
500
return job_resource_name
501
502
# Example usage
503
customer_emails = [
504
"john.doe@example.com",
505
"jane.smith@example.com",
506
"customer@company.com"
507
# ... thousands more emails
508
]
509
510
upload_customer_match_emails(client, customer_id, user_list_resource_name, customer_emails)
511
```
512
513
### Store Sales Upload
514
515
```python
516
def upload_store_sales_data(client, customer_id, conversion_action_resource_name, store_sales_data):
517
"""Upload store sales data for conversion tracking."""
518
519
offline_user_data_job_service = client.get_service("OfflineUserDataJobService")
520
521
# Create store sales upload job
522
job = client.get_type("OfflineUserDataJob")
523
job.type_ = client.enums.OfflineUserDataJobTypeEnum.STORE_SALES_UPLOAD_FIRST_PARTY
524
525
# Configure store sales metadata
526
store_sales_metadata = job.store_sales_metadata
527
store_sales_metadata.loyalty_fraction = 0.8 # 80% of sales are from loyalty customers
528
store_sales_metadata.transaction_upload_fraction = 1.0 # Upload 100% of transactions
529
530
create_job_response = offline_user_data_job_service.create_offline_user_data_job(
531
customer_id=customer_id,
532
job=job
533
)
534
535
job_resource_name = create_job_response.resource_name
536
537
# Add store sales operations
538
operations = []
539
540
for sale_data in store_sales_data:
541
operation = client.get_type("OfflineUserDataJobOperation")
542
user_data = operation.create
543
544
# Add user identifiers
545
if 'email' in sale_data:
546
hashed_email = hashlib.sha256(sale_data['email'].lower().encode()).hexdigest()
547
user_identifier = client.get_type("UserIdentifier")
548
user_identifier.hashed_email = hashed_email
549
user_data.user_identifiers.append(user_identifier)
550
551
if 'phone' in sale_data:
552
hashed_phone = hashlib.sha256(sale_data['phone'].encode()).hexdigest()
553
user_identifier = client.get_type("UserIdentifier")
554
user_identifier.hashed_phone_number = hashed_phone
555
user_data.user_identifiers.append(user_identifier)
556
557
# Add transaction data
558
transaction_attribute = client.get_type("TransactionAttribute")
559
transaction_attribute.transaction_date_time = sale_data['transaction_date_time']
560
transaction_attribute.transaction_amount_micros = int(sale_data['amount'] * 1_000_000)
561
transaction_attribute.currency_code = sale_data.get('currency_code', 'USD')
562
transaction_attribute.conversion_action = conversion_action_resource_name
563
564
if 'order_id' in sale_data:
565
transaction_attribute.order_id = sale_data['order_id']
566
567
user_data.transaction_attribute = transaction_attribute
568
operations.append(operation)
569
570
# Add operations to job
571
offline_user_data_job_service.add_offline_user_data_job_operations(
572
resource_name=job_resource_name,
573
enable_partial_failure=True,
574
operations=operations
575
)
576
577
# Run the job
578
offline_user_data_job_service.run_offline_user_data_job(
579
resource_name=job_resource_name
580
)
581
582
return job_resource_name
583
```
584
585
## Batch Performance Monitoring
586
587
### Monitor Batch Job Progress
588
589
```python
590
def monitor_batch_job_progress(client, batch_job_resource_name, poll_interval=30):
591
"""Monitor batch job progress and provide status updates."""
592
593
batch_job_service = client.get_service("BatchJobService")
594
595
start_time = time.time()
596
597
while True:
598
try:
599
batch_job = batch_job_service.get_batch_job(
600
resource_name=batch_job_resource_name
601
)
602
603
status = batch_job.status
604
elapsed_time = time.time() - start_time
605
606
progress_info = {
607
'status': status.name,
608
'elapsed_minutes': elapsed_time / 60,
609
'total_operations': batch_job.total_operations,
610
'processed_operations': batch_job.processed_operations,
611
'progress_percentage': 0
612
}
613
614
if batch_job.total_operations > 0:
615
progress_info['progress_percentage'] = (
616
batch_job.processed_operations / batch_job.total_operations * 100
617
)
618
619
print(f"Status: {progress_info['status']} | "
620
f"Progress: {progress_info['progress_percentage']:.1f}% | "
621
f"Elapsed: {progress_info['elapsed_minutes']:.1f} min")
622
623
if status == client.enums.BatchJobStatusEnum.DONE:
624
print("β Batch job completed successfully!")
625
return True
626
elif status == client.enums.BatchJobStatusEnum.FAILED:
627
print("β Batch job failed!")
628
return False
629
630
time.sleep(poll_interval)
631
632
except GoogleAdsException as ex:
633
print(f"Error monitoring batch job: {ex.error.code().name}")
634
return False
635
```
636
637
### Analyze Batch Job Results
638
639
```python
640
def analyze_batch_job_results(client, batch_job_resource_name):
641
"""Analyze results from a completed batch job."""
642
643
batch_job_service = client.get_service("BatchJobService")
644
645
# Get all results
646
results_response = batch_job_service.list_batch_job_results(
647
resource_name=batch_job_resource_name
648
)
649
650
# Analyze results
651
total_operations = 0
652
successful_operations = 0
653
failed_operations = 0
654
error_summary = {}
655
656
for result in results_response.results:
657
total_operations += 1
658
659
if result.status and result.status.code != 0:
660
failed_operations += 1
661
error_code = result.status.code
662
error_message = result.status.message
663
664
if error_code not in error_summary:
665
error_summary[error_code] = {
666
'count': 0,
667
'message': error_message
668
}
669
error_summary[error_code]['count'] += 1
670
else:
671
successful_operations += 1
672
673
# Print summary
674
print(f"\nπ Batch Job Results Summary:")
675
print(f"Total Operations: {total_operations}")
676
print(f"Successful: {successful_operations} ({successful_operations/total_operations*100:.1f}%)")
677
print(f"Failed: {failed_operations} ({failed_operations/total_operations*100:.1f}%)")
678
679
if error_summary:
680
print(f"\nβ Error Breakdown:")
681
for error_code, error_info in error_summary.items():
682
print(f" Code {error_code}: {error_info['count']} occurrences")
683
print(f" Message: {error_info['message']}")
684
685
return {
686
'total': total_operations,
687
'successful': successful_operations,
688
'failed': failed_operations,
689
'errors': error_summary
690
}
691
```
692
693
## Types
694
695
```python { .api }
696
# Batch job types
697
class BatchJob:
698
resource_name: str
699
id: Optional[int]
700
next_add_sequence_token: str
701
status: BatchJobStatusEnum.BatchJobStatus
702
long_running_operation: str
703
creation_date_time: str
704
start_date_time: str
705
completion_date_time: str
706
total_operations: int
707
processed_operations: int
708
709
class BatchJobResult:
710
operation_index: Optional[int]
711
mutate_operation_response: MutateOperationResponse
712
status: Status
713
714
class MutateOperation:
715
ad_group_ad_label_operation: AdGroupAdLabelOperation
716
ad_group_ad_operation: AdGroupAdOperation
717
ad_group_asset_operation: AdGroupAssetOperation
718
ad_group_bid_modifier_operation: AdGroupBidModifierOperation
719
ad_group_criterion_customizer_operation: AdGroupCriterionCustomizerOperation
720
ad_group_criterion_label_operation: AdGroupCriterionLabelOperation
721
ad_group_criterion_operation: AdGroupCriterionOperation
722
ad_group_customizer_operation: AdGroupCustomizerOperation
723
ad_group_extension_setting_operation: AdGroupExtensionSettingOperation
724
ad_group_feed_operation: AdGroupFeedOperation
725
ad_group_label_operation: AdGroupLabelOperation
726
ad_group_operation: AdGroupOperation
727
ad_operation: AdOperation
728
ad_parameter_operation: AdParameterOperation
729
asset_group_asset_operation: AssetGroupAssetOperation
730
asset_group_listing_group_filter_operation: AssetGroupListingGroupFilterOperation
731
asset_group_operation: AssetGroupOperation
732
asset_group_signal_operation: AssetGroupSignalOperation
733
asset_operation: AssetOperation
734
asset_set_asset_operation: AssetSetAssetOperation
735
asset_set_operation: AssetSetOperation
736
audience_operation: AudienceOperation
737
bidding_data_exclusion_operation: BiddingDataExclusionOperation
738
bidding_seasonality_adjustment_operation: BiddingSeasonalityAdjustmentOperation
739
bidding_strategy_operation: BiddingStrategyOperation
740
campaign_asset_operation: CampaignAssetOperation
741
campaign_asset_set_operation: CampaignAssetSetOperation
742
campaign_bid_modifier_operation: CampaignBidModifierOperation
743
campaign_budget_operation: CampaignBudgetOperation
744
campaign_conversion_goal_operation: CampaignConversionGoalOperation
745
campaign_criterion_operation: CampaignCriterionOperation
746
campaign_customizer_operation: CampaignCustomizerOperation
747
campaign_draft_operation: CampaignDraftOperation
748
campaign_extension_setting_operation: CampaignExtensionSettingOperation
749
campaign_feed_operation: CampaignFeedOperation
750
campaign_group_operation: CampaignGroupOperation
751
campaign_label_operation: CampaignLabelOperation
752
campaign_operation: CampaignOperation
753
campaign_shared_set_operation: CampaignSharedSetOperation
754
conversion_action_operation: ConversionActionOperation
755
conversion_custom_variable_operation: ConversionCustomVariableOperation
756
conversion_goal_campaign_config_operation: ConversionGoalCampaignConfigOperation
757
conversion_value_rule_operation: ConversionValueRuleOperation
758
conversion_value_rule_set_operation: ConversionValueRuleSetOperation
759
custom_audience_operation: CustomAudienceOperation
760
custom_conversion_goal_operation: CustomConversionGoalOperation
761
custom_interest_operation: CustomInterestOperation
762
customer_asset_operation: CustomerAssetOperation
763
customer_conversion_goal_operation: CustomerConversionGoalOperation
764
customer_customizer_operation: CustomerCustomizerOperation
765
customer_extension_setting_operation: CustomerExtensionSettingOperation
766
customer_feed_operation: CustomerFeedOperation
767
customer_label_operation: CustomerLabelOperation
768
customer_negative_criterion_operation: CustomerNegativeCriterionOperation
769
customizer_attribute_operation: CustomizerAttributeOperation
770
extension_feed_item_operation: ExtensionFeedItemOperation
771
feed_item_operation: FeedItemOperation
772
feed_item_set_link_operation: FeedItemSetLinkOperation
773
feed_item_set_operation: FeedItemSetOperation
774
feed_item_target_operation: FeedItemTargetOperation
775
feed_mapping_operation: FeedMappingOperation
776
feed_operation: FeedOperation
777
keyword_plan_ad_group_keyword_operation: KeywordPlanAdGroupKeywordOperation
778
keyword_plan_ad_group_operation: KeywordPlanAdGroupOperation
779
keyword_plan_campaign_keyword_operation: KeywordPlanCampaignKeywordOperation
780
keyword_plan_campaign_operation: KeywordPlanCampaignOperation
781
keyword_plan_operation: KeywordPlanOperation
782
label_operation: LabelOperation
783
media_file_operation: MediaFileOperation
784
remarketing_action_operation: RemarketingActionOperation
785
shared_criterion_operation: SharedCriterionOperation
786
shared_set_operation: SharedSetOperation
787
user_list_operation: UserListOperation
788
789
# Offline user data job types
790
class OfflineUserDataJob:
791
resource_name: str
792
id: Optional[int]
793
external_id: Optional[int]
794
type_: OfflineUserDataJobTypeEnum.OfflineUserDataJobType
795
status: OfflineUserDataJobStatusEnum.OfflineUserDataJobStatus
796
failure_reason: OfflineUserDataJobFailureReasonEnum.OfflineUserDataJobFailureReason
797
operation_filter: OfflineUserDataJobMatchRateRange
798
customer_match_user_list_metadata: CustomerMatchUserListMetadata
799
store_sales_metadata: StoreSalesMetadata
800
801
class CustomerMatchUserListMetadata:
802
user_list: Optional[str]
803
consent: Consent
804
user_list_size_for_search: Optional[int]
805
user_list_size_for_display: Optional[int]
806
807
class StoreSalesMetadata:
808
loyalty_fraction: Optional[float]
809
transaction_upload_fraction: Optional[float]
810
custom_key: Optional[str]
811
third_party_metadata: StoreSalesThirdPartyMetadata
812
813
class OfflineUserDataJobOperation:
814
create: UserData
815
remove: UserData
816
remove_all: bool
817
818
class UserData:
819
user_identifiers: List[UserIdentifier]
820
transaction_attribute: TransactionAttribute
821
user_attribute: UserAttribute
822
823
class TransactionAttribute:
824
transaction_date_time: Optional[str]
825
transaction_amount_micros: Optional[int]
826
currency_code: Optional[str]
827
conversion_action: Optional[str]
828
order_id: Optional[str]
829
store_attribute: StoreAttribute
830
custom_value: Optional[str]
831
item_attribute: ItemAttribute
832
833
class UserIdentifier:
834
user_identifier_source: UserIdentifierSourceEnum.UserIdentifierSource
835
hashed_email: Optional[str]
836
hashed_phone_number: Optional[str]
837
mobile_id: Optional[str]
838
third_party_user_id: Optional[str]
839
address_info: OfflineUserAddressInfo
840
841
# Operation types
842
class BatchJobOperation:
843
update_mask: FieldMask
844
create: BatchJob
845
update: BatchJob
846
remove: str
847
848
# Request types
849
class AddBatchJobOperationsRequest:
850
resource_name: str
851
sequence_token: str
852
mutate_operations: List[MutateOperation]
853
854
class RunBatchJobRequest:
855
resource_name: str
856
857
class ListBatchJobResultsRequest:
858
resource_name: str
859
page_token: str
860
page_size: int
861
response_content_type: ResponseContentTypeEnum.ResponseContentType
862
863
class AddOfflineUserDataJobOperationsRequest:
864
resource_name: str
865
enable_partial_failure: bool
866
enable_warnings: bool
867
operations: List[OfflineUserDataJobOperation]
868
869
class RunOfflineUserDataJobRequest:
870
resource_name: str
871
validate_only: bool
872
873
# Response types
874
class MutateBatchJobResponse:
875
result: MutateBatchJobResult
876
877
class MutateBatchJobResult:
878
resource_name: str
879
batch_job: BatchJob
880
881
class AddBatchJobOperationsResponse:
882
total_operations: int
883
next_sequence_token: str
884
885
class ListBatchJobResultsResponse:
886
results: List[BatchJobResult]
887
next_page_token: str
888
889
class CreateOfflineUserDataJobResponse:
890
resource_name: str
891
892
class AddOfflineUserDataJobOperationsResponse:
893
partial_failure_error: Status
894
warning: Status
895
```