def get_task_instance_with_http_info(self, dag_id, dag_run_id, task_id, **kwargs): # noqa: E501 """Get a task instance # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_task_instance_with_http_info(dag_id, dag_run_id, task_id, async_req=True) >>> result = thread.get() :param async_req bool: execute request asynchronously :param str dag_id: The DAG ID. (required) :param str dag_run_id: The DAG Run ID. (required) :param str task_id: The Task ID. (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(TaskInstance, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread. """ local_var_params = locals() all_params = ['dag_id', 'dag_run_id', 'task_id'] all_params.extend([ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout' ]) for key, val in six.iteritems(local_var_params['kwargs']): if key not in all_params: raise ApiTypeError("Got an unexpected keyword argument '%s'" " to method get_task_instance" % key) local_var_params[key] = val del local_var_params['kwargs'] # verify the required parameter 'dag_id' is set if self.api_client.client_side_validation and ( 'dag_id' not in local_var_params or # noqa: E501 local_var_params['dag_id'] is None): # noqa: E501 raise ApiValueError( "Missing the required parameter `dag_id` when calling `get_task_instance`" ) # noqa: E501 # verify the required parameter 'dag_run_id' is set if self.api_client.client_side_validation and ( 'dag_run_id' not in local_var_params or # noqa: E501 local_var_params['dag_run_id'] is None): # noqa: E501 raise ApiValueError( "Missing the required parameter `dag_run_id` when calling `get_task_instance`" ) # noqa: E501 # verify the required parameter 'task_id' is set if self.api_client.client_side_validation and ( 'task_id' not in local_var_params or # noqa: E501 local_var_params['task_id'] is None): # noqa: E501 raise ApiValueError( "Missing the required parameter `task_id` when calling `get_task_instance`" ) # noqa: E501 collection_formats = {} path_params = {} if 'dag_id' in local_var_params: path_params['dag_id'] = local_var_params['dag_id'] # noqa: E501 if 'dag_run_id' in local_var_params: path_params['dag_run_id'] = local_var_params[ 'dag_run_id'] # noqa: E501 if 'task_id' in local_var_params: path_params['task_id'] = local_var_params['task_id'] # noqa: E501 query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # Authentication setting auth_settings = [] # noqa: E501 return self.api_client.call_api( '/dags/{dag_id}/dagRuns/{dag_run_id}/taskInstances/{task_id}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='TaskInstance', # noqa: E501 auth_settings=auth_settings, async_req=local_var_params.get('async_req'), _return_http_data_only=local_var_params.get( '_return_http_data_only'), # noqa: E501 _preload_content=local_var_params.get('_preload_content', True), _request_timeout=local_var_params.get('_request_timeout'), collection_formats=collection_formats)
def get_dag_source_with_http_info(self, file_token, **kwargs): # noqa: E501 """Get source code using file token # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_dag_source_with_http_info(file_token, async_req=True) >>> result = thread.get() :param async_req bool: execute request asynchronously :param str file_token: The key containing the encrypted path to the file. Encryption and decryption take place only on the server. This prevents the client from reading an non-DAG file. This also ensures API extensibility, because the format of encrypted data may change. (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(InlineResponse2001, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread. """ local_var_params = locals() all_params = [ 'file_token' ] all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout' ] ) for key, val in six.iteritems(local_var_params['kwargs']): if key not in all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_dag_source" % key ) local_var_params[key] = val del local_var_params['kwargs'] # verify the required parameter 'file_token' is set if self.api_client.client_side_validation and ('file_token' not in local_var_params or # noqa: E501 local_var_params['file_token'] is None): # noqa: E501 raise ApiValueError("Missing the required parameter `file_token` when calling `get_dag_source`") # noqa: E501 collection_formats = {} path_params = {} if 'file_token' in local_var_params: path_params['file_token'] = local_var_params['file_token'] # noqa: E501 query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # Authentication setting auth_settings = [] # noqa: E501 return self.api_client.call_api( '/dagSources/{file_token}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='InlineResponse2001', # noqa: E501 auth_settings=auth_settings, async_req=local_var_params.get('async_req'), _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 _preload_content=local_var_params.get('_preload_content', True), _request_timeout=local_var_params.get('_request_timeout'), collection_formats=collection_formats)
def get_event_logs_with_http_info(self, **kwargs): # noqa: E501 """Get all log entries from event log # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_event_logs_with_http_info(async_req=True) >>> result = thread.get() :param async_req bool: execute request asynchronously :param int limit: The numbers of items to return. :param int offset: The number of items to skip before starting to collect the result set. :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(EventLogCollection, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread. """ local_var_params = locals() all_params = ['limit', 'offset'] all_params.extend([ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout' ]) for key, val in six.iteritems(local_var_params['kwargs']): if key not in all_params: raise ApiTypeError("Got an unexpected keyword argument '%s'" " to method get_event_logs" % key) local_var_params[key] = val del local_var_params['kwargs'] if self.api_client.client_side_validation and 'offset' in local_var_params and local_var_params[ 'offset'] < 0: # noqa: E501 raise ApiValueError( "Invalid value for parameter `offset` when calling `get_event_logs`, must be a value greater than or equal to `0`" ) # noqa: E501 collection_formats = {} path_params = {} query_params = [] if 'limit' in local_var_params and local_var_params[ 'limit'] is not None: # noqa: E501 query_params.append( ('limit', local_var_params['limit'])) # noqa: E501 if 'offset' in local_var_params and local_var_params[ 'offset'] is not None: # noqa: E501 query_params.append( ('offset', local_var_params['offset'])) # noqa: E501 header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # Authentication setting auth_settings = [] # noqa: E501 return self.api_client.call_api( '/eventLogs', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='EventLogCollection', # noqa: E501 auth_settings=auth_settings, async_req=local_var_params.get('async_req'), _return_http_data_only=local_var_params.get( '_return_http_data_only'), # noqa: E501 _preload_content=local_var_params.get('_preload_content', True), _request_timeout=local_var_params.get('_request_timeout'), collection_formats=collection_formats)
def get_dag_runs_batch_with_http_info(self, list_dag_runs_form, **kwargs): # noqa: E501 """Get all DAG Runs from aall DAGs. # noqa: E501 This endpoint is a POST to allow filtering across a large number of DAG IDs, where as a GET it would run in to maximum HTTP request URL lengthlimits # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_dag_runs_batch_with_http_info(list_dag_runs_form, async_req=True) >>> result = thread.get() :param async_req bool: execute request asynchronously :param ListDagRunsForm list_dag_runs_form: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DAGRunCollection, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread. """ local_var_params = locals() all_params = ['list_dag_runs_form'] all_params.extend([ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout' ]) for key, val in six.iteritems(local_var_params['kwargs']): if key not in all_params: raise ApiTypeError("Got an unexpected keyword argument '%s'" " to method get_dag_runs_batch" % key) local_var_params[key] = val del local_var_params['kwargs'] # verify the required parameter 'list_dag_runs_form' is set if self.api_client.client_side_validation and ( 'list_dag_runs_form' not in local_var_params or # noqa: E501 local_var_params['list_dag_runs_form'] is None): # noqa: E501 raise ApiValueError( "Missing the required parameter `list_dag_runs_form` when calling `get_dag_runs_batch`" ) # noqa: E501 collection_formats = {} path_params = {} query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None if 'list_dag_runs_form' in local_var_params: body_params = local_var_params['list_dag_runs_form'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # HTTP header `Content-Type` header_params[ 'Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 # Authentication setting auth_settings = [] # noqa: E501 return self.api_client.call_api( '/dags/~/dagRuns/list', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='DAGRunCollection', # noqa: E501 auth_settings=auth_settings, async_req=local_var_params.get('async_req'), _return_http_data_only=local_var_params.get( '_return_http_data_only'), # noqa: E501 _preload_content=local_var_params.get('_preload_content', True), _request_timeout=local_var_params.get('_request_timeout'), collection_formats=collection_formats)
def update_dag_run_with_http_info(self, dag_id, dag_run_id, dag_run, **kwargs): # noqa: E501 """Update a DAG Run # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.update_dag_run_with_http_info(dag_id, dag_run_id, dag_run, async_req=True) >>> result = thread.get() :param async_req bool: execute request asynchronously :param str dag_id: The DAG ID. (required) :param str dag_run_id: The DAG Run ID. (required) :param DAGRun dag_run: (required) :param list[str] update_mask: The fields to update on the connection (connection, pool etc). If absent or empty, all modifiable fields are updated. A comma-separated list of fully qualified names of fields. :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DAGRun, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread. """ local_var_params = locals() all_params = ['dag_id', 'dag_run_id', 'dag_run', 'update_mask'] all_params.extend([ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout' ]) for key, val in six.iteritems(local_var_params['kwargs']): if key not in all_params: raise ApiTypeError("Got an unexpected keyword argument '%s'" " to method update_dag_run" % key) local_var_params[key] = val del local_var_params['kwargs'] # verify the required parameter 'dag_id' is set if self.api_client.client_side_validation and ( 'dag_id' not in local_var_params or # noqa: E501 local_var_params['dag_id'] is None): # noqa: E501 raise ApiValueError( "Missing the required parameter `dag_id` when calling `update_dag_run`" ) # noqa: E501 # verify the required parameter 'dag_run_id' is set if self.api_client.client_side_validation and ( 'dag_run_id' not in local_var_params or # noqa: E501 local_var_params['dag_run_id'] is None): # noqa: E501 raise ApiValueError( "Missing the required parameter `dag_run_id` when calling `update_dag_run`" ) # noqa: E501 # verify the required parameter 'dag_run' is set if self.api_client.client_side_validation and ( 'dag_run' not in local_var_params or # noqa: E501 local_var_params['dag_run'] is None): # noqa: E501 raise ApiValueError( "Missing the required parameter `dag_run` when calling `update_dag_run`" ) # noqa: E501 collection_formats = {} path_params = {} if 'dag_id' in local_var_params: path_params['dag_id'] = local_var_params['dag_id'] # noqa: E501 if 'dag_run_id' in local_var_params: path_params['dag_run_id'] = local_var_params[ 'dag_run_id'] # noqa: E501 query_params = [] if 'update_mask' in local_var_params and local_var_params[ 'update_mask'] is not None: # noqa: E501 query_params.append( ('update_mask', local_var_params['update_mask'])) # noqa: E501 collection_formats['update_mask'] = 'csv' # noqa: E501 header_params = {} form_params = [] local_var_files = {} body_params = None if 'dag_run' in local_var_params: body_params = local_var_params['dag_run'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # HTTP header `Content-Type` header_params[ 'Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 # Authentication setting auth_settings = [] # noqa: E501 return self.api_client.call_api( '/dags/{dag_id}/dagRuns/{dag_run_id}', 'PATCH', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='DAGRun', # noqa: E501 auth_settings=auth_settings, async_req=local_var_params.get('async_req'), _return_http_data_only=local_var_params.get( '_return_http_data_only'), # noqa: E501 _preload_content=local_var_params.get('_preload_content', True), _request_timeout=local_var_params.get('_request_timeout'), collection_formats=collection_formats)
def get_dag_runs_with_http_info(self, dag_id, **kwargs): # noqa: E501 """Get all DAG Runs # noqa: E501 This endpoint allows specifying `~` as the dag_id to retrieve DAG Runs for all DAGs. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_dag_runs_with_http_info(dag_id, async_req=True) >>> result = thread.get() :param async_req bool: execute request asynchronously :param str dag_id: The DAG ID. (required) :param int limit: The numbers of items to return. :param int offset: The number of items to skip before starting to collect the result set. :param datetime execution_date_gte: Returns objects greater or equal to the specified date. This can be combined with execution_date_lte parameter to receive only the selected period. :param datetime execution_date_lte: Returns objects less than or equal to the specified date. This can be combined with execution_date_gte parameter to receive only the selected period. :param datetime start_date_gte: Returns objects greater or equal the specified date. This can be combined with startd_ate_lte parameter to receive only the selected period. :param datetime start_date_lte: Returns objects less or equal the specified date. This can be combined with start_date_gte parameter to receive only the selected period. :param datetime end_date_gte: Returns objects greater or equal the specified date. This can be combined with start_date_lte parameter to receive only the selected period. :param datetime end_date_lte: Returns objects less than or equal to the specified date. This can be combined with start_date_gte parameter to receive only the selected period. :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DAGRunCollection, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread. """ local_var_params = locals() all_params = [ 'dag_id', 'limit', 'offset', 'execution_date_gte', 'execution_date_lte', 'start_date_gte', 'start_date_lte', 'end_date_gte', 'end_date_lte' ] all_params.extend([ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout' ]) for key, val in six.iteritems(local_var_params['kwargs']): if key not in all_params: raise ApiTypeError("Got an unexpected keyword argument '%s'" " to method get_dag_runs" % key) local_var_params[key] = val del local_var_params['kwargs'] # verify the required parameter 'dag_id' is set if self.api_client.client_side_validation and ( 'dag_id' not in local_var_params or # noqa: E501 local_var_params['dag_id'] is None): # noqa: E501 raise ApiValueError( "Missing the required parameter `dag_id` when calling `get_dag_runs`" ) # noqa: E501 if self.api_client.client_side_validation and 'limit' in local_var_params and local_var_params[ 'limit'] < 1: # noqa: E501 raise ApiValueError( "Invalid value for parameter `limit` when calling `get_dag_runs`, must be a value greater than or equal to `1`" ) # noqa: E501 if self.api_client.client_side_validation and 'offset' in local_var_params and local_var_params[ 'offset'] < 0: # noqa: E501 raise ApiValueError( "Invalid value for parameter `offset` when calling `get_dag_runs`, must be a value greater than or equal to `0`" ) # noqa: E501 collection_formats = {} path_params = {} if 'dag_id' in local_var_params: path_params['dag_id'] = local_var_params['dag_id'] # noqa: E501 query_params = [] if 'limit' in local_var_params and local_var_params[ 'limit'] is not None: # noqa: E501 query_params.append( ('limit', local_var_params['limit'])) # noqa: E501 if 'offset' in local_var_params and local_var_params[ 'offset'] is not None: # noqa: E501 query_params.append( ('offset', local_var_params['offset'])) # noqa: E501 if 'execution_date_gte' in local_var_params and local_var_params[ 'execution_date_gte'] is not None: # noqa: E501 query_params.append( ('execution_date_gte', local_var_params['execution_date_gte'])) # noqa: E501 if 'execution_date_lte' in local_var_params and local_var_params[ 'execution_date_lte'] is not None: # noqa: E501 query_params.append( ('execution_date_lte', local_var_params['execution_date_lte'])) # noqa: E501 if 'start_date_gte' in local_var_params and local_var_params[ 'start_date_gte'] is not None: # noqa: E501 query_params.append( ('start_date_gte', local_var_params['start_date_gte'])) # noqa: E501 if 'start_date_lte' in local_var_params and local_var_params[ 'start_date_lte'] is not None: # noqa: E501 query_params.append( ('start_date_lte', local_var_params['start_date_lte'])) # noqa: E501 if 'end_date_gte' in local_var_params and local_var_params[ 'end_date_gte'] is not None: # noqa: E501 query_params.append( ('end_date_gte', local_var_params['end_date_gte'])) # noqa: E501 if 'end_date_lte' in local_var_params and local_var_params[ 'end_date_lte'] is not None: # noqa: E501 query_params.append( ('end_date_lte', local_var_params['end_date_lte'])) # noqa: E501 header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # Authentication setting auth_settings = [] # noqa: E501 return self.api_client.call_api( '/dags/{dag_id}/dagRuns', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='DAGRunCollection', # noqa: E501 auth_settings=auth_settings, async_req=local_var_params.get('async_req'), _return_http_data_only=local_var_params.get( '_return_http_data_only'), # noqa: E501 _preload_content=local_var_params.get('_preload_content', True), _request_timeout=local_var_params.get('_request_timeout'), collection_formats=collection_formats)
def get_health_with_http_info(self, **kwargs): # noqa: E501 """Returns the status of Airflow's metadatabase and scheduler # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_health_with_http_info(async_req=True) >>> result = thread.get() :param async_req bool: execute request asynchronously :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(HealthInfo, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread. """ local_var_params = locals() all_params = [] all_params.extend([ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout' ]) for key, val in six.iteritems(local_var_params['kwargs']): if key not in all_params: raise ApiTypeError("Got an unexpected keyword argument '%s'" " to method get_health" % key) local_var_params[key] = val del local_var_params['kwargs'] collection_formats = {} path_params = {} query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # Authentication setting auth_settings = [] # noqa: E501 return self.api_client.call_api( '/health', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='HealthInfo', # noqa: E501 auth_settings=auth_settings, async_req=local_var_params.get('async_req'), _return_http_data_only=local_var_params.get( '_return_http_data_only'), # noqa: E501 _preload_content=local_var_params.get('_preload_content', True), _request_timeout=local_var_params.get('_request_timeout'), collection_formats=collection_formats)
def create_pool_with_http_info(self, pool, **kwargs): # noqa: E501 """Create a pool # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.create_pool_with_http_info(pool, async_req=True) >>> result = thread.get() :param async_req bool: execute request asynchronously :param Pool pool: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(Pool, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread. """ local_var_params = locals() all_params = ['pool'] all_params.extend([ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout' ]) for key, val in six.iteritems(local_var_params['kwargs']): if key not in all_params: raise ApiTypeError("Got an unexpected keyword argument '%s'" " to method create_pool" % key) local_var_params[key] = val del local_var_params['kwargs'] # verify the required parameter 'pool' is set if self.api_client.client_side_validation and ( 'pool' not in local_var_params or # noqa: E501 local_var_params['pool'] is None): # noqa: E501 raise ApiValueError( "Missing the required parameter `pool` when calling `create_pool`" ) # noqa: E501 collection_formats = {} path_params = {} query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None if 'pool' in local_var_params: body_params = local_var_params['pool'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # HTTP header `Content-Type` header_params[ 'Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 # Authentication setting auth_settings = [] # noqa: E501 return self.api_client.call_api( '/pools', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='Pool', # noqa: E501 auth_settings=auth_settings, async_req=local_var_params.get('async_req'), _return_http_data_only=local_var_params.get( '_return_http_data_only'), # noqa: E501 _preload_content=local_var_params.get('_preload_content', True), _request_timeout=local_var_params.get('_request_timeout'), collection_formats=collection_formats)
def delete_variable_with_http_info(self, variable_key, **kwargs): # noqa: E501 """Delete variable # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.delete_variable_with_http_info(variable_key, async_req=True) >>> result = thread.get() :param async_req bool: execute request asynchronously :param str variable_key: The Variable Key. (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: None If the method is called asynchronously, returns the request thread. """ local_var_params = locals() all_params = ['variable_key'] all_params.extend([ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout' ]) for key, val in six.iteritems(local_var_params['kwargs']): if key not in all_params: raise ApiTypeError("Got an unexpected keyword argument '%s'" " to method delete_variable" % key) local_var_params[key] = val del local_var_params['kwargs'] # verify the required parameter 'variable_key' is set if self.api_client.client_side_validation and ( 'variable_key' not in local_var_params or # noqa: E501 local_var_params['variable_key'] is None): # noqa: E501 raise ApiValueError( "Missing the required parameter `variable_key` when calling `delete_variable`" ) # noqa: E501 collection_formats = {} path_params = {} if 'variable_key' in local_var_params: path_params['variable_key'] = local_var_params[ 'variable_key'] # noqa: E501 query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # Authentication setting auth_settings = [] # noqa: E501 return self.api_client.call_api( '/variables/{variable_key}', 'DELETE', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, # noqa: E501 auth_settings=auth_settings, async_req=local_var_params.get('async_req'), _return_http_data_only=local_var_params.get( '_return_http_data_only'), # noqa: E501 _preload_content=local_var_params.get('_preload_content', True), _request_timeout=local_var_params.get('_request_timeout'), collection_formats=collection_formats)
def call_with_http_info(self, **kwargs): try: index = self.api_client.configuration.server_operation_index.get( self.settings['operation_id'], self.api_client.configuration.server_index ) if kwargs['_host_index'] is None else kwargs['_host_index'] server_variables = self.api_client.configuration.server_operation_variables.get( self.settings['operation_id'], self.api_client.configuration.server_variables) _host = self.api_client.configuration.get_host_from_settings( index, variables=server_variables, servers=self.settings['servers']) except IndexError: if self.settings['servers']: raise ApiValueError( "Invalid host index. Must be 0 <= index < %s" % len(self.settings['servers'])) _host = None for key, value in kwargs.items(): if key not in self.params_map['all']: raise ApiTypeError("Got an unexpected parameter '%s'" " to method `%s`" % (key, self.settings['operation_id'])) # only throw this nullable ApiValueError if _check_input_type # is False, if _check_input_type==True we catch this case # in self.__validate_inputs if (key not in self.params_map['nullable'] and value is None and kwargs['_check_input_type'] is False): raise ApiValueError( "Value may not be None for non-nullable parameter `%s`" " when calling `%s`" % (key, self.settings['operation_id'])) for key in self.params_map['required']: if key not in kwargs.keys(): raise ApiValueError( "Missing the required parameter `%s` when calling " "`%s`" % (key, self.settings['operation_id'])) self.__validate_inputs(kwargs) params = self.__gather_params(kwargs) accept_headers_list = self.headers_map['accept'] if accept_headers_list: params['header']['Accept'] = self.api_client.select_header_accept( accept_headers_list) content_type_headers_list = self.headers_map['content_type'] if content_type_headers_list: header_list = self.api_client.select_header_content_type( content_type_headers_list) params['header']['Content-Type'] = header_list return self.api_client.call_api( self.settings['endpoint_path'], self.settings['http_method'], params['path'], params['query'], params['header'], body=params['body'], post_params=params['form'], files=params['file'], response_type=self.settings['response_type'], auth_settings=self.settings['auth'], async_req=kwargs['async_req'], _check_type=kwargs['_check_return_type'], _return_http_data_only=kwargs['_return_http_data_only'], _preload_content=kwargs['_preload_content'], _request_timeout=kwargs['_request_timeout'], _host=_host, collection_formats=params['collection_format'])