alibabacloud-fc20230330 4.2.2__py3-none-any.whl → 4.2.3__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 +448 -1120
  3. alibabacloud_fc20230330/models.py +102 -102
  4. {alibabacloud_fc20230330-4.2.2.dist-info → alibabacloud_fc20230330-4.2.3.dist-info}/METADATA +2 -2
  5. alibabacloud_fc20230330-4.2.3.dist-info/RECORD +8 -0
  6. alibabacloud_fc20230330-4.2.2.dist-info/RECORD +0 -8
  7. {alibabacloud_fc20230330-4.2.2.dist-info → alibabacloud_fc20230330-4.2.3.dist-info}/LICENSE +0 -0
  8. {alibabacloud_fc20230330-4.2.2.dist-info → alibabacloud_fc20230330-4.2.3.dist-info}/WHEEL +0 -0
  9. {alibabacloud_fc20230330-4.2.2.dist-info → alibabacloud_fc20230330-4.2.3.dist-info}/top_level.txt +0 -0
alibabacloud_fc20230330/client.py CHANGED
@@ -72,16 +72,10 @@ class Client(OpenApiClient):
72
72
  req_body_type='json',
73
73
  body_type='json'
74
74
  )
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
- )
75
+ return TeaCore.from_map(
76
+ fc20230330_models.CreateAliasResponse(),
77
+ self.call_api(params, req, runtime)
78
+ )
85
79
 
86
80
  async def create_alias_with_options_async(
87
81
  self,
@@ -114,16 +108,10 @@ class Client(OpenApiClient):
114
108
  req_body_type='json',
115
109
  body_type='json'
116
110
  )
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
- )
111
+ return TeaCore.from_map(
112
+ fc20230330_models.CreateAliasResponse(),
113
+ await self.call_api_async(params, req, runtime)
114
+ )
127
115
 
128
116
  def create_alias(
129
117
  self,
@@ -187,16 +175,10 @@ class Client(OpenApiClient):
187
175
  req_body_type='json',
188
176
  body_type='json'
189
177
  )
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
- )
178
+ return TeaCore.from_map(
179
+ fc20230330_models.CreateCustomDomainResponse(),
180
+ self.call_api(params, req, runtime)
181
+ )
200
182
 
201
183
  async def create_custom_domain_with_options_async(
202
184
  self,
@@ -230,16 +212,10 @@ class Client(OpenApiClient):
230
212
  req_body_type='json',
231
213
  body_type='json'
232
214
  )
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
- )
215
+ return TeaCore.from_map(
216
+ fc20230330_models.CreateCustomDomainResponse(),
217
+ await self.call_api_async(params, req, runtime)
218
+ )
243
219
 
244
220
  def create_custom_domain(
245
221
  self,
@@ -305,16 +281,10 @@ class Client(OpenApiClient):
305
281
  req_body_type='json',
306
282
  body_type='json'
307
283
  )
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
- )
284
+ return TeaCore.from_map(
285
+ fc20230330_models.CreateFunctionResponse(),
286
+ self.call_api(params, req, runtime)
287
+ )
318
288
 
319
289
  async def create_function_with_options_async(
320
290
  self,
@@ -348,16 +318,10 @@ class Client(OpenApiClient):
348
318
  req_body_type='json',
349
319
  body_type='json'
350
320
  )
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
- )
321
+ return TeaCore.from_map(
322
+ fc20230330_models.CreateFunctionResponse(),
323
+ await self.call_api_async(params, req, runtime)
324
+ )
361
325
 
362
326
  def create_function(
363
327
  self,
@@ -422,16 +386,10 @@ class Client(OpenApiClient):
422
386
  req_body_type='json',
423
387
  body_type='json'
424
388
  )
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
- )
389
+ return TeaCore.from_map(
390
+ fc20230330_models.CreateLayerVersionResponse(),
391
+ self.call_api(params, req, runtime)
392
+ )
435
393
 
436
394
  async def create_layer_version_with_options_async(
437
395
  self,
@@ -464,16 +422,10 @@ class Client(OpenApiClient):
464
422
  req_body_type='json',
465
423
  body_type='json'
466
424
  )
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
- )
425
+ return TeaCore.from_map(
426
+ fc20230330_models.CreateLayerVersionResponse(),
427
+ await self.call_api_async(params, req, runtime)
428
+ )
477
429
 
478
430
  def create_layer_version(
479
431
  self,
@@ -536,16 +488,10 @@ class Client(OpenApiClient):
536
488
  req_body_type='json',
537
489
  body_type='json'
538
490
  )
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
- )
491
+ return TeaCore.from_map(
492
+ fc20230330_models.CreateTriggerResponse(),
493
+ self.call_api(params, req, runtime)
494
+ )
549
495
 
550
496
  async def create_trigger_with_options_async(
551
497
  self,
@@ -578,16 +524,10 @@ class Client(OpenApiClient):
578
524
  req_body_type='json',
579
525
  body_type='json'
580
526
  )
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
- )
527
+ return TeaCore.from_map(
528
+ fc20230330_models.CreateTriggerResponse(),
529
+ await self.call_api_async(params, req, runtime)
530
+ )
591
531
 
592
532
  def create_trigger(
593
533
  self,
@@ -650,16 +590,10 @@ class Client(OpenApiClient):
650
590
  req_body_type='json',
651
591
  body_type='none'
652
592
  )
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
- )
593
+ return TeaCore.from_map(
594
+ fc20230330_models.CreateVpcBindingResponse(),
595
+ self.call_api(params, req, runtime)
596
+ )
663
597
 
664
598
  async def create_vpc_binding_with_options_async(
665
599
  self,
@@ -692,16 +626,10 @@ class Client(OpenApiClient):
692
626
  req_body_type='json',
693
627
  body_type='none'
694
628
  )
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
- )
629
+ return TeaCore.from_map(
630
+ fc20230330_models.CreateVpcBindingResponse(),
631
+ await self.call_api_async(params, req, runtime)
632
+ )
705
633
 
706
634
  def create_vpc_binding(
707
635
  self,
@@ -761,16 +689,10 @@ class Client(OpenApiClient):
761
689
  req_body_type='json',
762
690
  body_type='none'
763
691
  )
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
- )
692
+ return TeaCore.from_map(
693
+ fc20230330_models.DeleteAliasResponse(),
694
+ self.call_api(params, req, runtime)
695
+ )
774
696
 
