text: # coding: utf-8
  
  """
      OpenSilex API
  
      No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)  # noqa: E501
  
      OpenAPI spec version: INSTANCE-SNAPSHOT
      
      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 opensilexClientToolsPython.api_client import ApiClient
  
  
  class DataApi(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_list_data(self, **kwargs):  # noqa: E501
          """Add data  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.add_list_data(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str authorization: Authentication token (required)
          :param list[DataCreationDTO] body: Data description
          :param str accept_language: Request accepted language
          :return: ObjectUriResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.add_list_data_with_http_info(**kwargs)  # noqa: E501
          else:
              (data) = self.add_list_data_with_http_info(**kwargs)  # noqa: E501
              return data
  
      def add_list_data_with_http_info(self, **kwargs):  # noqa: E501
          """Add data  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.add_list_data_with_http_info(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str authorization: Authentication token (required)
          :param list[DataCreationDTO] body: Data description
          :param str accept_language: Request accepted language
          :return: ObjectUriResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['body', ]  # noqa: E501
          all_params.append('async_req')
          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_list_data" % key
                  )
              params[key] = val
          del params['kwargs']
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          header_params = {}
          #if 'authorization' in params:
          #    header_params['Authorization'] = params['authorization']  # noqa: E501
          #if 'accept_language' in params:
          #    header_params['Accept-Language'] = params['accept_language']  # noqa: E501
  
          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 = []  # noqa: E501
  
          return self.api_client.call_api(
              '/core/data', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='ObjectUriResponse',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _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 count_data(self, **kwargs):  # noqa: E501
          """Count data  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.count_data(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str authorization: Authentication token (required)
          :param str start_date: Search by minimal date
          :param str end_date: Search by maximal date
          :param str timezone: Precise the timezone corresponding to the given dates
          :param list[str] experiments: Search by experiment uris
          :param list[str] targets: Search by target uris
          :param list[str] variables: Search by variables uris
          :param list[str] devices: Search by devices uris
          :param float min_confidence: Search by minimal confidence index
          :param float max_confidence: Search by maximal confidence index
          :param list[str] provenances: Search by provenances
          :param str metadata: Search by metadata
          :param str accept_language: Request accepted language
          :return: int
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.count_data_with_http_info(**kwargs)  # noqa: E501
          else:
              (data) = self.count_data_with_http_info(**kwargs)  # noqa: E501
              return data
  
      def count_data_with_http_info(self, **kwargs):  # noqa: E501
          """Count data  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.count_data_with_http_info(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str authorization: Authentication token (required)
          :param str start_date: Search by minimal date
          :param str end_date: Search by maximal date
          :param str timezone: Precise the timezone corresponding to the given dates
          :param list[str] experiments: Search by experiment uris
          :param list[str] targets: Search by target uris
          :param list[str] variables: Search by variables uris
          :param list[str] devices: Search by devices uris
          :param float min_confidence: Search by minimal confidence index
          :param float max_confidence: Search by maximal confidence index
          :param list[str] provenances: Search by provenances
          :param str metadata: Search by metadata
          :param str accept_language: Request accepted language
          :return: int
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['start_date', 'end_date', 'timezone', 'experiments', 'targets', 'variables', 'devices', 'min_confidence', 'max_confidence', 'provenances', 'metadata', ]  # noqa: E501
          all_params.append('async_req')
          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 count_data" % key
                  )
              params[key] = val
          del params['kwargs']
  
          if 'min_confidence' in params and params['min_confidence'] > 1:  # noqa: E501
              raise ValueError("Invalid value for parameter `min_confidence` when calling `count_data`, must be a value less than or equal to `1`")  # noqa: E501
          if 'min_confidence' in params and params['min_confidence'] < 0:  # noqa: E501
              raise ValueError("Invalid value for parameter `min_confidence` when calling `count_data`, must be a value greater than or equal to `0`")  # noqa: E501
          if 'max_confidence' in params and params['max_confidence'] > 1:  # noqa: E501
              raise ValueError("Invalid value for parameter `max_confidence` when calling `count_data`, must be a value less than or equal to `1`")  # noqa: E501
          if 'max_confidence' in params and params['max_confidence'] < 0:  # noqa: E501
              raise ValueError("Invalid value for parameter `max_confidence` when calling `count_data`, must be a value greater than or equal to `0`")  # noqa: E501
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'start_date' in params:
              query_params.append(('start_date', params['start_date']))  # noqa: E501
          if 'end_date' in params:
              query_params.append(('end_date', params['end_date']))  # noqa: E501
          if 'timezone' in params:
              query_params.append(('timezone', params['timezone']))  # noqa: E501
          if 'experiments' in params:
              query_params.append(('experiments', params['experiments']))  # noqa: E501
              collection_formats['experiments'] = 'multi'  # noqa: E501
          if 'targets' in params:
              query_params.append(('targets', params['targets']))  # noqa: E501
              collection_formats['targets'] = 'multi'  # noqa: E501
          if 'variables' in params:
              query_params.append(('variables', params['variables']))  # noqa: E501
              collection_formats['variables'] = 'multi'  # noqa: E501
          if 'devices' in params:
              query_params.append(('devices', params['devices']))  # noqa: E501
              collection_formats['devices'] = 'multi'  # noqa: E501
          if 'min_confidence' in params:
              query_params.append(('min_confidence', params['min_confidence']))  # noqa: E501
          if 'max_confidence' in params:
              query_params.append(('max_confidence', params['max_confidence']))  # noqa: E501
          if 'provenances' in params:
              query_params.append(('provenances', params['provenances']))  # noqa: E501
              collection_formats['provenances'] = 'multi'  # noqa: E501
          if 'metadata' in params:
              query_params.append(('metadata', params['metadata']))  # noqa: E501
  
          header_params = {}
          #if 'authorization' in params:
          #    header_params['Authorization'] = params['authorization']  # noqa: E501
          #if 'accept_language' in params:
          #    header_params['Accept-Language'] = params['accept_language']  # noqa: E501
  
          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 = []  # noqa: E501
  
          return self.api_client.call_api(
              '/core/data/count', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='int',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _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_provenance(self, **kwargs):  # noqa: E501
          """Add a provenance  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.create_provenance(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str authorization: Authentication token (required)
          :param ProvenanceCreationDTO body: Provenance description
          :param str accept_language: Request accepted language
          :return: ObjectUriResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.create_provenance_with_http_info(**kwargs)  # noqa: E501
          else:
              (data) = self.create_provenance_with_http_info(**kwargs)  # noqa: E501
              return data
  
      def create_provenance_with_http_info(self, **kwargs):  # noqa: E501
          """Add a provenance  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.create_provenance_with_http_info(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str authorization: Authentication token (required)
          :param ProvenanceCreationDTO body: Provenance description
          :param str accept_language: Request accepted language
          :return: ObjectUriResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['body', ]  # noqa: E501
          all_params.append('async_req')
          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_provenance" % key
                  )
              params[key] = val
          del params['kwargs']
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          header_params = {}
          #if 'authorization' in params:
          #    header_params['Authorization'] = params['authorization']  # noqa: E501
          #if 'accept_language' in params:
          #    header_params['Accept-Language'] = params['accept_language']  # noqa: E501
  
          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 = []  # noqa: E501
  
          return self.api_client.call_api(
              '/core/provenances', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='ObjectUriResponse',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _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_data(self, uri, **kwargs):  # noqa: E501
          """Delete data  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.delete_data(uri, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str uri: Data URI (required)
          :param str authorization: Authentication token (required)
          :param str accept_language: Request accepted language
          :return: ObjectUriResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.delete_data_with_http_info(uri, **kwargs)  # noqa: E501
          else:
              (data) = self.delete_data_with_http_info(uri, **kwargs)  # noqa: E501
              return data
  
      def delete_data_with_http_info(self, uri, **kwargs):  # noqa: E501
          """Delete data  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.delete_data_with_http_info(uri, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str uri: Data URI (required)
          :param str authorization: Authentication token (required)
          :param str accept_language: Request accepted language
          :return: ObjectUriResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['uri', ]  # noqa: E501
          all_params.append('async_req')
          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_data" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'uri' is set
          if ('uri' not in params or
                  params['uri'] is None):
              raise ValueError("Missing the required parameter `uri` when calling `delete_data`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'uri' in params:
              path_params['uri'] = params['uri']  # noqa: E501
  
          query_params = []
  
          header_params = {}
          #if 'authorization' in params:
          #    header_params['Authorization'] = params['authorization']  # noqa: E501
          #if 'accept_language' in params:
          #    header_params['Accept-Language'] = params['accept_language']  # noqa: E501
  
          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 = []  # noqa: E501
  
          return self.api_client.call_api(
              '/core/data/{uri}', 'DELETE',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='ObjectUriResponse',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _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_data_on_search(self, **kwargs):  # noqa: E501
          """Delete data on criteria  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.delete_data_on_search(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str authorization: Authentication token (required)
          :param str experiment: Search by experiment uri
          :param str target: Search by target uri
          :param str variable: Search by variable uri
          :param str provenance: Search by provenance uri
          :param str accept_language: Request accepted language
          :return: ObjectUriResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.delete_data_on_search_with_http_info(**kwargs)  # noqa: E501
          else:
              (data) = self.delete_data_on_search_with_http_info(**kwargs)  # noqa: E501
              return data
  
      def delete_data_on_search_with_http_info(self, **kwargs):  # noqa: E501
          """Delete data on criteria  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.delete_data_on_search_with_http_info(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str authorization: Authentication token (required)
          :param str experiment: Search by experiment uri
          :param str target: Search by target uri
          :param str variable: Search by variable uri
          :param str provenance: Search by provenance uri
          :param str accept_language: Request accepted language
          :return: ObjectUriResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['experiment', 'target', 'variable', 'provenance', ]  # noqa: E501
          all_params.append('async_req')
          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_data_on_search" % key
                  )
              params[key] = val
          del params['kwargs']
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'experiment' in params:
              query_params.append(('experiment', params['experiment']))  # noqa: E501
          if 'target' in params:
              query_params.append(('target', params['target']))  # noqa: E501
          if 'variable' in params:
              query_params.append(('variable', params['variable']))  # noqa: E501
          if 'provenance' in params:
              query_params.append(('provenance', params['provenance']))  # noqa: E501
  
          header_params = {}
          #if 'authorization' in params:
          #    header_params['Authorization'] = params['authorization']  # noqa: E501
          #if 'accept_language' in params:
          #    header_params['Accept-Language'] = params['accept_language']  # noqa: E501
  
          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 = []  # noqa: E501
  
          return self.api_client.call_api(
              '/core/data', 'DELETE',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='ObjectUriResponse',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _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_provenance(self, uri, **kwargs):  # noqa: E501
          """Delete a provenance that doesn't describe data  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.delete_provenance(uri, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str uri: Provenance URI (required)
          :param str authorization: Authentication token (required)
          :param str accept_language: Request accepted language
          :return: ObjectUriResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.delete_provenance_with_http_info(uri, **kwargs)  # noqa: E501
          else:
              (data) = self.delete_provenance_with_http_info(uri, **kwargs)  # noqa: E501
              return data
  
      def delete_provenance_with_http_info(self, uri, **kwargs):  # noqa: E501
          """Delete a provenance that doesn't describe data  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.delete_provenance_with_http_info(uri, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str uri: Provenance URI (required)
          :param str authorization: Authentication token (required)
          :param str accept_language: Request accepted language
          :return: ObjectUriResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['uri', ]  # noqa: E501
          all_params.append('async_req')
          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_provenance" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'uri' is set
          if ('uri' not in params or
                  params['uri'] is None):
              raise ValueError("Missing the required parameter `uri` when calling `delete_provenance`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'uri' in params:
              path_params['uri'] = params['uri']  # noqa: E501
  
          query_params = []
  
          header_params = {}
          #if 'authorization' in params:
          #    header_params['Authorization'] = params['authorization']  # noqa: E501
          #if 'accept_language' in params:
          #    header_params['Accept-Language'] = params['accept_language']  # noqa: E501
  
          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 = []  # noqa: E501
  
          return self.api_client.call_api(
              '/core/provenances/{uri}', 'DELETE',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='ObjectUriResponse',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _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 export_data(self, **kwargs):  # noqa: E501
          """Export data  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.export_data(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str authorization: Authentication token (required)
          :param str start_date: Search by minimal date
          :param str end_date: Search by maximal date
          :param str timezone: Precise the timezone corresponding to the given dates
          :param list[str] experiments: Search by experiment uris
          :param list[str] targets: Search by targets
          :param list[str] variables: Search by variables
          :param list[str] devices: Search by devices uris
          :param float min_confidence: Search by minimal confidence index
          :param float max_confidence: Search by maximal confidence index
          :param list[str] provenances: Search by provenances
          :param str metadata: Search by metadata
          :param str mode: Format wide or long
          :param bool with_raw_data: Export also raw_data
          :param list[str] order_by: List of fields to sort as an array of fieldName=asc|desc
          :param int page: Page number
          :param int page_size: Page size
          :param str accept_language: Request accepted language
          :return: None
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.export_data_with_http_info(**kwargs)  # noqa: E501
          else:
              (data) = self.export_data_with_http_info(**kwargs)  # noqa: E501
              return data
  
      def export_data_with_http_info(self, **kwargs):  # noqa: E501
          """Export data  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.export_data_with_http_info(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str authorization: Authentication token (required)
          :param str start_date: Search by minimal date
          :param str end_date: Search by maximal date
          :param str timezone: Precise the timezone corresponding to the given dates
          :param list[str] experiments: Search by experiment uris
          :param list[str] targets: Search by targets
          :param list[str] variables: Search by variables
          :param list[str] devices: Search by devices uris
          :param float min_confidence: Search by minimal confidence index
          :param float max_confidence: Search by maximal confidence index
          :param list[str] provenances: Search by provenances
          :param str metadata: Search by metadata
          :param str mode: Format wide or long
          :param bool with_raw_data: Export also raw_data
          :param list[str] order_by: List of fields to sort as an array of fieldName=asc|desc
          :param int page: Page number
          :param int page_size: Page size
          :param str accept_language: Request accepted language
          :return: None
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['start_date', 'end_date', 'timezone', 'experiments', 'targets', 'variables', 'devices', 'min_confidence', 'max_confidence', 'provenances', 'metadata', 'mode', 'with_raw_data', 'order_by', 'page', 'page_size', ]  # noqa: E501
          all_params.append('async_req')
          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 export_data" % key
                  )
              params[key] = val
          del params['kwargs']
  
          if 'min_confidence' in params and params['min_confidence'] > 1:  # noqa: E501
              raise ValueError("Invalid value for parameter `min_confidence` when calling `export_data`, must be a value less than or equal to `1`")  # noqa: E501
          if 'min_confidence' in params and params['min_confidence'] < 0:  # noqa: E501
              raise ValueError("Invalid value for parameter `min_confidence` when calling `export_data`, must be a value greater than or equal to `0`")  # noqa: E501
          if 'max_confidence' in params and params['max_confidence'] > 1:  # noqa: E501
              raise ValueError("Invalid value for parameter `max_confidence` when calling `export_data`, must be a value less than or equal to `1`")  # noqa: E501
          if 'max_confidence' in params and params['max_confidence'] < 0:  # noqa: E501
              raise ValueError("Invalid value for parameter `max_confidence` when calling `export_data`, must be a value greater than or equal to `0`")  # noqa: E501
          if 'page' in params and params['page'] < 0:  # noqa: E501
              raise ValueError("Invalid value for parameter `page` when calling `export_data`, must be a value greater than or equal to `0`")  # noqa: E501
          if 'page_size' in params and params['page_size'] < 0:  # noqa: E501
              raise ValueError("Invalid value for parameter `page_size` when calling `export_data`, must be a value greater than or equal to `0`")  # noqa: E501
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'start_date' in params:
              query_params.append(('start_date', params['start_date']))  # noqa: E501
          if 'end_date' in params:
              query_params.append(('end_date', params['end_date']))  # noqa: E501
          if 'timezone' in params:
              query_params.append(('timezone', params['timezone']))  # noqa: E501
          if 'experiments' in params:
              query_params.append(('experiments', params['experiments']))  # noqa: E501
              collection_formats['experiments'] = 'multi'  # noqa: E501
          if 'targets' in params:
              query_params.append(('targets', params['targets']))  # noqa: E501
              collection_formats['targets'] = 'multi'  # noqa: E501
          if 'variables' in params:
              query_params.append(('variables', params['variables']))  # noqa: E501
              collection_formats['variables'] = 'multi'  # noqa: E501
          if 'devices' in params:
              query_params.append(('devices', params['devices']))  # noqa: E501
              collection_formats['devices'] = 'multi'  # noqa: E501
          if 'min_confidence' in params:
              query_params.append(('min_confidence', params['min_confidence']))  # noqa: E501
          if 'max_confidence' in params:
              query_params.append(('max_confidence', params['max_confidence']))  # noqa: E501
          if 'provenances' in params:
              query_params.append(('provenances', params['provenances']))  # noqa: E501
              collection_formats['provenances'] = 'multi'  # noqa: E501
          if 'metadata' in params:
              query_params.append(('metadata', params['metadata']))  # noqa: E501
          if 'mode' in params:
              query_params.append(('mode', params['mode']))  # noqa: E501
          if 'with_raw_data' in params:
              query_params.append(('with_raw_data', params['with_raw_data']))  # noqa: E501
          if 'order_by' in params:
              query_params.append(('order_by', params['order_by']))  # noqa: E501
              collection_formats['order_by'] = 'multi'  # noqa: E501
          if 'page' in params:
              query_params.append(('page', params['page']))  # noqa: E501
          if 'page_size' in params:
              query_params.append(('page_size', params['page_size']))  # noqa: E501
  
          header_params = {}
          #if 'authorization' in params:
          #    header_params['Authorization'] = params['authorization']  # noqa: E501
          #if 'accept_language' in params:
          #    header_params['Accept-Language'] = params['accept_language']  # noqa: E501
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['text/plain'])  # 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(
              '/core/data/export', '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_req=params.get('async_req'),
              _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_data(self, uri, **kwargs):  # noqa: E501
          """Get data  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.get_data(uri, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str uri: Data URI (required)
          :param str authorization: Authentication token (required)
          :param str accept_language: Request accepted language
          :return: DataGetDTO
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.get_data_with_http_info(uri, **kwargs)  # noqa: E501
          else:
              (data) = self.get_data_with_http_info(uri, **kwargs)  # noqa: E501
              return data
  
      def get_data_with_http_info(self, uri, **kwargs):  # noqa: E501
          """Get data  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.get_data_with_http_info(uri, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str uri: Data URI (required)
          :param str authorization: Authentication token (required)
          :param str accept_language: Request accepted language
          :return: DataGetDTO
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['uri', ]  # noqa: E501
          all_params.append('async_req')
          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_data" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'uri' is set
          if ('uri' not in params or
                  params['uri'] is None):
              raise ValueError("Missing the required parameter `uri` when calling `get_data`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'uri' in params:
              path_params['uri'] = params['uri']  # noqa: E501
  
          query_params = []
  
          header_params = {}
          #if 'authorization' in params:
          #    header_params['Authorization'] = params['authorization']  # noqa: E501
          #if 'accept_language' in params:
          #    header_params['Accept-Language'] = params['accept_language']  # noqa: E501
  
          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 = []  # noqa: E501
  
          return self.api_client.call_api(
              '/core/data/{uri}', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='DataGetDTO',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _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_data_file(self, uri, **kwargs):  # noqa: E501
          """Get a data file  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.get_data_file(uri, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str uri: Search by fileUri (required)
          :param str authorization: Authentication token (required)
          :param str accept_language: Request accepted language
          :return: None
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.get_data_file_with_http_info(uri, **kwargs)  # noqa: E501
          else:
              (data) = self.get_data_file_with_http_info(uri, **kwargs)  # noqa: E501
              return data
  
      def get_data_file_with_http_info(self, uri, **kwargs):  # noqa: E501
          """Get a data file  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.get_data_file_with_http_info(uri, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str uri: Search by fileUri (required)
          :param str authorization: Authentication token (required)
          :param str accept_language: Request accepted language
          :return: None
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['uri', ]  # noqa: E501
          all_params.append('async_req')
          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_data_file" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'uri' is set
          if ('uri' not in params or
                  params['uri'] is None):
              raise ValueError("Missing the required parameter `uri` when calling `get_data_file`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'uri' in params:
              path_params['uri'] = params['uri']  # noqa: E501
  
          query_params = []
  
          header_params = {}
          #if 'authorization' in params:
          #    header_params['Authorization'] = params['authorization']  # noqa: E501
          #if 'accept_language' in params:
          #    header_params['Accept-Language'] = params['accept_language']  # noqa: E501
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/octet-stream'])  # 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(
              '/core/datafiles/{uri}', '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_req=params.get('async_req'),
              _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_data_file_description(self, uri, **kwargs):  # noqa: E501
          """Get a data file description  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.get_data_file_description(uri, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str uri: Search by fileUri (required)
          :param str authorization: Authentication token (required)
          :param str accept_language: Request accepted language
          :return: DataFileGetDTO
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.get_data_file_description_with_http_info(uri, **kwargs)  # noqa: E501
          else:
              (data) = self.get_data_file_description_with_http_info(uri, **kwargs)  # noqa: E501
              return data
  
      def get_data_file_description_with_http_info(self, uri, **kwargs):  # noqa: E501
          """Get a data file description  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.get_data_file_description_with_http_info(uri, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str uri: Search by fileUri (required)
          :param str authorization: Authentication token (required)
          :param str accept_language: Request accepted language
          :return: DataFileGetDTO
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['uri', ]  # noqa: E501
          all_params.append('async_req')
          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_data_file_description" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'uri' is set
          if ('uri' not in params or
                  params['uri'] is None):
              raise ValueError("Missing the required parameter `uri` when calling `get_data_file_description`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'uri' in params:
              path_params['uri'] = params['uri']  # noqa: E501
  
          query_params = []
  
          header_params = {}
          #if 'authorization' in params:
          #    header_params['Authorization'] = params['authorization']  # noqa: E501
          #if 'accept_language' in params:
          #    header_params['Accept-Language'] = params['accept_language']  # noqa: E501
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/core/datafiles/{uri}/description', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='DataFileGetDTO',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _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_data_file_descriptions_by_search(self, **kwargs):  # noqa: E501
          """Search data files  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.get_data_file_descriptions_by_search(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str authorization: Authentication token (required)
          :param str rdf_type: Search by rdf type uri
          :param str start_date: Search by minimal date
          :param str end_date: Search by maximal date
          :param str timezone: Precise the timezone corresponding to the given dates
          :param list[str] experiments: Search by experiments
          :param list[str] targets: Search by targets uris list
          :param list[str] devices: Search by devices uris
          :param list[str] provenances: Search by provenance uris list
          :param str metadata: Search by metadata
          :param list[str] order_by: List of fields to sort as an array of fieldName=asc|desc
          :param int page: Page number
          :param int page_size: Page size
          :param str accept_language: Request accepted language
          :return: list[DataFileGetDTO]
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.get_data_file_descriptions_by_search_with_http_info(**kwargs)  # noqa: E501
          else:
              (data) = self.get_data_file_descriptions_by_search_with_http_info(**kwargs)  # noqa: E501
              return data
  
      def get_data_file_descriptions_by_search_with_http_info(self, **kwargs):  # noqa: E501
          """Search data files  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.get_data_file_descriptions_by_search_with_http_info(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str authorization: Authentication token (required)
          :param str rdf_type: Search by rdf type uri
          :param str start_date: Search by minimal date
          :param str end_date: Search by maximal date
          :param str timezone: Precise the timezone corresponding to the given dates
          :param list[str] experiments: Search by experiments
          :param list[str] targets: Search by targets uris list
          :param list[str] devices: Search by devices uris
          :param list[str] provenances: Search by provenance uris list
          :param str metadata: Search by metadata
          :param list[str] order_by: List of fields to sort as an array of fieldName=asc|desc
          :param int page: Page number
          :param int page_size: Page size
          :param str accept_language: Request accepted language
          :return: list[DataFileGetDTO]
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['rdf_type', 'start_date', 'end_date', 'timezone', 'experiments', 'targets', 'devices', 'provenances', 'metadata', 'order_by', 'page', 'page_size', ]  # noqa: E501
          all_params.append('async_req')
          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_data_file_descriptions_by_search" % key
                  )
              params[key] = val
          del params['kwargs']
  
          if 'page' in params and params['page'] < 0:  # noqa: E501
              raise ValueError("Invalid value for parameter `page` when calling `get_data_file_descriptions_by_search`, must be a value greater than or equal to `0`")  # noqa: E501
          if 'page_size' in params and params['page_size'] < 0:  # noqa: E501
              raise ValueError("Invalid value for parameter `page_size` when calling `get_data_file_descriptions_by_search`, must be a value greater than or equal to `0`")  # noqa: E501
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'rdf_type' in params:
              query_params.append(('rdf_type', params['rdf_type']))  # noqa: E501
          if 'start_date' in params:
              query_params.append(('start_date', params['start_date']))  # noqa: E501
          if 'end_date' in params:
              query_params.append(('end_date', params['end_date']))  # noqa: E501
          if 'timezone' in params:
              query_params.append(('timezone', params['timezone']))  # noqa: E501
          if 'experiments' in params:
              query_params.append(('experiments', params['experiments']))  # noqa: E501
              collection_formats['experiments'] = 'multi'  # noqa: E501
          if 'targets' in params:
              query_params.append(('targets', params['targets']))  # noqa: E501
              collection_formats['targets'] = 'multi'  # noqa: E501
          if 'devices' in params:
              query_params.append(('devices', params['devices']))  # noqa: E501
              collection_formats['devices'] = 'multi'  # noqa: E501
          if 'provenances' in params:
              query_params.append(('provenances', params['provenances']))  # noqa: E501
              collection_formats['provenances'] = 'multi'  # noqa: E501
          if 'metadata' in params:
              query_params.append(('metadata', params['metadata']))  # noqa: E501
          if 'order_by' in params:
              query_params.append(('order_by', params['order_by']))  # noqa: E501
              collection_formats['order_by'] = 'multi'  # noqa: E501
          if 'page' in params:
              query_params.append(('page', params['page']))  # noqa: E501
          if 'page_size' in params:
              query_params.append(('page_size', params['page_size']))  # noqa: E501
  
          header_params = {}
          #if 'authorization' in params:
          #    header_params['Authorization'] = params['authorization']  # noqa: E501
          #if 'accept_language' in params:
          #    header_params['Accept-Language'] = params['accept_language']  # noqa: E501
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/core/datafiles', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='list[DataFileGetDTO]',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _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_datafiles_provenances(self, **kwargs):  # noqa: E501
          """Get provenances linked to datafiles  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.get_datafiles_provenances(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str authorization: Authentication token (required)
          :param list[str] experiments: Search by experiment uris
          :param list[str] targets: Search by targets uris
          :param list[str] devices: Search by devices uris
          :param str accept_language: Request accepted language
          :return: list[ProvenanceGetDTO]
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.get_datafiles_provenances_with_http_info(**kwargs)  # noqa: E501
          else:
              (data) = self.get_datafiles_provenances_with_http_info(**kwargs)  # noqa: E501
              return data
  
      def get_datafiles_provenances_with_http_info(self, **kwargs):  # noqa: E501
          """Get provenances linked to datafiles  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.get_datafiles_provenances_with_http_info(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str authorization: Authentication token (required)
          :param list[str] experiments: Search by experiment uris
          :param list[str] targets: Search by targets uris
          :param list[str] devices: Search by devices uris
          :param str accept_language: Request accepted language
          :return: list[ProvenanceGetDTO]
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['experiments', 'targets', 'devices', ]  # noqa: E501
          all_params.append('async_req')
          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_datafiles_provenances" % key
                  )
              params[key] = val
          del params['kwargs']
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'experiments' in params:
              query_params.append(('experiments', params['experiments']))  # noqa: E501
              collection_formats['experiments'] = 'multi'  # noqa: E501
          if 'targets' in params:
              query_params.append(('targets', params['targets']))  # noqa: E501
              collection_formats['targets'] = 'multi'  # noqa: E501
          if 'devices' in params:
              query_params.append(('devices', params['devices']))  # noqa: E501
              collection_formats['devices'] = 'multi'  # noqa: E501
  
          header_params = {}
          #if 'authorization' in params:
          #    header_params['Authorization'] = params['authorization']  # noqa: E501
          #if 'accept_language' in params:
          #    header_params['Accept-Language'] = params['accept_language']  # noqa: E501
  
          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 = []  # noqa: E501
  
          return self.api_client.call_api(
              '/core/datafiles/provenances', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='list[ProvenanceGetDTO]',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _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_pictures_thumbnails(self, uri, **kwargs):  # noqa: E501
          """Get a picture thumbnail  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.get_pictures_thumbnails(uri, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str uri: Search by fileUri (required)
          :param str authorization: Authentication token (required)
          :param int scaled_width: Thumbnail width
          :param int scaled_height: Thumbnail height
          :param str accept_language: Request accepted language
          :return: None
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.get_pictures_thumbnails_with_http_info(uri, **kwargs)  # noqa: E501
          else:
              (data) = self.get_pictures_thumbnails_with_http_info(uri, **kwargs)  # noqa: E501
              return data
  
      def get_pictures_thumbnails_with_http_info(self, uri, **kwargs):  # noqa: E501
          """Get a picture thumbnail  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.get_pictures_thumbnails_with_http_info(uri, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str uri: Search by fileUri (required)
          :param str authorization: Authentication token (required)
          :param int scaled_width: Thumbnail width
          :param int scaled_height: Thumbnail height
          :param str accept_language: Request accepted language
          :return: None
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['uri', 'scaled_width', 'scaled_height', ]  # noqa: E501
          all_params.append('async_req')
          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_pictures_thumbnails" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'uri' is set
          if ('uri' not in params or
                  params['uri'] is None):
              raise ValueError("Missing the required parameter `uri` when calling `get_pictures_thumbnails`")  # noqa: E501
  
          if 'scaled_width' in params and params['scaled_width'] > 1920:  # noqa: E501
              raise ValueError("Invalid value for parameter `scaled_width` when calling `get_pictures_thumbnails`, must be a value less than or equal to `1920`")  # noqa: E501
          if 'scaled_width' in params and params['scaled_width'] < 256:  # noqa: E501
              raise ValueError("Invalid value for parameter `scaled_width` when calling `get_pictures_thumbnails`, must be a value greater than or equal to `256`")  # noqa: E501
          if 'scaled_height' in params and params['scaled_height'] > 1080:  # noqa: E501
              raise ValueError("Invalid value for parameter `scaled_height` when calling `get_pictures_thumbnails`, must be a value less than or equal to `1080`")  # noqa: E501
          if 'scaled_height' in params and params['scaled_height'] < 144:  # noqa: E501
              raise ValueError("Invalid value for parameter `scaled_height` when calling `get_pictures_thumbnails`, must be a value greater than or equal to `144`")  # noqa: E501
          collection_formats = {}
  
          path_params = {}
          if 'uri' in params:
              path_params['uri'] = params['uri']  # noqa: E501
  
          query_params = []
          if 'scaled_width' in params:
              query_params.append(('scaled_width', params['scaled_width']))  # noqa: E501
          if 'scaled_height' in params:
              query_params.append(('scaled_height', params['scaled_height']))  # noqa: E501
  
          header_params = {}
          #if 'authorization' in params:
          #    header_params['Authorization'] = params['authorization']  # noqa: E501
          #if 'accept_language' in params:
          #    header_params['Accept-Language'] = params['accept_language']  # noqa: E501
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/octet-stream'])  # 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(
              '/core/datafiles/{uri}/thumbnail', '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_req=params.get('async_req'),
              _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_provenance(self, uri, **kwargs):  # noqa: E501
          """Get a provenance  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.get_provenance(uri, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str uri: Provenance URI (required)
          :param str authorization: Authentication token (required)
          :param str accept_language: Request accepted language
          :return: ProvenanceGetDTO
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.get_provenance_with_http_info(uri, **kwargs)  # noqa: E501
          else:
              (data) = self.get_provenance_with_http_info(uri, **kwargs)  # noqa: E501
              return data
  
      def get_provenance_with_http_info(self, uri, **kwargs):  # noqa: E501
          """Get a provenance  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.get_provenance_with_http_info(uri, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str uri: Provenance URI (required)
          :param str authorization: Authentication token (required)
          :param str accept_language: Request accepted language
          :return: ProvenanceGetDTO
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['uri', ]  # noqa: E501
          all_params.append('async_req')
          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_provenance" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'uri' is set
          if ('uri' not in params or
                  params['uri'] is None):
              raise ValueError("Missing the required parameter `uri` when calling `get_provenance`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'uri' in params:
              path_params['uri'] = params['uri']  # noqa: E501
  
          query_params = []
  
          header_params = {}
          #if 'authorization' in params:
          #    header_params['Authorization'] = params['authorization']  # noqa: E501
          #if 'accept_language' in params:
          #    header_params['Accept-Language'] = params['accept_language']  # noqa: E501
  
          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 = []  # noqa: E501
  
          return self.api_client.call_api(
              '/core/provenances/{uri}', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='ProvenanceGetDTO',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _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_provenances_by_ur_is(self, uris, **kwargs):  # noqa: E501
          """Get a list of provenances by their URIs  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.get_provenances_by_ur_is(uris, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param list[str] uris: Provenances URIs (required)
          :param str authorization: Authentication token (required)
          :param str accept_language: Request accepted language
          :return: list[ProvenanceGetDTO]
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.get_provenances_by_ur_is_with_http_info(uris, **kwargs)  # noqa: E501
          else:
              (data) = self.get_provenances_by_ur_is_with_http_info(uris, **kwargs)  # noqa: E501
              return data
  
      def get_provenances_by_ur_is_with_http_info(self, uris, **kwargs):  # noqa: E501
          """Get a list of provenances by their URIs  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.get_provenances_by_ur_is_with_http_info(uris, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param list[str] uris: Provenances URIs (required)
          :param str authorization: Authentication token (required)
          :param str accept_language: Request accepted language
          :return: list[ProvenanceGetDTO]
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['uris', ]  # noqa: E501
          all_params.append('async_req')
          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_provenances_by_ur_is" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'uris' is set
          if ('uris' not in params or
                  params['uris'] is None):
              raise ValueError("Missing the required parameter `uris` when calling `get_provenances_by_ur_is`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'uris' in params:
              query_params.append(('uris', params['uris']))  # noqa: E501
              collection_formats['uris'] = 'multi'  # noqa: E501
  
          header_params = {}
          #if 'authorization' in params:
          #    header_params['Authorization'] = params['authorization']  # noqa: E501
          #if 'accept_language' in params:
          #    header_params['Accept-Language'] = params['accept_language']  # noqa: E501
  
          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 = []  # noqa: E501
  
          return self.api_client.call_api(
              '/core/provenances/by_uris', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='list[ProvenanceGetDTO]',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _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_used_provenances(self, **kwargs):  # noqa: E501
          """Get provenances linked to data  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.get_used_provenances(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str authorization: Authentication token (required)
          :param list[str] experiments: Search by experiment uris
          :param list[str] targets: Search by targets uris
          :param list[str] variables: Search by variables uris
          :param list[str] devices: Search by devices uris
          :param str accept_language: Request accepted language
          :return: list[ProvenanceGetDTO]
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.get_used_provenances_with_http_info(**kwargs)  # noqa: E501
          else:
              (data) = self.get_used_provenances_with_http_info(**kwargs)  # noqa: E501
              return data
  
      def get_used_provenances_with_http_info(self, **kwargs):  # noqa: E501
          """Get provenances linked to data  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.get_used_provenances_with_http_info(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str authorization: Authentication token (required)
          :param list[str] experiments: Search by experiment uris
          :param list[str] targets: Search by targets uris
          :param list[str] variables: Search by variables uris
          :param list[str] devices: Search by devices uris
          :param str accept_language: Request accepted language
          :return: list[ProvenanceGetDTO]
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['experiments', 'targets', 'variables', 'devices', ]  # noqa: E501
          all_params.append('async_req')
          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_used_provenances" % key
                  )
              params[key] = val
          del params['kwargs']
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'experiments' in params:
              query_params.append(('experiments', params['experiments']))  # noqa: E501
              collection_formats['experiments'] = 'multi'  # noqa: E501
          if 'targets' in params:
              query_params.append(('targets', params['targets']))  # noqa: E501
              collection_formats['targets'] = 'multi'  # noqa: E501
          if 'variables' in params:
              query_params.append(('variables', params['variables']))  # noqa: E501
              collection_formats['variables'] = 'multi'  # noqa: E501
          if 'devices' in params:
              query_params.append(('devices', params['devices']))  # noqa: E501
              collection_formats['devices'] = 'multi'  # noqa: E501
  
          header_params = {}
          #if 'authorization' in params:
          #    header_params['Authorization'] = params['authorization']  # noqa: E501
          #if 'accept_language' in params:
          #    header_params['Accept-Language'] = params['accept_language']  # noqa: E501
  
          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 = []  # noqa: E501
  
          return self.api_client.call_api(
              '/core/data/provenances', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='list[ProvenanceGetDTO]',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _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_used_variables(self, **kwargs):  # noqa: E501
          """Get variables linked to data  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.get_used_variables(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str authorization: Authentication token (required)
          :param list[str] experiments: Search by experiment uris
          :param list[str] targets: Search by targets uris
          :param list[str] provenances: Search by provenance uris
          :param str accept_language: Request accepted language
          :return: list[ProvenanceGetDTO]
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.get_used_variables_with_http_info(**kwargs)  # noqa: E501
          else:
              (data) = self.get_used_variables_with_http_info(**kwargs)  # noqa: E501
              return data
  
      def get_used_variables_with_http_info(self, **kwargs):  # noqa: E501
          """Get variables linked to data  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.get_used_variables_with_http_info(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str authorization: Authentication token (required)
          :param list[str] experiments: Search by experiment uris
          :param list[str] targets: Search by targets uris
          :param list[str] provenances: Search by provenance uris
          :param str accept_language: Request accepted language
          :return: list[ProvenanceGetDTO]
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['experiments', 'targets', 'provenances', ]  # noqa: E501
          all_params.append('async_req')
          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_used_variables" % key
                  )
              params[key] = val
          del params['kwargs']
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'experiments' in params:
              query_params.append(('experiments', params['experiments']))  # noqa: E501
              collection_formats['experiments'] = 'multi'  # noqa: E501
          if 'targets' in params:
              query_params.append(('targets', params['targets']))  # noqa: E501
              collection_formats['targets'] = 'multi'  # noqa: E501
          if 'provenances' in params:
              query_params.append(('provenances', params['provenances']))  # noqa: E501
              collection_formats['provenances'] = 'multi'  # noqa: E501
  
          header_params = {}
          #if 'authorization' in params:
          #    header_params['Authorization'] = params['authorization']  # noqa: E501
          #if 'accept_language' in params:
          #    header_params['Accept-Language'] = params['accept_language']  # noqa: E501
  
          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 = []  # noqa: E501
  
          return self.api_client.call_api(
              '/core/data/variables', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='list[ProvenanceGetDTO]',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _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 import_csv_data(self, provenance, file, **kwargs):  # noqa: E501
          """Import a CSV file for the given provenanceURI  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.import_csv_data(provenance, file, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str provenance: Provenance URI (required)
          :param file file: File (required)
          :param str authorization: Authentication token (required)
          :param str accept_language: Request accepted language
          :return: DataCSVValidationDTO
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.import_csv_data_with_http_info(provenance, file, **kwargs)  # noqa: E501
          else:
              (data) = self.import_csv_data_with_http_info(provenance, file, **kwargs)  # noqa: E501
              return data
  
      def import_csv_data_with_http_info(self, provenance, file, **kwargs):  # noqa: E501
          """Import a CSV file for the given provenanceURI  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.import_csv_data_with_http_info(provenance, file, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str provenance: Provenance URI (required)
          :param file file: File (required)
          :param str authorization: Authentication token (required)
          :param str accept_language: Request accepted language
          :return: DataCSVValidationDTO
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['provenance', 'file', ]  # noqa: E501
          all_params.append('async_req')
          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 import_csv_data" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'provenance' is set
          if ('provenance' not in params or
                  params['provenance'] is None):
              raise ValueError("Missing the required parameter `provenance` when calling `import_csv_data`")  # 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 `import_csv_data`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'provenance' in params:
              query_params.append(('provenance', params['provenance']))  # noqa: E501
  
          header_params = {}
          #if 'authorization' in params:
          #    header_params['Authorization'] = params['authorization']  # noqa: E501
          #if 'accept_language' in params:
          #    header_params['Accept-Language'] = params['accept_language']  # noqa: E501
  
          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 = []  # noqa: E501
  
          return self.api_client.call_api(
              '/core/data/import', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='DataCSVValidationDTO',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _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 post_data_file(self, description, file, **kwargs):  # noqa: E501
          """Add a data file  # noqa: E501
  
          {\"rdf_type\":\"http://www.opensilex.org/vocabulary/oeso#Image\", \"date\":\"2020-08-21T00:00:00+01:00\", \"target\":\"http://plot01\", \"provenance\": { \"uri\":\"http://opensilex.dev/provenance/1598001689415\" }, \"metadata\":{ \"LabelView\" : \"side90\", \"paramA\" : \"90\"}}  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.post_data_file(description, file, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str description: File description with metadata (required)
          :param file file: Data file (required)
          :param str authorization: Authentication token (required)
          :param str accept_language: Request accepted language
          :return: ObjectUriResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.post_data_file_with_http_info(description, file, **kwargs)  # noqa: E501
          else:
              (data) = self.post_data_file_with_http_info(description, file, **kwargs)  # noqa: E501
              return data
  
      def post_data_file_with_http_info(self, description, file, **kwargs):  # noqa: E501
          """Add a data file  # noqa: E501
  
          {\"rdf_type\":\"http://www.opensilex.org/vocabulary/oeso#Image\", \"date\":\"2020-08-21T00:00:00+01:00\", \"target\":\"http://plot01\", \"provenance\": { \"uri\":\"http://opensilex.dev/provenance/1598001689415\" }, \"metadata\":{ \"LabelView\" : \"side90\", \"paramA\" : \"90\"}}  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.post_data_file_with_http_info(description, file, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str description: File description with metadata (required)
          :param file file: Data file (required)
          :param str authorization: Authentication token (required)
          :param str accept_language: Request accepted language
          :return: ObjectUriResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['description', 'file', ]  # noqa: E501
          all_params.append('async_req')
          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 post_data_file" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'description' is set
          if ('description' not in params or
                  params['description'] is None):
              raise ValueError("Missing the required parameter `description` when calling `post_data_file`")  # 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 `post_data_file`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          header_params = {}
          #if 'authorization' in params:
          #    header_params['Authorization'] = params['authorization']  # noqa: E501
          #if 'accept_language' in params:
          #    header_params['Accept-Language'] = params['accept_language']  # noqa: E501
  
          form_params = []
          local_var_files = {}
          if 'description' in params:
              form_params.append(('description', params['description']))  # noqa: E501
          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 = []  # noqa: E501
  
          return self.api_client.call_api(
              '/core/datafiles', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='ObjectUriResponse',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _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 post_data_file_paths(self, body, **kwargs):  # noqa: E501
          """Describe datafiles and give their relative paths in the configured storage system. In the case of already stored datafiles.  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.post_data_file_paths(body, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param list[DataFilePathCreationDTO] body: Metadata of the file (required)
          :param str authorization: Authentication token (required)
          :param str accept_language: Request accepted language
          :return: ObjectUriResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.post_data_file_paths_with_http_info(body, **kwargs)  # noqa: E501
          else:
              (data) = self.post_data_file_paths_with_http_info(body, **kwargs)  # noqa: E501
              return data
  
      def post_data_file_paths_with_http_info(self, body, **kwargs):  # noqa: E501
          """Describe datafiles and give their relative paths in the configured storage system. In the case of already stored datafiles.  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.post_data_file_paths_with_http_info(body, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param list[DataFilePathCreationDTO] body: Metadata of the file (required)
          :param str authorization: Authentication token (required)
          :param str accept_language: Request accepted language
          :return: ObjectUriResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['body', ]  # noqa: E501
          all_params.append('async_req')
          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 post_data_file_paths" % 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 `post_data_file_paths`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          header_params = {}
          #if 'authorization' in params:
          #    header_params['Authorization'] = params['authorization']  # noqa: E501
          #if 'accept_language' in params:
          #    header_params['Accept-Language'] = params['accept_language']  # noqa: E501
  
          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 = []  # noqa: E501
  
          return self.api_client.call_api(
              '/core/datafiles/description', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='ObjectUriResponse',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _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 search_data_list(self, **kwargs):  # noqa: E501
          """Search data  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.search_data_list(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str authorization: Authentication token (required)
          :param str start_date: Search by minimal date
          :param str end_date: Search by maximal date
          :param str timezone: Precise the timezone corresponding to the given dates
          :param list[str] experiments: Search by experiment uris
          :param list[str] targets: Search by targets uris
          :param list[str] variables: Search by variables uris
          :param list[str] devices: Search by devices uris
          :param float min_confidence: Search by minimal confidence index
          :param float max_confidence: Search by maximal confidence index
          :param list[str] provenances: Search by provenances
          :param str metadata: Search by metadata
          :param list[str] order_by: List of fields to sort as an array of fieldName=asc|desc
          :param int page: Page number
          :param int page_size: Page size
          :param str accept_language: Request accepted language
          :return: list[DataGetDTO]
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.search_data_list_with_http_info(**kwargs)  # noqa: E501
          else:
              (data) = self.search_data_list_with_http_info(**kwargs)  # noqa: E501
              return data
  
      def search_data_list_with_http_info(self, **kwargs):  # noqa: E501
          """Search data  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.search_data_list_with_http_info(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str authorization: Authentication token (required)
          :param str start_date: Search by minimal date
          :param str end_date: Search by maximal date
          :param str timezone: Precise the timezone corresponding to the given dates
          :param list[str] experiments: Search by experiment uris
          :param list[str] targets: Search by targets uris
          :param list[str] variables: Search by variables uris
          :param list[str] devices: Search by devices uris
          :param float min_confidence: Search by minimal confidence index
          :param float max_confidence: Search by maximal confidence index
          :param list[str] provenances: Search by provenances
          :param str metadata: Search by metadata
          :param list[str] order_by: List of fields to sort as an array of fieldName=asc|desc
          :param int page: Page number
          :param int page_size: Page size
          :param str accept_language: Request accepted language
          :return: list[DataGetDTO]
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['start_date', 'end_date', 'timezone', 'experiments', 'targets', 'variables', 'devices', 'min_confidence', 'max_confidence', 'provenances', 'metadata', 'order_by', 'page', 'page_size', ]  # noqa: E501
          all_params.append('async_req')
          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 search_data_list" % key
                  )
              params[key] = val
          del params['kwargs']
  
          if 'min_confidence' in params and params['min_confidence'] > 1:  # noqa: E501
              raise ValueError("Invalid value for parameter `min_confidence` when calling `search_data_list`, must be a value less than or equal to `1`")  # noqa: E501
          if 'min_confidence' in params and params['min_confidence'] < 0:  # noqa: E501
              raise ValueError("Invalid value for parameter `min_confidence` when calling `search_data_list`, must be a value greater than or equal to `0`")  # noqa: E501
          if 'max_confidence' in params and params['max_confidence'] > 1:  # noqa: E501
              raise ValueError("Invalid value for parameter `max_confidence` when calling `search_data_list`, must be a value less than or equal to `1`")  # noqa: E501
          if 'max_confidence' in params and params['max_confidence'] < 0:  # noqa: E501
              raise ValueError("Invalid value for parameter `max_confidence` when calling `search_data_list`, must be a value greater than or equal to `0`")  # noqa: E501
          if 'page' in params and params['page'] < 0:  # noqa: E501
              raise ValueError("Invalid value for parameter `page` when calling `search_data_list`, must be a value greater than or equal to `0`")  # noqa: E501
          if 'page_size' in params and params['page_size'] < 0:  # noqa: E501
              raise ValueError("Invalid value for parameter `page_size` when calling `search_data_list`, must be a value greater than or equal to `0`")  # noqa: E501
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'start_date' in params:
              query_params.append(('start_date', params['start_date']))  # noqa: E501
          if 'end_date' in params:
              query_params.append(('end_date', params['end_date']))  # noqa: E501
          if 'timezone' in params:
              query_params.append(('timezone', params['timezone']))  # noqa: E501
          if 'experiments' in params:
              query_params.append(('experiments', params['experiments']))  # noqa: E501
              collection_formats['experiments'] = 'multi'  # noqa: E501
          if 'targets' in params:
              query_params.append(('targets', params['targets']))  # noqa: E501
              collection_formats['targets'] = 'multi'  # noqa: E501
          if 'variables' in params:
              query_params.append(('variables', params['variables']))  # noqa: E501
              collection_formats['variables'] = 'multi'  # noqa: E501
          if 'devices' in params:
              query_params.append(('devices', params['devices']))  # noqa: E501
              collection_formats['devices'] = 'multi'  # noqa: E501
          if 'min_confidence' in params:
              query_params.append(('min_confidence', params['min_confidence']))  # noqa: E501
          if 'max_confidence' in params:
              query_params.append(('max_confidence', params['max_confidence']))  # noqa: E501
          if 'provenances' in params:
              query_params.append(('provenances', params['provenances']))  # noqa: E501
              collection_formats['provenances'] = 'multi'  # noqa: E501
          if 'metadata' in params:
              query_params.append(('metadata', params['metadata']))  # noqa: E501
          if 'order_by' in params:
              query_params.append(('order_by', params['order_by']))  # noqa: E501
              collection_formats['order_by'] = 'multi'  # noqa: E501
          if 'page' in params:
              query_params.append(('page', params['page']))  # noqa: E501
          if 'page_size' in params:
              query_params.append(('page_size', params['page_size']))  # noqa: E501
  
          header_params = {}
          #if 'authorization' in params:
          #    header_params['Authorization'] = params['authorization']  # noqa: E501
          #if 'accept_language' in params:
          #    header_params['Accept-Language'] = params['accept_language']  # noqa: E501
  
          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 = []  # noqa: E501
  
          return self.api_client.call_api(
              '/core/data', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='list[DataGetDTO]',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _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 search_provenance(self, **kwargs):  # noqa: E501
          """Get provenances  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.search_provenance(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str authorization: Authentication token (required)
          :param str name: Regex pattern for filtering by name
          :param str description: Search by description
          :param str activity: Search by activity URI
          :param str activity_type: Search by activity type
          :param str agent: Search by agent URI
          :param str agent_type: Search by agent type
          :param list[str] order_by: List of fields to sort as an array of fieldName=asc|desc
          :param int page: Page number
          :param int page_size: Page size
          :param str accept_language: Request accepted language
          :return: list[ProvenanceGetDTO]
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.search_provenance_with_http_info(**kwargs)  # noqa: E501
          else:
              (data) = self.search_provenance_with_http_info(**kwargs)  # noqa: E501
              return data
  
      def search_provenance_with_http_info(self, **kwargs):  # noqa: E501
          """Get provenances  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.search_provenance_with_http_info(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str authorization: Authentication token (required)
          :param str name: Regex pattern for filtering by name
          :param str description: Search by description
          :param str activity: Search by activity URI
          :param str activity_type: Search by activity type
          :param str agent: Search by agent URI
          :param str agent_type: Search by agent type
          :param list[str] order_by: List of fields to sort as an array of fieldName=asc|desc
          :param int page: Page number
          :param int page_size: Page size
          :param str accept_language: Request accepted language
          :return: list[ProvenanceGetDTO]
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['name', 'description', 'activity', 'activity_type', 'agent', 'agent_type', 'order_by', 'page', 'page_size', ]  # noqa: E501
          all_params.append('async_req')
          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 search_provenance" % key
                  )
              params[key] = val
          del params['kwargs']
  
          if 'page' in params and params['page'] < 0:  # noqa: E501
              raise ValueError("Invalid value for parameter `page` when calling `search_provenance`, must be a value greater than or equal to `0`")  # noqa: E501
          if 'page_size' in params and params['page_size'] < 0:  # noqa: E501
              raise ValueError("Invalid value for parameter `page_size` when calling `search_provenance`, must be a value greater than or equal to `0`")  # noqa: E501
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'name' in params:
              query_params.append(('name', params['name']))  # noqa: E501
          if 'description' in params:
              query_params.append(('description', params['description']))  # noqa: E501
          if 'activity' in params:
              query_params.append(('activity', params['activity']))  # noqa: E501
          if 'activity_type' in params:
              query_params.append(('activity_type', params['activity_type']))  # noqa: E501
          if 'agent' in params:
              query_params.append(('agent', params['agent']))  # noqa: E501
          if 'agent_type' in params:
              query_params.append(('agent_type', params['agent_type']))  # noqa: E501
          if 'order_by' in params:
              query_params.append(('order_by', params['order_by']))  # noqa: E501
              collection_formats['order_by'] = 'multi'  # noqa: E501
          if 'page' in params:
              query_params.append(('page', params['page']))  # noqa: E501
          if 'page_size' in params:
              query_params.append(('page_size', params['page_size']))  # noqa: E501
  
          header_params = {}
          #if 'authorization' in params:
          #    header_params['Authorization'] = params['authorization']  # noqa: E501
          #if 'accept_language' in params:
          #    header_params['Accept-Language'] = params['accept_language']  # noqa: E501
  
          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 = []  # noqa: E501
  
          return self.api_client.call_api(
              '/core/provenances', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='list[ProvenanceGetDTO]',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _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(self, **kwargs):  # noqa: E501
          """Update data  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.update(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str authorization: Authentication token (required)
          :param DataUpdateDTO body: Data description
          :param str accept_language: Request accepted language
          :return: ObjectUriResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.update_with_http_info(**kwargs)  # noqa: E501
          else:
              (data) = self.update_with_http_info(**kwargs)  # noqa: E501
              return data
  
      def update_with_http_info(self, **kwargs):  # noqa: E501
          """Update data  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.update_with_http_info(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str authorization: Authentication token (required)
          :param DataUpdateDTO body: Data description
          :param str accept_language: Request accepted language
          :return: ObjectUriResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['body', ]  # noqa: E501
          all_params.append('async_req')
          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" % key
                  )
              params[key] = val
          del params['kwargs']
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          header_params = {}
          #if 'authorization' in params:
          #    header_params['Authorization'] = params['authorization']  # noqa: E501
          #if 'accept_language' in params:
          #    header_params['Accept-Language'] = params['accept_language']  # noqa: E501
  
          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 = []  # noqa: E501
  
          return self.api_client.call_api(
              '/core/data', 'PUT',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='ObjectUriResponse',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _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_confidence(self, uri, **kwargs):  # noqa: E501
          """Update confidence index  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.update_confidence(uri, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str uri: Data URI (required)
          :param str authorization: Authentication token (required)
          :param DataConfidenceDTO body: Data description
          :param str accept_language: Request accepted language
          :return: ObjectUriResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.update_confidence_with_http_info(uri, **kwargs)  # noqa: E501
          else:
              (data) = self.update_confidence_with_http_info(uri, **kwargs)  # noqa: E501
              return data
  
      def update_confidence_with_http_info(self, uri, **kwargs):  # noqa: E501
          """Update confidence index  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.update_confidence_with_http_info(uri, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str uri: Data URI (required)
          :param str authorization: Authentication token (required)
          :param DataConfidenceDTO body: Data description
          :param str accept_language: Request accepted language
          :return: ObjectUriResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['uri', 'body', ]  # noqa: E501
          all_params.append('async_req')
          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_confidence" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'uri' is set
          if ('uri' not in params or
                  params['uri'] is None):
              raise ValueError("Missing the required parameter `uri` when calling `update_confidence`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'uri' in params:
              path_params['uri'] = params['uri']  # noqa: E501
  
          query_params = []
  
          header_params = {}
          #if 'authorization' in params:
          #    header_params['Authorization'] = params['authorization']  # noqa: E501
          #if 'accept_language' in params:
          #    header_params['Accept-Language'] = params['accept_language']  # noqa: E501
  
          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 = []  # noqa: E501
  
          return self.api_client.call_api(
              '/core/data/{uri}/confidence', 'PUT',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='ObjectUriResponse',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _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_provenance(self, **kwargs):  # noqa: E501
          """Update a provenance  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.update_provenance(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str authorization: Authentication token (required)
          :param ProvenanceUpdateDTO body: Provenance description
          :param str accept_language: Request accepted language
          :return: ObjectUriResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.update_provenance_with_http_info(**kwargs)  # noqa: E501
          else:
              (data) = self.update_provenance_with_http_info(**kwargs)  # noqa: E501
              return data
  
      def update_provenance_with_http_info(self, **kwargs):  # noqa: E501
          """Update a provenance  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.update_provenance_with_http_info(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str authorization: Authentication token (required)
          :param ProvenanceUpdateDTO body: Provenance description
          :param str accept_language: Request accepted language
          :return: ObjectUriResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['body', ]  # noqa: E501
          all_params.append('async_req')
          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_provenance" % key
                  )
              params[key] = val
          del params['kwargs']
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          header_params = {}
          #if 'authorization' in params:
          #    header_params['Authorization'] = params['authorization']  # noqa: E501
          #if 'accept_language' in params:
          #    header_params['Accept-Language'] = params['accept_language']  # noqa: E501
  
          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 = []  # noqa: E501
  
          return self.api_client.call_api(
              '/core/provenances', 'PUT',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='ObjectUriResponse',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _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 validate_csv(self, provenance, file, **kwargs):  # noqa: E501
          """Import a CSV file for the given provenanceURI.  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.validate_csv(provenance, file, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str provenance: Provenance URI (required)
          :param file file: File (required)
          :param str authorization: Authentication token (required)
          :param str accept_language: Request accepted language
          :return: DataCSVValidationDTO
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.validate_csv_with_http_info(provenance, file, **kwargs)  # noqa: E501
          else:
              (data) = self.validate_csv_with_http_info(provenance, file, **kwargs)  # noqa: E501
              return data
  
      def validate_csv_with_http_info(self, provenance, file, **kwargs):  # noqa: E501
          """Import a CSV file for the given provenanceURI.  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.validate_csv_with_http_info(provenance, file, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str provenance: Provenance URI (required)
          :param file file: File (required)
          :param str authorization: Authentication token (required)
          :param str accept_language: Request accepted language
          :return: DataCSVValidationDTO
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['provenance', 'file', ]  # noqa: E501
          all_params.append('async_req')
          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 validate_csv" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'provenance' is set
          if ('provenance' not in params or
                  params['provenance'] is None):
              raise ValueError("Missing the required parameter `provenance` when calling `validate_csv`")  # 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 `validate_csv`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'provenance' in params:
              query_params.append(('provenance', params['provenance']))  # noqa: E501
  
          header_params = {}
          #if 'authorization' in params:
          #    header_params['Authorization'] = params['authorization']  # noqa: E501
          #if 'accept_language' in params:
          #    header_params['Accept-Language'] = params['accept_language']  # noqa: E501
  
          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 = []  # noqa: E501
  
          return self.api_client.call_api(
              '/core/data/import_validation', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='DataCSVValidationDTO',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _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)
  