docs: def create(cls, name, project, app, revision=None, batch_input=None,
                 batch_by=None, inputs=None, description=None, run=False,
                 disable_batch=False, interruptible=None,
                 execution_settings=None, api=None):
  
          """
          Creates a task on server.
          :param name: Task name.
          :param project: Project identifier.
          :param app: CWL app identifier.
          :param revision: CWL app revision.
          :param batch_input: Batch input.
          :param batch_by: Batch criteria.
          :param inputs: Input map.
          :param description: Task description.
          :param run: True if you want to run a task upon creation.
          :param disable_batch: If True disables batching of a batch task.
          :param interruptible: If True interruptible instance will be used.
          :param execution_settings: Execution settings for the task.
          :param api: Api instance.
          :return: Task object.
          :raises: TaskValidationError if validation Fails.
          :raises: SbgError if any exception occurs during request.
          """
          task_data = {}
          params = {}
          project = Transform.to_project(project)
  
          app_id = Transform.to_app(app)
  
          if revision:
              app_id = app_id + "/" + six.text_type(revision)
          else:
              if isinstance(app, App):
                  app_id = app_id + "/" + six.text_type(app.revision)
  
          task_inputs = {
              'inputs': Task._serialize_inputs(inputs) if inputs else {}
          }
  
          if batch_input and batch_by:
              task_data['batch_input'] = batch_input
              task_data['batch_by'] = batch_by
              if disable_batch:
                  params.update({'batch': False})
  
          task_meta = {
              'name': name,
              'project': project,
              'app': app_id,
              'description': description,
          }
          task_data.update(task_meta)
          task_data.update(task_inputs)
  
          if interruptible is not None:
              task_data['use_interruptible_instances'] = interruptible
  
          if execution_settings:
              task_data.update({'execution_settings': execution_settings})
  
          if run:
              params.update({'action': 'run'})
  
          api = api if api else cls._API
          created_task = api.post(cls._URL['query'], data=task_data,
                                  params=params).json()
          if run and 'errors' in created_task:
              if bool(created_task['errors']):
                  raise TaskValidationError(
                      'Unable to run task! Task contains errors.',
                      task=Task(api=api, **created_task)
                  )
  
          return Task(api=api, **created_task)