alibabacloud-fc20230330 4.2.0__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 +564 -1104
  3. alibabacloud_fc20230330/models.py +191 -102
  4. {alibabacloud_fc20230330-4.2.0.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.0.dist-info/RECORD +0 -8
  7. {alibabacloud_fc20230330-4.2.0.dist-info → alibabacloud_fc20230330-4.2.3.dist-info}/LICENSE +0 -0
  8. {alibabacloud_fc20230330-4.2.0.dist-info → alibabacloud_fc20230330-4.2.3.dist-info}/WHEEL +0 -0
  9. {alibabacloud_fc20230330-4.2.0.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,
@@ -1809,6 +1617,110 @@ class Client(OpenApiClient):
1809
1617
  headers = {}
1810
1618
  return await self.delete_vpc_binding_with_options_async(function_name, vpc_id, headers, runtime)
1811
1619
 
1620
+ def describe_regions_with_options(
1621
+ self,
1622
+ request: fc20230330_models.DescribeRegionsRequest,
1623
+ headers: Dict[str, str],
1624
+ runtime: util_models.RuntimeOptions,
1625
+ ) -> fc20230330_models.DescribeRegionsResponse:
1626
+ """
1627
+ @summary 查询产品的地域信息列表
1628
+
1629
+ @param request: DescribeRegionsRequest
1630
+ @param headers: map
1631
+ @param runtime: runtime options for this request RuntimeOptions
1632
+ @return: DescribeRegionsResponse
1633
+ """
1634
+ UtilClient.validate_model(request)
1635
+ query = {}
1636
+ if not UtilClient.is_unset(request.accept_language):
1637
+ query['AcceptLanguage'] = request.accept_language
1638
+ req = open_api_models.OpenApiRequest(
1639
+ headers=headers,
1640
+ query=OpenApiUtilClient.query(query)
1641
+ )
1642
+ params = open_api_models.Params(
1643
+ action='DescribeRegions',
1644
+ version='2023-03-30',
1645
+ protocol='HTTPS',
1646
+ pathname=f'/2023-03-30/regions',
1647
+ method='GET',
1648
+ auth_type='AK',
1649
+ style='ROA',
1650
+ req_body_type='json',
1651
+ body_type='json'
1652
+ )
1653
+ return TeaCore.from_map(
1654
+ fc20230330_models.DescribeRegionsResponse(),
1655
+ self.call_api(params, req, runtime)
1656
+ )
1657
+
1658
+ async def describe_regions_with_options_async(
1659
+ self,
1660
+ request: fc20230330_models.DescribeRegionsRequest,
1661
+ headers: Dict[str, str],
1662
+ runtime: util_models.RuntimeOptions,
1663
+ ) -> fc20230330_models.DescribeRegionsResponse:
1664
+ """
1665
+ @summary 查询产品的地域信息列表
1666
+
1667
+ @param request: DescribeRegionsRequest
1668
+ @param headers: map
1669
+ @param runtime: runtime options for this request RuntimeOptions
1670
+ @return: DescribeRegionsResponse
1671
+ """
1672
+ UtilClient.validate_model(request)
1673
+ query = {}
1674
+ if not UtilClient.is_unset(request.accept_language):
1675
+ query['AcceptLanguage'] = request.accept_language
1676
+ req = open_api_models.OpenApiRequest(
1677
+ headers=headers,
1678
+ query=OpenApiUtilClient.query(query)
1679
+ )
1680
+ params = open_api_models.Params(
1681
+ action='DescribeRegions',
1682
+ version='2023-03-30',
1683
+ protocol='HTTPS',
1684
+ pathname=f'/2023-03-30/regions',
1685
+ method='GET',
1686
+ auth_type='AK',
1687
+ style='ROA',
1688
+ req_body_type='json',
1689
+ body_type='json'
1690
+ )
1691
+ return TeaCore.from_map(
1692
+ fc20230330_models.DescribeRegionsResponse(),
1693
+ await self.call_api_async(params, req, runtime)
1694
+ )
1695
+
1696
+ def describe_regions(
1697
+ self,
1698
+ request: fc20230330_models.DescribeRegionsRequest,
1699
+ ) -> fc20230330_models.DescribeRegionsResponse:
1700
+ """
1701
+ @summary 查询产品的地域信息列表
1702
+
1703
+ @param request: DescribeRegionsRequest
1704
+ @return: DescribeRegionsResponse
1705
+ """
1706
+ runtime = util_models.RuntimeOptions()
1707
+ headers = {}
1708
+ return self.describe_regions_with_options(request, headers, runtime)
1709
+
1710
+ async def describe_regions_async(
1711
+ self,
1712
+ request: fc20230330_models.DescribeRegionsRequest,
1713
+ ) -> fc20230330_models.DescribeRegionsResponse:
1714
+ """
1715
+ @summary 查询产品的地域信息列表
1716
+
1717
+ @param request: DescribeRegionsRequest
1718
+ @return: DescribeRegionsResponse
1719
+ """
1720
+ runtime = util_models.RuntimeOptions()
1721
+ headers = {}
1722
+ return await self.describe_regions_with_options_async(request, headers, runtime)
1723
+
1812
1724
  def disable_function_invocation_with_options(
1813
1725
  self,
1814
1726
  function_name: str,
@@ -1817,7 +1729,9 @@ class Client(OpenApiClient):
1817
1729
  runtime: util_models.RuntimeOptions,
1818
1730
  ) -> fc20230330_models.DisableFunctionInvocationResponse:
1819
1731
  """
1820
- @summary 禁止函数调用
1732
+ @summary The DisableFunctionInvocation operation prevents a function from being invoked and optionally terminates all requests that are being processed. Once a function\\"s invocation is disabled, no new instances can be created, and the existing provisioned instances are destroyed. This operation is currently in private preview.
1733
+
1734
+ @description Exercise caution when you call this operation on a function in a production environment, as improper deactivation may lead to business disruptions.
1821
1735
 
1822
1736
  @param request: DisableFunctionInvocationRequest
1823
1737
  @param headers: map
@@ -1845,16 +1759,10 @@ class Client(OpenApiClient):
1845
1759
  req_body_type='json',
1846
1760
  body_type='json'
1847
1761
  )
1848
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1849
- return TeaCore.from_map(
1850
- fc20230330_models.DisableFunctionInvocationResponse(),
1851
- self.call_api(params, req, runtime)
1852
- )
1853
- else:
1854
- return TeaCore.from_map(
1855
- fc20230330_models.DisableFunctionInvocationResponse(),
1856
- self.execute(params, req, runtime)
1857
- )
1762
+ return TeaCore.from_map(
1763
+ fc20230330_models.DisableFunctionInvocationResponse(),
1764
+ self.call_api(params, req, runtime)
1765
+ )
1858
1766
 
1859
1767
  async def disable_function_invocation_with_options_async(
1860
1768
  self,
@@ -1864,7 +1772,9 @@ class Client(OpenApiClient):
1864
1772
  runtime: util_models.RuntimeOptions,
1865
1773
  ) -> fc20230330_models.DisableFunctionInvocationResponse:
1866
1774
  """
1867
- @summary 禁止函数调用
1775
+ @summary The DisableFunctionInvocation operation prevents a function from being invoked and optionally terminates all requests that are being processed. Once a function\\"s invocation is disabled, no new instances can be created, and the existing provisioned instances are destroyed. This operation is currently in private preview.
1776
+
1777
+ @description Exercise caution when you call this operation on a function in a production environment, as improper deactivation may lead to business disruptions.
1868
1778
 
1869
1779
  @param request: DisableFunctionInvocationRequest
1870
1780
  @param headers: map
@@ -1892,16 +1802,10 @@ class Client(OpenApiClient):
1892
1802
  req_body_type='json',
1893
1803
  body_type='json'
1894
1804
  )
1895
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1896
- return TeaCore.from_map(
1897
- fc20230330_models.DisableFunctionInvocationResponse(),
1898
- await self.call_api_async(params, req, runtime)
1899
- )
1900
- else:
1901
- return TeaCore.from_map(
1902
- fc20230330_models.DisableFunctionInvocationResponse(),
1903
- await self.execute_async(params, req, runtime)
1904
- )
1805
+ return TeaCore.from_map(
1806
+ fc20230330_models.DisableFunctionInvocationResponse(),
1807
+ await self.call_api_async(params, req, runtime)
1808
+ )
1905
1809
 
1906
1810
  def disable_function_invocation(
1907
1811
  self,
@@ -1909,7 +1813,9 @@ class Client(OpenApiClient):
1909
1813
  request: fc20230330_models.DisableFunctionInvocationRequest,
1910
1814
  ) -> fc20230330_models.DisableFunctionInvocationResponse:
1911
1815
  """
1912
- @summary 禁止函数调用
1816
+ @summary The DisableFunctionInvocation operation prevents a function from being invoked and optionally terminates all requests that are being processed. Once a function\\"s invocation is disabled, no new instances can be created, and the existing provisioned instances are destroyed. This operation is currently in private preview.
1817
+
1818
+ @description Exercise caution when you call this operation on a function in a production environment, as improper deactivation may lead to business disruptions.
1913
1819
 
1914
1820
  @param request: DisableFunctionInvocationRequest
1915
1821
  @return: DisableFunctionInvocationResponse
@@ -1924,7 +1830,9 @@ class Client(OpenApiClient):
1924
1830
  request: fc20230330_models.DisableFunctionInvocationRequest,
1925
1831
  ) -> fc20230330_models.DisableFunctionInvocationResponse:
1926
1832
  """
1927
- @summary 禁止函数调用
1833
+ @summary The DisableFunctionInvocation operation prevents a function from being invoked and optionally terminates all requests that are being processed. Once a function\\"s invocation is disabled, no new instances can be created, and the existing provisioned instances are destroyed. This operation is currently in private preview.
1834
+
1835
+ @description Exercise caution when you call this operation on a function in a production environment, as improper deactivation may lead to business disruptions.
1928
1836
 
1929
1837
  @param request: DisableFunctionInvocationRequest
1930
1838
  @return: DisableFunctionInvocationResponse
@@ -1960,16 +1868,10 @@ class Client(OpenApiClient):
1960
1868
  req_body_type='json',
1961
1869
  body_type='json'
1962
1870
  )