775
697
  async def delete_alias_with_options_async(
776
698
  self,
@@ -800,16 +722,10 @@ class Client(OpenApiClient):
800
722
  req_body_type='json',
801
723
  body_type='none'
802
724
  )
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
- )
725
+ return TeaCore.from_map(
726
+ fc20230330_models.DeleteAliasResponse(),
727
+ await self.call_api_async(params, req, runtime)
728
+ )
813
729
 
814
730
  def delete_alias(
815
731
  self,
@@ -873,16 +789,10 @@ class Client(OpenApiClient):
873
789
  req_body_type='json',
874
790
  body_type='none'
875
791
  )
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
- )
792
+ return TeaCore.from_map(
793
+ fc20230330_models.DeleteAsyncInvokeConfigResponse(),
794
+ self.call_api(params, req, runtime)
795
+ )
886
796
 
887
797
  async def delete_async_invoke_config_with_options_async(
888
798
  self,
@@ -918,16 +828,10 @@ class Client(OpenApiClient):
918
828
  req_body_type='json',
919
829
  body_type='none'
920
830
  )
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
- )
831
+ return TeaCore.from_map(
832
+ fc20230330_models.DeleteAsyncInvokeConfigResponse(),
833
+ await self.call_api_async(params, req, runtime)
834
+ )
931
835
 
932
836
  def delete_async_invoke_config(
933
837
  self,
@@ -986,16 +890,10 @@ class Client(OpenApiClient):
986
890
  req_body_type='json',
987
891
  body_type='none'
988
892
  )
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
- )
893
+ return TeaCore.from_map(
894
+ fc20230330_models.DeleteConcurrencyConfigResponse(),
895
+ self.call_api(params, req, runtime)
896
+ )
999
897
 
1000
898
  async def delete_concurrency_config_with_options_async(
1001
899
  self,
@@ -1024,16 +922,10 @@ class Client(OpenApiClient):
1024
922
  req_body_type='json',
1025
923
  body_type='none'
1026
924
  )
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
- )
925
+ return TeaCore.from_map(
926
+ fc20230330_models.DeleteConcurrencyConfigResponse(),
927
+ await self.call_api_async(params, req, runtime)
928
+ )
1037
929
 
1038
930
  def delete_concurrency_config(
1039
931
  self,
@@ -1088,16 +980,10 @@ class Client(OpenApiClient):
1088
980
  req_body_type='json',
1089
981
  body_type='none'
1090
982
  )
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
- )
983
+ return TeaCore.from_map(
984
+ fc20230330_models.DeleteCustomDomainResponse(),
985
+ self.call_api(params, req, runtime)
986
+ )
1101
987
 
1102
988
  async def delete_custom_domain_with_options_async(
1103
989
  self,
@@ -1126,16 +1012,10 @@ class Client(OpenApiClient):
1126
1012
  req_body_type='json',
1127
1013
  body_type='none'
1128
1014
  )
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
- )
1015
+ return TeaCore.from_map(
1016
+ fc20230330_models.DeleteCustomDomainResponse(),
1017
+ await self.call_api_async(params, req, runtime)
1018
+ )
1139
1019
 
1140
1020
  def delete_custom_domain(
1141
1021
  self,
@@ -1190,16 +1070,10 @@ class Client(OpenApiClient):
1190
1070
  req_body_type='json',
1191
1071
  body_type='none'
1192
1072
  )
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
- )
1073
+ return TeaCore.from_map(
1074
+ fc20230330_models.DeleteFunctionResponse(),
1075
+ self.call_api(params, req, runtime)
1076
+ )
1203
1077
 
1204
1078
  async def delete_function_with_options_async(
1205
1079
  self,
@@ -1228,16 +1102,10 @@ class Client(OpenApiClient):
1228
1102
  req_body_type='json',
1229
1103
  body_type='none'
1230
1104
  )
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
- )
1105
+ return TeaCore.from_map(
1106
+ fc20230330_models.DeleteFunctionResponse(),
1107
+ await self.call_api_async(params, req, runtime)
1108
+ )
1241
1109
 
1242
1110
  def delete_function(
1243
1111
  self,
@@ -1293,16 +1161,10 @@ class Client(OpenApiClient):
1293
1161
  req_body_type='json',
1294
1162
  body_type='none'
1295
1163
  )
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
- )
1164
+ return TeaCore.from_map(
1165
+ fc20230330_models.DeleteFunctionVersionResponse(),
1166
+ self.call_api(params, req, runtime)
1167
+ )
1306
1168
 
1307
1169
  async def delete_function_version_with_options_async(
1308
1170
  self,
@@ -1332,16 +1194,10 @@ class Client(OpenApiClient):
1332
1194
  req_body_type='json',
1333
1195
  body_type='none'
1334
1196
  )
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
- )
1197
+ return TeaCore.from_map(
1198
+ fc20230330_models.DeleteFunctionVersionResponse(),
1199
+ await self.call_api_async(params, req, runtime)
1200
+ )
1345
1201
 
1346
1202
  def delete_function_version(
1347
1203
  self,
@@ -1399,16 +1255,10 @@ class Client(OpenApiClient):
1399
1255
  req_body_type='json',
1400
1256
  body_type='none'
1401
1257
  )
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
- )
1258
+ return TeaCore.from_map(
1259
+ fc20230330_models.DeleteLayerVersionResponse(),
1260
+ self.call_api(params, req, runtime)
1261
+ )
1412
1262
 
1413
1263
  async def delete_layer_version_with_options_async(
1414
1264
  self,
@@ -1438,16 +1288,10 @@ class Client(OpenApiClient):
1438
1288
  req_body_type='json',
1439
1289
  body_type='none'
1440
1290
  )
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
- )
1291
+ return TeaCore.from_map(
1292
+ fc20230330_models.DeleteLayerVersionResponse(),
1293
+ await self.call_api_async(params, req, runtime)
1294
+ )
1451
1295
 
1452
1296
  def delete_layer_version(
1453
1297
  self,
@@ -1511,16 +1355,10 @@ class Client(OpenApiClient):
1511
1355
  req_body_type='json',
1512
1356
  body_type='none'
1513
1357
  )
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
- )
1358
+ return TeaCore.from_map(
1359
+ fc20230330_models.DeleteProvisionConfigResponse(),
1360
+ self.call_api(params, req, runtime)
1361
+ )
1524
1362
 
1525
1363
  async def delete_provision_config_with_options_async(
1526
1364
  self,
@@ -1556,16 +1394,10 @@ class Client(OpenApiClient):
1556
1394
  req_body_type='json',
1557
1395
  body_type='none'
1558
1396
  )
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
- )
1397
+ return TeaCore.from_map(
1398
+ fc20230330_models.DeleteProvisionConfigResponse(),
1399
+ await self.call_api_async(params, req, runtime)
1400
+ )
1569
1401
 
