def __setattr__(self, name, value):
object.__setattr__(self, name, value)
if name == 'disabled_client_side_validations':
s = set(filter(None, value.split(',')))
for v in s:
if v not in JSON_SCHEMA_VALIDATION_KEYWORDS:
raise ApiValueError("Invalid keyword: '{0}''".format(v))
self._disabled_client_side_validations = s
def _apply_auth_params(self, headers, querys, auth_setting):
"""Updates the request parameters based on a single auth_setting
:param headers: Header parameters dict to be updated.
:param querys: Query parameters tuple list to be updated.
:param auth_setting: auth settings for the endpoint
"""
if auth_setting['in'] == 'cookie':
headers['Cookie'] = auth_setting['value']
elif auth_setting['in'] == 'header':
headers[auth_setting['key']] = auth_setting['value']
elif auth_setting['in'] == 'query':
querys.append((auth_setting['key'], auth_setting['value']))
else:
raise ApiValueError(
'Authentication token must be in `query` or `header`')
def get_asset_or_livestream_id_with_http_info(self, playback_id,
**kwargs): # noqa: E501
"""Retrieve an Asset or Live Stream ID # noqa: E501
Retrieves the Identifier of the Asset or Live Stream associated with the Playback ID. # 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_asset_or_livestream_id_with_http_info(playback_id, async_req=True)
>>> result = thread.get()
:param playback_id: The live stream's playback ID. (required)
:type playback_id: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
: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.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(GetAssetOrLiveStreamIdResponse, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
all_params = ['playback_id']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout', '_request_auth'
])
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_asset_or_livestream_id" %
key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'playback_id' is set
if self.api_client.client_side_validation and (
'playback_id' not in local_var_params or # noqa: E501
local_var_params['playback_id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `playback_id` when calling `get_asset_or_livestream_id`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'playback_id' in local_var_params:
path_params['PLAYBACK_ID'] = local_var_params[
'playback_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 = ['accessToken'] # noqa: E501
response_types_map = {
200: "GetAssetOrLiveStreamIdResponse",
}
return self.api_client.call_api(
'/video/v1/playback-ids/{PLAYBACK_ID}',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_types_map=response_types_map,
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,
_request_auth=local_var_params.get('_request_auth'))
def list_related_incidents_with_http_info(self, incident_id,
**kwargs): # noqa: E501
"""List Related Incidents # noqa: E501
Returns all the incidents that seem related to a specific incident. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.list_related_incidents_with_http_info(incident_id, async_req=True)
>>> result = thread.get()
:param incident_id: ID of the Incident (required)
:type incident_id: str
:param limit: Number of items to include in the response
:type limit: int
:param page: Offset by this many pages, of the size of `limit`
:type page: int
:param order_by: Value to order the results by
:type order_by: str
:param order_direction: Sort order.
:type order_direction: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
: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.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(ListRelatedIncidentsResponse, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
all_params = [
'incident_id', 'limit', 'page', 'order_by', 'order_direction'
]
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout', '_request_auth'
])
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 list_related_incidents" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'incident_id' is set
if self.api_client.client_side_validation and (
'incident_id' not in local_var_params or # noqa: E501
local_var_params['incident_id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `incident_id` when calling `list_related_incidents`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'incident_id' in local_var_params:
path_params['INCIDENT_ID'] = local_var_params[
'incident_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 'page' in local_var_params and local_var_params[
'page'] is not None: # noqa: E501
query_params.append(
('page', local_var_params['page'])) # noqa: E501
if 'order_by' in local_var_params and local_var_params[
'order_by'] is not None: # noqa: E501
query_params.append(
('order_by', local_var_params['order_by'])) # noqa: E501
if 'order_direction' in local_var_params and local_var_params[
'order_direction'] is not None: # noqa: E501
query_params.append(
('order_direction',
local_var_params['order_direction'])) # 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 = ['accessToken'] # noqa: E501
response_types_map = {
200: "ListRelatedIncidentsResponse",
}
return self.api_client.call_api(
'/data/v1/incidents/{INCIDENT_ID}/related',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_types_map=response_types_map,
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,
_request_auth=local_var_params.get('_request_auth'))
def list_insights_with_http_info(self, metric_id, **kwargs): # noqa: E501
"""List Insights # noqa: E501
Returns a list of insights for a metric. These are the worst performing values across all breakdowns sorted by how much they negatively impact a specific metric. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.list_insights_with_http_info(metric_id, async_req=True)
>>> result = thread.get()
:param metric_id: ID of the Metric (required)
:type metric_id: str
:param measurement: Measurement for the provided metric. If omitted, the default for the metric will be used.
:type measurement: str
:param order_direction: Sort order.
:type order_direction: str
:param timeframe: Timeframe window to limit results by. Must be provided as an array query string parameter (e.g. timeframe[]=). Accepted formats are... * array of epoch timestamps e.g. `timeframe[]=1498867200&timeframe[]=1498953600` * duration string e.g. `timeframe[]=24:hours or timeframe[]=7:days`
:type timeframe: list[str]
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
: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.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(ListInsightsResponse, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
all_params = [
'metric_id', 'measurement', 'order_direction', 'timeframe'
]
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout', '_request_auth'
])
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 list_insights" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'metric_id' is set
if self.api_client.client_side_validation and (
'metric_id' not in local_var_params or # noqa: E501
local_var_params['metric_id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `metric_id` when calling `list_insights`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'metric_id' in local_var_params:
path_params['METRIC_ID'] = local_var_params[
'metric_id'] # noqa: E501
query_params = []
if 'measurement' in local_var_params and local_var_params[
'measurement'] is not None: # noqa: E501
query_params.append(
('measurement', local_var_params['measurement'])) # noqa: E501
if 'order_direction' in local_var_params and local_var_params[
'order_direction'] is not None: # noqa: E501
query_params.append(
('order_direction',
local_var_params['order_direction'])) # noqa: E501
if 'timeframe' in local_var_params and local_var_params[
'timeframe'] is not None: # noqa: E501
query_params.append(
('timeframe[]', local_var_params['timeframe'])) # noqa: E501
collection_formats['timeframe[]'] = 'multi' # 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 = ['accessToken'] # noqa: E501
response_types_map = {
200: "ListInsightsResponse",
}
return self.api_client.call_api(
'/data/v1/metrics/{METRIC_ID}/insights',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_types_map=response_types_map,
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,
_request_auth=local_var_params.get('_request_auth'))
def get_metric_timeseries_data_with_http_info(self, metric_id,
**kwargs): # noqa: E501
"""Get metric timeseries data # noqa: E501
Returns timeseries data for a specific metric. # 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_metric_timeseries_data_with_http_info(metric_id, async_req=True)
>>> result = thread.get()
:param metric_id: ID of the Metric (required)
:type metric_id: str
:param timeframe: Timeframe window to limit results by. Must be provided as an array query string parameter (e.g. timeframe[]=). Accepted formats are... * array of epoch timestamps e.g. `timeframe[]=1498867200&timeframe[]=1498953600` * duration string e.g. `timeframe[]=24:hours or timeframe[]=7:days`
:type timeframe: list[str]
:param filters: Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US`
:type filters: list[str]
:param measurement: Measurement for the provided metric. If omitted, the default for the metric will be used.
:type measurement: str
:param order_direction: Sort order.
:type order_direction: str
:param group_by: Time granularity to group results by. If this value is omitted, a default granularity is chosen based on the timeframe. For timeframes of 6 hours or less, the default granularity is `ten_minutes`. Between 6 hours and 15 hours inclusive, the default granularity is `hour`. The granularity of timeframes that exceed 15 hours is `day`. This default behaviour is subject to change; it is strongly suggested that you explicitly specify the granularity.
:type group_by: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
: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.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(GetMetricTimeseriesDataResponse, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
all_params = [
'metric_id', 'timeframe', 'filters', 'measurement',
'order_direction', 'group_by'
]
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout', '_request_auth'
])
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_metric_timeseries_data" %
key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'metric_id' is set
if self.api_client.client_side_validation and (
'metric_id' not in local_var_params or # noqa: E501
local_var_params['metric_id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `metric_id` when calling `get_metric_timeseries_data`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'metric_id' in local_var_params:
path_params['METRIC_ID'] = local_var_params[
'metric_id'] # noqa: E501
query_params = []
if 'timeframe' in local_var_params and local_var_params[
'timeframe'] is not None: # noqa: E501
query_params.append(
('timeframe[]', local_var_params['timeframe'])) # noqa: E501
collection_formats['timeframe[]'] = 'multi' # noqa: E501
if 'filters' in local_var_params and local_var_params[
'filters'] is not None: # noqa: E501
query_params.append(
('filters[]', local_var_params['filters'])) # noqa: E501
collection_formats['filters[]'] = 'multi' # noqa: E501
if 'measurement' in local_var_params and local_var_params[
'measurement'] is not None: # noqa: E501
query_params.append(
('measurement', local_var_params['measurement'])) # noqa: E501
if 'order_direction' in local_var_params and local_var_params[
'order_direction'] is not None: # noqa: E501
query_params.append(
('order_direction',
local_var_params['order_direction'])) # noqa: E501
if 'group_by' in local_var_params and local_var_params[
'group_by'] is not None: # noqa: E501
query_params.append(
('group_by', local_var_params['group_by'])) # 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 = ['accessToken'] # noqa: E501
response_types_map = {
200: "GetMetricTimeseriesDataResponse",
}
return self.api_client.call_api(
'/data/v1/metrics/{METRIC_ID}/timeseries',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_types_map=response_types_map,
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,
_request_auth=local_var_params.get('_request_auth'))
def list_filter_values_with_http_info(self, filter_id, **kwargs): # noqa: E501
"""Lists values for a specific filter # noqa: E501
The API has been replaced by the list-dimension-values API call. Lists the values for a filter along with a total count of related views. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.list_filter_values_with_http_info(filter_id, async_req=True)
>>> result = thread.get()
:param filter_id: ID of the Filter (required)
:type filter_id: str
:param limit: Number of items to include in the response
:type limit: int
:param page: Offset by this many pages, of the size of `limit`
:type page: int
:param filters: Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US`
:type filters: list[str]
:param timeframe: Timeframe window to limit results by. Must be provided as an array query string parameter (e.g. timeframe[]=). Accepted formats are... * array of epoch timestamps e.g. `timeframe[]=1498867200&timeframe[]=1498953600` * duration string e.g. `timeframe[]=24:hours or timeframe[]=7:days`
:type timeframe: list[str]
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
: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.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(ListFilterValuesResponse, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
all_params = [
'filter_id',
'limit',
'page',
'filters',
'timeframe'
]
all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout',
'_request_auth'
]
)
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 list_filter_values" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'filter_id' is set
if self.api_client.client_side_validation and ('filter_id' not in local_var_params or # noqa: E501
local_var_params['filter_id'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `filter_id` when calling `list_filter_values`") # noqa: E501
collection_formats = {}
path_params = {}
if 'filter_id' in local_var_params:
path_params['FILTER_ID'] = local_var_params['filter_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 'page' in local_var_params and local_var_params['page'] is not None: # noqa: E501
query_params.append(('page', local_var_params['page'])) # noqa: E501
if 'filters' in local_var_params and local_var_params['filters'] is not None: # noqa: E501
query_params.append(('filters[]', local_var_params['filters'])) # noqa: E501
collection_formats['filters[]'] = 'multi' # noqa: E501
if 'timeframe' in local_var_params and local_var_params['timeframe'] is not None: # noqa: E501
query_params.append(('timeframe[]', local_var_params['timeframe'])) # noqa: E501
collection_formats['timeframe[]'] = 'multi' # 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 = ['accessToken'] # noqa: E501
response_types_map = {
200: "ListFilterValuesResponse",
}
return self.api_client.call_api(
'/data/v1/filters/{FILTER_ID}', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_types_map=response_types_map,
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,
_request_auth=local_var_params.get('_request_auth'))
def get_url_signing_key_with_http_info(self, signing_key_id,
**kwargs): # noqa: E501
"""Retrieve a URL signing key # noqa: E501
Retrieves the details of a URL signing key that has previously been created. Supply the unique signing key ID that was returned from your previous request, and Mux will return the corresponding signing key information. **The private key is not returned in this response.** # 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_url_signing_key_with_http_info(signing_key_id, async_req=True)
>>> result = thread.get()
:param signing_key_id: The ID of the signing key. (required)
:type signing_key_id: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
: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.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(SigningKeyResponse, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
all_params = ['signing_key_id']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout', '_request_auth'
])
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_url_signing_key" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'signing_key_id' is set
if self.api_client.client_side_validation and (
'signing_key_id' not in local_var_params or # noqa: E501
local_var_params['signing_key_id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `signing_key_id` when calling `get_url_signing_key`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'signing_key_id' in local_var_params:
path_params['SIGNING_KEY_ID'] = local_var_params[
'signing_key_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 = ['accessToken'] # noqa: E501
response_types_map = {
200: "SigningKeyResponse",
}
return self.api_client.call_api(
'/video/v1/signing-keys/{SIGNING_KEY_ID}',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_types_map=response_types_map,
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,
_request_auth=local_var_params.get('_request_auth'))
def delete_url_signing_key_with_http_info(self, signing_key_id,
**kwargs): # noqa: E501
"""Delete a URL signing key # noqa: E501
Deletes an existing signing key. Use with caution, as this will invalidate any existing signatures and no URLs can be signed using the key again. # 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_url_signing_key_with_http_info(signing_key_id, async_req=True)
>>> result = thread.get()
:param signing_key_id: The ID of the signing key. (required)
:type signing_key_id: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
: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.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
local_var_params = locals()
all_params = ['signing_key_id']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout', '_request_auth'
])
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_url_signing_key" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'signing_key_id' is set
if self.api_client.client_side_validation and (
'signing_key_id' not in local_var_params or # noqa: E501
local_var_params['signing_key_id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `signing_key_id` when calling `delete_url_signing_key`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'signing_key_id' in local_var_params:
path_params['SIGNING_KEY_ID'] = local_var_params[
'signing_key_id'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = ['accessToken'] # noqa: E501
response_types_map = {}
return self.api_client.call_api(
'/video/v1/signing-keys/{SIGNING_KEY_ID}',
'DELETE',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_types_map=response_types_map,
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,
_request_auth=local_var_params.get('_request_auth'))
def get_realtime_breakdown_with_http_info(self, realtime_metric_id,
**kwargs): # noqa: E501
"""Get Real-Time Breakdown # noqa: E501
Gets breakdown information for a specific dimension and metric along with the number of concurrent viewers and negative impact score. # 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_realtime_breakdown_with_http_info(realtime_metric_id, async_req=True)
>>> result = thread.get()
:param realtime_metric_id: ID of the Realtime Metric (required)
:type realtime_metric_id: str
:param dimension: Dimension the specified value belongs to
:type dimension: str
:param timestamp: Timestamp to limit results by. This value must be provided as a unix timestamp. Defaults to the current unix timestamp.
:type timestamp: float
:param filters: Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US`
:type filters: list[str]
:param order_by: Value to order the results by
:type order_by: str
:param order_direction: Sort order.
:type order_direction: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
: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.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(GetRealTimeBreakdownResponse, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
all_params = [
'realtime_metric_id', 'dimension', 'timestamp', 'filters',
'order_by', 'order_direction'
]
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout', '_request_auth'
])
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_realtime_breakdown" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'realtime_metric_id' is set
if self.api_client.client_side_validation and (
'realtime_metric_id' not in local_var_params or # noqa: E501
local_var_params['realtime_metric_id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `realtime_metric_id` when calling `get_realtime_breakdown`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'realtime_metric_id' in local_var_params:
path_params['REALTIME_METRIC_ID'] = local_var_params[
'realtime_metric_id'] # noqa: E501
query_params = []
if 'dimension' in local_var_params and local_var_params[
'dimension'] is not None: # noqa: E501
query_params.append(
('dimension', local_var_params['dimension'])) # noqa: E501
if 'timestamp' in local_var_params and local_var_params[
'timestamp'] is not None: # noqa: E501
query_params.append(
('timestamp', local_var_params['timestamp'])) # noqa: E501
if 'filters' in local_var_params and local_var_params[
'filters'] is not None: # noqa: E501
query_params.append(
('filters[]', local_var_params['filters'])) # noqa: E501
collection_formats['filters[]'] = 'multi' # noqa: E501
if 'order_by' in local_var_params and local_var_params[
'order_by'] is not None: # noqa: E501
query_params.append(
('order_by', local_var_params['order_by'])) # noqa: E501
if 'order_direction' in local_var_params and local_var_params[
'order_direction'] is not None: # noqa: E501
query_params.append(
('order_direction',
local_var_params['order_direction'])) # 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 = ['accessToken'] # noqa: E501
response_types_map = {
200: "GetRealTimeBreakdownResponse",
}
return self.api_client.call_api(
'/data/v1/realtime/metrics/{REALTIME_METRIC_ID}/breakdown',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_types_map=response_types_map,
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,
_request_auth=local_var_params.get('_request_auth'))
def request(self,
method,
url,
query_params=None,
headers=None,
body=None,
post_params=None,
_preload_content=True,
_request_timeout=None):
"""Perform requests.
:param method: http request method
:param url: http request url
:param query_params: query parameters in the url
:param headers: http request headers
:param body: request json body, for `application/json`
:param post_params: request post parameters,
`application/x-www-form-urlencoded`
and `multipart/form-data`
: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.
"""
method = method.upper()
assert method in [
'GET', 'HEAD', 'DELETE', 'POST', 'PUT', 'PATCH', 'OPTIONS'
]
if post_params and body:
raise ApiValueError(
"body parameter cannot be used with post_params parameter.")
post_params = post_params or {}
headers = headers or {}
timeout = None
if _request_timeout:
if isinstance(_request_timeout,
six.integer_types + (float, )): # noqa: E501,F821
timeout = urllib3.Timeout(total=_request_timeout)
elif (isinstance(_request_timeout, tuple)
and len(_request_timeout) == 2):
timeout = urllib3.Timeout(connect=_request_timeout[0],
read=_request_timeout[1])
if 'Content-Type' not in headers:
headers['Content-Type'] = 'application/json'
try:
# For `POST`, `PUT`, `PATCH`, `OPTIONS`, `DELETE`
if method in ['POST', 'PUT', 'PATCH', 'OPTIONS', 'DELETE']:
if query_params:
url += '?' + urlencode(query_params)
if re.search('json', headers['Content-Type'], re.IGNORECASE):
request_body = None
if body is not None:
request_body = json.dumps(body)
r = self.pool_manager.request(
method,
url,
body=request_body,
preload_content=_preload_content,
timeout=timeout,
headers=headers)
elif headers[
'Content-Type'] == 'application/x-www-form-urlencoded': # noqa: E501
r = self.pool_manager.request(
method,
url,
fields=post_params,
encode_multipart=False,
preload_content=_preload_content,
timeout=timeout,
headers=headers)
elif headers['Content-Type'] == 'multipart/form-data':
# must del headers['Content-Type'], or the correct
# Content-Type which generated by urllib3 will be
# overwritten.
del headers['Content-Type']
r = self.pool_manager.request(
method,
url,
fields=post_params,
encode_multipart=True,
preload_content=_preload_content,
timeout=timeout,
headers=headers)
# Pass a `string` parameter directly in the body to support
# other content types than Json when `body` argument is
# provided in serialized form
elif isinstance(body, str) or isinstance(body, bytes):
request_body = body
r = self.pool_manager.request(
method,
url,
body=request_body,
preload_content=_preload_content,
timeout=timeout,
headers=headers)
else:
# Cannot generate the request from given parameters
msg = """Cannot prepare a request message for provided
arguments. Please check that your arguments match
declared content type."""
raise ApiException(status=0, reason=msg)
# For `GET`, `HEAD`
else:
r = self.pool_manager.request(method,
url,
fields=query_params,
preload_content=_preload_content,
timeout=timeout,
headers=headers)
except urllib3.exceptions.SSLError as e:
msg = "{0}\n{1}".format(type(e).__name__, str(e))
raise ApiException(status=0, reason=msg)
if _preload_content:
r = RESTResponse(r)
# log response body
logger.debug("response body: %s", r.data)
if not 200 <= r.status <= 299:
if r.status == 401:
raise UnauthorizedException(http_resp=r)
if r.status == 403:
raise ForbiddenException(http_resp=r)
if r.status == 404:
raise NotFoundException(http_resp=r)
if 500 <= r.status <= 599:
raise ServiceException(http_resp=r)
raise ApiException(http_resp=r)
return r
def request(self,
method,
url,
query_params=None,
headers=None,
post_params=None,
body=None,
_preload_content=True,
_request_timeout=None):
"""Makes the HTTP request using RESTClient."""
if method == "GET":
return self.rest_client.GET(url,
query_params=query_params,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
headers=headers)
elif method == "HEAD":
return self.rest_client.HEAD(url,
query_params=query_params,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
headers=headers)
elif method == "OPTIONS":
return self.rest_client.OPTIONS(url,
query_params=query_params,
headers=headers,
_preload_content=_preload_content,
_request_timeout=_request_timeout)
elif method == "POST":
return self.rest_client.POST(url,
query_params=query_params,
headers=headers,
post_params=post_params,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
body=body)
elif method == "PUT":
return self.rest_client.PUT(url,
query_params=query_params,
headers=headers,
post_params=post_params,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
body=body)
elif method == "PATCH":
return self.rest_client.PATCH(url,
query_params=query_params,
headers=headers,
post_params=post_params,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
body=body)
elif method == "DELETE":
return self.rest_client.DELETE(url,
query_params=query_params,
headers=headers,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
body=body)
else:
raise ApiValueError("http method must be `GET`, `HEAD`, `OPTIONS`,"
" `POST`, `PATCH`, `PUT` or `DELETE`.")
def create_playback_restriction_with_http_info(
self, create_playback_restriction_request, **kwargs): # noqa: E501
"""Create a Playback Restriction # noqa: E501
Create a new Playback Restriction. # 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_playback_restriction_with_http_info(create_playback_restriction_request, async_req=True)
>>> result = thread.get()
:param create_playback_restriction_request: (required)
:type create_playback_restriction_request: CreatePlaybackRestrictionRequest
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
: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.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(PlaybackRestriction, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
all_params = ['create_playback_restriction_request']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout', '_request_auth'
])
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_playback_restriction" %
key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'create_playback_restriction_request' is set
if self.api_client.client_side_validation and (
'create_playback_restriction_request' not in local_var_params
or # noqa: E501
local_var_params['create_playback_restriction_request'] is None
): # noqa: E501
raise ApiValueError(
"Missing the required parameter `create_playback_restriction_request` when calling `create_playback_restriction`"
) # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'create_playback_restriction_request' in local_var_params:
body_params = local_var_params[
'create_playback_restriction_request']
# 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 = ['accessToken'] # noqa: E501
response_types_map = {
201: "PlaybackRestriction",
}
return self.api_client.call_api(
'/video/v1/playback-restrictions',
'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_types_map=response_types_map,
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,
_request_auth=local_var_params.get('_request_auth'))
def update_referrer_domain_restriction_with_http_info(
self, playback_restriction_id, body, **kwargs): # noqa: E501
"""Update the Referrer Playback Restriction # noqa: E501
Allows you to modify the list of domians or change how Mux validates playback requests without the `Referer` HTTP header. The Referrer restriction fully replaces the old list with this new list of domains. # 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_referrer_domain_restriction_with_http_info(playback_restriction_id, body, async_req=True)
>>> result = thread.get()
:param playback_restriction_id: ID of the Playback Restriction. (required)
:type playback_restriction_id: str
:param body: (required)
:type body: ReferrerDomainRestriction
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
: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.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(PlaybackRestriction, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
all_params = ['playback_restriction_id', 'body']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout', '_request_auth'
])
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_referrer_domain_restriction" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'playback_restriction_id' is set
if self.api_client.client_side_validation and (
'playback_restriction_id' not in local_var_params
or # noqa: E501
local_var_params['playback_restriction_id'] is None
): # noqa: E501
raise ApiValueError(
"Missing the required parameter `playback_restriction_id` when calling `update_referrer_domain_restriction`"
) # noqa: E501
# verify the required parameter 'body' is set
if self.api_client.client_side_validation and (
'body' not in local_var_params or # noqa: E501
local_var_params['body'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `body` when calling `update_referrer_domain_restriction`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'playback_restriction_id' in local_var_params:
path_params['PLAYBACK_RESTRICTION_ID'] = local_var_params[
'playback_restriction_id'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'body' in local_var_params:
body_params = local_var_params['body']
# 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 = ['accessToken'] # noqa: E501
response_types_map = {
200: "PlaybackRestriction",
}
return self.api_client.call_api(
'/video/v1/playback-restrictions/{PLAYBACK_RESTRICTION_ID}/referrer',
'PUT',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_types_map=response_types_map,
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,
_request_auth=local_var_params.get('_request_auth'))
def cancel_direct_upload_with_http_info(self, upload_id,
**kwargs): # noqa: E501
"""Cancel a direct upload # noqa: E501
Cancels a direct upload and marks it as cancelled. If a pending upload finishes after this request, no asset will be created. This request will only succeed if the upload is still in the `waiting` state. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.cancel_direct_upload_with_http_info(upload_id, async_req=True)
>>> result = thread.get()
:param upload_id: ID of the Upload (required)
:type upload_id: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
: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.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(UploadResponse, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
all_params = ['upload_id']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout', '_request_auth'
])
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 cancel_direct_upload" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'upload_id' is set
if self.api_client.client_side_validation and (
'upload_id' not in local_var_params or # noqa: E501
local_var_params['upload_id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `upload_id` when calling `cancel_direct_upload`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'upload_id' in local_var_params:
path_params['UPLOAD_ID'] = local_var_params[
'upload_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 = ['accessToken'] # noqa: E501
response_types_map = {
200: "UploadResponse",
403: None,
}
return self.api_client.call_api(
'/video/v1/uploads/{UPLOAD_ID}/cancel',
'PUT',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_types_map=response_types_map,
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,
_request_auth=local_var_params.get('_request_auth'))
