alibabacloud-fc20230330 4.3.0__py3-none-any.whl → 4.4.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (9) hide show
  1. alibabacloud_fc20230330/__init__.py +1 -1
  2. alibabacloud_fc20230330/client.py +554 -1120
  3. alibabacloud_fc20230330/models.py +1552 -230
  4. {alibabacloud_fc20230330-4.3.0.dist-info → alibabacloud_fc20230330-4.4.0.dist-info}/METADATA +3 -3
  5. alibabacloud_fc20230330-4.4.0.dist-info/RECORD +8 -0
  6. alibabacloud_fc20230330-4.3.0.dist-info/RECORD +0 -8
  7. {alibabacloud_fc20230330-4.3.0.dist-info → alibabacloud_fc20230330-4.4.0.dist-info}/LICENSE +0 -0
  8. {alibabacloud_fc20230330-4.3.0.dist-info → alibabacloud_fc20230330-4.4.0.dist-info}/WHEEL +0 -0
  9. {alibabacloud_fc20230330-4.3.0.dist-info → alibabacloud_fc20230330-4.4.0.dist-info}/top_level.txt +0 -0
alibabacloud_fc20230330/client.py CHANGED
@@ -41,6 +41,104 @@ class Client(OpenApiClient):
41
41
  return endpoint_map.get(region_id)
42
42
  return EndpointUtilClient.get_endpoint_rules(product_id, region_id, endpoint_rule, network, suffix)
43
43
 
44
+ def change_resource_group_with_options(
45
+ self,
46
+ request: fc20230330_models.ChangeResourceGroupRequest,
47
+ headers: Dict[str, str],
48
+ runtime: util_models.RuntimeOptions,
49
+ ) -> fc20230330_models.ChangeResourceGroupResponse:
50
+ """
51
+ @summary 修改实例所在资源组
52
+
53
+ @param request: ChangeResourceGroupRequest
54
+ @param headers: map
55
+ @param runtime: runtime options for this request RuntimeOptions
56
+ @return: ChangeResourceGroupResponse
57
+ """
58
+ UtilClient.validate_model(request)
59
+ req = open_api_models.OpenApiRequest(
60
+ headers=headers,
61
+ body=OpenApiUtilClient.parse_to_map(request.body)
62
+ )
63
+ params = open_api_models.Params(
64
+ action='ChangeResourceGroup',
65
+ version='2023-03-30',
66
+ protocol='HTTPS',
67
+ pathname=f'/2023-03-30/resource-groups',
68
+ method='PUT',
69
+ auth_type='AK',
70
+ style='ROA',
71
+ req_body_type='json',
72
+ body_type='json'
73
+ )
74
+ return TeaCore.from_map(
75
+ fc20230330_models.ChangeResourceGroupResponse(),
76
+ self.call_api(params, req, runtime)
77
+ )
78
+
79
+ async def change_resource_group_with_options_async(
80
+ self,
81
+ request: fc20230330_models.ChangeResourceGroupRequest,
82
+ headers: Dict[str, str],
83
+ runtime: util_models.RuntimeOptions,
84
+ ) -> fc20230330_models.ChangeResourceGroupResponse:
85
+ """
86
+ @summary 修改实例所在资源组
87
+
88
+ @param request: ChangeResourceGroupRequest
89
+ @param headers: map
90
+ @param runtime: runtime options for this request RuntimeOptions
91
+ @return: ChangeResourceGroupResponse
92
+ """
93
+ UtilClient.validate_model(request)
94
+ req = open_api_models.OpenApiRequest(
95
+ headers=headers,
96
+ body=OpenApiUtilClient.parse_to_map(request.body)
97
+ )
98
+ params = open_api_models.Params(
99
+ action='ChangeResourceGroup',
100
+ version='2023-03-30',
101
+ protocol='HTTPS',
102
+ pathname=f'/2023-03-30/resource-groups',
103
+ method='PUT',
104
+ auth_type='AK',
105
+ style='ROA',
106
+ req_body_type='json',
107
+ body_type='json'
108
+ )
109
+ return TeaCore.from_map(
110
+ fc20230330_models.ChangeResourceGroupResponse(),
111
+ await self.call_api_async(params, req, runtime)
112
+ )
113
+
114
+ def change_resource_group(
115
+ self,
116
+ request: fc20230330_models.ChangeResourceGroupRequest,
117
+ ) -> fc20230330_models.ChangeResourceGroupResponse:
118
+ """
119
+ @summary 修改实例所在资源组
120
+
121
+ @param request: ChangeResourceGroupRequest
122
+ @return: ChangeResourceGroupResponse
123
+ """
124
+ runtime = util_models.RuntimeOptions()
125
+ headers = {}
126
+ return self.change_resource_group_with_options(request, headers, runtime)
127
+
128
+ async def change_resource_group_async(
129
+ self,
130
+ request: fc20230330_models.ChangeResourceGroupRequest,
131
+ ) -> fc20230330_models.ChangeResourceGroupResponse:
132
+ """
133
+ @summary 修改实例所在资源组
134
+
135
+ @param request: ChangeResourceGroupRequest
136
+ @return: ChangeResourceGroupResponse
137
+ """
138
+ runtime = util_models.RuntimeOptions()
139
+ headers = {}
140
+ return await self.change_resource_group_with_options_async(request, headers, runtime)
141
+
44
142
  def create_alias_with_options(
45
143
  self,
46
144
  function_name: str,
@@ -72,16 +170,10 @@ class Client(OpenApiClient):
72
170
  req_body_type='json',
73
171
  body_type='json'
74
172
  )
75
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
76
- return TeaCore.from_map(
77
- fc20230330_models.CreateAliasResponse(),
78
- self.call_api(params, req, runtime)
79
- )
80
- else:
81
- return TeaCore.from_map(
82
- fc20230330_models.CreateAliasResponse(),
83
- self.execute(params, req, runtime)
84
- )
173
+ return TeaCore.from_map(
174
+ fc20230330_models.CreateAliasResponse(),
175
+ self.call_api(params, req, runtime)
176
+ )
85
177
 
86
178
  async def create_alias_with_options_async(
87
179
  self,
@@ -114,16 +206,10 @@ class Client(OpenApiClient):
114
206
  req_body_type='json',
115
207
  body_type='json'
116
208
  )
117
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
118
- return TeaCore.from_map(
119
- fc20230330_models.CreateAliasResponse(),
120
- await self.call_api_async(params, req, runtime)
121
- )
122
- else:
123
- return TeaCore.from_map(
124
- fc20230330_models.CreateAliasResponse(),
125
- await self.execute_async(params, req, runtime)
126
- )
209
+ return TeaCore.from_map(
210
+ fc20230330_models.CreateAliasResponse(),
211
+ await self.call_api_async(params, req, runtime)
212
+ )
127
213
 
128
214
  def create_alias(
129
215
  self,
@@ -187,16 +273,10 @@ class Client(OpenApiClient):
187
273
  req_body_type='json',
188
274
  body_type='json'
189
275
  )
190
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
191
- return TeaCore.from_map(
192
- fc20230330_models.CreateCustomDomainResponse(),
193
- self.call_api(params, req, runtime)
194
- )
195
- else:
196
- return TeaCore.from_map(
197
- fc20230330_models.CreateCustomDomainResponse(),
198
- self.execute(params, req, runtime)
199
- )
276
+ return TeaCore.from_map(
277
+ fc20230330_models.CreateCustomDomainResponse(),
278
+ self.call_api(params, req, runtime)
279
+ )
200
280
 
201
281
  async def create_custom_domain_with_options_async(
202
282
  self,
@@ -230,16 +310,10 @@ class Client(OpenApiClient):
230
310
  req_body_type='json',
231
311
  body_type='json'
232
312
  )
233
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
234
- return TeaCore.from_map(
235
- fc20230330_models.CreateCustomDomainResponse(),
236
- await self.call_api_async(params, req, runtime)
237
- )
238
- else:
239
- return TeaCore.from_map(
240
- fc20230330_models.CreateCustomDomainResponse(),
241
- await self.execute_async(params, req, runtime)
242
- )
313
+ return TeaCore.from_map(
314
+ fc20230330_models.CreateCustomDomainResponse(),
315
+ await self.call_api_async(params, req, runtime)
316
+ )
243
317
 
244
318
  def create_custom_domain(
245
319
  self,
@@ -305,16 +379,10 @@ class Client(OpenApiClient):
305
379
  req_body_type='json',
306
380
  body_type='json'
307
381
  )
308
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
309
- return TeaCore.from_map(
310
- fc20230330_models.CreateFunctionResponse(),
311
- self.call_api(params, req, runtime)
312
- )
313
- else:
314
- return TeaCore.from_map(
315
- fc20230330_models.CreateFunctionResponse(),
316
- self.execute(params, req, runtime)
317
- )
382
+ return TeaCore.from_map(
383
+ fc20230330_models.CreateFunctionResponse(),
384
+ self.call_api(params, req, runtime)
385
+ )
318
386
 
319
387
  async def create_function_with_options_async(
320
388
  self,
@@ -348,16 +416,10 @@ class Client(OpenApiClient):
348
416
  req_body_type='json',
349
417
  body_type='json'
350
418
  )
351
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
352
- return TeaCore.from_map(
353
- fc20230330_models.CreateFunctionResponse(),
354
- await self.call_api_async(params, req, runtime)
355
- )
356
- else:
357
- return TeaCore.from_map(
358
- fc20230330_models.CreateFunctionResponse(),
359
- await self.execute_async(params, req, runtime)
360
- )
419
+ return TeaCore.from_map(
420
+ fc20230330_models.CreateFunctionResponse(),
421
+ await self.call_api_async(params, req, runtime)
422
+ )
361
423
 
362
424
  def create_function(
363
425
  self,
@@ -422,16 +484,10 @@ class Client(OpenApiClient):
422
484
  req_body_type='json',
423
485
  body_type='json'
424
486
  )
425
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
426
- return TeaCore.from_map(
427
- fc20230330_models.CreateLayerVersionResponse(),
428
- self.call_api(params, req, runtime)
429
- )
430
- else:
431
- return TeaCore.from_map(
432
- fc20230330_models.CreateLayerVersionResponse(),
433
- self.execute(params, req, runtime)
434
- )
487
+ return TeaCore.from_map(
488
+ fc20230330_models.CreateLayerVersionResponse(),
489
+ self.call_api(params, req, runtime)
490
+ )
435
491
 
436
492
  async def create_layer_version_with_options_async(
437
493
  self,
@@ -464,16 +520,10 @@ class Client(OpenApiClient):
464
520
  req_body_type='json',
465
521
  body_type='json'
466
522
  )
467
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
468
- return TeaCore.from_map(
469
- fc20230330_models.CreateLayerVersionResponse(),
470
- await self.call_api_async(params, req, runtime)
471
- )
472
- else:
473
- return TeaCore.from_map(
474
- fc20230330_models.CreateLayerVersionResponse(),
475
- await self.execute_async(params, req, runtime)
476
- )
523
+ return TeaCore.from_map(
524
+ fc20230330_models.CreateLayerVersionResponse(),
525
+ await self.call_api_async(params, req, runtime)
526
+ )
477
527
 
478
528
  def create_layer_version(
479
529
  self,
@@ -536,16 +586,10 @@ class Client(OpenApiClient):
536
586
  req_body_type='json',
537
587
  body_type='json'
538
588
  )
539
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
540
- return TeaCore.from_map(
541
- fc20230330_models.CreateTriggerResponse(),
542
- self.call_api(params, req, runtime)
543
- )
544
- else:
545
- return TeaCore.from_map(
546
- fc20230330_models.CreateTriggerResponse(),
547
- self.execute(params, req, runtime)
548
- )
589
+ return TeaCore.from_map(
590
+ fc20230330_models.CreateTriggerResponse(),
591
+ self.call_api(params, req, runtime)
592
+ )
549
593
 
550
594
  async def create_trigger_with_options_async(
551
595
  self,
@@ -578,16 +622,10 @@ class Client(OpenApiClient):
578
622
  req_body_type='json',
579
623
  body_type='json'
580
624
  )
