class_docstr: Structure to discover and store `Dataset` dependencies.
  
  Used primarily by the `Scene` object to organize dependency finding.
  Dependencies are stored used a series of `Node` objects which this
  class is a subclass of.
class_docstr_tok: ["Structure","to","discover","and","store","`","Dataset","`","dependencies",".","Used","primarily","by","the","`","Scene","`","object","to","organize","dependency","finding",".","Dependencies","are","stored","used","a","series","of","`","Node","`","objects","which","this","class","is","a","subclass","of","."]
docstr: Find the compositor object for the given dataset_key.
docstr_tok: ["Find","the","compositor","object","for","the","given","dataset_key","."]
code: def _find_compositor(self, dataset_key, query):
      """Find the compositor object for the given dataset_key."""
      # NOTE: This function can not find a modifier that performs
      # one or more modifications if it has modifiers see if we can find
      # the unmodified version first
  
      if dataset_key.is_modified():
          implicit_dependency_node = (
              self._create_implicit_dependency_subtree(
                  dataset_key, query
              )
          )
          dataset_key = self._promote_query_to_modified_dataid(
              dataset_key, implicit_dependency_node.name
          )
          try:
              compositor = self.get_modifier(dataset_key)
          except KeyError:
              raise KeyError(
                  "Can't find anything called {}".format(
                      str(dataset_key)
                  )
              )
          compositor.attrs["prerequisites"] = [
              implicit_dependency_node
          ] + list(compositor.attrs["prerequisites"])
      else:
          try:
              compositor = self.get_compositor(dataset_key)
          except KeyError:
              raise KeyError(
                  "Can't find anything called {}".format(
                      str(dataset_key)
                  )
              )
  
      root = CompositorNode(compositor)
      composite_id = root.name
  
      prerequisite_filter = (
          composite_id.create_filter_query_without_required_fields(
              dataset_key
          )
      )
  
      # Get the prerequisites
      LOG.trace(
          "Looking for composite prerequisites for: {}".format(
              dataset_key
          )
      )
      prereqs = [
          create_filtered_query(prereq, prerequisite_filter)
          if not isinstance(prereq, Node)
          else prereq
          for prereq in compositor.attrs["prerequisites"]
      ]
      prereqs = self._create_required_subtrees(
          root, prereqs, query=query
      )
      root.add_required_nodes(prereqs)
  
      # Get the optionals
      LOG.trace(
          "Looking for optional prerequisites for: {}".format(
              dataset_key
          )
      )
      optionals = [
          create_filtered_query(prereq, prerequisite_filter)
          if not isinstance(prereq, Node)
          else prereq
          for prereq in compositor.attrs["optional_prerequisites"]
      ]
      optionals = self._create_optional_subtrees(
          root, optionals, query=query
      )
      root.add_optional_nodes(optionals)
  
      return root
  
imports: from __future__ import annotations
  from typing import Container, Iterable, Optional
  import numpy
  from satpy import DataID, DatasetDict
  from satpy.dataset import ModifierTuple, create_filtered_query
  from satpy.dataset.data_dict import TooManyResults, get_key
  from satpy.node import EMPTY_LEAF_NAME, LOG, CompositorNode, MissingDependencies, Node, ReaderNode
label_desc: Use image node_id 16 for calling the DependencyTree obj's underlying member method code with example usage: obj._find_compositor(dataset_key, query) and returns: root