alibabacloud-fc20230330 4.2.2__py3-none-any.whl → 4.2.4__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 +452 -1120
  3. alibabacloud_fc20230330/models.py +114 -102
  4. {alibabacloud_fc20230330-4.2.2.dist-info → alibabacloud_fc20230330-4.2.4.dist-info}/METADATA +2 -2
  5. alibabacloud_fc20230330-4.2.4.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.4.dist-info}/LICENSE +0 -0
  8. {alibabacloud_fc20230330-4.2.2.dist-info → alibabacloud_fc20230330-4.2.4.dist-info}/WHEEL +0 -0
  9. {alibabacloud_fc20230330-4.2.2.dist-info → alibabacloud_fc20230330-4.2.4.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,
@@ -4339,6 +3907,8 @@ class Client(OpenApiClient):
4339
3907
  query['description'] = request.description
4340
3908
  if not UtilClient.is_unset(request.fc_version):
4341
3909
  query['fcVersion'] = request.fc_version
3910
+ if not UtilClient.is_unset(request.function_name):
3911
+ query['functionName'] = request.function_name
4342
3912
  if not UtilClient.is_unset(request.gpu_type):
4343
3913
  query['gpuType'] = request.gpu_type
4344
3914
  if not UtilClient.is_unset(request.limit):
@@ -4366,16 +3936,10 @@ class Client(OpenApiClient):
4366
3936
  req_body_type='json',
4367
3937
  body_type='json'
4368
3938
  )
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
- )
3939
+ return TeaCore.from_map(
3940
+ fc20230330_models.ListFunctionsResponse(),
3941
+ self.call_api(params, req, runtime)
3942
+ )
4379
3943
 
4380
3944
  async def list_functions_with_options_async(
4381
3945
  self,
@@ -4403,6 +3967,8 @@ class Client(OpenApiClient):
4403
3967
  query['description'] = request.description
4404
3968
  if not UtilClient.is_unset(request.fc_version):
4405
3969
  query['fcVersion'] = request.fc_version
3970
+ if not UtilClient.is_unset(request.function_name):
3971
+ query['functionName'] = request.function_name
4406
3972
  if not UtilClient.is_unset(request.gpu_type):
4407
3973
  query['gpuType'] = request.gpu_type
4408
3974
  if not UtilClient.is_unset(request.limit):
@@ -4430,16 +3996,10 @@ class Client(OpenApiClient):
4430
3996
  req_body_type='json',
4431
3997
  body_type='json'
4432
3998
  )
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
- )
3999
+ return TeaCore.from_map(
4000
+ fc20230330_models.ListFunctionsResponse(),
4001
+ await self.call_api_async(params, req, runtime)
4002
+ )
4443
4003
 
4444
4004
  def list_functions(
4445
4005
  self,
@@ -4527,16 +4087,10 @@ class Client(OpenApiClient):
4527
4087
  req_body_type='json',
4528
4088
  body_type='json'
4529
4089
  )
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
- )
4090
+ return TeaCore.from_map(
4091
+ fc20230330_models.ListInstancesResponse(),
4092
+ self.call_api(params, req, runtime)
4093
+ )
4540
4094
 
4541
4095
  async def list_instances_with_options_async(
4542
4096
  self,
@@ -4592,16 +4146,10 @@ class Client(OpenApiClient):
4592
4146
  req_body_type='json',
4593
4147
  body_type='json'
4594
4148
  )
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
- )
4149
+ return TeaCore.from_map(
4150
+ fc20230330_models.ListInstancesResponse(),
4151
+ await self.call_api_async(params, req, runtime)
4152
+ )
4605
4153
 
4606
4154
  def list_instances(
4607
4155
  self,
@@ -4669,16 +4217,10 @@ class Client(OpenApiClient):
4669
4217
  req_body_type='json',
4670
4218
  body_type='json'
4671
4219
  )
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
- )
4220
+ return TeaCore.from_map(
4221
+ fc20230330_models.ListLayerVersionsResponse(),
4222
+ self.call_api(params, req, runtime)
4223
+ )
4682
4224
 