581
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
582
- return TeaCore.from_map(
583
- fc20230330_models.CreateTriggerResponse(),
584
- await self.call_api_async(params, req, runtime)
585
- )
586
- else:
587
- return TeaCore.from_map(
588
- fc20230330_models.CreateTriggerResponse(),
589
- await self.execute_async(params, req, runtime)
590
- )
625
+ return TeaCore.from_map(
626
+ fc20230330_models.CreateTriggerResponse(),
627
+ await self.call_api_async(params, req, runtime)
628
+ )
591
629
 
592
630
  def create_trigger(
593
631
  self,
@@ -650,16 +688,10 @@ class Client(OpenApiClient):
650
688
  req_body_type='json',
651
689
  body_type='none'
652
690
  )
653
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
654
- return TeaCore.from_map(
655
- fc20230330_models.CreateVpcBindingResponse(),
656
- self.call_api(params, req, runtime)
657
- )
658
- else:
659
- return TeaCore.from_map(
660
- fc20230330_models.CreateVpcBindingResponse(),
661
- self.execute(params, req, runtime)
662
- )
691
+ return TeaCore.from_map(
692
+ fc20230330_models.CreateVpcBindingResponse(),
693
+ self.call_api(params, req, runtime)
694
+ )
663
695
 
664
696
  async def create_vpc_binding_with_options_async(
665
697
  self,
@@ -692,16 +724,10 @@ class Client(OpenApiClient):
692
724
  req_body_type='json',
693
725
  body_type='none'
694
726
  )
695
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
696
- return TeaCore.from_map(
697
- fc20230330_models.CreateVpcBindingResponse(),
698
- await self.call_api_async(params, req, runtime)
699
- )
700
- else:
701
- return TeaCore.from_map(
702
- fc20230330_models.CreateVpcBindingResponse(),
703
- await self.execute_async(params, req, runtime)
704
- )
727
+ return TeaCore.from_map(
728
+ fc20230330_models.CreateVpcBindingResponse(),
729
+ await self.call_api_async(params, req, runtime)
730
+ )
705
731
 
706
732
  def create_vpc_binding(
707
733
  self,
@@ -761,16 +787,10 @@ class Client(OpenApiClient):
761
787
  req_body_type='json',
762
788
  body_type='none'
763
789
  )
764
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
765
- return TeaCore.from_map(
766
- fc20230330_models.DeleteAliasResponse(),
767
- self.call_api(params, req, runtime)
768
- )
769
- else:
770
- return TeaCore.from_map(
771
- fc20230330_models.DeleteAliasResponse(),
772
- self.execute(params, req, runtime)
773
- )
790
+ return TeaCore.from_map(
791
+ fc20230330_models.DeleteAliasResponse(),
792
+ self.call_api(params, req, runtime)
793
+ )
774
794
 
775
795
  async def delete_alias_with_options_async(
776
796
  self,
@@ -800,16 +820,10 @@ class Client(OpenApiClient):
800
820
  req_body_type='json',
801
821
  body_type='none'
802
822
  )
803
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
804
- return TeaCore.from_map(
805
- fc20230330_models.DeleteAliasResponse(),
806
- await self.call_api_async(params, req, runtime)
807
- )
808
- else:
809
- return TeaCore.from_map(
810
- fc20230330_models.DeleteAliasResponse(),
811
- await self.execute_async(params, req, runtime)
812
- )
823
+ return TeaCore.from_map(
824
+ fc20230330_models.DeleteAliasResponse(),
825
+ await self.call_api_async(params, req, runtime)
826
+ )
813
827
 
814
828
  def delete_alias(
815
829
  self,
@@ -873,16 +887,10 @@ class Client(OpenApiClient):
873
887
  req_body_type='json',
874
888
  body_type='none'
875
889
  )
876
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
877
- return TeaCore.from_map(
878
- fc20230330_models.DeleteAsyncInvokeConfigResponse(),
879
- self.call_api(params, req, runtime)
880
- )
881
- else:
882
- return TeaCore.from_map(
883
- fc20230330_models.DeleteAsyncInvokeConfigResponse(),
884
- self.execute(params, req, runtime)
885
- )
890
+ return TeaCore.from_map(
891
+ fc20230330_models.DeleteAsyncInvokeConfigResponse(),
892
+ self.call_api(params, req, runtime)
893
+ )
886
894
 
887
895
  async def delete_async_invoke_config_with_options_async(
888
896
  self,
@@ -918,16 +926,10 @@ class Client(OpenApiClient):
918
926
  req_body_type='json',
919
927
  body_type='none'
920
928
  )
921
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
922
- return TeaCore.from_map(
923
- fc20230330_models.DeleteAsyncInvokeConfigResponse(),
924
- await self.call_api_async(params, req, runtime)
925
- )
926
- else:
927
- return TeaCore.from_map(
928
- fc20230330_models.DeleteAsyncInvokeConfigResponse(),
929
- await self.execute_async(params, req, runtime)
930
- )
929
+ return TeaCore.from_map(
930
+ fc20230330_models.DeleteAsyncInvokeConfigResponse(),
931
+ await self.call_api_async(params, req, runtime)
932
+ )
931
933
 
932
934
  def delete_async_invoke_config(
933
935
  self,
@@ -986,16 +988,10 @@ class Client(OpenApiClient):
986
988
  req_body_type='json',
987
989
  body_type='none'
988
990
  )
989
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
990
- return TeaCore.from_map(
991
- fc20230330_models.DeleteConcurrencyConfigResponse(),
992
- self.call_api(params, req, runtime)
993
- )
994
- else:
995
- return TeaCore.from_map(
996
- fc20230330_models.DeleteConcurrencyConfigResponse(),
997
- self.execute(params, req, runtime)
998
- )
991
+ return TeaCore.from_map(
992
+ fc20230330_models.DeleteConcurrencyConfigResponse(),
993
+ self.call_api(params, req, runtime)
994
+ )
999
995
 
1000
996
  async def delete_concurrency_config_with_options_async(
1001
997
  self,
@@ -1024,16 +1020,10 @@ class Client(OpenApiClient):
1024
1020
  req_body_type='json',
1025
1021
  body_type='none'
1026
1022
  )
1027
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1028
- return TeaCore.from_map(
1029
- fc20230330_models.DeleteConcurrencyConfigResponse(),
1030
- await self.call_api_async(params, req, runtime)
1031
- )
1032
- else:
1033
- return TeaCore.from_map(
1034
- fc20230330_models.DeleteConcurrencyConfigResponse(),
1035
- await self.execute_async(params, req, runtime)
1036
- )
1023
+ return TeaCore.from_map(
1024
+ fc20230330_models.DeleteConcurrencyConfigResponse(),
1025
+ await self.call_api_async(params, req, runtime)
1026
+ )
1037
1027
 
1038
1028
  def delete_concurrency_config(
1039
1029
  self,
@@ -1088,16 +1078,10 @@ class Client(OpenApiClient):
1088
1078
  req_body_type='json',
1089
1079
  body_type='none'
1090
1080
  )
1091
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1092
- return TeaCore.from_map(
1093
- fc20230330_models.DeleteCustomDomainResponse(),
1094
- self.call_api(params, req, runtime)
1095
- )
1096
- else:
1097
- return TeaCore.from_map(
1098
- fc20230330_models.DeleteCustomDomainResponse(),
1099
- self.execute(params, req, runtime)
1100
- )
1081
+ return TeaCore.from_map(
1082
+ fc20230330_models.DeleteCustomDomainResponse(),
1083
+ self.call_api(params, req, runtime)
1084
+ )
1101
1085
 
1102
1086
  async def delete_custom_domain_with_options_async(
1103
1087
  self,
@@ -1126,16 +1110,10 @@ class Client(OpenApiClient):
1126
1110
  req_body_type='json',
1127
1111
  body_type='none'
1128
1112
  )
1129
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1130
- return TeaCore.from_map(
1131
- fc20230330_models.DeleteCustomDomainResponse(),
1132
- await self.call_api_async(params, req, runtime)
1133
- )
1134
- else:
1135
- return TeaCore.from_map(
1136
- fc20230330_models.DeleteCustomDomainResponse(),
1137
- await self.execute_async(params, req, runtime)
1138
- )
1113
+ return TeaCore.from_map(
1114
+ fc20230330_models.DeleteCustomDomainResponse(),
1115
+ await self.call_api_async(params, req, runtime)
1116
+ )
1139
1117
 
1140
1118
  def delete_custom_domain(
1141
1119
  self,
@@ -1190,16 +1168,10 @@ class Client(OpenApiClient):
1190
1168
  req_body_type='json',
1191
1169
  body_type='none'
1192
1170
  )
1193
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1194
- return TeaCore.from_map(
1195
- fc20230330_models.DeleteFunctionResponse(),
1196
- self.call_api(params, req, runtime)
1197
- )
1198
- else:
1199
- return TeaCore.from_map(
1200
- fc20230330_models.DeleteFunctionResponse(),
1201
- self.execute(params, req, runtime)
1202
- )
1171
+ return TeaCore.from_map(
1172
+ fc20230330_models.DeleteFunctionResponse(),
1173
+ self.call_api(params, req, runtime)
1174
+ )
1203
1175
 
1204
1176
  async def delete_function_with_options_async(
1205
1177
  self,
@@ -1228,16 +1200,10 @@ class Client(OpenApiClient):
1228
1200
  req_body_type='json',
1229
1201
  body_type='none'
1230
1202
  )
1231
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1232
- return TeaCore.from_map(
1233
- fc20230330_models.DeleteFunctionResponse(),
1234
- await self.call_api_async(params, req, runtime)
1235
- )
1236
- else:
1237
- return TeaCore.from_map(
1238
- fc20230330_models.DeleteFunctionResponse(),
1239
- await self.execute_async(params, req, runtime)
1240
- )
1203
+ return TeaCore.from_map(
1204
+ fc20230330_models.DeleteFunctionResponse(),
1205
+ await self.call_api_async(params, req, runtime)
1206
+ )
1241
1207
 
1242
1208
  def delete_function(
1243
1209
  self,
@@ -1293,16 +1259,10 @@ class Client(OpenApiClient):
1293
1259
  req_body_type='json',
1294
1260
  body_type='none'
1295
1261
  )
1296
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1297
- return TeaCore.from_map(
1298
- fc20230330_models.DeleteFunctionVersionResponse(),
1299
- self.call_api(params, req, runtime)
1300
- )
1301
- else:
1302
- return TeaCore.from_map(
1303
- fc20230330_models.DeleteFunctionVersionResponse(),
1304
- self.execute(params, req, runtime)
1305
- )
1262
+ return TeaCore.from_map(
1263
+ fc20230330_models.DeleteFunctionVersionResponse(),
1264
+ self.call_api(params, req, runtime)
1265
+ )
1306
1266
 
1307
1267
  async def delete_function_version_with_options_async(
1308
1268
  self,
@@ -1332,16 +1292,10 @@ class Client(OpenApiClient):
1332
1292
  req_body_type='json',
1333
1293
  body_type='none'
1334
1294
  )
1335
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1336
- return TeaCore.from_map(
1337
- fc20230330_models.DeleteFunctionVersionResponse(),
1338
- await self.call_api_async(params, req, runtime)
1339
- )
1340
- else:
1341
- return TeaCore.from_map(
1342
- fc20230330_models.DeleteFunctionVersionResponse(),
1343
- await self.execute_async(params, req, runtime)
1344
- )
1295
+ return TeaCore.from_map(
1296
+ fc20230330_models.DeleteFunctionVersionResponse(),
1297
+ await self.call_api_async(params, req, runtime)
1298
+ )
1345
1299
 
1346
1300
  def delete_function_version(
1347
1301
  self,
@@ -1399,16 +1353,10 @@ class Client(OpenApiClient):
1399
1353
  req_body_type='json',
1400
1354
  body_type='none'
1401
1355
  )
1402
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1403
- return TeaCore.from_map(
1404
- fc20230330_models.DeleteLayerVersionResponse(),
1405
- self.call_api(params, req, runtime)
1406
- )
1407
- else:
1408
- return TeaCore.from_map(
1409
- fc20230330_models.DeleteLayerVersionResponse(),
1410
- self.execute(params, req, runtime)
1411
- )
1356
+ return TeaCore.from_map(
1357
+ fc20230330_models.DeleteLayerVersionResponse(),
1358
+ self.call_api(params, req, runtime)
1359
+ )
1412
1360
 
