docs: def add_dispatcher(self, dsp, inputs, outputs, dsp_id=None,
                         input_domain=None, weight=None, inp_weight=None,
                         description=None, include_defaults=False,
                         await_domain=None, **kwargs):
          """
          Add a single sub-dispatcher node to dispatcher.
  
          :param dsp:
              Child dispatcher that is added as sub-dispatcher node to the parent
              dispatcher.
          :type dsp: Dispatcher | dict[str, list]
  
          :param inputs:
              Inputs mapping. Data node ids from parent dispatcher to child
              sub-dispatcher.
          :type inputs: dict[str, str | list[str]] | tuple[str] |
                        (str, ..., dict[str, str | list[str]])
  
          :param outputs:
              Outputs mapping. Data node ids from child sub-dispatcher to parent
              dispatcher.
          :type outputs: dict[str, str | list[str]] | tuple[str] |
                         (str, ..., dict[str, str | list[str]])
  
          :param dsp_id:
              Sub-dispatcher node id.
              If None will be assigned as <dsp.name>.
          :type dsp_id: str, optional
  
          :param input_domain:
              A function that checks if input values satisfy the function domain.
              This can be any function that takes the a dictionary with the inputs
              of the sub-dispatcher node and returns True if input values satisfy
              the domain, otherwise False.
  
              .. note:: This function is invoked every time that a data node reach
                 the sub-dispatcher node.
          :type input_domain: (dict) -> bool, optional
  
          :param weight:
              Node weight. It is a weight coefficient that is used by the dispatch
              algorithm to estimate the minimum workflow.
          :type weight: float, int, optional
  
          :param inp_weight:
              Edge weights from data nodes to the sub-dispatcher node.
              It is a dictionary (key=data node id) with the weight coefficients
              used by the dispatch algorithm to estimate the minimum workflow.
          :type inp_weight: dict[str, int | float], optional
  
          :param description:
              Sub-dispatcher node's description.
          :type description: str, optional
  
          :param include_defaults:
              If True the default values of the sub-dispatcher are added to the
              current dispatcher.
          :type include_defaults: bool, optional
  
          :param await_domain:
              If True the Dispatcher waits all input results before executing the
              `input_domain` function. If a number is defined this is used as
              `timeout` for `Future.result` method [default: True]. Note this is
              used when asynchronous or parallel execution is enable.
          :type await_domain: bool|int|float, optional
  
          :param kwargs:
              Set additional node attributes using key=value.
          :type kwargs: keyword arguments, optional
  
          :return:
              Self.
          :rtype: BlueDispatcher
          """
          kwargs.update(_call_kw(locals()))
          self.deferred.append(('add_dispatcher', kwargs))
          return self