4683
4225
  async def list_layer_versions_with_options_async(
4684
4226
  self,
@@ -4716,16 +4258,10 @@ class Client(OpenApiClient):
4716
4258
  req_body_type='json',
4717
4259
  body_type='json'
4718
4260
  )
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
- )
4261
+ return TeaCore.from_map(
4262
+ fc20230330_models.ListLayerVersionsResponse(),
4263
+ await self.call_api_async(params, req, runtime)
4264
+ )
4729
4265
 
4730
4266
  def list_layer_versions(
4731
4267
  self,
@@ -4798,16 +4334,10 @@ class Client(OpenApiClient):
4798
4334
  req_body_type='json',
4799
4335
  body_type='json'
4800
4336
  )
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
- )
4337
+ return TeaCore.from_map(
4338
+ fc20230330_models.ListLayersResponse(),
4339
+ self.call_api(params, req, runtime)
4340
+ )
4811
4341
 
4812
4342
  async def list_layers_with_options_async(
4813
4343
  self,
@@ -4850,16 +4380,10 @@ class Client(OpenApiClient):
4850
4380
  req_body_type='json',
4851
4381
  body_type='json'
4852
4382
  )
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
- )
4383
+ return TeaCore.from_map(
4384
+ fc20230330_models.ListLayersResponse(),
4385
+ await self.call_api_async(params, req, runtime)
4386
+ )
4863
4387
 
4864
4388
  def list_layers(
4865
4389
  self,
@@ -4926,16 +4450,10 @@ class Client(OpenApiClient):
4926
4450
  req_body_type='json',
4927
4451
  body_type='json'
4928
4452
  )
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
- )
4453
+ return TeaCore.from_map(
4454
+ fc20230330_models.ListProvisionConfigsResponse(),
4455
+ self.call_api(params, req, runtime)
4456
+ )
4939
4457
 
4940
4458
  async def list_provision_configs_with_options_async(
4941
4459
  self,
@@ -4974,16 +4492,10 @@ class Client(OpenApiClient):
4974
4492
  req_body_type='json',
4975
4493
  body_type='json'
4976
4494
  )
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
- )
4495
+ return TeaCore.from_map(
4496
+ fc20230330_models.ListProvisionConfigsResponse(),
4497
+ await self.call_api_async(params, req, runtime)
4498
+ )
4987
4499
 
4988
4500
  def list_provision_configs(
4989
4501
  self,
@@ -5060,16 +4572,10 @@ class Client(OpenApiClient):
5060
4572
  req_body_type='json',
5061
4573
  body_type='json'
5062
4574
  )
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
- )
4575
+ return TeaCore.from_map(
4576
+ fc20230330_models.ListTagResourcesResponse(),
4577
+ self.call_api(params, req, runtime)
4578
+ )
5073
4579
 
5074
4580
  async def list_tag_resources_with_options_async(
5075
4581
  self,
@@ -5118,16 +4624,10 @@ class Client(OpenApiClient):
5118
4624
  req_body_type='json',
5119
4625
  body_type='json'
5120
4626
  )
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
- )
4627
+ return TeaCore.from_map(
4628
+ fc20230330_models.ListTagResourcesResponse(),
4629
+ await self.call_api_async(params, req, runtime)
4630
+ )
5131
4631
 
5132
4632
  def list_tag_resources(
5133
4633
  self,
@@ -5195,16 +4695,10 @@ class Client(OpenApiClient):
5195
4695
  req_body_type='json',
5196
4696
  body_type='json'
5197
4697
  )
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
- )
4698
+ return TeaCore.from_map(
4699
+ fc20230330_models.ListTriggersResponse(),
4700
+ self.call_api(params, req, runtime)
4701
+ )
5208
4702
 
5209
4703
  async def list_triggers_with_options_async(
5210
4704
  self,
@@ -5244,16 +4738,10 @@ class Client(OpenApiClient):
5244
4738
  req_body_type='json',
5245
4739
  body_type='json'
5246
4740
  )
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
- )
4741
+ return TeaCore.from_map(
4742
+ fc20230330_models.ListTriggersResponse(),
4743
+ await self.call_api_async(params, req, runtime)
4744
+ )
5257
4745
 