1570
1402
  def delete_provision_config(
1571
1403
  self,
@@ -1625,16 +1457,10 @@ class Client(OpenApiClient):
1625
1457
  req_body_type='json',
1626
1458
  body_type='none'
1627
1459
  )
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
- )
1460
+ return TeaCore.from_map(
1461
+ fc20230330_models.DeleteTriggerResponse(),
1462
+ self.call_api(params, req, runtime)
1463
+ )
1638
1464
 
1639
1465
  async def delete_trigger_with_options_async(
1640
1466
  self,
@@ -1664,16 +1490,10 @@ class Client(OpenApiClient):
1664
1490
  req_body_type='json',
1665
1491
  body_type='none'
1666
1492
  )
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
- )
1493
+ return TeaCore.from_map(
1494
+ fc20230330_models.DeleteTriggerResponse(),
1495
+ await self.call_api_async(params, req, runtime)
1496
+ )
1677
1497
 
1678
1498
  def delete_trigger(
1679
1499
  self,
@@ -1731,16 +1551,10 @@ class Client(OpenApiClient):
1731
1551
  req_body_type='json',
1732
1552
  body_type='none'
1733
1553
  )
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
- )
1554
+ return TeaCore.from_map(
1555
+ fc20230330_models.DeleteVpcBindingResponse(),
1556
+ self.call_api(params, req, runtime)
1557
+ )
1744
1558
 
1745
1559
  async def delete_vpc_binding_with_options_async(
1746
1560
  self,
@@ -1770,16 +1584,10 @@ class Client(OpenApiClient):
1770
1584
  req_body_type='json',
1771
1585
  body_type='none'
1772
1586
  )
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
- )
1587
+ return TeaCore.from_map(
1588
+ fc20230330_models.DeleteVpcBindingResponse(),
1589
+ await self.call_api_async(params, req, runtime)
1590
+ )
1783
1591
 
1784
1592
  def delete_vpc_binding(
1785
1593
  self,
@@ -1842,16 +1650,10 @@ class Client(OpenApiClient):
1842
1650
  req_body_type='json',
1843
1651
  body_type='json'
1844
1652
  )
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
- )
1653
+ return TeaCore.from_map(
1654
+ fc20230330_models.DescribeRegionsResponse(),
1655
+ self.call_api(params, req, runtime)
1656
+ )
1855
1657
 
1856
1658
  async def describe_regions_with_options_async(
1857
1659
  self,
@@ -1886,16 +1688,10 @@ class Client(OpenApiClient):
1886
1688
  req_body_type='json',
1887
1689
  body_type='json'
1888
1690
  )
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
- )
1691
+ return TeaCore.from_map(
1692
+ fc20230330_models.DescribeRegionsResponse(),
1693
+ await self.call_api_async(params, req, runtime)
1694
+ )
1899
1695
 
1900
1696
  def describe_regions(
1901
1697
  self,
@@ -1963,16 +1759,10 @@ class Client(OpenApiClient):
1963
1759
  req_body_type='json',
1964
1760
  body_type='json'
1965
1761
  )
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
- )
1762
+ return TeaCore.from_map(
1763
+ fc20230330_models.DisableFunctionInvocationResponse(),
1764
+ self.call_api(params, req, runtime)
1765
+ )
1976
1766
 
1977
1767
  async def disable_function_invocation_with_options_async(
1978
1768
  self,
@@ -2012,16 +1802,10 @@ class Client(OpenApiClient):
2012
1802
  req_body_type='json',
2013
1803
  body_type='json'
2014
1804
  )
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
- )
1805
+ return TeaCore.from_map(
1806
+ fc20230330_models.DisableFunctionInvocationResponse(),
1807
+ await self.call_api_async(params, req, runtime)
1808
+ )
2025
1809
 
2026
1810
  def disable_function_invocation(
2027
1811
  self,
@@ -2084,16 +1868,10 @@ class Client(OpenApiClient):
2084
1868
  req_body_type='json',
2085
1869
  body_type='json'
2086
1870
  )
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
- )
1871
+ return TeaCore.from_map(
1872
+ fc20230330_models.EnableFunctionInvocationResponse(),
1873
+ self.call_api(params, req, runtime)
1874
+ )
2097
1875
 
2098
1876
  async def enable_function_invocation_with_options_async(
2099
1877
  self,
@@ -2122,16 +1900,10 @@ class Client(OpenApiClient):
2122
1900
  req_body_type='json',
2123
1901
  body_type='json'
2124
1902
  )
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
- )
1903
+ return TeaCore.from_map(
1904
+ fc20230330_models.EnableFunctionInvocationResponse(),
1905
+ await self.call_api_async(params, req, runtime)
1906
+ )
2135
1907
 
2136
1908
  def enable_function_invocation(
2137
1909
  self,
@@ -2187,16 +1959,10 @@ class Client(OpenApiClient):
2187
1959
  req_body_type='json',
2188
1960
  body_type='json'
2189
1961
  )
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
- )
1962
+ return TeaCore.from_map(
1963
+ fc20230330_models.GetAliasResponse(),
1964
+ self.call_api(params, req, runtime)
1965
+ )
2200
1966
 
2201
1967
  async def get_alias_with_options_async(
2202
1968
  self,
@@ -2226,16 +1992,10 @@ class Client(OpenApiClient):
2226
1992
  req_body_type='json',
2227
1993
  body_type='json'
2228
1994
  )
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
- )
1995
+ return TeaCore.from_map(
1996
+ fc20230330_models.GetAliasResponse(),
1997
+ await self.call_api_async(params, req, runtime)
1998
+ )
2239
1999
 
2240
2000
  def get_alias(
2241
2001
  self,
@@ -2299,16 +2059,10 @@ class Client(OpenApiClient):
2299
2059
  req_body_type='json',
2300
2060
  body_type='json'
2301
2061
  )
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
- )
2062
+ return TeaCore.from_map(
2063
+ fc20230330_models.GetAsyncInvokeConfigResponse(),
2064
+ self.call_api(params, req, runtime)
2065
+ )
2312
2066
 
2313
2067
  async def get_async_invoke_config_with_options_async(
2314
2068
  self,
@@ -2344,16 +2098,10 @@ class Client(OpenApiClient):
2344
2098
  req_body_type='json',
2345
2099
  body_type='json'
2346
2100
  )
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
- )
2101
+ return TeaCore.from_map(
2102
+ fc20230330_models.GetAsyncInvokeConfigResponse(),
2103
+ await self.call_api_async(params, req, runtime)
2104
+ )
2357
2105
 