1963
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1964
- return TeaCore.from_map(
1965
- fc20230330_models.EnableFunctionInvocationResponse(),
1966
- self.call_api(params, req, runtime)
1967
- )
1968
- else:
1969
- return TeaCore.from_map(
1970
- fc20230330_models.EnableFunctionInvocationResponse(),
1971
- self.execute(params, req, runtime)
1972
- )
1871
+ return TeaCore.from_map(
1872
+ fc20230330_models.EnableFunctionInvocationResponse(),
1873
+ self.call_api(params, req, runtime)
1874
+ )
1973
1875
 
1974
1876
  async def enable_function_invocation_with_options_async(
1975
1877
  self,
@@ -1998,16 +1900,10 @@ class Client(OpenApiClient):
1998
1900
  req_body_type='json',
1999
1901
  body_type='json'
2000
1902
  )
2001
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2002
- return TeaCore.from_map(
2003
- fc20230330_models.EnableFunctionInvocationResponse(),
2004
- await self.call_api_async(params, req, runtime)
2005
- )
2006
- else:
2007
- return TeaCore.from_map(
2008
- fc20230330_models.EnableFunctionInvocationResponse(),
2009
- await self.execute_async(params, req, runtime)
2010
- )
1903
+ return TeaCore.from_map(
1904
+ fc20230330_models.EnableFunctionInvocationResponse(),
1905
+ await self.call_api_async(params, req, runtime)
1906
+ )
2011
1907
 
2012
1908
  def enable_function_invocation(
2013
1909
  self,
@@ -2063,16 +1959,10 @@ class Client(OpenApiClient):
2063
1959
  req_body_type='json',
2064
1960
  body_type='json'
2065
1961
  )
2066
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2067
- return TeaCore.from_map(
2068
- fc20230330_models.GetAliasResponse(),
2069
- self.call_api(params, req, runtime)
2070
- )
2071
- else:
2072
- return TeaCore.from_map(
2073
- fc20230330_models.GetAliasResponse(),
2074
- self.execute(params, req, runtime)
2075
- )
1962
+ return TeaCore.from_map(
1963
+ fc20230330_models.GetAliasResponse(),
1964
+ self.call_api(params, req, runtime)
1965
+ )
2076
1966
 
2077
1967
  async def get_alias_with_options_async(
2078
1968
  self,
@@ -2102,16 +1992,10 @@ class Client(OpenApiClient):
2102
1992
  req_body_type='json',
2103
1993
  body_type='json'
2104
1994
  )
2105
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2106
- return TeaCore.from_map(
2107
- fc20230330_models.GetAliasResponse(),
2108
- await self.call_api_async(params, req, runtime)
2109
- )
2110
- else:
2111
- return TeaCore.from_map(
2112
- fc20230330_models.GetAliasResponse(),
2113
- await self.execute_async(params, req, runtime)
2114
- )
1995
+ return TeaCore.from_map(
1996
+ fc20230330_models.GetAliasResponse(),
1997
+ await self.call_api_async(params, req, runtime)
1998
+ )
2115
1999
 
2116
2000
  def get_alias(
2117
2001
  self,
@@ -2175,16 +2059,10 @@ class Client(OpenApiClient):
2175
2059
  req_body_type='json',
2176
2060
  body_type='json'
2177
2061
  )
2178
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2179
- return TeaCore.from_map(
2180
- fc20230330_models.GetAsyncInvokeConfigResponse(),
2181
- self.call_api(params, req, runtime)
2182
- )
2183
- else:
2184
- return TeaCore.from_map(
2185
- fc20230330_models.GetAsyncInvokeConfigResponse(),
2186
- self.execute(params, req, runtime)
2187
- )
2062
+ return TeaCore.from_map(
2063
+ fc20230330_models.GetAsyncInvokeConfigResponse(),
2064
+ self.call_api(params, req, runtime)
2065
+ )
2188
2066
 
2189
2067
  async def get_async_invoke_config_with_options_async(
2190
2068
  self,
@@ -2220,16 +2098,10 @@ class Client(OpenApiClient):
2220
2098
  req_body_type='json',
2221
2099
  body_type='json'
2222
2100
  )
2223
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2224
- return TeaCore.from_map(
2225
- fc20230330_models.GetAsyncInvokeConfigResponse(),
2226
- await self.call_api_async(params, req, runtime)
2227
- )
2228
- else:
2229
- return TeaCore.from_map(
2230
- fc20230330_models.GetAsyncInvokeConfigResponse(),
2231
- await self.execute_async(params, req, runtime)
2232
- )
2101
+ return TeaCore.from_map(
2102
+ fc20230330_models.GetAsyncInvokeConfigResponse(),
2103
+ await self.call_api_async(params, req, runtime)
2104
+ )
2233
2105
 
2234
2106
  def get_async_invoke_config(
2235
2107
  self,
@@ -2296,16 +2168,10 @@ class Client(OpenApiClient):
2296
2168
  req_body_type='json',
2297
2169
  body_type='json'
2298
2170
  )
2299
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2300
- return TeaCore.from_map(
2301
- fc20230330_models.GetAsyncTaskResponse(),
2302
- self.call_api(params, req, runtime)
2303
- )
2304
- else:
2305
- return TeaCore.from_map(
2306
- fc20230330_models.GetAsyncTaskResponse(),
2307
- self.execute(params, req, runtime)
2308
- )
2171
+ return TeaCore.from_map(
2172
+ fc20230330_models.GetAsyncTaskResponse(),
2173
+ self.call_api(params, req, runtime)
2174
+ )
2309
2175
 
2310
2176
  async def get_async_task_with_options_async(
2311
2177
  self,
@@ -2342,16 +2208,10 @@ class Client(OpenApiClient):
2342
2208
  req_body_type='json',
2343
2209
  body_type='json'
2344
2210
  )
2345
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2346
- return TeaCore.from_map(
2347
- fc20230330_models.GetAsyncTaskResponse(),
2348
- await self.call_api_async(params, req, runtime)
2349
- )
2350
- else:
2351
- return TeaCore.from_map(
2352
- fc20230330_models.GetAsyncTaskResponse(),
2353
- await self.execute_async(params, req, runtime)
2354
- )
2211
+ return TeaCore.from_map(
2212
+ fc20230330_models.GetAsyncTaskResponse(),
2213
+ await self.call_api_async(params, req, runtime)
2214
+ )
2355
2215
 
2356
2216
  def get_async_task(
2357
2217
  self,
@@ -2412,16 +2272,10 @@ class Client(OpenApiClient):
2412
2272
  req_body_type='json',
2413
2273
  body_type='json'
2414
2274
  )
2415
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2416
- return TeaCore.from_map(
2417
- fc20230330_models.GetConcurrencyConfigResponse(),
2418
- self.call_api(params, req, runtime)
2419
- )
2420
- else:
2421
- return TeaCore.from_map(
2422
- fc20230330_models.GetConcurrencyConfigResponse(),
2423
- self.execute(params, req, runtime)
2424
- )
2275
+ return TeaCore.from_map(
2276
+ fc20230330_models.GetConcurrencyConfigResponse(),
2277
+ self.call_api(params, req, runtime)
2278
+ )
2425
2279
 
2426
2280
  async def get_concurrency_config_with_options_async(
2427
2281
  self,
@@ -2450,16 +2304,10 @@ class Client(OpenApiClient):
2450
2304
  req_body_type='json',
2451
2305
  body_type='json'
2452
2306
  )
2453
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2454
- return TeaCore.from_map(
2455
- fc20230330_models.GetConcurrencyConfigResponse(),
2456
- await self.call_api_async(params, req, runtime)
2457
- )
2458
- else:
2459
- return TeaCore.from_map(
2460
- fc20230330_models.GetConcurrencyConfigResponse(),
2461
- await self.execute_async(params, req, runtime)
2462
- )
2307
+ return TeaCore.from_map(
2308
+ fc20230330_models.GetConcurrencyConfigResponse(),
2309
+ await self.call_api_async(params, req, runtime)
2310
+ )
2463
2311
 
2464
2312
  def get_concurrency_config(
2465
2313
  self,
@@ -2514,16 +2362,10 @@ class Client(OpenApiClient):
2514
2362
  req_body_type='json',
2515
2363
  body_type='json'
2516
2364
  )