1413
1361
  async def delete_layer_version_with_options_async(
1414
1362
  self,
@@ -1438,16 +1386,10 @@ class Client(OpenApiClient):
1438
1386
  req_body_type='json',
1439
1387
  body_type='none'
1440
1388
  )
1441
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1442
- return TeaCore.from_map(
1443
- fc20230330_models.DeleteLayerVersionResponse(),
1444
- await self.call_api_async(params, req, runtime)
1445
- )
1446
- else:
1447
- return TeaCore.from_map(
1448
- fc20230330_models.DeleteLayerVersionResponse(),
1449
- await self.execute_async(params, req, runtime)
1450
- )
1389
+ return TeaCore.from_map(
1390
+ fc20230330_models.DeleteLayerVersionResponse(),
1391
+ await self.call_api_async(params, req, runtime)
1392
+ )
1451
1393
 
1452
1394
  def delete_layer_version(
1453
1395
  self,
@@ -1511,16 +1453,10 @@ class Client(OpenApiClient):
1511
1453
  req_body_type='json',
1512
1454
  body_type='none'
1513
1455
  )
1514
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1515
- return TeaCore.from_map(
1516
- fc20230330_models.DeleteProvisionConfigResponse(),
1517
- self.call_api(params, req, runtime)
1518
- )
1519
- else:
1520
- return TeaCore.from_map(
1521
- fc20230330_models.DeleteProvisionConfigResponse(),
1522
- self.execute(params, req, runtime)
1523
- )
1456
+ return TeaCore.from_map(
1457
+ fc20230330_models.DeleteProvisionConfigResponse(),
1458
+ self.call_api(params, req, runtime)
1459
+ )
1524
1460
 
1525
1461
  async def delete_provision_config_with_options_async(
1526
1462
  self,
@@ -1556,16 +1492,10 @@ class Client(OpenApiClient):
1556
1492
  req_body_type='json',
1557
1493
  body_type='none'
1558
1494
  )
1559
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1560
- return TeaCore.from_map(
1561
- fc20230330_models.DeleteProvisionConfigResponse(),
1562
- await self.call_api_async(params, req, runtime)
1563
- )
1564
- else:
1565
- return TeaCore.from_map(
1566
- fc20230330_models.DeleteProvisionConfigResponse(),
1567
- await self.execute_async(params, req, runtime)
1568
- )
1495
+ return TeaCore.from_map(
1496
+ fc20230330_models.DeleteProvisionConfigResponse(),
1497
+ await self.call_api_async(params, req, runtime)
1498
+ )
1569
1499
 
1570
1500
  def delete_provision_config(
1571
1501
  self,
@@ -1625,16 +1555,10 @@ class Client(OpenApiClient):
1625
1555
  req_body_type='json',
1626
1556
  body_type='none'
1627
1557
  )
1628
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1629
- return TeaCore.from_map(
1630
- fc20230330_models.DeleteTriggerResponse(),
1631
- self.call_api(params, req, runtime)
1632
- )
1633
- else:
1634
- return TeaCore.from_map(
1635
- fc20230330_models.DeleteTriggerResponse(),
1636
- self.execute(params, req, runtime)
1637
- )
1558
+ return TeaCore.from_map(
1559
+ fc20230330_models.DeleteTriggerResponse(),
1560
+ self.call_api(params, req, runtime)
1561
+ )
1638
1562
 
1639
1563
  async def delete_trigger_with_options_async(
1640
1564
  self,
@@ -1664,16 +1588,10 @@ class Client(OpenApiClient):
1664
1588
  req_body_type='json',
1665
1589
  body_type='none'
1666
1590
  )
1667
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1668
- return TeaCore.from_map(
1669
- fc20230330_models.DeleteTriggerResponse(),
1670
- await self.call_api_async(params, req, runtime)
1671
- )
1672
- else:
1673
- return TeaCore.from_map(
1674
- fc20230330_models.DeleteTriggerResponse(),
1675
- await self.execute_async(params, req, runtime)
1676
- )
1591
+ return TeaCore.from_map(
1592
+ fc20230330_models.DeleteTriggerResponse(),
1593
+ await self.call_api_async(params, req, runtime)
1594
+ )
1677
1595
 
1678
1596
  def delete_trigger(
1679
1597
  self,
@@ -1731,16 +1649,10 @@ class Client(OpenApiClient):
1731
1649
  req_body_type='json',
1732
1650
  body_type='none'
1733
1651
  )
1734
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1735
- return TeaCore.from_map(
1736
- fc20230330_models.DeleteVpcBindingResponse(),
1737
- self.call_api(params, req, runtime)
1738
- )
1739
- else:
1740
- return TeaCore.from_map(
1741
- fc20230330_models.DeleteVpcBindingResponse(),
1742
- self.execute(params, req, runtime)
1743
- )
1652
+ return TeaCore.from_map(
1653
+ fc20230330_models.DeleteVpcBindingResponse(),
1654
+ self.call_api(params, req, runtime)
1655
+ )
1744
1656
 
1745
1657
  async def delete_vpc_binding_with_options_async(
1746
1658
  self,
@@ -1770,16 +1682,10 @@ class Client(OpenApiClient):
1770
1682
  req_body_type='json',
1771
1683
  body_type='none'
1772
1684
  )
1773
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1774
- return TeaCore.from_map(
1775
- fc20230330_models.DeleteVpcBindingResponse(),
1776
- await self.call_api_async(params, req, runtime)
1777
- )
1778
- else:
1779
- return TeaCore.from_map(
1780
- fc20230330_models.DeleteVpcBindingResponse(),
1781
- await self.execute_async(params, req, runtime)
1782
- )
1685
+ return TeaCore.from_map(
1686
+ fc20230330_models.DeleteVpcBindingResponse(),
1687
+ await self.call_api_async(params, req, runtime)
1688
+ )
1783
1689
 
1784
1690
  def delete_vpc_binding(
1785
1691
  self,
@@ -1842,16 +1748,10 @@ class Client(OpenApiClient):
1842
1748
  req_body_type='json',
1843
1749
  body_type='json'
1844
1750
  )
1845
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1846
- return TeaCore.from_map(
1847
- fc20230330_models.DescribeRegionsResponse(),
1848
- self.call_api(params, req, runtime)
1849
- )
1850
- else:
1851
- return TeaCore.from_map(
1852
- fc20230330_models.DescribeRegionsResponse(),
1853
- self.execute(params, req, runtime)
1854
- )
1751
+ return TeaCore.from_map(
1752
+ fc20230330_models.DescribeRegionsResponse(),
1753
+ self.call_api(params, req, runtime)
1754
+ )
1855
1755
 
1856
1756
  async def describe_regions_with_options_async(
1857
1757
  self,
@@ -1886,16 +1786,10 @@ class Client(OpenApiClient):
1886
1786
  req_body_type='json',
1887
1787
  body_type='json'
1888
1788
  )
1889
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1890
- return TeaCore.from_map(
1891
- fc20230330_models.DescribeRegionsResponse(),
1892
- await self.call_api_async(params, req, runtime)
1893
- )
1894
- else:
1895
- return TeaCore.from_map(
1896
- fc20230330_models.DescribeRegionsResponse(),
1897
- await self.execute_async(params, req, runtime)
1898
- )
1789
+ return TeaCore.from_map(
1790
+ fc20230330_models.DescribeRegionsResponse(),
1791
+ await self.call_api_async(params, req, runtime)
1792
+ )
1899
1793
 
1900
1794
  def describe_regions(
1901
1795
  self,
@@ -1963,16 +1857,10 @@ class Client(OpenApiClient):
1963
1857
  req_body_type='json',
1964
1858
  body_type='json'
1965
1859
  )
1966
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1967
- return TeaCore.from_map(
1968
- fc20230330_models.DisableFunctionInvocationResponse(),
1969
- self.call_api(params, req, runtime)
1970
- )
1971
- else:
1972
- return TeaCore.from_map(
1973
- fc20230330_models.DisableFunctionInvocationResponse(),
1974
- self.execute(params, req, runtime)
1975
- )
1860
+ return TeaCore.from_map(
1861
+ fc20230330_models.DisableFunctionInvocationResponse(),
1862
+ self.call_api(params, req, runtime)
1863
+ )
1976
1864
 
1977
1865
  async def disable_function_invocation_with_options_async(
1978
1866
  self,
@@ -2012,16 +1900,10 @@ class Client(OpenApiClient):
2012
1900
  req_body_type='json',
2013
1901
  body_type='json'
2014
1902
  )
2015
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2016
- return TeaCore.from_map(
2017
- fc20230330_models.DisableFunctionInvocationResponse(),
2018
- await self.call_api_async(params, req, runtime)
2019
- )
2020
- else:
2021
- return TeaCore.from_map(
2022
- fc20230330_models.DisableFunctionInvocationResponse(),
2023
- await self.execute_async(params, req, runtime)
2024
- )
1903
+ return TeaCore.from_map(
1904
+ fc20230330_models.DisableFunctionInvocationResponse(),
1905
+ await self.call_api_async(params, req, runtime)
1906
+ )
2025
1907
 
2026
1908
  def disable_function_invocation(
2027
1909
  self,
@@ -2084,16 +1966,10 @@ class Client(OpenApiClient):
2084
1966
  req_body_type='json',
2085
1967
  body_type='json'
2086
1968
  )
2087
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2088
- return TeaCore.from_map(
2089
- fc20230330_models.EnableFunctionInvocationResponse(),
2090
- self.call_api(params, req, runtime)
2091
- )
2092
- else:
2093
- return TeaCore.from_map(
2094
- fc20230330_models.EnableFunctionInvocationResponse(),
2095
- self.execute(params, req, runtime)
2096
- )
1969
+ return TeaCore.from_map(
1970
+ fc20230330_models.EnableFunctionInvocationResponse(),
1971
+ self.call_api(params, req, runtime)
1972
+ )
2097
1973
 
2098
1974
  async def enable_function_invocation_with_options_async(
2099
1975
  self,
@@ -2122,16 +1998,10 @@ class Client(OpenApiClient):
2122
1998
  req_body_type='json',
2123
1999
  body_type='json'
2124
2000
  )
2125
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2126
- return TeaCore.from_map(
2127
- fc20230330_models.EnableFunctionInvocationResponse(),
2128
- await self.call_api_async(params, req, runtime)
2129
- )
2130
- else:
2131
- return TeaCore.from_map(
2132
- fc20230330_models.EnableFunctionInvocationResponse(),
2133
- await self.execute_async(params, req, runtime)
2134
- )
2001
+ return TeaCore.from_map(
2002
+ fc20230330_models.EnableFunctionInvocationResponse(),
2003
+ await self.call_api_async(params, req, runtime)
2004
+ )
2135
2005
 
2136
2006
  def enable_function_invocation(
2137
2007
  self,
@@ -2187,16 +2057,10 @@ class Client(OpenApiClient):
2187
2057
  req_body_type='json',
2188
2058
  body_type='json'
2189
2059
  )
2190
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2191
- return TeaCore.from_map(
2192
- fc20230330_models.GetAliasResponse(),
2193
- self.call_api(params, req, runtime)
2194
- )
2195
- else:
2196
- return TeaCore.from_map(
2197
- fc20230330_models.GetAliasResponse(),
2198
- self.execute(params, req, runtime)
2199
- )
2060
+ return TeaCore.from_map(
2061
+ fc20230330_models.GetAliasResponse(),
2062
+ self.call_api(params, req, runtime)
2063
+ )
2200
2064
 
2201
2065
  async def get_alias_with_options_async(
2202
2066
  self,
@@ -2226,16 +2090,10 @@ class Client(OpenApiClient):
2226
2090
  req_body_type='json',
2227
2091
  body_type='json'
2228
2092
  )
2229
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2230
- return TeaCore.from_map(
2231
- fc20230330_models.GetAliasResponse(),
2232
- await self.call_api_async(params, req, runtime)
2233
- )
2234
- else:
2235
- return TeaCore.from_map(
2236
- fc20230330_models.GetAliasResponse(),
2237
- await self.execute_async(params, req, runtime)
2238
- )
2093
+ return TeaCore.from_map(
2094
+ fc20230330_models.GetAliasResponse(),
2095
+ await self.call_api_async(params, req, runtime)
2096
+ )
2239
2097
 