2358
2106
  def get_async_invoke_config(
2359
2107
  self,
@@ -2420,16 +2168,10 @@ class Client(OpenApiClient):
2420
2168
  req_body_type='json',
2421
2169
  body_type='json'
2422
2170
  )
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
- )
2171
+ return TeaCore.from_map(
2172
+ fc20230330_models.GetAsyncTaskResponse(),
2173
+ self.call_api(params, req, runtime)
2174
+ )
2433
2175
 
2434
2176
  async def get_async_task_with_options_async(
2435
2177
  self,
@@ -2466,16 +2208,10 @@ class Client(OpenApiClient):
2466
2208
  req_body_type='json',
2467
2209
  body_type='json'
2468
2210
  )
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
- )
2211
+ return TeaCore.from_map(
2212
+ fc20230330_models.GetAsyncTaskResponse(),
2213
+ await self.call_api_async(params, req, runtime)
2214
+ )
2479
2215
 
2480
2216
  def get_async_task(
2481
2217
  self,
@@ -2536,16 +2272,10 @@ class Client(OpenApiClient):
2536
2272
  req_body_type='json',
2537
2273
  body_type='json'
2538
2274
  )
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
- )
2275
+ return TeaCore.from_map(
2276
+ fc20230330_models.GetConcurrencyConfigResponse(),
2277
+ self.call_api(params, req, runtime)
2278
+ )
2549
2279
 
2550
2280
  async def get_concurrency_config_with_options_async(
2551
2281
  self,
@@ -2574,16 +2304,10 @@ class Client(OpenApiClient):
2574
2304
  req_body_type='json',
2575
2305
  body_type='json'
2576
2306
  )
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
- )
2307
+ return TeaCore.from_map(
2308
+ fc20230330_models.GetConcurrencyConfigResponse(),
2309
+ await self.call_api_async(params, req, runtime)
2310
+ )
2587
2311
 
2588
2312
  def get_concurrency_config(
2589
2313
  self,
@@ -2638,16 +2362,10 @@ class Client(OpenApiClient):
2638
2362
  req_body_type='json',
2639
2363
  body_type='json'
2640
2364
  )
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
- )
2365
+ return TeaCore.from_map(
2366
+ fc20230330_models.GetCustomDomainResponse(),
2367
+ self.call_api(params, req, runtime)
2368
+ )
2651
2369
 
2652
2370
  async def get_custom_domain_with_options_async(
2653
2371
  self,
@@ -2676,16 +2394,10 @@ class Client(OpenApiClient):
2676
2394
  req_body_type='json',
2677
2395
  body_type='json'
2678
2396
  )
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
- )
2397
+ return TeaCore.from_map(
2398
+ fc20230330_models.GetCustomDomainResponse(),
2399
+ await self.call_api_async(params, req, runtime)
2400
+ )
2689
2401
 
2690
2402
  def get_custom_domain(
2691
2403
  self,
@@ -2747,16 +2459,10 @@ class Client(OpenApiClient):
2747
2459
  req_body_type='json',
2748
2460
  body_type='json'
2749
2461
  )
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
- )
2462
+ return TeaCore.from_map(
2463
+ fc20230330_models.GetFunctionResponse(),
2464
+ self.call_api(params, req, runtime)
2465
+ )
2760
2466
 
2761
2467
  async def get_function_with_options_async(
2762
2468
  self,
@@ -2792,16 +2498,10 @@ class Client(OpenApiClient):
2792
2498
  req_body_type='json',
2793
2499
  body_type='json'
2794
2500
  )
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
- )
2501
+ return TeaCore.from_map(
2502
+ fc20230330_models.GetFunctionResponse(),
2503
+ await self.call_api_async(params, req, runtime)
2504
+ )
2805
2505
 
2806
2506
  def get_function(
2807
2507
  self,
@@ -2867,16 +2567,10 @@ class Client(OpenApiClient):
2867
2567
  req_body_type='json',
2868
2568
  body_type='json'
2869
2569
  )
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
- )
2570
+ return TeaCore.from_map(
2571
+ fc20230330_models.GetFunctionCodeResponse(),
2572
+ self.call_api(params, req, runtime)
2573
+ )
2880
2574
 
2881
2575
  async def get_function_code_with_options_async(
2882
2576
  self,
@@ -2912,16 +2606,10 @@ class Client(OpenApiClient):
2912
2606
  req_body_type='json',
2913
2607
  body_type='json'
2914
2608
  )
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
- )
2609
+ return TeaCore.from_map(
2610
+ fc20230330_models.GetFunctionCodeResponse(),
2611
+ await self.call_api_async(params, req, runtime)
2612
+ )
2925
2613
 
2926
2614
  def get_function_code(
2927
2615
  self,
@@ -2981,16 +2669,10 @@ class Client(OpenApiClient):
2981
2669
  req_body_type='json',
2982
2670
  body_type='json'
2983
2671
  )
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
- )
2672
+ return TeaCore.from_map(
2673
+ fc20230330_models.GetLayerVersionResponse(),
2674
+ self.call_api(params, req, runtime)
2675
+ )
2994
2676
 
2995
2677
  async def get_layer_version_with_options_async(
2996
2678
  self,
@@ -3020,16 +2702,10 @@ class Client(OpenApiClient):
3020
2702
  req_body_type='json',
3021
2703
  body_type='json'
3022
2704
  )
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
- )
2705
+ return TeaCore.from_map(
2706
+ fc20230330_models.GetLayerVersionResponse(),
2707
+ await self.call_api_async(params, req, runtime)
2708
+ )
3033
2709
 
3034
2710
  def get_layer_version(
3035
2711
  self,
@@ -3086,16 +2762,10 @@ class Client(OpenApiClient):
3086
2762
  req_body_type='json',
3087
2763
  body_type='json'
3088
2764
  )
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
- )
2765
+ return TeaCore.from_map(
2766
+ fc20230330_models.GetLayerVersionByArnResponse(),
2767
+ self.call_api(params, req, runtime)
2768
+ )
3099
2769
 
3100
2770
  async def get_layer_version_by_arn_with_options_async(
3101
2771
  self,
@@ -3124,16 +2794,10 @@ class Client(OpenApiClient):
3124
2794
  req_body_type='json',
3125
2795
  body_type='json'
3126
2796
  )
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
- )
2797
+ return TeaCore.from_map(
2798
+ fc20230330_models.GetLayerVersionByArnResponse(),
2799
+ await self.call_api_async(params, req, runtime)
2800
+ )
3137
2801
 