2517
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2518
- return TeaCore.from_map(
2519
- fc20230330_models.GetCustomDomainResponse(),
2520
- self.call_api(params, req, runtime)
2521
- )
2522
- else:
2523
- return TeaCore.from_map(
2524
- fc20230330_models.GetCustomDomainResponse(),
2525
- self.execute(params, req, runtime)
2526
- )
2365
+ return TeaCore.from_map(
2366
+ fc20230330_models.GetCustomDomainResponse(),
2367
+ self.call_api(params, req, runtime)
2368
+ )
2527
2369
 
2528
2370
  async def get_custom_domain_with_options_async(
2529
2371
  self,
@@ -2552,16 +2394,10 @@ class Client(OpenApiClient):
2552
2394
  req_body_type='json',
2553
2395
  body_type='json'
2554
2396
  )
2555
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2556
- return TeaCore.from_map(
2557
- fc20230330_models.GetCustomDomainResponse(),
2558
- await self.call_api_async(params, req, runtime)
2559
- )
2560
- else:
2561
- return TeaCore.from_map(
2562
- fc20230330_models.GetCustomDomainResponse(),
2563
- await self.execute_async(params, req, runtime)
2564
- )
2397
+ return TeaCore.from_map(
2398
+ fc20230330_models.GetCustomDomainResponse(),
2399
+ await self.call_api_async(params, req, runtime)
2400
+ )
2565
2401
 
2566
2402
  def get_custom_domain(
2567
2403
  self,
@@ -2623,16 +2459,10 @@ class Client(OpenApiClient):
2623
2459
  req_body_type='json',
2624
2460
  body_type='json'
2625
2461
  )
2626
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2627
- return TeaCore.from_map(
2628
- fc20230330_models.GetFunctionResponse(),
2629
- self.call_api(params, req, runtime)
2630
- )
2631
- else:
2632
- return TeaCore.from_map(
2633
- fc20230330_models.GetFunctionResponse(),
2634
- self.execute(params, req, runtime)
2635
- )
2462
+ return TeaCore.from_map(
2463
+ fc20230330_models.GetFunctionResponse(),
2464
+ self.call_api(params, req, runtime)
2465
+ )
2636
2466
 
2637
2467
  async def get_function_with_options_async(
2638
2468
  self,
@@ -2668,16 +2498,10 @@ class Client(OpenApiClient):
2668
2498
  req_body_type='json',
2669
2499
  body_type='json'
2670
2500
  )
2671
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2672
- return TeaCore.from_map(
2673
- fc20230330_models.GetFunctionResponse(),
2674
- await self.call_api_async(params, req, runtime)
2675
- )
2676
- else:
2677
- return TeaCore.from_map(
2678
- fc20230330_models.GetFunctionResponse(),
2679
- await self.execute_async(params, req, runtime)
2680
- )
2501
+ return TeaCore.from_map(
2502
+ fc20230330_models.GetFunctionResponse(),
2503
+ await self.call_api_async(params, req, runtime)
2504
+ )
2681
2505
 
2682
2506
  def get_function(
2683
2507
  self,
@@ -2743,16 +2567,10 @@ class Client(OpenApiClient):
2743
2567
  req_body_type='json',
2744
2568
  body_type='json'
2745
2569
  )
2746
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2747
- return TeaCore.from_map(
2748
- fc20230330_models.GetFunctionCodeResponse(),
2749
- self.call_api(params, req, runtime)
2750
- )
2751
- else:
2752
- return TeaCore.from_map(
2753
- fc20230330_models.GetFunctionCodeResponse(),
2754
- self.execute(params, req, runtime)
2755
- )
2570
+ return TeaCore.from_map(
2571
+ fc20230330_models.GetFunctionCodeResponse(),
2572
+ self.call_api(params, req, runtime)
2573
+ )
2756
2574
 
2757
2575
  async def get_function_code_with_options_async(
2758
2576
  self,
@@ -2788,16 +2606,10 @@ class Client(OpenApiClient):
2788
2606
  req_body_type='json',
2789
2607
  body_type='json'
2790
2608
  )
2791
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2792
- return TeaCore.from_map(
2793
- fc20230330_models.GetFunctionCodeResponse(),
2794
- await self.call_api_async(params, req, runtime)
2795
- )
2796
- else:
2797
- return TeaCore.from_map(
2798
- fc20230330_models.GetFunctionCodeResponse(),
2799
- await self.execute_async(params, req, runtime)
2800
- )
2609
+ return TeaCore.from_map(
2610
+ fc20230330_models.GetFunctionCodeResponse(),
2611
+ await self.call_api_async(params, req, runtime)
2612
+ )
2801
2613
 
2802
2614
  def get_function_code(
2803
2615
  self,
@@ -2857,16 +2669,10 @@ class Client(OpenApiClient):
2857
2669
  req_body_type='json',
2858
2670
  body_type='json'
2859
2671
  )
2860
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2861
- return TeaCore.from_map(
2862
- fc20230330_models.GetLayerVersionResponse(),
2863
- self.call_api(params, req, runtime)
2864
- )
2865
- else:
2866
- return TeaCore.from_map(
2867
- fc20230330_models.GetLayerVersionResponse(),
2868
- self.execute(params, req, runtime)
2869
- )
2672
+ return TeaCore.from_map(
2673
+ fc20230330_models.GetLayerVersionResponse(),
2674
+ self.call_api(params, req, runtime)
2675
+ )
2870
2676
 
2871
2677
  async def get_layer_version_with_options_async(
2872
2678
  self,
@@ -2896,16 +2702,10 @@ class Client(OpenApiClient):
2896
2702
  req_body_type='json',
2897
2703
  body_type='json'
2898
2704
  )
2899
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2900
- return TeaCore.from_map(
2901
- fc20230330_models.GetLayerVersionResponse(),
2902
- await self.call_api_async(params, req, runtime)
2903
- )
2904
- else:
2905
- return TeaCore.from_map(
2906
- fc20230330_models.GetLayerVersionResponse(),
2907
- await self.execute_async(params, req, runtime)
2908
- )
2705
+ return TeaCore.from_map(
2706
+ fc20230330_models.GetLayerVersionResponse(),
2707
+ await self.call_api_async(params, req, runtime)
2708
+ )
2909
2709
 
2910
2710
  def get_layer_version(
2911
2711
  self,
@@ -2962,16 +2762,10 @@ class Client(OpenApiClient):
2962
2762
  req_body_type='json',
2963
2763
  body_type='json'
2964
2764
  )
2965
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2966
- return TeaCore.from_map(
2967
- fc20230330_models.GetLayerVersionByArnResponse(),
2968
- self.call_api(params, req, runtime)
2969
- )
2970
- else:
2971
- return TeaCore.from_map(
2972
- fc20230330_models.GetLayerVersionByArnResponse(),
2973
- self.execute(params, req, runtime)
2974
- )
2765
+ return TeaCore.from_map(
2766
+ fc20230330_models.GetLayerVersionByArnResponse(),
2767
+ self.call_api(params, req, runtime)
2768
+ )
2975
2769
 
2976
2770
  async def get_layer_version_by_arn_with_options_async(
2977
2771
  self,
@@ -3000,16 +2794,10 @@ class Client(OpenApiClient):
3000
2794
  req_body_type='json',
3001
2795
  body_type='json'
3002
2796
  )
3003
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3004
- return TeaCore.from_map(
3005
- fc20230330_models.GetLayerVersionByArnResponse(),
3006
- await self.call_api_async(params, req, runtime)
3007
- )
3008
- else:
3009
- return TeaCore.from_map(
3010
- fc20230330_models.GetLayerVersionByArnResponse(),
3011
- await self.execute_async(params, req, runtime)
3012
- )
2797
+ return TeaCore.from_map(
2798
+ fc20230330_models.GetLayerVersionByArnResponse(),
2799
+ await self.call_api_async(params, req, runtime)
2800
+ )
3013
2801
 
3014
2802
  def get_layer_version_by_arn(
3015
2803
  self,
@@ -3071,16 +2859,10 @@ class Client(OpenApiClient):
3071
2859
  req_body_type='json',
3072
2860
  body_type='json'
3073
2861
  )
3074
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3075
- return TeaCore.from_map(
3076
- fc20230330_models.GetProvisionConfigResponse(),
3077
- self.call_api(params, req, runtime)
3078
- )
3079
- else:
3080
- return TeaCore.from_map(
3081
- fc20230330_models.GetProvisionConfigResponse(),
3082
- self.execute(params, req, runtime)
3083
- )
2862
+ return TeaCore.from_map(
2863
+ fc20230330_models.GetProvisionConfigResponse(),
2864
+ self.call_api(params, req, runtime)
2865
+ )
3084
2866
 
3085
2867
  async def get_provision_config_with_options_async(
3086
2868
  self,
@@ -3116,16 +2898,10 @@ class Client(OpenApiClient):
3116
2898
  req_body_type='json',
3117
2899
  body_type='json'
3118
2900
  )
3119
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3120
- return TeaCore.from_map(
3121
- fc20230330_models.GetProvisionConfigResponse(),
3122
- await self.call_api_async(params, req, runtime)
3123
- )
3124
- else:
3125
- return TeaCore.from_map(
3126
- fc20230330_models.GetProvisionConfigResponse(),
3127
- await self.execute_async(params, req, runtime)
3128
- )
2901
+ return TeaCore.from_map(
2902
+ fc20230330_models.GetProvisionConfigResponse(),
2903
+ await self.call_api_async(params, req, runtime)
2904
+ )
3129
2905
 
