@@ -130,6 +130,200 @@ def attach_mount_service_to_self_file_system_with_http_info(self, body, **kwargs
130130 _request_timeout = params .get ('_request_timeout' ),
131131 collection_formats = collection_formats )
132132
133+ def config_data_flow_bandwidth (self , body , ** kwargs ): # noqa: E501
134+ """config_data_flow_bandwidth # noqa: E501
135+
136+ This method makes a synchronous HTTP request by default. To make an
137+ asynchronous HTTP request, please pass async_req=True
138+ >>> thread = api.config_data_flow_bandwidth(body, async_req=True)
139+ >>> result = thread.get()
140+
141+ :param async_req bool
142+ :param ConfigDataFlowBandwidthRequest body: (required)
143+ :return: ConfigDataFlowBandwidthResponse
144+ If the method is called asynchronously,
145+ returns the request thread.
146+ """
147+ kwargs ['_return_http_data_only' ] = True
148+ if kwargs .get ('async_req' ):
149+ return self .config_data_flow_bandwidth_with_http_info (body , ** kwargs ) # noqa: E501
150+ else :
151+ (data ) = self .config_data_flow_bandwidth_with_http_info (body , ** kwargs ) # noqa: E501
152+ return data
153+
154+ def config_data_flow_bandwidth_with_http_info (self , body , ** kwargs ): # noqa: E501
155+ """config_data_flow_bandwidth # noqa: E501
156+
157+ This method makes a synchronous HTTP request by default. To make an
158+ asynchronous HTTP request, please pass async_req=True
159+ >>> thread = api.config_data_flow_bandwidth_with_http_info(body, async_req=True)
160+ >>> result = thread.get()
161+
162+ :param async_req bool
163+ :param ConfigDataFlowBandwidthRequest body: (required)
164+ :return: ConfigDataFlowBandwidthResponse
165+ If the method is called asynchronously,
166+ returns the request thread.
167+ """
168+
169+ all_params = ['body' ] # noqa: E501
170+ all_params .append ('async_req' )
171+ all_params .append ('_return_http_data_only' )
172+ all_params .append ('_preload_content' )
173+ all_params .append ('_request_timeout' )
174+
175+ params = locals ()
176+ for key , val in six .iteritems (params ['kwargs' ]):
177+ if key not in all_params :
178+ raise TypeError (
179+ "Got an unexpected keyword argument '%s'"
180+ " to method config_data_flow_bandwidth" % key
181+ )
182+ params [key ] = val
183+ del params ['kwargs' ]
184+ # verify the required parameter 'body' is set
185+ if self .api_client .client_side_validation and ('body' not in params or
186+ params ['body' ] is None ): # noqa: E501
187+ raise ValueError ("Missing the required parameter `body` when calling `config_data_flow_bandwidth`" ) # noqa: E501
188+
189+ collection_formats = {}
190+
191+ path_params = {}
192+
193+ query_params = []
194+
195+ header_params = {}
196+
197+ form_params = []
198+ local_var_files = {}
199+
200+ body_params = None
201+ if 'body' in params :
202+ body_params = params ['body' ]
203+ # HTTP header `Accept`
204+ header_params ['Accept' ] = self .api_client .select_header_accept (
205+ ['application/json' ]) # noqa: E501
206+
207+ # HTTP header `Content-Type`
208+ header_params ['Content-Type' ] = self .api_client .select_header_content_type ( # noqa: E501
209+ ['application/json' ]) # noqa: E501
210+
211+ # Authentication setting
212+ auth_settings = ['volcengineSign' ] # noqa: E501
213+
214+ return self .api_client .call_api (
215+ '/ConfigDataFlowBandwidth/2022-01-01/vepfs/post/application_json/' , 'POST' ,
216+ path_params ,
217+ query_params ,
218+ header_params ,
219+ body = body_params ,
220+ post_params = form_params ,
221+ files = local_var_files ,
222+ response_type = 'ConfigDataFlowBandwidthResponse' , # noqa: E501
223+ auth_settings = auth_settings ,
224+ async_req = params .get ('async_req' ),
225+ _return_http_data_only = params .get ('_return_http_data_only' ),
226+ _preload_content = params .get ('_preload_content' , True ),
227+ _request_timeout = params .get ('_request_timeout' ),
228+ collection_formats = collection_formats )
229+
230+ def create_data_flow_task (self , body , ** kwargs ): # noqa: E501
231+ """create_data_flow_task # noqa: E501
232+
233+ This method makes a synchronous HTTP request by default. To make an
234+ asynchronous HTTP request, please pass async_req=True
235+ >>> thread = api.create_data_flow_task(body, async_req=True)
236+ >>> result = thread.get()
237+
238+ :param async_req bool
239+ :param CreateDataFlowTaskRequest body: (required)
240+ :return: CreateDataFlowTaskResponse
241+ If the method is called asynchronously,
242+ returns the request thread.
243+ """
244+ kwargs ['_return_http_data_only' ] = True
245+ if kwargs .get ('async_req' ):
246+ return self .create_data_flow_task_with_http_info (body , ** kwargs ) # noqa: E501
247+ else :
248+ (data ) = self .create_data_flow_task_with_http_info (body , ** kwargs ) # noqa: E501
249+ return data
250+
251+ def create_data_flow_task_with_http_info (self , body , ** kwargs ): # noqa: E501
252+ """create_data_flow_task # noqa: E501
253+
254+ This method makes a synchronous HTTP request by default. To make an
255+ asynchronous HTTP request, please pass async_req=True
256+ >>> thread = api.create_data_flow_task_with_http_info(body, async_req=True)
257+ >>> result = thread.get()
258+
259+ :param async_req bool
260+ :param CreateDataFlowTaskRequest body: (required)
261+ :return: CreateDataFlowTaskResponse
262+ If the method is called asynchronously,
263+ returns the request thread.
264+ """
265+
266+ all_params = ['body' ] # noqa: E501
267+ all_params .append ('async_req' )
268+ all_params .append ('_return_http_data_only' )
269+ all_params .append ('_preload_content' )
270+ all_params .append ('_request_timeout' )
271+
272+ params = locals ()
273+ for key , val in six .iteritems (params ['kwargs' ]):
274+ if key not in all_params :
275+ raise TypeError (
276+ "Got an unexpected keyword argument '%s'"
277+ " to method create_data_flow_task" % key
278+ )
279+ params [key ] = val
280+ del params ['kwargs' ]
281+ # verify the required parameter 'body' is set
282+ if self .api_client .client_side_validation and ('body' not in params or
283+ params ['body' ] is None ): # noqa: E501
284+ raise ValueError ("Missing the required parameter `body` when calling `create_data_flow_task`" ) # noqa: E501
285+
286+ collection_formats = {}
287+
288+ path_params = {}
289+
290+ query_params = []
291+
292+ header_params = {}
293+
294+ form_params = []
295+ local_var_files = {}
296+
297+ body_params = None
298+ if 'body' in params :
299+ body_params = params ['body' ]
300+ # HTTP header `Accept`
301+ header_params ['Accept' ] = self .api_client .select_header_accept (
302+ ['application/json' ]) # noqa: E501
303+
304+ # HTTP header `Content-Type`
305+ header_params ['Content-Type' ] = self .api_client .select_header_content_type ( # noqa: E501
306+ ['application/json' ]) # noqa: E501
307+
308+ # Authentication setting
309+ auth_settings = ['volcengineSign' ] # noqa: E501
310+
311+ return self .api_client .call_api (
312+ '/CreateDataFlowTask/2022-01-01/vepfs/post/application_json/' , 'POST' ,
313+ path_params ,
314+ query_params ,
315+ header_params ,
316+ body = body_params ,
317+ post_params = form_params ,
318+ files = local_var_files ,
319+ response_type = 'CreateDataFlowTaskResponse' , # noqa: E501
320+ auth_settings = auth_settings ,
321+ async_req = params .get ('async_req' ),
322+ _return_http_data_only = params .get ('_return_http_data_only' ),
323+ _preload_content = params .get ('_preload_content' , True ),
324+ _request_timeout = params .get ('_request_timeout' ),
325+ collection_formats = collection_formats )
326+
133327 def create_file_system (self , body , ** kwargs ): # noqa: E501
134328 """create_file_system # noqa: E501
135329
@@ -421,6 +615,103 @@ def create_mount_service_with_http_info(self, body, **kwargs): # noqa: E501
421615 _request_timeout = params .get ('_request_timeout' ),
422616 collection_formats = collection_formats )
423617
618+ def create_pre_signed_url (self , body , ** kwargs ): # noqa: E501
619+ """create_pre_signed_url # noqa: E501
620+
621+ This method makes a synchronous HTTP request by default. To make an
622+ asynchronous HTTP request, please pass async_req=True
623+ >>> thread = api.create_pre_signed_url(body, async_req=True)
624+ >>> result = thread.get()
625+
626+ :param async_req bool
627+ :param CreatePreSignedUrlRequest body: (required)
628+ :return: CreatePreSignedUrlResponse
629+ If the method is called asynchronously,
630+ returns the request thread.
631+ """
632+ kwargs ['_return_http_data_only' ] = True
633+ if kwargs .get ('async_req' ):
634+ return self .create_pre_signed_url_with_http_info (body , ** kwargs ) # noqa: E501
635+ else :
636+ (data ) = self .create_pre_signed_url_with_http_info (body , ** kwargs ) # noqa: E501
637+ return data
638+
639+ def create_pre_signed_url_with_http_info (self , body , ** kwargs ): # noqa: E501
640+ """create_pre_signed_url # noqa: E501
641+
642+ This method makes a synchronous HTTP request by default. To make an
643+ asynchronous HTTP request, please pass async_req=True
644+ >>> thread = api.create_pre_signed_url_with_http_info(body, async_req=True)
645+ >>> result = thread.get()
646+
647+ :param async_req bool
648+ :param CreatePreSignedUrlRequest body: (required)
649+ :return: CreatePreSignedUrlResponse
650+ If the method is called asynchronously,
651+ returns the request thread.
652+ """
653+
654+ all_params = ['body' ] # noqa: E501
655+ all_params .append ('async_req' )
656+ all_params .append ('_return_http_data_only' )
657+ all_params .append ('_preload_content' )
658+ all_params .append ('_request_timeout' )
659+
660+ params = locals ()
661+ for key , val in six .iteritems (params ['kwargs' ]):
662+ if key not in all_params :
663+ raise TypeError (
664+ "Got an unexpected keyword argument '%s'"
665+ " to method create_pre_signed_url" % key
666+ )
667+ params [key ] = val
668+ del params ['kwargs' ]
669+ # verify the required parameter 'body' is set
670+ if self .api_client .client_side_validation and ('body' not in params or
671+ params ['body' ] is None ): # noqa: E501
672+ raise ValueError ("Missing the required parameter `body` when calling `create_pre_signed_url`" ) # noqa: E501
673+
674+ collection_formats = {}
675+
676+ path_params = {}
677+
678+ query_params = []
679+
680+ header_params = {}
681+
682+ form_params = []
683+ local_var_files = {}
684+
685+ body_params = None
686+ if 'body' in params :
687+ body_params = params ['body' ]
688+ # HTTP header `Accept`
689+ header_params ['Accept' ] = self .api_client .select_header_accept (
690+ ['application/json' ]) # noqa: E501
691+
692+ # HTTP header `Content-Type`
693+ header_params ['Content-Type' ] = self .api_client .select_header_content_type ( # noqa: E501
694+ ['application/json' ]) # noqa: E501
695+
696+ # Authentication setting
697+ auth_settings = ['volcengineSign' ] # noqa: E501
698+
699+ return self .api_client .call_api (
700+ '/CreatePreSignedUrl/2022-01-01/vepfs/post/application_json/' , 'POST' ,
701+ path_params ,
702+ query_params ,
703+ header_params ,
704+ body = body_params ,
705+ post_params = form_params ,
706+ files = local_var_files ,
707+ response_type = 'CreatePreSignedUrlResponse' , # noqa: E501
708+ auth_settings = auth_settings ,
709+ async_req = params .get ('async_req' ),
710+ _return_http_data_only = params .get ('_return_http_data_only' ),
711+ _preload_content = params .get ('_preload_content' , True ),
712+ _request_timeout = params .get ('_request_timeout' ),
713+ collection_formats = collection_formats )
714+
424715 def delete_file_system (self , body , ** kwargs ): # noqa: E501
425716 """delete_file_system # noqa: E501
426717
0 commit comments