text: # coding: utf-8
  
  """
      Memsource REST API
  
      Welcome to Memsource's API documentation. To view our legacy APIs please [visit our documentation](https://wiki.memsource.com/wiki/Memsource_API) and for more information about our new APIs, [visit our blog](https://www.memsource.com/blog/2017/10/24/introducing-rest-apis-qa-with-the-memsource-api-team/).    If you have any questions, please contact [Memsource Support](<mailto:support@memsource.com>).  # noqa: E501
  
      OpenAPI spec version: Latest
      
      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 memsource_cli.api_client import ApiClient
  
  
  class JobApi(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 compare_part(self, project_uid, **kwargs):  # noqa: E501
          """Compare jobs on workflow levels  # 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.compare_part(project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param JobPartReadyReferences body:
          :param int at_workflow_level:
          :param int with_workflow_level:
          :return: ComparedSegmentsDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.compare_part_with_http_info(project_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.compare_part_with_http_info(project_uid, **kwargs)  # noqa: E501
              return data
  
      def compare_part_with_http_info(self, project_uid, **kwargs):  # noqa: E501
          """Compare jobs on workflow levels  # 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.compare_part_with_http_info(project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param JobPartReadyReferences body:
          :param int at_workflow_level:
          :param int with_workflow_level:
          :return: ComparedSegmentsDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', 'body', 'at_workflow_level', 'with_workflow_level']  # 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 compare_part" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `compare_part`")  # noqa: E501
  
          if 'at_workflow_level' in params and params['at_workflow_level'] > 15:  # noqa: E501
              raise ValueError("Invalid value for parameter `at_workflow_level` when calling `compare_part`, must be a value less than or equal to `15`")  # noqa: E501
          if 'at_workflow_level' in params and params['at_workflow_level'] < 1:  # noqa: E501
              raise ValueError("Invalid value for parameter `at_workflow_level` when calling `compare_part`, must be a value greater than or equal to `1`")  # noqa: E501
          if 'with_workflow_level' in params and params['with_workflow_level'] > 15:  # noqa: E501
              raise ValueError("Invalid value for parameter `with_workflow_level` when calling `compare_part`, must be a value less than or equal to `15`")  # noqa: E501
          if 'with_workflow_level' in params and params['with_workflow_level'] < 1:  # noqa: E501
              raise ValueError("Invalid value for parameter `with_workflow_level` when calling `compare_part`, must be a value greater than or equal to `1`")  # noqa: E501
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
  
          query_params = []
          if 'at_workflow_level' in params:
              query_params.append(('atWorkflowLevel', params['at_workflow_level']))  # noqa: E501
          if 'with_workflow_level' in params:
              query_params.append(('withWorkflowLevel', params['with_workflow_level']))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'body' in params:
              body_params = params['body']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/json'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v1/projects/{projectUid}/jobs/compare', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='ComparedSegmentsDto',  # 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 completed_file(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Download target file  # noqa: E501
  
          This call will return target file with translation. This means even for other jobs that were created via 'split jobs' etc.  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.completed_file(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :param str format:
          :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.completed_file_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.completed_file_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
              return data
  
      def completed_file_with_http_info(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Download target file  # noqa: E501
  
          This call will return target file with translation. This means even for other jobs that were created via 'split jobs' etc.  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.completed_file_with_http_info(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :param str format:
          :return: None
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', 'job_uid', 'format']  # 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 completed_file" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `completed_file`")  # noqa: E501
          # verify the required parameter 'job_uid' is set
          if ('job_uid' not in params or
                  params['job_uid'] is None):
              raise ValueError("Missing the required parameter `job_uid` when calling `completed_file`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
          if 'job_uid' in params:
              path_params['jobUid'] = params['job_uid']  # noqa: E501
  
          query_params = []
          if 'format' in params:
              query_params.append(('format', params['format']))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/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(
              '/api2/v1/projects/{projectUid}/jobs/{jobUid}/targetFile', '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 create_job(self, project_uid, **kwargs):  # noqa: E501
          """Create job  # noqa: E501
  
           Job file can be provided directly in the message body or downloaded from connector.   Please supply job metadata in `Memsource` header.   For file in the request body provide also the filename in `Content-Disposition` header.  Accepted metadata:     - `targetLangs` - **required**   - `due` - ISO 8601   - `workflowSettings` - project with workflow - see examples bellow   - `assignments` - project without workflows - see examples bellow   - `importSettings` - re-usable import settings - see [Create import settings](#operation/createImportSettings)   - `useProjectFileImportSettings` - mutually exclusive with importSettings   - `callbackUrl` - consumer callback   - `path` - original destination directory      for remote file jobs also `remoteFile` - see examples bellow:   - `connectorToken` - remote connector token   - `remoteFolder`    - `remoteFileName`   - `continuous` - true for continuous job  Create and assign job in project without workflow step: ```  {   \"targetLangs\": [     \"cs_cz\"   ],   \"callbackUrl\": \"https://my-shiny-service.com/consumeCallback\",   \"importSettings\": {     \"uid\": \"abcd123\"   },   \"due\": \"2007-12-03T10:15:30.00Z\",   \"path\": \"destination directory\",   \"assignments\": [     {       \"targetLang\": \"cs_cz\",       \"providers\": [         {           \"id\": \"4321\",           \"type\": \"USER\"         }       ]     }   ],   \"notifyProvider\": {     \"organizationEmailTemplate\": {       \"id\": \"39\"     },     \"notificationIntervalInMinutes\": \"10\"   } } ```  Create job from remote file without workflow steps: ```  {   \"remoteFile\": {     \"connectorToken\": \"948123ef-e1ef-4cd3-a90e-af1617848af3\",     \"remoteFolder\": \"/\",     \"remoteFileName\": \"Few words.docx\",     \"continuous\": false   },   \"assignments\": [],   \"workflowSettings\": [],   \"targetLangs\": [     \"cs\"   ] } ```  Create and assign job in project with workflow step: ```  {   \"targetLangs\": [     \"de\"   ],   \"useProjectFileImportSettings\": \"true\",   \"workflowSettings\": [     {       \"id\": \"64\",       \"due\": \"2007-12-03T10:15:30.00Z\",       \"assignments\": [         {           \"targetLang\": \"de\",           \"providers\": [             {               \"id\": \"3\",               \"type\": \"VENDOR\"             }           ]         }       ],       \"notifyProvider\": {         \"organizationEmailTemplate\": {           \"id\": \"39\"         },         \"notificationIntervalInMinutes\": \"10\"       }     }   ] } ```       # 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_job(project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str memsource:
          :param str content_disposition: must match pattern `filename\\*=UTF-8''(.+)|filename=\"?(.+)\"?`
          :param InputStream body:
          :return: JobListDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.create_job_with_http_info(project_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.create_job_with_http_info(project_uid, **kwargs)  # noqa: E501
              return data
  
      def create_job_with_http_info(self, project_uid, **kwargs):  # noqa: E501
          """Create job  # noqa: E501
  
           Job file can be provided directly in the message body or downloaded from connector.   Please supply job metadata in `Memsource` header.   For file in the request body provide also the filename in `Content-Disposition` header.  Accepted metadata:     - `targetLangs` - **required**   - `due` - ISO 8601   - `workflowSettings` - project with workflow - see examples bellow   - `assignments` - project without workflows - see examples bellow   - `importSettings` - re-usable import settings - see [Create import settings](#operation/createImportSettings)   - `useProjectFileImportSettings` - mutually exclusive with importSettings   - `callbackUrl` - consumer callback   - `path` - original destination directory      for remote file jobs also `remoteFile` - see examples bellow:   - `connectorToken` - remote connector token   - `remoteFolder`    - `remoteFileName`   - `continuous` - true for continuous job  Create and assign job in project without workflow step: ```  {   \"targetLangs\": [     \"cs_cz\"   ],   \"callbackUrl\": \"https://my-shiny-service.com/consumeCallback\",   \"importSettings\": {     \"uid\": \"abcd123\"   },   \"due\": \"2007-12-03T10:15:30.00Z\",   \"path\": \"destination directory\",   \"assignments\": [     {       \"targetLang\": \"cs_cz\",       \"providers\": [         {           \"id\": \"4321\",           \"type\": \"USER\"         }       ]     }   ],   \"notifyProvider\": {     \"organizationEmailTemplate\": {       \"id\": \"39\"     },     \"notificationIntervalInMinutes\": \"10\"   } } ```  Create job from remote file without workflow steps: ```  {   \"remoteFile\": {     \"connectorToken\": \"948123ef-e1ef-4cd3-a90e-af1617848af3\",     \"remoteFolder\": \"/\",     \"remoteFileName\": \"Few words.docx\",     \"continuous\": false   },   \"assignments\": [],   \"workflowSettings\": [],   \"targetLangs\": [     \"cs\"   ] } ```  Create and assign job in project with workflow step: ```  {   \"targetLangs\": [     \"de\"   ],   \"useProjectFileImportSettings\": \"true\",   \"workflowSettings\": [     {       \"id\": \"64\",       \"due\": \"2007-12-03T10:15:30.00Z\",       \"assignments\": [         {           \"targetLang\": \"de\",           \"providers\": [             {               \"id\": \"3\",               \"type\": \"VENDOR\"             }           ]         }       ],       \"notifyProvider\": {         \"organizationEmailTemplate\": {           \"id\": \"39\"         },         \"notificationIntervalInMinutes\": \"10\"       }     }   ] } ```       # 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_job_with_http_info(project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str memsource:
          :param str content_disposition: must match pattern `filename\\*=UTF-8''(.+)|filename=\"?(.+)\"?`
          :param InputStream body:
          :return: JobListDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', 'memsource', 'content_disposition', 'body', 'token']  # 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_job" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `create_job`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
  
          query_params = []
          if 'token' in params:
              query_params.append(('token', params['token']))  # noqa: E501
  
          header_params = {}
          if 'memsource' in params:
              header_params['Memsource'] = params['memsource']  # noqa: E501
          if 'content_disposition' in params:
              header_params['Content-Disposition'] = params['content_disposition']  # 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/octet-stream'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v1/projects/{projectUid}/jobs', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='JobListDto',  # 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_term_by_job(self, job_uid, project_uid, **kwargs):  # noqa: E501
          """Create term in job's term bases  # noqa: E501
  
          Create new term in the write term base assigned to the job  # 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_term_by_job(job_uid, project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str job_uid: (required)
          :param str project_uid: (required)
          :param CreateTermsDto body:
          :return: TermPairDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.create_term_by_job_with_http_info(job_uid, project_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.create_term_by_job_with_http_info(job_uid, project_uid, **kwargs)  # noqa: E501
              return data
  
      def create_term_by_job_with_http_info(self, job_uid, project_uid, **kwargs):  # noqa: E501
          """Create term in job's term bases  # noqa: E501
  
          Create new term in the write term base assigned to the job  # 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_term_by_job_with_http_info(job_uid, project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str job_uid: (required)
          :param str project_uid: (required)
          :param CreateTermsDto body:
          :return: TermPairDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['job_uid', 'project_uid', '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_term_by_job" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'job_uid' is set
          if ('job_uid' not in params or
                  params['job_uid'] is None):
              raise ValueError("Missing the required parameter `job_uid` when calling `create_term_by_job`")  # noqa: E501
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `create_term_by_job`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'job_uid' in params:
              path_params['jobUid'] = params['job_uid']  # noqa: E501
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'body' in params:
              body_params = params['body']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/json'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v1/projects/{projectUid}/jobs/{jobUid}/termBases/createByJob', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='TermPairDto',  # 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_all_translations(self, project_uid, **kwargs):  # noqa: E501
          """Delete all translations  # 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_all_translations(project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param JobPartReadyReferences body:
          :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.delete_all_translations_with_http_info(project_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.delete_all_translations_with_http_info(project_uid, **kwargs)  # noqa: E501
              return data
  
      def delete_all_translations_with_http_info(self, project_uid, **kwargs):  # noqa: E501
          """Delete all translations  # 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_all_translations_with_http_info(project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param JobPartReadyReferences body:
          :return: None
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', '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 delete_all_translations" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `delete_all_translations`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'body' in params:
              body_params = params['body']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/json'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v1/projects/{projectUid}/jobs/translations', 'DELETE',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type=None,  # noqa: E501
              auth_settings=auth_settings,
              async_req=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_parts(self, project_uid, **kwargs):  # noqa: E501
          """Delete job (batch)  # 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_parts(project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param JobPartReferences body:
          :param bool purge:
          :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.delete_parts_with_http_info(project_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.delete_parts_with_http_info(project_uid, **kwargs)  # noqa: E501
              return data
  
      def delete_parts_with_http_info(self, project_uid, **kwargs):  # noqa: E501
          """Delete job (batch)  # 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_parts_with_http_info(project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param JobPartReferences body:
          :param bool purge:
          :return: None
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', 'body', 'purge', 'token']  # 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_parts" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `delete_parts`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
  
          query_params = []
          if 'purge' in params:
              query_params.append(('purge', params['purge']))  # noqa: E501
          if 'token' in params:
              query_params.append(('token', params['token']))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'body' in params:
              body_params = params['body']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/json'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v1/projects/{projectUid}/jobs/batch', 'DELETE',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type=None,  # noqa: E501
              auth_settings=auth_settings,
              async_req=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 edit_part(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Edit job  # 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.edit_part(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :param JobPartUpdateSingleDto body:
          :return: JobPartExtendedDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.edit_part_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.edit_part_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
              return data
  
      def edit_part_with_http_info(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Edit job  # 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.edit_part_with_http_info(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :param JobPartUpdateSingleDto body:
          :return: JobPartExtendedDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', 'job_uid', '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 edit_part" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `edit_part`")  # noqa: E501
          # verify the required parameter 'job_uid' is set
          if ('job_uid' not in params or
                  params['job_uid'] is None):
              raise ValueError("Missing the required parameter `job_uid` when calling `edit_part`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
          if 'job_uid' in params:
              path_params['jobUid'] = params['job_uid']  # noqa: E501
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'body' in params:
              body_params = params['body']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/json'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v1/projects/{projectUid}/jobs/{jobUid}', 'PUT',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='JobPartExtendedDto',  # 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 edit_parts(self, project_uid, **kwargs):  # noqa: E501
          """Edit jobs (batch)  # noqa: E501
  
           Returns only jobs which were updated by the batch operation.   # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.edit_parts(project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param JobPartUpdateBatchDto body:
          :return: JobPartsDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.edit_parts_with_http_info(project_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.edit_parts_with_http_info(project_uid, **kwargs)  # noqa: E501
              return data
  
      def edit_parts_with_http_info(self, project_uid, **kwargs):  # noqa: E501
          """Edit jobs (batch)  # noqa: E501
  
           Returns only jobs which were updated by the batch operation.   # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.edit_parts_with_http_info(project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param JobPartUpdateBatchDto body:
          :return: JobPartsDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', '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 edit_parts" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `edit_parts`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'body' in params:
              body_params = params['body']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/json'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v1/projects/{projectUid}/jobs/batch', 'PUT',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='JobPartsDto',  # 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 file_preview(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Download preview file  # noqa: E501
  
          Takes bilingual file (.mxliff only) as argument. If not passed, data will be taken from database  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.file_preview(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :param InputStream body:
          :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.file_preview_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.file_preview_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
              return data
  
      def file_preview_with_http_info(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Download preview file  # noqa: E501
  
          Takes bilingual file (.mxliff only) as argument. If not passed, data will be taken from database  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.file_preview_with_http_info(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :param InputStream body:
          :return: None
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', 'job_uid', '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 file_preview" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `file_preview`")  # noqa: E501
          # verify the required parameter 'job_uid' is set
          if ('job_uid' not in params or
                  params['job_uid'] is None):
              raise ValueError("Missing the required parameter `job_uid` when calling `file_preview`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
          if 'job_uid' in params:
              path_params['jobUid'] = params['job_uid']  # noqa: E501
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'body' in params:
              body_params = params['body']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/octet-stream'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/octet-stream'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v1/projects/{projectUid}/jobs/{jobUid}/preview', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type=None,  # noqa: E501
              auth_settings=auth_settings,
              async_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 file_preview_job(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Download preview 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.file_preview_job(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :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.file_preview_job_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.file_preview_job_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
              return data
  
      def file_preview_job_with_http_info(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Download preview 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.file_preview_job_with_http_info(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :return: None
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', 'job_uid']  # 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 file_preview_job" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `file_preview_job`")  # noqa: E501
          # verify the required parameter 'job_uid' is set
          if ('job_uid' not in params or
                  params['job_uid'] is None):
              raise ValueError("Missing the required parameter `job_uid` when calling `file_preview_job`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
          if 'job_uid' in params:
              path_params['jobUid'] = params['job_uid']  # noqa: E501
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/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(
              '/api2/v1/projects/{projectUid}/jobs/{jobUid}/preview', '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_bilingual_file(self, project_uid, **kwargs):  # noqa: E501
          """Download bilingual 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_bilingual_file(project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param JobPartReadyReferences body:
          :param str format:
          :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_bilingual_file_with_http_info(project_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.get_bilingual_file_with_http_info(project_uid, **kwargs)  # noqa: E501
              return data
  
      def get_bilingual_file_with_http_info(self, project_uid, **kwargs):  # noqa: E501
          """Download bilingual 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_bilingual_file_with_http_info(project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param JobPartReadyReferences body:
          :param str format:
          :return: None
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', 'body', 'format']  # 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_bilingual_file" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `get_bilingual_file`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
  
          query_params = []
          if 'format' in params:
              query_params.append(('format', params['format']))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'body' in params:
              body_params = params['body']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/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(
              '/api2/v1/projects/{projectUid}/jobs/bilingualFile', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type=None,  # noqa: E501
              auth_settings=auth_settings,
              async_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_completed_file_warnings(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Get target file's warnings  # noqa: E501
  
           This call will return target file's warnings. This means even for other jobs that were created via 'split jobs' etc.   # 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_completed_file_warnings(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :return: TargetFileWarningsDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.get_completed_file_warnings_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.get_completed_file_warnings_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
              return data
  
      def get_completed_file_warnings_with_http_info(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Get target file's warnings  # noqa: E501
  
           This call will return target file's warnings. This means even for other jobs that were created via 'split jobs' etc.   # 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_completed_file_warnings_with_http_info(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :return: TargetFileWarningsDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', 'job_uid']  # 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_completed_file_warnings" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `get_completed_file_warnings`")  # noqa: E501
          # verify the required parameter 'job_uid' is set
          if ('job_uid' not in params or
                  params['job_uid'] is None):
              raise ValueError("Missing the required parameter `job_uid` when calling `get_completed_file_warnings`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
          if 'job_uid' in params:
              path_params['jobUid'] = params['job_uid']  # noqa: E501
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/json'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v1/projects/{projectUid}/jobs/{jobUid}/targetFileWarnings', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='TargetFileWarningsDto',  # 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_original_file(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Download original 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_original_file(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :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_original_file_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.get_original_file_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
              return data
  
      def get_original_file_with_http_info(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Download original 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_original_file_with_http_info(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :return: None
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', 'job_uid']  # 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_original_file" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `get_original_file`")  # noqa: E501
          # verify the required parameter 'job_uid' is set
          if ('job_uid' not in params or
                  params['job_uid'] is None):
              raise ValueError("Missing the required parameter `job_uid` when calling `get_original_file`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
          if 'job_uid' in params:
              path_params['jobUid'] = params['job_uid']  # noqa: E501
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/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(
              '/api2/v1/projects/{projectUid}/jobs/{jobUid}/original', '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_part(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Get job  # 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_part(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :return: JobPartExtendedDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.get_part_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.get_part_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
              return data
  
      def get_part_with_http_info(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Get job  # 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_part_with_http_info(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :return: JobPartExtendedDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', 'job_uid', 'token']  # 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_part" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `get_part`")  # noqa: E501
          # verify the required parameter 'job_uid' is set
          if ('job_uid' not in params or
                  params['job_uid'] is None):
              raise ValueError("Missing the required parameter `job_uid` when calling `get_part`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
          if 'job_uid' in params:
              path_params['jobUid'] = params['job_uid']  # noqa: E501
  
          query_params = []
          if 'token' in params:
              query_params.append(('token', params['token']))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # 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(
              '/api2/v1/projects/{projectUid}/jobs/{jobUid}', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='JobPartExtendedDto',  # 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_parts_workflow_step(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Get job's workflowStep  # 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_parts_workflow_step(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :return: ProjectWorkflowStepDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.get_parts_workflow_step_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.get_parts_workflow_step_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
              return data
  
      def get_parts_workflow_step_with_http_info(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Get job's workflowStep  # 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_parts_workflow_step_with_http_info(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :return: ProjectWorkflowStepDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', 'job_uid']  # 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_parts_workflow_step" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `get_parts_workflow_step`")  # noqa: E501
          # verify the required parameter 'job_uid' is set
          if ('job_uid' not in params or
                  params['job_uid'] is None):
              raise ValueError("Missing the required parameter `job_uid` when calling `get_parts_workflow_step`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
          if 'job_uid' in params:
              path_params['jobUid'] = params['job_uid']  # noqa: E501
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/json'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v1/projects/{projectUid}/jobs/{jobUid}/workflowStep', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='ProjectWorkflowStepDto',  # 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_segments_count(self, project_uid, **kwargs):  # noqa: E501
          """Get segments count  # noqa: E501
  
          Provides segments count (progress data)  # 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_segments_count(project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param JobPartReadyReferences body:
          :return: SegmentsCountsResponseListDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.get_segments_count_with_http_info(project_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.get_segments_count_with_http_info(project_uid, **kwargs)  # noqa: E501
              return data
  
      def get_segments_count_with_http_info(self, project_uid, **kwargs):  # noqa: E501
          """Get segments count  # noqa: E501
  
          Provides segments count (progress data)  # 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_segments_count_with_http_info(project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param JobPartReadyReferences body:
          :return: SegmentsCountsResponseListDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', '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 get_segments_count" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `get_segments_count`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'body' in params:
              body_params = params['body']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/json'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v1/projects/{projectUid}/jobs/segmentsCount', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='SegmentsCountsResponseListDto',  # 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_translation_resources(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Get translation resources  # 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_translation_resources(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :return: TranslationResourcesDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.get_translation_resources_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.get_translation_resources_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
              return data
  
      def get_translation_resources_with_http_info(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Get translation resources  # 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_translation_resources_with_http_info(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :return: TranslationResourcesDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', 'job_uid']  # 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_translation_resources" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `get_translation_resources`")  # noqa: E501
          # verify the required parameter 'job_uid' is set
          if ('job_uid' not in params or
                  params['job_uid'] is None):
              raise ValueError("Missing the required parameter `job_uid` when calling `get_translation_resources`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
          if 'job_uid' in params:
              path_params['jobUid'] = params['job_uid']  # noqa: E501
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/json'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v1/projects/{projectUid}/jobs/{jobUid}/translationResources', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='TranslationResourcesDto',  # 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 list_part_analyse1(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """List analyses  # 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.list_part_analyse1(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :param int page_number:
          :param int page_size:
          :return: PageDtoAnalyseV2Dto
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.list_part_analyse1_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.list_part_analyse1_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
              return data
  
      def list_part_analyse1_with_http_info(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """List analyses  # 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.list_part_analyse1_with_http_info(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :param int page_number:
          :param int page_size:
          :return: PageDtoAnalyseV2Dto
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', 'job_uid', 'page_number', '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 list_part_analyse1" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `list_part_analyse1`")  # noqa: E501
          # verify the required parameter 'job_uid' is set
          if ('job_uid' not in params or
                  params['job_uid'] is None):
              raise ValueError("Missing the required parameter `job_uid` when calling `list_part_analyse1`")  # noqa: E501
  
          if 'page_number' in params and params['page_number'] < 0:  # noqa: E501
              raise ValueError("Invalid value for parameter `page_number` when calling `list_part_analyse1`, must be a value greater than or equal to `0`")  # noqa: E501
          if 'page_size' in params and params['page_size'] > 50:  # noqa: E501
              raise ValueError("Invalid value for parameter `page_size` when calling `list_part_analyse1`, must be a value less than or equal to `50`")  # noqa: E501
          if 'page_size' in params and params['page_size'] < 1:  # noqa: E501
              raise ValueError("Invalid value for parameter `page_size` when calling `list_part_analyse1`, must be a value greater than or equal to `1`")  # noqa: E501
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
          if 'job_uid' in params:
              path_params['jobUid'] = params['job_uid']  # noqa: E501
  
          query_params = []
          if 'page_number' in params:
              query_params.append(('pageNumber', params['page_number']))  # noqa: E501
          if 'page_size' in params:
              query_params.append(('pageSize', params['page_size']))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v2/projects/{projectUid}/jobs/{jobUid}/analyses', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='PageDtoAnalyseV2Dto',  # 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 list_parts_v2(self, project_uid, **kwargs):  # noqa: E501
          """List jobs  # 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.list_parts_v2(project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param int page_number:
          :param int page_size:
          :param bool count:
          :param int workflow_level:
          :param list[str] status:
          :param int assigned_user:
          :param int due_in_hours:
          :param str filename:
          :param str target_lang:
          :param int assigned_vendor:
          :return: PageDtoJobPartReferenceV2
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.list_parts_v2_with_http_info(project_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.list_parts_v2_with_http_info(project_uid, **kwargs)  # noqa: E501
              return data
  
      def list_parts_v2_with_http_info(self, project_uid, **kwargs):  # noqa: E501
          """List jobs  # 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.list_parts_v2_with_http_info(project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param int page_number:
          :param int page_size:
          :param bool count:
          :param int workflow_level:
          :param list[str] status:
          :param int assigned_user:
          :param int due_in_hours:
          :param str filename:
          :param str target_lang:
          :param int assigned_vendor:
          :return: PageDtoJobPartReferenceV2
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', 'page_number', 'page_size', 'count', 'workflow_level', 'status', 'assigned_user', 'due_in_hours', 'filename', 'target_lang', 'assigned_vendor', 'token']  # 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 list_parts_v2" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `list_parts_v2`")  # noqa: E501
  
          if 'page_number' in params and params['page_number'] < 0:  # noqa: E501
              raise ValueError("Invalid value for parameter `page_number` when calling `list_parts_v2`, must be a value greater than or equal to `0`")  # noqa: E501
          if 'page_size' in params and params['page_size'] > 50:  # noqa: E501
              raise ValueError("Invalid value for parameter `page_size` when calling `list_parts_v2`, must be a value less than or equal to `50`")  # noqa: E501
          if 'page_size' in params and params['page_size'] < 1:  # noqa: E501
              raise ValueError("Invalid value for parameter `page_size` when calling `list_parts_v2`, must be a value greater than or equal to `1`")  # noqa: E501
          if 'workflow_level' in params and params['workflow_level'] > 15:  # noqa: E501
              raise ValueError("Invalid value for parameter `workflow_level` when calling `list_parts_v2`, must be a value less than or equal to `15`")  # noqa: E501
          if 'workflow_level' in params and params['workflow_level'] < 1:  # noqa: E501
              raise ValueError("Invalid value for parameter `workflow_level` when calling `list_parts_v2`, must be a value greater than or equal to `1`")  # noqa: E501
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
  
          query_params = []
          if 'page_number' in params:
              query_params.append(('pageNumber', params['page_number']))  # noqa: E501
          if 'page_size' in params:
              query_params.append(('pageSize', params['page_size']))  # noqa: E501
          if 'count' in params:
              query_params.append(('count', params['count']))  # noqa: E501
          if 'workflow_level' in params:
              query_params.append(('workflowLevel', params['workflow_level']))  # noqa: E501
          if 'status' in params:
              query_params.append(('status', params['status']))  # noqa: E501
              collection_formats['status'] = 'multi'  # noqa: E501
          if 'assigned_user' in params:
              query_params.append(('assignedUser', params['assigned_user']))  # noqa: E501
          if 'due_in_hours' in params:
              query_params.append(('dueInHours', params['due_in_hours']))  # noqa: E501
          if 'filename' in params:
              query_params.append(('filename', params['filename']))  # noqa: E501
          if 'target_lang' in params:
              query_params.append(('targetLang', params['target_lang']))  # noqa: E501
          if 'assigned_vendor' in params:
              query_params.append(('assignedVendor', params['assigned_vendor']))  # noqa: E501
          if 'token' in params:
              query_params.append(('token', params['token']))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v2/projects/{projectUid}/jobs', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='PageDtoJobPartReferenceV2',  # 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 list_providers1(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Get suggested providers  # 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.list_providers1(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :return: ProviderListDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.list_providers1_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.list_providers1_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
              return data
  
      def list_providers1_with_http_info(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Get suggested providers  # 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.list_providers1_with_http_info(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :return: ProviderListDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', 'job_uid']  # 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 list_providers1" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `list_providers1`")  # noqa: E501
          # verify the required parameter 'job_uid' is set
          if ('job_uid' not in params or
                  params['job_uid'] is None):
              raise ValueError("Missing the required parameter `job_uid` when calling `list_providers1`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
          if 'job_uid' in params:
              path_params['jobUid'] = params['job_uid']  # noqa: E501
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/json'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v1/projects/{projectUid}/jobs/{jobUid}/providers/suggest', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='ProviderListDto',  # 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 list_segments(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Get segments  # 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.list_segments(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :param int begin_index:
          :param int end_index:
          :return: SegmentListDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.list_segments_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.list_segments_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
              return data
  
      def list_segments_with_http_info(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Get segments  # 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.list_segments_with_http_info(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :param int begin_index:
          :param int end_index:
          :return: SegmentListDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', 'job_uid', 'begin_index', 'end_index']  # 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 list_segments" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `list_segments`")  # noqa: E501
          # verify the required parameter 'job_uid' is set
          if ('job_uid' not in params or
                  params['job_uid'] is None):
              raise ValueError("Missing the required parameter `job_uid` when calling `list_segments`")  # noqa: E501
  
          if 'begin_index' in params and params['begin_index'] < 0:  # noqa: E501
              raise ValueError("Invalid value for parameter `begin_index` when calling `list_segments`, must be a value greater than or equal to `0`")  # noqa: E501
          if 'end_index' in params and params['end_index'] < 0:  # noqa: E501
              raise ValueError("Invalid value for parameter `end_index` when calling `list_segments`, must be a value greater than or equal to `0`")  # noqa: E501
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
          if 'job_uid' in params:
              path_params['jobUid'] = params['job_uid']  # noqa: E501
  
          query_params = []
          if 'begin_index' in params:
              query_params.append(('beginIndex', params['begin_index']))  # noqa: E501
          if 'end_index' in params:
              query_params.append(('endIndex', params['end_index']))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # 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(
              '/api2/v1/projects/{projectUid}/jobs/{jobUid}/segments', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='SegmentListDto',  # 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 notify_assigned(self, project_uid, **kwargs):  # noqa: E501
          """Notify assigned users  # 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.notify_assigned(project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param NotifyJobPartsRequestDto body:
          :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.notify_assigned_with_http_info(project_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.notify_assigned_with_http_info(project_uid, **kwargs)  # noqa: E501
              return data
  
      def notify_assigned_with_http_info(self, project_uid, **kwargs):  # noqa: E501
          """Notify assigned users  # 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.notify_assigned_with_http_info(project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param NotifyJobPartsRequestDto body:
          :return: None
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', '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 notify_assigned" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `notify_assigned`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'body' in params:
              body_params = params['body']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/json'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v1/projects/{projectUid}/jobs/notifyAssigned', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type=None,  # noqa: E501
              auth_settings=auth_settings,
              async_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 preview_urls(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Get PDF preview  # 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.preview_urls(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :param int workflow_level:
          :return: PreviewUrlsDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.preview_urls_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.preview_urls_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
              return data
  
      def preview_urls_with_http_info(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Get PDF preview  # 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.preview_urls_with_http_info(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :param int workflow_level:
          :return: PreviewUrlsDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', 'job_uid', 'workflow_level']  # 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 preview_urls" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `preview_urls`")  # noqa: E501
          # verify the required parameter 'job_uid' is set
          if ('job_uid' not in params or
                  params['job_uid'] is None):
              raise ValueError("Missing the required parameter `job_uid` when calling `preview_urls`")  # noqa: E501
  
          if 'workflow_level' in params and params['workflow_level'] > 15:  # noqa: E501
              raise ValueError("Invalid value for parameter `workflow_level` when calling `preview_urls`, must be a value less than or equal to `15`")  # noqa: E501
          if 'workflow_level' in params and params['workflow_level'] < 1:  # noqa: E501
              raise ValueError("Invalid value for parameter `workflow_level` when calling `preview_urls`, must be a value greater than or equal to `1`")  # noqa: E501
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
          if 'job_uid' in params:
              path_params['jobUid'] = params['job_uid']  # noqa: E501
  
          query_params = []
          if 'workflow_level' in params:
              query_params.append(('workflowLevel', params['workflow_level']))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # 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(
              '/api2/v1/projects/{projectUid}/jobs/{jobUid}/previewUrl', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='PreviewUrlsDto',  # 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 pseudo_translate(self, project_uid, **kwargs):  # noqa: E501
          """Pseudo-translate job  # 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.pseudo_translate(project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param JobPartReadyReferences body:
          :param str replacement:
          :param str prefix:
          :param str suffix:
          :param float length:
          :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.pseudo_translate_with_http_info(project_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.pseudo_translate_with_http_info(project_uid, **kwargs)  # noqa: E501
              return data
  
      def pseudo_translate_with_http_info(self, project_uid, **kwargs):  # noqa: E501
          """Pseudo-translate job  # 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.pseudo_translate_with_http_info(project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param JobPartReadyReferences body:
          :param str replacement:
          :param str prefix:
          :param str suffix:
          :param float length:
          :return: None
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', 'body', 'replacement', 'prefix', 'suffix', 'length']  # 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 pseudo_translate" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `pseudo_translate`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
  
          query_params = []
          if 'replacement' in params:
              query_params.append(('replacement', params['replacement']))  # noqa: E501
          if 'prefix' in params:
              query_params.append(('prefix', params['prefix']))  # noqa: E501
          if 'suffix' in params:
              query_params.append(('suffix', params['suffix']))  # noqa: E501
          if 'length' in params:
              query_params.append(('length', params['length']))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'body' in params:
              body_params = params['body']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['*/*'])  # 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(
              '/api2/v1/projects/{projectUid}/jobs/pseudoTranslate', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type=None,  # noqa: E501
              auth_settings=auth_settings,
              async_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 pseudo_translate_job_part(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Pseudo-translates job  # 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.pseudo_translate_job_part(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :param PseudoTranslateActionDto body:
          :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.pseudo_translate_job_part_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.pseudo_translate_job_part_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
              return data
  
      def pseudo_translate_job_part_with_http_info(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Pseudo-translates job  # 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.pseudo_translate_job_part_with_http_info(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :param PseudoTranslateActionDto body:
          :return: None
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', 'job_uid', '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 pseudo_translate_job_part" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `pseudo_translate_job_part`")  # noqa: E501
          # verify the required parameter 'job_uid' is set
          if ('job_uid' not in params or
                  params['job_uid'] is None):
              raise ValueError("Missing the required parameter `job_uid` when calling `pseudo_translate_job_part`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
          if 'job_uid' in params:
              path_params['jobUid'] = params['job_uid']  # noqa: E501
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'body' in params:
              body_params = params['body']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/json'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v1/projects/{projectUid}/jobs/{jobUid}/pseudoTranslate', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type=None,  # noqa: E501
              auth_settings=auth_settings,
              async_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_by_job3(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Search job's translation memories  # 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_by_job3(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :param SearchTMByJobRequestDtoV3 body:
          :return: SearchResponseListTmDtoV3
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.search_by_job3_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.search_by_job3_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
              return data
  
      def search_by_job3_with_http_info(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Search job's translation memories  # 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_by_job3_with_http_info(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :param SearchTMByJobRequestDtoV3 body:
          :return: SearchResponseListTmDtoV3
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', 'job_uid', '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 search_by_job3" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `search_by_job3`")  # noqa: E501
          # verify the required parameter 'job_uid' is set
          if ('job_uid' not in params or
                  params['job_uid'] is None):
              raise ValueError("Missing the required parameter `job_uid` when calling `search_by_job3`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
          if 'job_uid' in params:
              path_params['jobUid'] = params['job_uid']  # noqa: E501
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'body' in params:
              body_params = params['body']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v3/projects/{projectUid}/jobs/{jobUid}/transMemories/search', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='SearchResponseListTmDtoV3',  # 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_parts_in_project(self, project_uid, **kwargs):  # noqa: E501
          """Search jobs in project  # 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_parts_in_project(project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param SearchJobsRequestDto body:
          :return: SearchJobsDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.search_parts_in_project_with_http_info(project_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.search_parts_in_project_with_http_info(project_uid, **kwargs)  # noqa: E501
              return data
  
      def search_parts_in_project_with_http_info(self, project_uid, **kwargs):  # noqa: E501
          """Search jobs in project  # 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_parts_in_project_with_http_info(project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param SearchJobsRequestDto body:
          :return: SearchJobsDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', '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 search_parts_in_project" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `search_parts_in_project`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'body' in params:
              body_params = params['body']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/json'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v1/projects/{projectUid}/jobs/search', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='SearchJobsDto',  # 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_segment_by_job(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Search translation memory for segment by job  # noqa: E501
  
          Returns at most <i>maxSegments</i>             records with <i>score >= scoreThreshold</i> and at most <i>maxSubsegments</i> records which are subsegment,             i.e. the source text is substring of the query text.  # 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_segment_by_job(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :param SearchTMByJobRequestDto body:
          :return: SearchResponseListTmDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.search_segment_by_job_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.search_segment_by_job_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
              return data
  
      def search_segment_by_job_with_http_info(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Search translation memory for segment by job  # noqa: E501
  
          Returns at most <i>maxSegments</i>             records with <i>score >= scoreThreshold</i> and at most <i>maxSubsegments</i> records which are subsegment,             i.e. the source text is substring of the query text.  # 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_segment_by_job_with_http_info(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :param SearchTMByJobRequestDto body:
          :return: SearchResponseListTmDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', 'job_uid', '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 search_segment_by_job" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `search_segment_by_job`")  # noqa: E501
          # verify the required parameter 'job_uid' is set
          if ('job_uid' not in params or
                  params['job_uid'] is None):
              raise ValueError("Missing the required parameter `job_uid` when calling `search_segment_by_job`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
          if 'job_uid' in params:
              path_params['jobUid'] = params['job_uid']  # noqa: E501
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'body' in params:
              body_params = params['body']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/json'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v1/projects/{projectUid}/jobs/{jobUid}/transMemories/searchSegment', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='SearchResponseListTmDto',  # 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_terms_by_job1(self, job_uid, project_uid, **kwargs):  # noqa: E501
          """Search job's term bases  # noqa: E501
  
          Search all read term bases assigned to the job  # 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_terms_by_job1(job_uid, project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str job_uid: (required)
          :param str project_uid: (required)
          :param SearchTbByJobRequestDto body:
          :return: SearchTbResponseListDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.search_terms_by_job1_with_http_info(job_uid, project_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.search_terms_by_job1_with_http_info(job_uid, project_uid, **kwargs)  # noqa: E501
              return data
  
      def search_terms_by_job1_with_http_info(self, job_uid, project_uid, **kwargs):  # noqa: E501
          """Search job's term bases  # noqa: E501
  
          Search all read term bases assigned to the job  # 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_terms_by_job1_with_http_info(job_uid, project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str job_uid: (required)
          :param str project_uid: (required)
          :param SearchTbByJobRequestDto body:
          :return: SearchTbResponseListDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['job_uid', 'project_uid', '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 search_terms_by_job1" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'job_uid' is set
          if ('job_uid' not in params or
                  params['job_uid'] is None):
              raise ValueError("Missing the required parameter `job_uid` when calling `search_terms_by_job1`")  # noqa: E501
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `search_terms_by_job1`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'job_uid' in params:
              path_params['jobUid'] = params['job_uid']  # noqa: E501
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'body' in params:
              body_params = params['body']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/json'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v2/projects/{projectUid}/jobs/{jobUid}/termBases/searchByJob', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='SearchTbResponseListDto',  # 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_terms_in_text_by_job_v2(self, job_uid, project_uid, **kwargs):  # noqa: E501
          """Search terms in text  # noqa: E501
  
          Search in text in all read term bases assigned to the job  # 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_terms_in_text_by_job_v2(job_uid, project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str job_uid: (required)
          :param str project_uid: (required)
          :param SearchTbInTextByJobRequestDto body:
          :return: SearchInTextResponseList2Dto
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.search_terms_in_text_by_job_v2_with_http_info(job_uid, project_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.search_terms_in_text_by_job_v2_with_http_info(job_uid, project_uid, **kwargs)  # noqa: E501
              return data
  
      def search_terms_in_text_by_job_v2_with_http_info(self, job_uid, project_uid, **kwargs):  # noqa: E501
          """Search terms in text  # noqa: E501
  
          Search in text in all read term bases assigned to the job  # 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_terms_in_text_by_job_v2_with_http_info(job_uid, project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str job_uid: (required)
          :param str project_uid: (required)
          :param SearchTbInTextByJobRequestDto body:
          :return: SearchInTextResponseList2Dto
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['job_uid', 'project_uid', '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 search_terms_in_text_by_job_v2" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'job_uid' is set
          if ('job_uid' not in params or
                  params['job_uid'] is None):
              raise ValueError("Missing the required parameter `job_uid` when calling `search_terms_in_text_by_job_v2`")  # noqa: E501
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `search_terms_in_text_by_job_v2`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'job_uid' in params:
              path_params['jobUid'] = params['job_uid']  # noqa: E501
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'body' in params:
              body_params = params['body']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/json'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v2/projects/{projectUid}/jobs/{jobUid}/termBases/searchInTextByJob', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='SearchInTextResponseList2Dto',  # 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 set_status(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Edit job status  # 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.set_status(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :param JobStatusChangeActionDto body:
          :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.set_status_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.set_status_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
              return data
  
      def set_status_with_http_info(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Edit job status  # 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.set_status_with_http_info(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :param JobStatusChangeActionDto body:
          :return: None
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', 'job_uid', '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 set_status" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `set_status`")  # noqa: E501
          # verify the required parameter 'job_uid' is set
          if ('job_uid' not in params or
                  params['job_uid'] is None):
              raise ValueError("Missing the required parameter `job_uid` when calling `set_status`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
          if 'job_uid' in params:
              path_params['jobUid'] = params['job_uid']  # noqa: E501
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'body' in params:
              body_params = params['body']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/json'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v1/projects/{projectUid}/jobs/{jobUid}/setStatus', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type=None,  # noqa: E501
              auth_settings=auth_settings,
              async_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 split(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Split job  # noqa: E501
  
           Splits job by one of the following methods: * **After specific segments** - fill in `segmentOrdinals` * **Into X parts** - fill in `partCount`  * **Into parts with specific size** - fill in `partSize`. partSize represents segment count in each part. * **Into parts with specific word count** - fill in `wordCount`   * **By document parts** - fill in `byDocumentParts`, works only with **PowerPoint** files   Only one option at a time is allowed.  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.split(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :param SplitJobActionDto body:
          :return: JobPartsDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.split_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.split_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
              return data
  
      def split_with_http_info(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Split job  # noqa: E501
  
           Splits job by one of the following methods: * **After specific segments** - fill in `segmentOrdinals` * **Into X parts** - fill in `partCount`  * **Into parts with specific size** - fill in `partSize`. partSize represents segment count in each part. * **Into parts with specific word count** - fill in `wordCount`   * **By document parts** - fill in `byDocumentParts`, works only with **PowerPoint** files   Only one option at a time is allowed.  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.split_with_http_info(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :param SplitJobActionDto body:
          :return: JobPartsDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', 'job_uid', '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 split" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `split`")  # noqa: E501
          # verify the required parameter 'job_uid' is set
          if ('job_uid' not in params or
                  params['job_uid'] is None):
              raise ValueError("Missing the required parameter `job_uid` when calling `split`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
          if 'job_uid' in params:
              path_params['jobUid'] = params['job_uid']  # noqa: E501
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'body' in params:
              body_params = params['body']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/json'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v1/projects/{projectUid}/jobs/{jobUid}/split', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='JobPartsDto',  # 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 status_changes(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Get status changes  # 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.status_changes(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :return: JobPartStatusChangesDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.status_changes_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.status_changes_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
              return data
  
      def status_changes_with_http_info(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Get status changes  # 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.status_changes_with_http_info(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :return: JobPartStatusChangesDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', 'job_uid']  # 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 status_changes" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `status_changes`")  # noqa: E501
          # verify the required parameter 'job_uid' is set
          if ('job_uid' not in params or
                  params['job_uid'] is None):
              raise ValueError("Missing the required parameter `job_uid` when calling `status_changes`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
          if 'job_uid' in params:
              path_params['jobUid'] = params['job_uid']  # noqa: E501
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/json'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v1/projects/{projectUid}/jobs/{jobUid}/statusChanges', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='JobPartStatusChangesDto',  # 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 upload_bilingual_file(self, **kwargs):  # noqa: E501
          """Upload bilingual file  # noqa: E501
  
          Returns updated job parts  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.upload_bilingual_file(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param InputStream body:
          :param str format:
          :param str save_to_trans_memory:
          :param bool set_completed:
          :return: JobPartsDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.upload_bilingual_file_with_http_info(**kwargs)  # noqa: E501
          else:
              (data) = self.upload_bilingual_file_with_http_info(**kwargs)  # noqa: E501
              return data
  
      def upload_bilingual_file_with_http_info(self, **kwargs):  # noqa: E501
          """Upload bilingual file  # noqa: E501
  
          Returns updated job parts  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.upload_bilingual_file_with_http_info(async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param InputStream body:
          :param str format:
          :param str save_to_trans_memory:
          :param bool set_completed:
          :return: JobPartsDto
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['body', 'format', 'save_to_trans_memory', 'set_completed']  # 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 upload_bilingual_file" % key
                  )
              params[key] = val
          del params['kwargs']
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'format' in params:
              query_params.append(('format', params['format']))  # noqa: E501
          if 'save_to_trans_memory' in params:
              query_params.append(('saveToTransMemory', params['save_to_trans_memory']))  # noqa: E501
          if 'set_completed' in params:
              query_params.append(('setCompleted', params['set_completed']))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'body' in params:
              body_params = params['body']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/octet-stream'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v1/bilingualFiles', 'PUT',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='JobPartsDto',  # 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 web_editor_link_v2(self, project_uid, **kwargs):  # noqa: E501
          """Get Web Editor URL  # noqa: E501
  
           Possible warning codes are:   - `NOT_ACCEPTED_BY_LINGUIST` - Job is not accepted by linguist   - `NOT_ASSIGNED_TO_LINGUIST` - Job is not assigned to linguist   - `PDF` - One of requested jobs is PDF   - `PREVIOUS_WORKFLOW_NOT_COMPLETED` - Previous workflow step is not completed   - `PREVIOUS_WORKFLOW_NOT_COMPLETED_STRICT` - Previous workflow step is not completed and project has strictWorkflowFinish set to true   - `IN_DELIVERED_STATE` - Jobs in DELIVERED state   - `IN_COMPLETED_STATE` - Jobs in COMPLETED state  Possible error codes are:   - `ASSIGNED_TO_OTHER_USER` - Job is accepted by other user   - `NOT_UNIQUE_TARGET_LANG` - Requested jobs contains different target locales   - `TOO_MANY_SEGMENTS` - Count of requested job's requests is higher then **40000**   - `COMPLETED_JOINED_WITH_OTHER` - Jobs in COMPLETED state cannot be joined with jobs in other states   - `DELIVERED_JOINED_WITH_OTHER` - Jobs in DELIVERED state cannot be joined with jobs in other states  Warning response example: ``` {     \"warnings\": [         {             \"message\": \"Not accepted by linguist\",             \"args\": {                 \"jobs\": [                     \"abcd1234\"                 ]             },             \"code\": \"NOT_ACCEPTED_BY_LINGUIST\"         },         {             \"message\": \"Previous workflow step not completed\",             \"args\": {                 \"jobs\": [                     \"abcd1234\"                 ]             },             \"code\": \"PREVIOUS_WORKFLOW_NOT_COMPLETED\"         }     ],     \"url\": \"/web/job/abcd1234-efgh5678/translate\" } ```  Error response example: Status: `400 Bad Request` ``` {     \"errorCode\": \"NOT_UNIQUE_TARGET_LANG\",     \"errorDescription\": \"Only files with identical target languages can be joined\",     \"errorDetails\": [         {             \"code\": \"NOT_UNIQUE_TARGET_LANG\",             \"args\": {                 \"targetLocales\": [                     \"de\",                     \"en\"                 ]             },             \"message\": \"Only files with identical target languages can be joined\"         },         {             \"code\": \"TOO_MANY_SEGMENTS\",             \"args\": {                 \"maxSegments\": 40000,                 \"segments\": 400009             },             \"message\": \"Up to 40000 segments can be opened in the Memsource Web Editor, job has 400009 segments\"         }     ] } ```   # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.web_editor_link_v2(project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param CreateWebEditorLinkDtoV2 body:
          :return: WebEditorLinkDtoV2
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.web_editor_link_v2_with_http_info(project_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.web_editor_link_v2_with_http_info(project_uid, **kwargs)  # noqa: E501
              return data
  
      def web_editor_link_v2_with_http_info(self, project_uid, **kwargs):  # noqa: E501
          """Get Web Editor URL  # noqa: E501
  
           Possible warning codes are:   - `NOT_ACCEPTED_BY_LINGUIST` - Job is not accepted by linguist   - `NOT_ASSIGNED_TO_LINGUIST` - Job is not assigned to linguist   - `PDF` - One of requested jobs is PDF   - `PREVIOUS_WORKFLOW_NOT_COMPLETED` - Previous workflow step is not completed   - `PREVIOUS_WORKFLOW_NOT_COMPLETED_STRICT` - Previous workflow step is not completed and project has strictWorkflowFinish set to true   - `IN_DELIVERED_STATE` - Jobs in DELIVERED state   - `IN_COMPLETED_STATE` - Jobs in COMPLETED state  Possible error codes are:   - `ASSIGNED_TO_OTHER_USER` - Job is accepted by other user   - `NOT_UNIQUE_TARGET_LANG` - Requested jobs contains different target locales   - `TOO_MANY_SEGMENTS` - Count of requested job's requests is higher then **40000**   - `COMPLETED_JOINED_WITH_OTHER` - Jobs in COMPLETED state cannot be joined with jobs in other states   - `DELIVERED_JOINED_WITH_OTHER` - Jobs in DELIVERED state cannot be joined with jobs in other states  Warning response example: ``` {     \"warnings\": [         {             \"message\": \"Not accepted by linguist\",             \"args\": {                 \"jobs\": [                     \"abcd1234\"                 ]             },             \"code\": \"NOT_ACCEPTED_BY_LINGUIST\"         },         {             \"message\": \"Previous workflow step not completed\",             \"args\": {                 \"jobs\": [                     \"abcd1234\"                 ]             },             \"code\": \"PREVIOUS_WORKFLOW_NOT_COMPLETED\"         }     ],     \"url\": \"/web/job/abcd1234-efgh5678/translate\" } ```  Error response example: Status: `400 Bad Request` ``` {     \"errorCode\": \"NOT_UNIQUE_TARGET_LANG\",     \"errorDescription\": \"Only files with identical target languages can be joined\",     \"errorDetails\": [         {             \"code\": \"NOT_UNIQUE_TARGET_LANG\",             \"args\": {                 \"targetLocales\": [                     \"de\",                     \"en\"                 ]             },             \"message\": \"Only files with identical target languages can be joined\"         },         {             \"code\": \"TOO_MANY_SEGMENTS\",             \"args\": {                 \"maxSegments\": 40000,                 \"segments\": 400009             },             \"message\": \"Up to 40000 segments can be opened in the Memsource Web Editor, job has 400009 segments\"         }     ] } ```   # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.web_editor_link_v2_with_http_info(project_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param CreateWebEditorLinkDtoV2 body:
          :return: WebEditorLinkDtoV2
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', '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 web_editor_link_v2" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `web_editor_link_v2`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'body' in params:
              body_params = params['body']
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v2/projects/{projectUid}/jobs/webEditor', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='WebEditorLinkDtoV2',  # 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 wild_card_search_by_job3(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Wildcard search job's translation memories  # 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.wild_card_search_by_job3(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :param WildCardSearchByJobRequestDtoV3 body:
          :return: SearchResponseListTmDtoV3
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.wild_card_search_by_job3_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
          else:
              (data) = self.wild_card_search_by_job3_with_http_info(project_uid, job_uid, **kwargs)  # noqa: E501
              return data
  
      def wild_card_search_by_job3_with_http_info(self, project_uid, job_uid, **kwargs):  # noqa: E501
          """Wildcard search job's translation memories  # 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.wild_card_search_by_job3_with_http_info(project_uid, job_uid, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str project_uid: (required)
          :param str job_uid: (required)
          :param WildCardSearchByJobRequestDtoV3 body:
          :return: SearchResponseListTmDtoV3
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['project_uid', 'job_uid', '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 wild_card_search_by_job3" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'project_uid' is set
          if ('project_uid' not in params or
                  params['project_uid'] is None):
              raise ValueError("Missing the required parameter `project_uid` when calling `wild_card_search_by_job3`")  # noqa: E501
          # verify the required parameter 'job_uid' is set
          if ('job_uid' not in params or
                  params['job_uid'] is None):
              raise ValueError("Missing the required parameter `job_uid` when calling `wild_card_search_by_job3`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
          if 'project_uid' in params:
              path_params['projectUid'] = params['project_uid']  # noqa: E501
          if 'job_uid' in params:
              path_params['jobUid'] = params['job_uid']  # noqa: E501
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'body' in params:
              body_params = params['body']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/json'])  # noqa: E501
  
          # Authentication setting
          auth_settings = []  # noqa: E501
  
          return self.api_client.call_api(
              '/api2/v3/projects/{projectUid}/jobs/{jobUid}/transMemories/wildCardSearch', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='SearchResponseListTmDtoV3',  # 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)
  