5258
4746
  def list_triggers(
5259
4747
  self,
@@ -5312,16 +4800,10 @@ class Client(OpenApiClient):
5312
4800
  req_body_type='json',
5313
4801
  body_type='json'
5314
4802
  )
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
- )
4803
+ return TeaCore.from_map(
4804
+ fc20230330_models.ListVpcBindingsResponse(),
4805
+ self.call_api(params, req, runtime)
4806
+ )
5325
4807
 
5326
4808
  async def list_vpc_bindings_with_options_async(
5327
4809
  self,
@@ -5350,16 +4832,10 @@ class Client(OpenApiClient):
5350
4832
  req_body_type='json',
5351
4833
  body_type='json'
5352
4834
  )
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
- )
4835
+ return TeaCore.from_map(
4836
+ fc20230330_models.ListVpcBindingsResponse(),
4837
+ await self.call_api_async(params, req, runtime)
4838
+ )
5363
4839
 
5364
4840
  def list_vpc_bindings(
5365
4841
  self,
@@ -5418,16 +4894,10 @@ class Client(OpenApiClient):
5418
4894
  req_body_type='json',
5419
4895
  body_type='json'
5420
4896
  )
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
- )
4897
+ return TeaCore.from_map(
4898
+ fc20230330_models.PublishFunctionVersionResponse(),
4899
+ self.call_api(params, req, runtime)
4900
+ )
5431
4901
 
5432
4902
  async def publish_function_version_with_options_async(
5433
4903
  self,
@@ -5460,16 +4930,10 @@ class Client(OpenApiClient):
5460
4930
  req_body_type='json',
5461
4931
  body_type='json'
5462
4932
  )
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
- )
4933
+ return TeaCore.from_map(
4934
+ fc20230330_models.PublishFunctionVersionResponse(),
4935
+ await self.call_api_async(params, req, runtime)
4936
+ )
5473
4937
 
5474
4938
  def publish_function_version(
5475
4939
  self,
@@ -5536,16 +5000,10 @@ class Client(OpenApiClient):
5536
5000
  req_body_type='json',
5537
5001
  body_type='json'
5538
5002
  )
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
- )
5003
+ return TeaCore.from_map(
5004
+ fc20230330_models.PutAsyncInvokeConfigResponse(),
5005
+ self.call_api(params, req, runtime)
5006
+ )
5549
5007
 
5550
5008
  async def put_async_invoke_config_with_options_async(
5551
5009
  self,
@@ -5582,16 +5040,10 @@ class Client(OpenApiClient):
5582
5040
  req_body_type='json',
5583
5041
  body_type='json'
5584
5042
  )
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
- )
5043
+ return TeaCore.from_map(
5044
+ fc20230330_models.PutAsyncInvokeConfigResponse(),
5045
+ await self.call_api_async(params, req, runtime)
5046
+ )
5595
5047
 
5596
5048
  def put_async_invoke_config(
5597
5049
  self,
@@ -5654,16 +5106,10 @@ class Client(OpenApiClient):
5654
5106
  req_body_type='json',
5655
5107
  body_type='json'
5656
5108
  )
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
- )
5109
+ return TeaCore.from_map(
5110
+ fc20230330_models.PutConcurrencyConfigResponse(),
5111
+ self.call_api(params, req, runtime)
5112
+ )
5667
5113
 
5668
5114
  async def put_concurrency_config_with_options_async(
5669
5115
  self,
@@ -5696,16 +5142,10 @@ class Client(OpenApiClient):
5696
5142
  req_body_type='json',
5697
5143
  body_type='json'
5698
5144
  )
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
- )
5145
+ return TeaCore.from_map(
5146
+ fc20230330_models.PutConcurrencyConfigResponse(),
5147
+ await self.call_api_async(params, req, runtime)
5148
+ )
5709
5149
 