2240
2098
  def get_alias(
2241
2099
  self,
@@ -2299,16 +2157,10 @@ class Client(OpenApiClient):
2299
2157
  req_body_type='json',
2300
2158
  body_type='json'
2301
2159
  )
2302
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2303
- return TeaCore.from_map(
2304
- fc20230330_models.GetAsyncInvokeConfigResponse(),
2305
- self.call_api(params, req, runtime)
2306
- )
2307
- else:
2308
- return TeaCore.from_map(
2309
- fc20230330_models.GetAsyncInvokeConfigResponse(),
2310
- self.execute(params, req, runtime)
2311
- )
2160
+ return TeaCore.from_map(
2161
+ fc20230330_models.GetAsyncInvokeConfigResponse(),
2162
+ self.call_api(params, req, runtime)
2163
+ )
2312
2164
 
2313
2165
  async def get_async_invoke_config_with_options_async(
2314
2166
  self,
@@ -2344,16 +2196,10 @@ class Client(OpenApiClient):
2344
2196
  req_body_type='json',
2345
2197
  body_type='json'
2346
2198
  )
2347
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2348
- return TeaCore.from_map(
2349
- fc20230330_models.GetAsyncInvokeConfigResponse(),
2350
- await self.call_api_async(params, req, runtime)
2351
- )
2352
- else:
2353
- return TeaCore.from_map(
2354
- fc20230330_models.GetAsyncInvokeConfigResponse(),
2355
- await self.execute_async(params, req, runtime)
2356
- )
2199
+ return TeaCore.from_map(
2200
+ fc20230330_models.GetAsyncInvokeConfigResponse(),
2201
+ await self.call_api_async(params, req, runtime)
2202
+ )
2357
2203
 
2358
2204
  def get_async_invoke_config(
2359
2205
  self,
@@ -2420,16 +2266,10 @@ class Client(OpenApiClient):
2420
2266
  req_body_type='json',
2421
2267
  body_type='json'
2422
2268
  )
2423
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2424
- return TeaCore.from_map(
2425
- fc20230330_models.GetAsyncTaskResponse(),
2426
- self.call_api(params, req, runtime)
2427
- )
2428
- else:
2429
- return TeaCore.from_map(
2430
- fc20230330_models.GetAsyncTaskResponse(),
2431
- self.execute(params, req, runtime)
2432
- )
2269
+ return TeaCore.from_map(
2270
+ fc20230330_models.GetAsyncTaskResponse(),
2271
+ self.call_api(params, req, runtime)
2272
+ )
2433
2273
 
2434
2274
  async def get_async_task_with_options_async(
2435
2275
  self,
@@ -2466,16 +2306,10 @@ class Client(OpenApiClient):
2466
2306
  req_body_type='json',
2467
2307
  body_type='json'
2468
2308
  )
2469
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2470
- return TeaCore.from_map(
2471
- fc20230330_models.GetAsyncTaskResponse(),
2472
- await self.call_api_async(params, req, runtime)
2473
- )
2474
- else:
2475
- return TeaCore.from_map(
2476
- fc20230330_models.GetAsyncTaskResponse(),
2477
- await self.execute_async(params, req, runtime)
2478
- )
2309
+ return TeaCore.from_map(
2310
+ fc20230330_models.GetAsyncTaskResponse(),
2311
+ await self.call_api_async(params, req, runtime)
2312
+ )
2479
2313
 
2480
2314
  def get_async_task(
2481
2315
  self,
@@ -2536,16 +2370,10 @@ class Client(OpenApiClient):
2536
2370
  req_body_type='json',
2537
2371
  body_type='json'
2538
2372
  )
2539
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2540
- return TeaCore.from_map(
2541
- fc20230330_models.GetConcurrencyConfigResponse(),
2542
- self.call_api(params, req, runtime)
2543
- )
2544
- else:
2545
- return TeaCore.from_map(
2546
- fc20230330_models.GetConcurrencyConfigResponse(),
2547
- self.execute(params, req, runtime)
2548
- )
2373
+ return TeaCore.from_map(
2374
+ fc20230330_models.GetConcurrencyConfigResponse(),
2375
+ self.call_api(params, req, runtime)
2376
+ )
2549
2377
 
2550
2378
  async def get_concurrency_config_with_options_async(
2551
2379
  self,
@@ -2574,16 +2402,10 @@ class Client(OpenApiClient):
2574
2402
  req_body_type='json',
2575
2403
  body_type='json'
2576
2404
  )
2577
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2578
- return TeaCore.from_map(
2579
- fc20230330_models.GetConcurrencyConfigResponse(),
2580
- await self.call_api_async(params, req, runtime)
2581
- )
2582
- else:
2583
- return TeaCore.from_map(
2584
- fc20230330_models.GetConcurrencyConfigResponse(),
2585
- await self.execute_async(params, req, runtime)
2586
- )
2405
+ return TeaCore.from_map(
2406
+ fc20230330_models.GetConcurrencyConfigResponse(),
2407
+ await self.call_api_async(params, req, runtime)
2408
+ )
2587
2409
 
2588
2410
  def get_concurrency_config(
2589
2411
  self,
@@ -2638,16 +2460,10 @@ class Client(OpenApiClient):
2638
2460
  req_body_type='json',
2639
2461
  body_type='json'
2640
2462
  )
2641
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2642
- return TeaCore.from_map(
2643
- fc20230330_models.GetCustomDomainResponse(),
2644
- self.call_api(params, req, runtime)
2645
- )
2646
- else:
2647
- return TeaCore.from_map(
2648
- fc20230330_models.GetCustomDomainResponse(),
2649
- self.execute(params, req, runtime)
2650
- )
2463
+ return TeaCore.from_map(
2464
+ fc20230330_models.GetCustomDomainResponse(),
2465
+ self.call_api(params, req, runtime)
2466
+ )
2651
2467
 
2652
2468
  async def get_custom_domain_with_options_async(
2653
2469
  self,
@@ -2676,16 +2492,10 @@ class Client(OpenApiClient):
2676
2492
  req_body_type='json',
2677
2493
  body_type='json'
2678
2494
  )
2679
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2680
- return TeaCore.from_map(
2681
- fc20230330_models.GetCustomDomainResponse(),
2682
- await self.call_api_async(params, req, runtime)
2683
- )
2684
- else:
2685
- return TeaCore.from_map(
2686
- fc20230330_models.GetCustomDomainResponse(),
2687
- await self.execute_async(params, req, runtime)
2688
- )
2495
+ return TeaCore.from_map(
2496
+ fc20230330_models.GetCustomDomainResponse(),
2497
+ await self.call_api_async(params, req, runtime)
2498
+ )
2689
2499
 
2690
2500
  def get_custom_domain(
2691
2501
  self,
@@ -2747,16 +2557,10 @@ class Client(OpenApiClient):
2747
2557
  req_body_type='json',
2748
2558
  body_type='json'
2749
2559
  )
2750
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2751
- return TeaCore.from_map(
2752
- fc20230330_models.GetFunctionResponse(),
2753
- self.call_api(params, req, runtime)
2754
- )
2755
- else:
2756
- return TeaCore.from_map(
2757
- fc20230330_models.GetFunctionResponse(),
2758
- self.execute(params, req, runtime)
2759
- )
2560
+ return TeaCore.from_map(
2561
+ fc20230330_models.GetFunctionResponse(),
2562
+ self.call_api(params, req, runtime)
2563
+ )
2760
2564
 
2761
2565
  async def get_function_with_options_async(
2762
2566
  self,
@@ -2792,16 +2596,10 @@ class Client(OpenApiClient):
2792
2596
  req_body_type='json',
2793
2597
  body_type='json'
2794
2598
  )
2795
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2796
- return TeaCore.from_map(
2797
- fc20230330_models.GetFunctionResponse(),
2798
- await self.call_api_async(params, req, runtime)
2799
- )
2800
- else:
2801
- return TeaCore.from_map(
2802
- fc20230330_models.GetFunctionResponse(),
2803
- await self.execute_async(params, req, runtime)
2804
- )
2599
+ return TeaCore.from_map(
2600
+ fc20230330_models.GetFunctionResponse(),
2601
+ await self.call_api_async(params, req, runtime)
2602
+ )
2805
2603
 
2806
2604
  def get_function(
2807
2605
  self,
@@ -2867,16 +2665,10 @@ class Client(OpenApiClient):
2867
2665
  req_body_type='json',
2868
2666
  body_type='json'
2869
2667
  )
2870
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2871
- return TeaCore.from_map(
2872
- fc20230330_models.GetFunctionCodeResponse(),
2873
- self.call_api(params, req, runtime)
2874
- )
2875
- else:
2876
- return TeaCore.from_map(
2877
- fc20230330_models.GetFunctionCodeResponse(),
2878
- self.execute(params, req, runtime)
2879
- )
2668
+ return TeaCore.from_map(
2669
+ fc20230330_models.GetFunctionCodeResponse(),
2670
+ self.call_api(params, req, runtime)
2671
+ )
2880
2672
 
2881
2673
  async def get_function_code_with_options_async(
2882
2674
  self,
@@ -2912,16 +2704,10 @@ class Client(OpenApiClient):
2912
2704
  req_body_type='json',
2913
2705
  body_type='json'
2914
2706
  )
2915
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2916
- return TeaCore.from_map(
2917
- fc20230330_models.GetFunctionCodeResponse(),
2918
- await self.call_api_async(params, req, runtime)
2919
- )
2920
- else:
2921
- return TeaCore.from_map(
2922
- fc20230330_models.GetFunctionCodeResponse(),
2923
- await self.execute_async(params, req, runtime)
2924
- )
2707
+ return TeaCore.from_map(
2708
+ fc20230330_models.GetFunctionCodeResponse(),
2709
+ await self.call_api_async(params, req, runtime)
2710
+ )
2925
2711
 
2926
2712
  def get_function_code(
2927
2713
  self,
@@ -2981,16 +2767,10 @@ class Client(OpenApiClient):
2981
2767
  req_body_type='json',
2982
2768
  body_type='json'
2983
2769
  )
2984
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2985
- return TeaCore.from_map(
2986
- fc20230330_models.GetLayerVersionResponse(),
2987
- self.call_api(params, req, runtime)
2988
- )
2989
- else:
2990
- return TeaCore.from_map(
2991
- fc20230330_models.GetLayerVersionResponse(),
2992
- self.execute(params, req, runtime)
2993
- )
2770
+ return TeaCore.from_map(
2771
+ fc20230330_models.GetLayerVersionResponse(),
2772
+ self.call_api(params, req, runtime)
2773
+ )
2994
2774
 
2995
2775
  async def get_layer_version_with_options_async(
2996
2776
  self,
@@ -3020,16 +2800,10 @@ class Client(OpenApiClient):
3020
2800
  req_body_type='json',
3021
2801
  body_type='json'
3022
2802
  )
3023
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3024
- return TeaCore.from_map(
3025
- fc20230330_models.GetLayerVersionResponse(),
3026
- await self.call_api_async(params, req, runtime)
3027
- )
3028
- else:
3029
- return TeaCore.from_map(
3030
- fc20230330_models.GetLayerVersionResponse(),
3031
- await self.execute_async(params, req, runtime)
3032
- )
2803
+ return TeaCore.from_map(
2804
+ fc20230330_models.GetLayerVersionResponse(),
2805
+ await self.call_api_async(params, req, runtime)
2806
+ )
3033
2807
 
3034
2808
  def get_layer_version(
3035
2809
  self,
@@ -3086,16 +2860,10 @@ class Client(OpenApiClient):
3086
2860
  req_body_type='json',
3087
2861
  body_type='json'
3088
2862
  )
3089
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3090
- return TeaCore.from_map(
3091
- fc20230330_models.GetLayerVersionByArnResponse(),
3092
- self.call_api(params, req, runtime)
3093
- )
3094
- else:
3095
- return TeaCore.from_map(
3096
- fc20230330_models.GetLayerVersionByArnResponse(),
3097
- self.execute(params, req, runtime)
3098
- )
2863
+ return TeaCore.from_map(
2864
+ fc20230330_models.GetLayerVersionByArnResponse(),
2865
+ self.call_api(params, req, runtime)
2866
+ )
3099
2867
 