3130
2906
  def get_provision_config(
3131
2907
  self,
@@ -3185,16 +2961,10 @@ class Client(OpenApiClient):
3185
2961
  req_body_type='json',
3186
2962
  body_type='json'
3187
2963
  )
3188
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3189
- return TeaCore.from_map(
3190
- fc20230330_models.GetTriggerResponse(),
3191
- self.call_api(params, req, runtime)
3192
- )
3193
- else:
3194
- return TeaCore.from_map(
3195
- fc20230330_models.GetTriggerResponse(),
3196
- self.execute(params, req, runtime)
3197
- )
2964
+ return TeaCore.from_map(
2965
+ fc20230330_models.GetTriggerResponse(),
2966
+ self.call_api(params, req, runtime)
2967
+ )
3198
2968
 
3199
2969
  async def get_trigger_with_options_async(
3200
2970
  self,
@@ -3224,16 +2994,10 @@ class Client(OpenApiClient):
3224
2994
  req_body_type='json',
3225
2995
  body_type='json'
3226
2996
  )
3227
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3228
- return TeaCore.from_map(
3229
- fc20230330_models.GetTriggerResponse(),
3230
- await self.call_api_async(params, req, runtime)
3231
- )
3232
- else:
3233
- return TeaCore.from_map(
3234
- fc20230330_models.GetTriggerResponse(),
3235
- await self.execute_async(params, req, runtime)
3236
- )
2997
+ return TeaCore.from_map(
2998
+ fc20230330_models.GetTriggerResponse(),
2999
+ await self.call_api_async(params, req, runtime)
3000
+ )
3237
3001
 
3238
3002
  def get_trigger(
3239
3003
  self,
@@ -3447,16 +3211,10 @@ class Client(OpenApiClient):
3447
3211
  req_body_type='json',
3448
3212
  body_type='json'
3449
3213
  )
3450
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3451
- return TeaCore.from_map(
3452
- fc20230330_models.ListAliasesResponse(),
3453
- self.call_api(params, req, runtime)
3454
- )
3455
- else:
3456
- return TeaCore.from_map(
3457
- fc20230330_models.ListAliasesResponse(),
3458
- self.execute(params, req, runtime)
3459
- )
3214
+ return TeaCore.from_map(
3215
+ fc20230330_models.ListAliasesResponse(),
3216
+ self.call_api(params, req, runtime)
3217
+ )
3460
3218
 
3461
3219
  async def list_aliases_with_options_async(
3462
3220
  self,
@@ -3496,16 +3254,10 @@ class Client(OpenApiClient):
3496
3254
  req_body_type='json',
3497
3255
  body_type='json'
3498
3256
  )
3499
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3500
- return TeaCore.from_map(
3501
- fc20230330_models.ListAliasesResponse(),
3502
- await self.call_api_async(params, req, runtime)
3503
- )
3504
- else:
3505
- return TeaCore.from_map(
3506
- fc20230330_models.ListAliasesResponse(),
3507
- await self.execute_async(params, req, runtime)
3508
- )
3257
+ return TeaCore.from_map(
3258
+ fc20230330_models.ListAliasesResponse(),
3259
+ await self.call_api_async(params, req, runtime)
3260
+ )
3509
3261
 
3510
3262
  def list_aliases(
3511
3263
  self,
@@ -3574,16 +3326,10 @@ class Client(OpenApiClient):
3574
3326
  req_body_type='json',
3575
3327
  body_type='json'
3576
3328
  )
3577
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3578
- return TeaCore.from_map(
3579
- fc20230330_models.ListAsyncInvokeConfigsResponse(),
3580
- self.call_api(params, req, runtime)
3581
- )
3582
- else:
3583
- return TeaCore.from_map(
3584
- fc20230330_models.ListAsyncInvokeConfigsResponse(),
3585
- self.execute(params, req, runtime)
3586
- )
3329
+ return TeaCore.from_map(
3330
+ fc20230330_models.ListAsyncInvokeConfigsResponse(),
3331
+ self.call_api(params, req, runtime)
3332
+ )
3587
3333
 
3588
3334
  async def list_async_invoke_configs_with_options_async(
3589
3335
  self,
@@ -3622,16 +3368,10 @@ class Client(OpenApiClient):
3622
3368
  req_body_type='json',
3623
3369
  body_type='json'
3624
3370
  )
3625
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3626
- return TeaCore.from_map(
3627
- fc20230330_models.ListAsyncInvokeConfigsResponse(),
3628
- await self.call_api_async(params, req, runtime)
3629
- )
3630
- else:
3631
- return TeaCore.from_map(
3632
- fc20230330_models.ListAsyncInvokeConfigsResponse(),
3633
- await self.execute_async(params, req, runtime)
3634
- )
3371
+ return TeaCore.from_map(
3372
+ fc20230330_models.ListAsyncInvokeConfigsResponse(),
3373
+ await self.call_api_async(params, req, runtime)
3374
+ )
3635
3375
 
3636
3376
  def list_async_invoke_configs(
3637
3377
  self,
@@ -3711,16 +3451,10 @@ class Client(OpenApiClient):
3711
3451
  req_body_type='json',
3712
3452
  body_type='json'
3713
3453
  )
3714
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3715
- return TeaCore.from_map(
3716
- fc20230330_models.ListAsyncTasksResponse(),
3717
- self.call_api(params, req, runtime)
3718
- )
3719
- else:
3720
- return TeaCore.from_map(
3721
- fc20230330_models.ListAsyncTasksResponse(),
3722
- self.execute(params, req, runtime)
3723
- )
3454
+ return TeaCore.from_map(
3455
+ fc20230330_models.ListAsyncTasksResponse(),
3456
+ self.call_api(params, req, runtime)
3457
+ )
3724
3458
 
3725
3459
  async def list_async_tasks_with_options_async(
3726
3460
  self,
@@ -3772,16 +3506,10 @@ class Client(OpenApiClient):
3772
3506
  req_body_type='json',
3773
3507
  body_type='json'
3774
3508
  )
3775
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3776
- return TeaCore.from_map(
3777
- fc20230330_models.ListAsyncTasksResponse(),
3778
- await self.call_api_async(params, req, runtime)
3779
- )
3780
- else:
3781
- return TeaCore.from_map(
3782
- fc20230330_models.ListAsyncTasksResponse(),
3783
- await self.execute_async(params, req, runtime)
3784
- )
3509
+ return TeaCore.from_map(
3510
+ fc20230330_models.ListAsyncTasksResponse(),
3511
+ await self.call_api_async(params, req, runtime)
3512
+ )
3785
3513
 
3786
3514
  def list_async_tasks(
3787
3515
  self,
@@ -3850,16 +3578,10 @@ class Client(OpenApiClient):
3850
3578
  req_body_type='json',
3851
3579
  body_type='json'
3852
3580
  )
3853
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3854
- return TeaCore.from_map(
3855
- fc20230330_models.ListConcurrencyConfigsResponse(),
3856
- self.call_api(params, req, runtime)
3857
- )
3858
- else:
3859
- return TeaCore.from_map(
3860
- fc20230330_models.ListConcurrencyConfigsResponse(),
3861
- self.execute(params, req, runtime)
3862
- )
3581
+ return TeaCore.from_map(
3582
+ fc20230330_models.ListConcurrencyConfigsResponse(),
3583
+ self.call_api(params, req, runtime)
3584
+ )
3863
3585
 
3864
3586
  async def list_concurrency_configs_with_options_async(
3865
3587
  self,
@@ -3898,16 +3620,10 @@ class Client(OpenApiClient):
3898
3620
  req_body_type='json',
3899
3621
  body_type='json'
3900
3622
  )
3901
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3902
- return TeaCore.from_map(
3903
- fc20230330_models.ListConcurrencyConfigsResponse(),
3904
- await self.call_api_async(params, req, runtime)
3905
- )
3906
- else:
3907
- return TeaCore.from_map(
3908
- fc20230330_models.ListConcurrencyConfigsResponse(),
3909
- await self.execute_async(params, req, runtime)
3910
- )
3623
+ return TeaCore.from_map(
3624
+ fc20230330_models.ListConcurrencyConfigsResponse(),
3625
+ await self.call_api_async(params, req, runtime)
3626
+ )
3911
3627
 
3912
3628
  def list_concurrency_configs(
3913
3629
  self,
@@ -3974,16 +3690,10 @@ class Client(OpenApiClient):
3974
3690
  req_body_type='json',
3975
3691
  body_type='json'
3976
3692
  )
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.ListCustomDomainsResponse(),
3980
- self.call_api(params, req, runtime)
3981
- )
3982
- else:
3983
- return TeaCore.from_map(
3984
- fc20230330_models.ListCustomDomainsResponse(),
3985
- self.execute(params, req, runtime)
3986
- )
3693
+ return TeaCore.from_map(
3694
+ fc20230330_models.ListCustomDomainsResponse(),
3695
+ self.call_api(params, req, runtime)
3696
+ )
3987
3697
 