3138
2802
  def get_layer_version_by_arn(
3139
2803
  self,
@@ -3195,16 +2859,10 @@ class Client(OpenApiClient):
3195
2859
  req_body_type='json',
3196
2860
  body_type='json'
3197
2861
  )
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
- )
2862
+ return TeaCore.from_map(
2863
+ fc20230330_models.GetProvisionConfigResponse(),
2864
+ self.call_api(params, req, runtime)
2865
+ )
3208
2866
 
3209
2867
  async def get_provision_config_with_options_async(
3210
2868
  self,
@@ -3240,16 +2898,10 @@ class Client(OpenApiClient):
3240
2898
  req_body_type='json',
3241
2899
  body_type='json'
3242
2900
  )
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
- )
2901
+ return TeaCore.from_map(
2902
+ fc20230330_models.GetProvisionConfigResponse(),
2903
+ await self.call_api_async(params, req, runtime)
2904
+ )
3253
2905
 
3254
2906
  def get_provision_config(
3255
2907
  self,
@@ -3309,16 +2961,10 @@ class Client(OpenApiClient):
3309
2961
  req_body_type='json',
3310
2962
  body_type='json'
3311
2963
  )
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
- )
2964
+ return TeaCore.from_map(
2965
+ fc20230330_models.GetTriggerResponse(),
2966
+ self.call_api(params, req, runtime)
2967
+ )
3322
2968
 
3323
2969
  async def get_trigger_with_options_async(
3324
2970
  self,
@@ -3348,16 +2994,10 @@ class Client(OpenApiClient):
3348
2994
  req_body_type='json',
3349
2995
  body_type='json'
3350
2996
  )
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
- )
2997
+ return TeaCore.from_map(
2998
+ fc20230330_models.GetTriggerResponse(),
2999
+ await self.call_api_async(params, req, runtime)
3000
+ )
3361
3001
 
3362
3002
  def get_trigger(
3363
3003
  self,
@@ -3571,16 +3211,10 @@ class Client(OpenApiClient):
3571
3211
  req_body_type='json',
3572
3212
  body_type='json'
3573
3213
  )
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
- )
3214
+ return TeaCore.from_map(
3215
+ fc20230330_models.ListAliasesResponse(),
3216
+ self.call_api(params, req, runtime)
3217
+ )
3584
3218
 
3585
3219
  async def list_aliases_with_options_async(
3586
3220
  self,
@@ -3620,16 +3254,10 @@ class Client(OpenApiClient):
3620
3254
  req_body_type='json',
3621
3255
  body_type='json'
3622
3256
  )
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
- )
3257
+ return TeaCore.from_map(
3258
+ fc20230330_models.ListAliasesResponse(),
3259
+ await self.call_api_async(params, req, runtime)
3260
+ )
3633
3261
 
3634
3262
  def list_aliases(
3635
3263
  self,
@@ -3698,16 +3326,10 @@ class Client(OpenApiClient):
3698
3326
  req_body_type='json',
3699
3327
  body_type='json'
3700
3328
  )
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
- )
3329
+ return TeaCore.from_map(
3330
+ fc20230330_models.ListAsyncInvokeConfigsResponse(),
3331
+ self.call_api(params, req, runtime)
3332
+ )
3711
3333
 
3712
3334
  async def list_async_invoke_configs_with_options_async(
3713
3335
  self,
@@ -3746,16 +3368,10 @@ class Client(OpenApiClient):
3746
3368
  req_body_type='json',
3747
3369
  body_type='json'
3748
3370
  )
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
- )
3371
+ return TeaCore.from_map(
3372
+ fc20230330_models.ListAsyncInvokeConfigsResponse(),
3373
+ await self.call_api_async(params, req, runtime)
3374
+ )
3759
3375
 
3760
3376
  def list_async_invoke_configs(
3761
3377
  self,
@@ -3835,16 +3451,10 @@ class Client(OpenApiClient):
3835
3451
  req_body_type='json',
3836
3452
  body_type='json'
3837
3453
  )
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
- )
3454
+ return TeaCore.from_map(
3455
+ fc20230330_models.ListAsyncTasksResponse(),
3456
+ self.call_api(params, req, runtime)
3457
+ )
3848
3458
 
3849
3459
  async def list_async_tasks_with_options_async(
3850
3460
  self,
@@ -3896,16 +3506,10 @@ class Client(OpenApiClient):
3896
3506
  req_body_type='json',
3897
3507
  body_type='json'
3898
3508
  )
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
- )
3509
+ return TeaCore.from_map(
3510
+ fc20230330_models.ListAsyncTasksResponse(),
3511
+ await self.call_api_async(params, req, runtime)
3512
+ )
3909
3513
 
3910
3514
  def list_async_tasks(
3911
3515
  self,
@@ -3974,16 +3578,10 @@ class Client(OpenApiClient):
3974
3578
  req_body_type='json',
3975
3579
  body_type='json'
3976
3580
  )
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
- )
3581
+ return TeaCore.from_map(
3582
+ fc20230330_models.ListConcurrencyConfigsResponse(),
3583
+ self.call_api(params, req, runtime)
3584
+ )
3987
3585
 
3988
3586
  async def list_concurrency_configs_with_options_async(
3989
3587
  self,
@@ -4022,16 +3620,10 @@ class Client(OpenApiClient):
4022
3620
  req_body_type='json',
4023
3621
  body_type='json'
4024
3622
  )
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
- )
3623
+ return TeaCore.from_map(
3624
+ fc20230330_models.ListConcurrencyConfigsResponse(),
3625
+ await self.call_api_async(params, req, runtime)
3626
+ )
4035
3627
 
4036
3628
  def list_concurrency_configs(
4037
3629
  self,
@@ -4098,16 +3690,10 @@ class Client(OpenApiClient):
4098
3690
  req_body_type='json',
4099
3691
  body_type='json'
4100
3692
  )
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
- )
3693
+ return TeaCore.from_map(
3694
+ fc20230330_models.ListCustomDomainsResponse(),
3695
+ self.call_api(params, req, runtime)
3696
+ )
4111
3697
 
4112
3698
  async def list_custom_domains_with_options_async(
4113
3699
  self,
@@ -4146,16 +3732,10 @@ class Client(OpenApiClient):
4146
3732
  req_body_type='json',
4147
3733
  body_type='json'
4148
3734
  )
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
- )
3735
+ return TeaCore.from_map(
3736
+ fc20230330_models.ListCustomDomainsResponse(),
3737
+ await self.call_api_async(params, req, runtime)
3738
+ )
4159
3739
 