5710
5150
  def put_concurrency_config(
5711
5151
  self,
@@ -5773,16 +5213,10 @@ class Client(OpenApiClient):
5773
5213
  req_body_type='json',
5774
5214
  body_type='none'
5775
5215
  )
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
- )
5216
+ return TeaCore.from_map(
5217
+ fc20230330_models.PutLayerACLResponse(),
5218
+ self.call_api(params, req, runtime)
5219
+ )
5786
5220
 
5787
5221
  async def put_layer_aclwith_options_async(
5788
5222
  self,
@@ -5820,16 +5254,10 @@ class Client(OpenApiClient):
5820
5254
  req_body_type='json',
5821
5255
  body_type='none'
5822
5256
  )
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
- )
5257
+ return TeaCore.from_map(
5258
+ fc20230330_models.PutLayerACLResponse(),
5259
+ await self.call_api_async(params, req, runtime)
5260
+ )
5833
5261
 
5834
5262
  def put_layer_acl(
5835
5263
  self,
@@ -5896,16 +5324,10 @@ class Client(OpenApiClient):
5896
5324
  req_body_type='json',
5897
5325
  body_type='json'
5898
5326
  )
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
- )
5327
+ return TeaCore.from_map(
5328
+ fc20230330_models.PutProvisionConfigResponse(),
5329
+ self.call_api(params, req, runtime)
5330
+ )
5909
5331
 
5910
5332
  async def put_provision_config_with_options_async(
5911
5333
  self,
@@ -5942,16 +5364,10 @@ class Client(OpenApiClient):
5942
5364
  req_body_type='json',
5943
5365
  body_type='json'
5944
5366
  )
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
- )
5367
+ return TeaCore.from_map(
5368
+ fc20230330_models.PutProvisionConfigResponse(),
5369
+ await self.call_api_async(params, req, runtime)
5370
+ )
5955
5371
 
5956
5372
  def put_provision_config(
5957
5373
  self,
@@ -6018,16 +5434,10 @@ class Client(OpenApiClient):
6018
5434
  req_body_type='json',
6019
5435
  body_type='none'
6020
5436
  )
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
- )
5437
+ return TeaCore.from_map(
5438
+ fc20230330_models.StopAsyncTaskResponse(),
5439
+ self.call_api(params, req, runtime)
5440
+ )
6031
5441
 
6032
5442
  async def stop_async_task_with_options_async(
6033
5443
  self,
@@ -6064,16 +5474,10 @@ class Client(OpenApiClient):
6064
5474
  req_body_type='json',
6065
5475
  body_type='none'
6066
5476
  )
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
- )
5477
+ return TeaCore.from_map(
5478
+ fc20230330_models.StopAsyncTaskResponse(),
5479
+ await self.call_api_async(params, req, runtime)
5480
+ )
6077
5481
 
6078
5482
  def stop_async_task(
6079
5483
  self,
@@ -6139,16 +5543,10 @@ class Client(OpenApiClient):
6139
5543
  req_body_type='json',
6140
5544
  body_type='none'
6141
5545
  )
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
- )
5546
+ return TeaCore.from_map(
5547
+ fc20230330_models.TagResourcesResponse(),
5548
+ self.call_api(params, req, runtime)
5549
+ )
6152
5550
 
6153
5551
  async def tag_resources_with_options_async(
6154
5552
  self,
@@ -6182,16 +5580,10 @@ class Client(OpenApiClient):
6182
5580
  req_body_type='json',
6183
5581
  body_type='none'
6184
5582
  )
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
- )
5583
+ return TeaCore.from_map(
5584
+ fc20230330_models.TagResourcesResponse(),
5585
+ await self.call_api_async(params, req, runtime)
5586
+ )
6195
5587
 
6196
5588
  def tag_resources(
6197
5589
  self,
@@ -6270,16 +5662,10 @@ class Client(OpenApiClient):
6270
5662
  req_body_type='json',
6271
5663
  body_type='none'
6272
5664
  )
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
- )
5665
+ return TeaCore.from_map(
5666
+ fc20230330_models.UntagResourcesResponse(),
5667
+ self.call_api(params, req, runtime)
5668
+ )
6283
5669
 