3988
3698
  async def list_custom_domains_with_options_async(
3989
3699
  self,
@@ -4022,16 +3732,10 @@ class Client(OpenApiClient):
4022
3732
  req_body_type='json',
4023
3733
  body_type='json'
4024
3734
  )
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.ListCustomDomainsResponse(),
4028
- await self.call_api_async(params, req, runtime)
4029
- )
4030
- else:
4031
- return TeaCore.from_map(
4032
- fc20230330_models.ListCustomDomainsResponse(),
4033
- await self.execute_async(params, req, runtime)
4034
- )
3735
+ return TeaCore.from_map(
3736
+ fc20230330_models.ListCustomDomainsResponse(),
3737
+ await self.call_api_async(params, req, runtime)
3738
+ )
4035
3739
 
4036
3740
  def list_custom_domains(
4037
3741
  self,
@@ -4099,16 +3803,10 @@ class Client(OpenApiClient):
4099
3803
  req_body_type='json',
4100
3804
  body_type='json'
4101
3805
  )
4102
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4103
- return TeaCore.from_map(
4104
- fc20230330_models.ListFunctionVersionsResponse(),
4105
- self.call_api(params, req, runtime)
4106
- )
4107
- else:
4108
- return TeaCore.from_map(
4109
- fc20230330_models.ListFunctionVersionsResponse(),
4110
- self.execute(params, req, runtime)
4111
- )
3806
+ return TeaCore.from_map(
3807
+ fc20230330_models.ListFunctionVersionsResponse(),
3808
+ self.call_api(params, req, runtime)
3809
+ )
4112
3810
 
4113
3811
  async def list_function_versions_with_options_async(
4114
3812
  self,
@@ -4148,16 +3846,10 @@ class Client(OpenApiClient):
4148
3846
  req_body_type='json',
4149
3847
  body_type='json'
4150
3848
  )
4151
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4152
- return TeaCore.from_map(
4153
- fc20230330_models.ListFunctionVersionsResponse(),
4154
- await self.call_api_async(params, req, runtime)
4155
- )
4156
- else:
4157
- return TeaCore.from_map(
4158
- fc20230330_models.ListFunctionVersionsResponse(),
4159
- await self.execute_async(params, req, runtime)
4160
- )
3849
+ return TeaCore.from_map(
3850
+ fc20230330_models.ListFunctionVersionsResponse(),
3851
+ await self.call_api_async(params, req, runtime)
3852
+ )
4161
3853
 
4162
3854
  def list_function_versions(
4163
3855
  self,
@@ -4198,6 +3890,8 @@ class Client(OpenApiClient):
4198
3890
  """
4199
3891
  @summary 列出函数。
4200
3892
 
3893
+ @description ListFunctions returns only a subset of a function\\"s attribute fields. To obtain the additional fields, which include state, stateReasonCode, stateReason, lastUpdateStatus, lastUpdateStatusReasonCode, and lastUpdateStatusReason, use [GetFunction](https://help.aliyun.com/document_detail/2618610.html).
3894
+
4201
3895
  @param tmp_req: ListFunctionsRequest
4202
3896
  @param headers: map
4203
3897
  @param runtime: runtime options for this request RuntimeOptions
@@ -4240,16 +3934,10 @@ class Client(OpenApiClient):
4240
3934
  req_body_type='json',
4241
3935
  body_type='json'
4242
3936
  )
4243
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4244
- return TeaCore.from_map(
4245
- fc20230330_models.ListFunctionsResponse(),
4246
- self.call_api(params, req, runtime)
4247
- )
4248
- else:
4249
- return TeaCore.from_map(
4250
- fc20230330_models.ListFunctionsResponse(),
4251
- self.execute(params, req, runtime)
4252
- )
3937
+ return TeaCore.from_map(
3938
+ fc20230330_models.ListFunctionsResponse(),
3939
+ self.call_api(params, req, runtime)
3940
+ )
4253
3941
 
4254
3942
  async def list_functions_with_options_async(
4255
3943
  self,
@@ -4260,6 +3948,8 @@ class Client(OpenApiClient):
4260
3948
  """
4261
3949
  @summary 列出函数。
4262
3950
 
3951
+ @description ListFunctions returns only a subset of a function\\"s attribute fields. To obtain the additional fields, which include state, stateReasonCode, stateReason, lastUpdateStatus, lastUpdateStatusReasonCode, and lastUpdateStatusReason, use [GetFunction](https://help.aliyun.com/document_detail/2618610.html).
3952
+
4263
3953
  @param tmp_req: ListFunctionsRequest
4264
3954
  @param headers: map
4265
3955
  @param runtime: runtime options for this request RuntimeOptions
@@ -4302,16 +3992,10 @@ class Client(OpenApiClient):
4302
3992
  req_body_type='json',
4303
3993
  body_type='json'
4304
3994
  )
4305
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4306
- return TeaCore.from_map(
4307
- fc20230330_models.ListFunctionsResponse(),
4308
- await self.call_api_async(params, req, runtime)
4309
- )
4310
- else:
4311
- return TeaCore.from_map(
4312
- fc20230330_models.ListFunctionsResponse(),
4313
- await self.execute_async(params, req, runtime)
4314
- )
3995
+ return TeaCore.from_map(
3996
+ fc20230330_models.ListFunctionsResponse(),
3997
+ await self.call_api_async(params, req, runtime)
3998
+ )
4315
3999
 
4316
4000
  def list_functions(
4317
4001
  self,
@@ -4320,6 +4004,8 @@ class Client(OpenApiClient):
4320
4004
  """
4321
4005
  @summary 列出函数。
4322
4006
 
4007
+ @description ListFunctions returns only a subset of a function\\"s attribute fields. To obtain the additional fields, which include state, stateReasonCode, stateReason, lastUpdateStatus, lastUpdateStatusReasonCode, and lastUpdateStatusReason, use [GetFunction](https://help.aliyun.com/document_detail/2618610.html).
4008
+
4323
4009
  @param request: ListFunctionsRequest
4324
4010
  @return: ListFunctionsResponse
4325
4011
  """
@@ -4334,6 +4020,8 @@ class Client(OpenApiClient):
4334
4020
  """
4335
4021
  @summary 列出函数。
4336
4022
 
4023
+ @description ListFunctions returns only a subset of a function\\"s attribute fields. To obtain the additional fields, which include state, stateReasonCode, stateReason, lastUpdateStatus, lastUpdateStatusReasonCode, and lastUpdateStatusReason, use [GetFunction](https://help.aliyun.com/document_detail/2618610.html).
4024
+
4337
4025
  @param request: ListFunctionsRequest
4338
4026
  @return: ListFunctionsResponse
4339
4027
  """
@@ -4395,16 +4083,10 @@ class Client(OpenApiClient):
4395
4083
  req_body_type='json',
4396
4084
  body_type='json'
4397
4085
  )
4398
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4399
- return TeaCore.from_map(
4400
- fc20230330_models.ListInstancesResponse(),
4401
- self.call_api(params, req, runtime)
4402
- )
4403
- else:
4404
- return TeaCore.from_map(
4405
- fc20230330_models.ListInstancesResponse(),
4406
- self.execute(params, req, runtime)
4407
- )
4086
+ return TeaCore.from_map(
4087
+ fc20230330_models.ListInstancesResponse(),
4088
+ self.call_api(params, req, runtime)
4089
+ )
4408
4090
 
4409
4091
  async def list_instances_with_options_async(
4410
4092
  self,
@@ -4460,16 +4142,10 @@ class Client(OpenApiClient):
4460
4142
  req_body_type='json',
4461
4143
  body_type='json'
4462
4144
  )
4463
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4464
- return TeaCore.from_map(
4465
- fc20230330_models.ListInstancesResponse(),
4466
- await self.call_api_async(params, req, runtime)
4467
- )
4468
- else:
4469
- return TeaCore.from_map(
4470
- fc20230330_models.ListInstancesResponse(),
4471
- await self.execute_async(params, req, runtime)
4472
- )
4145
+ return TeaCore.from_map(
4146
+ fc20230330_models.ListInstancesResponse(),
4147
+ await self.call_api_async(params, req, runtime)
4148
+ )
4473
4149
 
4474
4150
  def list_instances(
4475
4151
  self,
@@ -4537,16 +4213,10 @@ class Client(OpenApiClient):
4537
4213
  req_body_type='json',
4538
4214
  body_type='json'
4539
4215
  )
4540
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4541
- return TeaCore.from_map(
4542
- fc20230330_models.ListLayerVersionsResponse(),
4543
- self.call_api(params, req, runtime)
4544
- )
4545
- else:
4546
- return TeaCore.from_map(
4547
- fc20230330_models.ListLayerVersionsResponse(),
4548
- self.execute(params, req, runtime)
4549
- )
4216
+ return TeaCore.from_map(
4217
+ fc20230330_models.ListLayerVersionsResponse(),
4218
+ self.call_api(params, req, runtime)
4219
+ )
4550
4220
 
4551
4221
  async def list_layer_versions_with_options_async(
4552
4222
  self,
@@ -4584,16 +4254,10 @@ class Client(OpenApiClient):
4584
4254
  req_body_type='json',
4585
4255
  body_type='json'
4586
4256
  )
4587
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4588
- return TeaCore.from_map(
4589
- fc20230330_models.ListLayerVersionsResponse(),
4590
- await self.call_api_async(params, req, runtime)
4591
- )
4592
- else:
4593
- return TeaCore.from_map(
4594
- fc20230330_models.ListLayerVersionsResponse(),
4595
- await self.execute_async(params, req, runtime)
4596
- )
4257
+ return TeaCore.from_map(
4258
+ fc20230330_models.ListLayerVersionsResponse(),
4259
+ await self.call_api_async(params, req, runtime)
4260
+ )
4597
4261
 