3100
2868
  async def get_layer_version_by_arn_with_options_async(
3101
2869
  self,
@@ -3124,16 +2892,10 @@ class Client(OpenApiClient):
3124
2892
  req_body_type='json',
3125
2893
  body_type='json'
3126
2894
  )
3127
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3128
- return TeaCore.from_map(
3129
- fc20230330_models.GetLayerVersionByArnResponse(),
3130
- await self.call_api_async(params, req, runtime)
3131
- )
3132
- else:
3133
- return TeaCore.from_map(
3134
- fc20230330_models.GetLayerVersionByArnResponse(),
3135
- await self.execute_async(params, req, runtime)
3136
- )
2895
+ return TeaCore.from_map(
2896
+ fc20230330_models.GetLayerVersionByArnResponse(),
2897
+ await self.call_api_async(params, req, runtime)
2898
+ )
3137
2899
 
3138
2900
  def get_layer_version_by_arn(
3139
2901
  self,
@@ -3195,16 +2957,10 @@ class Client(OpenApiClient):
3195
2957
  req_body_type='json',
3196
2958
  body_type='json'
3197
2959
  )
3198
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3199
- return TeaCore.from_map(
3200
- fc20230330_models.GetProvisionConfigResponse(),
3201
- self.call_api(params, req, runtime)
3202
- )
3203
- else:
3204
- return TeaCore.from_map(
3205
- fc20230330_models.GetProvisionConfigResponse(),
3206
- self.execute(params, req, runtime)
3207
- )
2960
+ return TeaCore.from_map(
2961
+ fc20230330_models.GetProvisionConfigResponse(),
2962
+ self.call_api(params, req, runtime)
2963
+ )
3208
2964
 
3209
2965
  async def get_provision_config_with_options_async(
3210
2966
  self,
@@ -3240,16 +2996,10 @@ class Client(OpenApiClient):
3240
2996
  req_body_type='json',
3241
2997
  body_type='json'
3242
2998
  )
3243
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3244
- return TeaCore.from_map(
3245
- fc20230330_models.GetProvisionConfigResponse(),
3246
- await self.call_api_async(params, req, runtime)
3247
- )
3248
- else:
3249
- return TeaCore.from_map(
3250
- fc20230330_models.GetProvisionConfigResponse(),
3251
- await self.execute_async(params, req, runtime)
3252
- )
2999
+ return TeaCore.from_map(
3000
+ fc20230330_models.GetProvisionConfigResponse(),
3001
+ await self.call_api_async(params, req, runtime)
3002
+ )
3253
3003
 
3254
3004
  def get_provision_config(
3255
3005
  self,
@@ -3309,16 +3059,10 @@ class Client(OpenApiClient):
3309
3059
  req_body_type='json',
3310
3060
  body_type='json'
3311
3061
  )
3312
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3313
- return TeaCore.from_map(
3314
- fc20230330_models.GetTriggerResponse(),
3315
- self.call_api(params, req, runtime)
3316
- )
3317
- else:
3318
- return TeaCore.from_map(
3319
- fc20230330_models.GetTriggerResponse(),
3320
- self.execute(params, req, runtime)
3321
- )
3062
+ return TeaCore.from_map(
3063
+ fc20230330_models.GetTriggerResponse(),
3064
+ self.call_api(params, req, runtime)
3065
+ )
3322
3066
 
3323
3067
  async def get_trigger_with_options_async(
3324
3068
  self,
@@ -3348,16 +3092,10 @@ class Client(OpenApiClient):
3348
3092
  req_body_type='json',
3349
3093
  body_type='json'
3350
3094
  )
3351
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3352
- return TeaCore.from_map(
3353
- fc20230330_models.GetTriggerResponse(),
3354
- await self.call_api_async(params, req, runtime)
3355
- )
3356
- else:
3357
- return TeaCore.from_map(
3358
- fc20230330_models.GetTriggerResponse(),
3359
- await self.execute_async(params, req, runtime)
3360
- )
3095
+ return TeaCore.from_map(
3096
+ fc20230330_models.GetTriggerResponse(),
3097
+ await self.call_api_async(params, req, runtime)
3098
+ )
3361
3099
 
3362
3100
  def get_trigger(
3363
3101
  self,
@@ -3571,16 +3309,10 @@ class Client(OpenApiClient):
3571
3309
  req_body_type='json',
3572
3310
  body_type='json'
3573
3311
  )
3574
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3575
- return TeaCore.from_map(
3576
- fc20230330_models.ListAliasesResponse(),
3577
- self.call_api(params, req, runtime)
3578
- )
3579
- else:
3580
- return TeaCore.from_map(
3581
- fc20230330_models.ListAliasesResponse(),
3582
- self.execute(params, req, runtime)
3583
- )
3312
+ return TeaCore.from_map(
3313
+ fc20230330_models.ListAliasesResponse(),
3314
+ self.call_api(params, req, runtime)
3315
+ )
3584
3316
 
3585
3317
  async def list_aliases_with_options_async(
3586
3318
  self,
@@ -3620,16 +3352,10 @@ class Client(OpenApiClient):
3620
3352
  req_body_type='json',
3621
3353
  body_type='json'
3622
3354
  )
3623
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3624
- return TeaCore.from_map(
3625
- fc20230330_models.ListAliasesResponse(),
3626
- await self.call_api_async(params, req, runtime)
3627
- )
3628
- else:
3629
- return TeaCore.from_map(
3630
- fc20230330_models.ListAliasesResponse(),
3631
- await self.execute_async(params, req, runtime)
3632
- )
3355
+ return TeaCore.from_map(
3356
+ fc20230330_models.ListAliasesResponse(),
3357
+ await self.call_api_async(params, req, runtime)
3358
+ )
3633
3359
 
3634
3360
  def list_aliases(
3635
3361
  self,
@@ -3698,16 +3424,10 @@ class Client(OpenApiClient):
3698
3424
  req_body_type='json',
3699
3425
  body_type='json'
3700
3426
  )
3701
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3702
- return TeaCore.from_map(
3703
- fc20230330_models.ListAsyncInvokeConfigsResponse(),
3704
- self.call_api(params, req, runtime)
3705
- )
3706
- else:
3707
- return TeaCore.from_map(
3708
- fc20230330_models.ListAsyncInvokeConfigsResponse(),
3709
- self.execute(params, req, runtime)
3710
- )
3427
+ return TeaCore.from_map(
3428
+ fc20230330_models.ListAsyncInvokeConfigsResponse(),
3429
+ self.call_api(params, req, runtime)
3430
+ )
3711
3431
 
3712
3432
  async def list_async_invoke_configs_with_options_async(
3713
3433
  self,
@@ -3746,16 +3466,10 @@ class Client(OpenApiClient):
3746
3466
  req_body_type='json',
3747
3467
  body_type='json'
3748
3468
  )
3749
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3750
- return TeaCore.from_map(
3751
- fc20230330_models.ListAsyncInvokeConfigsResponse(),
3752
- await self.call_api_async(params, req, runtime)
3753
- )
3754
- else:
3755
- return TeaCore.from_map(
3756
- fc20230330_models.ListAsyncInvokeConfigsResponse(),
3757
- await self.execute_async(params, req, runtime)
3758
- )
3469
+ return TeaCore.from_map(
3470
+ fc20230330_models.ListAsyncInvokeConfigsResponse(),
3471
+ await self.call_api_async(params, req, runtime)
3472
+ )
3759
3473
 
3760
3474
  def list_async_invoke_configs(
3761
3475
  self,
@@ -3835,16 +3549,10 @@ class Client(OpenApiClient):
3835
3549
  req_body_type='json',
3836
3550
  body_type='json'
3837
3551
  )
3838
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3839
- return TeaCore.from_map(
3840
- fc20230330_models.ListAsyncTasksResponse(),
3841
- self.call_api(params, req, runtime)
3842
- )
3843
- else:
3844
- return TeaCore.from_map(
3845
- fc20230330_models.ListAsyncTasksResponse(),
3846
- self.execute(params, req, runtime)
3847
- )
3552
+ return TeaCore.from_map(
3553
+ fc20230330_models.ListAsyncTasksResponse(),
3554
+ self.call_api(params, req, runtime)
3555
+ )
3848
3556
 
3849
3557
  async def list_async_tasks_with_options_async(
3850
3558
  self,
@@ -3896,16 +3604,10 @@ class Client(OpenApiClient):
3896
3604
  req_body_type='json',
3897
3605
  body_type='json'
3898
3606
  )
3899
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3900
- return TeaCore.from_map(
3901
- fc20230330_models.ListAsyncTasksResponse(),
3902
- await self.call_api_async(params, req, runtime)
3903
- )
3904
- else:
3905
- return TeaCore.from_map(
3906
- fc20230330_models.ListAsyncTasksResponse(),
3907
- await self.execute_async(params, req, runtime)
3908
- )
3607
+ return TeaCore.from_map(
3608
+ fc20230330_models.ListAsyncTasksResponse(),
3609
+ await self.call_api_async(params, req, runtime)
3610
+ )
3909
3611
 
3910
3612
  def list_async_tasks(
3911
3613
  self,
@@ -3974,16 +3676,10 @@ class Client(OpenApiClient):
3974
3676
  req_body_type='json',
3975
3677
  body_type='json'
3976
3678
  )
3977
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3978
- return TeaCore.from_map(
3979
- fc20230330_models.ListConcurrencyConfigsResponse(),
3980
- self.call_api(params, req, runtime)
3981
- )
3982
- else:
3983
- return TeaCore.from_map(
3984
- fc20230330_models.ListConcurrencyConfigsResponse(),
3985
- self.execute(params, req, runtime)
3986
- )
3679
+ return TeaCore.from_map(
3680
+ fc20230330_models.ListConcurrencyConfigsResponse(),
3681
+ self.call_api(params, req, runtime)
3682
+ )
3987
3683
 
3988
3684
  async def list_concurrency_configs_with_options_async(
3989
3685
  self,
@@ -4022,16 +3718,10 @@ class Client(OpenApiClient):
4022
3718
  req_body_type='json',
4023
3719
  body_type='json'
4024
3720
  )
4025
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4026
- return TeaCore.from_map(
4027
- fc20230330_models.ListConcurrencyConfigsResponse(),
4028
- await self.call_api_async(params, req, runtime)
4029
- )
4030
- else:
4031
- return TeaCore.from_map(
4032
- fc20230330_models.ListConcurrencyConfigsResponse(),
4033
- await self.execute_async(params, req, runtime)
4034
- )
3721
+ return TeaCore.from_map(
3722
+ fc20230330_models.ListConcurrencyConfigsResponse(),
3723
+ await self.call_api_async(params, req, runtime)
3724
+ )
4035
3725
 
4036
3726
  def list_concurrency_configs(
4037
3727
  self,
@@ -4098,16 +3788,10 @@ class Client(OpenApiClient):
4098
3788
  req_body_type='json',
4099
3789
  body_type='json'
4100
3790
  )
4101
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4102
- return TeaCore.from_map(
4103
- fc20230330_models.ListCustomDomainsResponse(),
4104
- self.call_api(params, req, runtime)
4105
- )
4106
- else:
4107
- return TeaCore.from_map(
4108
- fc20230330_models.ListCustomDomainsResponse(),
4109
- self.execute(params, req, runtime)
4110
- )
3791
+ return TeaCore.from_map(
3792
+ fc20230330_models.ListCustomDomainsResponse(),
3793
+ self.call_api(params, req, runtime)
3794
+ )
4111
3795
 
4112
3796
  async def list_custom_domains_with_options_async(
4113
3797
  self,
@@ -4146,16 +3830,10 @@ class Client(OpenApiClient):
4146
3830
  req_body_type='json',
4147
3831
  body_type='json'
4148
3832
  )
