|
28 | 28 | # The request isn't a proto-plus wrapped type, |
29 | 29 | # so it must be constructed via keyword expansion. |
30 | 30 | if request is None: |
31 | | - request = {} |
32 | | - if isinstance(request, dict): |
33 | | - request = operations_pb2.ListOperationsRequest(**request) |
| 31 | + request_pb = operations_pb2.ListOperationsRequest() |
| 32 | + elif isinstance(request, dict): |
| 33 | + request_pb = operations_pb2.ListOperationsRequest(**request) |
| 34 | + else: |
| 35 | + request_pb = request |
34 | 36 |
|
35 | 37 | # Wrap the RPC method; this adds retry and timeout information, |
36 | 38 | # and friendly error handling. |
|
40 | 42 | # add these here. |
41 | 43 | metadata = tuple(metadata) + ( |
42 | 44 | gapic_v1.routing_header.to_grpc_metadata( |
43 | | - (("name", request.name),)), |
| 45 | + (("name", request_pb.name),)), |
44 | 46 | ) |
45 | 47 |
|
46 | 48 | # Send the request. |
47 | 49 | response = rpc( |
48 | | - request, retry=retry, timeout=timeout, metadata=metadata,) |
| 50 | + request_pb, retry=retry, timeout=timeout, metadata=metadata,) |
49 | 51 |
|
50 | 52 | # Done; return the response. |
51 | 53 | return response |
|
80 | 82 | # The request isn't a proto-plus wrapped type, |
81 | 83 | # so it must be constructed via keyword expansion. |
82 | 84 | if request is None: |
83 | | - request = {} |
84 | | - if isinstance(request, dict): |
85 | | - request = operations_pb2.GetOperationRequest(**request) |
| 85 | + request_pb = operations_pb2.GetOperationRequest() |
| 86 | + elif isinstance(request, dict): |
| 87 | + request_pb = operations_pb2.GetOperationRequest(**request) |
| 88 | + else: |
| 89 | + request_pb = request |
86 | 90 |
|
87 | 91 | # Wrap the RPC method; this adds retry and timeout information, |
88 | 92 | # and friendly error handling. |
|
92 | 96 | # add these here. |
93 | 97 | metadata = tuple(metadata) + ( |
94 | 98 | gapic_v1.routing_header.to_grpc_metadata( |
95 | | - (("name", request.name),)), |
| 99 | + (("name", request_pb.name),)), |
96 | 100 | ) |
97 | 101 |
|
98 | 102 | # Send the request. |
99 | 103 | response = rpc( |
100 | | - request, retry=retry, timeout=timeout, metadata=metadata,) |
| 104 | + request_pb, retry=retry, timeout=timeout, metadata=metadata,) |
101 | 105 |
|
102 | 106 | # Done; return the response. |
103 | 107 | return response |
|
135 | 139 | # The request isn't a proto-plus wrapped type, |
136 | 140 | # so it must be constructed via keyword expansion. |
137 | 141 | if request is None: |
138 | | - request = {} |
139 | | - if isinstance(request, dict): |
140 | | - request = operations_pb2.DeleteOperationRequest(**request) |
| 142 | + request_pb = operations_pb2.DeleteOperationRequest() |
| 143 | + elif isinstance(request, dict): |
| 144 | + request_pb = operations_pb2.DeleteOperationRequest(**request) |
| 145 | + else: |
| 146 | + request_pb = request |
141 | 147 |
|
142 | 148 | # Wrap the RPC method; this adds retry and timeout information, |
143 | 149 | # and friendly error handling. |
|
147 | 153 | # add these here. |
148 | 154 | metadata = tuple(metadata) + ( |
149 | 155 | gapic_v1.routing_header.to_grpc_metadata( |
150 | | - (("name", request.name),)), |
| 156 | + (("name", request_pb.name),)), |
151 | 157 | ) |
152 | 158 |
|
153 | 159 | # Send the request. |
154 | | - rpc(request, retry=retry, timeout=timeout, metadata=metadata,) |
| 160 | + rpc(request_pb, retry=retry, timeout=timeout, metadata=metadata,) |
155 | 161 | {% endif %} |
156 | 162 |
|
157 | 163 | {% if "CancelOperation" in api.mixin_api_methods %} |
|
185 | 191 | # The request isn't a proto-plus wrapped type, |
186 | 192 | # so it must be constructed via keyword expansion. |
187 | 193 | if request is None: |
188 | | - request = {} |
189 | | - if isinstance(request, dict): |
190 | | - request = operations_pb2.CancelOperationRequest(**request) |
| 194 | + request_pb = operations_pb2.CancelOperationRequest() |
| 195 | + elif isinstance(request, dict): |
| 196 | + request_pb = operations_pb2.CancelOperationRequest(**request) |
| 197 | + else: |
| 198 | + request_pb = request |
191 | 199 |
|
192 | 200 | # Wrap the RPC method; this adds retry and timeout information, |
193 | 201 | # and friendly error handling. |
|
197 | 205 | # add these here. |
198 | 206 | metadata = tuple(metadata) + ( |
199 | 207 | gapic_v1.routing_header.to_grpc_metadata( |
200 | | - (("name", request.name),)), |
| 208 | + (("name", request_pb.name),)), |
201 | 209 | ) |
202 | 210 |
|
203 | 211 | # Send the request. |
204 | | - rpc(request, retry=retry, timeout=timeout, metadata=metadata,) |
| 212 | + rpc(request_pb, retry=retry, timeout=timeout, metadata=metadata,) |
205 | 213 | {% endif %} |
206 | 214 |
|
207 | 215 | {% if "WaitOperation" in api.mixin_api_methods %} |
|
238 | 246 | # The request isn't a proto-plus wrapped type, |
239 | 247 | # so it must be constructed via keyword expansion. |
240 | 248 | if request is None: |
241 | | - request = {} |
242 | | - if isinstance(request, dict): |
243 | | - request = operations_pb2.WaitOperationRequest(**request) |
| 249 | + request_pb = operations_pb2.WaitOperationRequest() |
| 250 | + elif isinstance(request, dict): |
| 251 | + request_pb = operations_pb2.WaitOperationRequest(**request) |
| 252 | + else: |
| 253 | + request_pb = request |
244 | 254 |
|
245 | 255 | # Wrap the RPC method; this adds retry and timeout information, |
246 | 256 | # and friendly error handling. |
|
250 | 260 |
|
251 | 261 | # Send the request. |
252 | 262 | response = rpc( |
253 | | - request, retry=retry, timeout=timeout, metadata=metadata,) |
| 263 | + request_pb, retry=retry, timeout=timeout, metadata=metadata,) |
254 | 264 |
|
255 | 265 | # Done; return the response. |
256 | 266 | return response |
|
355 | 365 | # The request isn't a proto-plus wrapped type, |
356 | 366 | # so it must be constructed via keyword expansion. |
357 | 367 | if request is None: |
358 | | - request = {} |
359 | | - if isinstance(request, dict): |
360 | | - request = iam_policy_pb2.SetIamPolicyRequest(**request) |
| 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 |
361 | 373 |
|
362 | 374 | # Wrap the RPC method; this adds retry and timeout information, |
363 | 375 | # and friendly error handling. |
|
367 | 379 | # add these here. |
368 | 380 | metadata = tuple(metadata) + ( |
369 | 381 | gapic_v1.routing_header.to_grpc_metadata( |
370 | | - (("resource", request.resource),)), |
| 382 | + (("resource", request_pb.resource),)), |
371 | 383 | ) |
372 | 384 |
|
373 | 385 | # Send the request. |
374 | 386 | response = rpc( |
375 | | - request, retry=retry, timeout=timeout, metadata=metadata,) |
| 387 | + request_pb, retry=retry, timeout=timeout, metadata=metadata,) |
376 | 388 |
|
377 | 389 | # Done; return the response. |
378 | 390 | return response |
|
473 | 485 | # The request isn't a proto-plus wrapped type, |
474 | 486 | # so it must be constructed via keyword expansion. |
475 | 487 | if request is None: |
476 | | - request = {} |
477 | | - if isinstance(request, dict): |
478 | | - request = iam_policy_pb2.GetIamPolicyRequest(**request) |
| 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 |
479 | 493 |
|
480 | 494 | # Wrap the RPC method; this adds retry and timeout information, |
481 | 495 | # and friendly error handling. |
|
485 | 499 | # add these here. |
486 | 500 | metadata = tuple(metadata) + ( |
487 | 501 | gapic_v1.routing_header.to_grpc_metadata( |
488 | | - (("resource", request.resource),)), |
| 502 | + (("resource", request_pb.resource),)), |
489 | 503 | ) |
490 | 504 |
|
491 | 505 | # Send the request. |
492 | 506 | response = rpc( |
493 | | - request, retry=retry, timeout=timeout, metadata=metadata,) |
| 507 | + request_pb, retry=retry, timeout=timeout, metadata=metadata,) |
494 | 508 |
|
495 | 509 | # Done; return the response. |
496 | 510 | return response |
|
529 | 543 | # The request isn't a proto-plus wrapped type, |
530 | 544 | # so it must be constructed via keyword expansion. |
531 | 545 | if request is None: |
532 | | - request = {} |
533 | | - if isinstance(request, dict): |
534 | | - request = iam_policy_pb2.TestIamPermissionsRequest(**request) |
| 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 |
535 | 551 |
|
536 | 552 | # Wrap the RPC method; this adds retry and timeout information, |
537 | 553 | # and friendly error handling. |
|
541 | 557 | # add these here. |
542 | 558 | metadata = tuple(metadata) + ( |
543 | 559 | gapic_v1.routing_header.to_grpc_metadata( |
544 | | - (("resource", request.resource),)), |
| 560 | + (("resource", request_pb.resource),)), |
545 | 561 | ) |
546 | 562 |
|
547 | 563 | # Send the request. |
548 | 564 | response = rpc( |
549 | | - request, retry=retry, timeout=timeout, metadata=metadata,) |
| 565 | + request_pb, retry=retry, timeout=timeout, metadata=metadata,) |
550 | 566 |
|
551 | 567 | # Done; return the response. |
552 | 568 | return response |
|
584 | 600 | # The request isn't a proto-plus wrapped type, |
585 | 601 | # so it must be constructed via keyword expansion. |
586 | 602 | if request is None: |
587 | | - request = {} |
588 | | - if isinstance(request, dict): |
589 | | - request = locations_pb2.GetLocationRequest(**request) |
| 603 | + request_pb = locations_pb2.GetLocationRequest() |
| 604 | + elif isinstance(request, dict): |
| 605 | + request_pb = locations_pb2.GetLocationRequest(**request) |
| 606 | + else: |
| 607 | + request_pb = request |
590 | 608 |
|
591 | 609 | # Wrap the RPC method; this adds retry and timeout information, |
592 | 610 | # and friendly error handling. |
|
596 | 614 | # add these here. |
597 | 615 | metadata = tuple(metadata) + ( |
598 | 616 | gapic_v1.routing_header.to_grpc_metadata( |
599 | | - (("name", request.name),)), |
| 617 | + (("name", request_pb.name),)), |
600 | 618 | ) |
601 | 619 |
|
602 | 620 | # Send the request. |
603 | 621 | response = rpc( |
604 | | - request, retry=retry, timeout=timeout, metadata=metadata,) |
| 622 | + request_pb, retry=retry, timeout=timeout, metadata=metadata,) |
605 | 623 |
|
606 | 624 | # Done; return the response. |
607 | 625 | return response |
|
635 | 653 | # The request isn't a proto-plus wrapped type, |
636 | 654 | # so it must be constructed via keyword expansion. |
637 | 655 | if request is None: |
638 | | - request = {} |
639 | | - if isinstance(request, dict): |
640 | | - request = locations_pb2.ListLocationsRequest(**request) |
| 656 | + request_pb = locations_pb2.ListLocationsRequest() |
| 657 | + elif isinstance(request, dict): |
| 658 | + request_pb = locations_pb2.ListLocationsRequest(**request) |
| 659 | + else: |
| 660 | + request_pb = request |
641 | 661 |
|
642 | 662 | # Wrap the RPC method; this adds retry and timeout information, |
643 | 663 | # and friendly error handling. |
|
647 | 667 | # add these here. |
648 | 668 | metadata = tuple(metadata) + ( |
649 | 669 | gapic_v1.routing_header.to_grpc_metadata( |
650 | | - (("name", request.name),)), |
| 670 | + (("name", request_pb.name),)), |
651 | 671 | ) |
652 | 672 |
|
653 | 673 | # Send the request. |
654 | 674 | response = rpc( |
655 | | - request, retry=retry, timeout=timeout, metadata=metadata,) |
| 675 | + request_pb, retry=retry, timeout=timeout, metadata=metadata,) |
656 | 676 |
|
657 | 677 | # Done; return the response. |
658 | 678 | return response |
|
0 commit comments