4598
4262
  def list_layer_versions(
4599
4263
  self,
@@ -4666,16 +4330,10 @@ class Client(OpenApiClient):
4666
4330
  req_body_type='json',
4667
4331
  body_type='json'
4668
4332
  )
4669
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4670
- return TeaCore.from_map(
4671
- fc20230330_models.ListLayersResponse(),
4672
- self.call_api(params, req, runtime)
4673
- )
4674
- else:
4675
- return TeaCore.from_map(
4676
- fc20230330_models.ListLayersResponse(),
4677
- self.execute(params, req, runtime)
4678
- )
4333
+ return TeaCore.from_map(
4334
+ fc20230330_models.ListLayersResponse(),
4335
+ self.call_api(params, req, runtime)
4336
+ )
4679
4337
 
4680
4338
  async def list_layers_with_options_async(
4681
4339
  self,
@@ -4718,16 +4376,10 @@ class Client(OpenApiClient):
4718
4376
  req_body_type='json',
4719
4377
  body_type='json'
4720
4378
  )
4721
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4722
- return TeaCore.from_map(
4723
- fc20230330_models.ListLayersResponse(),
4724
- await self.call_api_async(params, req, runtime)
4725
- )
4726
- else:
4727
- return TeaCore.from_map(
4728
- fc20230330_models.ListLayersResponse(),
4729
- await self.execute_async(params, req, runtime)
4730
- )
4379
+ return TeaCore.from_map(
4380
+ fc20230330_models.ListLayersResponse(),
4381
+ await self.call_api_async(params, req, runtime)
4382
+ )
4731
4383
 
4732
4384
  def list_layers(
4733
4385
  self,
@@ -4794,16 +4446,10 @@ class Client(OpenApiClient):
4794
4446
  req_body_type='json',
4795
4447
  body_type='json'
4796
4448
  )
4797
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4798
- return TeaCore.from_map(
4799
- fc20230330_models.ListProvisionConfigsResponse(),
4800
- self.call_api(params, req, runtime)
4801
- )
4802
- else:
4803
- return TeaCore.from_map(
4804
- fc20230330_models.ListProvisionConfigsResponse(),
4805
- self.execute(params, req, runtime)
4806
- )
4449
+ return TeaCore.from_map(
4450
+ fc20230330_models.ListProvisionConfigsResponse(),
4451
+ self.call_api(params, req, runtime)
4452
+ )
4807
4453
 
4808
4454
  async def list_provision_configs_with_options_async(
4809
4455
  self,
@@ -4842,16 +4488,10 @@ class Client(OpenApiClient):
4842
4488
  req_body_type='json',
4843
4489
  body_type='json'
4844
4490
  )
4845
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4846
- return TeaCore.from_map(
4847
- fc20230330_models.ListProvisionConfigsResponse(),
4848
- await self.call_api_async(params, req, runtime)
4849
- )
4850
- else:
4851
- return TeaCore.from_map(
4852
- fc20230330_models.ListProvisionConfigsResponse(),
4853
- await self.execute_async(params, req, runtime)
4854
- )
4491
+ return TeaCore.from_map(
4492
+ fc20230330_models.ListProvisionConfigsResponse(),
4493
+ await self.call_api_async(params, req, runtime)
4494
+ )
4855
4495
 
4856
4496
  def list_provision_configs(
4857
4497
  self,
@@ -4928,16 +4568,10 @@ class Client(OpenApiClient):
4928
4568
  req_body_type='json',
4929
4569
  body_type='json'
4930
4570
  )
4931
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4932
- return TeaCore.from_map(
4933
- fc20230330_models.ListTagResourcesResponse(),
4934
- self.call_api(params, req, runtime)
4935
- )
4936
- else:
4937
- return TeaCore.from_map(
4938
- fc20230330_models.ListTagResourcesResponse(),
4939
- self.execute(params, req, runtime)
4940
- )
4571
+ return TeaCore.from_map(
4572
+ fc20230330_models.ListTagResourcesResponse(),
4573
+ self.call_api(params, req, runtime)
4574
+ )
4941
4575
 
4942
4576
  async def list_tag_resources_with_options_async(
4943
4577
  self,
@@ -4986,16 +4620,10 @@ class Client(OpenApiClient):
4986
4620
  req_body_type='json',
4987
4621
  body_type='json'
4988
4622
  )
4989
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4990
- return TeaCore.from_map(
4991
- fc20230330_models.ListTagResourcesResponse(),
4992
- await self.call_api_async(params, req, runtime)
4993
- )
4994
- else:
4995
- return TeaCore.from_map(
4996
- fc20230330_models.ListTagResourcesResponse(),
4997
- await self.execute_async(params, req, runtime)
4998
- )
4623
+ return TeaCore.from_map(
4624
+ fc20230330_models.ListTagResourcesResponse(),
4625
+ await self.call_api_async(params, req, runtime)
4626
+ )
4999
4627
 
5000
4628
  def list_tag_resources(
5001
4629
  self,
@@ -5063,16 +4691,10 @@ class Client(OpenApiClient):
5063
4691
  req_body_type='json',
5064
4692
  body_type='json'
5065
4693
  )
5066
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5067
- return TeaCore.from_map(
5068
- fc20230330_models.ListTriggersResponse(),
5069
- self.call_api(params, req, runtime)
5070
- )
5071
- else:
5072
- return TeaCore.from_map(
5073
- fc20230330_models.ListTriggersResponse(),
5074
- self.execute(params, req, runtime)
5075
- )
4694
+ return TeaCore.from_map(
4695
+ fc20230330_models.ListTriggersResponse(),
4696
+ self.call_api(params, req, runtime)
4697
+ )
5076
4698
 
5077
4699
  async def list_triggers_with_options_async(
5078
4700
  self,
@@ -5112,16 +4734,10 @@ class Client(OpenApiClient):
5112
4734
  req_body_type='json',
5113
4735
  body_type='json'
5114
4736
  )
5115
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5116
- return TeaCore.from_map(
5117
- fc20230330_models.ListTriggersResponse(),
5118
- await self.call_api_async(params, req, runtime)
5119
- )
5120
- else:
5121
- return TeaCore.from_map(
5122
- fc20230330_models.ListTriggersResponse(),
5123
- await self.execute_async(params, req, runtime)
5124
- )
4737
+ return TeaCore.from_map(
4738
+ fc20230330_models.ListTriggersResponse(),
4739
+ await self.call_api_async(params, req, runtime)
4740
+ )
5125
4741
 
5126
4742
  def list_triggers(
5127
4743
  self,
@@ -5180,16 +4796,10 @@ class Client(OpenApiClient):
5180
4796
  req_body_type='json',
5181
4797
  body_type='json'
5182
4798
  )
5183
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5184
- return TeaCore.from_map(
5185
- fc20230330_models.ListVpcBindingsResponse(),
5186
- self.call_api(params, req, runtime)
5187
- )
5188
- else:
5189
- return TeaCore.from_map(
5190
- fc20230330_models.ListVpcBindingsResponse(),
5191
- self.execute(params, req, runtime)
5192
- )
4799
+ return TeaCore.from_map(
4800
+ fc20230330_models.ListVpcBindingsResponse(),
4801
+ self.call_api(params, req, runtime)
4802
+ )
5193
4803
 
5194
4804
  async def list_vpc_bindings_with_options_async(
5195
4805
  self,
@@ -5218,16 +4828,10 @@ class Client(OpenApiClient):
5218
4828
  req_body_type='json',
5219
4829
  body_type='json'
5220
4830
  )
5221
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5222
- return TeaCore.from_map(
5223
- fc20230330_models.ListVpcBindingsResponse(),
5224
- await self.call_api_async(params, req, runtime)
5225
- )
5226
- else:
5227
- return TeaCore.from_map(
5228
- fc20230330_models.ListVpcBindingsResponse(),
5229
- await self.execute_async(params, req, runtime)
5230
- )
4831
+ return TeaCore.from_map(
4832
+ fc20230330_models.ListVpcBindingsResponse(),
4833
+ await self.call_api_async(params, req, runtime)
4834
+ )
5231
4835
 
5232
4836
  def list_vpc_bindings(
5233
4837
  self,
@@ -5286,16 +4890,10 @@ class Client(OpenApiClient):
5286
4890
  req_body_type='json',
5287
4891
  body_type='json'
5288
4892
  )
5289
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5290
- return TeaCore.from_map(
5291
- fc20230330_models.PublishFunctionVersionResponse(),
5292
- self.call_api(params, req, runtime)
5293
- )
5294
- else:
5295
- return TeaCore.from_map(
5296
- fc20230330_models.PublishFunctionVersionResponse(),
5297
- self.execute(params, req, runtime)
5298
- )
4893
+ return TeaCore.from_map(
4894
+ fc20230330_models.PublishFunctionVersionResponse(),
4895
+ self.call_api(params, req, runtime)
4896
+ )
5299
4897
 
5300
4898
  async def publish_function_version_with_options_async(
5301
4899
  self,
@@ -5328,16 +4926,10 @@ class Client(OpenApiClient):
5328
4926
  req_body_type='json',
5329
4927
  body_type='json'
5330
4928
  )
