code: def _partial(self, _id, features=None, persistence=None):
          
  
          root = features is None
  
          stored = self._stored(_id, persistence)
          is_cached = self.store and stored
  
          if self.store and not stored:
              data_writer = None
          elif root:
              data_writer = BytesIODataWriter
          else:
              data_writer = None
  
          should_store = self.store and not stored
          nf = self.copy(
              extractor=DecoderNode if is_cached else self.extractor,
              store=root or should_store,
              needs=dict(),
              data_writer=data_writer,
              persistence=self.persistence,
              extractor_args=dict(decodifier=self.decoder, version=self.version) \
                  if is_cached else self.extractor_args)
  
          if root:
              features = dict()
  
          features[self.key] = nf
  
          if not is_cached:
              for k, v in list(self.needs.items()):
                  v._partial(_id, features=features, persistence=persistence)
                  nf.needs[k] = features[v.key]
  
          return features
docs: TODO: _partial is a shit name for this, kind of.  I'm building a graph
          such that I can only do work necessary to compute self, and no more