4160
3740
  def list_custom_domains(
4161
3741
  self,
@@ -4223,16 +3803,10 @@ class Client(OpenApiClient):
4223
3803
  req_body_type='json',
4224
3804
  body_type='json'
4225
3805
  )
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
- )
3806
+ return TeaCore.from_map(
3807
+ fc20230330_models.ListFunctionVersionsResponse(),
3808
+ self.call_api(params, req, runtime)
3809
+ )
4236
3810
 
4237
3811
  async def list_function_versions_with_options_async(
4238
3812
  self,
@@ -4272,16 +3846,10 @@ class Client(OpenApiClient):
4272
3846
  req_body_type='json',
4273
3847
  body_type='json'
4274
3848
  )
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
- )
3849
+ return TeaCore.from_map(
3850
+ fc20230330_models.ListFunctionVersionsResponse(),
3851
+ await self.call_api_async(params, req, runtime)
3852
+ )
4285
3853
 
4286
3854
  def list_function_versions(
4287
3855
  self,
@@ -4366,16 +3934,10 @@ class Client(OpenApiClient):
4366
3934
  req_body_type='json',
4367
3935
  body_type='json'
4368
3936
  )
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
- )
3937
+ return TeaCore.from_map(
3938
+ fc20230330_models.ListFunctionsResponse(),
3939
+ self.call_api(params, req, runtime)
3940
+ )
4379
3941
 
4380
3942
  async def list_functions_with_options_async(
4381
3943
  self,
@@ -4430,16 +3992,10 @@ class Client(OpenApiClient):
4430
3992
  req_body_type='json',
4431
3993
  body_type='json'
4432
3994
  )
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
- )
3995
+ return TeaCore.from_map(
3996
+ fc20230330_models.ListFunctionsResponse(),
3997
+ await self.call_api_async(params, req, runtime)
3998
+ )
4443
3999
 
4444
4000
  def list_functions(
4445
4001
  self,
@@ -4527,16 +4083,10 @@ class Client(OpenApiClient):
4527
4083
  req_body_type='json',
4528
4084
  body_type='json'
4529
4085
  )
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
- )
4086
+ return TeaCore.from_map(
4087
+ fc20230330_models.ListInstancesResponse(),
4088
+ self.call_api(params, req, runtime)
4089
+ )
4540
4090
 
4541
4091
  async def list_instances_with_options_async(
4542
4092
  self,
@@ -4592,16 +4142,10 @@ class Client(OpenApiClient):
4592
4142
  req_body_type='json',
4593
4143
  body_type='json'
4594
4144
  )
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
- )
4145
+ return TeaCore.from_map(
4146
+ fc20230330_models.ListInstancesResponse(),
4147
+ await self.call_api_async(params, req, runtime)
4148
+ )
4605
4149
 
4606
4150
  def list_instances(
4607
4151
  self,
@@ -4669,16 +4213,10 @@ class Client(OpenApiClient):
4669
4213
  req_body_type='json',
4670
4214
  body_type='json'
4671
4215
  )
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
- )
4216
+ return TeaCore.from_map(
4217
+ fc20230330_models.ListLayerVersionsResponse(),
4218
+ self.call_api(params, req, runtime)
4219
+ )
4682
4220
 
4683
4221
  async def list_layer_versions_with_options_async(
4684
4222
  self,
@@ -4716,16 +4254,10 @@ class Client(OpenApiClient):
4716
4254
  req_body_type='json',
4717
4255
  body_type='json'
4718
4256
  )
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
- )
4257
+ return TeaCore.from_map(
4258
+ fc20230330_models.ListLayerVersionsResponse(),
4259
+ await self.call_api_async(params, req, runtime)
4260
+ )
4729
4261
 
4730
4262
  def list_layer_versions(
4731
4263
  self,
@@ -4798,16 +4330,10 @@ class Client(OpenApiClient):
4798
4330
  req_body_type='json',
4799
4331
  body_type='json'
4800
4332
  )
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
- )
4333
+ return TeaCore.from_map(
4334
+ fc20230330_models.ListLayersResponse(),
4335
+ self.call_api(params, req, runtime)
4336
+ )
4811
4337
 
4812
4338
  async def list_layers_with_options_async(
4813
4339
  self,
@@ -4850,16 +4376,10 @@ class Client(OpenApiClient):
4850
4376
  req_body_type='json',
4851
4377
  body_type='json'
4852
4378
  )
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
- )
4379
+ return TeaCore.from_map(
4380
+ fc20230330_models.ListLayersResponse(),
4381
+ await self.call_api_async(params, req, runtime)
4382
+ )
4863
4383
 
4864
4384
  def list_layers(
4865
4385
  self,
@@ -4926,16 +4446,10 @@ class Client(OpenApiClient):
4926
4446
  req_body_type='json',
4927
4447
  body_type='json'
4928
4448
  )
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
- )
4449
+ return TeaCore.from_map(
4450
+ fc20230330_models.ListProvisionConfigsResponse(),
4451
+ self.call_api(params, req, runtime)
4452
+ )
4939
4453
 
4940
4454
  async def list_provision_configs_with_options_async(
4941
4455
  self,
@@ -4974,16 +4488,10 @@ class Client(OpenApiClient):
4974
4488
  req_body_type='json',
4975
4489
  body_type='json'
4976
4490
  )
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
- )
4491
+ return TeaCore.from_map(
4492
+ fc20230330_models.ListProvisionConfigsResponse(),
4493
+ await self.call_api_async(params, req, runtime)
4494
+ )
4987
4495
 
4988
4496
  def list_provision_configs(
4989
4497
  self,
@@ -5060,16 +4568,10 @@ class Client(OpenApiClient):
5060
4568
  req_body_type='json',
5061
4569
  body_type='json'
5062
4570
  )
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
- )
4571
+ return TeaCore.from_map(
4572
+ fc20230330_models.ListTagResourcesResponse(),
4573
+ self.call_api(params, req, runtime)
4574
+ )
5073
4575
 
5074
4576
  async def list_tag_resources_with_options_async(
5075
4577
  self,
@@ -5118,16 +4620,10 @@ class Client(OpenApiClient):
5118
4620
  req_body_type='json',
5119
4621
  body_type='json'
5120
4622
  )
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
- )
4623
+ return TeaCore.from_map(
4624
+ fc20230330_models.ListTagResourcesResponse(),
4625
+ await self.call_api_async(params, req, runtime)
4626
+ )
5131
4627
 