6284
5670
  async def untag_resources_with_options_async(
6285
5671
  self,
@@ -6326,16 +5712,10 @@ class Client(OpenApiClient):
6326
5712
  req_body_type='json',
6327
5713
  body_type='none'
6328
5714
  )
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
- )
5715
+ return TeaCore.from_map(
5716
+ fc20230330_models.UntagResourcesResponse(),
5717
+ await self.call_api_async(params, req, runtime)
5718
+ )
6339
5719
 
6340
5720
  def untag_resources(
6341
5721
  self,
@@ -6397,16 +5777,10 @@ class Client(OpenApiClient):
6397
5777
  req_body_type='json',
6398
5778
  body_type='json'
6399
5779
  )
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
- )
5780
+ return TeaCore.from_map(
5781
+ fc20230330_models.UpdateAliasResponse(),
5782
+ self.call_api(params, req, runtime)
5783
+ )
6410
5784
 
6411
5785
  async def update_alias_with_options_async(
6412
5786
  self,
@@ -6440,16 +5814,10 @@ class Client(OpenApiClient):
6440
5814
  req_body_type='json',
6441
5815
  body_type='json'
6442
5816
  )
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
- )
5817
+ return TeaCore.from_map(
5818
+ fc20230330_models.UpdateAliasResponse(),
5819
+ await self.call_api_async(params, req, runtime)
5820
+ )
6453
5821
 
6454
5822
  def update_alias(
6455
5823
  self,
@@ -6514,16 +5882,10 @@ class Client(OpenApiClient):
6514
5882
  req_body_type='json',
6515
5883
  body_type='json'
6516
5884
  )
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
- )
5885
+ return TeaCore.from_map(
5886
+ fc20230330_models.UpdateCustomDomainResponse(),
5887
+ self.call_api(params, req, runtime)
5888
+ )
6527
5889
 
6528
5890
  async def update_custom_domain_with_options_async(
6529
5891
  self,
@@ -6556,16 +5918,10 @@ class Client(OpenApiClient):
6556
5918
  req_body_type='json',
6557
5919
  body_type='json'
6558
5920
  )
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
- )
5921
+ return TeaCore.from_map(
5922
+ fc20230330_models.UpdateCustomDomainResponse(),
5923
+ await self.call_api_async(params, req, runtime)
5924
+ )
6569
5925
 
6570
5926
  def update_custom_domain(
6571
5927
  self,
@@ -6628,16 +5984,10 @@ class Client(OpenApiClient):
6628
5984
  req_body_type='json',
6629
5985
  body_type='json'
6630
5986
  )
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
- )
5987
+ return TeaCore.from_map(
5988
+ fc20230330_models.UpdateFunctionResponse(),
5989
+ self.call_api(params, req, runtime)
5990
+ )
6641
5991
 
6642
5992
  async def update_function_with_options_async(
6643
5993
  self,
@@ -6670,16 +6020,10 @@ class Client(OpenApiClient):
6670
6020
  req_body_type='json',
6671
6021
  body_type='json'
6672
6022
  )
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
- )
6023
+ return TeaCore.from_map(
6024
+ fc20230330_models.UpdateFunctionResponse(),
6025
+ await self.call_api_async(params, req, runtime)
6026
+ )
6683
6027
 
6684
6028
  def update_function(
6685
6029
  self,
@@ -6743,16 +6087,10 @@ class Client(OpenApiClient):
6743
6087
  req_body_type='json',
6744
6088
  body_type='json'
6745
6089
  )
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
- )
6090
+ return TeaCore.from_map(
6091
+ fc20230330_models.UpdateTriggerResponse(),
6092
+ self.call_api(params, req, runtime)
6093
+ )
6756
6094
 
6757
6095
  async def update_trigger_with_options_async(
6758
6096
  self,
@@ -6786,16 +6124,10 @@ class Client(OpenApiClient):
6786
6124
  req_body_type='json',
6787
6125
  body_type='json'
6788
6126
  )
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
- )
6127
+ return TeaCore.from_map(
6128
+ fc20230330_models.UpdateTriggerResponse(),
6129
+ await self.call_api_async(params, req, runtime)
6130
+ )
6799
6131
 
6800
6132
  def update_trigger(
6801
6133
  self,