docs: def blue(self, memo=None):
          """
          Constructs a BlueDispatcher out of the current object.
  
          :param memo:
              A dictionary to cache Blueprints.
          :type memo: dict[T,schedula.utils.blue.Blueprint]
  
          :return:
              A BlueDispatcher of the current object.
          :rtype: schedula.utils.blue.BlueDispatcher
          """
          memo = {} if memo is None else memo
          if self in memo:
              return memo[self]
          from .utils.dsp import map_list
          from .utils.blue import BlueDispatcher, _parent_blue
          memo[self] = blue = BlueDispatcher(
              executor=self.executor, name=self.name, raises=self.raises,
              description=self.__doc__
          )
          dfl = self.default_values
          key_map_data = ['data_id', {'value': 'default_value'}]
          pred, succ = self.dmap.pred, self.dmap.succ
  
          def _set_weight(n, r, d):
              d = {i: j['weight'] for i, j in d.items() if 'weight' in j}
              if d:
                  r[n] = d
  
          for k, v in sorted(self.nodes.items(), key=lambda x: x[1]['index']):
              v = v.copy()
              t = v.pop('type')
              del v['index']
              if t == 'data':
                  method = 'add_data'
                  combine_dicts(map_list(key_map_data, k, dfl.get(k, {})), base=v)
              elif t in ('function', 'dispatcher'):
                  method = 'add_%s' % t
                  if t == 'dispatcher':
                      t = 'dsp'
                  v['%s_id' % t] = k
                  del v['wait_inputs']
                  _set_weight('inp_weight', v, pred[k])
                  _set_weight('out_weight', v, succ[k])
                  if 'function' in v:
                      v[t] = _parent_blue(v.pop('function'), memo)
              blue.deferred.append((method, v))
          return blue