5132
4628
  def list_tag_resources(
5133
4629
  self,
@@ -5195,16 +4691,10 @@ class Client(OpenApiClient):
5195
4691
  req_body_type='json',
5196
4692
  body_type='json'
5197
4693
  )
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
- )
4694
+ return TeaCore.from_map(
4695
+ fc20230330_models.ListTriggersResponse(),
4696
+ self.call_api(params, req, runtime)
4697
+ )
5208
4698
 
5209
4699
  async def list_triggers_with_options_async(
5210
4700
  self,
@@ -5244,16 +4734,10 @@ class Client(OpenApiClient):
5244
4734
  req_body_type='json',
5245
4735
  body_type='json'
5246
4736
  )
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
- )
4737
+ return TeaCore.from_map(
4738
+ fc20230330_models.ListTriggersResponse(),
4739
+ await self.call_api_async(params, req, runtime)
4740
+ )
5257
4741
 
5258
4742
  def list_triggers(
5259
4743
  self,
@@ -5312,16 +4796,10 @@ class Client(OpenApiClient):
5312
4796
  req_body_type='json',
5313
4797
  body_type='json'
5314
4798
  )
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
- )
4799
+ return TeaCore.from_map(
4800
+ fc20230330_models.ListVpcBindingsResponse(),
4801
+ self.call_api(params, req, runtime)
4802
+ )
5325
4803
 
5326
4804
  async def list_vpc_bindings_with_options_async(
5327
4805
  self,
@@ -5350,16 +4828,10 @@ class Client(OpenApiClient):
5350
4828
  req_body_type='json',
5351
4829
  body_type='json'
5352
4830
  )
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
- )
4831
+ return TeaCore.from_map(
4832
+ fc20230330_models.ListVpcBindingsResponse(),
4833
+ await self.call_api_async(params, req, runtime)
4834
+ )
5363
4835
 
5364
4836
  def list_vpc_bindings(
5365
4837
  self,
@@ -5418,16 +4890,10 @@ class Client(OpenApiClient):
5418
4890
  req_body_type='json',
5419
4891
  body_type='json'
5420
4892
  )
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
- )
4893
+ return TeaCore.from_map(
4894
+ fc20230330_models.PublishFunctionVersionResponse(),
4895
+ self.call_api(params, req, runtime)
4896
+ )
5431
4897
 
5432
4898
  async def publish_function_version_with_options_async(
5433
4899
  self,
@@ -5460,16 +4926,10 @@ class Client(OpenApiClient):
5460
4926
  req_body_type='json',
5461
4927
  body_type='json'
5462
4928
  )
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
- )
4929
+ return TeaCore.from_map(
4930
+ fc20230330_models.PublishFunctionVersionResponse(),
4931
+ await self.call_api_async(params, req, runtime)
4932
+ )
5473
4933
 
5474
4934
  def publish_function_version(
5475
4935
  self,
@@ -5536,16 +4996,10 @@ class Client(OpenApiClient):
5536
4996
  req_body_type='json',
5537
4997
  body_type='json'
5538
4998
  )
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
- )
4999
+ return TeaCore.from_map(
5000
+ fc20230330_models.PutAsyncInvokeConfigResponse(),
5001
+ self.call_api(params, req, runtime)
5002
+ )
5549
5003
 
5550
5004
  async def put_async_invoke_config_with_options_async(
5551
5005
  self,
@@ -5582,16 +5036,10 @@ class Client(OpenApiClient):
5582
5036
  req_body_type='json',
5583
5037
  body_type='json'
5584
5038
  )
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
- )
5039
+ return TeaCore.from_map(
5040
+ fc20230330_models.PutAsyncInvokeConfigResponse(),
5041
+ await self.call_api_async(params, req, runtime)
5042
+ )
5595
5043
 
5596
5044
  def put_async_invoke_config(
5597
5045
  self,
@@ -5654,16 +5102,10 @@ class Client(OpenApiClient):
5654
5102
  req_body_type='json',
5655
5103
  body_type='json'
5656
5104
  )
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
- )
5105
+ return TeaCore.from_map(
5106
+ fc20230330_models.PutConcurrencyConfigResponse(),
5107
+ self.call_api(params, req, runtime)
5108
+ )
5667
5109
 
5668
5110
  async def put_concurrency_config_with_options_async(
5669
5111
  self,
@@ -5696,16 +5138,10 @@ class Client(OpenApiClient):
5696
5138
  req_body_type='json',
5697
5139
  body_type='json'
5698
5140
  )
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
- )
5141
+ return TeaCore.from_map(
5142
+ fc20230330_models.PutConcurrencyConfigResponse(),
5143
+ await self.call_api_async(params, req, runtime)
5144
+ )
5709
5145
 
5710
5146
  def put_concurrency_config(
5711
5147
  self,
@@ -5773,16 +5209,10 @@ class Client(OpenApiClient):
5773
5209
  req_body_type='json',
5774
5210
  body_type='none'
5775
5211
  )
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
- )
5212
+ return TeaCore.from_map(
5213
+ fc20230330_models.PutLayerACLResponse(),
5214
+ self.call_api(params, req, runtime)
5215
+ )
5786
5216
 
5787
5217
  async def put_layer_aclwith_options_async(
5788
5218
  self,
@@ -5820,16 +5250,10 @@ class Client(OpenApiClient):
5820
5250
  req_body_type='json',
5821
5251
  body_type='none'
5822
5252
  )
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
- )
5253
+ return TeaCore.from_map(
5254
+ fc20230330_models.PutLayerACLResponse(),
5255
+ await self.call_api_async(params, req, runtime)
5256
+ )
5833
5257
 
5834
5258
  def put_layer_acl(
5835
5259
  self,
@@ -5896,16 +5320,10 @@ class Client(OpenApiClient):
5896
5320
  req_body_type='json',
5897
5321
  body_type='json'
5898
5322
  )
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
- )
5323
+ return TeaCore.from_map(
5324
+ fc20230330_models.PutProvisionConfigResponse(),
5325
+ self.call_api(params, req, runtime)
5326
+ )
5909
5327
 
5910
5328
  async def put_provision_config_with_options_async(
5911
5329
  self,
@@ -5942,16 +5360,10 @@ class Client(OpenApiClient):
5942
5360
  req_body_type='json',
5943
5361
  body_type='json'
5944
5362
  )
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
- )
5363
+ return TeaCore.from_map(
5364
+ fc20230330_models.PutProvisionConfigResponse(),
5365
+ await self.call_api_async(params, req, runtime)
5366
+ )
5955
5367
 
