alibabacloud-fc20230330 4.1.7__py3-none-any.whl → 4.5.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- alibabacloud_fc20230330/__init__.py +1 -1
- alibabacloud_fc20230330/client.py +1355 -1101
- alibabacloud_fc20230330/models.py +3688 -1593
- {alibabacloud_fc20230330-4.1.7.dist-info → alibabacloud_fc20230330-4.5.0.dist-info}/METADATA +3 -3
- alibabacloud_fc20230330-4.5.0.dist-info/RECORD +8 -0
- alibabacloud_fc20230330-4.1.7.dist-info/RECORD +0 -8
- {alibabacloud_fc20230330-4.1.7.dist-info → alibabacloud_fc20230330-4.5.0.dist-info}/LICENSE +0 -0
- {alibabacloud_fc20230330-4.1.7.dist-info → alibabacloud_fc20230330-4.5.0.dist-info}/WHEEL +0 -0
- {alibabacloud_fc20230330-4.1.7.dist-info → alibabacloud_fc20230330-4.5.0.dist-info}/top_level.txt +0 -0
|
@@ -41,6 +41,104 @@ class Client(OpenApiClient):
|
|
|
41
41
|
return endpoint_map.get(region_id)
|
|
42
42
|
return EndpointUtilClient.get_endpoint_rules(product_id, region_id, endpoint_rule, network, suffix)
|
|
43
43
|
|
|
44
|
+
def change_resource_group_with_options(
|
|
45
|
+
self,
|
|
46
|
+
request: fc20230330_models.ChangeResourceGroupRequest,
|
|
47
|
+
headers: Dict[str, str],
|
|
48
|
+
runtime: util_models.RuntimeOptions,
|
|
49
|
+
) -> fc20230330_models.ChangeResourceGroupResponse:
|
|
50
|
+
"""
|
|
51
|
+
@summary 修改实例所在资源组
|
|
52
|
+
|
|
53
|
+
@param request: ChangeResourceGroupRequest
|
|
54
|
+
@param headers: map
|
|
55
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
56
|
+
@return: ChangeResourceGroupResponse
|
|
57
|
+
"""
|
|
58
|
+
UtilClient.validate_model(request)
|
|
59
|
+
req = open_api_models.OpenApiRequest(
|
|
60
|
+
headers=headers,
|
|
61
|
+
body=OpenApiUtilClient.parse_to_map(request.body)
|
|
62
|
+
)
|
|
63
|
+
params = open_api_models.Params(
|
|
64
|
+
action='ChangeResourceGroup',
|
|
65
|
+
version='2023-03-30',
|
|
66
|
+
protocol='HTTPS',
|
|
67
|
+
pathname=f'/2023-03-30/resource-groups',
|
|
68
|
+
method='PUT',
|
|
69
|
+
auth_type='AK',
|
|
70
|
+
style='ROA',
|
|
71
|
+
req_body_type='json',
|
|
72
|
+
body_type='json'
|
|
73
|
+
)
|
|
74
|
+
return TeaCore.from_map(
|
|
75
|
+
fc20230330_models.ChangeResourceGroupResponse(),
|
|
76
|
+
self.call_api(params, req, runtime)
|
|
77
|
+
)
|
|
78
|
+
|
|
79
|
+
async def change_resource_group_with_options_async(
|
|
80
|
+
self,
|
|
81
|
+
request: fc20230330_models.ChangeResourceGroupRequest,
|
|
82
|
+
headers: Dict[str, str],
|
|
83
|
+
runtime: util_models.RuntimeOptions,
|
|
84
|
+
) -> fc20230330_models.ChangeResourceGroupResponse:
|
|
85
|
+
"""
|
|
86
|
+
@summary 修改实例所在资源组
|
|
87
|
+
|
|
88
|
+
@param request: ChangeResourceGroupRequest
|
|
89
|
+
@param headers: map
|
|
90
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
91
|
+
@return: ChangeResourceGroupResponse
|
|
92
|
+
"""
|
|
93
|
+
UtilClient.validate_model(request)
|
|
94
|
+
req = open_api_models.OpenApiRequest(
|
|
95
|
+
headers=headers,
|
|
96
|
+
body=OpenApiUtilClient.parse_to_map(request.body)
|
|
97
|
+
)
|
|
98
|
+
params = open_api_models.Params(
|
|
99
|
+
action='ChangeResourceGroup',
|
|
100
|
+
version='2023-03-30',
|
|
101
|
+
protocol='HTTPS',
|
|
102
|
+
pathname=f'/2023-03-30/resource-groups',
|
|
103
|
+
method='PUT',
|
|
104
|
+
auth_type='AK',
|
|
105
|
+
style='ROA',
|
|
106
|
+
req_body_type='json',
|
|
107
|
+
body_type='json'
|
|
108
|
+
)
|
|
109
|
+
return TeaCore.from_map(
|
|
110
|
+
fc20230330_models.ChangeResourceGroupResponse(),
|
|
111
|
+
await self.call_api_async(params, req, runtime)
|
|
112
|
+
)
|
|
113
|
+
|
|
114
|
+
def change_resource_group(
|
|
115
|
+
self,
|
|
116
|
+
request: fc20230330_models.ChangeResourceGroupRequest,
|
|
117
|
+
) -> fc20230330_models.ChangeResourceGroupResponse:
|
|
118
|
+
"""
|
|
119
|
+
@summary 修改实例所在资源组
|
|
120
|
+
|
|
121
|
+
@param request: ChangeResourceGroupRequest
|
|
122
|
+
@return: ChangeResourceGroupResponse
|
|
123
|
+
"""
|
|
124
|
+
runtime = util_models.RuntimeOptions()
|
|
125
|
+
headers = {}
|
|
126
|
+
return self.change_resource_group_with_options(request, headers, runtime)
|
|
127
|
+
|
|
128
|
+
async def change_resource_group_async(
|
|
129
|
+
self,
|
|
130
|
+
request: fc20230330_models.ChangeResourceGroupRequest,
|
|
131
|
+
) -> fc20230330_models.ChangeResourceGroupResponse:
|
|
132
|
+
"""
|
|
133
|
+
@summary 修改实例所在资源组
|
|
134
|
+
|
|
135
|
+
@param request: ChangeResourceGroupRequest
|
|
136
|
+
@return: ChangeResourceGroupResponse
|
|
137
|
+
"""
|
|
138
|
+
runtime = util_models.RuntimeOptions()
|
|
139
|
+
headers = {}
|
|
140
|
+
return await self.change_resource_group_with_options_async(request, headers, runtime)
|
|
141
|
+
|
|
44
142
|
def create_alias_with_options(
|
|
45
143
|
self,
|
|
46
144
|
function_name: str,
|
|
@@ -72,16 +170,10 @@ class Client(OpenApiClient):
|
|
|
72
170
|
req_body_type='json',
|
|
73
171
|
body_type='json'
|
|
74
172
|
)
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
)
|
|
80
|
-
else:
|
|
81
|
-
return TeaCore.from_map(
|
|
82
|
-
fc20230330_models.CreateAliasResponse(),
|
|
83
|
-
self.execute(params, req, runtime)
|
|
84
|
-
)
|
|
173
|
+
return TeaCore.from_map(
|
|
174
|
+
fc20230330_models.CreateAliasResponse(),
|
|
175
|
+
self.call_api(params, req, runtime)
|
|
176
|
+
)
|
|
85
177
|
|
|
86
178
|
async def create_alias_with_options_async(
|
|
87
179
|
self,
|
|
@@ -114,16 +206,10 @@ class Client(OpenApiClient):
|
|
|
114
206
|
req_body_type='json',
|
|
115
207
|
body_type='json'
|
|
116
208
|
)
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
)
|
|
122
|
-
else:
|
|
123
|
-
return TeaCore.from_map(
|
|
124
|
-
fc20230330_models.CreateAliasResponse(),
|
|
125
|
-
await self.execute_async(params, req, runtime)
|
|
126
|
-
)
|
|
209
|
+
return TeaCore.from_map(
|
|
210
|
+
fc20230330_models.CreateAliasResponse(),
|
|
211
|
+
await self.call_api_async(params, req, runtime)
|
|
212
|
+
)
|
|
127
213
|
|
|
128
214
|
def create_alias(
|
|
129
215
|
self,
|
|
@@ -187,16 +273,10 @@ class Client(OpenApiClient):
|
|
|
187
273
|
req_body_type='json',
|
|
188
274
|
body_type='json'
|
|
189
275
|
)
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
194
|
-
)
|
|
195
|
-
else:
|
|
196
|
-
return TeaCore.from_map(
|
|
197
|
-
fc20230330_models.CreateCustomDomainResponse(),
|
|
198
|
-
self.execute(params, req, runtime)
|
|
199
|
-
)
|
|
276
|
+
return TeaCore.from_map(
|
|
277
|
+
fc20230330_models.CreateCustomDomainResponse(),
|
|
278
|
+
self.call_api(params, req, runtime)
|
|
279
|
+
)
|
|
200
280
|
|
|
201
281
|
async def create_custom_domain_with_options_async(
|
|
202
282
|
self,
|
|
@@ -230,16 +310,10 @@ class Client(OpenApiClient):
|
|
|
230
310
|
req_body_type='json',
|
|
231
311
|
body_type='json'
|
|
232
312
|
)
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
)
|
|
238
|
-
else:
|
|
239
|
-
return TeaCore.from_map(
|
|
240
|
-
fc20230330_models.CreateCustomDomainResponse(),
|
|
241
|
-
await self.execute_async(params, req, runtime)
|
|
242
|
-
)
|
|
313
|
+
return TeaCore.from_map(
|
|
314
|
+
fc20230330_models.CreateCustomDomainResponse(),
|
|
315
|
+
await self.call_api_async(params, req, runtime)
|
|
316
|
+
)
|
|
243
317
|
|
|
244
318
|
def create_custom_domain(
|
|
245
319
|
self,
|
|
@@ -305,16 +379,10 @@ class Client(OpenApiClient):
|
|
|
305
379
|
req_body_type='json',
|
|
306
380
|
body_type='json'
|
|
307
381
|
)
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
)
|
|
313
|
-
else:
|
|
314
|
-
return TeaCore.from_map(
|
|
315
|
-
fc20230330_models.CreateFunctionResponse(),
|
|
316
|
-
self.execute(params, req, runtime)
|
|
317
|
-
)
|
|
382
|
+
return TeaCore.from_map(
|
|
383
|
+
fc20230330_models.CreateFunctionResponse(),
|
|
384
|
+
self.call_api(params, req, runtime)
|
|
385
|
+
)
|
|
318
386
|
|
|
319
387
|
async def create_function_with_options_async(
|
|
320
388
|
self,
|
|
@@ -348,16 +416,10 @@ class Client(OpenApiClient):
|
|
|
348
416
|
req_body_type='json',
|
|
349
417
|
body_type='json'
|
|
350
418
|
)
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
|
|
355
|
-
)
|
|
356
|
-
else:
|
|
357
|
-
return TeaCore.from_map(
|
|
358
|
-
fc20230330_models.CreateFunctionResponse(),
|
|
359
|
-
await self.execute_async(params, req, runtime)
|
|
360
|
-
)
|
|
419
|
+
return TeaCore.from_map(
|
|
420
|
+
fc20230330_models.CreateFunctionResponse(),
|
|
421
|
+
await self.call_api_async(params, req, runtime)
|
|
422
|
+
)
|
|
361
423
|
|
|
362
424
|
def create_function(
|
|
363
425
|
self,
|
|
@@ -422,16 +484,10 @@ class Client(OpenApiClient):
|
|
|
422
484
|
req_body_type='json',
|
|
423
485
|
body_type='json'
|
|
424
486
|
)
|
|
425
|
-
|
|
426
|
-
|
|
427
|
-
|
|
428
|
-
|
|
429
|
-
)
|
|
430
|
-
else:
|
|
431
|
-
return TeaCore.from_map(
|
|
432
|
-
fc20230330_models.CreateLayerVersionResponse(),
|
|
433
|
-
self.execute(params, req, runtime)
|
|
434
|
-
)
|
|
487
|
+
return TeaCore.from_map(
|
|
488
|
+
fc20230330_models.CreateLayerVersionResponse(),
|
|
489
|
+
self.call_api(params, req, runtime)
|
|
490
|
+
)
|
|
435
491
|
|
|
436
492
|
async def create_layer_version_with_options_async(
|
|
437
493
|
self,
|
|
@@ -464,16 +520,10 @@ class Client(OpenApiClient):
|
|
|
464
520
|
req_body_type='json',
|
|
465
521
|
body_type='json'
|
|
466
522
|
)
|
|
467
|
-
|
|
468
|
-
|
|
469
|
-
|
|
470
|
-
|
|
471
|
-
)
|
|
472
|
-
else:
|
|
473
|
-
return TeaCore.from_map(
|
|
474
|
-
fc20230330_models.CreateLayerVersionResponse(),
|
|
475
|
-
await self.execute_async(params, req, runtime)
|
|
476
|
-
)
|
|
523
|
+
return TeaCore.from_map(
|
|
524
|
+
fc20230330_models.CreateLayerVersionResponse(),
|
|
525
|
+
await self.call_api_async(params, req, runtime)
|
|
526
|
+
)
|
|
477
527
|
|
|
478
528
|
def create_layer_version(
|
|
479
529
|
self,
|
|
@@ -536,16 +586,10 @@ class Client(OpenApiClient):
|
|
|
536
586
|
req_body_type='json',
|
|
537
587
|
body_type='json'
|
|
538
588
|
)
|
|
539
|
-
|
|
540
|
-
|
|
541
|
-
|
|
542
|
-
|
|
543
|
-
)
|
|
544
|
-
else:
|
|
545
|
-
return TeaCore.from_map(
|
|
546
|
-
fc20230330_models.CreateTriggerResponse(),
|
|
547
|
-
self.execute(params, req, runtime)
|
|
548
|
-
)
|
|
589
|
+
return TeaCore.from_map(
|
|
590
|
+
fc20230330_models.CreateTriggerResponse(),
|
|
591
|
+
self.call_api(params, req, runtime)
|
|
592
|
+
)
|
|
549
593
|
|
|
550
594
|
async def create_trigger_with_options_async(
|
|
551
595
|
self,
|
|
@@ -578,16 +622,10 @@ class Client(OpenApiClient):
|
|
|
578
622
|
req_body_type='json',
|
|
579
623
|
body_type='json'
|
|
580
624
|
)
|
|
581
|
-
|
|
582
|
-
|
|
583
|
-
|
|
584
|
-
|
|
585
|
-
)
|
|
586
|
-
else:
|
|
587
|
-
return TeaCore.from_map(
|
|
588
|
-
fc20230330_models.CreateTriggerResponse(),
|
|
589
|
-
await self.execute_async(params, req, runtime)
|
|
590
|
-
)
|
|
625
|
+
return TeaCore.from_map(
|
|
626
|
+
fc20230330_models.CreateTriggerResponse(),
|
|
627
|
+
await self.call_api_async(params, req, runtime)
|
|
628
|
+
)
|
|
591
629
|
|
|
592
630
|
def create_trigger(
|
|
593
631
|
self,
|
|
@@ -650,16 +688,10 @@ class Client(OpenApiClient):
|
|
|
650
688
|
req_body_type='json',
|
|
651
689
|
body_type='none'
|
|
652
690
|
)
|
|
653
|
-
|
|
654
|
-
|
|
655
|
-
|
|
656
|
-
|
|
657
|
-
)
|
|
658
|
-
else:
|
|
659
|
-
return TeaCore.from_map(
|
|
660
|
-
fc20230330_models.CreateVpcBindingResponse(),
|
|
661
|
-
self.execute(params, req, runtime)
|
|
662
|
-
)
|
|
691
|
+
return TeaCore.from_map(
|
|
692
|
+
fc20230330_models.CreateVpcBindingResponse(),
|
|
693
|
+
self.call_api(params, req, runtime)
|
|
694
|
+
)
|
|
663
695
|
|
|
664
696
|
async def create_vpc_binding_with_options_async(
|
|
665
697
|
self,
|
|
@@ -692,16 +724,10 @@ class Client(OpenApiClient):
|
|
|
692
724
|
req_body_type='json',
|
|
693
725
|
body_type='none'
|
|
694
726
|
)
|
|
695
|
-
|
|
696
|
-
|
|
697
|
-
|
|
698
|
-
|
|
699
|
-
)
|
|
700
|
-
else:
|
|
701
|
-
return TeaCore.from_map(
|
|
702
|
-
fc20230330_models.CreateVpcBindingResponse(),
|
|
703
|
-
await self.execute_async(params, req, runtime)
|
|
704
|
-
)
|
|
727
|
+
return TeaCore.from_map(
|
|
728
|
+
fc20230330_models.CreateVpcBindingResponse(),
|
|
729
|
+
await self.call_api_async(params, req, runtime)
|
|
730
|
+
)
|
|
705
731
|
|
|
706
732
|
def create_vpc_binding(
|
|
707
733
|
self,
|
|
@@ -761,16 +787,10 @@ class Client(OpenApiClient):
|
|
|
761
787
|
req_body_type='json',
|
|
762
788
|
body_type='none'
|
|
763
789
|
)
|
|
764
|
-
|
|
765
|
-
|
|
766
|
-
|
|
767
|
-
|
|
768
|
-
)
|
|
769
|
-
else:
|
|
770
|
-
return TeaCore.from_map(
|
|
771
|
-
fc20230330_models.DeleteAliasResponse(),
|
|
772
|
-
self.execute(params, req, runtime)
|
|
773
|
-
)
|
|
790
|
+
return TeaCore.from_map(
|
|
791
|
+
fc20230330_models.DeleteAliasResponse(),
|
|
792
|
+
self.call_api(params, req, runtime)
|
|
793
|
+
)
|
|
774
794
|
|
|
775
795
|
async def delete_alias_with_options_async(
|
|
776
796
|
self,
|
|
@@ -800,16 +820,10 @@ class Client(OpenApiClient):
|
|
|
800
820
|
req_body_type='json',
|
|
801
821
|
body_type='none'
|
|
802
822
|
)
|
|
803
|
-
|
|
804
|
-
|
|
805
|
-
|
|
806
|
-
|
|
807
|
-
)
|
|
808
|
-
else:
|
|
809
|
-
return TeaCore.from_map(
|
|
810
|
-
fc20230330_models.DeleteAliasResponse(),
|
|
811
|
-
await self.execute_async(params, req, runtime)
|
|
812
|
-
)
|
|
823
|
+
return TeaCore.from_map(
|
|
824
|
+
fc20230330_models.DeleteAliasResponse(),
|
|
825
|
+
await self.call_api_async(params, req, runtime)
|
|
826
|
+
)
|
|
813
827
|
|
|
814
828
|
def delete_alias(
|
|
815
829
|
self,
|
|
@@ -873,16 +887,10 @@ class Client(OpenApiClient):
|
|
|
873
887
|
req_body_type='json',
|
|
874
888
|
body_type='none'
|
|
875
889
|
)
|
|
876
|
-
|
|
877
|
-
|
|
878
|
-
|
|
879
|
-
|
|
880
|
-
)
|
|
881
|
-
else:
|
|
882
|
-
return TeaCore.from_map(
|
|
883
|
-
fc20230330_models.DeleteAsyncInvokeConfigResponse(),
|
|
884
|
-
self.execute(params, req, runtime)
|
|
885
|
-
)
|
|
890
|
+
return TeaCore.from_map(
|
|
891
|
+
fc20230330_models.DeleteAsyncInvokeConfigResponse(),
|
|
892
|
+
self.call_api(params, req, runtime)
|
|
893
|
+
)
|
|
886
894
|
|
|
887
895
|
async def delete_async_invoke_config_with_options_async(
|
|
888
896
|
self,
|
|
@@ -918,16 +926,10 @@ class Client(OpenApiClient):
|
|
|
918
926
|
req_body_type='json',
|
|
919
927
|
body_type='none'
|
|
920
928
|
)
|
|
921
|
-
|
|
922
|
-
|
|
923
|
-
|
|
924
|
-
|
|
925
|
-
)
|
|
926
|
-
else:
|
|
927
|
-
return TeaCore.from_map(
|
|
928
|
-
fc20230330_models.DeleteAsyncInvokeConfigResponse(),
|
|
929
|
-
await self.execute_async(params, req, runtime)
|
|
930
|
-
)
|
|
929
|
+
return TeaCore.from_map(
|
|
930
|
+
fc20230330_models.DeleteAsyncInvokeConfigResponse(),
|
|
931
|
+
await self.call_api_async(params, req, runtime)
|
|
932
|
+
)
|
|
931
933
|
|
|
932
934
|
def delete_async_invoke_config(
|
|
933
935
|
self,
|
|
@@ -986,16 +988,10 @@ class Client(OpenApiClient):
|
|
|
986
988
|
req_body_type='json',
|
|
987
989
|
body_type='none'
|
|
988
990
|
)
|
|
989
|
-
|
|
990
|
-
|
|
991
|
-
|
|
992
|
-
|
|
993
|
-
)
|
|
994
|
-
else:
|
|
995
|
-
return TeaCore.from_map(
|
|
996
|
-
fc20230330_models.DeleteConcurrencyConfigResponse(),
|
|
997
|
-
self.execute(params, req, runtime)
|
|
998
|
-
)
|
|
991
|
+
return TeaCore.from_map(
|
|
992
|
+
fc20230330_models.DeleteConcurrencyConfigResponse(),
|
|
993
|
+
self.call_api(params, req, runtime)
|
|
994
|
+
)
|
|
999
995
|
|
|
1000
996
|
async def delete_concurrency_config_with_options_async(
|
|
1001
997
|
self,
|
|
@@ -1024,16 +1020,10 @@ class Client(OpenApiClient):
|
|
|
1024
1020
|
req_body_type='json',
|
|
1025
1021
|
body_type='none'
|
|
1026
1022
|
)
|
|
1027
|
-
|
|
1028
|
-
|
|
1029
|
-
|
|
1030
|
-
|
|
1031
|
-
)
|
|
1032
|
-
else:
|
|
1033
|
-
return TeaCore.from_map(
|
|
1034
|
-
fc20230330_models.DeleteConcurrencyConfigResponse(),
|
|
1035
|
-
await self.execute_async(params, req, runtime)
|
|
1036
|
-
)
|
|
1023
|
+
return TeaCore.from_map(
|
|
1024
|
+
fc20230330_models.DeleteConcurrencyConfigResponse(),
|
|
1025
|
+
await self.call_api_async(params, req, runtime)
|
|
1026
|
+
)
|
|
1037
1027
|
|
|
1038
1028
|
def delete_concurrency_config(
|
|
1039
1029
|
self,
|
|
@@ -1088,16 +1078,10 @@ class Client(OpenApiClient):
|
|
|
1088
1078
|
req_body_type='json',
|
|
1089
1079
|
body_type='none'
|
|
1090
1080
|
)
|
|
1091
|
-
|
|
1092
|
-
|
|
1093
|
-
|
|
1094
|
-
|
|
1095
|
-
)
|
|
1096
|
-
else:
|
|
1097
|
-
return TeaCore.from_map(
|
|
1098
|
-
fc20230330_models.DeleteCustomDomainResponse(),
|
|
1099
|
-
self.execute(params, req, runtime)
|
|
1100
|
-
)
|
|
1081
|
+
return TeaCore.from_map(
|
|
1082
|
+
fc20230330_models.DeleteCustomDomainResponse(),
|
|
1083
|
+
self.call_api(params, req, runtime)
|
|
1084
|
+
)
|
|
1101
1085
|
|
|
1102
1086
|
async def delete_custom_domain_with_options_async(
|
|
1103
1087
|
self,
|
|
@@ -1126,16 +1110,10 @@ class Client(OpenApiClient):
|
|
|
1126
1110
|
req_body_type='json',
|
|
1127
1111
|
body_type='none'
|
|
1128
1112
|
)
|
|
1129
|
-
|
|
1130
|
-
|
|
1131
|
-
|
|
1132
|
-
|
|
1133
|
-
)
|
|
1134
|
-
else:
|
|
1135
|
-
return TeaCore.from_map(
|
|
1136
|
-
fc20230330_models.DeleteCustomDomainResponse(),
|
|
1137
|
-
await self.execute_async(params, req, runtime)
|
|
1138
|
-
)
|
|
1113
|
+
return TeaCore.from_map(
|
|
1114
|
+
fc20230330_models.DeleteCustomDomainResponse(),
|
|
1115
|
+
await self.call_api_async(params, req, runtime)
|
|
1116
|
+
)
|
|
1139
1117
|
|
|
1140
1118
|
def delete_custom_domain(
|
|
1141
1119
|
self,
|
|
@@ -1190,16 +1168,10 @@ class Client(OpenApiClient):
|
|
|
1190
1168
|
req_body_type='json',
|
|
1191
1169
|
body_type='none'
|
|
1192
1170
|
)
|
|
1193
|
-
|
|
1194
|
-
|
|
1195
|
-
|
|
1196
|
-
|
|
1197
|
-
)
|
|
1198
|
-
else:
|
|
1199
|
-
return TeaCore.from_map(
|
|
1200
|
-
fc20230330_models.DeleteFunctionResponse(),
|
|
1201
|
-
self.execute(params, req, runtime)
|
|
1202
|
-
)
|
|
1171
|
+
return TeaCore.from_map(
|
|
1172
|
+
fc20230330_models.DeleteFunctionResponse(),
|
|
1173
|
+
self.call_api(params, req, runtime)
|
|
1174
|
+
)
|
|
1203
1175
|
|
|
1204
1176
|
async def delete_function_with_options_async(
|
|
1205
1177
|
self,
|
|
@@ -1228,16 +1200,10 @@ class Client(OpenApiClient):
|
|
|
1228
1200
|
req_body_type='json',
|
|
1229
1201
|
body_type='none'
|
|
1230
1202
|
)
|
|
1231
|
-
|
|
1232
|
-
|
|
1233
|
-
|
|
1234
|
-
|
|
1235
|
-
)
|
|
1236
|
-
else:
|
|
1237
|
-
return TeaCore.from_map(
|
|
1238
|
-
fc20230330_models.DeleteFunctionResponse(),
|
|
1239
|
-
await self.execute_async(params, req, runtime)
|
|
1240
|
-
)
|
|
1203
|
+
return TeaCore.from_map(
|
|
1204
|
+
fc20230330_models.DeleteFunctionResponse(),
|
|
1205
|
+
await self.call_api_async(params, req, runtime)
|
|
1206
|
+
)
|
|
1241
1207
|
|
|
1242
1208
|
def delete_function(
|
|
1243
1209
|
self,
|
|
@@ -1273,7 +1239,7 @@ class Client(OpenApiClient):
|
|
|
1273
1239
|
runtime: util_models.RuntimeOptions,
|
|
1274
1240
|
) -> fc20230330_models.DeleteFunctionVersionResponse:
|
|
1275
1241
|
"""
|
|
1276
|
-
@summary
|
|
1242
|
+
@summary http://pre.hhht/#vpc
|
|
1277
1243
|
|
|
1278
1244
|
@param headers: map
|
|
1279
1245
|
@param runtime: runtime options for this request RuntimeOptions
|
|
@@ -1293,16 +1259,10 @@ class Client(OpenApiClient):
|
|
|
1293
1259
|
req_body_type='json',
|
|
1294
1260
|
body_type='none'
|
|
1295
1261
|
)
|
|
1296
|
-
|
|
1297
|
-
|
|
1298
|
-
|
|
1299
|
-
|
|
1300
|
-
)
|
|
1301
|
-
else:
|
|
1302
|
-
return TeaCore.from_map(
|
|
1303
|
-
fc20230330_models.DeleteFunctionVersionResponse(),
|
|
1304
|
-
self.execute(params, req, runtime)
|
|
1305
|
-
)
|
|
1262
|
+
return TeaCore.from_map(
|
|
1263
|
+
fc20230330_models.DeleteFunctionVersionResponse(),
|
|
1264
|
+
self.call_api(params, req, runtime)
|
|
1265
|
+
)
|
|
1306
1266
|
|
|
1307
1267
|
async def delete_function_version_with_options_async(
|
|
1308
1268
|
self,
|
|
@@ -1312,7 +1272,7 @@ class Client(OpenApiClient):
|
|
|
1312
1272
|
runtime: util_models.RuntimeOptions,
|
|
1313
1273
|
) -> fc20230330_models.DeleteFunctionVersionResponse:
|
|
1314
1274
|
"""
|
|
1315
|
-
@summary
|
|
1275
|
+
@summary http://pre.hhht/#vpc
|
|
1316
1276
|
|
|
1317
1277
|
@param headers: map
|
|
1318
1278
|
@param runtime: runtime options for this request RuntimeOptions
|
|
@@ -1332,16 +1292,10 @@ class Client(OpenApiClient):
|
|
|
1332
1292
|
req_body_type='json',
|
|
1333
1293
|
body_type='none'
|
|
1334
1294
|
)
|
|
1335
|
-
|
|
1336
|
-
|
|
1337
|
-
|
|
1338
|
-
|
|
1339
|
-
)
|
|
1340
|
-
else:
|
|
1341
|
-
return TeaCore.from_map(
|
|
1342
|
-
fc20230330_models.DeleteFunctionVersionResponse(),
|
|
1343
|
-
await self.execute_async(params, req, runtime)
|
|
1344
|
-
)
|
|
1295
|
+
return TeaCore.from_map(
|
|
1296
|
+
fc20230330_models.DeleteFunctionVersionResponse(),
|
|
1297
|
+
await self.call_api_async(params, req, runtime)
|
|
1298
|
+
)
|
|
1345
1299
|
|
|
1346
1300
|
def delete_function_version(
|
|
1347
1301
|
self,
|
|
@@ -1349,7 +1303,7 @@ class Client(OpenApiClient):
|
|
|
1349
1303
|
version_id: str,
|
|
1350
1304
|
) -> fc20230330_models.DeleteFunctionVersionResponse:
|
|
1351
1305
|
"""
|
|
1352
|
-
@summary
|
|
1306
|
+
@summary http://pre.hhht/#vpc
|
|
1353
1307
|
|
|
1354
1308
|
@return: DeleteFunctionVersionResponse
|
|
1355
1309
|
"""
|
|
@@ -1363,7 +1317,7 @@ class Client(OpenApiClient):
|
|
|
1363
1317
|
version_id: str,
|
|
1364
1318
|
) -> fc20230330_models.DeleteFunctionVersionResponse:
|
|
1365
1319
|
"""
|
|
1366
|
-
@summary
|
|
1320
|
+
@summary http://pre.hhht/#vpc
|
|
1367
1321
|
|
|
1368
1322
|
@return: DeleteFunctionVersionResponse
|
|
1369
1323
|
"""
|
|
@@ -1399,16 +1353,10 @@ class Client(OpenApiClient):
|
|
|
1399
1353
|
req_body_type='json',
|
|
1400
1354
|
body_type='none'
|
|
1401
1355
|
)
|
|
1402
|
-
|
|
1403
|
-
|
|
1404
|
-
|
|
1405
|
-
|
|
1406
|
-
)
|
|
1407
|
-
else:
|
|
1408
|
-
return TeaCore.from_map(
|
|
1409
|
-
fc20230330_models.DeleteLayerVersionResponse(),
|
|
1410
|
-
self.execute(params, req, runtime)
|
|
1411
|
-
)
|
|
1356
|
+
return TeaCore.from_map(
|
|
1357
|
+
fc20230330_models.DeleteLayerVersionResponse(),
|
|
1358
|
+
self.call_api(params, req, runtime)
|
|
1359
|
+
)
|
|
1412
1360
|
|
|
1413
1361
|
async def delete_layer_version_with_options_async(
|
|
1414
1362
|
self,
|
|
@@ -1438,16 +1386,10 @@ class Client(OpenApiClient):
|
|
|
1438
1386
|
req_body_type='json',
|
|
1439
1387
|
body_type='none'
|
|
1440
1388
|
)
|
|
1441
|
-
|
|
1442
|
-
|
|
1443
|
-
|
|
1444
|
-
|
|
1445
|
-
)
|
|
1446
|
-
else:
|
|
1447
|
-
return TeaCore.from_map(
|
|
1448
|
-
fc20230330_models.DeleteLayerVersionResponse(),
|
|
1449
|
-
await self.execute_async(params, req, runtime)
|
|
1450
|
-
)
|
|
1389
|
+
return TeaCore.from_map(
|
|
1390
|
+
fc20230330_models.DeleteLayerVersionResponse(),
|
|
1391
|
+
await self.call_api_async(params, req, runtime)
|
|
1392
|
+
)
|
|
1451
1393
|
|
|
1452
1394
|
def delete_layer_version(
|
|
1453
1395
|
self,
|
|
@@ -1511,16 +1453,10 @@ class Client(OpenApiClient):
|
|
|
1511
1453
|
req_body_type='json',
|
|
1512
1454
|
body_type='none'
|
|
1513
1455
|
)
|
|
1514
|
-
|
|
1515
|
-
|
|
1516
|
-
|
|
1517
|
-
|
|
1518
|
-
)
|
|
1519
|
-
else:
|
|
1520
|
-
return TeaCore.from_map(
|
|
1521
|
-
fc20230330_models.DeleteProvisionConfigResponse(),
|
|
1522
|
-
self.execute(params, req, runtime)
|
|
1523
|
-
)
|
|
1456
|
+
return TeaCore.from_map(
|
|
1457
|
+
fc20230330_models.DeleteProvisionConfigResponse(),
|
|
1458
|
+
self.call_api(params, req, runtime)
|
|
1459
|
+
)
|
|
1524
1460
|
|
|
1525
1461
|
async def delete_provision_config_with_options_async(
|
|
1526
1462
|
self,
|
|
@@ -1556,16 +1492,10 @@ class Client(OpenApiClient):
|
|
|
1556
1492
|
req_body_type='json',
|
|
1557
1493
|
body_type='none'
|
|
1558
1494
|
)
|
|
1559
|
-
|
|
1560
|
-
|
|
1561
|
-
|
|
1562
|
-
|
|
1563
|
-
)
|
|
1564
|
-
else:
|
|
1565
|
-
return TeaCore.from_map(
|
|
1566
|
-
fc20230330_models.DeleteProvisionConfigResponse(),
|
|
1567
|
-
await self.execute_async(params, req, runtime)
|
|
1568
|
-
)
|
|
1495
|
+
return TeaCore.from_map(
|
|
1496
|
+
fc20230330_models.DeleteProvisionConfigResponse(),
|
|
1497
|
+
await self.call_api_async(params, req, runtime)
|
|
1498
|
+
)
|
|
1569
1499
|
|
|
1570
1500
|
def delete_provision_config(
|
|
1571
1501
|
self,
|
|
@@ -1597,6 +1527,114 @@ class Client(OpenApiClient):
|
|
|
1597
1527
|
headers = {}
|
|
1598
1528
|
return await self.delete_provision_config_with_options_async(function_name, request, headers, runtime)
|
|
1599
1529
|
|
|
1530
|
+
def delete_scaling_config_with_options(
|
|
1531
|
+
self,
|
|
1532
|
+
function_name: str,
|
|
1533
|
+
request: fc20230330_models.DeleteScalingConfigRequest,
|
|
1534
|
+
headers: Dict[str, str],
|
|
1535
|
+
runtime: util_models.RuntimeOptions,
|
|
1536
|
+
) -> fc20230330_models.DeleteScalingConfigResponse:
|
|
1537
|
+
"""
|
|
1538
|
+
@summary 删除弹性配置
|
|
1539
|
+
|
|
1540
|
+
@param request: DeleteScalingConfigRequest
|
|
1541
|
+
@param headers: map
|
|
1542
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
1543
|
+
@return: DeleteScalingConfigResponse
|
|
1544
|
+
"""
|
|
1545
|
+
UtilClient.validate_model(request)
|
|
1546
|
+
query = {}
|
|
1547
|
+
if not UtilClient.is_unset(request.qualifier):
|
|
1548
|
+
query['qualifier'] = request.qualifier
|
|
1549
|
+
req = open_api_models.OpenApiRequest(
|
|
1550
|
+
headers=headers,
|
|
1551
|
+
query=OpenApiUtilClient.query(query)
|
|
1552
|
+
)
|
|
1553
|
+
params = open_api_models.Params(
|
|
1554
|
+
action='DeleteScalingConfig',
|
|
1555
|
+
version='2023-03-30',
|
|
1556
|
+
protocol='HTTPS',
|
|
1557
|
+
pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/scaling-config',
|
|
1558
|
+
method='DELETE',
|
|
1559
|
+
auth_type='AK',
|
|
1560
|
+
style='ROA',
|
|
1561
|
+
req_body_type='json',
|
|
1562
|
+
body_type='none'
|
|
1563
|
+
)
|
|
1564
|
+
return TeaCore.from_map(
|
|
1565
|
+
fc20230330_models.DeleteScalingConfigResponse(),
|
|
1566
|
+
self.call_api(params, req, runtime)
|
|
1567
|
+
)
|
|
1568
|
+
|
|
1569
|
+
async def delete_scaling_config_with_options_async(
|
|
1570
|
+
self,
|
|
1571
|
+
function_name: str,
|
|
1572
|
+
request: fc20230330_models.DeleteScalingConfigRequest,
|
|
1573
|
+
headers: Dict[str, str],
|
|
1574
|
+
runtime: util_models.RuntimeOptions,
|
|
1575
|
+
) -> fc20230330_models.DeleteScalingConfigResponse:
|
|
1576
|
+
"""
|
|
1577
|
+
@summary 删除弹性配置
|
|
1578
|
+
|
|
1579
|
+
@param request: DeleteScalingConfigRequest
|
|
1580
|
+
@param headers: map
|
|
1581
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
1582
|
+
@return: DeleteScalingConfigResponse
|
|
1583
|
+
"""
|
|
1584
|
+
UtilClient.validate_model(request)
|
|
1585
|
+
query = {}
|
|
1586
|
+
if not UtilClient.is_unset(request.qualifier):
|
|
1587
|
+
query['qualifier'] = request.qualifier
|
|
1588
|
+
req = open_api_models.OpenApiRequest(
|
|
1589
|
+
headers=headers,
|
|
1590
|
+
query=OpenApiUtilClient.query(query)
|
|
1591
|
+
)
|
|
1592
|
+
params = open_api_models.Params(
|
|
1593
|
+
action='DeleteScalingConfig',
|
|
1594
|
+
version='2023-03-30',
|
|
1595
|
+
protocol='HTTPS',
|
|
1596
|
+
pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/scaling-config',
|
|
1597
|
+
method='DELETE',
|
|
1598
|
+
auth_type='AK',
|
|
1599
|
+
style='ROA',
|
|
1600
|
+
req_body_type='json',
|
|
1601
|
+
body_type='none'
|
|
1602
|
+
)
|
|
1603
|
+
return TeaCore.from_map(
|
|
1604
|
+
fc20230330_models.DeleteScalingConfigResponse(),
|
|
1605
|
+
await self.call_api_async(params, req, runtime)
|
|
1606
|
+
)
|
|
1607
|
+
|
|
1608
|
+
def delete_scaling_config(
|
|
1609
|
+
self,
|
|
1610
|
+
function_name: str,
|
|
1611
|
+
request: fc20230330_models.DeleteScalingConfigRequest,
|
|
1612
|
+
) -> fc20230330_models.DeleteScalingConfigResponse:
|
|
1613
|
+
"""
|
|
1614
|
+
@summary 删除弹性配置
|
|
1615
|
+
|
|
1616
|
+
@param request: DeleteScalingConfigRequest
|
|
1617
|
+
@return: DeleteScalingConfigResponse
|
|
1618
|
+
"""
|
|
1619
|
+
runtime = util_models.RuntimeOptions()
|
|
1620
|
+
headers = {}
|
|
1621
|
+
return self.delete_scaling_config_with_options(function_name, request, headers, runtime)
|
|
1622
|
+
|
|
1623
|
+
async def delete_scaling_config_async(
|
|
1624
|
+
self,
|
|
1625
|
+
function_name: str,
|
|
1626
|
+
request: fc20230330_models.DeleteScalingConfigRequest,
|
|
1627
|
+
) -> fc20230330_models.DeleteScalingConfigResponse:
|
|
1628
|
+
"""
|
|
1629
|
+
@summary 删除弹性配置
|
|
1630
|
+
|
|
1631
|
+
@param request: DeleteScalingConfigRequest
|
|
1632
|
+
@return: DeleteScalingConfigResponse
|
|
1633
|
+
"""
|
|
1634
|
+
runtime = util_models.RuntimeOptions()
|
|
1635
|
+
headers = {}
|
|
1636
|
+
return await self.delete_scaling_config_with_options_async(function_name, request, headers, runtime)
|
|
1637
|
+
|
|
1600
1638
|
def delete_trigger_with_options(
|
|
1601
1639
|
self,
|
|
1602
1640
|
function_name: str,
|
|
@@ -1625,16 +1663,10 @@ class Client(OpenApiClient):
|
|
|
1625
1663
|
req_body_type='json',
|
|
1626
1664
|
body_type='none'
|
|
1627
1665
|
)
|
|
1628
|
-
|
|
1629
|
-
|
|
1630
|
-
|
|
1631
|
-
|
|
1632
|
-
)
|
|
1633
|
-
else:
|
|
1634
|
-
return TeaCore.from_map(
|
|
1635
|
-
fc20230330_models.DeleteTriggerResponse(),
|
|
1636
|
-
self.execute(params, req, runtime)
|
|
1637
|
-
)
|
|
1666
|
+
return TeaCore.from_map(
|
|
1667
|
+
fc20230330_models.DeleteTriggerResponse(),
|
|
1668
|
+
self.call_api(params, req, runtime)
|
|
1669
|
+
)
|
|
1638
1670
|
|
|
1639
1671
|
async def delete_trigger_with_options_async(
|
|
1640
1672
|
self,
|
|
@@ -1664,16 +1696,10 @@ class Client(OpenApiClient):
|
|
|
1664
1696
|
req_body_type='json',
|
|
1665
1697
|
body_type='none'
|
|
1666
1698
|
)
|
|
1667
|
-
|
|
1668
|
-
|
|
1669
|
-
|
|
1670
|
-
|
|
1671
|
-
)
|
|
1672
|
-
else:
|
|
1673
|
-
return TeaCore.from_map(
|
|
1674
|
-
fc20230330_models.DeleteTriggerResponse(),
|
|
1675
|
-
await self.execute_async(params, req, runtime)
|
|
1676
|
-
)
|
|
1699
|
+
return TeaCore.from_map(
|
|
1700
|
+
fc20230330_models.DeleteTriggerResponse(),
|
|
1701
|
+
await self.call_api_async(params, req, runtime)
|
|
1702
|
+
)
|
|
1677
1703
|
|
|
1678
1704
|
def delete_trigger(
|
|
1679
1705
|
self,
|
|
@@ -1731,16 +1757,10 @@ class Client(OpenApiClient):
|
|
|
1731
1757
|
req_body_type='json',
|
|
1732
1758
|
body_type='none'
|
|
1733
1759
|
)
|
|
1734
|
-
|
|
1735
|
-
|
|
1736
|
-
|
|
1737
|
-
|
|
1738
|
-
)
|
|
1739
|
-
else:
|
|
1740
|
-
return TeaCore.from_map(
|
|
1741
|
-
fc20230330_models.DeleteVpcBindingResponse(),
|
|
1742
|
-
self.execute(params, req, runtime)
|
|
1743
|
-
)
|
|
1760
|
+
return TeaCore.from_map(
|
|
1761
|
+
fc20230330_models.DeleteVpcBindingResponse(),
|
|
1762
|
+
self.call_api(params, req, runtime)
|
|
1763
|
+
)
|
|
1744
1764
|
|
|
1745
1765
|
async def delete_vpc_binding_with_options_async(
|
|
1746
1766
|
self,
|
|
@@ -1770,16 +1790,10 @@ class Client(OpenApiClient):
|
|
|
1770
1790
|
req_body_type='json',
|
|
1771
1791
|
body_type='none'
|
|
1772
1792
|
)
|
|
1773
|
-
|
|
1774
|
-
|
|
1775
|
-
|
|
1776
|
-
|
|
1777
|
-
)
|
|
1778
|
-
else:
|
|
1779
|
-
return TeaCore.from_map(
|
|
1780
|
-
fc20230330_models.DeleteVpcBindingResponse(),
|
|
1781
|
-
await self.execute_async(params, req, runtime)
|
|
1782
|
-
)
|
|
1793
|
+
return TeaCore.from_map(
|
|
1794
|
+
fc20230330_models.DeleteVpcBindingResponse(),
|
|
1795
|
+
await self.call_api_async(params, req, runtime)
|
|
1796
|
+
)
|
|
1783
1797
|
|
|
1784
1798
|
def delete_vpc_binding(
|
|
1785
1799
|
self,
|
|
@@ -1809,6 +1823,320 @@ class Client(OpenApiClient):
|
|
|
1809
1823
|
headers = {}
|
|
1810
1824
|
return await self.delete_vpc_binding_with_options_async(function_name, vpc_id, headers, runtime)
|
|
1811
1825
|
|
|
1826
|
+
def describe_regions_with_options(
|
|
1827
|
+
self,
|
|
1828
|
+
request: fc20230330_models.DescribeRegionsRequest,
|
|
1829
|
+
headers: Dict[str, str],
|
|
1830
|
+
runtime: util_models.RuntimeOptions,
|
|
1831
|
+
) -> fc20230330_models.DescribeRegionsResponse:
|
|
1832
|
+
"""
|
|
1833
|
+
@summary 查询产品的地域信息列表
|
|
1834
|
+
|
|
1835
|
+
@param request: DescribeRegionsRequest
|
|
1836
|
+
@param headers: map
|
|
1837
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
1838
|
+
@return: DescribeRegionsResponse
|
|
1839
|
+
"""
|
|
1840
|
+
UtilClient.validate_model(request)
|
|
1841
|
+
query = {}
|
|
1842
|
+
if not UtilClient.is_unset(request.accept_language):
|
|
1843
|
+
query['AcceptLanguage'] = request.accept_language
|
|
1844
|
+
req = open_api_models.OpenApiRequest(
|
|
1845
|
+
headers=headers,
|
|
1846
|
+
query=OpenApiUtilClient.query(query)
|
|
1847
|
+
)
|
|
1848
|
+
params = open_api_models.Params(
|
|
1849
|
+
action='DescribeRegions',
|
|
1850
|
+
version='2023-03-30',
|
|
1851
|
+
protocol='HTTPS',
|
|
1852
|
+
pathname=f'/2023-03-30/regions',
|
|
1853
|
+
method='GET',
|
|
1854
|
+
auth_type='AK',
|
|
1855
|
+
style='ROA',
|
|
1856
|
+
req_body_type='json',
|
|
1857
|
+
body_type='json'
|
|
1858
|
+
)
|
|
1859
|
+
return TeaCore.from_map(
|
|
1860
|
+
fc20230330_models.DescribeRegionsResponse(),
|
|
1861
|
+
self.call_api(params, req, runtime)
|
|
1862
|
+
)
|
|
1863
|
+
|
|
1864
|
+
async def describe_regions_with_options_async(
|
|
1865
|
+
self,
|
|
1866
|
+
request: fc20230330_models.DescribeRegionsRequest,
|
|
1867
|
+
headers: Dict[str, str],
|
|
1868
|
+
runtime: util_models.RuntimeOptions,
|
|
1869
|
+
) -> fc20230330_models.DescribeRegionsResponse:
|
|
1870
|
+
"""
|
|
1871
|
+
@summary 查询产品的地域信息列表
|
|
1872
|
+
|
|
1873
|
+
@param request: DescribeRegionsRequest
|
|
1874
|
+
@param headers: map
|
|
1875
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
1876
|
+
@return: DescribeRegionsResponse
|
|
1877
|
+
"""
|
|
1878
|
+
UtilClient.validate_model(request)
|
|
1879
|
+
query = {}
|
|
1880
|
+
if not UtilClient.is_unset(request.accept_language):
|
|
1881
|
+
query['AcceptLanguage'] = request.accept_language
|
|
1882
|
+
req = open_api_models.OpenApiRequest(
|
|
1883
|
+
headers=headers,
|
|
1884
|
+
query=OpenApiUtilClient.query(query)
|
|
1885
|
+
)
|
|
1886
|
+
params = open_api_models.Params(
|
|
1887
|
+
action='DescribeRegions',
|
|
1888
|
+
version='2023-03-30',
|
|
1889
|
+
protocol='HTTPS',
|
|
1890
|
+
pathname=f'/2023-03-30/regions',
|
|
1891
|
+
method='GET',
|
|
1892
|
+
auth_type='AK',
|
|
1893
|
+
style='ROA',
|
|
1894
|
+
req_body_type='json',
|
|
1895
|
+
body_type='json'
|
|
1896
|
+
)
|
|
1897
|
+
return TeaCore.from_map(
|
|
1898
|
+
fc20230330_models.DescribeRegionsResponse(),
|
|
1899
|
+
await self.call_api_async(params, req, runtime)
|
|
1900
|
+
)
|
|
1901
|
+
|
|
1902
|
+
def describe_regions(
|
|
1903
|
+
self,
|
|
1904
|
+
request: fc20230330_models.DescribeRegionsRequest,
|
|
1905
|
+
) -> fc20230330_models.DescribeRegionsResponse:
|
|
1906
|
+
"""
|
|
1907
|
+
@summary 查询产品的地域信息列表
|
|
1908
|
+
|
|
1909
|
+
@param request: DescribeRegionsRequest
|
|
1910
|
+
@return: DescribeRegionsResponse
|
|
1911
|
+
"""
|
|
1912
|
+
runtime = util_models.RuntimeOptions()
|
|
1913
|
+
headers = {}
|
|
1914
|
+
return self.describe_regions_with_options(request, headers, runtime)
|
|
1915
|
+
|
|
1916
|
+
async def describe_regions_async(
|
|
1917
|
+
self,
|
|
1918
|
+
request: fc20230330_models.DescribeRegionsRequest,
|
|
1919
|
+
) -> fc20230330_models.DescribeRegionsResponse:
|
|
1920
|
+
"""
|
|
1921
|
+
@summary 查询产品的地域信息列表
|
|
1922
|
+
|
|
1923
|
+
@param request: DescribeRegionsRequest
|
|
1924
|
+
@return: DescribeRegionsResponse
|
|
1925
|
+
"""
|
|
1926
|
+
runtime = util_models.RuntimeOptions()
|
|
1927
|
+
headers = {}
|
|
1928
|
+
return await self.describe_regions_with_options_async(request, headers, runtime)
|
|
1929
|
+
|
|
1930
|
+
def disable_function_invocation_with_options(
|
|
1931
|
+
self,
|
|
1932
|
+
function_name: str,
|
|
1933
|
+
request: fc20230330_models.DisableFunctionInvocationRequest,
|
|
1934
|
+
headers: Dict[str, str],
|
|
1935
|
+
runtime: util_models.RuntimeOptions,
|
|
1936
|
+
) -> fc20230330_models.DisableFunctionInvocationResponse:
|
|
1937
|
+
"""
|
|
1938
|
+
@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.
|
|
1939
|
+
|
|
1940
|
+
@description Exercise caution when you call this operation on a function in a production environment, as improper deactivation may lead to business disruptions.
|
|
1941
|
+
|
|
1942
|
+
@param request: DisableFunctionInvocationRequest
|
|
1943
|
+
@param headers: map
|
|
1944
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
1945
|
+
@return: DisableFunctionInvocationResponse
|
|
1946
|
+
"""
|
|
1947
|
+
UtilClient.validate_model(request)
|
|
1948
|
+
body = {}
|
|
1949
|
+
if not UtilClient.is_unset(request.abort_ongoing_request):
|
|
1950
|
+
body['abortOngoingRequest'] = request.abort_ongoing_request
|
|
1951
|
+
if not UtilClient.is_unset(request.reason):
|
|
1952
|
+
body['reason'] = request.reason
|
|
1953
|
+
req = open_api_models.OpenApiRequest(
|
|
1954
|
+
headers=headers,
|
|
1955
|
+
body=OpenApiUtilClient.parse_to_map(body)
|
|
1956
|
+
)
|
|
1957
|
+
params = open_api_models.Params(
|
|
1958
|
+
action='DisableFunctionInvocation',
|
|
1959
|
+
version='2023-03-30',
|
|
1960
|
+
protocol='HTTPS',
|
|
1961
|
+
pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/invoke/disable',
|
|
1962
|
+
method='POST',
|
|
1963
|
+
auth_type='AK',
|
|
1964
|
+
style='ROA',
|
|
1965
|
+
req_body_type='json',
|
|
1966
|
+
body_type='json'
|
|
1967
|
+
)
|
|
1968
|
+
return TeaCore.from_map(
|
|
1969
|
+
fc20230330_models.DisableFunctionInvocationResponse(),
|
|
1970
|
+
self.call_api(params, req, runtime)
|
|
1971
|
+
)
|
|
1972
|
+
|
|
1973
|
+
async def disable_function_invocation_with_options_async(
|
|
1974
|
+
self,
|
|
1975
|
+
function_name: str,
|
|
1976
|
+
request: fc20230330_models.DisableFunctionInvocationRequest,
|
|
1977
|
+
headers: Dict[str, str],
|
|
1978
|
+
runtime: util_models.RuntimeOptions,
|
|
1979
|
+
) -> fc20230330_models.DisableFunctionInvocationResponse:
|
|
1980
|
+
"""
|
|
1981
|
+
@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.
|
|
1982
|
+
|
|
1983
|
+
@description Exercise caution when you call this operation on a function in a production environment, as improper deactivation may lead to business disruptions.
|
|
1984
|
+
|
|
1985
|
+
@param request: DisableFunctionInvocationRequest
|
|
1986
|
+
@param headers: map
|
|
1987
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
1988
|
+
@return: DisableFunctionInvocationResponse
|
|
1989
|
+
"""
|
|
1990
|
+
UtilClient.validate_model(request)
|
|
1991
|
+
body = {}
|
|
1992
|
+
if not UtilClient.is_unset(request.abort_ongoing_request):
|
|
1993
|
+
body['abortOngoingRequest'] = request.abort_ongoing_request
|
|
1994
|
+
if not UtilClient.is_unset(request.reason):
|
|
1995
|
+
body['reason'] = request.reason
|
|
1996
|
+
req = open_api_models.OpenApiRequest(
|
|
1997
|
+
headers=headers,
|
|
1998
|
+
body=OpenApiUtilClient.parse_to_map(body)
|
|
1999
|
+
)
|
|
2000
|
+
params = open_api_models.Params(
|
|
2001
|
+
action='DisableFunctionInvocation',
|
|
2002
|
+
version='2023-03-30',
|
|
2003
|
+
protocol='HTTPS',
|
|
2004
|
+
pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/invoke/disable',
|
|
2005
|
+
method='POST',
|
|
2006
|
+
auth_type='AK',
|
|
2007
|
+
style='ROA',
|
|
2008
|
+
req_body_type='json',
|
|
2009
|
+
body_type='json'
|
|
2010
|
+
)
|
|
2011
|
+
return TeaCore.from_map(
|
|
2012
|
+
fc20230330_models.DisableFunctionInvocationResponse(),
|
|
2013
|
+
await self.call_api_async(params, req, runtime)
|
|
2014
|
+
)
|
|
2015
|
+
|
|
2016
|
+
def disable_function_invocation(
|
|
2017
|
+
self,
|
|
2018
|
+
function_name: str,
|
|
2019
|
+
request: fc20230330_models.DisableFunctionInvocationRequest,
|
|
2020
|
+
) -> fc20230330_models.DisableFunctionInvocationResponse:
|
|
2021
|
+
"""
|
|
2022
|
+
@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.
|
|
2023
|
+
|
|
2024
|
+
@description Exercise caution when you call this operation on a function in a production environment, as improper deactivation may lead to business disruptions.
|
|
2025
|
+
|
|
2026
|
+
@param request: DisableFunctionInvocationRequest
|
|
2027
|
+
@return: DisableFunctionInvocationResponse
|
|
2028
|
+
"""
|
|
2029
|
+
runtime = util_models.RuntimeOptions()
|
|
2030
|
+
headers = {}
|
|
2031
|
+
return self.disable_function_invocation_with_options(function_name, request, headers, runtime)
|
|
2032
|
+
|
|
2033
|
+
async def disable_function_invocation_async(
|
|
2034
|
+
self,
|
|
2035
|
+
function_name: str,
|
|
2036
|
+
request: fc20230330_models.DisableFunctionInvocationRequest,
|
|
2037
|
+
) -> fc20230330_models.DisableFunctionInvocationResponse:
|
|
2038
|
+
"""
|
|
2039
|
+
@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.
|
|
2040
|
+
|
|
2041
|
+
@description Exercise caution when you call this operation on a function in a production environment, as improper deactivation may lead to business disruptions.
|
|
2042
|
+
|
|
2043
|
+
@param request: DisableFunctionInvocationRequest
|
|
2044
|
+
@return: DisableFunctionInvocationResponse
|
|
2045
|
+
"""
|
|
2046
|
+
runtime = util_models.RuntimeOptions()
|
|
2047
|
+
headers = {}
|
|
2048
|
+
return await self.disable_function_invocation_with_options_async(function_name, request, headers, runtime)
|
|
2049
|
+
|
|
2050
|
+
def enable_function_invocation_with_options(
|
|
2051
|
+
self,
|
|
2052
|
+
function_name: str,
|
|
2053
|
+
headers: Dict[str, str],
|
|
2054
|
+
runtime: util_models.RuntimeOptions,
|
|
2055
|
+
) -> fc20230330_models.EnableFunctionInvocationResponse:
|
|
2056
|
+
"""
|
|
2057
|
+
@summary 允许函数调用
|
|
2058
|
+
|
|
2059
|
+
@param headers: map
|
|
2060
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
2061
|
+
@return: EnableFunctionInvocationResponse
|
|
2062
|
+
"""
|
|
2063
|
+
req = open_api_models.OpenApiRequest(
|
|
2064
|
+
headers=headers
|
|
2065
|
+
)
|
|
2066
|
+
params = open_api_models.Params(
|
|
2067
|
+
action='EnableFunctionInvocation',
|
|
2068
|
+
version='2023-03-30',
|
|
2069
|
+
protocol='HTTPS',
|
|
2070
|
+
pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/invoke/enable',
|
|
2071
|
+
method='POST',
|
|
2072
|
+
auth_type='AK',
|
|
2073
|
+
style='ROA',
|
|
2074
|
+
req_body_type='json',
|
|
2075
|
+
body_type='json'
|
|
2076
|
+
)
|
|
2077
|
+
return TeaCore.from_map(
|
|
2078
|
+
fc20230330_models.EnableFunctionInvocationResponse(),
|
|
2079
|
+
self.call_api(params, req, runtime)
|
|
2080
|
+
)
|
|
2081
|
+
|
|
2082
|
+
async def enable_function_invocation_with_options_async(
|
|
2083
|
+
self,
|
|
2084
|
+
function_name: str,
|
|
2085
|
+
headers: Dict[str, str],
|
|
2086
|
+
runtime: util_models.RuntimeOptions,
|
|
2087
|
+
) -> fc20230330_models.EnableFunctionInvocationResponse:
|
|
2088
|
+
"""
|
|
2089
|
+
@summary 允许函数调用
|
|
2090
|
+
|
|
2091
|
+
@param headers: map
|
|
2092
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
2093
|
+
@return: EnableFunctionInvocationResponse
|
|
2094
|
+
"""
|
|
2095
|
+
req = open_api_models.OpenApiRequest(
|
|
2096
|
+
headers=headers
|
|
2097
|
+
)
|
|
2098
|
+
params = open_api_models.Params(
|
|
2099
|
+
action='EnableFunctionInvocation',
|
|
2100
|
+
version='2023-03-30',
|
|
2101
|
+
protocol='HTTPS',
|
|
2102
|
+
pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/invoke/enable',
|
|
2103
|
+
method='POST',
|
|
2104
|
+
auth_type='AK',
|
|
2105
|
+
style='ROA',
|
|
2106
|
+
req_body_type='json',
|
|
2107
|
+
body_type='json'
|
|
2108
|
+
)
|
|
2109
|
+
return TeaCore.from_map(
|
|
2110
|
+
fc20230330_models.EnableFunctionInvocationResponse(),
|
|
2111
|
+
await self.call_api_async(params, req, runtime)
|
|
2112
|
+
)
|
|
2113
|
+
|
|
2114
|
+
def enable_function_invocation(
|
|
2115
|
+
self,
|
|
2116
|
+
function_name: str,
|
|
2117
|
+
) -> fc20230330_models.EnableFunctionInvocationResponse:
|
|
2118
|
+
"""
|
|
2119
|
+
@summary 允许函数调用
|
|
2120
|
+
|
|
2121
|
+
@return: EnableFunctionInvocationResponse
|
|
2122
|
+
"""
|
|
2123
|
+
runtime = util_models.RuntimeOptions()
|
|
2124
|
+
headers = {}
|
|
2125
|
+
return self.enable_function_invocation_with_options(function_name, headers, runtime)
|
|
2126
|
+
|
|
2127
|
+
async def enable_function_invocation_async(
|
|
2128
|
+
self,
|
|
2129
|
+
function_name: str,
|
|
2130
|
+
) -> fc20230330_models.EnableFunctionInvocationResponse:
|
|
2131
|
+
"""
|
|
2132
|
+
@summary 允许函数调用
|
|
2133
|
+
|
|
2134
|
+
@return: EnableFunctionInvocationResponse
|
|
2135
|
+
"""
|
|
2136
|
+
runtime = util_models.RuntimeOptions()
|
|
2137
|
+
headers = {}
|
|
2138
|
+
return await self.enable_function_invocation_with_options_async(function_name, headers, runtime)
|
|
2139
|
+
|
|
1812
2140
|
def get_alias_with_options(
|
|
1813
2141
|
self,
|
|
1814
2142
|
function_name: str,
|
|
@@ -1837,16 +2165,10 @@ class Client(OpenApiClient):
|
|
|
1837
2165
|
req_body_type='json',
|
|
1838
2166
|
body_type='json'
|
|
1839
2167
|
)
|
|
1840
|
-
|
|
1841
|
-
|
|
1842
|
-
|
|
1843
|
-
|
|
1844
|
-
)
|
|
1845
|
-
else:
|
|
1846
|
-
return TeaCore.from_map(
|
|
1847
|
-
fc20230330_models.GetAliasResponse(),
|
|
1848
|
-
self.execute(params, req, runtime)
|
|
1849
|
-
)
|
|
2168
|
+
return TeaCore.from_map(
|
|
2169
|
+
fc20230330_models.GetAliasResponse(),
|
|
2170
|
+
self.call_api(params, req, runtime)
|
|
2171
|
+
)
|
|
1850
2172
|
|
|
1851
2173
|
async def get_alias_with_options_async(
|
|
1852
2174
|
self,
|
|
@@ -1876,16 +2198,10 @@ class Client(OpenApiClient):
|
|
|
1876
2198
|
req_body_type='json',
|
|
1877
2199
|
body_type='json'
|
|
1878
2200
|
)
|
|
1879
|
-
|
|
1880
|
-
|
|
1881
|
-
|
|
1882
|
-
|
|
1883
|
-
)
|
|
1884
|
-
else:
|
|
1885
|
-
return TeaCore.from_map(
|
|
1886
|
-
fc20230330_models.GetAliasResponse(),
|
|
1887
|
-
await self.execute_async(params, req, runtime)
|
|
1888
|
-
)
|
|
2201
|
+
return TeaCore.from_map(
|
|
2202
|
+
fc20230330_models.GetAliasResponse(),
|
|
2203
|
+
await self.call_api_async(params, req, runtime)
|
|
2204
|
+
)
|
|
1889
2205
|
|
|
1890
2206
|
def get_alias(
|
|
1891
2207
|
self,
|
|
@@ -1949,16 +2265,10 @@ class Client(OpenApiClient):
|
|
|
1949
2265
|
req_body_type='json',
|
|
1950
2266
|
body_type='json'
|
|
1951
2267
|
)
|
|
1952
|
-
|
|
1953
|
-
|
|
1954
|
-
|
|
1955
|
-
|
|
1956
|
-
)
|
|
1957
|
-
else:
|
|
1958
|
-
return TeaCore.from_map(
|
|
1959
|
-
fc20230330_models.GetAsyncInvokeConfigResponse(),
|
|
1960
|
-
self.execute(params, req, runtime)
|
|
1961
|
-
)
|
|
2268
|
+
return TeaCore.from_map(
|
|
2269
|
+
fc20230330_models.GetAsyncInvokeConfigResponse(),
|
|
2270
|
+
self.call_api(params, req, runtime)
|
|
2271
|
+
)
|
|
1962
2272
|
|
|
1963
2273
|
async def get_async_invoke_config_with_options_async(
|
|
1964
2274
|
self,
|
|
@@ -1994,16 +2304,10 @@ class Client(OpenApiClient):
|
|
|
1994
2304
|
req_body_type='json',
|
|
1995
2305
|
body_type='json'
|
|
1996
2306
|
)
|
|
1997
|
-
|
|
1998
|
-
|
|
1999
|
-
|
|
2000
|
-
|
|
2001
|
-
)
|
|
2002
|
-
else:
|
|
2003
|
-
return TeaCore.from_map(
|
|
2004
|
-
fc20230330_models.GetAsyncInvokeConfigResponse(),
|
|
2005
|
-
await self.execute_async(params, req, runtime)
|
|
2006
|
-
)
|
|
2307
|
+
return TeaCore.from_map(
|
|
2308
|
+
fc20230330_models.GetAsyncInvokeConfigResponse(),
|
|
2309
|
+
await self.call_api_async(params, req, runtime)
|
|
2310
|
+
)
|
|
2007
2311
|
|
|
2008
2312
|
def get_async_invoke_config(
|
|
2009
2313
|
self,
|
|
@@ -2070,16 +2374,10 @@ class Client(OpenApiClient):
|
|
|
2070
2374
|
req_body_type='json',
|
|
2071
2375
|
body_type='json'
|
|
2072
2376
|
)
|
|
2073
|
-
|
|
2074
|
-
|
|
2075
|
-
|
|
2076
|
-
|
|
2077
|
-
)
|
|
2078
|
-
else:
|
|
2079
|
-
return TeaCore.from_map(
|
|
2080
|
-
fc20230330_models.GetAsyncTaskResponse(),
|
|
2081
|
-
self.execute(params, req, runtime)
|
|
2082
|
-
)
|
|
2377
|
+
return TeaCore.from_map(
|
|
2378
|
+
fc20230330_models.GetAsyncTaskResponse(),
|
|
2379
|
+
self.call_api(params, req, runtime)
|
|
2380
|
+
)
|
|
2083
2381
|
|
|
2084
2382
|
async def get_async_task_with_options_async(
|
|
2085
2383
|
self,
|
|
@@ -2116,16 +2414,10 @@ class Client(OpenApiClient):
|
|
|
2116
2414
|
req_body_type='json',
|
|
2117
2415
|
body_type='json'
|
|
2118
2416
|
)
|
|
2119
|
-
|
|
2120
|
-
|
|
2121
|
-
|
|
2122
|
-
|
|
2123
|
-
)
|
|
2124
|
-
else:
|
|
2125
|
-
return TeaCore.from_map(
|
|
2126
|
-
fc20230330_models.GetAsyncTaskResponse(),
|
|
2127
|
-
await self.execute_async(params, req, runtime)
|
|
2128
|
-
)
|
|
2417
|
+
return TeaCore.from_map(
|
|
2418
|
+
fc20230330_models.GetAsyncTaskResponse(),
|
|
2419
|
+
await self.call_api_async(params, req, runtime)
|
|
2420
|
+
)
|
|
2129
2421
|
|
|
2130
2422
|
def get_async_task(
|
|
2131
2423
|
self,
|
|
@@ -2186,16 +2478,10 @@ class Client(OpenApiClient):
|
|
|
2186
2478
|
req_body_type='json',
|
|
2187
2479
|
body_type='json'
|
|
2188
2480
|
)
|
|
2189
|
-
|
|
2190
|
-
|
|
2191
|
-
|
|
2192
|
-
|
|
2193
|
-
)
|
|
2194
|
-
else:
|
|
2195
|
-
return TeaCore.from_map(
|
|
2196
|
-
fc20230330_models.GetConcurrencyConfigResponse(),
|
|
2197
|
-
self.execute(params, req, runtime)
|
|
2198
|
-
)
|
|
2481
|
+
return TeaCore.from_map(
|
|
2482
|
+
fc20230330_models.GetConcurrencyConfigResponse(),
|
|
2483
|
+
self.call_api(params, req, runtime)
|
|
2484
|
+
)
|
|
2199
2485
|
|
|
2200
2486
|
async def get_concurrency_config_with_options_async(
|
|
2201
2487
|
self,
|
|
@@ -2224,16 +2510,10 @@ class Client(OpenApiClient):
|
|
|
2224
2510
|
req_body_type='json',
|
|
2225
2511
|
body_type='json'
|
|
2226
2512
|
)
|
|
2227
|
-
|
|
2228
|
-
|
|
2229
|
-
|
|
2230
|
-
|
|
2231
|
-
)
|
|
2232
|
-
else:
|
|
2233
|
-
return TeaCore.from_map(
|
|
2234
|
-
fc20230330_models.GetConcurrencyConfigResponse(),
|
|
2235
|
-
await self.execute_async(params, req, runtime)
|
|
2236
|
-
)
|
|
2513
|
+
return TeaCore.from_map(
|
|
2514
|
+
fc20230330_models.GetConcurrencyConfigResponse(),
|
|
2515
|
+
await self.call_api_async(params, req, runtime)
|
|
2516
|
+
)
|
|
2237
2517
|
|
|
2238
2518
|
def get_concurrency_config(
|
|
2239
2519
|
self,
|
|
@@ -2288,16 +2568,10 @@ class Client(OpenApiClient):
|
|
|
2288
2568
|
req_body_type='json',
|
|
2289
2569
|
body_type='json'
|
|
2290
2570
|
)
|
|
2291
|
-
|
|
2292
|
-
|
|
2293
|
-
|
|
2294
|
-
|
|
2295
|
-
)
|
|
2296
|
-
else:
|
|
2297
|
-
return TeaCore.from_map(
|
|
2298
|
-
fc20230330_models.GetCustomDomainResponse(),
|
|
2299
|
-
self.execute(params, req, runtime)
|
|
2300
|
-
)
|
|
2571
|
+
return TeaCore.from_map(
|
|
2572
|
+
fc20230330_models.GetCustomDomainResponse(),
|
|
2573
|
+
self.call_api(params, req, runtime)
|
|
2574
|
+
)
|
|
2301
2575
|
|
|
2302
2576
|
async def get_custom_domain_with_options_async(
|
|
2303
2577
|
self,
|
|
@@ -2326,16 +2600,10 @@ class Client(OpenApiClient):
|
|
|
2326
2600
|
req_body_type='json',
|
|
2327
2601
|
body_type='json'
|
|
2328
2602
|
)
|
|
2329
|
-
|
|
2330
|
-
|
|
2331
|
-
|
|
2332
|
-
|
|
2333
|
-
)
|
|
2334
|
-
else:
|
|
2335
|
-
return TeaCore.from_map(
|
|
2336
|
-
fc20230330_models.GetCustomDomainResponse(),
|
|
2337
|
-
await self.execute_async(params, req, runtime)
|
|
2338
|
-
)
|
|
2603
|
+
return TeaCore.from_map(
|
|
2604
|
+
fc20230330_models.GetCustomDomainResponse(),
|
|
2605
|
+
await self.call_api_async(params, req, runtime)
|
|
2606
|
+
)
|
|
2339
2607
|
|
|
2340
2608
|
def get_custom_domain(
|
|
2341
2609
|
self,
|
|
@@ -2397,16 +2665,10 @@ class Client(OpenApiClient):
|
|
|
2397
2665
|
req_body_type='json',
|
|
2398
2666
|
body_type='json'
|
|
2399
2667
|
)
|
|
2400
|
-
|
|
2401
|
-
|
|
2402
|
-
|
|
2403
|
-
|
|
2404
|
-
)
|
|
2405
|
-
else:
|
|
2406
|
-
return TeaCore.from_map(
|
|
2407
|
-
fc20230330_models.GetFunctionResponse(),
|
|
2408
|
-
self.execute(params, req, runtime)
|
|
2409
|
-
)
|
|
2668
|
+
return TeaCore.from_map(
|
|
2669
|
+
fc20230330_models.GetFunctionResponse(),
|
|
2670
|
+
self.call_api(params, req, runtime)
|
|
2671
|
+
)
|
|
2410
2672
|
|
|
2411
2673
|
async def get_function_with_options_async(
|
|
2412
2674
|
self,
|
|
@@ -2442,16 +2704,10 @@ class Client(OpenApiClient):
|
|
|
2442
2704
|
req_body_type='json',
|
|
2443
2705
|
body_type='json'
|
|
2444
2706
|
)
|
|
2445
|
-
|
|
2446
|
-
|
|
2447
|
-
|
|
2448
|
-
|
|
2449
|
-
)
|
|
2450
|
-
else:
|
|
2451
|
-
return TeaCore.from_map(
|
|
2452
|
-
fc20230330_models.GetFunctionResponse(),
|
|
2453
|
-
await self.execute_async(params, req, runtime)
|
|
2454
|
-
)
|
|
2707
|
+
return TeaCore.from_map(
|
|
2708
|
+
fc20230330_models.GetFunctionResponse(),
|
|
2709
|
+
await self.call_api_async(params, req, runtime)
|
|
2710
|
+
)
|
|
2455
2711
|
|
|
2456
2712
|
def get_function(
|
|
2457
2713
|
self,
|
|
@@ -2517,16 +2773,10 @@ class Client(OpenApiClient):
|
|
|
2517
2773
|
req_body_type='json',
|
|
2518
2774
|
body_type='json'
|
|
2519
2775
|
)
|
|
2520
|
-
|
|
2521
|
-
|
|
2522
|
-
|
|
2523
|
-
|
|
2524
|
-
)
|
|
2525
|
-
else:
|
|
2526
|
-
return TeaCore.from_map(
|
|
2527
|
-
fc20230330_models.GetFunctionCodeResponse(),
|
|
2528
|
-
self.execute(params, req, runtime)
|
|
2529
|
-
)
|
|
2776
|
+
return TeaCore.from_map(
|
|
2777
|
+
fc20230330_models.GetFunctionCodeResponse(),
|
|
2778
|
+
self.call_api(params, req, runtime)
|
|
2779
|
+
)
|
|
2530
2780
|
|
|
2531
2781
|
async def get_function_code_with_options_async(
|
|
2532
2782
|
self,
|
|
@@ -2562,16 +2812,10 @@ class Client(OpenApiClient):
|
|
|
2562
2812
|
req_body_type='json',
|
|
2563
2813
|
body_type='json'
|
|
2564
2814
|
)
|
|
2565
|
-
|
|
2566
|
-
|
|
2567
|
-
|
|
2568
|
-
|
|
2569
|
-
)
|
|
2570
|
-
else:
|
|
2571
|
-
return TeaCore.from_map(
|
|
2572
|
-
fc20230330_models.GetFunctionCodeResponse(),
|
|
2573
|
-
await self.execute_async(params, req, runtime)
|
|
2574
|
-
)
|
|
2815
|
+
return TeaCore.from_map(
|
|
2816
|
+
fc20230330_models.GetFunctionCodeResponse(),
|
|
2817
|
+
await self.call_api_async(params, req, runtime)
|
|
2818
|
+
)
|
|
2575
2819
|
|
|
2576
2820
|
def get_function_code(
|
|
2577
2821
|
self,
|
|
@@ -2631,16 +2875,10 @@ class Client(OpenApiClient):
|
|
|
2631
2875
|
req_body_type='json',
|
|
2632
2876
|
body_type='json'
|
|
2633
2877
|
)
|
|
2634
|
-
|
|
2635
|
-
|
|
2636
|
-
|
|
2637
|
-
|
|
2638
|
-
)
|
|
2639
|
-
else:
|
|
2640
|
-
return TeaCore.from_map(
|
|
2641
|
-
fc20230330_models.GetLayerVersionResponse(),
|
|
2642
|
-
self.execute(params, req, runtime)
|
|
2643
|
-
)
|
|
2878
|
+
return TeaCore.from_map(
|
|
2879
|
+
fc20230330_models.GetLayerVersionResponse(),
|
|
2880
|
+
self.call_api(params, req, runtime)
|
|
2881
|
+
)
|
|
2644
2882
|
|
|
2645
2883
|
async def get_layer_version_with_options_async(
|
|
2646
2884
|
self,
|
|
@@ -2670,16 +2908,10 @@ class Client(OpenApiClient):
|
|
|
2670
2908
|
req_body_type='json',
|
|
2671
2909
|
body_type='json'
|
|
2672
2910
|
)
|
|
2673
|
-
|
|
2674
|
-
|
|
2675
|
-
|
|
2676
|
-
|
|
2677
|
-
)
|
|
2678
|
-
else:
|
|
2679
|
-
return TeaCore.from_map(
|
|
2680
|
-
fc20230330_models.GetLayerVersionResponse(),
|
|
2681
|
-
await self.execute_async(params, req, runtime)
|
|
2682
|
-
)
|
|
2911
|
+
return TeaCore.from_map(
|
|
2912
|
+
fc20230330_models.GetLayerVersionResponse(),
|
|
2913
|
+
await self.call_api_async(params, req, runtime)
|
|
2914
|
+
)
|
|
2683
2915
|
|
|
2684
2916
|
def get_layer_version(
|
|
2685
2917
|
self,
|
|
@@ -2736,16 +2968,10 @@ class Client(OpenApiClient):
|
|
|
2736
2968
|
req_body_type='json',
|
|
2737
2969
|
body_type='json'
|
|
2738
2970
|
)
|
|
2739
|
-
|
|
2740
|
-
|
|
2741
|
-
|
|
2742
|
-
|
|
2743
|
-
)
|
|
2744
|
-
else:
|
|
2745
|
-
return TeaCore.from_map(
|
|
2746
|
-
fc20230330_models.GetLayerVersionByArnResponse(),
|
|
2747
|
-
self.execute(params, req, runtime)
|
|
2748
|
-
)
|
|
2971
|
+
return TeaCore.from_map(
|
|
2972
|
+
fc20230330_models.GetLayerVersionByArnResponse(),
|
|
2973
|
+
self.call_api(params, req, runtime)
|
|
2974
|
+
)
|
|
2749
2975
|
|
|
2750
2976
|
async def get_layer_version_by_arn_with_options_async(
|
|
2751
2977
|
self,
|
|
@@ -2774,16 +3000,10 @@ class Client(OpenApiClient):
|
|
|
2774
3000
|
req_body_type='json',
|
|
2775
3001
|
body_type='json'
|
|
2776
3002
|
)
|
|
2777
|
-
|
|
2778
|
-
|
|
2779
|
-
|
|
2780
|
-
|
|
2781
|
-
)
|
|
2782
|
-
else:
|
|
2783
|
-
return TeaCore.from_map(
|
|
2784
|
-
fc20230330_models.GetLayerVersionByArnResponse(),
|
|
2785
|
-
await self.execute_async(params, req, runtime)
|
|
2786
|
-
)
|
|
3003
|
+
return TeaCore.from_map(
|
|
3004
|
+
fc20230330_models.GetLayerVersionByArnResponse(),
|
|
3005
|
+
await self.call_api_async(params, req, runtime)
|
|
3006
|
+
)
|
|
2787
3007
|
|
|
2788
3008
|
def get_layer_version_by_arn(
|
|
2789
3009
|
self,
|
|
@@ -2809,22 +3029,130 @@ class Client(OpenApiClient):
|
|
|
2809
3029
|
"""
|
|
2810
3030
|
runtime = util_models.RuntimeOptions()
|
|
2811
3031
|
headers = {}
|
|
2812
|
-
return await self.get_layer_version_by_arn_with_options_async(arn, headers, runtime)
|
|
3032
|
+
return await self.get_layer_version_by_arn_with_options_async(arn, headers, runtime)
|
|
3033
|
+
|
|
3034
|
+
def get_provision_config_with_options(
|
|
3035
|
+
self,
|
|
3036
|
+
function_name: str,
|
|
3037
|
+
request: fc20230330_models.GetProvisionConfigRequest,
|
|
3038
|
+
headers: Dict[str, str],
|
|
3039
|
+
runtime: util_models.RuntimeOptions,
|
|
3040
|
+
) -> fc20230330_models.GetProvisionConfigResponse:
|
|
3041
|
+
"""
|
|
3042
|
+
@summary Queries provisioned configurations.
|
|
3043
|
+
|
|
3044
|
+
@param request: GetProvisionConfigRequest
|
|
3045
|
+
@param headers: map
|
|
3046
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
3047
|
+
@return: GetProvisionConfigResponse
|
|
3048
|
+
"""
|
|
3049
|
+
UtilClient.validate_model(request)
|
|
3050
|
+
query = {}
|
|
3051
|
+
if not UtilClient.is_unset(request.qualifier):
|
|
3052
|
+
query['qualifier'] = request.qualifier
|
|
3053
|
+
req = open_api_models.OpenApiRequest(
|
|
3054
|
+
headers=headers,
|
|
3055
|
+
query=OpenApiUtilClient.query(query)
|
|
3056
|
+
)
|
|
3057
|
+
params = open_api_models.Params(
|
|
3058
|
+
action='GetProvisionConfig',
|
|
3059
|
+
version='2023-03-30',
|
|
3060
|
+
protocol='HTTPS',
|
|
3061
|
+
pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/provision-config',
|
|
3062
|
+
method='GET',
|
|
3063
|
+
auth_type='AK',
|
|
3064
|
+
style='ROA',
|
|
3065
|
+
req_body_type='json',
|
|
3066
|
+
body_type='json'
|
|
3067
|
+
)
|
|
3068
|
+
return TeaCore.from_map(
|
|
3069
|
+
fc20230330_models.GetProvisionConfigResponse(),
|
|
3070
|
+
self.call_api(params, req, runtime)
|
|
3071
|
+
)
|
|
3072
|
+
|
|
3073
|
+
async def get_provision_config_with_options_async(
|
|
3074
|
+
self,
|
|
3075
|
+
function_name: str,
|
|
3076
|
+
request: fc20230330_models.GetProvisionConfigRequest,
|
|
3077
|
+
headers: Dict[str, str],
|
|
3078
|
+
runtime: util_models.RuntimeOptions,
|
|
3079
|
+
) -> fc20230330_models.GetProvisionConfigResponse:
|
|
3080
|
+
"""
|
|
3081
|
+
@summary Queries provisioned configurations.
|
|
3082
|
+
|
|
3083
|
+
@param request: GetProvisionConfigRequest
|
|
3084
|
+
@param headers: map
|
|
3085
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
3086
|
+
@return: GetProvisionConfigResponse
|
|
3087
|
+
"""
|
|
3088
|
+
UtilClient.validate_model(request)
|
|
3089
|
+
query = {}
|
|
3090
|
+
if not UtilClient.is_unset(request.qualifier):
|
|
3091
|
+
query['qualifier'] = request.qualifier
|
|
3092
|
+
req = open_api_models.OpenApiRequest(
|
|
3093
|
+
headers=headers,
|
|
3094
|
+
query=OpenApiUtilClient.query(query)
|
|
3095
|
+
)
|
|
3096
|
+
params = open_api_models.Params(
|
|
3097
|
+
action='GetProvisionConfig',
|
|
3098
|
+
version='2023-03-30',
|
|
3099
|
+
protocol='HTTPS',
|
|
3100
|
+
pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/provision-config',
|
|
3101
|
+
method='GET',
|
|
3102
|
+
auth_type='AK',
|
|
3103
|
+
style='ROA',
|
|
3104
|
+
req_body_type='json',
|
|
3105
|
+
body_type='json'
|
|
3106
|
+
)
|
|
3107
|
+
return TeaCore.from_map(
|
|
3108
|
+
fc20230330_models.GetProvisionConfigResponse(),
|
|
3109
|
+
await self.call_api_async(params, req, runtime)
|
|
3110
|
+
)
|
|
3111
|
+
|
|
3112
|
+
def get_provision_config(
|
|
3113
|
+
self,
|
|
3114
|
+
function_name: str,
|
|
3115
|
+
request: fc20230330_models.GetProvisionConfigRequest,
|
|
3116
|
+
) -> fc20230330_models.GetProvisionConfigResponse:
|
|
3117
|
+
"""
|
|
3118
|
+
@summary Queries provisioned configurations.
|
|
3119
|
+
|
|
3120
|
+
@param request: GetProvisionConfigRequest
|
|
3121
|
+
@return: GetProvisionConfigResponse
|
|
3122
|
+
"""
|
|
3123
|
+
runtime = util_models.RuntimeOptions()
|
|
3124
|
+
headers = {}
|
|
3125
|
+
return self.get_provision_config_with_options(function_name, request, headers, runtime)
|
|
3126
|
+
|
|
3127
|
+
async def get_provision_config_async(
|
|
3128
|
+
self,
|
|
3129
|
+
function_name: str,
|
|
3130
|
+
request: fc20230330_models.GetProvisionConfigRequest,
|
|
3131
|
+
) -> fc20230330_models.GetProvisionConfigResponse:
|
|
3132
|
+
"""
|
|
3133
|
+
@summary Queries provisioned configurations.
|
|
3134
|
+
|
|
3135
|
+
@param request: GetProvisionConfigRequest
|
|
3136
|
+
@return: GetProvisionConfigResponse
|
|
3137
|
+
"""
|
|
3138
|
+
runtime = util_models.RuntimeOptions()
|
|
3139
|
+
headers = {}
|
|
3140
|
+
return await self.get_provision_config_with_options_async(function_name, request, headers, runtime)
|
|
2813
3141
|
|
|
2814
|
-
def
|
|
3142
|
+
def get_scaling_config_with_options(
|
|
2815
3143
|
self,
|
|
2816
3144
|
function_name: str,
|
|
2817
|
-
request: fc20230330_models.
|
|
3145
|
+
request: fc20230330_models.GetScalingConfigRequest,
|
|
2818
3146
|
headers: Dict[str, str],
|
|
2819
3147
|
runtime: util_models.RuntimeOptions,
|
|
2820
|
-
) -> fc20230330_models.
|
|
3148
|
+
) -> fc20230330_models.GetScalingConfigResponse:
|
|
2821
3149
|
"""
|
|
2822
|
-
@summary
|
|
3150
|
+
@summary 获取弹性配置
|
|
2823
3151
|
|
|
2824
|
-
@param request:
|
|
3152
|
+
@param request: GetScalingConfigRequest
|
|
2825
3153
|
@param headers: map
|
|
2826
3154
|
@param runtime: runtime options for this request RuntimeOptions
|
|
2827
|
-
@return:
|
|
3155
|
+
@return: GetScalingConfigResponse
|
|
2828
3156
|
"""
|
|
2829
3157
|
UtilClient.validate_model(request)
|
|
2830
3158
|
query = {}
|
|
@@ -2835,41 +3163,35 @@ class Client(OpenApiClient):
|
|
|
2835
3163
|
query=OpenApiUtilClient.query(query)
|
|
2836
3164
|
)
|
|
2837
3165
|
params = open_api_models.Params(
|
|
2838
|
-
action='
|
|
3166
|
+
action='GetScalingConfig',
|
|
2839
3167
|
version='2023-03-30',
|
|
2840
3168
|
protocol='HTTPS',
|
|
2841
|
-
pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/
|
|
3169
|
+
pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/scaling-config',
|
|
2842
3170
|
method='GET',
|
|
2843
3171
|
auth_type='AK',
|
|
2844
3172
|
style='ROA',
|
|
2845
3173
|
req_body_type='json',
|
|
2846
3174
|
body_type='json'
|
|
2847
3175
|
)
|
|
2848
|
-
|
|
2849
|
-
|
|
2850
|
-
|
|
2851
|
-
|
|
2852
|
-
)
|
|
2853
|
-
else:
|
|
2854
|
-
return TeaCore.from_map(
|
|
2855
|
-
fc20230330_models.GetProvisionConfigResponse(),
|
|
2856
|
-
self.execute(params, req, runtime)
|
|
2857
|
-
)
|
|
3176
|
+
return TeaCore.from_map(
|
|
3177
|
+
fc20230330_models.GetScalingConfigResponse(),
|
|
3178
|
+
self.call_api(params, req, runtime)
|
|
3179
|
+
)
|
|
2858
3180
|
|
|
2859
|
-
async def
|
|
3181
|
+
async def get_scaling_config_with_options_async(
|
|
2860
3182
|
self,
|
|
2861
3183
|
function_name: str,
|
|
2862
|
-
request: fc20230330_models.
|
|
3184
|
+
request: fc20230330_models.GetScalingConfigRequest,
|
|
2863
3185
|
headers: Dict[str, str],
|
|
2864
3186
|
runtime: util_models.RuntimeOptions,
|
|
2865
|
-
) -> fc20230330_models.
|
|
3187
|
+
) -> fc20230330_models.GetScalingConfigResponse:
|
|
2866
3188
|
"""
|
|
2867
|
-
@summary
|
|
3189
|
+
@summary 获取弹性配置
|
|
2868
3190
|
|
|
2869
|
-
@param request:
|
|
3191
|
+
@param request: GetScalingConfigRequest
|
|
2870
3192
|
@param headers: map
|
|
2871
3193
|
@param runtime: runtime options for this request RuntimeOptions
|
|
2872
|
-
@return:
|
|
3194
|
+
@return: GetScalingConfigResponse
|
|
2873
3195
|
"""
|
|
2874
3196
|
UtilClient.validate_model(request)
|
|
2875
3197
|
query = {}
|
|
@@ -2880,56 +3202,50 @@ class Client(OpenApiClient):
|
|
|
2880
3202
|
query=OpenApiUtilClient.query(query)
|
|
2881
3203
|
)
|
|
2882
3204
|
params = open_api_models.Params(
|
|
2883
|
-
action='
|
|
3205
|
+
action='GetScalingConfig',
|
|
2884
3206
|
version='2023-03-30',
|
|
2885
3207
|
protocol='HTTPS',
|
|
2886
|
-
pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/
|
|
3208
|
+
pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/scaling-config',
|
|
2887
3209
|
method='GET',
|
|
2888
3210
|
auth_type='AK',
|
|
2889
3211
|
style='ROA',
|
|
2890
3212
|
req_body_type='json',
|
|
2891
3213
|
body_type='json'
|
|
2892
3214
|
)
|
|
2893
|
-
|
|
2894
|
-
|
|
2895
|
-
|
|
2896
|
-
|
|
2897
|
-
)
|
|
2898
|
-
else:
|
|
2899
|
-
return TeaCore.from_map(
|
|
2900
|
-
fc20230330_models.GetProvisionConfigResponse(),
|
|
2901
|
-
await self.execute_async(params, req, runtime)
|
|
2902
|
-
)
|
|
3215
|
+
return TeaCore.from_map(
|
|
3216
|
+
fc20230330_models.GetScalingConfigResponse(),
|
|
3217
|
+
await self.call_api_async(params, req, runtime)
|
|
3218
|
+
)
|
|
2903
3219
|
|
|
2904
|
-
def
|
|
3220
|
+
def get_scaling_config(
|
|
2905
3221
|
self,
|
|
2906
3222
|
function_name: str,
|
|
2907
|
-
request: fc20230330_models.
|
|
2908
|
-
) -> fc20230330_models.
|
|
3223
|
+
request: fc20230330_models.GetScalingConfigRequest,
|
|
3224
|
+
) -> fc20230330_models.GetScalingConfigResponse:
|
|
2909
3225
|
"""
|
|
2910
|
-
@summary
|
|
3226
|
+
@summary 获取弹性配置
|
|
2911
3227
|
|
|
2912
|
-
@param request:
|
|
2913
|
-
@return:
|
|
3228
|
+
@param request: GetScalingConfigRequest
|
|
3229
|
+
@return: GetScalingConfigResponse
|
|
2914
3230
|
"""
|
|
2915
3231
|
runtime = util_models.RuntimeOptions()
|
|
2916
3232
|
headers = {}
|
|
2917
|
-
return self.
|
|
3233
|
+
return self.get_scaling_config_with_options(function_name, request, headers, runtime)
|
|
2918
3234
|
|
|
2919
|
-
async def
|
|
3235
|
+
async def get_scaling_config_async(
|
|
2920
3236
|
self,
|
|
2921
3237
|
function_name: str,
|
|
2922
|
-
request: fc20230330_models.
|
|
2923
|
-
) -> fc20230330_models.
|
|
3238
|
+
request: fc20230330_models.GetScalingConfigRequest,
|
|
3239
|
+
) -> fc20230330_models.GetScalingConfigResponse:
|
|
2924
3240
|
"""
|
|
2925
|
-
@summary
|
|
3241
|
+
@summary 获取弹性配置
|
|
2926
3242
|
|
|
2927
|
-
@param request:
|
|
2928
|
-
@return:
|
|
3243
|
+
@param request: GetScalingConfigRequest
|
|
3244
|
+
@return: GetScalingConfigResponse
|
|
2929
3245
|
"""
|
|
2930
3246
|
runtime = util_models.RuntimeOptions()
|
|
2931
3247
|
headers = {}
|
|
2932
|
-
return await self.
|
|
3248
|
+
return await self.get_scaling_config_with_options_async(function_name, request, headers, runtime)
|
|
2933
3249
|
|
|
2934
3250
|
def get_trigger_with_options(
|
|
2935
3251
|
self,
|
|
@@ -2959,16 +3275,10 @@ class Client(OpenApiClient):
|
|
|
2959
3275
|
req_body_type='json',
|
|
2960
3276
|
body_type='json'
|
|
2961
3277
|
)
|
|
2962
|
-
|
|
2963
|
-
|
|
2964
|
-
|
|
2965
|
-
|
|
2966
|
-
)
|
|
2967
|
-
else:
|
|
2968
|
-
return TeaCore.from_map(
|
|
2969
|
-
fc20230330_models.GetTriggerResponse(),
|
|
2970
|
-
self.execute(params, req, runtime)
|
|
2971
|
-
)
|
|
3278
|
+
return TeaCore.from_map(
|
|
3279
|
+
fc20230330_models.GetTriggerResponse(),
|
|
3280
|
+
self.call_api(params, req, runtime)
|
|
3281
|
+
)
|
|
2972
3282
|
|
|
2973
3283
|
async def get_trigger_with_options_async(
|
|
2974
3284
|
self,
|
|
@@ -2998,16 +3308,10 @@ class Client(OpenApiClient):
|
|
|
2998
3308
|
req_body_type='json',
|
|
2999
3309
|
body_type='json'
|
|
3000
3310
|
)
|
|
3001
|
-
|
|
3002
|
-
|
|
3003
|
-
|
|
3004
|
-
|
|
3005
|
-
)
|
|
3006
|
-
else:
|
|
3007
|
-
return TeaCore.from_map(
|
|
3008
|
-
fc20230330_models.GetTriggerResponse(),
|
|
3009
|
-
await self.execute_async(params, req, runtime)
|
|
3010
|
-
)
|
|
3311
|
+
return TeaCore.from_map(
|
|
3312
|
+
fc20230330_models.GetTriggerResponse(),
|
|
3313
|
+
await self.call_api_async(params, req, runtime)
|
|
3314
|
+
)
|
|
3011
3315
|
|
|
3012
3316
|
def get_trigger(
|
|
3013
3317
|
self,
|
|
@@ -3221,16 +3525,10 @@ class Client(OpenApiClient):
|
|
|
3221
3525
|
req_body_type='json',
|
|
3222
3526
|
body_type='json'
|
|
3223
3527
|
)
|
|
3224
|
-
|
|
3225
|
-
|
|
3226
|
-
|
|
3227
|
-
|
|
3228
|
-
)
|
|
3229
|
-
else:
|
|
3230
|
-
return TeaCore.from_map(
|
|
3231
|
-
fc20230330_models.ListAliasesResponse(),
|
|
3232
|
-
self.execute(params, req, runtime)
|
|
3233
|
-
)
|
|
3528
|
+
return TeaCore.from_map(
|
|
3529
|
+
fc20230330_models.ListAliasesResponse(),
|
|
3530
|
+
self.call_api(params, req, runtime)
|
|
3531
|
+
)
|
|
3234
3532
|
|
|
3235
3533
|
async def list_aliases_with_options_async(
|
|
3236
3534
|
self,
|
|
@@ -3270,16 +3568,10 @@ class Client(OpenApiClient):
|
|
|
3270
3568
|
req_body_type='json',
|
|
3271
3569
|
body_type='json'
|
|
3272
3570
|
)
|
|
3273
|
-
|
|
3274
|
-
|
|
3275
|
-
|
|
3276
|
-
|
|
3277
|
-
)
|
|
3278
|
-
else:
|
|
3279
|
-
return TeaCore.from_map(
|
|
3280
|
-
fc20230330_models.ListAliasesResponse(),
|
|
3281
|
-
await self.execute_async(params, req, runtime)
|
|
3282
|
-
)
|
|
3571
|
+
return TeaCore.from_map(
|
|
3572
|
+
fc20230330_models.ListAliasesResponse(),
|
|
3573
|
+
await self.call_api_async(params, req, runtime)
|
|
3574
|
+
)
|
|
3283
3575
|
|
|
3284
3576
|
def list_aliases(
|
|
3285
3577
|
self,
|
|
@@ -3348,16 +3640,10 @@ class Client(OpenApiClient):
|
|
|
3348
3640
|
req_body_type='json',
|
|
3349
3641
|
body_type='json'
|
|
3350
3642
|
)
|
|
3351
|
-
|
|
3352
|
-
|
|
3353
|
-
|
|
3354
|
-
|
|
3355
|
-
)
|
|
3356
|
-
else:
|
|
3357
|
-
return TeaCore.from_map(
|
|
3358
|
-
fc20230330_models.ListAsyncInvokeConfigsResponse(),
|
|
3359
|
-
self.execute(params, req, runtime)
|
|
3360
|
-
)
|
|
3643
|
+
return TeaCore.from_map(
|
|
3644
|
+
fc20230330_models.ListAsyncInvokeConfigsResponse(),
|
|
3645
|
+
self.call_api(params, req, runtime)
|
|
3646
|
+
)
|
|
3361
3647
|
|
|
3362
3648
|
async def list_async_invoke_configs_with_options_async(
|
|
3363
3649
|
self,
|
|
@@ -3396,16 +3682,10 @@ class Client(OpenApiClient):
|
|
|
3396
3682
|
req_body_type='json',
|
|
3397
3683
|
body_type='json'
|
|
3398
3684
|
)
|
|
3399
|
-
|
|
3400
|
-
|
|
3401
|
-
|
|
3402
|
-
|
|
3403
|
-
)
|
|
3404
|
-
else:
|
|
3405
|
-
return TeaCore.from_map(
|
|
3406
|
-
fc20230330_models.ListAsyncInvokeConfigsResponse(),
|
|
3407
|
-
await self.execute_async(params, req, runtime)
|
|
3408
|
-
)
|
|
3685
|
+
return TeaCore.from_map(
|
|
3686
|
+
fc20230330_models.ListAsyncInvokeConfigsResponse(),
|
|
3687
|
+
await self.call_api_async(params, req, runtime)
|
|
3688
|
+
)
|
|
3409
3689
|
|
|
3410
3690
|
def list_async_invoke_configs(
|
|
3411
3691
|
self,
|
|
@@ -3485,16 +3765,10 @@ class Client(OpenApiClient):
|
|
|
3485
3765
|
req_body_type='json',
|
|
3486
3766
|
body_type='json'
|
|
3487
3767
|
)
|
|
3488
|
-
|
|
3489
|
-
|
|
3490
|
-
|
|
3491
|
-
|
|
3492
|
-
)
|
|
3493
|
-
else:
|
|
3494
|
-
return TeaCore.from_map(
|
|
3495
|
-
fc20230330_models.ListAsyncTasksResponse(),
|
|
3496
|
-
self.execute(params, req, runtime)
|
|
3497
|
-
)
|
|
3768
|
+
return TeaCore.from_map(
|
|
3769
|
+
fc20230330_models.ListAsyncTasksResponse(),
|
|
3770
|
+
self.call_api(params, req, runtime)
|
|
3771
|
+
)
|
|
3498
3772
|
|
|
3499
3773
|
async def list_async_tasks_with_options_async(
|
|
3500
3774
|
self,
|
|
@@ -3546,16 +3820,10 @@ class Client(OpenApiClient):
|
|
|
3546
3820
|
req_body_type='json',
|
|
3547
3821
|
body_type='json'
|
|
3548
3822
|
)
|
|
3549
|
-
|
|
3550
|
-
|
|
3551
|
-
|
|
3552
|
-
|
|
3553
|
-
)
|
|
3554
|
-
else:
|
|
3555
|
-
return TeaCore.from_map(
|
|
3556
|
-
fc20230330_models.ListAsyncTasksResponse(),
|
|
3557
|
-
await self.execute_async(params, req, runtime)
|
|
3558
|
-
)
|
|
3823
|
+
return TeaCore.from_map(
|
|
3824
|
+
fc20230330_models.ListAsyncTasksResponse(),
|
|
3825
|
+
await self.call_api_async(params, req, runtime)
|
|
3826
|
+
)
|
|
3559
3827
|
|
|
3560
3828
|
def list_async_tasks(
|
|
3561
3829
|
self,
|
|
@@ -3624,16 +3892,10 @@ class Client(OpenApiClient):
|
|
|
3624
3892
|
req_body_type='json',
|
|
3625
3893
|
body_type='json'
|
|
3626
3894
|
)
|
|
3627
|
-
|
|
3628
|
-
|
|
3629
|
-
|
|
3630
|
-
|
|
3631
|
-
)
|
|
3632
|
-
else:
|
|
3633
|
-
return TeaCore.from_map(
|
|
3634
|
-
fc20230330_models.ListConcurrencyConfigsResponse(),
|
|
3635
|
-
self.execute(params, req, runtime)
|
|
3636
|
-
)
|
|
3895
|
+
return TeaCore.from_map(
|
|
3896
|
+
fc20230330_models.ListConcurrencyConfigsResponse(),
|
|
3897
|
+
self.call_api(params, req, runtime)
|
|
3898
|
+
)
|
|
3637
3899
|
|
|
3638
3900
|
async def list_concurrency_configs_with_options_async(
|
|
3639
3901
|
self,
|
|
@@ -3672,16 +3934,10 @@ class Client(OpenApiClient):
|
|
|
3672
3934
|
req_body_type='json',
|
|
3673
3935
|
body_type='json'
|
|
3674
3936
|
)
|
|
3675
|
-
|
|
3676
|
-
|
|
3677
|
-
|
|
3678
|
-
|
|
3679
|
-
)
|
|
3680
|
-
else:
|
|
3681
|
-
return TeaCore.from_map(
|
|
3682
|
-
fc20230330_models.ListConcurrencyConfigsResponse(),
|
|
3683
|
-
await self.execute_async(params, req, runtime)
|
|
3684
|
-
)
|
|
3937
|
+
return TeaCore.from_map(
|
|
3938
|
+
fc20230330_models.ListConcurrencyConfigsResponse(),
|
|
3939
|
+
await self.call_api_async(params, req, runtime)
|
|
3940
|
+
)
|
|
3685
3941
|
|
|
3686
3942
|
def list_concurrency_configs(
|
|
3687
3943
|
self,
|
|
@@ -3748,16 +4004,10 @@ class Client(OpenApiClient):
|
|
|
3748
4004
|
req_body_type='json',
|
|
3749
4005
|
body_type='json'
|
|
3750
4006
|
)
|
|
3751
|
-
|
|
3752
|
-
|
|
3753
|
-
|
|
3754
|
-
|
|
3755
|
-
)
|
|
3756
|
-
else:
|
|
3757
|
-
return TeaCore.from_map(
|
|
3758
|
-
fc20230330_models.ListCustomDomainsResponse(),
|
|
3759
|
-
self.execute(params, req, runtime)
|
|
3760
|
-
)
|
|
4007
|
+
return TeaCore.from_map(
|
|
4008
|
+
fc20230330_models.ListCustomDomainsResponse(),
|
|
4009
|
+
self.call_api(params, req, runtime)
|
|
4010
|
+
)
|
|
3761
4011
|
|
|
3762
4012
|
async def list_custom_domains_with_options_async(
|
|
3763
4013
|
self,
|
|
@@ -3796,16 +4046,10 @@ class Client(OpenApiClient):
|
|
|
3796
4046
|
req_body_type='json',
|
|
3797
4047
|
body_type='json'
|
|
3798
4048
|
)
|
|
3799
|
-
|
|
3800
|
-
|
|
3801
|
-
|
|
3802
|
-
|
|
3803
|
-
)
|
|
3804
|
-
else:
|
|
3805
|
-
return TeaCore.from_map(
|
|
3806
|
-
fc20230330_models.ListCustomDomainsResponse(),
|
|
3807
|
-
await self.execute_async(params, req, runtime)
|
|
3808
|
-
)
|
|
4049
|
+
return TeaCore.from_map(
|
|
4050
|
+
fc20230330_models.ListCustomDomainsResponse(),
|
|
4051
|
+
await self.call_api_async(params, req, runtime)
|
|
4052
|
+
)
|
|
3809
4053
|
|
|
3810
4054
|
def list_custom_domains(
|
|
3811
4055
|
self,
|
|
@@ -3873,16 +4117,10 @@ class Client(OpenApiClient):
|
|
|
3873
4117
|
req_body_type='json',
|
|
3874
4118
|
body_type='json'
|
|
3875
4119
|
)
|
|
3876
|
-
|
|
3877
|
-
|
|
3878
|
-
|
|
3879
|
-
|
|
3880
|
-
)
|
|
3881
|
-
else:
|
|
3882
|
-
return TeaCore.from_map(
|
|
3883
|
-
fc20230330_models.ListFunctionVersionsResponse(),
|
|
3884
|
-
self.execute(params, req, runtime)
|
|
3885
|
-
)
|
|
4120
|
+
return TeaCore.from_map(
|
|
4121
|
+
fc20230330_models.ListFunctionVersionsResponse(),
|
|
4122
|
+
self.call_api(params, req, runtime)
|
|
4123
|
+
)
|
|
3886
4124
|
|
|
3887
4125
|
async def list_function_versions_with_options_async(
|
|
3888
4126
|
self,
|
|
@@ -3922,16 +4160,10 @@ class Client(OpenApiClient):
|
|
|
3922
4160
|
req_body_type='json',
|
|
3923
4161
|
body_type='json'
|
|
3924
4162
|
)
|
|
3925
|
-
|
|
3926
|
-
|
|
3927
|
-
|
|
3928
|
-
|
|
3929
|
-
)
|
|
3930
|
-
else:
|
|
3931
|
-
return TeaCore.from_map(
|
|
3932
|
-
fc20230330_models.ListFunctionVersionsResponse(),
|
|
3933
|
-
await self.execute_async(params, req, runtime)
|
|
3934
|
-
)
|
|
4163
|
+
return TeaCore.from_map(
|
|
4164
|
+
fc20230330_models.ListFunctionVersionsResponse(),
|
|
4165
|
+
await self.call_api_async(params, req, runtime)
|
|
4166
|
+
)
|
|
3935
4167
|
|
|
3936
4168
|
def list_function_versions(
|
|
3937
4169
|
self,
|
|
@@ -3965,28 +4197,46 @@ class Client(OpenApiClient):
|
|
|
3965
4197
|
|
|
3966
4198
|
def list_functions_with_options(
|
|
3967
4199
|
self,
|
|
3968
|
-
|
|
4200
|
+
tmp_req: fc20230330_models.ListFunctionsRequest,
|
|
3969
4201
|
headers: Dict[str, str],
|
|
3970
4202
|
runtime: util_models.RuntimeOptions,
|
|
3971
4203
|
) -> fc20230330_models.ListFunctionsResponse:
|
|
3972
4204
|
"""
|
|
3973
4205
|
@summary 列出函数。
|
|
3974
4206
|
|
|
3975
|
-
@
|
|
4207
|
+
@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).
|
|
4208
|
+
|
|
4209
|
+
@param tmp_req: ListFunctionsRequest
|
|
3976
4210
|
@param headers: map
|
|
3977
4211
|
@param runtime: runtime options for this request RuntimeOptions
|
|
3978
4212
|
@return: ListFunctionsResponse
|
|
3979
4213
|
"""
|
|
3980
|
-
UtilClient.validate_model(
|
|
4214
|
+
UtilClient.validate_model(tmp_req)
|
|
4215
|
+
request = fc20230330_models.ListFunctionsShrinkRequest()
|
|
4216
|
+
OpenApiUtilClient.convert(tmp_req, request)
|
|
4217
|
+
if not UtilClient.is_unset(tmp_req.tags):
|
|
4218
|
+
request.tags_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.tags, 'tags', 'json')
|
|
3981
4219
|
query = {}
|
|
4220
|
+
if not UtilClient.is_unset(request.description):
|
|
4221
|
+
query['description'] = request.description
|
|
3982
4222
|
if not UtilClient.is_unset(request.fc_version):
|
|
3983
4223
|
query['fcVersion'] = request.fc_version
|
|
4224
|
+
if not UtilClient.is_unset(request.function_name):
|
|
4225
|
+
query['functionName'] = request.function_name
|
|
4226
|
+
if not UtilClient.is_unset(request.gpu_type):
|
|
4227
|
+
query['gpuType'] = request.gpu_type
|
|
3984
4228
|
if not UtilClient.is_unset(request.limit):
|
|
3985
4229
|
query['limit'] = request.limit
|
|
3986
4230
|
if not UtilClient.is_unset(request.next_token):
|
|
3987
4231
|
query['nextToken'] = request.next_token
|
|
3988
4232
|
if not UtilClient.is_unset(request.prefix):
|
|
3989
4233
|
query['prefix'] = request.prefix
|
|
4234
|
+
if not UtilClient.is_unset(request.resource_group_id):
|
|
4235
|
+
query['resourceGroupId'] = request.resource_group_id
|
|
4236
|
+
if not UtilClient.is_unset(request.runtime):
|
|
4237
|
+
query['runtime'] = request.runtime
|
|
4238
|
+
if not UtilClient.is_unset(request.tags_shrink):
|
|
4239
|
+
query['tags'] = request.tags_shrink
|
|
3990
4240
|
req = open_api_models.OpenApiRequest(
|
|
3991
4241
|
headers=headers,
|
|
3992
4242
|
query=OpenApiUtilClient.query(query)
|
|
@@ -4002,41 +4252,53 @@ class Client(OpenApiClient):
|
|
|
4002
4252
|
req_body_type='json',
|
|
4003
4253
|
body_type='json'
|
|
4004
4254
|
)
|
|
4005
|
-
|
|
4006
|
-
|
|
4007
|
-
|
|
4008
|
-
|
|
4009
|
-
)
|
|
4010
|
-
else:
|
|
4011
|
-
return TeaCore.from_map(
|
|
4012
|
-
fc20230330_models.ListFunctionsResponse(),
|
|
4013
|
-
self.execute(params, req, runtime)
|
|
4014
|
-
)
|
|
4255
|
+
return TeaCore.from_map(
|
|
4256
|
+
fc20230330_models.ListFunctionsResponse(),
|
|
4257
|
+
self.call_api(params, req, runtime)
|
|
4258
|
+
)
|
|
4015
4259
|
|
|
4016
4260
|
async def list_functions_with_options_async(
|
|
4017
4261
|
self,
|
|
4018
|
-
|
|
4262
|
+
tmp_req: fc20230330_models.ListFunctionsRequest,
|
|
4019
4263
|
headers: Dict[str, str],
|
|
4020
4264
|
runtime: util_models.RuntimeOptions,
|
|
4021
4265
|
) -> fc20230330_models.ListFunctionsResponse:
|
|
4022
4266
|
"""
|
|
4023
4267
|
@summary 列出函数。
|
|
4024
4268
|
|
|
4025
|
-
@
|
|
4269
|
+
@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).
|
|
4270
|
+
|
|
4271
|
+
@param tmp_req: ListFunctionsRequest
|
|
4026
4272
|
@param headers: map
|
|
4027
4273
|
@param runtime: runtime options for this request RuntimeOptions
|
|
4028
4274
|
@return: ListFunctionsResponse
|
|
4029
4275
|
"""
|
|
4030
|
-
UtilClient.validate_model(
|
|
4276
|
+
UtilClient.validate_model(tmp_req)
|
|
4277
|
+
request = fc20230330_models.ListFunctionsShrinkRequest()
|
|
4278
|
+
OpenApiUtilClient.convert(tmp_req, request)
|
|
4279
|
+
if not UtilClient.is_unset(tmp_req.tags):
|
|
4280
|
+
request.tags_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.tags, 'tags', 'json')
|
|
4031
4281
|
query = {}
|
|
4282
|
+
if not UtilClient.is_unset(request.description):
|
|
4283
|
+
query['description'] = request.description
|
|
4032
4284
|
if not UtilClient.is_unset(request.fc_version):
|
|
4033
4285
|
query['fcVersion'] = request.fc_version
|
|
4286
|
+
if not UtilClient.is_unset(request.function_name):
|
|
4287
|
+
query['functionName'] = request.function_name
|
|
4288
|
+
if not UtilClient.is_unset(request.gpu_type):
|
|
4289
|
+
query['gpuType'] = request.gpu_type
|
|
4034
4290
|
if not UtilClient.is_unset(request.limit):
|
|
4035
4291
|
query['limit'] = request.limit
|
|
4036
4292
|
if not UtilClient.is_unset(request.next_token):
|
|
4037
4293
|
query['nextToken'] = request.next_token
|
|
4038
4294
|
if not UtilClient.is_unset(request.prefix):
|
|
4039
4295
|
query['prefix'] = request.prefix
|
|
4296
|
+
if not UtilClient.is_unset(request.resource_group_id):
|
|
4297
|
+
query['resourceGroupId'] = request.resource_group_id
|
|
4298
|
+
if not UtilClient.is_unset(request.runtime):
|
|
4299
|
+
query['runtime'] = request.runtime
|
|
4300
|
+
if not UtilClient.is_unset(request.tags_shrink):
|
|
4301
|
+
query['tags'] = request.tags_shrink
|
|
4040
4302
|
req = open_api_models.OpenApiRequest(
|
|
4041
4303
|
headers=headers,
|
|
4042
4304
|
query=OpenApiUtilClient.query(query)
|
|
@@ -4052,16 +4314,10 @@ class Client(OpenApiClient):
|
|
|
4052
4314
|
req_body_type='json',
|
|
4053
4315
|
body_type='json'
|
|
4054
4316
|
)
|
|
4055
|
-
|
|
4056
|
-
|
|
4057
|
-
|
|
4058
|
-
|
|
4059
|
-
)
|
|
4060
|
-
else:
|
|
4061
|
-
return TeaCore.from_map(
|
|
4062
|
-
fc20230330_models.ListFunctionsResponse(),
|
|
4063
|
-
await self.execute_async(params, req, runtime)
|
|
4064
|
-
)
|
|
4317
|
+
return TeaCore.from_map(
|
|
4318
|
+
fc20230330_models.ListFunctionsResponse(),
|
|
4319
|
+
await self.call_api_async(params, req, runtime)
|
|
4320
|
+
)
|
|
4065
4321
|
|
|
4066
4322
|
def list_functions(
|
|
4067
4323
|
self,
|
|
@@ -4070,6 +4326,8 @@ class Client(OpenApiClient):
|
|
|
4070
4326
|
"""
|
|
4071
4327
|
@summary 列出函数。
|
|
4072
4328
|
|
|
4329
|
+
@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).
|
|
4330
|
+
|
|
4073
4331
|
@param request: ListFunctionsRequest
|
|
4074
4332
|
@return: ListFunctionsResponse
|
|
4075
4333
|
"""
|
|
@@ -4084,6 +4342,8 @@ class Client(OpenApiClient):
|
|
|
4084
4342
|
"""
|
|
4085
4343
|
@summary 列出函数。
|
|
4086
4344
|
|
|
4345
|
+
@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).
|
|
4346
|
+
|
|
4087
4347
|
@param request: ListFunctionsRequest
|
|
4088
4348
|
@return: ListFunctionsResponse
|
|
4089
4349
|
"""
|
|
@@ -4145,16 +4405,10 @@ class Client(OpenApiClient):
|
|
|
4145
4405
|
req_body_type='json',
|
|
4146
4406
|
body_type='json'
|
|
4147
4407
|
)
|
|
4148
|
-
|
|
4149
|
-
|
|
4150
|
-
|
|
4151
|
-
|
|
4152
|
-
)
|
|
4153
|
-
else:
|
|
4154
|
-
return TeaCore.from_map(
|
|
4155
|
-
fc20230330_models.ListInstancesResponse(),
|
|
4156
|
-
self.execute(params, req, runtime)
|
|
4157
|
-
)
|
|
4408
|
+
return TeaCore.from_map(
|
|
4409
|
+
fc20230330_models.ListInstancesResponse(),
|
|
4410
|
+
self.call_api(params, req, runtime)
|
|
4411
|
+
)
|
|
4158
4412
|
|
|
4159
4413
|
async def list_instances_with_options_async(
|
|
4160
4414
|
self,
|
|
@@ -4210,16 +4464,10 @@ class Client(OpenApiClient):
|
|
|
4210
4464
|
req_body_type='json',
|
|
4211
4465
|
body_type='json'
|
|
4212
4466
|
)
|
|
4213
|
-
|
|
4214
|
-
|
|
4215
|
-
|
|
4216
|
-
|
|
4217
|
-
)
|
|
4218
|
-
else:
|
|
4219
|
-
return TeaCore.from_map(
|
|
4220
|
-
fc20230330_models.ListInstancesResponse(),
|
|
4221
|
-
await self.execute_async(params, req, runtime)
|
|
4222
|
-
)
|
|
4467
|
+
return TeaCore.from_map(
|
|
4468
|
+
fc20230330_models.ListInstancesResponse(),
|
|
4469
|
+
await self.call_api_async(params, req, runtime)
|
|
4470
|
+
)
|
|
4223
4471
|
|
|
4224
4472
|
def list_instances(
|
|
4225
4473
|
self,
|
|
@@ -4287,16 +4535,10 @@ class Client(OpenApiClient):
|
|
|
4287
4535
|
req_body_type='json',
|
|
4288
4536
|
body_type='json'
|
|
4289
4537
|
)
|
|
4290
|
-
|
|
4291
|
-
|
|
4292
|
-
|
|
4293
|
-
|
|
4294
|
-
)
|
|
4295
|
-
else:
|
|
4296
|
-
return TeaCore.from_map(
|
|
4297
|
-
fc20230330_models.ListLayerVersionsResponse(),
|
|
4298
|
-
self.execute(params, req, runtime)
|
|
4299
|
-
)
|
|
4538
|
+
return TeaCore.from_map(
|
|
4539
|
+
fc20230330_models.ListLayerVersionsResponse(),
|
|
4540
|
+
self.call_api(params, req, runtime)
|
|
4541
|
+
)
|
|
4300
4542
|
|
|
4301
4543
|
async def list_layer_versions_with_options_async(
|
|
4302
4544
|
self,
|
|
@@ -4334,16 +4576,10 @@ class Client(OpenApiClient):
|
|
|
4334
4576
|
req_body_type='json',
|
|
4335
4577
|
body_type='json'
|
|
4336
4578
|
)
|
|
4337
|
-
|
|
4338
|
-
|
|
4339
|
-
|
|
4340
|
-
|
|
4341
|
-
)
|
|
4342
|
-
else:
|
|
4343
|
-
return TeaCore.from_map(
|
|
4344
|
-
fc20230330_models.ListLayerVersionsResponse(),
|
|
4345
|
-
await self.execute_async(params, req, runtime)
|
|
4346
|
-
)
|
|
4579
|
+
return TeaCore.from_map(
|
|
4580
|
+
fc20230330_models.ListLayerVersionsResponse(),
|
|
4581
|
+
await self.call_api_async(params, req, runtime)
|
|
4582
|
+
)
|
|
4347
4583
|
|
|
4348
4584
|
def list_layer_versions(
|
|
4349
4585
|
self,
|
|
@@ -4416,16 +4652,10 @@ class Client(OpenApiClient):
|
|
|
4416
4652
|
req_body_type='json',
|
|
4417
4653
|
body_type='json'
|
|
4418
4654
|
)
|
|
4419
|
-
|
|
4420
|
-
|
|
4421
|
-
|
|
4422
|
-
|
|
4423
|
-
)
|
|
4424
|
-
else:
|
|
4425
|
-
return TeaCore.from_map(
|
|
4426
|
-
fc20230330_models.ListLayersResponse(),
|
|
4427
|
-
self.execute(params, req, runtime)
|
|
4428
|
-
)
|
|
4655
|
+
return TeaCore.from_map(
|
|
4656
|
+
fc20230330_models.ListLayersResponse(),
|
|
4657
|
+
self.call_api(params, req, runtime)
|
|
4658
|
+
)
|
|
4429
4659
|
|
|
4430
4660
|
async def list_layers_with_options_async(
|
|
4431
4661
|
self,
|
|
@@ -4468,16 +4698,10 @@ class Client(OpenApiClient):
|
|
|
4468
4698
|
req_body_type='json',
|
|
4469
4699
|
body_type='json'
|
|
4470
4700
|
)
|
|
4471
|
-
|
|
4472
|
-
|
|
4473
|
-
|
|
4474
|
-
|
|
4475
|
-
)
|
|
4476
|
-
else:
|
|
4477
|
-
return TeaCore.from_map(
|
|
4478
|
-
fc20230330_models.ListLayersResponse(),
|
|
4479
|
-
await self.execute_async(params, req, runtime)
|
|
4480
|
-
)
|
|
4701
|
+
return TeaCore.from_map(
|
|
4702
|
+
fc20230330_models.ListLayersResponse(),
|
|
4703
|
+
await self.call_api_async(params, req, runtime)
|
|
4704
|
+
)
|
|
4481
4705
|
|
|
4482
4706
|
def list_layers(
|
|
4483
4707
|
self,
|
|
@@ -4544,16 +4768,10 @@ class Client(OpenApiClient):
|
|
|
4544
4768
|
req_body_type='json',
|
|
4545
4769
|
body_type='json'
|
|
4546
4770
|
)
|
|
4547
|
-
|
|
4548
|
-
|
|
4549
|
-
|
|
4550
|
-
|
|
4551
|
-
)
|
|
4552
|
-
else:
|
|
4553
|
-
return TeaCore.from_map(
|
|
4554
|
-
fc20230330_models.ListProvisionConfigsResponse(),
|
|
4555
|
-
self.execute(params, req, runtime)
|
|
4556
|
-
)
|
|
4771
|
+
return TeaCore.from_map(
|
|
4772
|
+
fc20230330_models.ListProvisionConfigsResponse(),
|
|
4773
|
+
self.call_api(params, req, runtime)
|
|
4774
|
+
)
|
|
4557
4775
|
|
|
4558
4776
|
async def list_provision_configs_with_options_async(
|
|
4559
4777
|
self,
|
|
@@ -4592,16 +4810,10 @@ class Client(OpenApiClient):
|
|
|
4592
4810
|
req_body_type='json',
|
|
4593
4811
|
body_type='json'
|
|
4594
4812
|
)
|
|
4595
|
-
|
|
4596
|
-
|
|
4597
|
-
|
|
4598
|
-
|
|
4599
|
-
)
|
|
4600
|
-
else:
|
|
4601
|
-
return TeaCore.from_map(
|
|
4602
|
-
fc20230330_models.ListProvisionConfigsResponse(),
|
|
4603
|
-
await self.execute_async(params, req, runtime)
|
|
4604
|
-
)
|
|
4813
|
+
return TeaCore.from_map(
|
|
4814
|
+
fc20230330_models.ListProvisionConfigsResponse(),
|
|
4815
|
+
await self.call_api_async(params, req, runtime)
|
|
4816
|
+
)
|
|
4605
4817
|
|
|
4606
4818
|
def list_provision_configs(
|
|
4607
4819
|
self,
|
|
@@ -4631,6 +4843,118 @@ class Client(OpenApiClient):
|
|
|
4631
4843
|
headers = {}
|
|
4632
4844
|
return await self.list_provision_configs_with_options_async(request, headers, runtime)
|
|
4633
4845
|
|
|
4846
|
+
def list_scaling_configs_with_options(
|
|
4847
|
+
self,
|
|
4848
|
+
request: fc20230330_models.ListScalingConfigsRequest,
|
|
4849
|
+
headers: Dict[str, str],
|
|
4850
|
+
runtime: util_models.RuntimeOptions,
|
|
4851
|
+
) -> fc20230330_models.ListScalingConfigsResponse:
|
|
4852
|
+
"""
|
|
4853
|
+
@summary 获取弹性配置列表
|
|
4854
|
+
|
|
4855
|
+
@param request: ListScalingConfigsRequest
|
|
4856
|
+
@param headers: map
|
|
4857
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
4858
|
+
@return: ListScalingConfigsResponse
|
|
4859
|
+
"""
|
|
4860
|
+
UtilClient.validate_model(request)
|
|
4861
|
+
query = {}
|
|
4862
|
+
if not UtilClient.is_unset(request.function_name):
|
|
4863
|
+
query['functionName'] = request.function_name
|
|
4864
|
+
if not UtilClient.is_unset(request.limit):
|
|
4865
|
+
query['limit'] = request.limit
|
|
4866
|
+
if not UtilClient.is_unset(request.next_token):
|
|
4867
|
+
query['nextToken'] = request.next_token
|
|
4868
|
+
req = open_api_models.OpenApiRequest(
|
|
4869
|
+
headers=headers,
|
|
4870
|
+
query=OpenApiUtilClient.query(query)
|
|
4871
|
+
)
|
|
4872
|
+
params = open_api_models.Params(
|
|
4873
|
+
action='ListScalingConfigs',
|
|
4874
|
+
version='2023-03-30',
|
|
4875
|
+
protocol='HTTPS',
|
|
4876
|
+
pathname=f'/2023-03-30/scaling-configs',
|
|
4877
|
+
method='GET',
|
|
4878
|
+
auth_type='AK',
|
|
4879
|
+
style='ROA',
|
|
4880
|
+
req_body_type='json',
|
|
4881
|
+
body_type='json'
|
|
4882
|
+
)
|
|
4883
|
+
return TeaCore.from_map(
|
|
4884
|
+
fc20230330_models.ListScalingConfigsResponse(),
|
|
4885
|
+
self.call_api(params, req, runtime)
|
|
4886
|
+
)
|
|
4887
|
+
|
|
4888
|
+
async def list_scaling_configs_with_options_async(
|
|
4889
|
+
self,
|
|
4890
|
+
request: fc20230330_models.ListScalingConfigsRequest,
|
|
4891
|
+
headers: Dict[str, str],
|
|
4892
|
+
runtime: util_models.RuntimeOptions,
|
|
4893
|
+
) -> fc20230330_models.ListScalingConfigsResponse:
|
|
4894
|
+
"""
|
|
4895
|
+
@summary 获取弹性配置列表
|
|
4896
|
+
|
|
4897
|
+
@param request: ListScalingConfigsRequest
|
|
4898
|
+
@param headers: map
|
|
4899
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
4900
|
+
@return: ListScalingConfigsResponse
|
|
4901
|
+
"""
|
|
4902
|
+
UtilClient.validate_model(request)
|
|
4903
|
+
query = {}
|
|
4904
|
+
if not UtilClient.is_unset(request.function_name):
|
|
4905
|
+
query['functionName'] = request.function_name
|
|
4906
|
+
if not UtilClient.is_unset(request.limit):
|
|
4907
|
+
query['limit'] = request.limit
|
|
4908
|
+
if not UtilClient.is_unset(request.next_token):
|
|
4909
|
+
query['nextToken'] = request.next_token
|
|
4910
|
+
req = open_api_models.OpenApiRequest(
|
|
4911
|
+
headers=headers,
|
|
4912
|
+
query=OpenApiUtilClient.query(query)
|
|
4913
|
+
)
|
|
4914
|
+
params = open_api_models.Params(
|
|
4915
|
+
action='ListScalingConfigs',
|
|
4916
|
+
version='2023-03-30',
|
|
4917
|
+
protocol='HTTPS',
|
|
4918
|
+
pathname=f'/2023-03-30/scaling-configs',
|
|
4919
|
+
method='GET',
|
|
4920
|
+
auth_type='AK',
|
|
4921
|
+
style='ROA',
|
|
4922
|
+
req_body_type='json',
|
|
4923
|
+
body_type='json'
|
|
4924
|
+
)
|
|
4925
|
+
return TeaCore.from_map(
|
|
4926
|
+
fc20230330_models.ListScalingConfigsResponse(),
|
|
4927
|
+
await self.call_api_async(params, req, runtime)
|
|
4928
|
+
)
|
|
4929
|
+
|
|
4930
|
+
def list_scaling_configs(
|
|
4931
|
+
self,
|
|
4932
|
+
request: fc20230330_models.ListScalingConfigsRequest,
|
|
4933
|
+
) -> fc20230330_models.ListScalingConfigsResponse:
|
|
4934
|
+
"""
|
|
4935
|
+
@summary 获取弹性配置列表
|
|
4936
|
+
|
|
4937
|
+
@param request: ListScalingConfigsRequest
|
|
4938
|
+
@return: ListScalingConfigsResponse
|
|
4939
|
+
"""
|
|
4940
|
+
runtime = util_models.RuntimeOptions()
|
|
4941
|
+
headers = {}
|
|
4942
|
+
return self.list_scaling_configs_with_options(request, headers, runtime)
|
|
4943
|
+
|
|
4944
|
+
async def list_scaling_configs_async(
|
|
4945
|
+
self,
|
|
4946
|
+
request: fc20230330_models.ListScalingConfigsRequest,
|
|
4947
|
+
) -> fc20230330_models.ListScalingConfigsResponse:
|
|
4948
|
+
"""
|
|
4949
|
+
@summary 获取弹性配置列表
|
|
4950
|
+
|
|
4951
|
+
@param request: ListScalingConfigsRequest
|
|
4952
|
+
@return: ListScalingConfigsResponse
|
|
4953
|
+
"""
|
|
4954
|
+
runtime = util_models.RuntimeOptions()
|
|
4955
|
+
headers = {}
|
|
4956
|
+
return await self.list_scaling_configs_with_options_async(request, headers, runtime)
|
|
4957
|
+
|
|
4634
4958
|
def list_tag_resources_with_options(
|
|
4635
4959
|
self,
|
|
4636
4960
|
tmp_req: fc20230330_models.ListTagResourcesRequest,
|
|
@@ -4678,16 +5002,10 @@ class Client(OpenApiClient):
|
|
|
4678
5002
|
req_body_type='json',
|
|
4679
5003
|
body_type='json'
|
|
4680
5004
|
)
|
|
4681
|
-
|
|
4682
|
-
|
|
4683
|
-
|
|
4684
|
-
|
|
4685
|
-
)
|
|
4686
|
-
else:
|
|
4687
|
-
return TeaCore.from_map(
|
|
4688
|
-
fc20230330_models.ListTagResourcesResponse(),
|
|
4689
|
-
self.execute(params, req, runtime)
|
|
4690
|
-
)
|
|
5005
|
+
return TeaCore.from_map(
|
|
5006
|
+
fc20230330_models.ListTagResourcesResponse(),
|
|
5007
|
+
self.call_api(params, req, runtime)
|
|
5008
|
+
)
|
|
4691
5009
|
|
|
4692
5010
|
async def list_tag_resources_with_options_async(
|
|
4693
5011
|
self,
|
|
@@ -4736,16 +5054,10 @@ class Client(OpenApiClient):
|
|
|
4736
5054
|
req_body_type='json',
|
|
4737
5055
|
body_type='json'
|
|
4738
5056
|
)
|
|
4739
|
-
|
|
4740
|
-
|
|
4741
|
-
|
|
4742
|
-
|
|
4743
|
-
)
|
|
4744
|
-
else:
|
|
4745
|
-
return TeaCore.from_map(
|
|
4746
|
-
fc20230330_models.ListTagResourcesResponse(),
|
|
4747
|
-
await self.execute_async(params, req, runtime)
|
|
4748
|
-
)
|
|
5057
|
+
return TeaCore.from_map(
|
|
5058
|
+
fc20230330_models.ListTagResourcesResponse(),
|
|
5059
|
+
await self.call_api_async(params, req, runtime)
|
|
5060
|
+
)
|
|
4749
5061
|
|
|
4750
5062
|
def list_tag_resources(
|
|
4751
5063
|
self,
|
|
@@ -4813,16 +5125,10 @@ class Client(OpenApiClient):
|
|
|
4813
5125
|
req_body_type='json',
|
|
4814
5126
|
body_type='json'
|
|
4815
5127
|
)
|
|
4816
|
-
|
|
4817
|
-
|
|
4818
|
-
|
|
4819
|
-
|
|
4820
|
-
)
|
|
4821
|
-
else:
|
|
4822
|
-
return TeaCore.from_map(
|
|
4823
|
-
fc20230330_models.ListTriggersResponse(),
|
|
4824
|
-
self.execute(params, req, runtime)
|
|
4825
|
-
)
|
|
5128
|
+
return TeaCore.from_map(
|
|
5129
|
+
fc20230330_models.ListTriggersResponse(),
|
|
5130
|
+
self.call_api(params, req, runtime)
|
|
5131
|
+
)
|
|
4826
5132
|
|
|
4827
5133
|
async def list_triggers_with_options_async(
|
|
4828
5134
|
self,
|
|
@@ -4862,16 +5168,10 @@ class Client(OpenApiClient):
|
|
|
4862
5168
|
req_body_type='json',
|
|
4863
5169
|
body_type='json'
|
|
4864
5170
|
)
|
|
4865
|
-
|
|
4866
|
-
|
|
4867
|
-
|
|
4868
|
-
|
|
4869
|
-
)
|
|
4870
|
-
else:
|
|
4871
|
-
return TeaCore.from_map(
|
|
4872
|
-
fc20230330_models.ListTriggersResponse(),
|
|
4873
|
-
await self.execute_async(params, req, runtime)
|
|
4874
|
-
)
|
|
5171
|
+
return TeaCore.from_map(
|
|
5172
|
+
fc20230330_models.ListTriggersResponse(),
|
|
5173
|
+
await self.call_api_async(params, req, runtime)
|
|
5174
|
+
)
|
|
4875
5175
|
|
|
4876
5176
|
def list_triggers(
|
|
4877
5177
|
self,
|
|
@@ -4930,16 +5230,10 @@ class Client(OpenApiClient):
|
|
|
4930
5230
|
req_body_type='json',
|
|
4931
5231
|
body_type='json'
|
|
4932
5232
|
)
|
|
4933
|
-
|
|
4934
|
-
|
|
4935
|
-
|
|
4936
|
-
|
|
4937
|
-
)
|
|
4938
|
-
else:
|
|
4939
|
-
return TeaCore.from_map(
|
|
4940
|
-
fc20230330_models.ListVpcBindingsResponse(),
|
|
4941
|
-
self.execute(params, req, runtime)
|
|
4942
|
-
)
|
|
5233
|
+
return TeaCore.from_map(
|
|
5234
|
+
fc20230330_models.ListVpcBindingsResponse(),
|
|
5235
|
+
self.call_api(params, req, runtime)
|
|
5236
|
+
)
|
|
4943
5237
|
|
|
4944
5238
|
async def list_vpc_bindings_with_options_async(
|
|
4945
5239
|
self,
|
|
@@ -4968,16 +5262,10 @@ class Client(OpenApiClient):
|
|
|
4968
5262
|
req_body_type='json',
|
|
4969
5263
|
body_type='json'
|
|
4970
5264
|
)
|
|
4971
|
-
|
|
4972
|
-
|
|
4973
|
-
|
|
4974
|
-
|
|
4975
|
-
)
|
|
4976
|
-
else:
|
|
4977
|
-
return TeaCore.from_map(
|
|
4978
|
-
fc20230330_models.ListVpcBindingsResponse(),
|
|
4979
|
-
await self.execute_async(params, req, runtime)
|
|
4980
|
-
)
|
|
5265
|
+
return TeaCore.from_map(
|
|
5266
|
+
fc20230330_models.ListVpcBindingsResponse(),
|
|
5267
|
+
await self.call_api_async(params, req, runtime)
|
|
5268
|
+
)
|
|
4981
5269
|
|
|
4982
5270
|
def list_vpc_bindings(
|
|
4983
5271
|
self,
|
|
@@ -5036,16 +5324,10 @@ class Client(OpenApiClient):
|
|
|
5036
5324
|
req_body_type='json',
|
|
5037
5325
|
body_type='json'
|
|
5038
5326
|
)
|
|
5039
|
-
|
|
5040
|
-
|
|
5041
|
-
|
|
5042
|
-
|
|
5043
|
-
)
|
|
5044
|
-
else:
|
|
5045
|
-
return TeaCore.from_map(
|
|
5046
|
-
fc20230330_models.PublishFunctionVersionResponse(),
|
|
5047
|
-
self.execute(params, req, runtime)
|
|
5048
|
-
)
|
|
5327
|
+
return TeaCore.from_map(
|
|
5328
|
+
fc20230330_models.PublishFunctionVersionResponse(),
|
|
5329
|
+
self.call_api(params, req, runtime)
|
|
5330
|
+
)
|
|
5049
5331
|
|
|
5050
5332
|
async def publish_function_version_with_options_async(
|
|
5051
5333
|
self,
|
|
@@ -5078,16 +5360,10 @@ class Client(OpenApiClient):
|
|
|
5078
5360
|
req_body_type='json',
|
|
5079
5361
|
body_type='json'
|
|
5080
5362
|
)
|
|
5081
|
-
|
|
5082
|
-
|
|
5083
|
-
|
|
5084
|
-
|
|
5085
|
-
)
|
|
5086
|
-
else:
|
|
5087
|
-
return TeaCore.from_map(
|
|
5088
|
-
fc20230330_models.PublishFunctionVersionResponse(),
|
|
5089
|
-
await self.execute_async(params, req, runtime)
|
|
5090
|
-
)
|
|
5363
|
+
return TeaCore.from_map(
|
|
5364
|
+
fc20230330_models.PublishFunctionVersionResponse(),
|
|
5365
|
+
await self.call_api_async(params, req, runtime)
|
|
5366
|
+
)
|
|
5091
5367
|
|
|
5092
5368
|
def publish_function_version(
|
|
5093
5369
|
self,
|
|
@@ -5154,16 +5430,10 @@ class Client(OpenApiClient):
|
|
|
5154
5430
|
req_body_type='json',
|
|
5155
5431
|
body_type='json'
|
|
5156
5432
|
)
|
|
5157
|
-
|
|
5158
|
-
|
|
5159
|
-
|
|
5160
|
-
|
|
5161
|
-
)
|
|
5162
|
-
else:
|
|
5163
|
-
return TeaCore.from_map(
|
|
5164
|
-
fc20230330_models.PutAsyncInvokeConfigResponse(),
|
|
5165
|
-
self.execute(params, req, runtime)
|
|
5166
|
-
)
|
|
5433
|
+
return TeaCore.from_map(
|
|
5434
|
+
fc20230330_models.PutAsyncInvokeConfigResponse(),
|
|
5435
|
+
self.call_api(params, req, runtime)
|
|
5436
|
+
)
|
|
5167
5437
|
|
|
5168
5438
|
async def put_async_invoke_config_with_options_async(
|
|
5169
5439
|
self,
|
|
@@ -5200,16 +5470,10 @@ class Client(OpenApiClient):
|
|
|
5200
5470
|
req_body_type='json',
|
|
5201
5471
|
body_type='json'
|
|
5202
5472
|
)
|
|
5203
|
-
|
|
5204
|
-
|
|
5205
|
-
|
|
5206
|
-
|
|
5207
|
-
)
|
|
5208
|
-
else:
|
|
5209
|
-
return TeaCore.from_map(
|
|
5210
|
-
fc20230330_models.PutAsyncInvokeConfigResponse(),
|
|
5211
|
-
await self.execute_async(params, req, runtime)
|
|
5212
|
-
)
|
|
5473
|
+
return TeaCore.from_map(
|
|
5474
|
+
fc20230330_models.PutAsyncInvokeConfigResponse(),
|
|
5475
|
+
await self.call_api_async(params, req, runtime)
|
|
5476
|
+
)
|
|
5213
5477
|
|
|
5214
5478
|
def put_async_invoke_config(
|
|
5215
5479
|
self,
|
|
@@ -5272,16 +5536,10 @@ class Client(OpenApiClient):
|
|
|
5272
5536
|
req_body_type='json',
|
|
5273
5537
|
body_type='json'
|
|
5274
5538
|
)
|
|
5275
|
-
|
|
5276
|
-
|
|
5277
|
-
|
|
5278
|
-
|
|
5279
|
-
)
|
|
5280
|
-
else:
|
|
5281
|
-
return TeaCore.from_map(
|
|
5282
|
-
fc20230330_models.PutConcurrencyConfigResponse(),
|
|
5283
|
-
self.execute(params, req, runtime)
|
|
5284
|
-
)
|
|
5539
|
+
return TeaCore.from_map(
|
|
5540
|
+
fc20230330_models.PutConcurrencyConfigResponse(),
|
|
5541
|
+
self.call_api(params, req, runtime)
|
|
5542
|
+
)
|
|
5285
5543
|
|
|
5286
5544
|
async def put_concurrency_config_with_options_async(
|
|
5287
5545
|
self,
|
|
@@ -5314,16 +5572,10 @@ class Client(OpenApiClient):
|
|
|
5314
5572
|
req_body_type='json',
|
|
5315
5573
|
body_type='json'
|
|
5316
5574
|
)
|
|
5317
|
-
|
|
5318
|
-
|
|
5319
|
-
|
|
5320
|
-
|
|
5321
|
-
)
|
|
5322
|
-
else:
|
|
5323
|
-
return TeaCore.from_map(
|
|
5324
|
-
fc20230330_models.PutConcurrencyConfigResponse(),
|
|
5325
|
-
await self.execute_async(params, req, runtime)
|
|
5326
|
-
)
|
|
5575
|
+
return TeaCore.from_map(
|
|
5576
|
+
fc20230330_models.PutConcurrencyConfigResponse(),
|
|
5577
|
+
await self.call_api_async(params, req, runtime)
|
|
5578
|
+
)
|
|
5327
5579
|
|
|
5328
5580
|
def put_concurrency_config(
|
|
5329
5581
|
self,
|
|
@@ -5391,16 +5643,10 @@ class Client(OpenApiClient):
|
|
|
5391
5643
|
req_body_type='json',
|
|
5392
5644
|
body_type='none'
|
|
5393
5645
|
)
|
|
5394
|
-
|
|
5395
|
-
|
|
5396
|
-
|
|
5397
|
-
|
|
5398
|
-
)
|
|
5399
|
-
else:
|
|
5400
|
-
return TeaCore.from_map(
|
|
5401
|
-
fc20230330_models.PutLayerACLResponse(),
|
|
5402
|
-
self.execute(params, req, runtime)
|
|
5403
|
-
)
|
|
5646
|
+
return TeaCore.from_map(
|
|
5647
|
+
fc20230330_models.PutLayerACLResponse(),
|
|
5648
|
+
self.call_api(params, req, runtime)
|
|
5649
|
+
)
|
|
5404
5650
|
|
|
5405
5651
|
async def put_layer_aclwith_options_async(
|
|
5406
5652
|
self,
|
|
@@ -5438,16 +5684,10 @@ class Client(OpenApiClient):
|
|
|
5438
5684
|
req_body_type='json',
|
|
5439
5685
|
body_type='none'
|
|
5440
5686
|
)
|
|
5441
|
-
|
|
5442
|
-
|
|
5443
|
-
|
|
5444
|
-
|
|
5445
|
-
)
|
|
5446
|
-
else:
|
|
5447
|
-
return TeaCore.from_map(
|
|
5448
|
-
fc20230330_models.PutLayerACLResponse(),
|
|
5449
|
-
await self.execute_async(params, req, runtime)
|
|
5450
|
-
)
|
|
5687
|
+
return TeaCore.from_map(
|
|
5688
|
+
fc20230330_models.PutLayerACLResponse(),
|
|
5689
|
+
await self.call_api_async(params, req, runtime)
|
|
5690
|
+
)
|
|
5451
5691
|
|
|
5452
5692
|
def put_layer_acl(
|
|
5453
5693
|
self,
|
|
@@ -5514,16 +5754,10 @@ class Client(OpenApiClient):
|
|
|
5514
5754
|
req_body_type='json',
|
|
5515
5755
|
body_type='json'
|
|
5516
5756
|
)
|
|
5517
|
-
|
|
5518
|
-
|
|
5519
|
-
|
|
5520
|
-
|
|
5521
|
-
)
|
|
5522
|
-
else:
|
|
5523
|
-
return TeaCore.from_map(
|
|
5524
|
-
fc20230330_models.PutProvisionConfigResponse(),
|
|
5525
|
-
self.execute(params, req, runtime)
|
|
5526
|
-
)
|
|
5757
|
+
return TeaCore.from_map(
|
|
5758
|
+
fc20230330_models.PutProvisionConfigResponse(),
|
|
5759
|
+
self.call_api(params, req, runtime)
|
|
5760
|
+
)
|
|
5527
5761
|
|
|
5528
5762
|
async def put_provision_config_with_options_async(
|
|
5529
5763
|
self,
|
|
@@ -5560,16 +5794,10 @@ class Client(OpenApiClient):
|
|
|
5560
5794
|
req_body_type='json',
|
|
5561
5795
|
body_type='json'
|
|
5562
5796
|
)
|
|
5563
|
-
|
|
5564
|
-
|
|
5565
|
-
|
|
5566
|
-
|
|
5567
|
-
)
|
|
5568
|
-
else:
|
|
5569
|
-
return TeaCore.from_map(
|
|
5570
|
-
fc20230330_models.PutProvisionConfigResponse(),
|
|
5571
|
-
await self.execute_async(params, req, runtime)
|
|
5572
|
-
)
|
|
5797
|
+
return TeaCore.from_map(
|
|
5798
|
+
fc20230330_models.PutProvisionConfigResponse(),
|
|
5799
|
+
await self.call_api_async(params, req, runtime)
|
|
5800
|
+
)
|
|
5573
5801
|
|
|
5574
5802
|
def put_provision_config(
|
|
5575
5803
|
self,
|
|
@@ -5601,6 +5829,116 @@ class Client(OpenApiClient):
|
|
|
5601
5829
|
headers = {}
|
|
5602
5830
|
return await self.put_provision_config_with_options_async(function_name, request, headers, runtime)
|
|
5603
5831
|
|
|
5832
|
+
def put_scaling_config_with_options(
|
|
5833
|
+
self,
|
|
5834
|
+
function_name: str,
|
|
5835
|
+
request: fc20230330_models.PutScalingConfigRequest,
|
|
5836
|
+
headers: Dict[str, str],
|
|
5837
|
+
runtime: util_models.RuntimeOptions,
|
|
5838
|
+
) -> fc20230330_models.PutScalingConfigResponse:
|
|
5839
|
+
"""
|
|
5840
|
+
@summary 设置弹性配置
|
|
5841
|
+
|
|
5842
|
+
@param request: PutScalingConfigRequest
|
|
5843
|
+
@param headers: map
|
|
5844
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
5845
|
+
@return: PutScalingConfigResponse
|
|
5846
|
+
"""
|
|
5847
|
+
UtilClient.validate_model(request)
|
|
5848
|
+
query = {}
|
|
5849
|
+
if not UtilClient.is_unset(request.qualifier):
|
|
5850
|
+
query['qualifier'] = request.qualifier
|
|
5851
|
+
req = open_api_models.OpenApiRequest(
|
|
5852
|
+
headers=headers,
|
|
5853
|
+
query=OpenApiUtilClient.query(query),
|
|
5854
|
+
body=OpenApiUtilClient.parse_to_map(request.body)
|
|
5855
|
+
)
|
|
5856
|
+
params = open_api_models.Params(
|
|
5857
|
+
action='PutScalingConfig',
|
|
5858
|
+
version='2023-03-30',
|
|
5859
|
+
protocol='HTTPS',
|
|
5860
|
+
pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/scaling-config',
|
|
5861
|
+
method='PUT',
|
|
5862
|
+
auth_type='AK',
|
|
5863
|
+
style='ROA',
|
|
5864
|
+
req_body_type='json',
|
|
5865
|
+
body_type='json'
|
|
5866
|
+
)
|
|
5867
|
+
return TeaCore.from_map(
|
|
5868
|
+
fc20230330_models.PutScalingConfigResponse(),
|
|
5869
|
+
self.call_api(params, req, runtime)
|
|
5870
|
+
)
|
|
5871
|
+
|
|
5872
|
+
async def put_scaling_config_with_options_async(
|
|
5873
|
+
self,
|
|
5874
|
+
function_name: str,
|
|
5875
|
+
request: fc20230330_models.PutScalingConfigRequest,
|
|
5876
|
+
headers: Dict[str, str],
|
|
5877
|
+
runtime: util_models.RuntimeOptions,
|
|
5878
|
+
) -> fc20230330_models.PutScalingConfigResponse:
|
|
5879
|
+
"""
|
|
5880
|
+
@summary 设置弹性配置
|
|
5881
|
+
|
|
5882
|
+
@param request: PutScalingConfigRequest
|
|
5883
|
+
@param headers: map
|
|
5884
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
5885
|
+
@return: PutScalingConfigResponse
|
|
5886
|
+
"""
|
|
5887
|
+
UtilClient.validate_model(request)
|
|
5888
|
+
query = {}
|
|
5889
|
+
if not UtilClient.is_unset(request.qualifier):
|
|
5890
|
+
query['qualifier'] = request.qualifier
|
|
5891
|
+
req = open_api_models.OpenApiRequest(
|
|
5892
|
+
headers=headers,
|
|
5893
|
+
query=OpenApiUtilClient.query(query),
|
|
5894
|
+
body=OpenApiUtilClient.parse_to_map(request.body)
|
|
5895
|
+
)
|
|
5896
|
+
params = open_api_models.Params(
|
|
5897
|
+
action='PutScalingConfig',
|
|
5898
|
+
version='2023-03-30',
|
|
5899
|
+
protocol='HTTPS',
|
|
5900
|
+
pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/scaling-config',
|
|
5901
|
+
method='PUT',
|
|
5902
|
+
auth_type='AK',
|
|
5903
|
+
style='ROA',
|
|
5904
|
+
req_body_type='json',
|
|
5905
|
+
body_type='json'
|
|
5906
|
+
)
|
|
5907
|
+
return TeaCore.from_map(
|
|
5908
|
+
fc20230330_models.PutScalingConfigResponse(),
|
|
5909
|
+
await self.call_api_async(params, req, runtime)
|
|
5910
|
+
)
|
|
5911
|
+
|
|
5912
|
+
def put_scaling_config(
|
|
5913
|
+
self,
|
|
5914
|
+
function_name: str,
|
|
5915
|
+
request: fc20230330_models.PutScalingConfigRequest,
|
|
5916
|
+
) -> fc20230330_models.PutScalingConfigResponse:
|
|
5917
|
+
"""
|
|
5918
|
+
@summary 设置弹性配置
|
|
5919
|
+
|
|
5920
|
+
@param request: PutScalingConfigRequest
|
|
5921
|
+
@return: PutScalingConfigResponse
|
|
5922
|
+
"""
|
|
5923
|
+
runtime = util_models.RuntimeOptions()
|
|
5924
|
+
headers = {}
|
|
5925
|
+
return self.put_scaling_config_with_options(function_name, request, headers, runtime)
|
|
5926
|
+
|
|
5927
|
+
async def put_scaling_config_async(
|
|
5928
|
+
self,
|
|
5929
|
+
function_name: str,
|
|
5930
|
+
request: fc20230330_models.PutScalingConfigRequest,
|
|
5931
|
+
) -> fc20230330_models.PutScalingConfigResponse:
|
|
5932
|
+
"""
|
|
5933
|
+
@summary 设置弹性配置
|
|
5934
|
+
|
|
5935
|
+
@param request: PutScalingConfigRequest
|
|
5936
|
+
@return: PutScalingConfigResponse
|
|
5937
|
+
"""
|
|
5938
|
+
runtime = util_models.RuntimeOptions()
|
|
5939
|
+
headers = {}
|
|
5940
|
+
return await self.put_scaling_config_with_options_async(function_name, request, headers, runtime)
|
|
5941
|
+
|
|
5604
5942
|
def stop_async_task_with_options(
|
|
5605
5943
|
self,
|
|
5606
5944
|
function_name: str,
|
|
@@ -5636,16 +5974,10 @@ class Client(OpenApiClient):
|
|
|
5636
5974
|
req_body_type='json',
|
|
5637
5975
|
body_type='none'
|
|
5638
5976
|
)
|
|
5639
|
-
|
|
5640
|
-
|
|
5641
|
-
|
|
5642
|
-
|
|
5643
|
-
)
|
|
5644
|
-
else:
|
|
5645
|
-
return TeaCore.from_map(
|
|
5646
|
-
fc20230330_models.StopAsyncTaskResponse(),
|
|
5647
|
-
self.execute(params, req, runtime)
|
|
5648
|
-
)
|
|
5977
|
+
return TeaCore.from_map(
|
|
5978
|
+
fc20230330_models.StopAsyncTaskResponse(),
|
|
5979
|
+
self.call_api(params, req, runtime)
|
|
5980
|
+
)
|
|
5649
5981
|
|
|
5650
5982
|
async def stop_async_task_with_options_async(
|
|
5651
5983
|
self,
|
|
@@ -5682,16 +6014,10 @@ class Client(OpenApiClient):
|
|
|
5682
6014
|
req_body_type='json',
|
|
5683
6015
|
body_type='none'
|
|
5684
6016
|
)
|
|
5685
|
-
|
|
5686
|
-
|
|
5687
|
-
|
|
5688
|
-
|
|
5689
|
-
)
|
|
5690
|
-
else:
|
|
5691
|
-
return TeaCore.from_map(
|
|
5692
|
-
fc20230330_models.StopAsyncTaskResponse(),
|
|
5693
|
-
await self.execute_async(params, req, runtime)
|
|
5694
|
-
)
|
|
6017
|
+
return TeaCore.from_map(
|
|
6018
|
+
fc20230330_models.StopAsyncTaskResponse(),
|
|
6019
|
+
await self.call_api_async(params, req, runtime)
|
|
6020
|
+
)
|
|
5695
6021
|
|
|
5696
6022
|
def stop_async_task(
|
|
5697
6023
|
self,
|
|
@@ -5757,16 +6083,10 @@ class Client(OpenApiClient):
|
|
|
5757
6083
|
req_body_type='json',
|
|
5758
6084
|
body_type='none'
|
|
5759
6085
|
)
|
|
5760
|
-
|
|
5761
|
-
|
|
5762
|
-
|
|
5763
|
-
|
|
5764
|
-
)
|
|
5765
|
-
else:
|
|
5766
|
-
return TeaCore.from_map(
|
|
5767
|
-
fc20230330_models.TagResourcesResponse(),
|
|
5768
|
-
self.execute(params, req, runtime)
|
|
5769
|
-
)
|
|
6086
|
+
return TeaCore.from_map(
|
|
6087
|
+
fc20230330_models.TagResourcesResponse(),
|
|
6088
|
+
self.call_api(params, req, runtime)
|
|
6089
|
+
)
|
|
5770
6090
|
|
|
5771
6091
|
async def tag_resources_with_options_async(
|
|
5772
6092
|
self,
|
|
@@ -5800,16 +6120,10 @@ class Client(OpenApiClient):
|
|
|
5800
6120
|
req_body_type='json',
|
|
5801
6121
|
body_type='none'
|
|
5802
6122
|
)
|
|
5803
|
-
|
|
5804
|
-
|
|
5805
|
-
|
|
5806
|
-
|
|
5807
|
-
)
|
|
5808
|
-
else:
|
|
5809
|
-
return TeaCore.from_map(
|
|
5810
|
-
fc20230330_models.TagResourcesResponse(),
|
|
5811
|
-
await self.execute_async(params, req, runtime)
|
|
5812
|
-
)
|
|
6123
|
+
return TeaCore.from_map(
|
|
6124
|
+
fc20230330_models.TagResourcesResponse(),
|
|
6125
|
+
await self.call_api_async(params, req, runtime)
|
|
6126
|
+
)
|
|
5813
6127
|
|
|
5814
6128
|
def tag_resources(
|
|
5815
6129
|
self,
|
|
@@ -5888,16 +6202,10 @@ class Client(OpenApiClient):
|
|
|
5888
6202
|
req_body_type='json',
|
|
5889
6203
|
body_type='none'
|
|
5890
6204
|
)
|
|
5891
|
-
|
|
5892
|
-
|
|
5893
|
-
|
|
5894
|
-
|
|
5895
|
-
)
|
|
5896
|
-
else:
|
|
5897
|
-
return TeaCore.from_map(
|
|
5898
|
-
fc20230330_models.UntagResourcesResponse(),
|
|
5899
|
-
self.execute(params, req, runtime)
|
|
5900
|
-
)
|
|
6205
|
+
return TeaCore.from_map(
|
|
6206
|
+
fc20230330_models.UntagResourcesResponse(),
|
|
6207
|
+
self.call_api(params, req, runtime)
|
|
6208
|
+
)
|
|
5901
6209
|
|
|
5902
6210
|
async def untag_resources_with_options_async(
|
|
5903
6211
|
self,
|
|
@@ -5944,16 +6252,10 @@ class Client(OpenApiClient):
|
|
|
5944
6252
|
req_body_type='json',
|
|
5945
6253
|
body_type='none'
|
|
5946
6254
|
)
|
|
5947
|
-
|
|
5948
|
-
|
|
5949
|
-
|
|
5950
|
-
|
|
5951
|
-
)
|
|
5952
|
-
else:
|
|
5953
|
-
return TeaCore.from_map(
|
|
5954
|
-
fc20230330_models.UntagResourcesResponse(),
|
|
5955
|
-
await self.execute_async(params, req, runtime)
|
|
5956
|
-
)
|
|
6255
|
+
return TeaCore.from_map(
|
|
6256
|
+
fc20230330_models.UntagResourcesResponse(),
|
|
6257
|
+
await self.call_api_async(params, req, runtime)
|
|
6258
|
+
)
|
|
5957
6259
|
|
|
5958
6260
|
def untag_resources(
|
|
5959
6261
|
self,
|
|
@@ -6015,16 +6317,10 @@ class Client(OpenApiClient):
|
|
|
6015
6317
|
req_body_type='json',
|
|
6016
6318
|
body_type='json'
|
|
6017
6319
|
)
|
|
6018
|
-
|
|
6019
|
-
|
|
6020
|
-
|
|
6021
|
-
|
|
6022
|
-
)
|
|
6023
|
-
else:
|
|
6024
|
-
return TeaCore.from_map(
|
|
6025
|
-
fc20230330_models.UpdateAliasResponse(),
|
|
6026
|
-
self.execute(params, req, runtime)
|
|
6027
|
-
)
|
|
6320
|
+
return TeaCore.from_map(
|
|
6321
|
+
fc20230330_models.UpdateAliasResponse(),
|
|
6322
|
+
self.call_api(params, req, runtime)
|
|
6323
|
+
)
|
|
6028
6324
|
|
|
6029
6325
|
async def update_alias_with_options_async(
|
|
6030
6326
|
self,
|
|
@@ -6058,16 +6354,10 @@ class Client(OpenApiClient):
|
|
|
6058
6354
|
req_body_type='json',
|
|
6059
6355
|
body_type='json'
|
|
6060
6356
|
)
|
|
6061
|
-
|
|
6062
|
-
|
|
6063
|
-
|
|
6064
|
-
|
|
6065
|
-
)
|
|
6066
|
-
else:
|
|
6067
|
-
return TeaCore.from_map(
|
|
6068
|
-
fc20230330_models.UpdateAliasResponse(),
|
|
6069
|
-
await self.execute_async(params, req, runtime)
|
|
6070
|
-
)
|
|
6357
|
+
return TeaCore.from_map(
|
|
6358
|
+
fc20230330_models.UpdateAliasResponse(),
|
|
6359
|
+
await self.call_api_async(params, req, runtime)
|
|
6360
|
+
)
|
|
6071
6361
|
|
|
6072
6362
|
def update_alias(
|
|
6073
6363
|
self,
|
|
@@ -6132,16 +6422,10 @@ class Client(OpenApiClient):
|
|
|
6132
6422
|
req_body_type='json',
|
|
6133
6423
|
body_type='json'
|
|
6134
6424
|
)
|
|
6135
|
-
|
|
6136
|
-
|
|
6137
|
-
|
|
6138
|
-
|
|
6139
|
-
)
|
|
6140
|
-
else:
|
|
6141
|
-
return TeaCore.from_map(
|
|
6142
|
-
fc20230330_models.UpdateCustomDomainResponse(),
|
|
6143
|
-
self.execute(params, req, runtime)
|
|
6144
|
-
)
|
|
6425
|
+
return TeaCore.from_map(
|
|
6426
|
+
fc20230330_models.UpdateCustomDomainResponse(),
|
|
6427
|
+
self.call_api(params, req, runtime)
|
|
6428
|
+
)
|
|
6145
6429
|
|
|
6146
6430
|
async def update_custom_domain_with_options_async(
|
|
6147
6431
|
self,
|
|
@@ -6174,16 +6458,10 @@ class Client(OpenApiClient):
|
|
|
6174
6458
|
req_body_type='json',
|
|
6175
6459
|
body_type='json'
|
|
6176
6460
|
)
|
|
6177
|
-
|
|
6178
|
-
|
|
6179
|
-
|
|
6180
|
-
|
|
6181
|
-
)
|
|
6182
|
-
else:
|
|
6183
|
-
return TeaCore.from_map(
|
|
6184
|
-
fc20230330_models.UpdateCustomDomainResponse(),
|
|
6185
|
-
await self.execute_async(params, req, runtime)
|
|
6186
|
-
)
|
|
6461
|
+
return TeaCore.from_map(
|
|
6462
|
+
fc20230330_models.UpdateCustomDomainResponse(),
|
|
6463
|
+
await self.call_api_async(params, req, runtime)
|
|
6464
|
+
)
|
|
6187
6465
|
|
|
6188
6466
|
def update_custom_domain(
|
|
6189
6467
|
self,
|
|
@@ -6246,16 +6524,10 @@ class Client(OpenApiClient):
|
|
|
6246
6524
|
req_body_type='json',
|
|
6247
6525
|
body_type='json'
|
|
6248
6526
|
)
|
|
6249
|
-
|
|
6250
|
-
|
|
6251
|
-
|
|
6252
|
-
|
|
6253
|
-
)
|
|
6254
|
-
else:
|
|
6255
|
-
return TeaCore.from_map(
|
|
6256
|
-
fc20230330_models.UpdateFunctionResponse(),
|
|
6257
|
-
self.execute(params, req, runtime)
|
|
6258
|
-
)
|
|
6527
|
+
return TeaCore.from_map(
|
|
6528
|
+
fc20230330_models.UpdateFunctionResponse(),
|
|
6529
|
+
self.call_api(params, req, runtime)
|
|
6530
|
+
)
|
|
6259
6531
|
|
|
6260
6532
|
async def update_function_with_options_async(
|
|
6261
6533
|
self,
|
|
@@ -6288,16 +6560,10 @@ class Client(OpenApiClient):
|
|
|
6288
6560
|
req_body_type='json',
|
|
6289
6561
|
body_type='json'
|
|
6290
6562
|
)
|
|
6291
|
-
|
|
6292
|
-
|
|
6293
|
-
|
|
6294
|
-
|
|
6295
|
-
)
|
|
6296
|
-
else:
|
|
6297
|
-
return TeaCore.from_map(
|
|
6298
|
-
fc20230330_models.UpdateFunctionResponse(),
|
|
6299
|
-
await self.execute_async(params, req, runtime)
|
|
6300
|
-
)
|
|
6563
|
+
return TeaCore.from_map(
|
|
6564
|
+
fc20230330_models.UpdateFunctionResponse(),
|
|
6565
|
+
await self.call_api_async(params, req, runtime)
|
|
6566
|
+
)
|
|
6301
6567
|
|
|
6302
6568
|
def update_function(
|
|
6303
6569
|
self,
|
|
@@ -6361,16 +6627,10 @@ class Client(OpenApiClient):
|
|
|
6361
6627
|
req_body_type='json',
|
|
6362
6628
|
body_type='json'
|
|
6363
6629
|
)
|
|
6364
|
-
|
|
6365
|
-
|
|
6366
|
-
|
|
6367
|
-
|
|
6368
|
-
)
|
|
6369
|
-
else:
|
|
6370
|
-
return TeaCore.from_map(
|
|
6371
|
-
fc20230330_models.UpdateTriggerResponse(),
|
|
6372
|
-
self.execute(params, req, runtime)
|
|
6373
|
-
)
|
|
6630
|
+
return TeaCore.from_map(
|
|
6631
|
+
fc20230330_models.UpdateTriggerResponse(),
|
|
6632
|
+
self.call_api(params, req, runtime)
|
|
6633
|
+
)
|
|
6374
6634
|
|
|
6375
6635
|
async def update_trigger_with_options_async(
|
|
6376
6636
|
self,
|
|
@@ -6404,16 +6664,10 @@ class Client(OpenApiClient):
|
|
|
6404
6664
|
req_body_type='json',
|
|
6405
6665
|
body_type='json'
|
|
6406
6666
|
)
|
|
6407
|
-
|
|
6408
|
-
|
|
6409
|
-
|
|
6410
|
-
|
|
6411
|
-
)
|
|
6412
|
-
else:
|
|
6413
|
-
return TeaCore.from_map(
|
|
6414
|
-
fc20230330_models.UpdateTriggerResponse(),
|
|
6415
|
-
await self.execute_async(params, req, runtime)
|
|
6416
|
-
)
|
|
6667
|
+
return TeaCore.from_map(
|
|
6668
|
+
fc20230330_models.UpdateTriggerResponse(),
|
|
6669
|
+
await self.call_api_async(params, req, runtime)
|
|
6670
|
+
)
|
|
6417
6671
|
|
|
6418
6672
|
def update_trigger(
|
|
6419
6673
|
self,
|