|
3 | 3 | {% if "ListOperations" in api.mixin_api_methods %} |
4 | 4 | def list_operations( |
5 | 5 | self, |
6 | | - request: Optional[operations_pb2.ListOperationsRequest] = None, |
| 6 | + request: Optional[Union[operations_pb2.ListOperationsRequest, dict]] = None, |
7 | 7 | *, |
8 | 8 | retry: OptionalRetry = gapic_v1.method.DEFAULT, |
9 | 9 | timeout: Union[float, object] = gapic_v1.method.DEFAULT, |
|
27 | 27 | # Create or coerce a protobuf request object. |
28 | 28 | # The request isn't a proto-plus wrapped type, |
29 | 29 | # so it must be constructed via keyword expansion. |
30 | | - if isinstance(request, dict): |
31 | | - request = operations_pb2.ListOperationsRequest(**request) |
| 30 | + if request is None: |
| 31 | + request_pb = operations_pb2.ListOperationsRequest() |
| 32 | + elif isinstance(request, dict): |
| 33 | + request_pb = operations_pb2.ListOperationsRequest(**request) |
| 34 | + else: |
| 35 | + request_pb = request |
32 | 36 |
|
33 | 37 | # Wrap the RPC method; this adds retry and timeout information, |
34 | 38 | # and friendly error handling. |
|
38 | 42 | # add these here. |
39 | 43 | metadata = tuple(metadata) + ( |
40 | 44 | gapic_v1.routing_header.to_grpc_metadata( |
41 | | - (("name", request.name),)), |
| 45 | + (("name", request_pb.name),)), |
42 | 46 | ) |
43 | 47 |
|
44 | 48 | # Send the request. |
45 | 49 | response = rpc( |
46 | | - request, retry=retry, timeout=timeout, metadata=metadata,) |
| 50 | + request_pb, retry=retry, timeout=timeout, metadata=metadata,) |
47 | 51 |
|
48 | 52 | # Done; return the response. |
49 | 53 | return response |
|
53 | 57 | {% if "GetOperation" in api.mixin_api_methods %} |
54 | 58 | def get_operation( |
55 | 59 | self, |
56 | | - request: Optional[operations_pb2.GetOperationRequest] = None, |
| 60 | + request: Optional[Union[operations_pb2.GetOperationRequest, dict]] = None, |
57 | 61 | *, |
58 | 62 | retry: OptionalRetry = gapic_v1.method.DEFAULT, |
59 | 63 | timeout: Union[float, object] = gapic_v1.method.DEFAULT, |
|
77 | 81 | # Create or coerce a protobuf request object. |
78 | 82 | # The request isn't a proto-plus wrapped type, |
79 | 83 | # so it must be constructed via keyword expansion. |
80 | | - if isinstance(request, dict): |
81 | | - request = operations_pb2.GetOperationRequest(**request) |
| 84 | + if request is None: |
| 85 | + request_pb = operations_pb2.GetOperationRequest() |
| 86 | + elif isinstance(request, dict): |
| 87 | + request_pb = operations_pb2.GetOperationRequest(**request) |
| 88 | + else: |
| 89 | + request_pb = request |
82 | 90 |
|
83 | 91 | # Wrap the RPC method; this adds retry and timeout information, |
84 | 92 | # and friendly error handling. |
|
88 | 96 | # add these here. |
89 | 97 | metadata = tuple(metadata) + ( |
90 | 98 | gapic_v1.routing_header.to_grpc_metadata( |
91 | | - (("name", request.name),)), |
| 99 | + (("name", request_pb.name),)), |
92 | 100 | ) |
93 | 101 |
|
94 | 102 | # Send the request. |
95 | 103 | response = rpc( |
96 | | - request, retry=retry, timeout=timeout, metadata=metadata,) |
| 104 | + request_pb, retry=retry, timeout=timeout, metadata=metadata,) |
97 | 105 |
|
98 | 106 | # Done; return the response. |
99 | 107 | return response |
|
102 | 110 | {% if "DeleteOperation" in api.mixin_api_methods %} |
103 | 111 | def delete_operation( |
104 | 112 | self, |
105 | | - request: Optional[operations_pb2.DeleteOperationRequest] = None, |
| 113 | + request: Optional[Union[operations_pb2.DeleteOperationRequest, dict]] = None, |
106 | 114 | *, |
107 | 115 | retry: OptionalRetry = gapic_v1.method.DEFAULT, |
108 | 116 | timeout: Union[float, object] = gapic_v1.method.DEFAULT, |
|
130 | 138 | # Create or coerce a protobuf request object. |
131 | 139 | # The request isn't a proto-plus wrapped type, |
132 | 140 | # so it must be constructed via keyword expansion. |
133 | | - if isinstance(request, dict): |
134 | | - request = operations_pb2.DeleteOperationRequest(**request) |
| 141 | + if request is None: |
| 142 | + request_pb = operations_pb2.DeleteOperationRequest() |
| 143 | + elif isinstance(request, dict): |
| 144 | + request_pb = operations_pb2.DeleteOperationRequest(**request) |
| 145 | + else: |
| 146 | + request_pb = request |
135 | 147 |
|
136 | 148 | # Wrap the RPC method; this adds retry and timeout information, |
137 | 149 | # and friendly error handling. |
|
141 | 153 | # add these here. |
142 | 154 | metadata = tuple(metadata) + ( |
143 | 155 | gapic_v1.routing_header.to_grpc_metadata( |
144 | | - (("name", request.name),)), |
| 156 | + (("name", request_pb.name),)), |
145 | 157 | ) |
146 | 158 |
|
147 | 159 | # Send the request. |
148 | | - rpc(request, retry=retry, timeout=timeout, metadata=metadata,) |
| 160 | + rpc(request_pb, retry=retry, timeout=timeout, metadata=metadata,) |
149 | 161 | {% endif %} |
150 | 162 |
|
151 | 163 | {% if "CancelOperation" in api.mixin_api_methods %} |
152 | 164 | def cancel_operation( |
153 | 165 | self, |
154 | | - request: Optional[operations_pb2.CancelOperationRequest] = None, |
| 166 | + request: Optional[Union[operations_pb2.CancelOperationRequest, dict]] = None, |
155 | 167 | *, |
156 | 168 | retry: OptionalRetry = gapic_v1.method.DEFAULT, |
157 | 169 | timeout: Union[float, object] = gapic_v1.method.DEFAULT, |
|
178 | 190 | # Create or coerce a protobuf request object. |
179 | 191 | # The request isn't a proto-plus wrapped type, |
180 | 192 | # so it must be constructed via keyword expansion. |
181 | | - if isinstance(request, dict): |
182 | | - request = operations_pb2.CancelOperationRequest(**request) |
| 193 | + if request is None: |
| 194 | + request_pb = operations_pb2.CancelOperationRequest() |
| 195 | + elif isinstance(request, dict): |
| 196 | + request_pb = operations_pb2.CancelOperationRequest(**request) |
| 197 | + else: |
| 198 | + request_pb = request |
183 | 199 |
|
184 | 200 | # Wrap the RPC method; this adds retry and timeout information, |
185 | 201 | # and friendly error handling. |
|
189 | 205 | # add these here. |
190 | 206 | metadata = tuple(metadata) + ( |
191 | 207 | gapic_v1.routing_header.to_grpc_metadata( |
192 | | - (("name", request.name),)), |
| 208 | + (("name", request_pb.name),)), |
193 | 209 | ) |
194 | 210 |
|
195 | 211 | # Send the request. |
196 | | - rpc(request, retry=retry, timeout=timeout, metadata=metadata,) |
| 212 | + rpc(request_pb, retry=retry, timeout=timeout, metadata=metadata,) |
197 | 213 | {% endif %} |
198 | 214 |
|
199 | 215 | {% if "WaitOperation" in api.mixin_api_methods %} |
200 | 216 | def wait_operation( |
201 | 217 | self, |
202 | | - request: Optional[operations_pb2.WaitOperationRequest] = None, |
| 218 | + request: Optional[Union[operations_pb2.WaitOperationRequest, dict]] = None, |
203 | 219 | *, |
204 | 220 | retry: OptionalRetry = gapic_v1.method.DEFAULT, |
205 | 221 | timeout: Union[float, object] = gapic_v1.method.DEFAULT, |
|
229 | 245 | # Create or coerce a protobuf request object. |
230 | 246 | # The request isn't a proto-plus wrapped type, |
231 | 247 | # so it must be constructed via keyword expansion. |
232 | | - if isinstance(request, dict): |
233 | | - request = operations_pb2.WaitOperationRequest(**request) |
| 248 | + if request is None: |
| 249 | + request_pb = operations_pb2.WaitOperationRequest() |
| 250 | + elif isinstance(request, dict): |
| 251 | + request_pb = operations_pb2.WaitOperationRequest(**request) |
| 252 | + else: |
| 253 | + request_pb = request |
234 | 254 |
|
235 | 255 | # Wrap the RPC method; this adds retry and timeout information, |
236 | 256 | # and friendly error handling. |
|
240 | 260 |
|
241 | 261 | # Send the request. |
242 | 262 | response = rpc( |
243 | | - request, retry=retry, timeout=timeout, metadata=metadata,) |
| 263 | + request_pb, retry=retry, timeout=timeout, metadata=metadata,) |
244 | 264 |
|
245 | 265 | # Done; return the response. |
246 | 266 | return response |
|
254 | 274 | {% if "SetIamPolicy" in api.mixin_api_methods %} |
255 | 275 | def set_iam_policy( |
256 | 276 | self, |
257 | | - request: Optional[iam_policy_pb2.SetIamPolicyRequest] = None, |
| 277 | + request: Optional[Union[iam_policy_pb2.SetIamPolicyRequest, dict]] = None, |
258 | 278 | *, |
259 | 279 | retry: OptionalRetry = gapic_v1.method.DEFAULT, |
260 | 280 | timeout: Union[float, object] = gapic_v1.method.DEFAULT, |
|
344 | 364 |
|
345 | 365 | # The request isn't a proto-plus wrapped type, |
346 | 366 | # so it must be constructed via keyword expansion. |
347 | | - if isinstance(request, dict): |
348 | | - request = iam_policy_pb2.SetIamPolicyRequest(**request) |
| 367 | + if request is None: |
| 368 | + request_pb = iam_policy_pb2.SetIamPolicyRequest() |
| 369 | + elif isinstance(request, dict): |
| 370 | + request_pb = iam_policy_pb2.SetIamPolicyRequest(**request) |
| 371 | + else: |
| 372 | + request_pb = request |
349 | 373 |
|
350 | 374 | # Wrap the RPC method; this adds retry and timeout information, |
351 | 375 | # and friendly error handling. |
|
355 | 379 | # add these here. |
356 | 380 | metadata = tuple(metadata) + ( |
357 | 381 | gapic_v1.routing_header.to_grpc_metadata( |
358 | | - (("resource", request.resource),)), |
| 382 | + (("resource", request_pb.resource),)), |
359 | 383 | ) |
360 | 384 |
|
361 | 385 | # Send the request. |
362 | 386 | response = rpc( |
363 | | - request, retry=retry, timeout=timeout, metadata=metadata,) |
| 387 | + request_pb, retry=retry, timeout=timeout, metadata=metadata,) |
364 | 388 |
|
365 | 389 | # Done; return the response. |
366 | 390 | return response |
|
369 | 393 | {% if "GetIamPolicy" in api.mixin_api_methods %} |
370 | 394 | def get_iam_policy( |
371 | 395 | self, |
372 | | - request: Optional[iam_policy_pb2.GetIamPolicyRequest] = None, |
| 396 | + request: Optional[Union[iam_policy_pb2.GetIamPolicyRequest, dict]] = None, |
373 | 397 | *, |
374 | 398 | retry: OptionalRetry = gapic_v1.method.DEFAULT, |
375 | 399 | timeout: Union[float, object] = gapic_v1.method.DEFAULT, |
|
460 | 484 |
|
461 | 485 | # The request isn't a proto-plus wrapped type, |
462 | 486 | # so it must be constructed via keyword expansion. |
463 | | - if isinstance(request, dict): |
464 | | - request = iam_policy_pb2.GetIamPolicyRequest(**request) |
| 487 | + if request is None: |
| 488 | + request_pb = iam_policy_pb2.GetIamPolicyRequest() |
| 489 | + elif isinstance(request, dict): |
| 490 | + request_pb = iam_policy_pb2.GetIamPolicyRequest(**request) |
| 491 | + else: |
| 492 | + request_pb = request |
465 | 493 |
|
466 | 494 | # Wrap the RPC method; this adds retry and timeout information, |
467 | 495 | # and friendly error handling. |
|
471 | 499 | # add these here. |
472 | 500 | metadata = tuple(metadata) + ( |
473 | 501 | gapic_v1.routing_header.to_grpc_metadata( |
474 | | - (("resource", request.resource),)), |
| 502 | + (("resource", request_pb.resource),)), |
475 | 503 | ) |
476 | 504 |
|
477 | 505 | # Send the request. |
478 | 506 | response = rpc( |
479 | | - request, retry=retry, timeout=timeout, metadata=metadata,) |
| 507 | + request_pb, retry=retry, timeout=timeout, metadata=metadata,) |
480 | 508 |
|
481 | 509 | # Done; return the response. |
482 | 510 | return response |
|
485 | 513 | {% if "TestIamPermissions" in api.mixin_api_methods %} |
486 | 514 | def test_iam_permissions( |
487 | 515 | self, |
488 | | - request: Optional[iam_policy_pb2.TestIamPermissionsRequest] = None, |
| 516 | + request: Optional[Union[iam_policy_pb2.TestIamPermissionsRequest, dict]] = None, |
489 | 517 | *, |
490 | 518 | retry: OptionalRetry = gapic_v1.method.DEFAULT, |
491 | 519 | timeout: Union[float, object] = gapic_v1.method.DEFAULT, |
|
514 | 542 |
|
515 | 543 | # The request isn't a proto-plus wrapped type, |
516 | 544 | # so it must be constructed via keyword expansion. |
517 | | - if isinstance(request, dict): |
518 | | - request = iam_policy_pb2.TestIamPermissionsRequest(**request) |
| 545 | + if request is None: |
| 546 | + request_pb = iam_policy_pb2.TestIamPermissionsRequest() |
| 547 | + elif isinstance(request, dict): |
| 548 | + request_pb = iam_policy_pb2.TestIamPermissionsRequest(**request) |
| 549 | + else: |
| 550 | + request_pb = request |
519 | 551 |
|
520 | 552 | # Wrap the RPC method; this adds retry and timeout information, |
521 | 553 | # and friendly error handling. |
|
525 | 557 | # add these here. |
526 | 558 | metadata = tuple(metadata) + ( |
527 | 559 | gapic_v1.routing_header.to_grpc_metadata( |
528 | | - (("resource", request.resource),)), |
| 560 | + (("resource", request_pb.resource),)), |
529 | 561 | ) |
530 | 562 |
|
531 | 563 | # Send the request. |
532 | 564 | response = rpc( |
533 | | - request, retry=retry, timeout=timeout, metadata=metadata,) |
| 565 | + request_pb, retry=retry, timeout=timeout, metadata=metadata,) |
534 | 566 |
|
535 | 567 | # Done; return the response. |
536 | 568 | return response |
|
543 | 575 | {% if "GetLocation" in api.mixin_api_methods %} |
544 | 576 | def get_location( |
545 | 577 | self, |
546 | | - request: Optional[locations_pb2.GetLocationRequest] = None, |
| 578 | + request: Optional[Union[locations_pb2.GetLocationRequest, dict]] = None, |
547 | 579 | *, |
548 | 580 | retry: OptionalRetry = gapic_v1.method.DEFAULT, |
549 | 581 | timeout: Union[float, object] = gapic_v1.method.DEFAULT, |
|
567 | 599 | # Create or coerce a protobuf request object. |
568 | 600 | # The request isn't a proto-plus wrapped type, |
569 | 601 | # so it must be constructed via keyword expansion. |
570 | | - if isinstance(request, dict): |
571 | | - request = locations_pb2.GetLocationRequest(**request) |
| 602 | + if request is None: |
| 603 | + request_pb = locations_pb2.GetLocationRequest() |
| 604 | + elif isinstance(request, dict): |
| 605 | + request_pb = locations_pb2.GetLocationRequest(**request) |
| 606 | + else: |
| 607 | + request_pb = request |
572 | 608 |
|
573 | 609 | # Wrap the RPC method; this adds retry and timeout information, |
574 | 610 | # and friendly error handling. |
|
578 | 614 | # add these here. |
579 | 615 | metadata = tuple(metadata) + ( |
580 | 616 | gapic_v1.routing_header.to_grpc_metadata( |
581 | | - (("name", request.name),)), |
| 617 | + (("name", request_pb.name),)), |
582 | 618 | ) |
583 | 619 |
|
584 | 620 | # Send the request. |
585 | 621 | response = rpc( |
586 | | - request, retry=retry, timeout=timeout, metadata=metadata,) |
| 622 | + request_pb, retry=retry, timeout=timeout, metadata=metadata,) |
587 | 623 |
|
588 | 624 | # Done; return the response. |
589 | 625 | return response |
|
592 | 628 | {% if "ListLocations" in api.mixin_api_methods %} |
593 | 629 | def list_locations( |
594 | 630 | self, |
595 | | - request: Optional[locations_pb2.ListLocationsRequest] = None, |
| 631 | + request: Optional[Union[locations_pb2.ListLocationsRequest, dict]] = None, |
596 | 632 | *, |
597 | 633 | retry: OptionalRetry = gapic_v1.method.DEFAULT, |
598 | 634 | timeout: Union[float, object] = gapic_v1.method.DEFAULT, |
|
616 | 652 | # Create or coerce a protobuf request object. |
617 | 653 | # The request isn't a proto-plus wrapped type, |
618 | 654 | # so it must be constructed via keyword expansion. |
619 | | - if isinstance(request, dict): |
620 | | - request = locations_pb2.ListLocationsRequest(**request) |
| 655 | + if request is None: |
| 656 | + request_pb = locations_pb2.ListLocationsRequest() |
| 657 | + elif isinstance(request, dict): |
| 658 | + request_pb = locations_pb2.ListLocationsRequest(**request) |
| 659 | + else: |
| 660 | + request_pb = request |
621 | 661 |
|
622 | 662 | # Wrap the RPC method; this adds retry and timeout information, |
623 | 663 | # and friendly error handling. |
|
627 | 667 | # add these here. |
628 | 668 | metadata = tuple(metadata) + ( |
629 | 669 | gapic_v1.routing_header.to_grpc_metadata( |
630 | | - (("name", request.name),)), |
| 670 | + (("name", request_pb.name),)), |
631 | 671 | ) |
632 | 672 |
|
633 | 673 | # Send the request. |
634 | 674 | response = rpc( |
635 | | - request, retry=retry, timeout=timeout, metadata=metadata,) |
| 675 | + request_pb, retry=retry, timeout=timeout, metadata=metadata,) |
636 | 676 |
|
637 | 677 | # Done; return the response. |
638 | 678 | return response |
|
0 commit comments