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'])
