volcengine-python-sdk 5.0.38__py2.py3-none-any.whl → 5.0.40__py2.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.
- {volcengine_python_sdk-5.0.38.dist-info → volcengine_python_sdk-5.0.40.dist-info}/METADATA +1 -1
- {volcengine_python_sdk-5.0.38.dist-info → volcengine_python_sdk-5.0.40.dist-info}/RECORD +112 -41
- volcenginesdkacep/__init__.py +16 -0
- volcenginesdkacep/api/acep_api.py +741 -62
- volcenginesdkacep/models/__init__.py +16 -0
- volcenginesdkacep/models/add_adb_key_request.py +257 -0
- volcenginesdkacep/models/add_adb_key_response.py +123 -0
- volcenginesdkacep/models/bind_adb_key_pods_request.py +177 -0
- volcenginesdkacep/models/bind_adb_key_pods_response.py +123 -0
- volcenginesdkacep/models/delete_adb_key_request.py +150 -0
- volcenginesdkacep/models/delete_adb_key_response.py +95 -0
- volcenginesdkacep/models/list_adb_key_pod_bindings_request.py +228 -0
- volcenginesdkacep/models/list_adb_key_pod_bindings_response.py +149 -0
- volcenginesdkacep/models/list_adb_key_request.py +306 -0
- volcenginesdkacep/models/list_adb_key_response.py +149 -0
- volcenginesdkacep/models/row_for_list_adb_key_output.py +331 -0
- volcenginesdkacep/models/row_for_list_adb_key_pod_bindings_output.py +305 -0
- volcenginesdkacep/models/unbind_adb_key_pods_request.py +177 -0
- volcenginesdkacep/models/unbind_adb_key_pods_response.py +123 -0
- volcenginesdkacep/models/update_adb_key_request.py +203 -0
- volcenginesdkacep/models/update_adb_key_response.py +95 -0
- volcenginesdkcen/__init__.py +4 -0
- volcenginesdkcen/api/cen_api.py +97 -0
- volcenginesdkcen/models/__init__.py +4 -0
- volcenginesdkcen/models/describe95_traffic_request.py +178 -0
- volcenginesdkcen/models/describe95_traffic_response.py +123 -0
- volcenginesdkcen/models/traffic_data_for_describe95_traffic_output.py +201 -0
- volcenginesdkcen/models/traffic_detail_data_for_describe95_traffic_output.py +175 -0
- volcenginesdkclawsentry/__init__.py +1 -0
- volcenginesdkclawsentry/models/__init__.py +1 -0
- volcenginesdkclawsentry/models/base_for_create_claw_input.py +3 -0
- volcenginesdkclawsentry/models/create_claw_request.py +121 -3
- volcenginesdkclawsentry/models/create_claw_response.py +55 -3
- volcenginesdkclawsentry/models/personal_claw_for_create_claw_input.py +129 -0
- volcenginesdkcore/api_client.py +1 -1
- volcenginesdkcore/configuration.py +1 -1
- volcenginesdkcore/endpoint/providers/default_provider.py +12 -0
- volcenginesdkcore/endpoint/providers/standard_provider.py +1 -0
- volcenginesdkflink20250101/__init__.py +40 -0
- volcenginesdkflink20250101/api/flink20250101_api.py +1194 -30
- volcenginesdkflink20250101/models/__init__.py +40 -0
- volcenginesdkflink20250101/models/available_savepoint_for_get_gws_start_method_output.py +331 -0
- volcenginesdkflink20250101/models/create_gmcs_resource_pool_request.py +441 -0
- volcenginesdkflink20250101/models/create_gmcs_resource_pool_response.py +253 -0
- volcenginesdkflink20250101/models/create_gws_application_draft_request.py +232 -0
- volcenginesdkflink20250101/models/create_gws_application_draft_response.py +539 -0
- volcenginesdkflink20250101/models/create_gws_savepoint_request.py +151 -0
- volcenginesdkflink20250101/models/create_gws_savepoint_response.py +175 -0
- volcenginesdkflink20250101/models/data_list_for_list_gmcs_resources_output.py +461 -0
- volcenginesdkflink20250101/models/delete_gmcs_resource_request.py +124 -0
- volcenginesdkflink20250101/models/delete_gmcs_resource_response.py +123 -0
- volcenginesdkflink20250101/models/dependency_for_list_gws_application_output.py +149 -0
- volcenginesdkflink20250101/models/deploy_gws_application_draft_request.py +284 -0
- volcenginesdkflink20250101/models/deploy_gws_application_draft_response.py +149 -0
- volcenginesdkflink20250101/models/deploy_request_for_list_gws_application_output.py +253 -0
- volcenginesdkflink20250101/models/extra_info_for_get_gmcs_resource_pool_output.py +175 -0
- volcenginesdkflink20250101/models/extra_info_for_list_gmcs_resources_output.py +175 -0
- volcenginesdkflink20250101/models/get_application_instance_response.py +289 -3
- volcenginesdkflink20250101/models/get_gmcs_resource_pool_request.py +124 -0
- volcenginesdkflink20250101/models/get_gmcs_resource_pool_response.py +539 -0
- volcenginesdkflink20250101/models/get_gws_start_method_request.py +124 -0
- volcenginesdkflink20250101/models/get_gws_start_method_response.py +175 -0
- volcenginesdkflink20250101/models/list_gmcs_resources_request.py +254 -0
- volcenginesdkflink20250101/models/list_gmcs_resources_response.py +201 -0
- volcenginesdkflink20250101/models/list_gws_application_request.py +322 -0
- volcenginesdkflink20250101/models/list_gws_application_response.py +201 -0
- volcenginesdkflink20250101/models/list_gws_savepoint_request.py +124 -0
- volcenginesdkflink20250101/models/list_gws_savepoint_response.py +123 -0
- volcenginesdkflink20250101/models/record_for_list_gws_application_output.py +747 -0
- volcenginesdkflink20250101/models/resource_for_create_gmcs_resource_pool_input.py +201 -0
- volcenginesdkflink20250101/models/resource_for_get_gmcs_resource_pool_output.py +201 -0
- volcenginesdkflink20250101/models/resource_for_list_gmcs_resources_output.py +201 -0
- volcenginesdkflink20250101/models/resource_for_update_gmcs_resource_pool_input.py +201 -0
- volcenginesdkflink20250101/models/savepoint_info_for_list_gws_savepoint_output.py +331 -0
- volcenginesdkflink20250101/models/tag_for_create_gmcs_resource_pool_input.py +149 -0
- volcenginesdkflink20250101/models/tag_for_create_gmcs_resource_pool_output.py +149 -0
- volcenginesdkflink20250101/models/tag_for_get_gmcs_resource_pool_output.py +149 -0
- volcenginesdkflink20250101/models/tag_for_list_gmcs_resources_output.py +149 -0
- volcenginesdkflink20250101/models/update_gmcs_resource_pool_request.py +254 -0
- volcenginesdkflink20250101/models/update_gmcs_resource_pool_response.py +149 -0
- volcenginesdkflink20250101/models/update_gws_application_draft_request.py +571 -0
- volcenginesdkflink20250101/models/update_gws_application_draft_response.py +149 -0
- volcenginesdkna/__init__.py +4 -0
- volcenginesdkna/api/na_api.py +97 -0
- volcenginesdkna/models/__init__.py +4 -0
- volcenginesdkna/models/create_path_analysis_request.py +27 -1
- volcenginesdkna/models/describe_instance_topology_request.py +157 -0
- volcenginesdkna/models/describe_instance_topology_response.py +149 -0
- volcenginesdkna/models/error_for_describe_instance_topology_output.py +149 -0
- volcenginesdkna/models/instance_topology_info_for_describe_instance_topology_output.py +305 -0
- volcenginesdktransitrouter/__init__.py +5 -1
- volcenginesdktransitrouter/api/transitrouter_api.py +97 -0
- volcenginesdktransitrouter/models/__init__.py +5 -1
- volcenginesdktransitrouter/models/describe95_traffic_request.py +185 -0
- volcenginesdktransitrouter/models/describe95_traffic_response.py +123 -0
- volcenginesdktransitrouter/models/describe_transit_router_multicast_domains_response.py +3 -3
- volcenginesdktransitrouter/models/describe_transit_router_vpn_attachments_request.py +3 -0
- volcenginesdktransitrouter/models/models.py +2172 -2172
- volcenginesdktransitrouter/models/traffic_data_for_describe95_traffic_output.py +201 -0
- volcenginesdktransitrouter/models/traffic_detail_data_for_describe95_traffic_output.py +175 -0
- volcenginesdktransitrouter/models/transit_router_attachment_for_describe_transit_router_vpn_attachments_output.py +27 -1
- volcenginesdktransitrouter/models/{transit_router_multicast_domains_for_describe_transit_router_multicast_domains_output.py → transit_router_multicast_domain_for_describe_transit_router_multicast_domains_output.py} +33 -33
- volcenginesdkvke/__init__.py +2 -0
- volcenginesdkvke/api/vke_api.py +97 -0
- volcenginesdkvke/models/__init__.py +2 -0
- volcenginesdkvke/models/item_for_list_scaling_policies_output.py +27 -1
- volcenginesdkvke/models/scale_node_pool_request.py +204 -0
- volcenginesdkvke/models/scale_node_pool_response.py +95 -0
- {volcengine_python_sdk-5.0.38.dist-info → volcengine_python_sdk-5.0.40.dist-info}/WHEEL +0 -0
- {volcengine_python_sdk-5.0.38.dist-info → volcengine_python_sdk-5.0.40.dist-info}/licenses/LICENSE.txt +0 -0
- {volcengine_python_sdk-5.0.38.dist-info → volcengine_python_sdk-5.0.40.dist-info}/licenses/NOTICE.md +0 -0
- {volcengine_python_sdk-5.0.38.dist-info → volcengine_python_sdk-5.0.40.dist-info}/top_level.txt +0 -0
|
@@ -33,6 +33,103 @@ class ACEPApi(object):
|
|
|
33
33
|
api_client = volcenginesdkcore.ApiClient()
|
|
34
34
|
self.api_client = api_client
|
|
35
35
|
|
|
36
|
+
def add_adb_key(self, body, **kwargs): # noqa: E501
|
|
37
|
+
"""add_adb_key # noqa: E501
|
|
38
|
+
|
|
39
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
40
|
+
asynchronous HTTP request, please pass async_req=True
|
|
41
|
+
>>> thread = api.add_adb_key(body, async_req=True)
|
|
42
|
+
>>> result = thread.get()
|
|
43
|
+
|
|
44
|
+
:param async_req bool
|
|
45
|
+
:param AddAdbKeyRequest body: (required)
|
|
46
|
+
:return: AddAdbKeyResponse
|
|
47
|
+
If the method is called asynchronously,
|
|
48
|
+
returns the request thread.
|
|
49
|
+
"""
|
|
50
|
+
kwargs['_return_http_data_only'] = True
|
|
51
|
+
if kwargs.get('async_req'):
|
|
52
|
+
return self.add_adb_key_with_http_info(body, **kwargs) # noqa: E501
|
|
53
|
+
else:
|
|
54
|
+
(data) = self.add_adb_key_with_http_info(body, **kwargs) # noqa: E501
|
|
55
|
+
return data
|
|
56
|
+
|
|
57
|
+
def add_adb_key_with_http_info(self, body, **kwargs): # noqa: E501
|
|
58
|
+
"""add_adb_key # noqa: E501
|
|
59
|
+
|
|
60
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
61
|
+
asynchronous HTTP request, please pass async_req=True
|
|
62
|
+
>>> thread = api.add_adb_key_with_http_info(body, async_req=True)
|
|
63
|
+
>>> result = thread.get()
|
|
64
|
+
|
|
65
|
+
:param async_req bool
|
|
66
|
+
:param AddAdbKeyRequest body: (required)
|
|
67
|
+
:return: AddAdbKeyResponse
|
|
68
|
+
If the method is called asynchronously,
|
|
69
|
+
returns the request thread.
|
|
70
|
+
"""
|
|
71
|
+
|
|
72
|
+
all_params = ['body'] # noqa: E501
|
|
73
|
+
all_params.append('async_req')
|
|
74
|
+
all_params.append('_return_http_data_only')
|
|
75
|
+
all_params.append('_preload_content')
|
|
76
|
+
all_params.append('_request_timeout')
|
|
77
|
+
|
|
78
|
+
params = locals()
|
|
79
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
80
|
+
if key not in all_params:
|
|
81
|
+
raise TypeError(
|
|
82
|
+
"Got an unexpected keyword argument '%s'"
|
|
83
|
+
" to method add_adb_key" % key
|
|
84
|
+
)
|
|
85
|
+
params[key] = val
|
|
86
|
+
del params['kwargs']
|
|
87
|
+
# verify the required parameter 'body' is set
|
|
88
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
89
|
+
params['body'] is None): # noqa: E501
|
|
90
|
+
raise ValueError("Missing the required parameter `body` when calling `add_adb_key`") # noqa: E501
|
|
91
|
+
|
|
92
|
+
collection_formats = {}
|
|
93
|
+
|
|
94
|
+
path_params = {}
|
|
95
|
+
|
|
96
|
+
query_params = []
|
|
97
|
+
|
|
98
|
+
header_params = {}
|
|
99
|
+
|
|
100
|
+
form_params = []
|
|
101
|
+
local_var_files = {}
|
|
102
|
+
|
|
103
|
+
body_params = None
|
|
104
|
+
if 'body' in params:
|
|
105
|
+
body_params = params['body']
|
|
106
|
+
# HTTP header `Accept`
|
|
107
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
108
|
+
['application/json']) # noqa: E501
|
|
109
|
+
|
|
110
|
+
# HTTP header `Content-Type`
|
|
111
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
112
|
+
['application/json']) # noqa: E501
|
|
113
|
+
|
|
114
|
+
# Authentication setting
|
|
115
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
116
|
+
|
|
117
|
+
return self.api_client.call_api(
|
|
118
|
+
'/AddAdbKey/2025-05-01/acep/post/application_json/', 'POST',
|
|
119
|
+
path_params,
|
|
120
|
+
query_params,
|
|
121
|
+
header_params,
|
|
122
|
+
body=body_params,
|
|
123
|
+
post_params=form_params,
|
|
124
|
+
files=local_var_files,
|
|
125
|
+
response_type='AddAdbKeyResponse', # noqa: E501
|
|
126
|
+
auth_settings=auth_settings,
|
|
127
|
+
async_req=params.get('async_req'),
|
|
128
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
129
|
+
_preload_content=params.get('_preload_content', True),
|
|
130
|
+
_request_timeout=params.get('_request_timeout'),
|
|
131
|
+
collection_formats=collection_formats)
|
|
132
|
+
|
|
36
133
|
def add_custom_route(self, body, **kwargs): # noqa: E501
|
|
37
134
|
"""add_custom_route # noqa: E501
|
|
38
135
|
|
|
@@ -809,6 +906,103 @@ class ACEPApi(object):
|
|
|
809
906
|
_request_timeout=params.get('_request_timeout'),
|
|
810
907
|
collection_formats=collection_formats)
|
|
811
908
|
|
|
909
|
+
def bind_adb_key_pods(self, body, **kwargs): # noqa: E501
|
|
910
|
+
"""bind_adb_key_pods # noqa: E501
|
|
911
|
+
|
|
912
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
913
|
+
asynchronous HTTP request, please pass async_req=True
|
|
914
|
+
>>> thread = api.bind_adb_key_pods(body, async_req=True)
|
|
915
|
+
>>> result = thread.get()
|
|
916
|
+
|
|
917
|
+
:param async_req bool
|
|
918
|
+
:param BindAdbKeyPodsRequest body: (required)
|
|
919
|
+
:return: BindAdbKeyPodsResponse
|
|
920
|
+
If the method is called asynchronously,
|
|
921
|
+
returns the request thread.
|
|
922
|
+
"""
|
|
923
|
+
kwargs['_return_http_data_only'] = True
|
|
924
|
+
if kwargs.get('async_req'):
|
|
925
|
+
return self.bind_adb_key_pods_with_http_info(body, **kwargs) # noqa: E501
|
|
926
|
+
else:
|
|
927
|
+
(data) = self.bind_adb_key_pods_with_http_info(body, **kwargs) # noqa: E501
|
|
928
|
+
return data
|
|
929
|
+
|
|
930
|
+
def bind_adb_key_pods_with_http_info(self, body, **kwargs): # noqa: E501
|
|
931
|
+
"""bind_adb_key_pods # noqa: E501
|
|
932
|
+
|
|
933
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
934
|
+
asynchronous HTTP request, please pass async_req=True
|
|
935
|
+
>>> thread = api.bind_adb_key_pods_with_http_info(body, async_req=True)
|
|
936
|
+
>>> result = thread.get()
|
|
937
|
+
|
|
938
|
+
:param async_req bool
|
|
939
|
+
:param BindAdbKeyPodsRequest body: (required)
|
|
940
|
+
:return: BindAdbKeyPodsResponse
|
|
941
|
+
If the method is called asynchronously,
|
|
942
|
+
returns the request thread.
|
|
943
|
+
"""
|
|
944
|
+
|
|
945
|
+
all_params = ['body'] # noqa: E501
|
|
946
|
+
all_params.append('async_req')
|
|
947
|
+
all_params.append('_return_http_data_only')
|
|
948
|
+
all_params.append('_preload_content')
|
|
949
|
+
all_params.append('_request_timeout')
|
|
950
|
+
|
|
951
|
+
params = locals()
|
|
952
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
953
|
+
if key not in all_params:
|
|
954
|
+
raise TypeError(
|
|
955
|
+
"Got an unexpected keyword argument '%s'"
|
|
956
|
+
" to method bind_adb_key_pods" % key
|
|
957
|
+
)
|
|
958
|
+
params[key] = val
|
|
959
|
+
del params['kwargs']
|
|
960
|
+
# verify the required parameter 'body' is set
|
|
961
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
962
|
+
params['body'] is None): # noqa: E501
|
|
963
|
+
raise ValueError("Missing the required parameter `body` when calling `bind_adb_key_pods`") # noqa: E501
|
|
964
|
+
|
|
965
|
+
collection_formats = {}
|
|
966
|
+
|
|
967
|
+
path_params = {}
|
|
968
|
+
|
|
969
|
+
query_params = []
|
|
970
|
+
|
|
971
|
+
header_params = {}
|
|
972
|
+
|
|
973
|
+
form_params = []
|
|
974
|
+
local_var_files = {}
|
|
975
|
+
|
|
976
|
+
body_params = None
|
|
977
|
+
if 'body' in params:
|
|
978
|
+
body_params = params['body']
|
|
979
|
+
# HTTP header `Accept`
|
|
980
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
981
|
+
['application/json']) # noqa: E501
|
|
982
|
+
|
|
983
|
+
# HTTP header `Content-Type`
|
|
984
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
985
|
+
['application/json']) # noqa: E501
|
|
986
|
+
|
|
987
|
+
# Authentication setting
|
|
988
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
989
|
+
|
|
990
|
+
return self.api_client.call_api(
|
|
991
|
+
'/BindAdbKeyPods/2025-05-01/acep/post/application_json/', 'POST',
|
|
992
|
+
path_params,
|
|
993
|
+
query_params,
|
|
994
|
+
header_params,
|
|
995
|
+
body=body_params,
|
|
996
|
+
post_params=form_params,
|
|
997
|
+
files=local_var_files,
|
|
998
|
+
response_type='BindAdbKeyPodsResponse', # noqa: E501
|
|
999
|
+
auth_settings=auth_settings,
|
|
1000
|
+
async_req=params.get('async_req'),
|
|
1001
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
1002
|
+
_preload_content=params.get('_preload_content', True),
|
|
1003
|
+
_request_timeout=params.get('_request_timeout'),
|
|
1004
|
+
collection_formats=collection_formats)
|
|
1005
|
+
|
|
812
1006
|
def bind_port_mapping_rule(self, body, **kwargs): # noqa: E501
|
|
813
1007
|
"""bind_port_mapping_rule # noqa: E501
|
|
814
1008
|
|
|
@@ -1973,6 +2167,103 @@ class ACEPApi(object):
|
|
|
1973
2167
|
_request_timeout=params.get('_request_timeout'),
|
|
1974
2168
|
collection_formats=collection_formats)
|
|
1975
2169
|
|
|
2170
|
+
def delete_adb_key(self, body, **kwargs): # noqa: E501
|
|
2171
|
+
"""delete_adb_key # noqa: E501
|
|
2172
|
+
|
|
2173
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2174
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2175
|
+
>>> thread = api.delete_adb_key(body, async_req=True)
|
|
2176
|
+
>>> result = thread.get()
|
|
2177
|
+
|
|
2178
|
+
:param async_req bool
|
|
2179
|
+
:param DeleteAdbKeyRequest body: (required)
|
|
2180
|
+
:return: DeleteAdbKeyResponse
|
|
2181
|
+
If the method is called asynchronously,
|
|
2182
|
+
returns the request thread.
|
|
2183
|
+
"""
|
|
2184
|
+
kwargs['_return_http_data_only'] = True
|
|
2185
|
+
if kwargs.get('async_req'):
|
|
2186
|
+
return self.delete_adb_key_with_http_info(body, **kwargs) # noqa: E501
|
|
2187
|
+
else:
|
|
2188
|
+
(data) = self.delete_adb_key_with_http_info(body, **kwargs) # noqa: E501
|
|
2189
|
+
return data
|
|
2190
|
+
|
|
2191
|
+
def delete_adb_key_with_http_info(self, body, **kwargs): # noqa: E501
|
|
2192
|
+
"""delete_adb_key # noqa: E501
|
|
2193
|
+
|
|
2194
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2195
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2196
|
+
>>> thread = api.delete_adb_key_with_http_info(body, async_req=True)
|
|
2197
|
+
>>> result = thread.get()
|
|
2198
|
+
|
|
2199
|
+
:param async_req bool
|
|
2200
|
+
:param DeleteAdbKeyRequest body: (required)
|
|
2201
|
+
:return: DeleteAdbKeyResponse
|
|
2202
|
+
If the method is called asynchronously,
|
|
2203
|
+
returns the request thread.
|
|
2204
|
+
"""
|
|
2205
|
+
|
|
2206
|
+
all_params = ['body'] # noqa: E501
|
|
2207
|
+
all_params.append('async_req')
|
|
2208
|
+
all_params.append('_return_http_data_only')
|
|
2209
|
+
all_params.append('_preload_content')
|
|
2210
|
+
all_params.append('_request_timeout')
|
|
2211
|
+
|
|
2212
|
+
params = locals()
|
|
2213
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
2214
|
+
if key not in all_params:
|
|
2215
|
+
raise TypeError(
|
|
2216
|
+
"Got an unexpected keyword argument '%s'"
|
|
2217
|
+
" to method delete_adb_key" % key
|
|
2218
|
+
)
|
|
2219
|
+
params[key] = val
|
|
2220
|
+
del params['kwargs']
|
|
2221
|
+
# verify the required parameter 'body' is set
|
|
2222
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
2223
|
+
params['body'] is None): # noqa: E501
|
|
2224
|
+
raise ValueError("Missing the required parameter `body` when calling `delete_adb_key`") # noqa: E501
|
|
2225
|
+
|
|
2226
|
+
collection_formats = {}
|
|
2227
|
+
|
|
2228
|
+
path_params = {}
|
|
2229
|
+
|
|
2230
|
+
query_params = []
|
|
2231
|
+
|
|
2232
|
+
header_params = {}
|
|
2233
|
+
|
|
2234
|
+
form_params = []
|
|
2235
|
+
local_var_files = {}
|
|
2236
|
+
|
|
2237
|
+
body_params = None
|
|
2238
|
+
if 'body' in params:
|
|
2239
|
+
body_params = params['body']
|
|
2240
|
+
# HTTP header `Accept`
|
|
2241
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
2242
|
+
['application/json']) # noqa: E501
|
|
2243
|
+
|
|
2244
|
+
# HTTP header `Content-Type`
|
|
2245
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
2246
|
+
['application/json']) # noqa: E501
|
|
2247
|
+
|
|
2248
|
+
# Authentication setting
|
|
2249
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
2250
|
+
|
|
2251
|
+
return self.api_client.call_api(
|
|
2252
|
+
'/DeleteAdbKey/2025-05-01/acep/post/application_json/', 'POST',
|
|
2253
|
+
path_params,
|
|
2254
|
+
query_params,
|
|
2255
|
+
header_params,
|
|
2256
|
+
body=body_params,
|
|
2257
|
+
post_params=form_params,
|
|
2258
|
+
files=local_var_files,
|
|
2259
|
+
response_type='DeleteAdbKeyResponse', # noqa: E501
|
|
2260
|
+
auth_settings=auth_settings,
|
|
2261
|
+
async_req=params.get('async_req'),
|
|
2262
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
2263
|
+
_preload_content=params.get('_preload_content', True),
|
|
2264
|
+
_request_timeout=params.get('_request_timeout'),
|
|
2265
|
+
collection_formats=collection_formats)
|
|
2266
|
+
|
|
1976
2267
|
def delete_aosp_image(self, body, **kwargs): # noqa: E501
|
|
1977
2268
|
"""delete_aosp_image # noqa: E501
|
|
1978
2269
|
|
|
@@ -4403,33 +4694,227 @@ class ACEPApi(object):
|
|
|
4403
4694
|
|
|
4404
4695
|
This method makes a synchronous HTTP request by default. To make an
|
|
4405
4696
|
asynchronous HTTP request, please pass async_req=True
|
|
4406
|
-
>>> thread = api.install_app(body, async_req=True)
|
|
4697
|
+
>>> thread = api.install_app(body, async_req=True)
|
|
4698
|
+
>>> result = thread.get()
|
|
4699
|
+
|
|
4700
|
+
:param async_req bool
|
|
4701
|
+
:param InstallAppRequest body: (required)
|
|
4702
|
+
:return: InstallAppResponse
|
|
4703
|
+
If the method is called asynchronously,
|
|
4704
|
+
returns the request thread.
|
|
4705
|
+
"""
|
|
4706
|
+
kwargs['_return_http_data_only'] = True
|
|
4707
|
+
if kwargs.get('async_req'):
|
|
4708
|
+
return self.install_app_with_http_info(body, **kwargs) # noqa: E501
|
|
4709
|
+
else:
|
|
4710
|
+
(data) = self.install_app_with_http_info(body, **kwargs) # noqa: E501
|
|
4711
|
+
return data
|
|
4712
|
+
|
|
4713
|
+
def install_app_with_http_info(self, body, **kwargs): # noqa: E501
|
|
4714
|
+
"""install_app # noqa: E501
|
|
4715
|
+
|
|
4716
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
4717
|
+
asynchronous HTTP request, please pass async_req=True
|
|
4718
|
+
>>> thread = api.install_app_with_http_info(body, async_req=True)
|
|
4719
|
+
>>> result = thread.get()
|
|
4720
|
+
|
|
4721
|
+
:param async_req bool
|
|
4722
|
+
:param InstallAppRequest body: (required)
|
|
4723
|
+
:return: InstallAppResponse
|
|
4724
|
+
If the method is called asynchronously,
|
|
4725
|
+
returns the request thread.
|
|
4726
|
+
"""
|
|
4727
|
+
|
|
4728
|
+
all_params = ['body'] # noqa: E501
|
|
4729
|
+
all_params.append('async_req')
|
|
4730
|
+
all_params.append('_return_http_data_only')
|
|
4731
|
+
all_params.append('_preload_content')
|
|
4732
|
+
all_params.append('_request_timeout')
|
|
4733
|
+
|
|
4734
|
+
params = locals()
|
|
4735
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
4736
|
+
if key not in all_params:
|
|
4737
|
+
raise TypeError(
|
|
4738
|
+
"Got an unexpected keyword argument '%s'"
|
|
4739
|
+
" to method install_app" % key
|
|
4740
|
+
)
|
|
4741
|
+
params[key] = val
|
|
4742
|
+
del params['kwargs']
|
|
4743
|
+
# verify the required parameter 'body' is set
|
|
4744
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
4745
|
+
params['body'] is None): # noqa: E501
|
|
4746
|
+
raise ValueError("Missing the required parameter `body` when calling `install_app`") # noqa: E501
|
|
4747
|
+
|
|
4748
|
+
collection_formats = {}
|
|
4749
|
+
|
|
4750
|
+
path_params = {}
|
|
4751
|
+
|
|
4752
|
+
query_params = []
|
|
4753
|
+
|
|
4754
|
+
header_params = {}
|
|
4755
|
+
|
|
4756
|
+
form_params = []
|
|
4757
|
+
local_var_files = {}
|
|
4758
|
+
|
|
4759
|
+
body_params = None
|
|
4760
|
+
if 'body' in params:
|
|
4761
|
+
body_params = params['body']
|
|
4762
|
+
# HTTP header `Accept`
|
|
4763
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
4764
|
+
['application/json']) # noqa: E501
|
|
4765
|
+
|
|
4766
|
+
# HTTP header `Content-Type`
|
|
4767
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
4768
|
+
['application/json']) # noqa: E501
|
|
4769
|
+
|
|
4770
|
+
# Authentication setting
|
|
4771
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
4772
|
+
|
|
4773
|
+
return self.api_client.call_api(
|
|
4774
|
+
'/InstallApp/2025-05-01/acep/post/application_json/', 'POST',
|
|
4775
|
+
path_params,
|
|
4776
|
+
query_params,
|
|
4777
|
+
header_params,
|
|
4778
|
+
body=body_params,
|
|
4779
|
+
post_params=form_params,
|
|
4780
|
+
files=local_var_files,
|
|
4781
|
+
response_type='InstallAppResponse', # noqa: E501
|
|
4782
|
+
auth_settings=auth_settings,
|
|
4783
|
+
async_req=params.get('async_req'),
|
|
4784
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
4785
|
+
_preload_content=params.get('_preload_content', True),
|
|
4786
|
+
_request_timeout=params.get('_request_timeout'),
|
|
4787
|
+
collection_formats=collection_formats)
|
|
4788
|
+
|
|
4789
|
+
def install_apps(self, body, **kwargs): # noqa: E501
|
|
4790
|
+
"""install_apps # noqa: E501
|
|
4791
|
+
|
|
4792
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
4793
|
+
asynchronous HTTP request, please pass async_req=True
|
|
4794
|
+
>>> thread = api.install_apps(body, async_req=True)
|
|
4795
|
+
>>> result = thread.get()
|
|
4796
|
+
|
|
4797
|
+
:param async_req bool
|
|
4798
|
+
:param InstallAppsRequest body: (required)
|
|
4799
|
+
:return: InstallAppsResponse
|
|
4800
|
+
If the method is called asynchronously,
|
|
4801
|
+
returns the request thread.
|
|
4802
|
+
"""
|
|
4803
|
+
kwargs['_return_http_data_only'] = True
|
|
4804
|
+
if kwargs.get('async_req'):
|
|
4805
|
+
return self.install_apps_with_http_info(body, **kwargs) # noqa: E501
|
|
4806
|
+
else:
|
|
4807
|
+
(data) = self.install_apps_with_http_info(body, **kwargs) # noqa: E501
|
|
4808
|
+
return data
|
|
4809
|
+
|
|
4810
|
+
def install_apps_with_http_info(self, body, **kwargs): # noqa: E501
|
|
4811
|
+
"""install_apps # noqa: E501
|
|
4812
|
+
|
|
4813
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
4814
|
+
asynchronous HTTP request, please pass async_req=True
|
|
4815
|
+
>>> thread = api.install_apps_with_http_info(body, async_req=True)
|
|
4816
|
+
>>> result = thread.get()
|
|
4817
|
+
|
|
4818
|
+
:param async_req bool
|
|
4819
|
+
:param InstallAppsRequest body: (required)
|
|
4820
|
+
:return: InstallAppsResponse
|
|
4821
|
+
If the method is called asynchronously,
|
|
4822
|
+
returns the request thread.
|
|
4823
|
+
"""
|
|
4824
|
+
|
|
4825
|
+
all_params = ['body'] # noqa: E501
|
|
4826
|
+
all_params.append('async_req')
|
|
4827
|
+
all_params.append('_return_http_data_only')
|
|
4828
|
+
all_params.append('_preload_content')
|
|
4829
|
+
all_params.append('_request_timeout')
|
|
4830
|
+
|
|
4831
|
+
params = locals()
|
|
4832
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
4833
|
+
if key not in all_params:
|
|
4834
|
+
raise TypeError(
|
|
4835
|
+
"Got an unexpected keyword argument '%s'"
|
|
4836
|
+
" to method install_apps" % key
|
|
4837
|
+
)
|
|
4838
|
+
params[key] = val
|
|
4839
|
+
del params['kwargs']
|
|
4840
|
+
# verify the required parameter 'body' is set
|
|
4841
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
4842
|
+
params['body'] is None): # noqa: E501
|
|
4843
|
+
raise ValueError("Missing the required parameter `body` when calling `install_apps`") # noqa: E501
|
|
4844
|
+
|
|
4845
|
+
collection_formats = {}
|
|
4846
|
+
|
|
4847
|
+
path_params = {}
|
|
4848
|
+
|
|
4849
|
+
query_params = []
|
|
4850
|
+
|
|
4851
|
+
header_params = {}
|
|
4852
|
+
|
|
4853
|
+
form_params = []
|
|
4854
|
+
local_var_files = {}
|
|
4855
|
+
|
|
4856
|
+
body_params = None
|
|
4857
|
+
if 'body' in params:
|
|
4858
|
+
body_params = params['body']
|
|
4859
|
+
# HTTP header `Accept`
|
|
4860
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
4861
|
+
['application/json']) # noqa: E501
|
|
4862
|
+
|
|
4863
|
+
# HTTP header `Content-Type`
|
|
4864
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
4865
|
+
['application/json']) # noqa: E501
|
|
4866
|
+
|
|
4867
|
+
# Authentication setting
|
|
4868
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
4869
|
+
|
|
4870
|
+
return self.api_client.call_api(
|
|
4871
|
+
'/InstallApps/2025-05-01/acep/post/application_json/', 'POST',
|
|
4872
|
+
path_params,
|
|
4873
|
+
query_params,
|
|
4874
|
+
header_params,
|
|
4875
|
+
body=body_params,
|
|
4876
|
+
post_params=form_params,
|
|
4877
|
+
files=local_var_files,
|
|
4878
|
+
response_type='InstallAppsResponse', # noqa: E501
|
|
4879
|
+
auth_settings=auth_settings,
|
|
4880
|
+
async_req=params.get('async_req'),
|
|
4881
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
4882
|
+
_preload_content=params.get('_preload_content', True),
|
|
4883
|
+
_request_timeout=params.get('_request_timeout'),
|
|
4884
|
+
collection_formats=collection_formats)
|
|
4885
|
+
|
|
4886
|
+
def launch_app(self, body, **kwargs): # noqa: E501
|
|
4887
|
+
"""launch_app # noqa: E501
|
|
4888
|
+
|
|
4889
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
4890
|
+
asynchronous HTTP request, please pass async_req=True
|
|
4891
|
+
>>> thread = api.launch_app(body, async_req=True)
|
|
4407
4892
|
>>> result = thread.get()
|
|
4408
4893
|
|
|
4409
4894
|
:param async_req bool
|
|
4410
|
-
:param
|
|
4411
|
-
:return:
|
|
4895
|
+
:param LaunchAppRequest body: (required)
|
|
4896
|
+
:return: LaunchAppResponse
|
|
4412
4897
|
If the method is called asynchronously,
|
|
4413
4898
|
returns the request thread.
|
|
4414
4899
|
"""
|
|
4415
4900
|
kwargs['_return_http_data_only'] = True
|
|
4416
4901
|
if kwargs.get('async_req'):
|
|
4417
|
-
return self.
|
|
4902
|
+
return self.launch_app_with_http_info(body, **kwargs) # noqa: E501
|
|
4418
4903
|
else:
|
|
4419
|
-
(data) = self.
|
|
4904
|
+
(data) = self.launch_app_with_http_info(body, **kwargs) # noqa: E501
|
|
4420
4905
|
return data
|
|
4421
4906
|
|
|
4422
|
-
def
|
|
4423
|
-
"""
|
|
4907
|
+
def launch_app_with_http_info(self, body, **kwargs): # noqa: E501
|
|
4908
|
+
"""launch_app # noqa: E501
|
|
4424
4909
|
|
|
4425
4910
|
This method makes a synchronous HTTP request by default. To make an
|
|
4426
4911
|
asynchronous HTTP request, please pass async_req=True
|
|
4427
|
-
>>> thread = api.
|
|
4912
|
+
>>> thread = api.launch_app_with_http_info(body, async_req=True)
|
|
4428
4913
|
>>> result = thread.get()
|
|
4429
4914
|
|
|
4430
4915
|
:param async_req bool
|
|
4431
|
-
:param
|
|
4432
|
-
:return:
|
|
4916
|
+
:param LaunchAppRequest body: (required)
|
|
4917
|
+
:return: LaunchAppResponse
|
|
4433
4918
|
If the method is called asynchronously,
|
|
4434
4919
|
returns the request thread.
|
|
4435
4920
|
"""
|
|
@@ -4445,14 +4930,14 @@ class ACEPApi(object):
|
|
|
4445
4930
|
if key not in all_params:
|
|
4446
4931
|
raise TypeError(
|
|
4447
4932
|
"Got an unexpected keyword argument '%s'"
|
|
4448
|
-
" to method
|
|
4933
|
+
" to method launch_app" % key
|
|
4449
4934
|
)
|
|
4450
4935
|
params[key] = val
|
|
4451
4936
|
del params['kwargs']
|
|
4452
4937
|
# verify the required parameter 'body' is set
|
|
4453
4938
|
if self.api_client.client_side_validation and ('body' not in params or
|
|
4454
4939
|
params['body'] is None): # noqa: E501
|
|
4455
|
-
raise ValueError("Missing the required parameter `body` when calling `
|
|
4940
|
+
raise ValueError("Missing the required parameter `body` when calling `launch_app`") # noqa: E501
|
|
4456
4941
|
|
|
4457
4942
|
collection_formats = {}
|
|
4458
4943
|
|
|
@@ -4480,14 +4965,14 @@ class ACEPApi(object):
|
|
|
4480
4965
|
auth_settings = ['volcengineSign'] # noqa: E501
|
|
4481
4966
|
|
|
4482
4967
|
return self.api_client.call_api(
|
|
4483
|
-
'/
|
|
4968
|
+
'/LaunchApp/2025-05-01/acep/post/application_json/', 'POST',
|
|
4484
4969
|
path_params,
|
|
4485
4970
|
query_params,
|
|
4486
4971
|
header_params,
|
|
4487
4972
|
body=body_params,
|
|
4488
4973
|
post_params=form_params,
|
|
4489
4974
|
files=local_var_files,
|
|
4490
|
-
response_type='
|
|
4975
|
+
response_type='LaunchAppResponse', # noqa: E501
|
|
4491
4976
|
auth_settings=auth_settings,
|
|
4492
4977
|
async_req=params.get('async_req'),
|
|
4493
4978
|
_return_http_data_only=params.get('_return_http_data_only'),
|
|
@@ -4495,38 +4980,38 @@ class ACEPApi(object):
|
|
|
4495
4980
|
_request_timeout=params.get('_request_timeout'),
|
|
4496
4981
|
collection_formats=collection_formats)
|
|
4497
4982
|
|
|
4498
|
-
def
|
|
4499
|
-
"""
|
|
4983
|
+
def launch_apps(self, body, **kwargs): # noqa: E501
|
|
4984
|
+
"""launch_apps # noqa: E501
|
|
4500
4985
|
|
|
4501
4986
|
This method makes a synchronous HTTP request by default. To make an
|
|
4502
4987
|
asynchronous HTTP request, please pass async_req=True
|
|
4503
|
-
>>> thread = api.
|
|
4988
|
+
>>> thread = api.launch_apps(body, async_req=True)
|
|
4504
4989
|
>>> result = thread.get()
|
|
4505
4990
|
|
|
4506
4991
|
:param async_req bool
|
|
4507
|
-
:param
|
|
4508
|
-
:return:
|
|
4992
|
+
:param LaunchAppsRequest body: (required)
|
|
4993
|
+
:return: LaunchAppsResponse
|
|
4509
4994
|
If the method is called asynchronously,
|
|
4510
4995
|
returns the request thread.
|
|
4511
4996
|
"""
|
|
4512
4997
|
kwargs['_return_http_data_only'] = True
|
|
4513
4998
|
if kwargs.get('async_req'):
|
|
4514
|
-
return self.
|
|
4999
|
+
return self.launch_apps_with_http_info(body, **kwargs) # noqa: E501
|
|
4515
5000
|
else:
|
|
4516
|
-
(data) = self.
|
|
5001
|
+
(data) = self.launch_apps_with_http_info(body, **kwargs) # noqa: E501
|
|
4517
5002
|
return data
|
|
4518
5003
|
|
|
4519
|
-
def
|
|
4520
|
-
"""
|
|
5004
|
+
def launch_apps_with_http_info(self, body, **kwargs): # noqa: E501
|
|
5005
|
+
"""launch_apps # noqa: E501
|
|
4521
5006
|
|
|
4522
5007
|
This method makes a synchronous HTTP request by default. To make an
|
|
4523
5008
|
asynchronous HTTP request, please pass async_req=True
|
|
4524
|
-
>>> thread = api.
|
|
5009
|
+
>>> thread = api.launch_apps_with_http_info(body, async_req=True)
|
|
4525
5010
|
>>> result = thread.get()
|
|
4526
5011
|
|
|
4527
5012
|
:param async_req bool
|
|
4528
|
-
:param
|
|
4529
|
-
:return:
|
|
5013
|
+
:param LaunchAppsRequest body: (required)
|
|
5014
|
+
:return: LaunchAppsResponse
|
|
4530
5015
|
If the method is called asynchronously,
|
|
4531
5016
|
returns the request thread.
|
|
4532
5017
|
"""
|
|
@@ -4542,14 +5027,14 @@ class ACEPApi(object):
|
|
|
4542
5027
|
if key not in all_params:
|
|
4543
5028
|
raise TypeError(
|
|
4544
5029
|
"Got an unexpected keyword argument '%s'"
|
|
4545
|
-
" to method
|
|
5030
|
+
" to method launch_apps" % key
|
|
4546
5031
|
)
|
|
4547
5032
|
params[key] = val
|
|
4548
5033
|
del params['kwargs']
|
|
4549
5034
|
# verify the required parameter 'body' is set
|
|
4550
5035
|
if self.api_client.client_side_validation and ('body' not in params or
|
|
4551
5036
|
params['body'] is None): # noqa: E501
|
|
4552
|
-
raise ValueError("Missing the required parameter `body` when calling `
|
|
5037
|
+
raise ValueError("Missing the required parameter `body` when calling `launch_apps`") # noqa: E501
|
|
4553
5038
|
|
|
4554
5039
|
collection_formats = {}
|
|
4555
5040
|
|
|
@@ -4577,14 +5062,14 @@ class ACEPApi(object):
|
|
|
4577
5062
|
auth_settings = ['volcengineSign'] # noqa: E501
|
|
4578
5063
|
|
|
4579
5064
|
return self.api_client.call_api(
|
|
4580
|
-
'/
|
|
5065
|
+
'/LaunchApps/2025-05-01/acep/post/application_json/', 'POST',
|
|
4581
5066
|
path_params,
|
|
4582
5067
|
query_params,
|
|
4583
5068
|
header_params,
|
|
4584
5069
|
body=body_params,
|
|
4585
5070
|
post_params=form_params,
|
|
4586
5071
|
files=local_var_files,
|
|
4587
|
-
response_type='
|
|
5072
|
+
response_type='LaunchAppsResponse', # noqa: E501
|
|
4588
5073
|
auth_settings=auth_settings,
|
|
4589
5074
|
async_req=params.get('async_req'),
|
|
4590
5075
|
_return_http_data_only=params.get('_return_http_data_only'),
|
|
@@ -4592,38 +5077,38 @@ class ACEPApi(object):
|
|
|
4592
5077
|
_request_timeout=params.get('_request_timeout'),
|
|
4593
5078
|
collection_formats=collection_formats)
|
|
4594
5079
|
|
|
4595
|
-
def
|
|
4596
|
-
"""
|
|
5080
|
+
def list_adb_key(self, body, **kwargs): # noqa: E501
|
|
5081
|
+
"""list_adb_key # noqa: E501
|
|
4597
5082
|
|
|
4598
5083
|
This method makes a synchronous HTTP request by default. To make an
|
|
4599
5084
|
asynchronous HTTP request, please pass async_req=True
|
|
4600
|
-
>>> thread = api.
|
|
5085
|
+
>>> thread = api.list_adb_key(body, async_req=True)
|
|
4601
5086
|
>>> result = thread.get()
|
|
4602
5087
|
|
|
4603
5088
|
:param async_req bool
|
|
4604
|
-
:param
|
|
4605
|
-
:return:
|
|
5089
|
+
:param ListAdbKeyRequest body: (required)
|
|
5090
|
+
:return: ListAdbKeyResponse
|
|
4606
5091
|
If the method is called asynchronously,
|
|
4607
5092
|
returns the request thread.
|
|
4608
5093
|
"""
|
|
4609
5094
|
kwargs['_return_http_data_only'] = True
|
|
4610
5095
|
if kwargs.get('async_req'):
|
|
4611
|
-
return self.
|
|
5096
|
+
return self.list_adb_key_with_http_info(body, **kwargs) # noqa: E501
|
|
4612
5097
|
else:
|
|
4613
|
-
(data) = self.
|
|
5098
|
+
(data) = self.list_adb_key_with_http_info(body, **kwargs) # noqa: E501
|
|
4614
5099
|
return data
|
|
4615
5100
|
|
|
4616
|
-
def
|
|
4617
|
-
"""
|
|
5101
|
+
def list_adb_key_with_http_info(self, body, **kwargs): # noqa: E501
|
|
5102
|
+
"""list_adb_key # noqa: E501
|
|
4618
5103
|
|
|
4619
5104
|
This method makes a synchronous HTTP request by default. To make an
|
|
4620
5105
|
asynchronous HTTP request, please pass async_req=True
|
|
4621
|
-
>>> thread = api.
|
|
5106
|
+
>>> thread = api.list_adb_key_with_http_info(body, async_req=True)
|
|
4622
5107
|
>>> result = thread.get()
|
|
4623
5108
|
|
|
4624
5109
|
:param async_req bool
|
|
4625
|
-
:param
|
|
4626
|
-
:return:
|
|
5110
|
+
:param ListAdbKeyRequest body: (required)
|
|
5111
|
+
:return: ListAdbKeyResponse
|
|
4627
5112
|
If the method is called asynchronously,
|
|
4628
5113
|
returns the request thread.
|
|
4629
5114
|
"""
|
|
@@ -4639,14 +5124,14 @@ class ACEPApi(object):
|
|
|
4639
5124
|
if key not in all_params:
|
|
4640
5125
|
raise TypeError(
|
|
4641
5126
|
"Got an unexpected keyword argument '%s'"
|
|
4642
|
-
" to method
|
|
5127
|
+
" to method list_adb_key" % key
|
|
4643
5128
|
)
|
|
4644
5129
|
params[key] = val
|
|
4645
5130
|
del params['kwargs']
|
|
4646
5131
|
# verify the required parameter 'body' is set
|
|
4647
5132
|
if self.api_client.client_side_validation and ('body' not in params or
|
|
4648
5133
|
params['body'] is None): # noqa: E501
|
|
4649
|
-
raise ValueError("Missing the required parameter `body` when calling `
|
|
5134
|
+
raise ValueError("Missing the required parameter `body` when calling `list_adb_key`") # noqa: E501
|
|
4650
5135
|
|
|
4651
5136
|
collection_formats = {}
|
|
4652
5137
|
|
|
@@ -4674,14 +5159,14 @@ class ACEPApi(object):
|
|
|
4674
5159
|
auth_settings = ['volcengineSign'] # noqa: E501
|
|
4675
5160
|
|
|
4676
5161
|
return self.api_client.call_api(
|
|
4677
|
-
'/
|
|
5162
|
+
'/ListAdbKey/2025-05-01/acep/post/application_json/', 'POST',
|
|
4678
5163
|
path_params,
|
|
4679
5164
|
query_params,
|
|
4680
5165
|
header_params,
|
|
4681
5166
|
body=body_params,
|
|
4682
5167
|
post_params=form_params,
|
|
4683
5168
|
files=local_var_files,
|
|
4684
|
-
response_type='
|
|
5169
|
+
response_type='ListAdbKeyResponse', # noqa: E501
|
|
4685
5170
|
auth_settings=auth_settings,
|
|
4686
5171
|
async_req=params.get('async_req'),
|
|
4687
5172
|
_return_http_data_only=params.get('_return_http_data_only'),
|
|
@@ -4689,38 +5174,38 @@ class ACEPApi(object):
|
|
|
4689
5174
|
_request_timeout=params.get('_request_timeout'),
|
|
4690
5175
|
collection_formats=collection_formats)
|
|
4691
5176
|
|
|
4692
|
-
def
|
|
4693
|
-
"""
|
|
5177
|
+
def list_adb_key_pod_bindings(self, body, **kwargs): # noqa: E501
|
|
5178
|
+
"""list_adb_key_pod_bindings # noqa: E501
|
|
4694
5179
|
|
|
4695
5180
|
This method makes a synchronous HTTP request by default. To make an
|
|
4696
5181
|
asynchronous HTTP request, please pass async_req=True
|
|
4697
|
-
>>> thread = api.
|
|
5182
|
+
>>> thread = api.list_adb_key_pod_bindings(body, async_req=True)
|
|
4698
5183
|
>>> result = thread.get()
|
|
4699
5184
|
|
|
4700
5185
|
:param async_req bool
|
|
4701
|
-
:param
|
|
4702
|
-
:return:
|
|
5186
|
+
:param ListAdbKeyPodBindingsRequest body: (required)
|
|
5187
|
+
:return: ListAdbKeyPodBindingsResponse
|
|
4703
5188
|
If the method is called asynchronously,
|
|
4704
5189
|
returns the request thread.
|
|
4705
5190
|
"""
|
|
4706
5191
|
kwargs['_return_http_data_only'] = True
|
|
4707
5192
|
if kwargs.get('async_req'):
|
|
4708
|
-
return self.
|
|
5193
|
+
return self.list_adb_key_pod_bindings_with_http_info(body, **kwargs) # noqa: E501
|
|
4709
5194
|
else:
|
|
4710
|
-
(data) = self.
|
|
5195
|
+
(data) = self.list_adb_key_pod_bindings_with_http_info(body, **kwargs) # noqa: E501
|
|
4711
5196
|
return data
|
|
4712
5197
|
|
|
4713
|
-
def
|
|
4714
|
-
"""
|
|
5198
|
+
def list_adb_key_pod_bindings_with_http_info(self, body, **kwargs): # noqa: E501
|
|
5199
|
+
"""list_adb_key_pod_bindings # noqa: E501
|
|
4715
5200
|
|
|
4716
5201
|
This method makes a synchronous HTTP request by default. To make an
|
|
4717
5202
|
asynchronous HTTP request, please pass async_req=True
|
|
4718
|
-
>>> thread = api.
|
|
5203
|
+
>>> thread = api.list_adb_key_pod_bindings_with_http_info(body, async_req=True)
|
|
4719
5204
|
>>> result = thread.get()
|
|
4720
5205
|
|
|
4721
5206
|
:param async_req bool
|
|
4722
|
-
:param
|
|
4723
|
-
:return:
|
|
5207
|
+
:param ListAdbKeyPodBindingsRequest body: (required)
|
|
5208
|
+
:return: ListAdbKeyPodBindingsResponse
|
|
4724
5209
|
If the method is called asynchronously,
|
|
4725
5210
|
returns the request thread.
|
|
4726
5211
|
"""
|
|
@@ -4736,14 +5221,14 @@ class ACEPApi(object):
|
|
|
4736
5221
|
if key not in all_params:
|
|
4737
5222
|
raise TypeError(
|
|
4738
5223
|
"Got an unexpected keyword argument '%s'"
|
|
4739
|
-
" to method
|
|
5224
|
+
" to method list_adb_key_pod_bindings" % key
|
|
4740
5225
|
)
|
|
4741
5226
|
params[key] = val
|
|
4742
5227
|
del params['kwargs']
|
|
4743
5228
|
# verify the required parameter 'body' is set
|
|
4744
5229
|
if self.api_client.client_side_validation and ('body' not in params or
|
|
4745
5230
|
params['body'] is None): # noqa: E501
|
|
4746
|
-
raise ValueError("Missing the required parameter `body` when calling `
|
|
5231
|
+
raise ValueError("Missing the required parameter `body` when calling `list_adb_key_pod_bindings`") # noqa: E501
|
|
4747
5232
|
|
|
4748
5233
|
collection_formats = {}
|
|
4749
5234
|
|
|
@@ -4771,14 +5256,14 @@ class ACEPApi(object):
|
|
|
4771
5256
|
auth_settings = ['volcengineSign'] # noqa: E501
|
|
4772
5257
|
|
|
4773
5258
|
return self.api_client.call_api(
|
|
4774
|
-
'/
|
|
5259
|
+
'/ListAdbKeyPodBindings/2025-05-01/acep/post/application_json/', 'POST',
|
|
4775
5260
|
path_params,
|
|
4776
5261
|
query_params,
|
|
4777
5262
|
header_params,
|
|
4778
5263
|
body=body_params,
|
|
4779
5264
|
post_params=form_params,
|
|
4780
5265
|
files=local_var_files,
|
|
4781
|
-
response_type='
|
|
5266
|
+
response_type='ListAdbKeyPodBindingsResponse', # noqa: E501
|
|
4782
5267
|
auth_settings=auth_settings,
|
|
4783
5268
|
async_req=params.get('async_req'),
|
|
4784
5269
|
_return_http_data_only=params.get('_return_http_data_only'),
|
|
@@ -9054,6 +9539,103 @@ class ACEPApi(object):
|
|
|
9054
9539
|
_request_timeout=params.get('_request_timeout'),
|
|
9055
9540
|
collection_formats=collection_formats)
|
|
9056
9541
|
|
|
9542
|
+
def unbind_adb_key_pods(self, body, **kwargs): # noqa: E501
|
|
9543
|
+
"""unbind_adb_key_pods # noqa: E501
|
|
9544
|
+
|
|
9545
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
9546
|
+
asynchronous HTTP request, please pass async_req=True
|
|
9547
|
+
>>> thread = api.unbind_adb_key_pods(body, async_req=True)
|
|
9548
|
+
>>> result = thread.get()
|
|
9549
|
+
|
|
9550
|
+
:param async_req bool
|
|
9551
|
+
:param UnbindAdbKeyPodsRequest body: (required)
|
|
9552
|
+
:return: UnbindAdbKeyPodsResponse
|
|
9553
|
+
If the method is called asynchronously,
|
|
9554
|
+
returns the request thread.
|
|
9555
|
+
"""
|
|
9556
|
+
kwargs['_return_http_data_only'] = True
|
|
9557
|
+
if kwargs.get('async_req'):
|
|
9558
|
+
return self.unbind_adb_key_pods_with_http_info(body, **kwargs) # noqa: E501
|
|
9559
|
+
else:
|
|
9560
|
+
(data) = self.unbind_adb_key_pods_with_http_info(body, **kwargs) # noqa: E501
|
|
9561
|
+
return data
|
|
9562
|
+
|
|
9563
|
+
def unbind_adb_key_pods_with_http_info(self, body, **kwargs): # noqa: E501
|
|
9564
|
+
"""unbind_adb_key_pods # noqa: E501
|
|
9565
|
+
|
|
9566
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
9567
|
+
asynchronous HTTP request, please pass async_req=True
|
|
9568
|
+
>>> thread = api.unbind_adb_key_pods_with_http_info(body, async_req=True)
|
|
9569
|
+
>>> result = thread.get()
|
|
9570
|
+
|
|
9571
|
+
:param async_req bool
|
|
9572
|
+
:param UnbindAdbKeyPodsRequest body: (required)
|
|
9573
|
+
:return: UnbindAdbKeyPodsResponse
|
|
9574
|
+
If the method is called asynchronously,
|
|
9575
|
+
returns the request thread.
|
|
9576
|
+
"""
|
|
9577
|
+
|
|
9578
|
+
all_params = ['body'] # noqa: E501
|
|
9579
|
+
all_params.append('async_req')
|
|
9580
|
+
all_params.append('_return_http_data_only')
|
|
9581
|
+
all_params.append('_preload_content')
|
|
9582
|
+
all_params.append('_request_timeout')
|
|
9583
|
+
|
|
9584
|
+
params = locals()
|
|
9585
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
9586
|
+
if key not in all_params:
|
|
9587
|
+
raise TypeError(
|
|
9588
|
+
"Got an unexpected keyword argument '%s'"
|
|
9589
|
+
" to method unbind_adb_key_pods" % key
|
|
9590
|
+
)
|
|
9591
|
+
params[key] = val
|
|
9592
|
+
del params['kwargs']
|
|
9593
|
+
# verify the required parameter 'body' is set
|
|
9594
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
9595
|
+
params['body'] is None): # noqa: E501
|
|
9596
|
+
raise ValueError("Missing the required parameter `body` when calling `unbind_adb_key_pods`") # noqa: E501
|
|
9597
|
+
|
|
9598
|
+
collection_formats = {}
|
|
9599
|
+
|
|
9600
|
+
path_params = {}
|
|
9601
|
+
|
|
9602
|
+
query_params = []
|
|
9603
|
+
|
|
9604
|
+
header_params = {}
|
|
9605
|
+
|
|
9606
|
+
form_params = []
|
|
9607
|
+
local_var_files = {}
|
|
9608
|
+
|
|
9609
|
+
body_params = None
|
|
9610
|
+
if 'body' in params:
|
|
9611
|
+
body_params = params['body']
|
|
9612
|
+
# HTTP header `Accept`
|
|
9613
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
9614
|
+
['application/json']) # noqa: E501
|
|
9615
|
+
|
|
9616
|
+
# HTTP header `Content-Type`
|
|
9617
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
9618
|
+
['application/json']) # noqa: E501
|
|
9619
|
+
|
|
9620
|
+
# Authentication setting
|
|
9621
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
9622
|
+
|
|
9623
|
+
return self.api_client.call_api(
|
|
9624
|
+
'/UnbindAdbKeyPods/2025-05-01/acep/post/application_json/', 'POST',
|
|
9625
|
+
path_params,
|
|
9626
|
+
query_params,
|
|
9627
|
+
header_params,
|
|
9628
|
+
body=body_params,
|
|
9629
|
+
post_params=form_params,
|
|
9630
|
+
files=local_var_files,
|
|
9631
|
+
response_type='UnbindAdbKeyPodsResponse', # noqa: E501
|
|
9632
|
+
auth_settings=auth_settings,
|
|
9633
|
+
async_req=params.get('async_req'),
|
|
9634
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
9635
|
+
_preload_content=params.get('_preload_content', True),
|
|
9636
|
+
_request_timeout=params.get('_request_timeout'),
|
|
9637
|
+
collection_formats=collection_formats)
|
|
9638
|
+
|
|
9057
9639
|
def unbind_port_mapping_rule(self, body, **kwargs): # noqa: E501
|
|
9058
9640
|
"""unbind_port_mapping_rule # noqa: E501
|
|
9059
9641
|
|
|
@@ -9345,6 +9927,103 @@ class ACEPApi(object):
|
|
|
9345
9927
|
_request_timeout=params.get('_request_timeout'),
|
|
9346
9928
|
collection_formats=collection_formats)
|
|
9347
9929
|
|
|
9930
|
+
def update_adb_key(self, body, **kwargs): # noqa: E501
|
|
9931
|
+
"""update_adb_key # noqa: E501
|
|
9932
|
+
|
|
9933
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
9934
|
+
asynchronous HTTP request, please pass async_req=True
|
|
9935
|
+
>>> thread = api.update_adb_key(body, async_req=True)
|
|
9936
|
+
>>> result = thread.get()
|
|
9937
|
+
|
|
9938
|
+
:param async_req bool
|
|
9939
|
+
:param UpdateAdbKeyRequest body: (required)
|
|
9940
|
+
:return: UpdateAdbKeyResponse
|
|
9941
|
+
If the method is called asynchronously,
|
|
9942
|
+
returns the request thread.
|
|
9943
|
+
"""
|
|
9944
|
+
kwargs['_return_http_data_only'] = True
|
|
9945
|
+
if kwargs.get('async_req'):
|
|
9946
|
+
return self.update_adb_key_with_http_info(body, **kwargs) # noqa: E501
|
|
9947
|
+
else:
|
|
9948
|
+
(data) = self.update_adb_key_with_http_info(body, **kwargs) # noqa: E501
|
|
9949
|
+
return data
|
|
9950
|
+
|
|
9951
|
+
def update_adb_key_with_http_info(self, body, **kwargs): # noqa: E501
|
|
9952
|
+
"""update_adb_key # noqa: E501
|
|
9953
|
+
|
|
9954
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
9955
|
+
asynchronous HTTP request, please pass async_req=True
|
|
9956
|
+
>>> thread = api.update_adb_key_with_http_info(body, async_req=True)
|
|
9957
|
+
>>> result = thread.get()
|
|
9958
|
+
|
|
9959
|
+
:param async_req bool
|
|
9960
|
+
:param UpdateAdbKeyRequest body: (required)
|
|
9961
|
+
:return: UpdateAdbKeyResponse
|
|
9962
|
+
If the method is called asynchronously,
|
|
9963
|
+
returns the request thread.
|
|
9964
|
+
"""
|
|
9965
|
+
|
|
9966
|
+
all_params = ['body'] # noqa: E501
|
|
9967
|
+
all_params.append('async_req')
|
|
9968
|
+
all_params.append('_return_http_data_only')
|
|
9969
|
+
all_params.append('_preload_content')
|
|
9970
|
+
all_params.append('_request_timeout')
|
|
9971
|
+
|
|
9972
|
+
params = locals()
|
|
9973
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
9974
|
+
if key not in all_params:
|
|
9975
|
+
raise TypeError(
|
|
9976
|
+
"Got an unexpected keyword argument '%s'"
|
|
9977
|
+
" to method update_adb_key" % key
|
|
9978
|
+
)
|
|
9979
|
+
params[key] = val
|
|
9980
|
+
del params['kwargs']
|
|
9981
|
+
# verify the required parameter 'body' is set
|
|
9982
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
9983
|
+
params['body'] is None): # noqa: E501
|
|
9984
|
+
raise ValueError("Missing the required parameter `body` when calling `update_adb_key`") # noqa: E501
|
|
9985
|
+
|
|
9986
|
+
collection_formats = {}
|
|
9987
|
+
|
|
9988
|
+
path_params = {}
|
|
9989
|
+
|
|
9990
|
+
query_params = []
|
|
9991
|
+
|
|
9992
|
+
header_params = {}
|
|
9993
|
+
|
|
9994
|
+
form_params = []
|
|
9995
|
+
local_var_files = {}
|
|
9996
|
+
|
|
9997
|
+
body_params = None
|
|
9998
|
+
if 'body' in params:
|
|
9999
|
+
body_params = params['body']
|
|
10000
|
+
# HTTP header `Accept`
|
|
10001
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
10002
|
+
['application/json']) # noqa: E501
|
|
10003
|
+
|
|
10004
|
+
# HTTP header `Content-Type`
|
|
10005
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
10006
|
+
['application/json']) # noqa: E501
|
|
10007
|
+
|
|
10008
|
+
# Authentication setting
|
|
10009
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
10010
|
+
|
|
10011
|
+
return self.api_client.call_api(
|
|
10012
|
+
'/UpdateAdbKey/2025-05-01/acep/post/application_json/', 'POST',
|
|
10013
|
+
path_params,
|
|
10014
|
+
query_params,
|
|
10015
|
+
header_params,
|
|
10016
|
+
body=body_params,
|
|
10017
|
+
post_params=form_params,
|
|
10018
|
+
files=local_var_files,
|
|
10019
|
+
response_type='UpdateAdbKeyResponse', # noqa: E501
|
|
10020
|
+
auth_settings=auth_settings,
|
|
10021
|
+
async_req=params.get('async_req'),
|
|
10022
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
10023
|
+
_preload_content=params.get('_preload_content', True),
|
|
10024
|
+
_request_timeout=params.get('_request_timeout'),
|
|
10025
|
+
collection_formats=collection_formats)
|
|
10026
|
+
|
|
9348
10027
|
def update_aosp_image(self, body, **kwargs): # noqa: E501
|
|
9349
10028
|
"""update_aosp_image # noqa: E501
|
|
9350
10029
|
|