4149
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4150
- return TeaCore.from_map(
4151
- fc20230330_models.ListCustomDomainsResponse(),
4152
- await self.call_api_async(params, req, runtime)
4153
- )
4154
- else:
4155
- return TeaCore.from_map(
4156
- fc20230330_models.ListCustomDomainsResponse(),
4157
- await self.execute_async(params, req, runtime)
4158
- )
3833
+ return TeaCore.from_map(
3834
+ fc20230330_models.ListCustomDomainsResponse(),
3835
+ await self.call_api_async(params, req, runtime)
3836
+ )
4159
3837
 
4160
3838
  def list_custom_domains(
4161
3839
  self,
@@ -4223,16 +3901,10 @@ class Client(OpenApiClient):
4223
3901
  req_body_type='json',
4224
3902
  body_type='json'
4225
3903
  )
4226
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4227
- return TeaCore.from_map(
4228
- fc20230330_models.ListFunctionVersionsResponse(),
4229
- self.call_api(params, req, runtime)
4230
- )
4231
- else:
4232
- return TeaCore.from_map(
4233
- fc20230330_models.ListFunctionVersionsResponse(),
4234
- self.execute(params, req, runtime)
4235
- )
3904
+ return TeaCore.from_map(
3905
+ fc20230330_models.ListFunctionVersionsResponse(),
3906
+ self.call_api(params, req, runtime)
3907
+ )
4236
3908
 
4237
3909
  async def list_function_versions_with_options_async(
4238
3910
  self,
@@ -4272,16 +3944,10 @@ class Client(OpenApiClient):
4272
3944
  req_body_type='json',
4273
3945
  body_type='json'
4274
3946
  )
4275
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4276
- return TeaCore.from_map(
4277
- fc20230330_models.ListFunctionVersionsResponse(),
4278
- await self.call_api_async(params, req, runtime)
4279
- )
4280
- else:
4281
- return TeaCore.from_map(
4282
- fc20230330_models.ListFunctionVersionsResponse(),
4283
- await self.execute_async(params, req, runtime)
4284
- )
3947
+ return TeaCore.from_map(
3948
+ fc20230330_models.ListFunctionVersionsResponse(),
3949
+ await self.call_api_async(params, req, runtime)
3950
+ )
4285
3951
 
4286
3952
  def list_function_versions(
4287
3953
  self,
@@ -4339,6 +4005,8 @@ class Client(OpenApiClient):
4339
4005
  query['description'] = request.description
4340
4006
  if not UtilClient.is_unset(request.fc_version):
4341
4007
  query['fcVersion'] = request.fc_version
4008
+ if not UtilClient.is_unset(request.function_name):
4009
+ query['functionName'] = request.function_name
4342
4010
  if not UtilClient.is_unset(request.gpu_type):
4343
4011
  query['gpuType'] = request.gpu_type
4344
4012
  if not UtilClient.is_unset(request.limit):
@@ -4347,6 +4015,8 @@ class Client(OpenApiClient):
4347
4015
  query['nextToken'] = request.next_token
4348
4016
  if not UtilClient.is_unset(request.prefix):
4349
4017
  query['prefix'] = request.prefix
4018
+ if not UtilClient.is_unset(request.resource_group_id):
4019
+ query['resourceGroupId'] = request.resource_group_id
4350
4020
  if not UtilClient.is_unset(request.runtime):
4351
4021
  query['runtime'] = request.runtime
4352
4022
  if not UtilClient.is_unset(request.tags_shrink):
@@ -4366,16 +4036,10 @@ class Client(OpenApiClient):
4366
4036
  req_body_type='json',
4367
4037
  body_type='json'
4368
4038
  )
4369
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4370
- return TeaCore.from_map(
4371
- fc20230330_models.ListFunctionsResponse(),
4372
- self.call_api(params, req, runtime)
4373
- )
4374
- else:
4375
- return TeaCore.from_map(
4376
- fc20230330_models.ListFunctionsResponse(),
4377
- self.execute(params, req, runtime)
4378
- )
4039
+ return TeaCore.from_map(
4040
+ fc20230330_models.ListFunctionsResponse(),
4041
+ self.call_api(params, req, runtime)
4042
+ )
4379
4043
 
4380
4044
  async def list_functions_with_options_async(
4381
4045
  self,
@@ -4403,6 +4067,8 @@ class Client(OpenApiClient):
4403
4067
  query['description'] = request.description
4404
4068
  if not UtilClient.is_unset(request.fc_version):
4405
4069
  query['fcVersion'] = request.fc_version
4070
+ if not UtilClient.is_unset(request.function_name):
4071
+ query['functionName'] = request.function_name
4406
4072
  if not UtilClient.is_unset(request.gpu_type):
4407
4073
  query['gpuType'] = request.gpu_type
4408
4074
  if not UtilClient.is_unset(request.limit):
@@ -4411,6 +4077,8 @@ class Client(OpenApiClient):
4411
4077
  query['nextToken'] = request.next_token
4412
4078
  if not UtilClient.is_unset(request.prefix):
4413
4079
  query['prefix'] = request.prefix
4080
+ if not UtilClient.is_unset(request.resource_group_id):
4081
+ query['resourceGroupId'] = request.resource_group_id
4414
4082
  if not UtilClient.is_unset(request.runtime):
4415
4083
  query['runtime'] = request.runtime
4416
4084
  if not UtilClient.is_unset(request.tags_shrink):
@@ -4430,16 +4098,10 @@ class Client(OpenApiClient):
4430
4098
  req_body_type='json',
4431
4099
  body_type='json'
4432
4100
  )
4433
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4434
- return TeaCore.from_map(
4435
- fc20230330_models.ListFunctionsResponse(),
4436
- await self.call_api_async(params, req, runtime)
4437
- )
4438
- else:
4439
- return TeaCore.from_map(
4440
- fc20230330_models.ListFunctionsResponse(),
4441
- await self.execute_async(params, req, runtime)
4442
- )
4101
+ return TeaCore.from_map(
4102
+ fc20230330_models.ListFunctionsResponse(),
4103
+ await self.call_api_async(params, req, runtime)
4104
+ )
4443
4105
 
4444
4106
  def list_functions(
4445
4107
  self,
@@ -4527,16 +4189,10 @@ class Client(OpenApiClient):
4527
4189
  req_body_type='json',
4528
4190
  body_type='json'
4529
4191
  )
4530
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4531
- return TeaCore.from_map(
4532
- fc20230330_models.ListInstancesResponse(),
4533
- self.call_api(params, req, runtime)
4534
- )
4535
- else:
4536
- return TeaCore.from_map(
4537
- fc20230330_models.ListInstancesResponse(),
4538
- self.execute(params, req, runtime)
4539
- )
4192
+ return TeaCore.from_map(
4193
+ fc20230330_models.ListInstancesResponse(),
4194
+ self.call_api(params, req, runtime)
4195
+ )
4540
4196
 
4541
4197
  async def list_instances_with_options_async(
4542
4198
  self,
@@ -4592,16 +4248,10 @@ class Client(OpenApiClient):
4592
4248
  req_body_type='json',
4593
4249
  body_type='json'
4594
4250
  )
4595
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4596
- return TeaCore.from_map(
4597
- fc20230330_models.ListInstancesResponse(),
4598
- await self.call_api_async(params, req, runtime)
4599
- )
4600
- else:
4601
- return TeaCore.from_map(
4602
- fc20230330_models.ListInstancesResponse(),
4603
- await self.execute_async(params, req, runtime)
4604
- )
4251
+ return TeaCore.from_map(
4252
+ fc20230330_models.ListInstancesResponse(),
4253
+ await self.call_api_async(params, req, runtime)
4254
+ )
4605
4255
 
4606
4256
  def list_instances(
4607
4257
  self,
@@ -4669,16 +4319,10 @@ class Client(OpenApiClient):
4669
4319
  req_body_type='json',
4670
4320
  body_type='json'
4671
4321
  )
4672
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4673
- return TeaCore.from_map(
4674
- fc20230330_models.ListLayerVersionsResponse(),
4675
- self.call_api(params, req, runtime)
4676
- )
4677
- else:
4678
- return TeaCore.from_map(
4679
- fc20230330_models.ListLayerVersionsResponse(),
4680
- self.execute(params, req, runtime)
4681
- )
4322
+ return TeaCore.from_map(
4323
+ fc20230330_models.ListLayerVersionsResponse(),
4324
+ self.call_api(params, req, runtime)
4325
+ )
4682
4326
 
4683
4327
  async def list_layer_versions_with_options_async(
4684
4328
  self,
@@ -4716,16 +4360,10 @@ class Client(OpenApiClient):
4716
4360
  req_body_type='json',
4717
4361
  body_type='json'
4718
4362
  )
4719
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4720
- return TeaCore.from_map(
4721
- fc20230330_models.ListLayerVersionsResponse(),
4722
- await self.call_api_async(params, req, runtime)
4723
- )
4724
- else:
4725
- return TeaCore.from_map(
4726
- fc20230330_models.ListLayerVersionsResponse(),
4727
- await self.execute_async(params, req, runtime)
4728
- )
4363
+ return TeaCore.from_map(
4364
+ fc20230330_models.ListLayerVersionsResponse(),
4365
+ await self.call_api_async(params, req, runtime)
4366
+ )
4729
4367
 
4730
4368
  def list_layer_versions(
4731
4369
  self,
@@ -4798,16 +4436,10 @@ class Client(OpenApiClient):
4798
4436
  req_body_type='json',
4799
4437
  body_type='json'
4800
4438
  )
4801
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4802
- return TeaCore.from_map(
4803
- fc20230330_models.ListLayersResponse(),
4804
- self.call_api(params, req, runtime)
4805
- )
4806
- else:
4807
- return TeaCore.from_map(
4808
- fc20230330_models.ListLayersResponse(),
4809
- self.execute(params, req, runtime)
4810
- )
4439
+ return TeaCore.from_map(
4440
+ fc20230330_models.ListLayersResponse(),
4441
+ self.call_api(params, req, runtime)
4442
+ )
4811
4443
 
4812
4444
  async def list_layers_with_options_async(
4813
4445
  self,
@@ -4850,16 +4482,10 @@ class Client(OpenApiClient):
4850
4482
  req_body_type='json',
4851
4483
  body_type='json'
4852
4484
  )
4853
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4854
- return TeaCore.from_map(
4855
- fc20230330_models.ListLayersResponse(),
4856
- await self.call_api_async(params, req, runtime)
4857
- )
4858
- else:
4859
- return TeaCore.from_map(
4860
- fc20230330_models.ListLayersResponse(),
4861
- await self.execute_async(params, req, runtime)
4862
- )
4485
+ return TeaCore.from_map(
4486
+ fc20230330_models.ListLayersResponse(),
4487
+ await self.call_api_async(params, req, runtime)
4488
+ )
4863
4489
 
4864
4490
  def list_layers(
4865
4491
  self,
@@ -4926,16 +4552,10 @@ class Client(OpenApiClient):
4926
4552
  req_body_type='json',
4927
4553
  body_type='json'
4928
4554
  )
4929
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4930
- return TeaCore.from_map(
4931
- fc20230330_models.ListProvisionConfigsResponse(),
4932
- self.call_api(params, req, runtime)
4933
- )
4934
- else:
4935
- return TeaCore.from_map(
4936
- fc20230330_models.ListProvisionConfigsResponse(),
4937
- self.execute(params, req, runtime)
4938
- )
4555
+ return TeaCore.from_map(
4556
+ fc20230330_models.ListProvisionConfigsResponse(),
4557
+ self.call_api(params, req, runtime)
4558
+ )
4939
4559
 
4940
4560
  async def list_provision_configs_with_options_async(
4941
4561
  self,
@@ -4974,16 +4594,10 @@ class Client(OpenApiClient):
4974
4594
  req_body_type='json',
4975
4595
  body_type='json'
4976
4596
  )
4977
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4978
- return TeaCore.from_map(
4979
- fc20230330_models.ListProvisionConfigsResponse(),
4980
- await self.call_api_async(params, req, runtime)
4981
- )
4982
- else:
4983
- return TeaCore.from_map(
4984
- fc20230330_models.ListProvisionConfigsResponse(),
4985
- await self.execute_async(params, req, runtime)
4986
- )
4597
+ return TeaCore.from_map(
4598
+ fc20230330_models.ListProvisionConfigsResponse(),
4599
+ await self.call_api_async(params, req, runtime)
4600
+ )
4987
4601
 