5331
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5332
- return TeaCore.from_map(
5333
- fc20230330_models.PublishFunctionVersionResponse(),
5334
- await self.call_api_async(params, req, runtime)
5335
- )
5336
- else:
5337
- return TeaCore.from_map(
5338
- fc20230330_models.PublishFunctionVersionResponse(),
5339
- await self.execute_async(params, req, runtime)
5340
- )
4929
+ return TeaCore.from_map(
4930
+ fc20230330_models.PublishFunctionVersionResponse(),
4931
+ await self.call_api_async(params, req, runtime)
4932
+ )
5341
4933
 
5342
4934
  def publish_function_version(
5343
4935
  self,
@@ -5404,16 +4996,10 @@ class Client(OpenApiClient):
5404
4996
  req_body_type='json',
5405
4997
  body_type='json'
5406
4998
  )
5407
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5408
- return TeaCore.from_map(
5409
- fc20230330_models.PutAsyncInvokeConfigResponse(),
5410
- self.call_api(params, req, runtime)
5411
- )
5412
- else:
5413
- return TeaCore.from_map(
5414
- fc20230330_models.PutAsyncInvokeConfigResponse(),
5415
- self.execute(params, req, runtime)
5416
- )
4999
+ return TeaCore.from_map(
5000
+ fc20230330_models.PutAsyncInvokeConfigResponse(),
5001
+ self.call_api(params, req, runtime)
5002
+ )
5417
5003
 
5418
5004
  async def put_async_invoke_config_with_options_async(
5419
5005
  self,
@@ -5450,16 +5036,10 @@ class Client(OpenApiClient):
5450
5036
  req_body_type='json',
5451
5037
  body_type='json'
5452
5038
  )
5453
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5454
- return TeaCore.from_map(
5455
- fc20230330_models.PutAsyncInvokeConfigResponse(),
5456
- await self.call_api_async(params, req, runtime)
5457
- )
5458
- else:
5459
- return TeaCore.from_map(
5460
- fc20230330_models.PutAsyncInvokeConfigResponse(),
5461
- await self.execute_async(params, req, runtime)
5462
- )
5039
+ return TeaCore.from_map(
5040
+ fc20230330_models.PutAsyncInvokeConfigResponse(),
5041
+ await self.call_api_async(params, req, runtime)
5042
+ )
5463
5043
 
5464
5044
  def put_async_invoke_config(
5465
5045
  self,
@@ -5522,16 +5102,10 @@ class Client(OpenApiClient):
5522
5102
  req_body_type='json',
5523
5103
  body_type='json'
5524
5104
  )
5525
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5526
- return TeaCore.from_map(
5527
- fc20230330_models.PutConcurrencyConfigResponse(),
5528
- self.call_api(params, req, runtime)
5529
- )
5530
- else:
5531
- return TeaCore.from_map(
5532
- fc20230330_models.PutConcurrencyConfigResponse(),
5533
- self.execute(params, req, runtime)
5534
- )
5105
+ return TeaCore.from_map(
5106
+ fc20230330_models.PutConcurrencyConfigResponse(),
5107
+ self.call_api(params, req, runtime)
5108
+ )
5535
5109
 
5536
5110
  async def put_concurrency_config_with_options_async(
5537
5111
  self,
@@ -5564,16 +5138,10 @@ class Client(OpenApiClient):
5564
5138
  req_body_type='json',
5565
5139
  body_type='json'
5566
5140
  )
5567
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5568
- return TeaCore.from_map(
5569
- fc20230330_models.PutConcurrencyConfigResponse(),
5570
- await self.call_api_async(params, req, runtime)
5571
- )
5572
- else:
5573
- return TeaCore.from_map(
5574
- fc20230330_models.PutConcurrencyConfigResponse(),
5575
- await self.execute_async(params, req, runtime)
5576
- )
5141
+ return TeaCore.from_map(
5142
+ fc20230330_models.PutConcurrencyConfigResponse(),
5143
+ await self.call_api_async(params, req, runtime)
5144
+ )
5577
5145
 
5578
5146
  def put_concurrency_config(
5579
5147
  self,
@@ -5641,16 +5209,10 @@ class Client(OpenApiClient):
5641
5209
  req_body_type='json',
5642
5210
  body_type='none'
5643
5211
  )
5644
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5645
- return TeaCore.from_map(
5646
- fc20230330_models.PutLayerACLResponse(),
5647
- self.call_api(params, req, runtime)
5648
- )
5649
- else:
5650
- return TeaCore.from_map(
5651
- fc20230330_models.PutLayerACLResponse(),
5652
- self.execute(params, req, runtime)
5653
- )
5212
+ return TeaCore.from_map(
5213
+ fc20230330_models.PutLayerACLResponse(),
5214
+ self.call_api(params, req, runtime)
5215
+ )
5654
5216
 
5655
5217
  async def put_layer_aclwith_options_async(
5656
5218
  self,
@@ -5688,16 +5250,10 @@ class Client(OpenApiClient):
5688
5250
  req_body_type='json',
5689
5251
  body_type='none'
5690
5252
  )
5691
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5692
- return TeaCore.from_map(
5693
- fc20230330_models.PutLayerACLResponse(),
5694
- await self.call_api_async(params, req, runtime)
5695
- )
5696
- else:
5697
- return TeaCore.from_map(
5698
- fc20230330_models.PutLayerACLResponse(),
5699
- await self.execute_async(params, req, runtime)
5700
- )
5253
+ return TeaCore.from_map(
5254
+ fc20230330_models.PutLayerACLResponse(),
5255
+ await self.call_api_async(params, req, runtime)
5256
+ )
5701
5257
 
5702
5258
  def put_layer_acl(
5703
5259
  self,
@@ -5764,16 +5320,10 @@ class Client(OpenApiClient):
5764
5320
  req_body_type='json',
5765
5321
  body_type='json'
5766
5322
  )
5767
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5768
- return TeaCore.from_map(
5769
- fc20230330_models.PutProvisionConfigResponse(),
5770
- self.call_api(params, req, runtime)
5771
- )
5772
- else:
5773
- return TeaCore.from_map(
5774
- fc20230330_models.PutProvisionConfigResponse(),
5775
- self.execute(params, req, runtime)
5776
- )
5323
+ return TeaCore.from_map(
5324
+ fc20230330_models.PutProvisionConfigResponse(),
5325
+ self.call_api(params, req, runtime)
5326
+ )
5777
5327
 
5778
5328
  async def put_provision_config_with_options_async(
5779
5329
  self,
@@ -5810,16 +5360,10 @@ class Client(OpenApiClient):
5810
5360
  req_body_type='json',
5811
5361
  body_type='json'
5812
5362
  )
5813
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5814
- return TeaCore.from_map(
5815
- fc20230330_models.PutProvisionConfigResponse(),
5816
- await self.call_api_async(params, req, runtime)
5817
- )
5818
- else:
5819
- return TeaCore.from_map(
5820
- fc20230330_models.PutProvisionConfigResponse(),
5821
- await self.execute_async(params, req, runtime)
5822
- )
5363
+ return TeaCore.from_map(
5364
+ fc20230330_models.PutProvisionConfigResponse(),
5365
+ await self.call_api_async(params, req, runtime)
5366
+ )
5823
5367
 
5824
5368
  def put_provision_config(
5825
5369
  self,
@@ -5886,16 +5430,10 @@ class Client(OpenApiClient):
5886
5430
  req_body_type='json',
5887
5431
  body_type='none'
5888
5432
  )
5889
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5890
- return TeaCore.from_map(
5891
- fc20230330_models.StopAsyncTaskResponse(),
5892
- self.call_api(params, req, runtime)
5893
- )
5894
- else:
5895
- return TeaCore.from_map(
5896
- fc20230330_models.StopAsyncTaskResponse(),
5897
- self.execute(params, req, runtime)
5898
- )
5433
+ return TeaCore.from_map(
5434
+ fc20230330_models.StopAsyncTaskResponse(),
5435
+ self.call_api(params, req, runtime)
5436
+ )
5899
5437
 
5900
5438
  async def stop_async_task_with_options_async(
5901
5439
  self,
@@ -5932,16 +5470,10 @@ class Client(OpenApiClient):
5932
5470
  req_body_type='json',
5933
5471
  body_type='none'
5934
5472
  )
5935
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5936
- return TeaCore.from_map(
5937
- fc20230330_models.StopAsyncTaskResponse(),
5938
- await self.call_api_async(params, req, runtime)
5939
- )
5940
- else:
5941
- return TeaCore.from_map(
5942
- fc20230330_models.StopAsyncTaskResponse(),
5943
- await self.execute_async(params, req, runtime)
5944
- )
5473
+ return TeaCore.from_map(
5474
+ fc20230330_models.StopAsyncTaskResponse(),
5475
+ await self.call_api_async(params, req, runtime)
5476
+ )
5945
5477
 
5946
5478
  def stop_async_task(
5947
5479
  self,
@@ -6007,16 +5539,10 @@ class Client(OpenApiClient):
6007
5539
  req_body_type='json',
6008
5540
  body_type='none'
6009
5541
  )
