# coding: utf-8

"""
    Endpoints

    Endpoints API for different services in SKIL  # noqa: E501

    OpenAPI spec version: 1.2.0-beta
    
    Generated by: https://github.com/swagger-api/swagger-codegen.git
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from skil_client.api_client import ApiClient


class DefaultApi(object):
    """NOTE: This class is auto generated by the swagger code generator program.

    Do not edit the class manually.
    Ref: https://github.com/swagger-api/swagger-codegen
    """

    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

    def add_credentials(self, add_credentials_request, **kwargs):  # noqa: E501
        """Adds credentials  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_credentials(add_credentials_request, async=True)
        >>> result = thread.get()

        :param async bool
        :param AddCredentialsRequest add_credentials_request: Add credentials request object (required)
        :return: ResourceCredentials
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.add_credentials_with_http_info(add_credentials_request, **kwargs)  # noqa: E501
        else:
            (data) = self.add_credentials_with_http_info(add_credentials_request, **kwargs)  # noqa: E501
            return data

    def add_credentials_with_http_info(self, add_credentials_request, **kwargs):  # noqa: E501
        """Adds credentials  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_credentials_with_http_info(add_credentials_request, async=True)
        >>> result = thread.get()

        :param async bool
        :param AddCredentialsRequest add_credentials_request: Add credentials request object (required)
        :return: ResourceCredentials
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['add_credentials_request']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_credentials" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'add_credentials_request' is set
        if ('add_credentials_request' not in params or
                params['add_credentials_request'] is None):
            raise ValueError("Missing the required parameter `add_credentials_request` when calling `add_credentials`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'add_credentials_request' in params:
            body_params = params['add_credentials_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/resources/credentials', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ResourceCredentials',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def add_evaluation_result(self, model_history_server_id, evaluation_results_entity, **kwargs):  # noqa: E501
        """Adds an evaluation result  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_evaluation_result(model_history_server_id, evaluation_results_entity, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param EvaluationResultsEntity evaluation_results_entity: The evaluation result entity (required)
        :return: EvaluationResultsEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.add_evaluation_result_with_http_info(model_history_server_id, evaluation_results_entity, **kwargs)  # noqa: E501
        else:
            (data) = self.add_evaluation_result_with_http_info(model_history_server_id, evaluation_results_entity, **kwargs)  # noqa: E501
            return data

    def add_evaluation_result_with_http_info(self, model_history_server_id, evaluation_results_entity, **kwargs):  # noqa: E501
        """Adds an evaluation result  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_evaluation_result_with_http_info(model_history_server_id, evaluation_results_entity, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param EvaluationResultsEntity evaluation_results_entity: The evaluation result entity (required)
        :return: EvaluationResultsEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_history_server_id', 'evaluation_results_entity']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_evaluation_result" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_history_server_id' is set
        if ('model_history_server_id' not in params or
                params['model_history_server_id'] is None):
            raise ValueError("Missing the required parameter `model_history_server_id` when calling `add_evaluation_result`")  # noqa: E501
        # verify the required parameter 'evaluation_results_entity' is set
        if ('evaluation_results_entity' not in params or
                params['evaluation_results_entity'] is None):
            raise ValueError("Missing the required parameter `evaluation_results_entity` when calling `add_evaluation_result`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'model_history_server_id' in params:
            path_params['modelHistoryServerId'] = params['model_history_server_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'evaluation_results_entity' in params:
            body_params = params['evaluation_results_entity']
        # 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/rpc/{modelHistoryServerId}/model/revisions/evaluations/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EvaluationResultsEntity',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def add_example_for_batch(self, model_history_server_id, add_example_request, **kwargs):  # noqa: E501
        """Adds a number of examples to a minibatch ID given an AddExampleRequest.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_example_for_batch(model_history_server_id, add_example_request, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param AddExampleRequest add_example_request: The add example request, encapsulating minibatch details and examples batch size (required)
        :return: AddExampleRequest
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.add_example_for_batch_with_http_info(model_history_server_id, add_example_request, **kwargs)  # noqa: E501
        else:
            (data) = self.add_example_for_batch_with_http_info(model_history_server_id, add_example_request, **kwargs)  # noqa: E501
            return data

    def add_example_for_batch_with_http_info(self, model_history_server_id, add_example_request, **kwargs):  # noqa: E501
        """Adds a number of examples to a minibatch ID given an AddExampleRequest.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_example_for_batch_with_http_info(model_history_server_id, add_example_request, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param AddExampleRequest add_example_request: The add example request, encapsulating minibatch details and examples batch size (required)
        :return: AddExampleRequest
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_history_server_id', 'add_example_request']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_example_for_batch" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_history_server_id' is set
        if ('model_history_server_id' not in params or
                params['model_history_server_id'] is None):
            raise ValueError("Missing the required parameter `model_history_server_id` when calling `add_example_for_batch`")  # noqa: E501
        # verify the required parameter 'add_example_request' is set
        if ('add_example_request' not in params or
                params['add_example_request'] is None):
            raise ValueError("Missing the required parameter `add_example_request` when calling `add_example_for_batch`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'model_history_server_id' in params:
            path_params['modelHistoryServerId'] = params['model_history_server_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'add_example_request' in params:
            body_params = params['add_example_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/rpc/{modelHistoryServerId}/model/exampleForBatch', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AddExampleRequest',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def add_example_to_minibatch(self, model_history_server_id, example_entity, **kwargs):  # noqa: E501
        """Adds an example to a minibatch  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_example_to_minibatch(model_history_server_id, example_entity, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param ExampleEntity example_entity: The example to add to the minibatch (required)
        :return: ExampleEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.add_example_to_minibatch_with_http_info(model_history_server_id, example_entity, **kwargs)  # noqa: E501
        else:
            (data) = self.add_example_to_minibatch_with_http_info(model_history_server_id, example_entity, **kwargs)  # noqa: E501
            return data

    def add_example_to_minibatch_with_http_info(self, model_history_server_id, example_entity, **kwargs):  # noqa: E501
        """Adds an example to a minibatch  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_example_to_minibatch_with_http_info(model_history_server_id, example_entity, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param ExampleEntity example_entity: The example to add to the minibatch (required)
        :return: ExampleEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_history_server_id', 'example_entity']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_example_to_minibatch" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_history_server_id' is set
        if ('model_history_server_id' not in params or
                params['model_history_server_id'] is None):
            raise ValueError("Missing the required parameter `model_history_server_id` when calling `add_example_to_minibatch`")  # noqa: E501
        # verify the required parameter 'example_entity' is set
        if ('example_entity' not in params or
                params['example_entity'] is None):
            raise ValueError("Missing the required parameter `example_entity` when calling `add_example_to_minibatch`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'model_history_server_id' in params:
            path_params['modelHistoryServerId'] = params['model_history_server_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'example_entity' in params:
            body_params = params['example_entity']
        # 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/rpc/{modelHistoryServerId}/model/example', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ExampleEntity',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def add_experiment(self, model_history_server_id, experiment_entity, **kwargs):  # noqa: E501
        """Add an experiment, given an experiment entity  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_experiment(model_history_server_id, experiment_entity, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param ExperimentEntity experiment_entity: The experiment entity to add (required)
        :return: ExperimentEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.add_experiment_with_http_info(model_history_server_id, experiment_entity, **kwargs)  # noqa: E501
        else:
            (data) = self.add_experiment_with_http_info(model_history_server_id, experiment_entity, **kwargs)  # noqa: E501
            return data

    def add_experiment_with_http_info(self, model_history_server_id, experiment_entity, **kwargs):  # noqa: E501
        """Add an experiment, given an experiment entity  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_experiment_with_http_info(model_history_server_id, experiment_entity, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param ExperimentEntity experiment_entity: The experiment entity to add (required)
        :return: ExperimentEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_history_server_id', 'experiment_entity']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_experiment" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_history_server_id' is set
        if ('model_history_server_id' not in params or
                params['model_history_server_id'] is None):
            raise ValueError("Missing the required parameter `model_history_server_id` when calling `add_experiment`")  # noqa: E501
        # verify the required parameter 'experiment_entity' is set
        if ('experiment_entity' not in params or
                params['experiment_entity'] is None):
            raise ValueError("Missing the required parameter `experiment_entity` when calling `add_experiment`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'model_history_server_id' in params:
            path_params['modelHistoryServerId'] = params['model_history_server_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'experiment_entity' in params:
            body_params = params['experiment_entity']
        # 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/rpc/{modelHistoryServerId}/experiment', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ExperimentEntity',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def add_minibatch(self, model_history_server_id, minibatch_entity, **kwargs):  # noqa: E501
        """Adds a minibatch  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_minibatch(model_history_server_id, minibatch_entity, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param MinibatchEntity minibatch_entity: The minibatch entity to add (required)
        :return: MinibatchEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.add_minibatch_with_http_info(model_history_server_id, minibatch_entity, **kwargs)  # noqa: E501
        else:
            (data) = self.add_minibatch_with_http_info(model_history_server_id, minibatch_entity, **kwargs)  # noqa: E501
            return data

    def add_minibatch_with_http_info(self, model_history_server_id, minibatch_entity, **kwargs):  # noqa: E501
        """Adds a minibatch  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_minibatch_with_http_info(model_history_server_id, minibatch_entity, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param MinibatchEntity minibatch_entity: The minibatch entity to add (required)
        :return: MinibatchEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_history_server_id', 'minibatch_entity']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_minibatch" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_history_server_id' is set
        if ('model_history_server_id' not in params or
                params['model_history_server_id'] is None):
            raise ValueError("Missing the required parameter `model_history_server_id` when calling `add_minibatch`")  # noqa: E501
        # verify the required parameter 'minibatch_entity' is set
        if ('minibatch_entity' not in params or
                params['minibatch_entity'] is None):
            raise ValueError("Missing the required parameter `minibatch_entity` when calling `add_minibatch`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'model_history_server_id' in params:
            path_params['modelHistoryServerId'] = params['model_history_server_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'minibatch_entity' in params:
            body_params = params['minibatch_entity']
        # 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/rpc/{modelHistoryServerId}/model/minibatch', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='MinibatchEntity',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def add_model_feedback(self, model_history_server_id, model_feed_back_request, **kwargs):  # noqa: E501
        """Adds an evaluation feedback to the model against a given minibatch id.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_model_feedback(model_history_server_id, model_feed_back_request, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param ModelFeedBackRequest model_feed_back_request: The model feedback request object (required)
        :return: ModelFeedBackRequest
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.add_model_feedback_with_http_info(model_history_server_id, model_feed_back_request, **kwargs)  # noqa: E501
        else:
            (data) = self.add_model_feedback_with_http_info(model_history_server_id, model_feed_back_request, **kwargs)  # noqa: E501
            return data

    def add_model_feedback_with_http_info(self, model_history_server_id, model_feed_back_request, **kwargs):  # noqa: E501
        """Adds an evaluation feedback to the model against a given minibatch id.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_model_feedback_with_http_info(model_history_server_id, model_feed_back_request, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param ModelFeedBackRequest model_feed_back_request: The model feedback request object (required)
        :return: ModelFeedBackRequest
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_history_server_id', 'model_feed_back_request']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_model_feedback" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_history_server_id' is set
        if ('model_history_server_id' not in params or
                params['model_history_server_id'] is None):
            raise ValueError("Missing the required parameter `model_history_server_id` when calling `add_model_feedback`")  # noqa: E501
        # verify the required parameter 'model_feed_back_request' is set
        if ('model_feed_back_request' not in params or
                params['model_feed_back_request'] is None):
            raise ValueError("Missing the required parameter `model_feed_back_request` when calling `add_model_feedback`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'model_history_server_id' in params:
            path_params['modelHistoryServerId'] = params['model_history_server_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'model_feed_back_request' in params:
            body_params = params['model_feed_back_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/rpc/{modelHistoryServerId}/model/feedback', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ModelFeedBackRequest',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def add_model_history(self, model_history_server_id, add_model_history_request, **kwargs):  # noqa: E501
        """Add a model history / workspace  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_model_history(model_history_server_id, add_model_history_request, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param AddModelHistoryRequest add_model_history_request: The model history request object (required)
        :return: ModelHistoryEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.add_model_history_with_http_info(model_history_server_id, add_model_history_request, **kwargs)  # noqa: E501
        else:
            (data) = self.add_model_history_with_http_info(model_history_server_id, add_model_history_request, **kwargs)  # noqa: E501
            return data

    def add_model_history_with_http_info(self, model_history_server_id, add_model_history_request, **kwargs):  # noqa: E501
        """Add a model history / workspace  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_model_history_with_http_info(model_history_server_id, add_model_history_request, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param AddModelHistoryRequest add_model_history_request: The model history request object (required)
        :return: ModelHistoryEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_history_server_id', 'add_model_history_request']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_model_history" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_history_server_id' is set
        if ('model_history_server_id' not in params or
                params['model_history_server_id'] is None):
            raise ValueError("Missing the required parameter `model_history_server_id` when calling `add_model_history`")  # noqa: E501
        # verify the required parameter 'add_model_history_request' is set
        if ('add_model_history_request' not in params or
                params['add_model_history_request'] is None):
            raise ValueError("Missing the required parameter `add_model_history_request` when calling `add_model_history`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'model_history_server_id' in params:
            path_params['modelHistoryServerId'] = params['model_history_server_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'add_model_history_request' in params:
            body_params = params['add_model_history_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/rpc/{modelHistoryServerId}/modelhistory', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ModelHistoryEntity',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def add_model_instance(self, model_history_server_id, model_instance_entity, **kwargs):  # noqa: E501
        """Adds a model  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_model_instance(model_history_server_id, model_instance_entity, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param ModelInstanceEntity model_instance_entity: The object encapsulating the model instance id and evaluation type to aggregate (required)
        :return: ModelInstanceEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.add_model_instance_with_http_info(model_history_server_id, model_instance_entity, **kwargs)  # noqa: E501
        else:
            (data) = self.add_model_instance_with_http_info(model_history_server_id, model_instance_entity, **kwargs)  # noqa: E501
            return data

    def add_model_instance_with_http_info(self, model_history_server_id, model_instance_entity, **kwargs):  # noqa: E501
        """Adds a model  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_model_instance_with_http_info(model_history_server_id, model_instance_entity, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param ModelInstanceEntity model_instance_entity: The object encapsulating the model instance id and evaluation type to aggregate (required)
        :return: ModelInstanceEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_history_server_id', 'model_instance_entity']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_model_instance" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_history_server_id' is set
        if ('model_history_server_id' not in params or
                params['model_history_server_id'] is None):
            raise ValueError("Missing the required parameter `model_history_server_id` when calling `add_model_instance`")  # noqa: E501
        # verify the required parameter 'model_instance_entity' is set
        if ('model_instance_entity' not in params or
                params['model_instance_entity'] is None):
            raise ValueError("Missing the required parameter `model_instance_entity` when calling `add_model_instance`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'model_history_server_id' in params:
            path_params['modelHistoryServerId'] = params['model_history_server_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'model_instance_entity' in params:
            body_params = params['model_instance_entity']
        # 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/rpc/{modelHistoryServerId}/model', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ModelInstanceEntity',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def add_resource(self, add_resource_request, **kwargs):  # noqa: E501
        """Adds a resource  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_resource(add_resource_request, async=True)
        >>> result = thread.get()

        :param async bool
        :param AddResourceRequest add_resource_request: The Add resource request object (required)
        :return: object
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.add_resource_with_http_info(add_resource_request, **kwargs)  # noqa: E501
        else:
            (data) = self.add_resource_with_http_info(add_resource_request, **kwargs)  # noqa: E501
            return data

    def add_resource_with_http_info(self, add_resource_request, **kwargs):  # noqa: E501
        """Adds a resource  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_resource_with_http_info(add_resource_request, async=True)
        >>> result = thread.get()

        :param async bool
        :param AddResourceRequest add_resource_request: The Add resource request object (required)
        :return: object
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['add_resource_request']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_resource" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'add_resource_request' is set
        if ('add_resource_request' not in params or
                params['add_resource_request'] is None):
            raise ValueError("Missing the required parameter `add_resource_request` when calling `add_resource`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'add_resource_request' in params:
            body_params = params['add_resource_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/resources/add/resource', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='object',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def add_resource_group(self, group_name, **kwargs):  # noqa: E501
        """Adds a resource group  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_resource_group(group_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param  group_name: Name of the resource group (required)
        :return: ResourceGroup
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.add_resource_group_with_http_info(group_name, **kwargs)  # noqa: E501
        else:
            (data) = self.add_resource_group_with_http_info(group_name, **kwargs)  # noqa: E501
            return data

    def add_resource_group_with_http_info(self, group_name, **kwargs):  # noqa: E501
        """Adds a resource group  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_resource_group_with_http_info(group_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param  group_name: Name of the resource group (required)
        :return: ResourceGroup
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['group_name']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_resource_group" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'group_name' is set
        if ('group_name' not in params or
                params['group_name'] is None):
            raise ValueError("Missing the required parameter `group_name` when calling `add_resource_group`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'group_name' in params:
            body_params = params['group_name']
        # 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
            ['text/plain; charset=utf-8'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/resources/add/group', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ResourceGroup',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def add_resource_to_group(self, resource_group_id, resource_id, **kwargs):  # noqa: E501
        """Adds a resource to a resource group  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_resource_to_group(resource_group_id, resource_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param int resource_group_id: ID of the resource group (required)
        :param int resource_id: ID of the resource (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.add_resource_to_group_with_http_info(resource_group_id, resource_id, **kwargs)  # noqa: E501
        else:
            (data) = self.add_resource_to_group_with_http_info(resource_group_id, resource_id, **kwargs)  # noqa: E501
            return data

    def add_resource_to_group_with_http_info(self, resource_group_id, resource_id, **kwargs):  # noqa: E501
        """Adds a resource to a resource group  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_resource_to_group_with_http_info(resource_group_id, resource_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param int resource_group_id: ID of the resource group (required)
        :param int resource_id: ID of the resource (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['resource_group_id', 'resource_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_resource_to_group" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'resource_group_id' is set
        if ('resource_group_id' not in params or
                params['resource_group_id'] is None):
            raise ValueError("Missing the required parameter `resource_group_id` when calling `add_resource_to_group`")  # noqa: E501
        # verify the required parameter 'resource_id' is set
        if ('resource_id' not in params or
                params['resource_id'] is None):
            raise ValueError("Missing the required parameter `resource_id` when calling `add_resource_to_group`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'resource_group_id' in params:
            path_params['resourceGroupId'] = params['resource_group_id']  # noqa: E501
        if 'resource_id' in params:
            path_params['resourceId'] = params['resource_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/resources/add/resourcetogroup/{resourceGroupId}/{resourceId}', 'GET',
            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=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def aggregate_model_results(self, model_history_server_id, aggregate_prediction, **kwargs):  # noqa: E501
        """Aggregates the evaluaition results of a model instance, based on the evaluation type  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.aggregate_model_results(model_history_server_id, aggregate_prediction, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param AggregatePrediction aggregate_prediction: The object encapsulating the model instance id and evaluation type to aggregate (required)
        :return: EvaluationResultsEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.aggregate_model_results_with_http_info(model_history_server_id, aggregate_prediction, **kwargs)  # noqa: E501
        else:
            (data) = self.aggregate_model_results_with_http_info(model_history_server_id, aggregate_prediction, **kwargs)  # noqa: E501
            return data

    def aggregate_model_results_with_http_info(self, model_history_server_id, aggregate_prediction, **kwargs):  # noqa: E501
        """Aggregates the evaluaition results of a model instance, based on the evaluation type  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.aggregate_model_results_with_http_info(model_history_server_id, aggregate_prediction, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param AggregatePrediction aggregate_prediction: The object encapsulating the model instance id and evaluation type to aggregate (required)
        :return: EvaluationResultsEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_history_server_id', 'aggregate_prediction']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method aggregate_model_results" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_history_server_id' is set
        if ('model_history_server_id' not in params or
                params['model_history_server_id'] is None):
            raise ValueError("Missing the required parameter `model_history_server_id` when calling `aggregate_model_results`")  # noqa: E501
        # verify the required parameter 'aggregate_prediction' is set
        if ('aggregate_prediction' not in params or
                params['aggregate_prediction'] is None):
            raise ValueError("Missing the required parameter `aggregate_prediction` when calling `aggregate_model_results`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'model_history_server_id' in params:
            path_params['modelHistoryServerId'] = params['model_history_server_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'aggregate_prediction' in params:
            body_params = params['aggregate_prediction']
        # 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/rpc/{modelHistoryServerId}/model/aggregateresults', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EvaluationResultsEntity',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def classify(self, body, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Use the deployed model to classify the input  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.classify(body, deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param Prediction body: The input NDArray (required)
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: ClassificationResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.classify_with_http_info(body, deployment_name, version_name, model_name, **kwargs)  # noqa: E501
        else:
            (data) = self.classify_with_http_info(body, deployment_name, version_name, model_name, **kwargs)  # noqa: E501
            return data

    def classify_with_http_info(self, body, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Use the deployed model to classify the input  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.classify_with_http_info(body, deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param Prediction body: The input NDArray (required)
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: ClassificationResult
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body', 'deployment_name', 'version_name', 'model_name']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method classify" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params or
                params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `classify`")  # noqa: E501
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `classify`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `classify`")  # noqa: E501
        # verify the required parameter 'model_name' is set
        if ('model_name' not in params or
                params['model_name'] is None):
            raise ValueError("Missing the required parameter `model_name` when calling `classify`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'model_name' in params:
            path_params['modelName'] = params['model_name']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/model/{modelName}/{versionName}/classify', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ClassificationResult',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def classifyarray(self, body, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Same as /classify but returns the output as Base64NDArrayBody  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.classifyarray(body, deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param Prediction body: The input NDArray (required)
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: Base64NDArrayBody
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.classifyarray_with_http_info(body, deployment_name, version_name, model_name, **kwargs)  # noqa: E501
        else:
            (data) = self.classifyarray_with_http_info(body, deployment_name, version_name, model_name, **kwargs)  # noqa: E501
            return data

    def classifyarray_with_http_info(self, body, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Same as /classify but returns the output as Base64NDArrayBody  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.classifyarray_with_http_info(body, deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param Prediction body: The input NDArray (required)
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: Base64NDArrayBody
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body', 'deployment_name', 'version_name', 'model_name']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method classifyarray" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params or
                params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `classifyarray`")  # noqa: E501
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `classifyarray`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `classifyarray`")  # noqa: E501
        # verify the required parameter 'model_name' is set
        if ('model_name' not in params or
                params['model_name'] is None):
            raise ValueError("Missing the required parameter `model_name` when calling `classifyarray`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'model_name' in params:
            path_params['modelName'] = params['model_name']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/model/{modelName}/{versionName}/classifyarray', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Base64NDArrayBody',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def classifyimage(self, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Use the deployed model to classify the input, using input image file from multipart form data.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.classifyimage(deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :param file image: The file to upload.
        :return: ClassificationResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.classifyimage_with_http_info(deployment_name, version_name, model_name, **kwargs)  # noqa: E501
        else:
            (data) = self.classifyimage_with_http_info(deployment_name, version_name, model_name, **kwargs)  # noqa: E501
            return data

    def classifyimage_with_http_info(self, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Use the deployed model to classify the input, using input image file from multipart form data.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.classifyimage_with_http_info(deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :param file image: The file to upload.
        :return: ClassificationResult
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['deployment_name', 'version_name', 'model_name', 'image']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method classifyimage" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `classifyimage`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `classifyimage`")  # noqa: E501
        # verify the required parameter 'model_name' is set
        if ('model_name' not in params or
                params['model_name'] is None):
            raise ValueError("Missing the required parameter `model_name` when calling `classifyimage`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'model_name' in params:
            path_params['modelName'] = params['model_name']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}
        if 'image' in params:
            local_var_files['image'] = params['image']  # noqa: E501

        body_params = None
        # 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
            ['multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/model/{modelName}/{versionName}/classifyimage', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ClassificationResult',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_job(self, job_id_or_type, create_job_request, **kwargs):  # noqa: E501
        """Create a job  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_job(job_id_or_type, create_job_request, async=True)
        >>> result = thread.get()

        :param async bool
        :param str job_id_or_type: Job Type (required)
        :param CreateJobRequest create_job_request: Create job request object (required)
        :return: JobEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.create_job_with_http_info(job_id_or_type, create_job_request, **kwargs)  # noqa: E501
        else:
            (data) = self.create_job_with_http_info(job_id_or_type, create_job_request, **kwargs)  # noqa: E501
            return data

    def create_job_with_http_info(self, job_id_or_type, create_job_request, **kwargs):  # noqa: E501
        """Create a job  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_job_with_http_info(job_id_or_type, create_job_request, async=True)
        >>> result = thread.get()

        :param async bool
        :param str job_id_or_type: Job Type (required)
        :param CreateJobRequest create_job_request: Create job request object (required)
        :return: JobEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['job_id_or_type', 'create_job_request']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_job" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'job_id_or_type' is set
        if ('job_id_or_type' not in params or
                params['job_id_or_type'] is None):
            raise ValueError("Missing the required parameter `job_id_or_type` when calling `create_job`")  # noqa: E501
        # verify the required parameter 'create_job_request' is set
        if ('create_job_request' not in params or
                params['create_job_request'] is None):
            raise ValueError("Missing the required parameter `create_job_request` when calling `create_job`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'job_id_or_type' in params:
            path_params['jobIdOrType'] = params['job_id_or_type']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_job_request' in params:
            body_params = params['create_job_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/jobs/{jobIdOrType}', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='JobEntity',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_model_history(self, model_history_server_id, model_history_entity, **kwargs):  # noqa: E501
        """Creates model History  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_model_history(model_history_server_id, model_history_entity, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param ModelHistoryEntity model_history_entity: The model history entity (required)
        :return: ModelHistoryEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.create_model_history_with_http_info(model_history_server_id, model_history_entity, **kwargs)  # noqa: E501
        else:
            (data) = self.create_model_history_with_http_info(model_history_server_id, model_history_entity, **kwargs)  # noqa: E501
            return data

    def create_model_history_with_http_info(self, model_history_server_id, model_history_entity, **kwargs):  # noqa: E501
        """Creates model History  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_model_history_with_http_info(model_history_server_id, model_history_entity, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param ModelHistoryEntity model_history_entity: The model history entity (required)
        :return: ModelHistoryEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_history_server_id', 'model_history_entity']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_model_history" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_history_server_id' is set
        if ('model_history_server_id' not in params or
                params['model_history_server_id'] is None):
            raise ValueError("Missing the required parameter `model_history_server_id` when calling `create_model_history`")  # noqa: E501
        # verify the required parameter 'model_history_entity' is set
        if ('model_history_entity' not in params or
                params['model_history_entity'] is None):
            raise ValueError("Missing the required parameter `model_history_entity` when calling `create_model_history`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'model_history_server_id' in params:
            path_params['modelHistoryServerId'] = params['model_history_server_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'model_history_entity' in params:
            body_params = params['model_history_entity']
        # 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/rpc/{modelHistoryServerId}/model/revisions', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ModelHistoryEntity',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_credentials_by_id(self, credential_id, **kwargs):  # noqa: E501
        """Delete credentials given an ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_credentials_by_id(credential_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param int credential_id: Credentials ID (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.delete_credentials_by_id_with_http_info(credential_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_credentials_by_id_with_http_info(credential_id, **kwargs)  # noqa: E501
            return data

    def delete_credentials_by_id_with_http_info(self, credential_id, **kwargs):  # noqa: E501
        """Delete credentials given an ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_credentials_by_id_with_http_info(credential_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param int credential_id: Credentials ID (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['credential_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_credentials_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'credential_id' is set
        if ('credential_id' not in params or
                params['credential_id'] is None):
            raise ValueError("Missing the required parameter `credential_id` when calling `delete_credentials_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'credential_id' in params:
            path_params['credentialId'] = params['credential_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/resources/credentials/{credentialId}', '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=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_experiment(self, model_history_server_id, experiment_id, **kwargs):  # noqa: E501
        """Deletes an experiment, given an experiment entity  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_experiment(model_history_server_id, experiment_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param str experiment_id: the GUID of the experiment to delete (required)
        :return: InlineResponse200
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.delete_experiment_with_http_info(model_history_server_id, experiment_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_experiment_with_http_info(model_history_server_id, experiment_id, **kwargs)  # noqa: E501
            return data

    def delete_experiment_with_http_info(self, model_history_server_id, experiment_id, **kwargs):  # noqa: E501
        """Deletes an experiment, given an experiment entity  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_experiment_with_http_info(model_history_server_id, experiment_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param str experiment_id: the GUID of the experiment to delete (required)
        :return: InlineResponse200
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_history_server_id', 'experiment_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_experiment" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_history_server_id' is set
        if ('model_history_server_id' not in params or
                params['model_history_server_id'] is None):
            raise ValueError("Missing the required parameter `model_history_server_id` when calling `delete_experiment`")  # noqa: E501
        # verify the required parameter 'experiment_id' is set
        if ('experiment_id' not in params or
                params['experiment_id'] is None):
            raise ValueError("Missing the required parameter `experiment_id` when calling `delete_experiment`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'model_history_server_id' in params:
            path_params['modelHistoryServerId'] = params['model_history_server_id']  # noqa: E501
        if 'experiment_id' in params:
            path_params['experimentID'] = params['experiment_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/rpc/{modelHistoryServerId}/experiment/{experimentID}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_job_by_id(self, job_id_or_type, **kwargs):  # noqa: E501
        """Deletes a job given its ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_job_by_id(job_id_or_type, async=True)
        >>> result = thread.get()

        :param async bool
        :param int job_id_or_type: Job ID (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.delete_job_by_id_with_http_info(job_id_or_type, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_job_by_id_with_http_info(job_id_or_type, **kwargs)  # noqa: E501
            return data

    def delete_job_by_id_with_http_info(self, job_id_or_type, **kwargs):  # noqa: E501
        """Deletes a job given its ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_job_by_id_with_http_info(job_id_or_type, async=True)
        >>> result = thread.get()

        :param async bool
        :param int job_id_or_type: Job ID (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['job_id_or_type']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_job_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'job_id_or_type' is set
        if ('job_id_or_type' not in params or
                params['job_id_or_type'] is None):
            raise ValueError("Missing the required parameter `job_id_or_type` when calling `delete_job_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'job_id_or_type' in params:
            path_params['jobIdOrType'] = params['job_id_or_type']  # 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/jobs/{jobIdOrType}', '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=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_model(self, deployment_id, model_id, **kwargs):  # noqa: E501
        """Delete a model by deployment and model id  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_model(deployment_id, model_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_id: ID deployment group (required)
        :param str model_id: the id of the deployed model (required)
        :return: InlineResponse200
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.delete_model_with_http_info(deployment_id, model_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_model_with_http_info(deployment_id, model_id, **kwargs)  # noqa: E501
            return data

    def delete_model_with_http_info(self, deployment_id, model_id, **kwargs):  # noqa: E501
        """Delete a model by deployment and model id  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_model_with_http_info(deployment_id, model_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_id: ID deployment group (required)
        :param str model_id: the id of the deployed model (required)
        :return: InlineResponse200
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['deployment_id', 'model_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_model" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'deployment_id' is set
        if ('deployment_id' not in params or
                params['deployment_id'] is None):
            raise ValueError("Missing the required parameter `deployment_id` when calling `delete_model`")  # noqa: E501
        # verify the required parameter 'model_id' is set
        if ('model_id' not in params or
                params['model_id'] is None):
            raise ValueError("Missing the required parameter `model_id` when calling `delete_model`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_id' in params:
            path_params['deploymentId'] = params['deployment_id']  # noqa: E501
        if 'model_id' in params:
            path_params['modelId'] = params['model_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/deployment/{deploymentId}/model/{modelId}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_model_history(self, model_history_server_id, model_history_id, **kwargs):  # noqa: E501
        """Deletes a model history / workspace, given its ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_model_history(model_history_server_id, model_history_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param str model_history_id: the GUID of the model history / workspace to delete (required)
        :return: InlineResponse200
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.delete_model_history_with_http_info(model_history_server_id, model_history_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_model_history_with_http_info(model_history_server_id, model_history_id, **kwargs)  # noqa: E501
            return data

    def delete_model_history_with_http_info(self, model_history_server_id, model_history_id, **kwargs):  # noqa: E501
        """Deletes a model history / workspace, given its ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_model_history_with_http_info(model_history_server_id, model_history_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param str model_history_id: the GUID of the model history / workspace to delete (required)
        :return: InlineResponse200
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_history_server_id', 'model_history_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_model_history" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_history_server_id' is set
        if ('model_history_server_id' not in params or
                params['model_history_server_id'] is None):
            raise ValueError("Missing the required parameter `model_history_server_id` when calling `delete_model_history`")  # noqa: E501
        # verify the required parameter 'model_history_id' is set
        if ('model_history_id' not in params or
                params['model_history_id'] is None):
            raise ValueError("Missing the required parameter `model_history_id` when calling `delete_model_history`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'model_history_server_id' in params:
            path_params['modelHistoryServerId'] = params['model_history_server_id']  # noqa: E501
        if 'model_history_id' in params:
            path_params['modelHistoryID'] = params['model_history_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/rpc/{modelHistoryServerId}/modelhistory/{modelHistoryID}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_model_instance(self, model_history_server_id, model_instance_id, **kwargs):  # noqa: E501
        """Deletes a model instance, given its ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_model_instance(model_history_server_id, model_instance_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param str model_instance_id: GUID of the model instance to delete. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.delete_model_instance_with_http_info(model_history_server_id, model_instance_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_model_instance_with_http_info(model_history_server_id, model_instance_id, **kwargs)  # noqa: E501
            return data

    def delete_model_instance_with_http_info(self, model_history_server_id, model_instance_id, **kwargs):  # noqa: E501
        """Deletes a model instance, given its ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_model_instance_with_http_info(model_history_server_id, model_instance_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param str model_instance_id: GUID of the model instance to delete. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_history_server_id', 'model_instance_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_model_instance" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_history_server_id' is set
        if ('model_history_server_id' not in params or
                params['model_history_server_id'] is None):
            raise ValueError("Missing the required parameter `model_history_server_id` when calling `delete_model_instance`")  # noqa: E501
        # verify the required parameter 'model_instance_id' is set
        if ('model_instance_id' not in params or
                params['model_instance_id'] is None):
            raise ValueError("Missing the required parameter `model_instance_id` when calling `delete_model_instance`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'model_history_server_id' in params:
            path_params['modelHistoryServerId'] = params['model_history_server_id']  # noqa: E501
        if 'model_instance_id' in params:
            path_params['modelInstanceID'] = params['model_instance_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/rpc/{modelHistoryServerId}/model/{modelInstanceID}', '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=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_resource_by_id(self, resource_id, **kwargs):  # noqa: E501
        """Delete the resource with the specified resource ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_resource_by_id(resource_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param int resource_id: ID of the resource (required)
        :return: Resource
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.delete_resource_by_id_with_http_info(resource_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_resource_by_id_with_http_info(resource_id, **kwargs)  # noqa: E501
            return data

    def delete_resource_by_id_with_http_info(self, resource_id, **kwargs):  # noqa: E501
        """Delete the resource with the specified resource ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_resource_by_id_with_http_info(resource_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param int resource_id: ID of the resource (required)
        :return: Resource
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['resource_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_resource_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'resource_id' is set
        if ('resource_id' not in params or
                params['resource_id'] is None):
            raise ValueError("Missing the required parameter `resource_id` when calling `delete_resource_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'resource_id' in params:
            path_params['resourceId'] = params['resource_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/resources/remove/resource/{resourceId}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Resource',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_resource_from_group(self, resource_group_id, resource_id, **kwargs):  # noqa: E501
        """Removes a resource from a resource group  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_resource_from_group(resource_group_id, resource_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param int resource_group_id: ID of the resource group (required)
        :param int resource_id: ID of the resource (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.delete_resource_from_group_with_http_info(resource_group_id, resource_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_resource_from_group_with_http_info(resource_group_id, resource_id, **kwargs)  # noqa: E501
            return data

    def delete_resource_from_group_with_http_info(self, resource_group_id, resource_id, **kwargs):  # noqa: E501
        """Removes a resource from a resource group  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_resource_from_group_with_http_info(resource_group_id, resource_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param int resource_group_id: ID of the resource group (required)
        :param int resource_id: ID of the resource (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['resource_group_id', 'resource_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_resource_from_group" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'resource_group_id' is set
        if ('resource_group_id' not in params or
                params['resource_group_id'] is None):
            raise ValueError("Missing the required parameter `resource_group_id` when calling `delete_resource_from_group`")  # noqa: E501
        # verify the required parameter 'resource_id' is set
        if ('resource_id' not in params or
                params['resource_id'] is None):
            raise ValueError("Missing the required parameter `resource_id` when calling `delete_resource_from_group`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'resource_group_id' in params:
            path_params['resourceGroupId'] = params['resource_group_id']  # noqa: E501
        if 'resource_id' in params:
            path_params['resourceId'] = params['resource_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/resources/remove/resourcefromgroup/{resourceGroupId}/{resourceId}', 'GET',
            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=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_resource_group_by_id(self, resource_group_id, **kwargs):  # noqa: E501
        """Delete the resource group with the specified resource group ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_resource_group_by_id(resource_group_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param int resource_group_id: ID of the resource group (required)
        :return: ResourceGroup
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.delete_resource_group_by_id_with_http_info(resource_group_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_resource_group_by_id_with_http_info(resource_group_id, **kwargs)  # noqa: E501
            return data

    def delete_resource_group_by_id_with_http_info(self, resource_group_id, **kwargs):  # noqa: E501
        """Delete the resource group with the specified resource group ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_resource_group_by_id_with_http_info(resource_group_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param int resource_group_id: ID of the resource group (required)
        :return: ResourceGroup
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['resource_group_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_resource_group_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'resource_group_id' is set
        if ('resource_group_id' not in params or
                params['resource_group_id'] is None):
            raise ValueError("Missing the required parameter `resource_group_id` when calling `delete_resource_group_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'resource_group_id' in params:
            path_params['resourceGroupId'] = params['resource_group_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/resources/remove/group/{resourceGroupId}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ResourceGroup',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def deploy_model(self, deployment_id, body, **kwargs):  # noqa: E501
        """Deploy a model in a deployment group.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.deploy_model(deployment_id, body, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_id: ID deployment group (required)
        :param ImportModelRequest body: the model import request (required)
        :return: ModelEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.deploy_model_with_http_info(deployment_id, body, **kwargs)  # noqa: E501
        else:
            (data) = self.deploy_model_with_http_info(deployment_id, body, **kwargs)  # noqa: E501
            return data

    def deploy_model_with_http_info(self, deployment_id, body, **kwargs):  # noqa: E501
        """Deploy a model in a deployment group.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.deploy_model_with_http_info(deployment_id, body, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_id: ID deployment group (required)
        :param ImportModelRequest body: the model import request (required)
        :return: ModelEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['deployment_id', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method deploy_model" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'deployment_id' is set
        if ('deployment_id' not in params or
                params['deployment_id'] is None):
            raise ValueError("Missing the required parameter `deployment_id` when calling `deploy_model`")  # noqa: E501
        # verify the required parameter 'body' is set
        if ('body' not in params or
                params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `deploy_model`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_id' in params:
            path_params['deploymentId'] = params['deployment_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/deployment/{deploymentId}/model', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ModelEntity',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def deployment_create(self, body, **kwargs):  # noqa: E501
        """Create a new deployment group.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.deployment_create(body, async=True)
        >>> result = thread.get()

        :param async bool
        :param CreateDeploymentRequest body: the deployment request (required)
        :return: DeploymentResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.deployment_create_with_http_info(body, **kwargs)  # noqa: E501
        else:
            (data) = self.deployment_create_with_http_info(body, **kwargs)  # noqa: E501
            return data

    def deployment_create_with_http_info(self, body, **kwargs):  # noqa: E501
        """Create a new deployment group.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.deployment_create_with_http_info(body, async=True)
        >>> result = thread.get()

        :param async bool
        :param CreateDeploymentRequest body: the deployment request (required)
        :return: DeploymentResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method deployment_create" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params or
                params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `deployment_create`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/deployment', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DeploymentResponse',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def deployment_delete(self, deployment_id, **kwargs):  # noqa: E501
        """Delete a deployment by id  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.deployment_delete(deployment_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_id: Id of the deployment group (required)
        :return: InlineResponse200
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.deployment_delete_with_http_info(deployment_id, **kwargs)  # noqa: E501
        else:
            (data) = self.deployment_delete_with_http_info(deployment_id, **kwargs)  # noqa: E501
            return data

    def deployment_delete_with_http_info(self, deployment_id, **kwargs):  # noqa: E501
        """Delete a deployment by id  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.deployment_delete_with_http_info(deployment_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_id: Id of the deployment group (required)
        :return: InlineResponse200
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['deployment_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method deployment_delete" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'deployment_id' is set
        if ('deployment_id' not in params or
                params['deployment_id'] is None):
            raise ValueError("Missing the required parameter `deployment_id` when calling `deployment_delete`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_id' in params:
            path_params['deploymentId'] = params['deployment_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/deployment/{deploymentId}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def deployment_get(self, deployment_id, **kwargs):  # noqa: E501
        """Get a deployment details by id  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.deployment_get(deployment_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_id: Id of the deployment group (required)
        :return: DeploymentResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.deployment_get_with_http_info(deployment_id, **kwargs)  # noqa: E501
        else:
            (data) = self.deployment_get_with_http_info(deployment_id, **kwargs)  # noqa: E501
            return data

    def deployment_get_with_http_info(self, deployment_id, **kwargs):  # noqa: E501
        """Get a deployment details by id  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.deployment_get_with_http_info(deployment_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_id: Id of the deployment group (required)
        :return: DeploymentResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['deployment_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method deployment_get" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'deployment_id' is set
        if ('deployment_id' not in params or
                params['deployment_id'] is None):
            raise ValueError("Missing the required parameter `deployment_id` when calling `deployment_get`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_id' in params:
            path_params['deploymentId'] = params['deployment_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/deployment/{deploymentId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DeploymentResponse',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def deployments(self, **kwargs):  # noqa: E501
        """Get a list of deployments  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.deployments(async=True)
        >>> result = thread.get()

        :param async bool
        :return: list[DeploymentResponse]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.deployments_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.deployments_with_http_info(**kwargs)  # noqa: E501
            return data

    def deployments_with_http_info(self, **kwargs):  # noqa: E501
        """Get a list of deployments  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.deployments_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :return: list[DeploymentResponse]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = []  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method deployments" % key
                )
            params[key] = val
        del 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/deployments', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[DeploymentResponse]',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def detectobjects(self, id, needs_preprocessing, threshold, image_file, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Detect the objects, given a (input) prediction request  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.detectobjects(id, needs_preprocessing, threshold, image_file, deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param str id: the GUID for mapping the results in the detections (required)
        :param bool needs_preprocessing: (true) if the image needs preprocessing (required)
        :param float threshold: A threshold, indicating the required surety for detecting a bounding box. For example, a threshold of 0.1 might give thousand bounding boxes for an image and a threshold of 0.99 might give none. (required)
        :param file image_file: the image file to detect objects from (required)
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: DetectionResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.detectobjects_with_http_info(id, needs_preprocessing, threshold, image_file, deployment_name, version_name, model_name, **kwargs)  # noqa: E501
        else:
            (data) = self.detectobjects_with_http_info(id, needs_preprocessing, threshold, image_file, deployment_name, version_name, model_name, **kwargs)  # noqa: E501
            return data

    def detectobjects_with_http_info(self, id, needs_preprocessing, threshold, image_file, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Detect the objects, given a (input) prediction request  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.detectobjects_with_http_info(id, needs_preprocessing, threshold, image_file, deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param str id: the GUID for mapping the results in the detections (required)
        :param bool needs_preprocessing: (true) if the image needs preprocessing (required)
        :param float threshold: A threshold, indicating the required surety for detecting a bounding box. For example, a threshold of 0.1 might give thousand bounding boxes for an image and a threshold of 0.99 might give none. (required)
        :param file image_file: the image file to detect objects from (required)
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: DetectionResult
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['id', 'needs_preprocessing', 'threshold', 'image_file', 'deployment_name', 'version_name', 'model_name']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method detectobjects" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'id' is set
        if ('id' not in params or
                params['id'] is None):
            raise ValueError("Missing the required parameter `id` when calling `detectobjects`")  # noqa: E501
        # verify the required parameter 'needs_preprocessing' is set
        if ('needs_preprocessing' not in params or
                params['needs_preprocessing'] is None):
            raise ValueError("Missing the required parameter `needs_preprocessing` when calling `detectobjects`")  # noqa: E501
        # verify the required parameter 'threshold' is set
        if ('threshold' not in params or
                params['threshold'] is None):
            raise ValueError("Missing the required parameter `threshold` when calling `detectobjects`")  # noqa: E501
        # verify the required parameter 'image_file' is set
        if ('image_file' not in params or
                params['image_file'] is None):
            raise ValueError("Missing the required parameter `image_file` when calling `detectobjects`")  # noqa: E501
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `detectobjects`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `detectobjects`")  # noqa: E501
        # verify the required parameter 'model_name' is set
        if ('model_name' not in params or
                params['model_name'] is None):
            raise ValueError("Missing the required parameter `model_name` when calling `detectobjects`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'model_name' in params:
            path_params['modelName'] = params['model_name']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}
        if 'id' in params:
            form_params.append(('id', params['id']))  # noqa: E501
        if 'needs_preprocessing' in params:
            form_params.append(('needsPreprocessing', params['needs_preprocessing']))  # noqa: E501
        if 'threshold' in params:
            form_params.append(('threshold', params['threshold']))  # noqa: E501
        if 'image_file' in params:
            local_var_files['imageFile'] = params['image_file']  # noqa: E501

        body_params = None
        # 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
            ['multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/model/{modelName}/{versionName}/detectobjects', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DetectionResult',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def download_job_output_file(self, job_id, download_output_file_request, **kwargs):  # noqa: E501
        """Download the output file from the job&#39;s execution. This will ONLY work if the job&#39;s run status is &#39;COMPLETE&#39;.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.download_job_output_file(job_id, download_output_file_request, async=True)
        >>> result = thread.get()

        :param async bool
        :param int job_id: Job ID (required)
        :param DownloadOutputFileRequest download_output_file_request: Download output file request object (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.download_job_output_file_with_http_info(job_id, download_output_file_request, **kwargs)  # noqa: E501
        else:
            (data) = self.download_job_output_file_with_http_info(job_id, download_output_file_request, **kwargs)  # noqa: E501
            return data

    def download_job_output_file_with_http_info(self, job_id, download_output_file_request, **kwargs):  # noqa: E501
        """Download the output file from the job&#39;s execution. This will ONLY work if the job&#39;s run status is &#39;COMPLETE&#39;.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.download_job_output_file_with_http_info(job_id, download_output_file_request, async=True)
        >>> result = thread.get()

        :param async bool
        :param int job_id: Job ID (required)
        :param DownloadOutputFileRequest download_output_file_request: Download output file request object (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['job_id', 'download_output_file_request']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method download_job_output_file" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'job_id' is set
        if ('job_id' not in params or
                params['job_id'] is None):
            raise ValueError("Missing the required parameter `job_id` when calling `download_job_output_file`")  # noqa: E501
        # verify the required parameter 'download_output_file_request' is set
        if ('download_output_file_request' not in params or
                params['download_output_file_request'] is None):
            raise ValueError("Missing the required parameter `download_output_file_request` when calling `download_job_output_file`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'job_id' in params:
            path_params['jobId'] = params['job_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'download_output_file_request' in params:
            body_params = params['download_output_file_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/jobs/{jobId}/outputfile', 'POST',
            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=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_all_jobs(self, **kwargs):  # noqa: E501
        """Get a list of all available jobs  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_all_jobs(async=True)
        >>> result = thread.get()

        :param async bool
        :return: list[JobEntity]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.get_all_jobs_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.get_all_jobs_with_http_info(**kwargs)  # noqa: E501
            return data

    def get_all_jobs_with_http_info(self, **kwargs):  # noqa: E501
        """Get a list of all available jobs  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_all_jobs_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :return: list[JobEntity]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = []  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_all_jobs" % key
                )
            params[key] = val
        del 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/jobs', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[JobEntity]',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_best_model_among_model_ids(self, model_history_server_id, best_model, **kwargs):  # noqa: E501
        """Gets the best model among the given model instance IDs, based on the evaluation type and column metric  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_best_model_among_model_ids(model_history_server_id, best_model, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param BestModel best_model: Object encapsulating the model ids, eval type and column metric name (required)
        :return: ModelInstanceEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.get_best_model_among_model_ids_with_http_info(model_history_server_id, best_model, **kwargs)  # noqa: E501
        else:
            (data) = self.get_best_model_among_model_ids_with_http_info(model_history_server_id, best_model, **kwargs)  # noqa: E501
            return data

    def get_best_model_among_model_ids_with_http_info(self, model_history_server_id, best_model, **kwargs):  # noqa: E501
        """Gets the best model among the given model instance IDs, based on the evaluation type and column metric  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_best_model_among_model_ids_with_http_info(model_history_server_id, best_model, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param BestModel best_model: Object encapsulating the model ids, eval type and column metric name (required)
        :return: ModelInstanceEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_history_server_id', 'best_model']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_best_model_among_model_ids" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_history_server_id' is set
        if ('model_history_server_id' not in params or
                params['model_history_server_id'] is None):
            raise ValueError("Missing the required parameter `model_history_server_id` when calling `get_best_model_among_model_ids`")  # noqa: E501
        # verify the required parameter 'best_model' is set
        if ('best_model' not in params or
                params['best_model'] is None):
            raise ValueError("Missing the required parameter `best_model` when calling `get_best_model_among_model_ids`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'model_history_server_id' in params:
            path_params['modelHistoryServerId'] = params['model_history_server_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'best_model' in params:
            body_params = params['best_model']
        # 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/rpc/{modelHistoryServerId}/model/best', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ModelInstanceEntity',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_credentials_by_id(self, credential_id, **kwargs):  # noqa: E501
        """Get credentials given an ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_credentials_by_id(credential_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param int credential_id: Credentials ID (required)
        :return: ResourceCredentials
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.get_credentials_by_id_with_http_info(credential_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_credentials_by_id_with_http_info(credential_id, **kwargs)  # noqa: E501
            return data

    def get_credentials_by_id_with_http_info(self, credential_id, **kwargs):  # noqa: E501
        """Get credentials given an ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_credentials_by_id_with_http_info(credential_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param int credential_id: Credentials ID (required)
        :return: ResourceCredentials
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['credential_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_credentials_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'credential_id' is set
        if ('credential_id' not in params or
                params['credential_id'] is None):
            raise ValueError("Missing the required parameter `credential_id` when calling `get_credentials_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'credential_id' in params:
            path_params['credentialId'] = params['credential_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/resources/credentials/{credentialId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ResourceCredentials',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_evaluation_for_model_id(self, model_history_server_id, model_instance_id, **kwargs):  # noqa: E501
        """Gets the list of evaluation results entity, given a model instance ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_evaluation_for_model_id(model_history_server_id, model_instance_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param str model_instance_id: GUID of the model instance to get evaluation results for. (required)
        :return: list[EvaluationResultsEntity]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.get_evaluation_for_model_id_with_http_info(model_history_server_id, model_instance_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_evaluation_for_model_id_with_http_info(model_history_server_id, model_instance_id, **kwargs)  # noqa: E501
            return data

    def get_evaluation_for_model_id_with_http_info(self, model_history_server_id, model_instance_id, **kwargs):  # noqa: E501
        """Gets the list of evaluation results entity, given a model instance ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_evaluation_for_model_id_with_http_info(model_history_server_id, model_instance_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param str model_instance_id: GUID of the model instance to get evaluation results for. (required)
        :return: list[EvaluationResultsEntity]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_history_server_id', 'model_instance_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_evaluation_for_model_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_history_server_id' is set
        if ('model_history_server_id' not in params or
                params['model_history_server_id'] is None):
            raise ValueError("Missing the required parameter `model_history_server_id` when calling `get_evaluation_for_model_id`")  # noqa: E501
        # verify the required parameter 'model_instance_id' is set
        if ('model_instance_id' not in params or
                params['model_instance_id'] is None):
            raise ValueError("Missing the required parameter `model_instance_id` when calling `get_evaluation_for_model_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'model_history_server_id' in params:
            path_params['modelHistoryServerId'] = params['model_history_server_id']  # noqa: E501
        if 'model_instance_id' in params:
            path_params['modelInstanceID'] = params['model_instance_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/rpc/{modelHistoryServerId}/model/revisions/evaluations/{modelInstanceID}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[EvaluationResultsEntity]',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_examples_for_minibatch(self, model_history_server_id, minibatch_id, **kwargs):  # noqa: E501
        """Gets all the examples for a minibatch ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_examples_for_minibatch(model_history_server_id, minibatch_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param str minibatch_id: The GUID of the minibatch (required)
        :return: list[ExampleEntity]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.get_examples_for_minibatch_with_http_info(model_history_server_id, minibatch_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_examples_for_minibatch_with_http_info(model_history_server_id, minibatch_id, **kwargs)  # noqa: E501
            return data

    def get_examples_for_minibatch_with_http_info(self, model_history_server_id, minibatch_id, **kwargs):  # noqa: E501
        """Gets all the examples for a minibatch ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_examples_for_minibatch_with_http_info(model_history_server_id, minibatch_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param str minibatch_id: The GUID of the minibatch (required)
        :return: list[ExampleEntity]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_history_server_id', 'minibatch_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_examples_for_minibatch" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_history_server_id' is set
        if ('model_history_server_id' not in params or
                params['model_history_server_id'] is None):
            raise ValueError("Missing the required parameter `model_history_server_id` when calling `get_examples_for_minibatch`")  # noqa: E501
        # verify the required parameter 'minibatch_id' is set
        if ('minibatch_id' not in params or
                params['minibatch_id'] is None):
            raise ValueError("Missing the required parameter `minibatch_id` when calling `get_examples_for_minibatch`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'model_history_server_id' in params:
            path_params['modelHistoryServerId'] = params['model_history_server_id']  # noqa: E501
        if 'minibatch_id' in params:
            path_params['minibatchId'] = params['minibatch_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/rpc/{modelHistoryServerId}/model/example/{minibatchId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[ExampleEntity]',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_experiment(self, model_history_server_id, experiment_id, **kwargs):  # noqa: E501
        """Obtain an experiment&#39;s details, given its ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_experiment(model_history_server_id, experiment_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param str experiment_id: the GUID of the experiment to obtain (required)
        :return: ExperimentEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.get_experiment_with_http_info(model_history_server_id, experiment_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_experiment_with_http_info(model_history_server_id, experiment_id, **kwargs)  # noqa: E501
            return data

    def get_experiment_with_http_info(self, model_history_server_id, experiment_id, **kwargs):  # noqa: E501
        """Obtain an experiment&#39;s details, given its ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_experiment_with_http_info(model_history_server_id, experiment_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param str experiment_id: the GUID of the experiment to obtain (required)
        :return: ExperimentEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_history_server_id', 'experiment_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_experiment" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_history_server_id' is set
        if ('model_history_server_id' not in params or
                params['model_history_server_id'] is None):
            raise ValueError("Missing the required parameter `model_history_server_id` when calling `get_experiment`")  # noqa: E501
        # verify the required parameter 'experiment_id' is set
        if ('experiment_id' not in params or
                params['experiment_id'] is None):
            raise ValueError("Missing the required parameter `experiment_id` when calling `get_experiment`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'model_history_server_id' in params:
            path_params['modelHistoryServerId'] = params['model_history_server_id']  # noqa: E501
        if 'experiment_id' in params:
            path_params['experimentID'] = params['experiment_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/rpc/{modelHistoryServerId}/experiment/{experimentID}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ExperimentEntity',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_experiments_for_model_history(self, model_history_server_id, model_history_id, **kwargs):  # noqa: E501
        """Obtain all experiments for a model history / workspace  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_experiments_for_model_history(model_history_server_id, model_history_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param str model_history_id: the GUID of the model history / workspace (required)
        :return: ExperimentEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.get_experiments_for_model_history_with_http_info(model_history_server_id, model_history_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_experiments_for_model_history_with_http_info(model_history_server_id, model_history_id, **kwargs)  # noqa: E501
            return data

    def get_experiments_for_model_history_with_http_info(self, model_history_server_id, model_history_id, **kwargs):  # noqa: E501
        """Obtain all experiments for a model history / workspace  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_experiments_for_model_history_with_http_info(model_history_server_id, model_history_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param str model_history_id: the GUID of the model history / workspace (required)
        :return: ExperimentEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_history_server_id', 'model_history_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_experiments_for_model_history" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_history_server_id' is set
        if ('model_history_server_id' not in params or
                params['model_history_server_id'] is None):
            raise ValueError("Missing the required parameter `model_history_server_id` when calling `get_experiments_for_model_history`")  # noqa: E501
        # verify the required parameter 'model_history_id' is set
        if ('model_history_id' not in params or
                params['model_history_id'] is None):
            raise ValueError("Missing the required parameter `model_history_id` when calling `get_experiments_for_model_history`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'model_history_server_id' in params:
            path_params['modelHistoryServerId'] = params['model_history_server_id']  # noqa: E501
        if 'model_history_id' in params:
            path_params['modelHistoryID'] = params['model_history_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/rpc/{modelHistoryServerId}/experiments/{modelHistoryID}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ExperimentEntity',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_job_by_id(self, job_id_or_type, **kwargs):  # noqa: E501
        """Get a job by its ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_job_by_id(job_id_or_type, async=True)
        >>> result = thread.get()

        :param async bool
        :param int job_id_or_type: Job ID (required)
        :return: JobEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.get_job_by_id_with_http_info(job_id_or_type, **kwargs)  # noqa: E501
        else:
            (data) = self.get_job_by_id_with_http_info(job_id_or_type, **kwargs)  # noqa: E501
            return data

    def get_job_by_id_with_http_info(self, job_id_or_type, **kwargs):  # noqa: E501
        """Get a job by its ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_job_by_id_with_http_info(job_id_or_type, async=True)
        >>> result = thread.get()

        :param async bool
        :param int job_id_or_type: Job ID (required)
        :return: JobEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['job_id_or_type']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_job_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'job_id_or_type' is set
        if ('job_id_or_type' not in params or
                params['job_id_or_type'] is None):
            raise ValueError("Missing the required parameter `job_id_or_type` when calling `get_job_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'job_id_or_type' in params:
            path_params['jobIdOrType'] = params['job_id_or_type']  # 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/jobs/{jobIdOrType}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='JobEntity',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_minibatch(self, model_history_server_id, minibatch_id, **kwargs):  # noqa: E501
        """Gets a minibatch for the model  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_minibatch(model_history_server_id, minibatch_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param str minibatch_id: The GUID of the minibatch (required)
        :return: MinibatchEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.get_minibatch_with_http_info(model_history_server_id, minibatch_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_minibatch_with_http_info(model_history_server_id, minibatch_id, **kwargs)  # noqa: E501
            return data

    def get_minibatch_with_http_info(self, model_history_server_id, minibatch_id, **kwargs):  # noqa: E501
        """Gets a minibatch for the model  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_minibatch_with_http_info(model_history_server_id, minibatch_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param str minibatch_id: The GUID of the minibatch (required)
        :return: MinibatchEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_history_server_id', 'minibatch_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_minibatch" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_history_server_id' is set
        if ('model_history_server_id' not in params or
                params['model_history_server_id'] is None):
            raise ValueError("Missing the required parameter `model_history_server_id` when calling `get_minibatch`")  # noqa: E501
        # verify the required parameter 'minibatch_id' is set
        if ('minibatch_id' not in params or
                params['minibatch_id'] is None):
            raise ValueError("Missing the required parameter `minibatch_id` when calling `get_minibatch`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'model_history_server_id' in params:
            path_params['modelHistoryServerId'] = params['model_history_server_id']  # noqa: E501
        if 'minibatch_id' in params:
            path_params['minibatchId'] = params['minibatch_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/rpc/{modelHistoryServerId}/model/minibatch/{minibatchId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='MinibatchEntity',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_model_history(self, model_history_server_id, model_history_id, **kwargs):  # noqa: E501
        """Gets a model history, given its ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_model_history(model_history_server_id, model_history_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param str model_history_id: GUID of the model history to get information of. (required)
        :return: ModelHistoryEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.get_model_history_with_http_info(model_history_server_id, model_history_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_model_history_with_http_info(model_history_server_id, model_history_id, **kwargs)  # noqa: E501
            return data

    def get_model_history_with_http_info(self, model_history_server_id, model_history_id, **kwargs):  # noqa: E501
        """Gets a model history, given its ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_model_history_with_http_info(model_history_server_id, model_history_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param str model_history_id: GUID of the model history to get information of. (required)
        :return: ModelHistoryEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_history_server_id', 'model_history_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_model_history" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_history_server_id' is set
        if ('model_history_server_id' not in params or
                params['model_history_server_id'] is None):
            raise ValueError("Missing the required parameter `model_history_server_id` when calling `get_model_history`")  # noqa: E501
        # verify the required parameter 'model_history_id' is set
        if ('model_history_id' not in params or
                params['model_history_id'] is None):
            raise ValueError("Missing the required parameter `model_history_id` when calling `get_model_history`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'model_history_server_id' in params:
            path_params['modelHistoryServerId'] = params['model_history_server_id']  # noqa: E501
        if 'model_history_id' in params:
            path_params['modelHistoryID'] = params['model_history_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/rpc/{modelHistoryServerId}/model/revision/{modelHistoryID}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ModelHistoryEntity',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_model_instance(self, model_history_server_id, model_instance_id, **kwargs):  # noqa: E501
        """Gets a model instance, given its ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_model_instance(model_history_server_id, model_instance_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param str model_instance_id: GUID of the model instance to get information of. (required)
        :return: ModelInstanceEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.get_model_instance_with_http_info(model_history_server_id, model_instance_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_model_instance_with_http_info(model_history_server_id, model_instance_id, **kwargs)  # noqa: E501
            return data

    def get_model_instance_with_http_info(self, model_history_server_id, model_instance_id, **kwargs):  # noqa: E501
        """Gets a model instance, given its ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_model_instance_with_http_info(model_history_server_id, model_instance_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param str model_instance_id: GUID of the model instance to get information of. (required)
        :return: ModelInstanceEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_history_server_id', 'model_instance_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_model_instance" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_history_server_id' is set
        if ('model_history_server_id' not in params or
                params['model_history_server_id'] is None):
            raise ValueError("Missing the required parameter `model_history_server_id` when calling `get_model_instance`")  # noqa: E501
        # verify the required parameter 'model_instance_id' is set
        if ('model_instance_id' not in params or
                params['model_instance_id'] is None):
            raise ValueError("Missing the required parameter `model_instance_id` when calling `get_model_instance`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'model_history_server_id' in params:
            path_params['modelHistoryServerId'] = params['model_history_server_id']  # noqa: E501
        if 'model_instance_id' in params:
            path_params['modelInstanceID'] = params['model_instance_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/rpc/{modelHistoryServerId}/model/{modelInstanceID}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ModelInstanceEntity',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_models_for_experiment(self, model_history_server_id, experiment_id, **kwargs):  # noqa: E501
        """Obtain a list of all the models for an experiment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_models_for_experiment(model_history_server_id, experiment_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param str experiment_id: the GUID of the experiment (required)
        :return: list[ModelInstanceEntity]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.get_models_for_experiment_with_http_info(model_history_server_id, experiment_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_models_for_experiment_with_http_info(model_history_server_id, experiment_id, **kwargs)  # noqa: E501
            return data

    def get_models_for_experiment_with_http_info(self, model_history_server_id, experiment_id, **kwargs):  # noqa: E501
        """Obtain a list of all the models for an experiment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_models_for_experiment_with_http_info(model_history_server_id, experiment_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param str experiment_id: the GUID of the experiment (required)
        :return: list[ModelInstanceEntity]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_history_server_id', 'experiment_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_models_for_experiment" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_history_server_id' is set
        if ('model_history_server_id' not in params or
                params['model_history_server_id'] is None):
            raise ValueError("Missing the required parameter `model_history_server_id` when calling `get_models_for_experiment`")  # noqa: E501
        # verify the required parameter 'experiment_id' is set
        if ('experiment_id' not in params or
                params['experiment_id'] is None):
            raise ValueError("Missing the required parameter `experiment_id` when calling `get_models_for_experiment`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'model_history_server_id' in params:
            path_params['modelHistoryServerId'] = params['model_history_server_id']  # noqa: E501
        if 'experiment_id' in params:
            path_params['experimentID'] = params['experiment_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/rpc/{modelHistoryServerId}/experiment/{experimentID}/models', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[ModelInstanceEntity]',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_resource_by_id(self, resource_id, **kwargs):  # noqa: E501
        """Get the resource with the specified resource ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_resource_by_id(resource_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param int resource_id: ID of the resource (required)
        :return: Resource
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.get_resource_by_id_with_http_info(resource_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_resource_by_id_with_http_info(resource_id, **kwargs)  # noqa: E501
            return data

    def get_resource_by_id_with_http_info(self, resource_id, **kwargs):  # noqa: E501
        """Get the resource with the specified resource ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_resource_by_id_with_http_info(resource_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param int resource_id: ID of the resource (required)
        :return: Resource
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['resource_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_resource_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'resource_id' is set
        if ('resource_id' not in params or
                params['resource_id'] is None):
            raise ValueError("Missing the required parameter `resource_id` when calling `get_resource_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'resource_id' in params:
            path_params['resourceId'] = params['resource_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/resources/resource/{resourceId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Resource',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_resource_by_sub_type(self, resource_sub_type, **kwargs):  # noqa: E501
        """Get all the resources with the specified resource subtype  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_resource_by_sub_type(resource_sub_type, async=True)
        >>> result = thread.get()

        :param async bool
        :param str resource_sub_type: Subtype of the resource (required)
        :return: list[Resource]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.get_resource_by_sub_type_with_http_info(resource_sub_type, **kwargs)  # noqa: E501
        else:
            (data) = self.get_resource_by_sub_type_with_http_info(resource_sub_type, **kwargs)  # noqa: E501
            return data

    def get_resource_by_sub_type_with_http_info(self, resource_sub_type, **kwargs):  # noqa: E501
        """Get all the resources with the specified resource subtype  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_resource_by_sub_type_with_http_info(resource_sub_type, async=True)
        >>> result = thread.get()

        :param async bool
        :param str resource_sub_type: Subtype of the resource (required)
        :return: list[Resource]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['resource_sub_type']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_resource_by_sub_type" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'resource_sub_type' is set
        if ('resource_sub_type' not in params or
                params['resource_sub_type'] is None):
            raise ValueError("Missing the required parameter `resource_sub_type` when calling `get_resource_by_sub_type`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'resource_sub_type' in params:
            path_params['resourceSubType'] = params['resource_sub_type']  # 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/resources/resources/subtype/{resourceSubType}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[Resource]',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_resource_by_type(self, resource_type, **kwargs):  # noqa: E501
        """Get all the resources with the specified resource type  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_resource_by_type(resource_type, async=True)
        >>> result = thread.get()

        :param async bool
        :param str resource_type: Type of the resource (required)
        :return: list[Resource]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.get_resource_by_type_with_http_info(resource_type, **kwargs)  # noqa: E501
        else:
            (data) = self.get_resource_by_type_with_http_info(resource_type, **kwargs)  # noqa: E501
            return data

    def get_resource_by_type_with_http_info(self, resource_type, **kwargs):  # noqa: E501
        """Get all the resources with the specified resource type  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_resource_by_type_with_http_info(resource_type, async=True)
        >>> result = thread.get()

        :param async bool
        :param str resource_type: Type of the resource (required)
        :return: list[Resource]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['resource_type']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_resource_by_type" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'resource_type' is set
        if ('resource_type' not in params or
                params['resource_type'] is None):
            raise ValueError("Missing the required parameter `resource_type` when calling `get_resource_by_type`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'resource_type' in params:
            path_params['resourceType'] = params['resource_type']  # 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/resources/resources/type/{resourceType}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[Resource]',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_resource_details_by_id(self, resource_id, **kwargs):  # noqa: E501
        """Get the resource details with the specified resource ID  # noqa: E501

        Get the details for the resource, for the given ID. Note that a 'ResourceDetails' object contains specific information about the resource (such as region for an AWS resource, or URI for a HDFS resource), where as the 'Resource' object contains only general information (name, id, type, subtype).   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_resource_details_by_id(resource_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param int resource_id: ID of the resource (required)
        :return: object
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.get_resource_details_by_id_with_http_info(resource_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_resource_details_by_id_with_http_info(resource_id, **kwargs)  # noqa: E501
            return data

    def get_resource_details_by_id_with_http_info(self, resource_id, **kwargs):  # noqa: E501
        """Get the resource details with the specified resource ID  # noqa: E501

        Get the details for the resource, for the given ID. Note that a 'ResourceDetails' object contains specific information about the resource (such as region for an AWS resource, or URI for a HDFS resource), where as the 'Resource' object contains only general information (name, id, type, subtype).   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_resource_details_by_id_with_http_info(resource_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param int resource_id: ID of the resource (required)
        :return: object
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['resource_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_resource_details_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'resource_id' is set
        if ('resource_id' not in params or
                params['resource_id'] is None):
            raise ValueError("Missing the required parameter `resource_id` when calling `get_resource_details_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'resource_id' in params:
            path_params['resourceId'] = params['resource_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/resources/details/{resourceId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='object',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_resource_group_by_id(self, resource_group_id, **kwargs):  # noqa: E501
        """Get the resource group with the specified resource group ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_resource_group_by_id(resource_group_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param int resource_group_id: ID of the resource group (required)
        :return: ResourceGroup
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.get_resource_group_by_id_with_http_info(resource_group_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_resource_group_by_id_with_http_info(resource_group_id, **kwargs)  # noqa: E501
            return data

    def get_resource_group_by_id_with_http_info(self, resource_group_id, **kwargs):  # noqa: E501
        """Get the resource group with the specified resource group ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_resource_group_by_id_with_http_info(resource_group_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param int resource_group_id: ID of the resource group (required)
        :return: ResourceGroup
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['resource_group_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_resource_group_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'resource_group_id' is set
        if ('resource_group_id' not in params or
                params['resource_group_id'] is None):
            raise ValueError("Missing the required parameter `resource_group_id` when calling `get_resource_group_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'resource_group_id' in params:
            path_params['resourceGroupId'] = params['resource_group_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/resources/group/{resourceGroupId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ResourceGroup',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_resource_groups(self, **kwargs):  # noqa: E501
        """Get a list of all the resource groups  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_resource_groups(async=True)
        >>> result = thread.get()

        :param async bool
        :return: list[ResourceGroup]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.get_resource_groups_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.get_resource_groups_with_http_info(**kwargs)  # noqa: E501
            return data

    def get_resource_groups_with_http_info(self, **kwargs):  # noqa: E501
        """Get a list of all the resource groups  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_resource_groups_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :return: list[ResourceGroup]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = []  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_resource_groups" % key
                )
            params[key] = val
        del 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/resources/groups', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[ResourceGroup]',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_resources(self, **kwargs):  # noqa: E501
        """A list of all known/registered resources, of all types  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_resources(async=True)
        >>> result = thread.get()

        :param async bool
        :return: list[Resource]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.get_resources_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.get_resources_with_http_info(**kwargs)  # noqa: E501
            return data

    def get_resources_with_http_info(self, **kwargs):  # noqa: E501
        """A list of all known/registered resources, of all types  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_resources_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :return: list[Resource]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = []  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_resources" % key
                )
            params[key] = val
        del 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/resources/resources', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[Resource]',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_resources_from_group(self, resource_group_id, **kwargs):  # noqa: E501
        """Get all resources from a resource group  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_resources_from_group(resource_group_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param int resource_group_id: ID of the resource group (required)
        :return: list[Resource]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.get_resources_from_group_with_http_info(resource_group_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_resources_from_group_with_http_info(resource_group_id, **kwargs)  # noqa: E501
            return data

    def get_resources_from_group_with_http_info(self, resource_group_id, **kwargs):  # noqa: E501
        """Get all resources from a resource group  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_resources_from_group_with_http_info(resource_group_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param int resource_group_id: ID of the resource group (required)
        :return: list[Resource]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['resource_group_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_resources_from_group" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'resource_group_id' is set
        if ('resource_group_id' not in params or
                params['resource_group_id'] is None):
            raise ValueError("Missing the required parameter `resource_group_id` when calling `get_resources_from_group`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'resource_group_id' in params:
            path_params['resourceGroupId'] = params['resource_group_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/resources/group/{resourceGroupId}/resources', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[Resource]',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def jsonarray(self, body, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Run inference on the input and returns it as a JsonArrayResponse  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.jsonarray(body, deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param Prediction body: The input NDArray (required)
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: JsonArrayResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.jsonarray_with_http_info(body, deployment_name, version_name, model_name, **kwargs)  # noqa: E501
        else:
            (data) = self.jsonarray_with_http_info(body, deployment_name, version_name, model_name, **kwargs)  # noqa: E501
            return data

    def jsonarray_with_http_info(self, body, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Run inference on the input and returns it as a JsonArrayResponse  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.jsonarray_with_http_info(body, deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param Prediction body: The input NDArray (required)
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: JsonArrayResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body', 'deployment_name', 'version_name', 'model_name']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method jsonarray" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params or
                params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `jsonarray`")  # noqa: E501
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `jsonarray`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `jsonarray`")  # noqa: E501
        # verify the required parameter 'model_name' is set
        if ('model_name' not in params or
                params['model_name'] is None):
            raise ValueError("Missing the required parameter `model_name` when calling `jsonarray`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'model_name' in params:
            path_params['modelName'] = params['model_name']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/model/{modelName}/{versionName}/jsonarray', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='JsonArrayResponse',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def knn(self, deployment_name, version_name, knn_name, body, **kwargs):  # noqa: E501
        """Runs knn on the given index with the given k  # noqa: E501

        Runs knn on the given index with the given k (note that this is for data already within the existing dataset not new data)  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.knn(deployment_name, version_name, knn_name, body, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str knn_name: ID or name of the deployed knn (required)
        :param NearestNeighborRequest body: (required)
        :return: NearestNeighborsResults
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.knn_with_http_info(deployment_name, version_name, knn_name, body, **kwargs)  # noqa: E501
        else:
            (data) = self.knn_with_http_info(deployment_name, version_name, knn_name, body, **kwargs)  # noqa: E501
            return data

    def knn_with_http_info(self, deployment_name, version_name, knn_name, body, **kwargs):  # noqa: E501
        """Runs knn on the given index with the given k  # noqa: E501

        Runs knn on the given index with the given k (note that this is for data already within the existing dataset not new data)  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.knn_with_http_info(deployment_name, version_name, knn_name, body, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str knn_name: ID or name of the deployed knn (required)
        :param NearestNeighborRequest body: (required)
        :return: NearestNeighborsResults
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['deployment_name', 'version_name', 'knn_name', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method knn" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `knn`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `knn`")  # noqa: E501
        # verify the required parameter 'knn_name' is set
        if ('knn_name' not in params or
                params['knn_name'] is None):
            raise ValueError("Missing the required parameter `knn_name` when calling `knn`")  # noqa: E501
        # verify the required parameter 'body' is set
        if ('body' not in params or
                params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `knn`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'knn_name' in params:
            path_params['knnName'] = params['knn_name']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/knn/{knnName}/{versionName}/knn', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='NearestNeighborsResults',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def knnnew(self, deployment_name, version_name, knn_name, body, **kwargs):  # noqa: E501
        """Run a k nearest neighbors search on a NEW data point  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.knnnew(deployment_name, version_name, knn_name, body, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str knn_name: ID or name of the deployed knn (required)
        :param Base64NDArrayBodyKNN body: The input NDArray (required)
        :return: NearestNeighborsResults
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.knnnew_with_http_info(deployment_name, version_name, knn_name, body, **kwargs)  # noqa: E501
        else:
            (data) = self.knnnew_with_http_info(deployment_name, version_name, knn_name, body, **kwargs)  # noqa: E501
            return data

    def knnnew_with_http_info(self, deployment_name, version_name, knn_name, body, **kwargs):  # noqa: E501
        """Run a k nearest neighbors search on a NEW data point  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.knnnew_with_http_info(deployment_name, version_name, knn_name, body, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str knn_name: ID or name of the deployed knn (required)
        :param Base64NDArrayBodyKNN body: The input NDArray (required)
        :return: NearestNeighborsResults
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['deployment_name', 'version_name', 'knn_name', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method knnnew" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `knnnew`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `knnnew`")  # noqa: E501
        # verify the required parameter 'knn_name' is set
        if ('knn_name' not in params or
                params['knn_name'] is None):
            raise ValueError("Missing the required parameter `knn_name` when calling `knnnew`")  # noqa: E501
        # verify the required parameter 'body' is set
        if ('body' not in params or
                params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `knnnew`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'knn_name' in params:
            path_params['knnName'] = params['knn_name']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/knn/{knnName}/{versionName}/knnnew', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='NearestNeighborsResults',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_all_experiments(self, **kwargs):  # noqa: E501
        """List all of the experiments in every model history / workspace  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_experiments(async=True)
        >>> result = thread.get()

        :param async bool
        :return: list[ExperimentEntity]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.list_all_experiments_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.list_all_experiments_with_http_info(**kwargs)  # noqa: E501
            return data

    def list_all_experiments_with_http_info(self, **kwargs):  # noqa: E501
        """List all of the experiments in every model history / workspace  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_experiments_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :return: list[ExperimentEntity]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = []  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_all_experiments" % key
                )
            params[key] = val
        del 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/rpc/{modelHistoryServerId}/experiments', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[ExperimentEntity]',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def logfilepath(self, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Get logs file path  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.logfilepath(deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.logfilepath_with_http_info(deployment_name, version_name, model_name, **kwargs)  # noqa: E501
        else:
            (data) = self.logfilepath_with_http_info(deployment_name, version_name, model_name, **kwargs)  # noqa: E501
            return data

    def logfilepath_with_http_info(self, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Get logs file path  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.logfilepath_with_http_info(deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['deployment_name', 'version_name', 'model_name']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method logfilepath" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `logfilepath`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `logfilepath`")  # noqa: E501
        # verify the required parameter 'model_name' is set
        if ('model_name' not in params or
                params['model_name'] is None):
            raise ValueError("Missing the required parameter `model_name` when calling `logfilepath`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'model_name' in params:
            path_params['modelName'] = params['model_name']  # 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(
            ['text'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/model/{modelName}/{versionName}/logfilepath', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='str',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def login(self, credentials, **kwargs):  # noqa: E501
        """Post JSON credentials and obtain a JWT authorization token.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.login(credentials, async=True)
        >>> result = thread.get()

        :param async bool
        :param Credentials credentials: Login credentials. (required)
        :return: Token
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.login_with_http_info(credentials, **kwargs)  # noqa: E501
        else:
            (data) = self.login_with_http_info(credentials, **kwargs)  # noqa: E501
            return data

    def login_with_http_info(self, credentials, **kwargs):  # noqa: E501
        """Post JSON credentials and obtain a JWT authorization token.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.login_with_http_info(credentials, async=True)
        >>> result = thread.get()

        :param async bool
        :param Credentials credentials: Login credentials. (required)
        :return: Token
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['credentials']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method login" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'credentials' is set
        if ('credentials' not in params or
                params['credentials'] is None):
            raise ValueError("Missing the required parameter `credentials` when calling `login`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'credentials' in params:
            body_params = params['credentials']
        # 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(
            '/login', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Token',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def logs(self, body, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Get logs  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.logs(body, deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param LogRequest body: the the log request (required)
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: LogBatch
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.logs_with_http_info(body, deployment_name, version_name, model_name, **kwargs)  # noqa: E501
        else:
            (data) = self.logs_with_http_info(body, deployment_name, version_name, model_name, **kwargs)  # noqa: E501
            return data

    def logs_with_http_info(self, body, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Get logs  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.logs_with_http_info(body, deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param LogRequest body: the the log request (required)
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: LogBatch
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body', 'deployment_name', 'version_name', 'model_name']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method logs" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params or
                params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `logs`")  # noqa: E501
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `logs`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `logs`")  # noqa: E501
        # verify the required parameter 'model_name' is set
        if ('model_name' not in params or
                params['model_name'] is None):
            raise ValueError("Missing the required parameter `model_name` when calling `logs`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'model_name' in params:
            path_params['modelName'] = params['model_name']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/model/{modelName}/{versionName}/logs', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='LogBatch',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def meta_get(self, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """this method can be used to get the meta data for the current model which set to the server  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.meta_get(deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: MetaData
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.meta_get_with_http_info(deployment_name, version_name, model_name, **kwargs)  # noqa: E501
        else:
            (data) = self.meta_get_with_http_info(deployment_name, version_name, model_name, **kwargs)  # noqa: E501
            return data

    def meta_get_with_http_info(self, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """this method can be used to get the meta data for the current model which set to the server  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.meta_get_with_http_info(deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: MetaData
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['deployment_name', 'version_name', 'model_name']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method meta_get" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `meta_get`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `meta_get`")  # noqa: E501
        # verify the required parameter 'model_name' is set
        if ('model_name' not in params or
                params['model_name'] is None):
            raise ValueError("Missing the required parameter `model_name` when calling `meta_get`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'model_name' in params:
            path_params['modelName'] = params['model_name']  # 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

        # 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/model/{modelName}/{versionName}/meta', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='MetaData',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def meta_post(self, body, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """This method can be used to set meta data for the current model which is set to the server  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.meta_post(body, deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param MetaData body: the meta data object (required)
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: MetaData
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.meta_post_with_http_info(body, deployment_name, version_name, model_name, **kwargs)  # noqa: E501
        else:
            (data) = self.meta_post_with_http_info(body, deployment_name, version_name, model_name, **kwargs)  # noqa: E501
            return data

    def meta_post_with_http_info(self, body, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """This method can be used to set meta data for the current model which is set to the server  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.meta_post_with_http_info(body, deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param MetaData body: the meta data object (required)
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: MetaData
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body', 'deployment_name', 'version_name', 'model_name']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method meta_post" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params or
                params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `meta_post`")  # noqa: E501
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `meta_post`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `meta_post`")  # noqa: E501
        # verify the required parameter 'model_name' is set
        if ('model_name' not in params or
                params['model_name'] is None):
            raise ValueError("Missing the required parameter `model_name` when calling `meta_post`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'model_name' in params:
            path_params['modelName'] = params['model_name']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/model/{modelName}/{versionName}/meta', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='MetaData',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def model_state_change(self, deployment_id, model_id, body, **kwargs):  # noqa: E501
        """Modify the state (start/stop) of a deployed model  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.model_state_change(deployment_id, model_id, body, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_id: ID deployment group (required)
        :param str model_id: the id of the deployed model (required)
        :param SetState body: the model state object (required)
        :return: ModelEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.model_state_change_with_http_info(deployment_id, model_id, body, **kwargs)  # noqa: E501
        else:
            (data) = self.model_state_change_with_http_info(deployment_id, model_id, body, **kwargs)  # noqa: E501
            return data

    def model_state_change_with_http_info(self, deployment_id, model_id, body, **kwargs):  # noqa: E501
        """Modify the state (start/stop) of a deployed model  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.model_state_change_with_http_info(deployment_id, model_id, body, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_id: ID deployment group (required)
        :param str model_id: the id of the deployed model (required)
        :param SetState body: the model state object (required)
        :return: ModelEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['deployment_id', 'model_id', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method model_state_change" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'deployment_id' is set
        if ('deployment_id' not in params or
                params['deployment_id'] is None):
            raise ValueError("Missing the required parameter `deployment_id` when calling `model_state_change`")  # noqa: E501
        # verify the required parameter 'model_id' is set
        if ('model_id' not in params or
                params['model_id'] is None):
            raise ValueError("Missing the required parameter `model_id` when calling `model_state_change`")  # noqa: E501
        # verify the required parameter 'body' is set
        if ('body' not in params or
                params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `model_state_change`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_id' in params:
            path_params['deploymentId'] = params['deployment_id']  # noqa: E501
        if 'model_id' in params:
            path_params['modelId'] = params['model_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/deployment/{deploymentId}/model/{modelId}/state', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ModelEntity',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def models(self, deployment_id, **kwargs):  # noqa: E501
        """Retrieve a list of all the deployed models given a deployment id  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.models(deployment_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_id: ID deployment group (required)
        :return: list[ModelEntity]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.models_with_http_info(deployment_id, **kwargs)  # noqa: E501
        else:
            (data) = self.models_with_http_info(deployment_id, **kwargs)  # noqa: E501
            return data

    def models_with_http_info(self, deployment_id, **kwargs):  # noqa: E501
        """Retrieve a list of all the deployed models given a deployment id  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.models_with_http_info(deployment_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_id: ID deployment group (required)
        :return: list[ModelEntity]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['deployment_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method models" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'deployment_id' is set
        if ('deployment_id' not in params or
                params['deployment_id'] is None):
            raise ValueError("Missing the required parameter `deployment_id` when calling `models`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_id' in params:
            path_params['deploymentId'] = params['deployment_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/deployment/{deploymentId}/models', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[ModelEntity]',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def modelset(self, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Set the model to be served  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.modelset(deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :param file file: The model file to upload (.pb file)
        :return: ModelStatus
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.modelset_with_http_info(deployment_name, version_name, model_name, **kwargs)  # noqa: E501
        else:
            (data) = self.modelset_with_http_info(deployment_name, version_name, model_name, **kwargs)  # noqa: E501
            return data

    def modelset_with_http_info(self, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Set the model to be served  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.modelset_with_http_info(deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :param file file: The model file to upload (.pb file)
        :return: ModelStatus
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['deployment_name', 'version_name', 'model_name', 'file']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method modelset" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `modelset`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `modelset`")  # noqa: E501
        # verify the required parameter 'model_name' is set
        if ('model_name' not in params or
                params['model_name'] is None):
            raise ValueError("Missing the required parameter `model_name` when calling `modelset`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'model_name' in params:
            path_params['modelName'] = params['model_name']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}
        if 'file' in params:
            local_var_files['file'] = params['file']  # noqa: E501

        body_params = None
        # 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
            ['multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/model/{modelName}/{versionName}/modelset', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ModelStatus',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def modelupdate(self, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Update the model to be served  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.modelupdate(deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :param file file: The model file to update with (.pb file)
        :return: ModelStatus
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.modelupdate_with_http_info(deployment_name, version_name, model_name, **kwargs)  # noqa: E501
        else:
            (data) = self.modelupdate_with_http_info(deployment_name, version_name, model_name, **kwargs)  # noqa: E501
            return data

    def modelupdate_with_http_info(self, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Update the model to be served  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.modelupdate_with_http_info(deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :param file file: The model file to update with (.pb file)
        :return: ModelStatus
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['deployment_name', 'version_name', 'model_name', 'file']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method modelupdate" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `modelupdate`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `modelupdate`")  # noqa: E501
        # verify the required parameter 'model_name' is set
        if ('model_name' not in params or
                params['model_name'] is None):
            raise ValueError("Missing the required parameter `model_name` when calling `modelupdate`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'model_name' in params:
            path_params['modelName'] = params['model_name']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}
        if 'file' in params:
            local_var_files['file'] = params['file']  # noqa: E501

        body_params = None
        # 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
            ['multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/model/{modelName}/{versionName}/modelupdate', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ModelStatus',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def multiclassify(self, body, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Represents all of the labels for a given classification  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.multiclassify(body, deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param Prediction body: The input NDArray (required)
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: MultiClassClassificationResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.multiclassify_with_http_info(body, deployment_name, version_name, model_name, **kwargs)  # noqa: E501
        else:
            (data) = self.multiclassify_with_http_info(body, deployment_name, version_name, model_name, **kwargs)  # noqa: E501
            return data

    def multiclassify_with_http_info(self, body, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Represents all of the labels for a given classification  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.multiclassify_with_http_info(body, deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param Prediction body: The input NDArray (required)
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: MultiClassClassificationResult
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body', 'deployment_name', 'version_name', 'model_name']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method multiclassify" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params or
                params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `multiclassify`")  # noqa: E501
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `multiclassify`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `multiclassify`")  # noqa: E501
        # verify the required parameter 'model_name' is set
        if ('model_name' not in params or
                params['model_name'] is None):
            raise ValueError("Missing the required parameter `model_name` when calling `multiclassify`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'model_name' in params:
            path_params['modelName'] = params['model_name']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/model/{modelName}/{versionName}/multiclassify', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='MultiClassClassificationResult',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def multipredict(self, body, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Get the output from the network, based on the given INDArray[] input  # noqa: E501

        Networks with multiple input/output are supported via this method. A Normalizer will be used if needsPreProcessing is set to true. The output/returned array of INDArray will be the raw predictions, and consequently this method can be used for classification or regression networks, with any type of output layer (standard, time series / RnnOutputLayer, etc).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.multipredict(body, deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param MultiPredictRequest body: The multiple input arrays with mask inputs to run inferences on (required)
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: MultiPredictResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.multipredict_with_http_info(body, deployment_name, version_name, model_name, **kwargs)  # noqa: E501
        else:
            (data) = self.multipredict_with_http_info(body, deployment_name, version_name, model_name, **kwargs)  # noqa: E501
            return data

    def multipredict_with_http_info(self, body, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Get the output from the network, based on the given INDArray[] input  # noqa: E501

        Networks with multiple input/output are supported via this method. A Normalizer will be used if needsPreProcessing is set to true. The output/returned array of INDArray will be the raw predictions, and consequently this method can be used for classification or regression networks, with any type of output layer (standard, time series / RnnOutputLayer, etc).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.multipredict_with_http_info(body, deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param MultiPredictRequest body: The multiple input arrays with mask inputs to run inferences on (required)
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: MultiPredictResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body', 'deployment_name', 'version_name', 'model_name']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method multipredict" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params or
                params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `multipredict`")  # noqa: E501
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `multipredict`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `multipredict`")  # noqa: E501
        # verify the required parameter 'model_name' is set
        if ('model_name' not in params or
                params['model_name'] is None):
            raise ValueError("Missing the required parameter `model_name` when calling `multipredict`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'model_name' in params:
            path_params['modelName'] = params['model_name']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/model/{modelName}/{versionName}/multipredict', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='MultiPredictResponse',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def multipredictimage(self, file, id, needs_preprocessing, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Get the output from the network using the given image file using the /multipredict endpoint&#39;s method  # noqa: E501

        Networks with multiple input/output are supported via this method. A Normalizer will be used if needsPreProcessing is set to true. The output/returned array of INDArray will be the raw predictions, and consequently this method can be used for classification or regression networks, with any type of output layer (standard, time series / RnnOutputLayer, etc).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.multipredictimage(file, id, needs_preprocessing, deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param file file: The image file to run the prediction on (required)
        :param str id: The id of the request (could be self generated) (required)
        :param bool needs_preprocessing: Whether or not the preprocessing is required (either 'true' or 'false') (required)
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: MultiPredictResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.multipredictimage_with_http_info(file, id, needs_preprocessing, deployment_name, version_name, model_name, **kwargs)  # noqa: E501
        else:
            (data) = self.multipredictimage_with_http_info(file, id, needs_preprocessing, deployment_name, version_name, model_name, **kwargs)  # noqa: E501
            return data

    def multipredictimage_with_http_info(self, file, id, needs_preprocessing, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Get the output from the network using the given image file using the /multipredict endpoint&#39;s method  # noqa: E501

        Networks with multiple input/output are supported via this method. A Normalizer will be used if needsPreProcessing is set to true. The output/returned array of INDArray will be the raw predictions, and consequently this method can be used for classification or regression networks, with any type of output layer (standard, time series / RnnOutputLayer, etc).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.multipredictimage_with_http_info(file, id, needs_preprocessing, deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param file file: The image file to run the prediction on (required)
        :param str id: The id of the request (could be self generated) (required)
        :param bool needs_preprocessing: Whether or not the preprocessing is required (either 'true' or 'false') (required)
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: MultiPredictResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['file', 'id', 'needs_preprocessing', 'deployment_name', 'version_name', 'model_name']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method multipredictimage" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'file' is set
        if ('file' not in params or
                params['file'] is None):
            raise ValueError("Missing the required parameter `file` when calling `multipredictimage`")  # noqa: E501
        # verify the required parameter 'id' is set
        if ('id' not in params or
                params['id'] is None):
            raise ValueError("Missing the required parameter `id` when calling `multipredictimage`")  # noqa: E501
        # verify the required parameter 'needs_preprocessing' is set
        if ('needs_preprocessing' not in params or
                params['needs_preprocessing'] is None):
            raise ValueError("Missing the required parameter `needs_preprocessing` when calling `multipredictimage`")  # noqa: E501
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `multipredictimage`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `multipredictimage`")  # noqa: E501
        # verify the required parameter 'model_name' is set
        if ('model_name' not in params or
                params['model_name'] is None):
            raise ValueError("Missing the required parameter `model_name` when calling `multipredictimage`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'model_name' in params:
            path_params['modelName'] = params['model_name']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}
        if 'file' in params:
            local_var_files['file'] = params['file']  # noqa: E501
        if 'id' in params:
            form_params.append(('id', params['id']))  # noqa: E501
        if 'needs_preprocessing' in params:
            form_params.append(('needs_preprocessing', params['needs_preprocessing']))  # noqa: E501

        body_params = None
        # 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
            ['multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/model/{modelName}/{versionName}/multipredictimage', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='MultiPredictResponse',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def predict(self, body, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Run inference on the input array.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.predict(body, deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param Prediction body: The input NDArray (required)
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: Prediction
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.predict_with_http_info(body, deployment_name, version_name, model_name, **kwargs)  # noqa: E501
        else:
            (data) = self.predict_with_http_info(body, deployment_name, version_name, model_name, **kwargs)  # noqa: E501
            return data

    def predict_with_http_info(self, body, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Run inference on the input array.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.predict_with_http_info(body, deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param Prediction body: The input NDArray (required)
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: Prediction
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body', 'deployment_name', 'version_name', 'model_name']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method predict" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params or
                params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `predict`")  # noqa: E501
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `predict`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `predict`")  # noqa: E501
        # verify the required parameter 'model_name' is set
        if ('model_name' not in params or
                params['model_name'] is None):
            raise ValueError("Missing the required parameter `model_name` when calling `predict`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'model_name' in params:
            path_params['modelName'] = params['model_name']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/model/{modelName}/{versionName}/predict', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Prediction',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def predictimage(self, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Run inference on the input array, using input image file from multipart form data.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.predictimage(deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :param file image: The file to upload.
        :return: Prediction
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.predictimage_with_http_info(deployment_name, version_name, model_name, **kwargs)  # noqa: E501
        else:
            (data) = self.predictimage_with_http_info(deployment_name, version_name, model_name, **kwargs)  # noqa: E501
            return data

    def predictimage_with_http_info(self, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Run inference on the input array, using input image file from multipart form data.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.predictimage_with_http_info(deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :param file image: The file to upload.
        :return: Prediction
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['deployment_name', 'version_name', 'model_name', 'image']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method predictimage" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `predictimage`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `predictimage`")  # noqa: E501
        # verify the required parameter 'model_name' is set
        if ('model_name' not in params or
                params['model_name'] is None):
            raise ValueError("Missing the required parameter `model_name` when calling `predictimage`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'model_name' in params:
            path_params['modelName'] = params['model_name']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}
        if 'image' in params:
            local_var_files['image'] = params['image']  # noqa: E501

        body_params = None
        # 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
            ['multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/model/{modelName}/{versionName}/predictimage', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Prediction',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def predictwithpreprocess(self, body, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Preprocesses the input and run inference on it  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.predictwithpreprocess(body, deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param list[str] body: The input array (required)
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: Prediction
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.predictwithpreprocess_with_http_info(body, deployment_name, version_name, model_name, **kwargs)  # noqa: E501
        else:
            (data) = self.predictwithpreprocess_with_http_info(body, deployment_name, version_name, model_name, **kwargs)  # noqa: E501
            return data

    def predictwithpreprocess_with_http_info(self, body, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Preprocesses the input and run inference on it  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.predictwithpreprocess_with_http_info(body, deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param list[str] body: The input array (required)
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: Prediction
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body', 'deployment_name', 'version_name', 'model_name']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method predictwithpreprocess" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params or
                params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `predictwithpreprocess`")  # noqa: E501
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `predictwithpreprocess`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `predictwithpreprocess`")  # noqa: E501
        # verify the required parameter 'model_name' is set
        if ('model_name' not in params or
                params['model_name'] is None):
            raise ValueError("Missing the required parameter `model_name` when calling `predictwithpreprocess`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'model_name' in params:
            path_params['modelName'] = params['model_name']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/model/{modelName}/{versionName}/predictwithpreprocess', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Prediction',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def predictwithpreprocessjson(self, body, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Preprocesses the input and run inference on it and returns it as a JsonArrayResponse  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.predictwithpreprocessjson(body, deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param list[str] body: The input array (required)
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: JsonArrayResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.predictwithpreprocessjson_with_http_info(body, deployment_name, version_name, model_name, **kwargs)  # noqa: E501
        else:
            (data) = self.predictwithpreprocessjson_with_http_info(body, deployment_name, version_name, model_name, **kwargs)  # noqa: E501
            return data

    def predictwithpreprocessjson_with_http_info(self, body, deployment_name, version_name, model_name, **kwargs):  # noqa: E501
        """Preprocesses the input and run inference on it and returns it as a JsonArrayResponse  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.predictwithpreprocessjson_with_http_info(body, deployment_name, version_name, model_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param list[str] body: The input array (required)
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str model_name: ID or name of the deployed model (required)
        :return: JsonArrayResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body', 'deployment_name', 'version_name', 'model_name']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method predictwithpreprocessjson" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params or
                params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `predictwithpreprocessjson`")  # noqa: E501
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `predictwithpreprocessjson`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `predictwithpreprocessjson`")  # noqa: E501
        # verify the required parameter 'model_name' is set
        if ('model_name' not in params or
                params['model_name'] is None):
            raise ValueError("Missing the required parameter `model_name` when calling `predictwithpreprocessjson`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'model_name' in params:
            path_params['modelName'] = params['model_name']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/model/{modelName}/{versionName}/predictwithpreprocessjson', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='JsonArrayResponse',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def refresh_job_status(self, job_id, **kwargs):  # noqa: E501
        """Refresh the remote job status. Can be used for monitoring.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.refresh_job_status(job_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param int job_id: Job ID (required)
        :return: JobEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.refresh_job_status_with_http_info(job_id, **kwargs)  # noqa: E501
        else:
            (data) = self.refresh_job_status_with_http_info(job_id, **kwargs)  # noqa: E501
            return data

    def refresh_job_status_with_http_info(self, job_id, **kwargs):  # noqa: E501
        """Refresh the remote job status. Can be used for monitoring.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.refresh_job_status_with_http_info(job_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param int job_id: Job ID (required)
        :return: JobEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['job_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method refresh_job_status" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'job_id' is set
        if ('job_id' not in params or
                params['job_id'] is None):
            raise ValueError("Missing the required parameter `job_id` when calling `refresh_job_status`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'job_id' in params:
            path_params['jobId'] = params['job_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/jobs/{jobId}/refresh', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='JobEntity',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def reimport_model(self, deployment_id, model_id, body, **kwargs):  # noqa: E501
        """Reimport a model to a previous deployed model in a deployment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.reimport_model(deployment_id, model_id, body, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_id: ID deployment group (required)
        :param str model_id: the id of the deployed model (required)
        :param ImportModelRequest body: the deployment request (required)
        :return: ModelEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.reimport_model_with_http_info(deployment_id, model_id, body, **kwargs)  # noqa: E501
        else:
            (data) = self.reimport_model_with_http_info(deployment_id, model_id, body, **kwargs)  # noqa: E501
            return data

    def reimport_model_with_http_info(self, deployment_id, model_id, body, **kwargs):  # noqa: E501
        """Reimport a model to a previous deployed model in a deployment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.reimport_model_with_http_info(deployment_id, model_id, body, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_id: ID deployment group (required)
        :param str model_id: the id of the deployed model (required)
        :param ImportModelRequest body: the deployment request (required)
        :return: ModelEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['deployment_id', 'model_id', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reimport_model" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'deployment_id' is set
        if ('deployment_id' not in params or
                params['deployment_id'] is None):
            raise ValueError("Missing the required parameter `deployment_id` when calling `reimport_model`")  # noqa: E501
        # verify the required parameter 'model_id' is set
        if ('model_id' not in params or
                params['model_id'] is None):
            raise ValueError("Missing the required parameter `model_id` when calling `reimport_model`")  # noqa: E501
        # verify the required parameter 'body' is set
        if ('body' not in params or
                params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `reimport_model`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_id' in params:
            path_params['deploymentId'] = params['deployment_id']  # noqa: E501
        if 'model_id' in params:
            path_params['modelId'] = params['model_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/deployment/{deploymentId}/model/{modelId}', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ModelEntity',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def run_a_job(self, job_id, **kwargs):  # noqa: E501
        """Start running an (already created) job on the remote resource  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.run_a_job(job_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param int job_id: Job ID (required)
        :return: JobEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.run_a_job_with_http_info(job_id, **kwargs)  # noqa: E501
        else:
            (data) = self.run_a_job_with_http_info(job_id, **kwargs)  # noqa: E501
            return data

    def run_a_job_with_http_info(self, job_id, **kwargs):  # noqa: E501
        """Start running an (already created) job on the remote resource  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.run_a_job_with_http_info(job_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param int job_id: Job ID (required)
        :return: JobEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['job_id']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method run_a_job" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'job_id' is set
        if ('job_id' not in params or
                params['job_id'] is None):
            raise ValueError("Missing the required parameter `job_id` when calling `run_a_job`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'job_id' in params:
            path_params['jobId'] = params['job_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

        # 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/jobs/{jobId}/run', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='JobEntity',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def transform_csv(self, deployment_name, version_name, transform_name, **kwargs):  # noqa: E501
        """Takes a BatchCSVRecord and returns the transformed array as BatchCSVRecord  # noqa: E501

        Takes a batch of SingleCSVRecord object and transforms it into the desired format  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.transform_csv(deployment_name, version_name, transform_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str transform_name: ID or name of the deployed transform (required)
        :param BatchCSVRecord batch_csv_record: The input batch of record arrays
        :return: BatchCSVRecord
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.transform_csv_with_http_info(deployment_name, version_name, transform_name, **kwargs)  # noqa: E501
        else:
            (data) = self.transform_csv_with_http_info(deployment_name, version_name, transform_name, **kwargs)  # noqa: E501
            return data

    def transform_csv_with_http_info(self, deployment_name, version_name, transform_name, **kwargs):  # noqa: E501
        """Takes a BatchCSVRecord and returns the transformed array as BatchCSVRecord  # noqa: E501

        Takes a batch of SingleCSVRecord object and transforms it into the desired format  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.transform_csv_with_http_info(deployment_name, version_name, transform_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str transform_name: ID or name of the deployed transform (required)
        :param BatchCSVRecord batch_csv_record: The input batch of record arrays
        :return: BatchCSVRecord
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['deployment_name', 'version_name', 'transform_name', 'batch_csv_record']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method transform_csv" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `transform_csv`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `transform_csv`")  # noqa: E501
        # verify the required parameter 'transform_name' is set
        if ('transform_name' not in params or
                params['transform_name'] is None):
            raise ValueError("Missing the required parameter `transform_name` when calling `transform_csv`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'transform_name' in params:
            path_params['transformName'] = params['transform_name']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'batch_csv_record' in params:
            body_params = params['batch_csv_record']
        # 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/datavec/{transformName}/{versionName}/transform', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='BatchCSVRecord',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def transformarray(self, deployment_name, version_name, transform_name, **kwargs):  # noqa: E501
        """Takes a batch input arrays and transforms it  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.transformarray(deployment_name, version_name, transform_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str transform_name: ID or name of the deployed transform (required)
        :param object batch_record: The input batch of record arrays
        :return: Base64NDArrayBody
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.transformarray_with_http_info(deployment_name, version_name, transform_name, **kwargs)  # noqa: E501
        else:
            (data) = self.transformarray_with_http_info(deployment_name, version_name, transform_name, **kwargs)  # noqa: E501
            return data

    def transformarray_with_http_info(self, deployment_name, version_name, transform_name, **kwargs):  # noqa: E501
        """Takes a batch input arrays and transforms it  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.transformarray_with_http_info(deployment_name, version_name, transform_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str transform_name: ID or name of the deployed transform (required)
        :param object batch_record: The input batch of record arrays
        :return: Base64NDArrayBody
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['deployment_name', 'version_name', 'transform_name', 'batch_record']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method transformarray" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `transformarray`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `transformarray`")  # noqa: E501
        # verify the required parameter 'transform_name' is set
        if ('transform_name' not in params or
                params['transform_name'] is None):
            raise ValueError("Missing the required parameter `transform_name` when calling `transformarray`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'transform_name' in params:
            path_params['transformName'] = params['transform_name']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'batch_record' in params:
            body_params = params['batch_record']
        # 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/datavec/{transformName}/{versionName}/transformarray', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Base64NDArrayBody',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def transformimage(self, deployment_name, version_name, image_transform_name, files, **kwargs):  # noqa: E501
        """Takes multiple multipart image file to transform and returns Base64NDArrayBody  # noqa: E501

        Takes multiple multipart image file and transforms it into the desired format and returns it in the form of Base64NDArrayBody  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.transformimage(deployment_name, version_name, image_transform_name, files, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str image_transform_name: ID or name of the deployed image transform (required)
        :param list[str] files: The image files to upload (required)
        :return: Base64NDArrayBody
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.transformimage_with_http_info(deployment_name, version_name, image_transform_name, files, **kwargs)  # noqa: E501
        else:
            (data) = self.transformimage_with_http_info(deployment_name, version_name, image_transform_name, files, **kwargs)  # noqa: E501
            return data

    def transformimage_with_http_info(self, deployment_name, version_name, image_transform_name, files, **kwargs):  # noqa: E501
        """Takes multiple multipart image file to transform and returns Base64NDArrayBody  # noqa: E501

        Takes multiple multipart image file and transforms it into the desired format and returns it in the form of Base64NDArrayBody  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.transformimage_with_http_info(deployment_name, version_name, image_transform_name, files, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str image_transform_name: ID or name of the deployed image transform (required)
        :param list[str] files: The image files to upload (required)
        :return: Base64NDArrayBody
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['deployment_name', 'version_name', 'image_transform_name', 'files']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method transformimage" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `transformimage`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `transformimage`")  # noqa: E501
        # verify the required parameter 'image_transform_name' is set
        if ('image_transform_name' not in params or
                params['image_transform_name'] is None):
            raise ValueError("Missing the required parameter `image_transform_name` when calling `transformimage`")  # noqa: E501
        # verify the required parameter 'files' is set
        if ('files' not in params or
                params['files'] is None):
            raise ValueError("Missing the required parameter `files` when calling `transformimage`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'image_transform_name' in params:
            path_params['imageTransformName'] = params['image_transform_name']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}
        if 'files' in params:
            form_params.append(('files', params['files']))  # noqa: E501
            collection_formats['files'] = 'csv'  # noqa: E501

        body_params = None
        # 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
            ['multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/datavec/{imageTransformName}/{versionName}/transformimage', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Base64NDArrayBody',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def transformincremental_csv(self, deployment_name, version_name, transform_name, **kwargs):  # noqa: E501
        """Takes SingleCSVRecord as input and returns the transformed array as SingleCSVRecord  # noqa: E501

        Takes a SingleCSVRecord object and transforms it into the desired format  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.transformincremental_csv(deployment_name, version_name, transform_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str transform_name: ID or name of the deployed transform (required)
        :param SingleCSVRecord single_csv_record: The input record array
        :return: SingleCSVRecord
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.transformincremental_csv_with_http_info(deployment_name, version_name, transform_name, **kwargs)  # noqa: E501
        else:
            (data) = self.transformincremental_csv_with_http_info(deployment_name, version_name, transform_name, **kwargs)  # noqa: E501
            return data

    def transformincremental_csv_with_http_info(self, deployment_name, version_name, transform_name, **kwargs):  # noqa: E501
        """Takes SingleCSVRecord as input and returns the transformed array as SingleCSVRecord  # noqa: E501

        Takes a SingleCSVRecord object and transforms it into the desired format  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.transformincremental_csv_with_http_info(deployment_name, version_name, transform_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str transform_name: ID or name of the deployed transform (required)
        :param SingleCSVRecord single_csv_record: The input record array
        :return: SingleCSVRecord
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['deployment_name', 'version_name', 'transform_name', 'single_csv_record']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method transformincremental_csv" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `transformincremental_csv`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `transformincremental_csv`")  # noqa: E501
        # verify the required parameter 'transform_name' is set
        if ('transform_name' not in params or
                params['transform_name'] is None):
            raise ValueError("Missing the required parameter `transform_name` when calling `transformincremental_csv`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'transform_name' in params:
            path_params['transformName'] = params['transform_name']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'single_csv_record' in params:
            body_params = params['single_csv_record']
        # 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/datavec/{transformName}/{versionName}/transformincremental', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SingleCSVRecord',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def transformincrementalarray(self, deployment_name, version_name, transform_name, **kwargs):  # noqa: E501
        """Same as /transformincremental but returns Base64NDArrayBody.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.transformincrementalarray(deployment_name, version_name, transform_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str transform_name: ID or name of the deployed transform (required)
        :param object single_record: The input record array
        :return: Base64NDArrayBody
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.transformincrementalarray_with_http_info(deployment_name, version_name, transform_name, **kwargs)  # noqa: E501
        else:
            (data) = self.transformincrementalarray_with_http_info(deployment_name, version_name, transform_name, **kwargs)  # noqa: E501
            return data

    def transformincrementalarray_with_http_info(self, deployment_name, version_name, transform_name, **kwargs):  # noqa: E501
        """Same as /transformincremental but returns Base64NDArrayBody.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.transformincrementalarray_with_http_info(deployment_name, version_name, transform_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str transform_name: ID or name of the deployed transform (required)
        :param object single_record: The input record array
        :return: Base64NDArrayBody
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['deployment_name', 'version_name', 'transform_name', 'single_record']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method transformincrementalarray" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `transformincrementalarray`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `transformincrementalarray`")  # noqa: E501
        # verify the required parameter 'transform_name' is set
        if ('transform_name' not in params or
                params['transform_name'] is None):
            raise ValueError("Missing the required parameter `transform_name` when calling `transformincrementalarray`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'transform_name' in params:
            path_params['transformName'] = params['transform_name']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'single_record' in params:
            body_params = params['single_record']
        # 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/datavec/{transformName}/{versionName}/transformincrementalarray', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Base64NDArrayBody',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def transformincrementalimage(self, deployment_name, version_name, image_transform_name, file, **kwargs):  # noqa: E501
        """Takes a single multipart image file to transform and returns Base64NDArrayBody  # noqa: E501

        Takes a single multipart image file and transforms it into the desired format and returns it in the form of Base64NDArrayBody  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.transformincrementalimage(deployment_name, version_name, image_transform_name, file, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str image_transform_name: ID or name of the deployed image transform (required)
        :param file file: The image file to upload (required)
        :return: Base64NDArrayBody
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.transformincrementalimage_with_http_info(deployment_name, version_name, image_transform_name, file, **kwargs)  # noqa: E501
        else:
            (data) = self.transformincrementalimage_with_http_info(deployment_name, version_name, image_transform_name, file, **kwargs)  # noqa: E501
            return data

    def transformincrementalimage_with_http_info(self, deployment_name, version_name, image_transform_name, file, **kwargs):  # noqa: E501
        """Takes a single multipart image file to transform and returns Base64NDArrayBody  # noqa: E501

        Takes a single multipart image file and transforms it into the desired format and returns it in the form of Base64NDArrayBody  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.transformincrementalimage_with_http_info(deployment_name, version_name, image_transform_name, file, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str image_transform_name: ID or name of the deployed image transform (required)
        :param file file: The image file to upload (required)
        :return: Base64NDArrayBody
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['deployment_name', 'version_name', 'image_transform_name', 'file']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method transformincrementalimage" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `transformincrementalimage`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `transformincrementalimage`")  # noqa: E501
        # verify the required parameter 'image_transform_name' is set
        if ('image_transform_name' not in params or
                params['image_transform_name'] is None):
            raise ValueError("Missing the required parameter `image_transform_name` when calling `transformincrementalimage`")  # noqa: E501
        # verify the required parameter 'file' is set
        if ('file' not in params or
                params['file'] is None):
            raise ValueError("Missing the required parameter `file` when calling `transformincrementalimage`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'image_transform_name' in params:
            path_params['imageTransformName'] = params['image_transform_name']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}
        if 'file' in params:
            local_var_files['file'] = params['file']  # noqa: E501

        body_params = None
        # 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
            ['multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/datavec/{imageTransformName}/{versionName}/transformincrementalimage', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Base64NDArrayBody',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def transformprocess_get(self, deployment_name, version_name, transform_name, **kwargs):  # noqa: E501
        """Gets the JSON string of the deployed transform process (CSV or Image)  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.transformprocess_get(deployment_name, version_name, transform_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str transform_name: ID or name of the deployed transform (required)
        :return: object
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.transformprocess_get_with_http_info(deployment_name, version_name, transform_name, **kwargs)  # noqa: E501
        else:
            (data) = self.transformprocess_get_with_http_info(deployment_name, version_name, transform_name, **kwargs)  # noqa: E501
            return data

    def transformprocess_get_with_http_info(self, deployment_name, version_name, transform_name, **kwargs):  # noqa: E501
        """Gets the JSON string of the deployed transform process (CSV or Image)  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.transformprocess_get_with_http_info(deployment_name, version_name, transform_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str transform_name: ID or name of the deployed transform (required)
        :return: object
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['deployment_name', 'version_name', 'transform_name']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method transformprocess_get" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `transformprocess_get`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `transformprocess_get`")  # noqa: E501
        # verify the required parameter 'transform_name' is set
        if ('transform_name' not in params or
                params['transform_name'] is None):
            raise ValueError("Missing the required parameter `transform_name` when calling `transformprocess_get`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'transform_name' in params:
            path_params['transformName'] = params['transform_name']  # 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/datavec/{transformName}/{versionName}/transformprocess', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='object',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def transformprocess_post(self, deployment_name, version_name, transform_name, **kwargs):  # noqa: E501
        """Sets the deployed (CSV or Image) transform process through the provided JSON string  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.transformprocess_post(deployment_name, version_name, transform_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str transform_name: ID or name of the deployed transform (required)
        :param object transform_process: The transform process to set
        :return: object
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.transformprocess_post_with_http_info(deployment_name, version_name, transform_name, **kwargs)  # noqa: E501
        else:
            (data) = self.transformprocess_post_with_http_info(deployment_name, version_name, transform_name, **kwargs)  # noqa: E501
            return data

    def transformprocess_post_with_http_info(self, deployment_name, version_name, transform_name, **kwargs):  # noqa: E501
        """Sets the deployed (CSV or Image) transform process through the provided JSON string  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.transformprocess_post_with_http_info(deployment_name, version_name, transform_name, async=True)
        >>> result = thread.get()

        :param async bool
        :param str deployment_name: Name of the deployment group (required)
        :param str version_name: Version name of the endpoint. The default value is \"default\" (required)
        :param str transform_name: ID or name of the deployed transform (required)
        :param object transform_process: The transform process to set
        :return: object
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['deployment_name', 'version_name', 'transform_name', 'transform_process']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method transformprocess_post" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'deployment_name' is set
        if ('deployment_name' not in params or
                params['deployment_name'] is None):
            raise ValueError("Missing the required parameter `deployment_name` when calling `transformprocess_post`")  # noqa: E501
        # verify the required parameter 'version_name' is set
        if ('version_name' not in params or
                params['version_name'] is None):
            raise ValueError("Missing the required parameter `version_name` when calling `transformprocess_post`")  # noqa: E501
        # verify the required parameter 'transform_name' is set
        if ('transform_name' not in params or
                params['transform_name'] is None):
            raise ValueError("Missing the required parameter `transform_name` when calling `transformprocess_post`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'deployment_name' in params:
            path_params['deploymentName'] = params['deployment_name']  # noqa: E501
        if 'version_name' in params:
            path_params['versionName'] = params['version_name']  # noqa: E501
        if 'transform_name' in params:
            path_params['transformName'] = params['transform_name']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'transform_process' in params:
            body_params = params['transform_process']
        # 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/endpoints/{deploymentName}/datavec/{transformName}/{versionName}/transformprocess', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='object',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_best_model_for_experiment(self, model_history_server_id, update_best_model, **kwargs):  # noqa: E501
        """Updates the best model for an experiment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_best_model_for_experiment(model_history_server_id, update_best_model, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param UpdateBestModel update_best_model: Model encapsulating the experiment id to update and the best model id. (required)
        :return: ExperimentEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.update_best_model_for_experiment_with_http_info(model_history_server_id, update_best_model, **kwargs)  # noqa: E501
        else:
            (data) = self.update_best_model_for_experiment_with_http_info(model_history_server_id, update_best_model, **kwargs)  # noqa: E501
            return data

    def update_best_model_for_experiment_with_http_info(self, model_history_server_id, update_best_model, **kwargs):  # noqa: E501
        """Updates the best model for an experiment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_best_model_for_experiment_with_http_info(model_history_server_id, update_best_model, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param UpdateBestModel update_best_model: Model encapsulating the experiment id to update and the best model id. (required)
        :return: ExperimentEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_history_server_id', 'update_best_model']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_best_model_for_experiment" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_history_server_id' is set
        if ('model_history_server_id' not in params or
                params['model_history_server_id'] is None):
            raise ValueError("Missing the required parameter `model_history_server_id` when calling `update_best_model_for_experiment`")  # noqa: E501
        # verify the required parameter 'update_best_model' is set
        if ('update_best_model' not in params or
                params['update_best_model'] is None):
            raise ValueError("Missing the required parameter `update_best_model` when calling `update_best_model_for_experiment`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'model_history_server_id' in params:
            path_params['modelHistoryServerId'] = params['model_history_server_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'update_best_model' in params:
            body_params = params['update_best_model']
        # 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/rpc/{modelHistoryServerId}/experiment/best', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ExperimentEntity',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_experiment(self, model_history_server_id, experiment_id, experiment_entity, **kwargs):  # noqa: E501
        """Updates an experiment, given an experiment entity  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_experiment(model_history_server_id, experiment_id, experiment_entity, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param str experiment_id: the GUID of the experiment to update (required)
        :param ExperimentEntity experiment_entity: The experiment entity to update with (required)
        :return: ExperimentEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.update_experiment_with_http_info(model_history_server_id, experiment_id, experiment_entity, **kwargs)  # noqa: E501
        else:
            (data) = self.update_experiment_with_http_info(model_history_server_id, experiment_id, experiment_entity, **kwargs)  # noqa: E501
            return data

    def update_experiment_with_http_info(self, model_history_server_id, experiment_id, experiment_entity, **kwargs):  # noqa: E501
        """Updates an experiment, given an experiment entity  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_experiment_with_http_info(model_history_server_id, experiment_id, experiment_entity, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param str experiment_id: the GUID of the experiment to update (required)
        :param ExperimentEntity experiment_entity: The experiment entity to update with (required)
        :return: ExperimentEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_history_server_id', 'experiment_id', 'experiment_entity']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_experiment" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_history_server_id' is set
        if ('model_history_server_id' not in params or
                params['model_history_server_id'] is None):
            raise ValueError("Missing the required parameter `model_history_server_id` when calling `update_experiment`")  # noqa: E501
        # verify the required parameter 'experiment_id' is set
        if ('experiment_id' not in params or
                params['experiment_id'] is None):
            raise ValueError("Missing the required parameter `experiment_id` when calling `update_experiment`")  # noqa: E501
        # verify the required parameter 'experiment_entity' is set
        if ('experiment_entity' not in params or
                params['experiment_entity'] is None):
            raise ValueError("Missing the required parameter `experiment_entity` when calling `update_experiment`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'model_history_server_id' in params:
            path_params['modelHistoryServerId'] = params['model_history_server_id']  # noqa: E501
        if 'experiment_id' in params:
            path_params['experimentID'] = params['experiment_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'experiment_entity' in params:
            body_params = params['experiment_entity']
        # 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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/rpc/{modelHistoryServerId}/experiment/{experimentID}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ExperimentEntity',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_model_history(self, model_history_server_id, model_history_id, update_model_history_request, **kwargs):  # noqa: E501
        """Update a model history / workspace  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_model_history(model_history_server_id, model_history_id, update_model_history_request, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param str model_history_id: the GUID of the model history / workspace to update (required)
        :param AddModelHistoryRequest update_model_history_request: The model history request object (required)
        :return: ModelHistoryEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.update_model_history_with_http_info(model_history_server_id, model_history_id, update_model_history_request, **kwargs)  # noqa: E501
        else:
            (data) = self.update_model_history_with_http_info(model_history_server_id, model_history_id, update_model_history_request, **kwargs)  # noqa: E501
            return data

    def update_model_history_with_http_info(self, model_history_server_id, model_history_id, update_model_history_request, **kwargs):  # noqa: E501
        """Update a model history / workspace  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_model_history_with_http_info(model_history_server_id, model_history_id, update_model_history_request, async=True)
        >>> result = thread.get()

        :param async bool
        :param str model_history_server_id: Process GUID of the model history server. Run `$SKIL_HOME/sbin/skil services` in a console to find out the model history server GUID. (required)
        :param str model_history_id: the GUID of the model history / workspace to update (required)
        :param AddModelHistoryRequest update_model_history_request: The model history request object (required)
        :return: ModelHistoryEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_history_server_id', 'model_history_id', 'update_model_history_request']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_model_history" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_history_server_id' is set
        if ('model_history_server_id' not in params or
                params['model_history_server_id'] is None):
            raise ValueError("Missing the required parameter `model_history_server_id` when calling `update_model_history`")  # noqa: E501
        # verify the required parameter 'model_history_id' is set
        if ('model_history_id' not in params or
                params['model_history_id'] is None):
            raise ValueError("Missing the required parameter `model_history_id` when calling `update_model_history`")  # noqa: E501
        # verify the required parameter 'update_model_history_request' is set
        if ('update_model_history_request' not in params or
                params['update_model_history_request'] is None):
            raise ValueError("Missing the required parameter `update_model_history_request` when calling `update_model_history`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'model_history_server_id' in params:
            path_params['modelHistoryServerId'] = params['model_history_server_id']  # noqa: E501
        if 'model_history_id' in params:
            path_params['modelHistoryID'] = params['model_history_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'update_model_history_request' in params:
            body_params = params['update_model_history_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 = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/rpc/{modelHistoryServerId}/modelhistory/{modelHistoryID}', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ModelHistoryEntity',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def upload(self, **kwargs):  # noqa: E501
        """Upload a model file to SKIL for import.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.upload(async=True)
        >>> result = thread.get()

        :param async bool
        :param file file: The file to upload.
        :return: FileUploadList
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.upload_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.upload_with_http_info(**kwargs)  # noqa: E501
            return data

    def upload_with_http_info(self, **kwargs):  # noqa: E501
        """Upload a model file to SKIL for import.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.upload_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param file file: The file to upload.
        :return: FileUploadList
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['file']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method upload" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}
        if 'file' in params:
            local_var_files['file'] = params['file']  # noqa: E501

        body_params = None
        # 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
            ['multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/api/upload/model', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='FileUploadList',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)