4988
4602
  def list_provision_configs(
4989
4603
  self,
@@ -5060,16 +4674,10 @@ class Client(OpenApiClient):
5060
4674
  req_body_type='json',
5061
4675
  body_type='json'
5062
4676
  )
5063
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5064
- return TeaCore.from_map(
5065
- fc20230330_models.ListTagResourcesResponse(),
5066
- self.call_api(params, req, runtime)
5067
- )
5068
- else:
5069
- return TeaCore.from_map(
5070
- fc20230330_models.ListTagResourcesResponse(),
5071
- self.execute(params, req, runtime)
5072
- )
4677
+ return TeaCore.from_map(
4678
+ fc20230330_models.ListTagResourcesResponse(),
4679
+ self.call_api(params, req, runtime)
4680
+ )
5073
4681
 
5074
4682
  async def list_tag_resources_with_options_async(
5075
4683
  self,
@@ -5118,16 +4726,10 @@ class Client(OpenApiClient):
5118
4726
  req_body_type='json',
5119
4727
  body_type='json'
5120
4728
  )
5121
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5122
- return TeaCore.from_map(
5123
- fc20230330_models.ListTagResourcesResponse(),
5124
- await self.call_api_async(params, req, runtime)
5125
- )
5126
- else:
5127
- return TeaCore.from_map(
5128
- fc20230330_models.ListTagResourcesResponse(),
5129
- await self.execute_async(params, req, runtime)
5130
- )
4729
+ return TeaCore.from_map(
4730
+ fc20230330_models.ListTagResourcesResponse(),
4731
+ await self.call_api_async(params, req, runtime)
4732
+ )
5131
4733
 
5132
4734
  def list_tag_resources(
5133
4735
  self,
@@ -5195,16 +4797,10 @@ class Client(OpenApiClient):
5195
4797
  req_body_type='json',
5196
4798
  body_type='json'
5197
4799
  )
5198
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5199
- return TeaCore.from_map(
5200
- fc20230330_models.ListTriggersResponse(),
5201
- self.call_api(params, req, runtime)
5202
- )
5203
- else:
5204
- return TeaCore.from_map(
5205
- fc20230330_models.ListTriggersResponse(),
5206
- self.execute(params, req, runtime)
5207
- )
4800
+ return TeaCore.from_map(
4801
+ fc20230330_models.ListTriggersResponse(),
4802
+ self.call_api(params, req, runtime)
4803
+ )
5208
4804
 
5209
4805
  async def list_triggers_with_options_async(
5210
4806
  self,
@@ -5244,16 +4840,10 @@ class Client(OpenApiClient):
5244
4840
  req_body_type='json',
5245
4841
  body_type='json'
5246
4842
  )
5247
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5248
- return TeaCore.from_map(
5249
- fc20230330_models.ListTriggersResponse(),
5250
- await self.call_api_async(params, req, runtime)
5251
- )
5252
- else:
5253
- return TeaCore.from_map(
5254
- fc20230330_models.ListTriggersResponse(),
5255
- await self.execute_async(params, req, runtime)
5256
- )
4843
+ return TeaCore.from_map(
4844
+ fc20230330_models.ListTriggersResponse(),
4845
+ await self.call_api_async(params, req, runtime)
4846
+ )
5257
4847
 
5258
4848
  def list_triggers(
5259
4849
  self,
@@ -5312,16 +4902,10 @@ class Client(OpenApiClient):
5312
4902
  req_body_type='json',
5313
4903
  body_type='json'
5314
4904
  )
5315
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5316
- return TeaCore.from_map(
5317
- fc20230330_models.ListVpcBindingsResponse(),
5318
- self.call_api(params, req, runtime)
5319
- )
5320
- else:
5321
- return TeaCore.from_map(
5322
- fc20230330_models.ListVpcBindingsResponse(),
5323
- self.execute(params, req, runtime)
5324
- )
4905
+ return TeaCore.from_map(
4906
+ fc20230330_models.ListVpcBindingsResponse(),
4907
+ self.call_api(params, req, runtime)
4908
+ )
5325
4909
 
5326
4910
  async def list_vpc_bindings_with_options_async(
5327
4911
  self,
@@ -5350,16 +4934,10 @@ class Client(OpenApiClient):
5350
4934
  req_body_type='json',
5351
4935
  body_type='json'
5352
4936
  )
5353
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5354
- return TeaCore.from_map(
5355
- fc20230330_models.ListVpcBindingsResponse(),
5356
- await self.call_api_async(params, req, runtime)
5357
- )
5358
- else:
5359
- return TeaCore.from_map(
5360
- fc20230330_models.ListVpcBindingsResponse(),
5361
- await self.execute_async(params, req, runtime)
5362
- )
4937
+ return TeaCore.from_map(
4938
+ fc20230330_models.ListVpcBindingsResponse(),
4939
+ await self.call_api_async(params, req, runtime)
4940
+ )
5363
4941
 
5364
4942
  def list_vpc_bindings(
5365
4943
  self,
@@ -5418,16 +4996,10 @@ class Client(OpenApiClient):
5418
4996
  req_body_type='json',
5419
4997
  body_type='json'
5420
4998
  )
5421
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5422
- return TeaCore.from_map(
5423
- fc20230330_models.PublishFunctionVersionResponse(),
5424
- self.call_api(params, req, runtime)
5425
- )
5426
- else:
5427
- return TeaCore.from_map(
5428
- fc20230330_models.PublishFunctionVersionResponse(),
5429
- self.execute(params, req, runtime)
5430
- )
4999
+ return TeaCore.from_map(
5000
+ fc20230330_models.PublishFunctionVersionResponse(),
5001
+ self.call_api(params, req, runtime)
5002
+ )
5431
5003
 
5432
5004
  async def publish_function_version_with_options_async(
5433
5005
  self,
@@ -5460,16 +5032,10 @@ class Client(OpenApiClient):
5460
5032
  req_body_type='json',
5461
5033
  body_type='json'
5462
5034
  )
5463
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5464
- return TeaCore.from_map(
5465
- fc20230330_models.PublishFunctionVersionResponse(),
5466
- await self.call_api_async(params, req, runtime)
5467
- )
5468
- else:
5469
- return TeaCore.from_map(
5470
- fc20230330_models.PublishFunctionVersionResponse(),
5471
- await self.execute_async(params, req, runtime)
5472
- )
5035
+ return TeaCore.from_map(
5036
+ fc20230330_models.PublishFunctionVersionResponse(),
5037
+ await self.call_api_async(params, req, runtime)
5038
+ )
5473
5039
 
5474
5040
  def publish_function_version(
5475
5041
  self,
@@ -5536,16 +5102,10 @@ class Client(OpenApiClient):
5536
5102
  req_body_type='json',
5537
5103
  body_type='json'
5538
5104
  )
5539
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5540
- return TeaCore.from_map(
5541
- fc20230330_models.PutAsyncInvokeConfigResponse(),
5542
- self.call_api(params, req, runtime)
5543
- )
5544
- else:
5545
- return TeaCore.from_map(
5546
- fc20230330_models.PutAsyncInvokeConfigResponse(),
5547
- self.execute(params, req, runtime)
5548
- )
5105
+ return TeaCore.from_map(
5106
+ fc20230330_models.PutAsyncInvokeConfigResponse(),
5107
+ self.call_api(params, req, runtime)
5108
+ )
5549
5109
 
5550
5110
  async def put_async_invoke_config_with_options_async(
5551
5111
  self,
@@ -5582,16 +5142,10 @@ class Client(OpenApiClient):
5582
5142
  req_body_type='json',
5583
5143
  body_type='json'
5584
5144
  )
5585
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5586
- return TeaCore.from_map(
5587
- fc20230330_models.PutAsyncInvokeConfigResponse(),
5588
- await self.call_api_async(params, req, runtime)
5589
- )
5590
- else:
5591
- return TeaCore.from_map(
5592
- fc20230330_models.PutAsyncInvokeConfigResponse(),
5593
- await self.execute_async(params, req, runtime)
5594
- )
5145
+ return TeaCore.from_map(
5146
+ fc20230330_models.PutAsyncInvokeConfigResponse(),
5147
+ await self.call_api_async(params, req, runtime)
5148
+ )
5595
5149
 
5596
5150
  def put_async_invoke_config(
5597
5151
  self,
@@ -5654,16 +5208,10 @@ class Client(OpenApiClient):
5654
5208
  req_body_type='json',
5655
5209
  body_type='json'
5656
5210
  )
5657
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5658
- return TeaCore.from_map(
5659
- fc20230330_models.PutConcurrencyConfigResponse(),
5660
- self.call_api(params, req, runtime)
5661
- )
5662
- else:
5663
- return TeaCore.from_map(
5664
- fc20230330_models.PutConcurrencyConfigResponse(),
5665
- self.execute(params, req, runtime)
5666
- )
5211
+ return TeaCore.from_map(
5212
+ fc20230330_models.PutConcurrencyConfigResponse(),
5213
+ self.call_api(params, req, runtime)
5214
+ )
5667
5215
 
5668
5216
  async def put_concurrency_config_with_options_async(
5669
5217
  self,
@@ -5696,16 +5244,10 @@ class Client(OpenApiClient):
5696
5244
  req_body_type='json',
5697
5245
  body_type='json'
5698
5246
  )
5699
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5700
- return TeaCore.from_map(
5701
- fc20230330_models.PutConcurrencyConfigResponse(),
5702
- await self.call_api_async(params, req, runtime)
5703
- )
5704
- else:
5705
- return TeaCore.from_map(
5706
- fc20230330_models.PutConcurrencyConfigResponse(),
5707
- await self.execute_async(params, req, runtime)
5708
- )
5247
+ return TeaCore.from_map(
5248
+ fc20230330_models.PutConcurrencyConfigResponse(),
5249
+ await self.call_api_async(params, req, runtime)
5250
+ )
5709
5251
 
5710
5252
  def put_concurrency_config(
5711
5253
  self,
@@ -5773,16 +5315,10 @@ class Client(OpenApiClient):
5773
5315
  req_body_type='json',
5774
5316
  body_type='none'
5775
5317
  )
5776
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5777
- return TeaCore.from_map(
5778
- fc20230330_models.PutLayerACLResponse(),
5779
- self.call_api(params, req, runtime)
5780
- )
5781
- else:
5782
- return TeaCore.from_map(
5783
- fc20230330_models.PutLayerACLResponse(),
5784
- self.execute(params, req, runtime)
5785
- )
5318
+ return TeaCore.from_map(
5319
+ fc20230330_models.PutLayerACLResponse(),
5320
+ self.call_api(params, req, runtime)
5321
+ )
5786
5322
 
5787
5323
  async def put_layer_aclwith_options_async(
5788
5324
  self,
@@ -5820,16 +5356,10 @@ class Client(OpenApiClient):
5820
5356
  req_body_type='json',
5821
5357
  body_type='none'
5822
5358
  )
5823
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5824
- return TeaCore.from_map(
5825
- fc20230330_models.PutLayerACLResponse(),
5826
- await self.call_api_async(params, req, runtime)
5827
- )
5828
- else:
5829
- return TeaCore.from_map(
5830
- fc20230330_models.PutLayerACLResponse(),
5831
- await self.execute_async(params, req, runtime)
5832
- )
5359
+ return TeaCore.from_map(
5360
+ fc20230330_models.PutLayerACLResponse(),
5361
+ await self.call_api_async(params, req, runtime)
5362
+ )
5833
5363
 
5834
5364
  def put_layer_acl(
5835
5365
  self,
@@ -5896,16 +5426,10 @@ class Client(OpenApiClient):
5896
5426
  req_body_type='json',
5897
5427
  body_type='json'
5898
5428
  )
5899
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5900
- return TeaCore.from_map(
5901
- fc20230330_models.PutProvisionConfigResponse(),
5902
- self.call_api(params, req, runtime)
5903
- )
5904
- else:
5905
- return TeaCore.from_map(
5906
- fc20230330_models.PutProvisionConfigResponse(),
5907
- self.execute(params, req, runtime)
5908
- )
5429
+ return TeaCore.from_map(
5430
+ fc20230330_models.PutProvisionConfigResponse(),
5431
+ self.call_api(params, req, runtime)
5432
+ )
5909
5433
 
