docs: def run(self, executable_input, project=None, folder=None, name=None, tags=None, properties=None, details=None,
              instance_type=None, stage_instance_types=None, stage_folders=None, rerun_stages=None, cluster_spec=None,
              depends_on=None, allow_ssh=None, debug=None, delay_workspace_destruction=None, priority=None,
              ignore_reuse=None, ignore_reuse_stages=None, extra_args=None, **kwargs):
          '''
          :param executable_input: Hash of the executable's input arguments
          :type executable_input: dict
          :param project: Project ID of the project context
          :type project: string
          :param folder: Folder in which executable's outputs will be placed in *project*
          :type folder: string
          :param name: Name for the new job (default is "<name of the executable>")
          :type name: string
          :param tags: Tags to associate with the job
          :type tags: list of strings
          :param properties: Properties to associate with the job
          :type properties: dict with string values
          :param details: Details to set for the job
          :type details: dict or list
          :param instance_type: Instance type on which the jobs will be run, or a dict mapping function names to instance type requests
          :type instance_type: string or dict
          :param depends_on: List of data objects or jobs to wait that need to enter the "closed" or "done" states, respectively, before the new job will be run; each element in the list can either be a dxpy handler or a string ID
          :type depends_on: list
          :param allow_ssh: List of hostname or IP masks to allow SSH connections from
          :type allow_ssh: list
          :param debug: Configuration options for job debugging
          :type debug: dict
          :param delay_workspace_destruction: Whether to keep the job's temporary workspace around for debugging purposes for 3 days after it succeeds or fails
          :type delay_workspace_destruction: boolean
          :param priority: Priority level to request for all jobs created in the execution tree, either "normal" or "high"
          :type priority: string
          :param ignore_reuse: Disable job reuse for this execution
          :type ignore_reuse: boolean
          :param ignore_reuse_stages: Stages of a workflow (IDs, names, or indices) or "*" for which job reuse should be disabled
          :type ignore_reuse_stages: list
          :param extra_args: If provided, a hash of options that will be merged into the underlying JSON given for the API call
          :type extra_args: dict
          :returns: Object handler of the newly created job
          :rtype: :class:`~dxpy.bindings.dxjob.DXJob`
  
          Creates a new job that executes the function "main" of this executable with
          the given input *executable_input*.
  
          '''
          # stage_instance_types, stage_folders, and rerun_stages are
          # only supported for workflows, but we include them
          # here. Applet-based executables should detect when they
          # receive a truthy workflow-specific value and raise an error.
          run_input = self._get_run_input(executable_input,
                                          project=project,
                                          folder=folder,
                                          name=name,
                                          tags=tags,
                                          properties=properties,
                                          details=details,
                                          instance_type=instance_type,
                                          stage_instance_types=stage_instance_types,
                                          stage_folders=stage_folders,
                                          rerun_stages=rerun_stages,
                                          cluster_spec=cluster_spec,
                                          depends_on=depends_on,
                                          allow_ssh=allow_ssh,
                                          ignore_reuse=ignore_reuse,
                                          ignore_reuse_stages=ignore_reuse_stages,
                                          debug=debug,
                                          delay_workspace_destruction=delay_workspace_destruction,
                                          priority=priority,
                                          extra_args=extra_args)
  
          return self._run_impl(run_input, **kwargs)