docs: def find_executions(classname=None, launched_by=None, executable=None, project=None,
                      state=None, origin_job=None, parent_job=None, no_parent_job=False,
                      parent_analysis=None, no_parent_analysis=False, root_execution=None,
                      created_after=None, created_before=None, describe=False,
                      name=None, name_mode="exact", tags=None, properties=None, limit=None,
                      first_page_size=100, return_handler=False, include_subjobs=True,
                      **kwargs):
      '''
      :param classname:
          Class with which to restrict the search, i.e. one of "job",
          "analysis"
      :type classname: string
      :param launched_by: User ID of the user who launched the execution's origin execution
      :type launched_by: string
      :param executable: ID of the applet or app that spawned this execution, or a corresponding remote object handler
      :type executable: string or a DXApp/DXApplet/DXWorkflow instance
      :param project: ID of the project context for the execution
      :type project: string
      :param state: State of the execution (e.g. "failed", "done")
      :type state: string
      :param origin_job: ID of the original job that eventually spawned this execution (possibly by way of other executions)
      :type origin_job: string
      :param parent_job: ID of the parent job (deprecated: use the string 'none' to indicate it should have no parent job; use *no_parent_job* instead)
      :type parent_job: string
      :param no_parent_job: Indicate results should have no parent job; cannot be set to True with *parent_job* set to a string
      :type no_parent_job: boolean
      :param parent_analysis: ID of the parent analysis (deprecated: use the string 'none' to indicate it should have no parent analysis; use *no_parent_analysis* instead)
      :type parent_analysis: string
      :param no_parent_analysis: Indicate results should have no parent analysis; cannot be set to True with *parent_analysis* set to a string
      :type no_parent_job: boolean
      :param root_execution: ID of the top-level (user-initiated) execution (job or analysis) that eventually spawned this execution (possibly by way of other executions)
      :type root_execution: string
      :param created_after: Timestamp after which each result was last created (see note accompanying :meth:`find_data_objects()` for interpretation)
      :type created_after: int or string
      :param created_before: Timestamp before which each result was last created (see note accompanying :meth:`find_data_objects()` for interpretation)
      :type created_before: int or string
      :param describe: Controls whether to also return the output of
          calling describe() on each execution. Supply False to omit
          describe output, True to obtain the default describe output, or
          a dict to be supplied as the describe call input (which may be
          used to customize the set of fields that is to be returned; for
          example, you can supply {"io": False} to suppress detailed
          information about the execution's inputs and outputs)
      :type describe: bool or dict
      :param name: Name of the job or analysis to search by (also see *name_mode*)
      :type name: string
      :param name_mode: Method by which to interpret the *name* field ("exact": exact match, "glob": use "*" and "?" as wildcards, "regexp": interpret as a regular expression)
      :type name_mode: string
      :param tags: List of tags that each result must have ALL of
      :type tags: list of strings
      :param properties: Properties (key-value pairs) that each result must have (use value True to require the property key and allow any value)
      :type properties: dict
      :param limit: The maximum number of results to be returned (if not specified, the number of results is unlimited)
      :type limit: int
      :param first_page_size: The number of results that the initial API call will return. Subsequent calls will raise this by multiplying by 2 up to a maximum of 1000.
      :type first_page_size: int
      :param return_handler: If True, yields results as dxpy object handlers (otherwise, yields each result as a dict with keys "id" and "project")
      :type return_handler: boolean
      :param include_subjobs: If False, no subjobs will be returned by the API
      :type include_subjobs: boolean
      :rtype: generator
  
      Returns a generator that yields all executions (jobs or analyses) that match the query. It transparently handles
      paging through the result set if necessary. For all parameters that are omitted, the search is not restricted by
      the corresponding field.
  
      The following example iterates through all finished jobs and analyses in a
      particular project that were launched in the last two days::
  
        for result in find_executions(state="done", project=proj_id, created_after="-2d"):
            print "Found job or analysis with object id " + result["id"]
  
      '''
  
      query = {}
      if classname is not None:
          query["class"] = classname
      if launched_by is not None:
          query["launchedBy"] = launched_by
      if executable is not None:
          if isinstance(executable, (DXApplet, DXApp, DXWorkflow)):
              query["executable"] = executable.get_id()
          else:
              query["executable"] = executable
      if project is not None:
          if isinstance(project, DXProject):
              query["project"] = project.get_id()
          else:
              query["project"] = project
      if state is not None:
          query["state"] = state
      if origin_job is not None:
          if isinstance(origin_job, DXJob):
              query["originJob"] = origin_job.get_id()
          else:
              query["originJob"] = origin_job
      if parent_job is not None:
          if no_parent_job:
              raise DXError('find_executions: Cannot provide parent_job and set no_parent_job to True')
          if parent_job == "none": # to be deprecated
              query["parentJob"] = None
          elif isinstance(parent_job, DXJob):
              query["parentJob"] = parent_job.get_id()
          else:
              query["parentJob"] = parent_job
      elif no_parent_job:
          query["parentJob"] = None
      if parent_analysis is not None:
          if no_parent_analysis:
              raise DXError('find_executions: Cannot provide parent_analysis and set no_parent_analysis to True')
          if parent_analysis == "none": # to be deprecated
              query["parentAnalysis"] = None
          elif isinstance(parent_analysis, DXAnalysis):
              query["parentAnalysis"] = parent_analysis.get_id()
          else:
              query["parentAnalysis"] = parent_analysis
      elif no_parent_analysis:
          query["parentAnalysis"] = None
      if root_execution is not None:
          if isinstance(root_execution, (DXJob, DXAnalysis)):
              query["rootExecution"] = root_execution.get_id()
          else:
              query["rootExecution"] = root_execution
      if created_after is not None or created_before is not None:
          query["created"] = {}
          if created_after is not None:
              query["created"]["after"] = dxpy.utils.normalize_time_input(created_after)
          if created_before is not None:
              query["created"]["before"] = dxpy.utils.normalize_time_input(created_before)
      if describe is not None and describe is not False:
          query["describe"] = describe
      if name is not None:
          if name_mode == 'exact':
              query['name'] = name
          elif name_mode == 'glob':
              query['name'] = {'glob': name}
          elif name_mode == 'regexp':
              query['name'] = {'regexp': name}
          else:
              raise DXError('find_executions: Unexpected value found for argument name_mode')
      if tags is not None:
          query['tags'] = {'$and': tags}
      if properties is not None:
          query['properties'] = properties
      if include_subjobs is not True:
          query["includeSubjobs"] = include_subjobs
      if limit is not None:
          query["limit"] = limit
  
      return _find(dxpy.api.system_find_executions, query, limit, return_handler, first_page_size, **kwargs)