5910
5434
  async def put_provision_config_with_options_async(
5911
5435
  self,
@@ -5942,16 +5466,10 @@ class Client(OpenApiClient):
5942
5466
  req_body_type='json',
5943
5467
  body_type='json'
5944
5468
  )
5945
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5946
- return TeaCore.from_map(
5947
- fc20230330_models.PutProvisionConfigResponse(),
5948
- await self.call_api_async(params, req, runtime)
5949
- )
5950
- else:
5951
- return TeaCore.from_map(
5952
- fc20230330_models.PutProvisionConfigResponse(),
5953
- await self.execute_async(params, req, runtime)
5954
- )
5469
+ return TeaCore.from_map(
5470
+ fc20230330_models.PutProvisionConfigResponse(),
5471
+ await self.call_api_async(params, req, runtime)
5472
+ )
5955
5473
 
5956
5474
  def put_provision_config(
5957
5475
  self,
@@ -6018,16 +5536,10 @@ class Client(OpenApiClient):
6018
5536
  req_body_type='json',
6019
5537
  body_type='none'
6020
5538
  )
6021
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6022
- return TeaCore.from_map(
6023
- fc20230330_models.StopAsyncTaskResponse(),
6024
- self.call_api(params, req, runtime)
6025
- )
6026
- else:
6027
- return TeaCore.from_map(
6028
- fc20230330_models.StopAsyncTaskResponse(),
6029
- self.execute(params, req, runtime)
6030
- )
5539
+ return TeaCore.from_map(
5540
+ fc20230330_models.StopAsyncTaskResponse(),
5541
+ self.call_api(params, req, runtime)
5542
+ )
6031
5543
 
6032
5544
  async def stop_async_task_with_options_async(
6033
5545
  self,
@@ -6064,16 +5576,10 @@ class Client(OpenApiClient):
6064
5576
  req_body_type='json',
6065
5577
  body_type='none'
6066
5578
  )
6067
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6068
- return TeaCore.from_map(
6069
- fc20230330_models.StopAsyncTaskResponse(),
6070
- await self.call_api_async(params, req, runtime)
6071
- )
6072
- else:
6073
- return TeaCore.from_map(
6074
- fc20230330_models.StopAsyncTaskResponse(),
6075
- await self.execute_async(params, req, runtime)
6076
- )
5579
+ return TeaCore.from_map(
5580
+ fc20230330_models.StopAsyncTaskResponse(),
5581
+ await self.call_api_async(params, req, runtime)
5582
+ )
6077
5583
 
6078
5584
  def stop_async_task(
6079
5585
  self,
@@ -6139,16 +5645,10 @@ class Client(OpenApiClient):
6139
5645
  req_body_type='json',
6140
5646
  body_type='none'
6141
5647
  )
6142
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6143
- return TeaCore.from_map(
6144
- fc20230330_models.TagResourcesResponse(),
6145
- self.call_api(params, req, runtime)
6146
- )
6147
- else:
6148
- return TeaCore.from_map(
6149
- fc20230330_models.TagResourcesResponse(),
6150
- self.execute(params, req, runtime)
6151
- )
5648
+ return TeaCore.from_map(
5649
+ fc20230330_models.TagResourcesResponse(),
5650
+ self.call_api(params, req, runtime)
5651
+ )
6152
5652
 
6153
5653
  async def tag_resources_with_options_async(
6154
5654
  self,
@@ -6182,16 +5682,10 @@ class Client(OpenApiClient):
6182
5682
  req_body_type='json',
6183
5683
  body_type='none'
6184
5684
  )
6185
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6186
- return TeaCore.from_map(
6187
- fc20230330_models.TagResourcesResponse(),
6188
- await self.call_api_async(params, req, runtime)
6189
- )
6190
- else:
6191
- return TeaCore.from_map(
6192
- fc20230330_models.TagResourcesResponse(),
6193
- await self.execute_async(params, req, runtime)
6194
- )
5685
+ return TeaCore.from_map(
5686
+ fc20230330_models.TagResourcesResponse(),
5687
+ await self.call_api_async(params, req, runtime)
5688
+ )
6195
5689
 
6196
5690
  def tag_resources(
6197
5691
  self,
@@ -6270,16 +5764,10 @@ class Client(OpenApiClient):
6270
5764
  req_body_type='json',
6271
5765
  body_type='none'
6272
5766
  )
6273
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6274
- return TeaCore.from_map(
6275
- fc20230330_models.UntagResourcesResponse(),
6276
- self.call_api(params, req, runtime)
6277
- )
6278
- else:
6279
- return TeaCore.from_map(
6280
- fc20230330_models.UntagResourcesResponse(),
6281
- self.execute(params, req, runtime)
6282
- )
5767
+ return TeaCore.from_map(
5768
+ fc20230330_models.UntagResourcesResponse(),
5769
+ self.call_api(params, req, runtime)
5770
+ )
6283
5771
 
6284
5772
  async def untag_resources_with_options_async(
6285
5773
  self,
@@ -6326,16 +5814,10 @@ class Client(OpenApiClient):
6326
5814
  req_body_type='json',
6327
5815
  body_type='none'
6328
5816
  )
6329
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6330
- return TeaCore.from_map(
6331
- fc20230330_models.UntagResourcesResponse(),
6332
- await self.call_api_async(params, req, runtime)
6333
- )
6334
- else:
6335
- return TeaCore.from_map(
6336
- fc20230330_models.UntagResourcesResponse(),
6337
- await self.execute_async(params, req, runtime)
6338
- )
5817
+ return TeaCore.from_map(
5818
+ fc20230330_models.UntagResourcesResponse(),
5819
+ await self.call_api_async(params, req, runtime)
5820
+ )
6339
5821
 
6340
5822
  def untag_resources(
6341
5823
  self,
@@ -6397,16 +5879,10 @@ class Client(OpenApiClient):
6397
5879
  req_body_type='json',
6398
5880
  body_type='json'
6399
5881
  )
6400
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6401
- return TeaCore.from_map(
6402
- fc20230330_models.UpdateAliasResponse(),
6403
- self.call_api(params, req, runtime)
6404
- )
6405
- else:
6406
- return TeaCore.from_map(
6407
- fc20230330_models.UpdateAliasResponse(),
6408
- self.execute(params, req, runtime)
6409
- )
5882
+ return TeaCore.from_map(
5883
+ fc20230330_models.UpdateAliasResponse(),
5884
+ self.call_api(params, req, runtime)
5885
+ )
6410
5886
 
6411
5887
  async def update_alias_with_options_async(
6412
5888
  self,
@@ -6440,16 +5916,10 @@ class Client(OpenApiClient):
6440
5916
  req_body_type='json',
6441
5917
  body_type='json'
6442
5918
  )
6443
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6444
- return TeaCore.from_map(
6445
- fc20230330_models.UpdateAliasResponse(),
6446
- await self.call_api_async(params, req, runtime)
6447
- )
6448
- else:
6449
- return TeaCore.from_map(
6450
- fc20230330_models.UpdateAliasResponse(),
6451
- await self.execute_async(params, req, runtime)
6452
- )
5919
+ return TeaCore.from_map(
5920
+ fc20230330_models.UpdateAliasResponse(),
5921
+ await self.call_api_async(params, req, runtime)
5922
+ )
6453
5923
 
6454
5924
  def update_alias(
6455
5925
  self,
@@ -6514,16 +5984,10 @@ class Client(OpenApiClient):
6514
5984
  req_body_type='json',
6515
5985
  body_type='json'
6516
5986
  )
6517
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6518
- return TeaCore.from_map(
6519
- fc20230330_models.UpdateCustomDomainResponse(),
6520
- self.call_api(params, req, runtime)
6521
- )
6522
- else:
6523
- return TeaCore.from_map(
6524
- fc20230330_models.UpdateCustomDomainResponse(),
6525
- self.execute(params, req, runtime)
6526
- )
5987
+ return TeaCore.from_map(
5988
+ fc20230330_models.UpdateCustomDomainResponse(),
5989
+ self.call_api(params, req, runtime)
5990
+ )
6527
5991
 
6528
5992
  async def update_custom_domain_with_options_async(
6529
5993
  self,
@@ -6556,16 +6020,10 @@ class Client(OpenApiClient):
6556
6020
  req_body_type='json',
6557
6021
  body_type='json'
6558
6022
  )
6559
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6560
- return TeaCore.from_map(
6561
- fc20230330_models.UpdateCustomDomainResponse(),
6562
- await self.call_api_async(params, req, runtime)
6563
- )
6564
- else:
6565
- return TeaCore.from_map(
6566
- fc20230330_models.UpdateCustomDomainResponse(),
6567
- await self.execute_async(params, req, runtime)
6568
- )
6023
+ return TeaCore.from_map(
6024
+ fc20230330_models.UpdateCustomDomainResponse(),
6025
+ await self.call_api_async(params, req, runtime)
6026
+ )
6569
6027
 
6570
6028
  def update_custom_domain(
6571
6029
  self,
@@ -6628,16 +6086,10 @@ class Client(OpenApiClient):
6628
6086
  req_body_type='json',
6629
6087
  body_type='json'
6630
6088
  )
6631
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6632
- return TeaCore.from_map(
6633
- fc20230330_models.UpdateFunctionResponse(),
6634
- self.call_api(params, req, runtime)
6635
- )
6636
- else:
6637
- return TeaCore.from_map(
6638
- fc20230330_models.UpdateFunctionResponse(),
6639
- self.execute(params, req, runtime)
6640
- )
6089
+ return TeaCore.from_map(
6090
+ fc20230330_models.UpdateFunctionResponse(),
6091
+ self.call_api(params, req, runtime)
6092
+ )
6641
6093
 
6642
6094
  async def update_function_with_options_async(
6643
6095
  self,
@@ -6670,16 +6122,10 @@ class Client(OpenApiClient):
6670
6122
  req_body_type='json',
6671
6123
  body_type='json'
6672
6124
  )
6673
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6674
- return TeaCore.from_map(
6675
- fc20230330_models.UpdateFunctionResponse(),
6676
- await self.call_api_async(params, req, runtime)
6677
- )
6678
- else:
6679
- return TeaCore.from_map(
6680
- fc20230330_models.UpdateFunctionResponse(),
6681
- await self.execute_async(params, req, runtime)
6682
- )
6125
+ return TeaCore.from_map(
6126
+ fc20230330_models.UpdateFunctionResponse(),
6127
+ await self.call_api_async(params, req, runtime)
6128
+ )
6683
6129
 
6684
6130
  def update_function(
6685
6131
  self,
@@ -6743,16 +6189,10 @@ class Client(OpenApiClient):
6743
6189
  req_body_type='json',
6744
6190
  body_type='json'
6745
6191
  )
6746
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6747
- return TeaCore.from_map(
6748
- fc20230330_models.UpdateTriggerResponse(),
6749
- self.call_api(params, req, runtime)
6750
- )
6751
- else:
6752
- return TeaCore.from_map(
6753
- fc20230330_models.UpdateTriggerResponse(),
6754
- self.execute(params, req, runtime)
6755
- )
6192
+ return TeaCore.from_map(
6193
+ fc20230330_models.UpdateTriggerResponse(),
6194
+ self.call_api(params, req, runtime)
6195
+ )
6756
6196
 
6757
6197
  async def update_trigger_with_options_async(
6758
6198
  self,
@@ -6786,16 +6226,10 @@ class Client(OpenApiClient):
6786
6226
  req_body_type='json',
6787
6227
  body_type='json'
6788
6228
  )
6789
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6790
- return TeaCore.from_map(
6791
- fc20230330_models.UpdateTriggerResponse(),
6792
- await self.call_api_async(params, req, runtime)
6793
- )
6794
- else:
6795
- return TeaCore.from_map(
6796
- fc20230330_models.UpdateTriggerResponse(),
6797
- await self.execute_async(params, req, runtime)
6798
- )
6229
+ return TeaCore.from_map(
6230
+ fc20230330_models.UpdateTriggerResponse(),
6231
+ await self.call_api_async(params, req, runtime)
6232
+ )
6799
6233
 
6800
6234
  def update_trigger(
6801
6235
  self,