6010
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6011
- return TeaCore.from_map(
6012
- fc20230330_models.TagResourcesResponse(),
6013
- self.call_api(params, req, runtime)
6014
- )
6015
- else:
6016
- return TeaCore.from_map(
6017
- fc20230330_models.TagResourcesResponse(),
6018
- self.execute(params, req, runtime)
6019
- )
5542
+ return TeaCore.from_map(
5543
+ fc20230330_models.TagResourcesResponse(),
5544
+ self.call_api(params, req, runtime)
5545
+ )
6020
5546
 
6021
5547
  async def tag_resources_with_options_async(
6022
5548
  self,
@@ -6050,16 +5576,10 @@ class Client(OpenApiClient):
6050
5576
  req_body_type='json',
6051
5577
  body_type='none'
6052
5578
  )
6053
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6054
- return TeaCore.from_map(
6055
- fc20230330_models.TagResourcesResponse(),
6056
- await self.call_api_async(params, req, runtime)
6057
- )
6058
- else:
6059
- return TeaCore.from_map(
6060
- fc20230330_models.TagResourcesResponse(),
6061
- await self.execute_async(params, req, runtime)
6062
- )
5579
+ return TeaCore.from_map(
5580
+ fc20230330_models.TagResourcesResponse(),
5581
+ await self.call_api_async(params, req, runtime)
5582
+ )
6063
5583
 
6064
5584
  def tag_resources(
6065
5585
  self,
@@ -6138,16 +5658,10 @@ class Client(OpenApiClient):
6138
5658
  req_body_type='json',
6139
5659
  body_type='none'
6140
5660
  )
6141
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6142
- return TeaCore.from_map(
6143
- fc20230330_models.UntagResourcesResponse(),
6144
- self.call_api(params, req, runtime)
6145
- )
6146
- else:
6147
- return TeaCore.from_map(
6148
- fc20230330_models.UntagResourcesResponse(),
6149
- self.execute(params, req, runtime)
6150
- )
5661
+ return TeaCore.from_map(
5662
+ fc20230330_models.UntagResourcesResponse(),
5663
+ self.call_api(params, req, runtime)
5664
+ )
6151
5665
 
6152
5666
  async def untag_resources_with_options_async(
6153
5667
  self,
@@ -6194,16 +5708,10 @@ class Client(OpenApiClient):
6194
5708
  req_body_type='json',
6195
5709
  body_type='none'
6196
5710
  )
6197
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6198
- return TeaCore.from_map(
6199
- fc20230330_models.UntagResourcesResponse(),
6200
- await self.call_api_async(params, req, runtime)
6201
- )
6202
- else:
6203
- return TeaCore.from_map(
6204
- fc20230330_models.UntagResourcesResponse(),
6205
- await self.execute_async(params, req, runtime)
6206
- )
5711
+ return TeaCore.from_map(
5712
+ fc20230330_models.UntagResourcesResponse(),
5713
+ await self.call_api_async(params, req, runtime)
5714
+ )
6207
5715
 
6208
5716
  def untag_resources(
6209
5717
  self,
@@ -6265,16 +5773,10 @@ class Client(OpenApiClient):
6265
5773
  req_body_type='json',
6266
5774
  body_type='json'
6267
5775
  )
6268
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6269
- return TeaCore.from_map(
6270
- fc20230330_models.UpdateAliasResponse(),
6271
- self.call_api(params, req, runtime)
6272
- )
6273
- else:
6274
- return TeaCore.from_map(
6275
- fc20230330_models.UpdateAliasResponse(),
6276
- self.execute(params, req, runtime)
6277
- )
5776
+ return TeaCore.from_map(
5777
+ fc20230330_models.UpdateAliasResponse(),
5778
+ self.call_api(params, req, runtime)
5779
+ )
6278
5780
 
6279
5781
  async def update_alias_with_options_async(
6280
5782
  self,
@@ -6308,16 +5810,10 @@ class Client(OpenApiClient):
6308
5810
  req_body_type='json',
6309
5811
  body_type='json'
6310
5812
  )
6311
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6312
- return TeaCore.from_map(
6313
- fc20230330_models.UpdateAliasResponse(),
6314
- await self.call_api_async(params, req, runtime)
6315
- )
6316
- else:
6317
- return TeaCore.from_map(
6318
- fc20230330_models.UpdateAliasResponse(),
6319
- await self.execute_async(params, req, runtime)
6320
- )
5813
+ return TeaCore.from_map(
5814
+ fc20230330_models.UpdateAliasResponse(),
5815
+ await self.call_api_async(params, req, runtime)
5816
+ )
6321
5817
 
6322
5818
  def update_alias(
6323
5819
  self,
@@ -6382,16 +5878,10 @@ class Client(OpenApiClient):
6382
5878
  req_body_type='json',
6383
5879
  body_type='json'
6384
5880
  )
6385
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6386
- return TeaCore.from_map(
6387
- fc20230330_models.UpdateCustomDomainResponse(),
6388
- self.call_api(params, req, runtime)
6389
- )
6390
- else:
6391
- return TeaCore.from_map(
6392
- fc20230330_models.UpdateCustomDomainResponse(),
6393
- self.execute(params, req, runtime)
6394
- )
5881
+ return TeaCore.from_map(
5882
+ fc20230330_models.UpdateCustomDomainResponse(),
5883
+ self.call_api(params, req, runtime)
5884
+ )
6395
5885
 
6396
5886
  async def update_custom_domain_with_options_async(
6397
5887
  self,
@@ -6424,16 +5914,10 @@ class Client(OpenApiClient):
6424
5914
  req_body_type='json',
6425
5915
  body_type='json'
6426
5916
  )
6427
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6428
- return TeaCore.from_map(
6429
- fc20230330_models.UpdateCustomDomainResponse(),
6430
- await self.call_api_async(params, req, runtime)
6431
- )
6432
- else:
6433
- return TeaCore.from_map(
6434
- fc20230330_models.UpdateCustomDomainResponse(),
6435
- await self.execute_async(params, req, runtime)
6436
- )
5917
+ return TeaCore.from_map(
5918
+ fc20230330_models.UpdateCustomDomainResponse(),
5919
+ await self.call_api_async(params, req, runtime)
5920
+ )
6437
5921
 
6438
5922
  def update_custom_domain(
6439
5923
  self,
@@ -6496,16 +5980,10 @@ class Client(OpenApiClient):
6496
5980
  req_body_type='json',
6497
5981
  body_type='json'
6498
5982
  )
6499
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6500
- return TeaCore.from_map(
6501
- fc20230330_models.UpdateFunctionResponse(),
6502
- self.call_api(params, req, runtime)
6503
- )
6504
- else:
6505
- return TeaCore.from_map(
6506
- fc20230330_models.UpdateFunctionResponse(),
6507
- self.execute(params, req, runtime)
6508
- )
5983
+ return TeaCore.from_map(
5984
+ fc20230330_models.UpdateFunctionResponse(),
5985
+ self.call_api(params, req, runtime)
5986
+ )
6509
5987
 
6510
5988
  async def update_function_with_options_async(
6511
5989
  self,
@@ -6538,16 +6016,10 @@ class Client(OpenApiClient):
6538
6016
  req_body_type='json',
6539
6017
  body_type='json'
6540
6018
  )
6541
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6542
- return TeaCore.from_map(
6543
- fc20230330_models.UpdateFunctionResponse(),
6544
- await self.call_api_async(params, req, runtime)
6545
- )
6546
- else:
6547
- return TeaCore.from_map(
6548
- fc20230330_models.UpdateFunctionResponse(),
6549
- await self.execute_async(params, req, runtime)
6550
- )
6019
+ return TeaCore.from_map(
6020
+ fc20230330_models.UpdateFunctionResponse(),
6021
+ await self.call_api_async(params, req, runtime)
6022
+ )
6551
6023
 
6552
6024
  def update_function(
6553
6025
  self,
@@ -6611,16 +6083,10 @@ class Client(OpenApiClient):
6611
6083
  req_body_type='json',
6612
6084
  body_type='json'
6613
6085
  )
6614
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6615
- return TeaCore.from_map(
6616
- fc20230330_models.UpdateTriggerResponse(),
6617
- self.call_api(params, req, runtime)
6618
- )
6619
- else:
6620
- return TeaCore.from_map(
6621
- fc20230330_models.UpdateTriggerResponse(),
6622
- self.execute(params, req, runtime)
6623
- )
6086
+ return TeaCore.from_map(
6087
+ fc20230330_models.UpdateTriggerResponse(),
6088
+ self.call_api(params, req, runtime)
6089
+ )
6624
6090
 
6625
6091
  async def update_trigger_with_options_async(
6626
6092
  self,
@@ -6654,16 +6120,10 @@ class Client(OpenApiClient):
6654
6120
  req_body_type='json',
6655
6121
  body_type='json'
6656
6122
  )
6657
- if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6658
- return TeaCore.from_map(
6659
- fc20230330_models.UpdateTriggerResponse(),
6660
- await self.call_api_async(params, req, runtime)
6661
- )
6662
- else:
6663
- return TeaCore.from_map(
6664
- fc20230330_models.UpdateTriggerResponse(),
6665
- await self.execute_async(params, req, runtime)
6666
- )
6123
+ return TeaCore.from_map(
6124
+ fc20230330_models.UpdateTriggerResponse(),
6125
+ await self.call_api_async(params, req, runtime)
6126
+ )
6667
6127
 
6668
6128
  def update_trigger(
6669
6129
  self,