5956
5368
  def put_provision_config(
5957
5369
  self,
@@ -6018,16 +5430,10 @@ class Client(OpenApiClient):
6018
5430
  req_body_type='json',
6019
5431
  body_type='none'
6020
5432
  )
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
- )
5433
+ return TeaCore.from_map(
5434
+ fc20230330_models.StopAsyncTaskResponse(),
5435
+ self.call_api(params, req, runtime)
5436
+ )
6031
5437
 
6032
5438
  async def stop_async_task_with_options_async(
6033
5439
  self,
@@ -6064,16 +5470,10 @@ class Client(OpenApiClient):
6064
5470
  req_body_type='json',
6065
5471
  body_type='none'
6066
5472
  )
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
- )
5473
+ return TeaCore.from_map(
5474
+ fc20230330_models.StopAsyncTaskResponse(),
5475
+ await self.call_api_async(params, req, runtime)
5476
+ )
6077
5477
 
6078
5478
  def stop_async_task(
6079
5479
  self,
@@ -6139,16 +5539,10 @@ class Client(OpenApiClient):
6139
5539
  req_body_type='json',
6140
5540
  body_type='none'
6141
5541
  )
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
- )
5542
+ return TeaCore.from_map(
5543
+ fc20230330_models.TagResourcesResponse(),
5544
+ self.call_api(params, req, runtime)
5545
+ )
6152
5546
 
6153
5547
  async def tag_resources_with_options_async(
6154
5548
  self,
@@ -6182,16 +5576,10 @@ class Client(OpenApiClient):
6182
5576
  req_body_type='json',
6183
5577
  body_type='none'
6184
5578
  )
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
- )
5579
+ return TeaCore.from_map(
5580
+ fc20230330_models.TagResourcesResponse(),
5581
+ await self.call_api_async(params, req, runtime)
5582
+ )
6195
5583
 
6196
5584
  def tag_resources(
6197
5585
  self,
@@ -6270,16 +5658,10 @@ class Client(OpenApiClient):
6270
5658
  req_body_type='json',
6271
5659
  body_type='none'
6272
5660
  )
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
- )
5661
+ return TeaCore.from_map(
5662
+ fc20230330_models.UntagResourcesResponse(),
5663
+ self.call_api(params, req, runtime)
5664
+ )
6283
5665
 
6284
5666
  async def untag_resources_with_options_async(
6285
5667
  self,
@@ -6326,16 +5708,10 @@ class Client(OpenApiClient):
6326
5708
  req_body_type='json',
6327
5709
  body_type='none'
6328
5710
  )
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
- )
5711
+ return TeaCore.from_map(
5712
+ fc20230330_models.UntagResourcesResponse(),
5713
+ await self.call_api_async(params, req, runtime)
5714
+ )
6339
5715
 
6340
5716
  def untag_resources(
6341
5717
  self,
@@ -6397,16 +5773,10 @@ class Client(OpenApiClient):
6397
5773
  req_body_type='json',
6398
5774
  body_type='json'
6399
5775
  )
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
- )
5776
+ return TeaCore.from_map(
5777
+ fc20230330_models.UpdateAliasResponse(),
5778
+ self.call_api(params, req, runtime)
5779
+ )
6410
5780
 
6411
5781
  async def update_alias_with_options_async(
6412
5782
  self,
@@ -6440,16 +5810,10 @@ class Client(OpenApiClient):
6440
5810
  req_body_type='json',
6441
5811
  body_type='json'
6442
5812
  )
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
- )
5813
+ return TeaCore.from_map(
5814
+ fc20230330_models.UpdateAliasResponse(),
5815
+ await self.call_api_async(params, req, runtime)
5816
+ )
6453
5817
 
6454
5818
  def update_alias(
6455
5819
  self,
@@ -6514,16 +5878,10 @@ class Client(OpenApiClient):
6514
5878
  req_body_type='json',
6515
5879
  body_type='json'
6516
5880
  )
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
- )
5881
+ return TeaCore.from_map(
5882
+ fc20230330_models.UpdateCustomDomainResponse(),
5883
+ self.call_api(params, req, runtime)
5884
+ )
6527
5885
 
6528
5886
  async def update_custom_domain_with_options_async(
6529
5887
  self,
@@ -6556,16 +5914,10 @@ class Client(OpenApiClient):
6556
5914
  req_body_type='json',
6557
5915
  body_type='json'
6558
5916
  )
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
- )
5917
+ return TeaCore.from_map(
5918
+ fc20230330_models.UpdateCustomDomainResponse(),
5919
+ await self.call_api_async(params, req, runtime)
5920
+ )
6569
5921
 
6570
5922
  def update_custom_domain(
6571
5923
  self,
@@ -6628,16 +5980,10 @@ class Client(OpenApiClient):
6628
5980
  req_body_type='json',
6629
5981
  body_type='json'
6630
5982
  )
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
- )
5983
+ return TeaCore.from_map(
5984
+ fc20230330_models.UpdateFunctionResponse(),
5985
+ self.call_api(params, req, runtime)
5986
+ )
6641
5987
 
6642
5988
  async def update_function_with_options_async(
6643
5989
  self,
@@ -6670,16 +6016,10 @@ class Client(OpenApiClient):
6670
6016
  req_body_type='json',
6671
6017
  body_type='json'
6672
6018
  )
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
- )
6019
+ return TeaCore.from_map(
6020
+ fc20230330_models.UpdateFunctionResponse(),
6021
+ await self.call_api_async(params, req, runtime)
6022
+ )
6683
6023
 
6684
6024
  def update_function(
6685
6025
  self,
@@ -6743,16 +6083,10 @@ class Client(OpenApiClient):
6743
6083
  req_body_type='json',
6744
6084
  body_type='json'
6745
6085
  )
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
- )
6086
+ return TeaCore.from_map(
6087
+ fc20230330_models.UpdateTriggerResponse(),
6088
+ self.call_api(params, req, runtime)
6089
+ )
6756
6090
 
6757
6091
  async def update_trigger_with_options_async(
6758
6092
  self,
@@ -6786,16 +6120,10 @@ class Client(OpenApiClient):
6786
6120
  req_body_type='json',
6787
6121
  body_type='json'
6788
6122
  )
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
- )
6123
+ return TeaCore.from_map(
6124
+ fc20230330_models.UpdateTriggerResponse(),
6125
+ await self.call_api_async(params, req, runtime)
6126
+ )
6799
6127
 
6800
6128
  def update_trigger(
6801
6129
  self,