class_docstr: This class will fill gaps in the source data using the following
  information bits from the underlying data source
  
    - timeframe and compression to dimension the output bars
  
    - sessionstart and sessionend
  
  If a data feed has missing bars in between 10:31 and 10:34 and the
  timeframe is minutes, the output will be filled with bars for minutes
  10:32 and 10:33 using the closing price of the last bar (10:31)
  
  Bars can be missinga amongst other things because
  
  Params:
    - ``fill_price`` (def: None): if None (or evaluates to False),the
      closing price will be used, else the passed value (which can be
      for example 'NaN' to have a missing bar in terms of evaluation but
      present in terms of time
  
    - ``fill_vol`` (def: NaN): used to fill the volume of missing bars
  
    - ``fill_oi`` (def: NaN): used to fill the openinterest of missing bars
code: def _load(self):
      if not len(self.p.dataname):
          self.p.dataname.start()  # start data if not done somewhere else
  
          # Copy from underlying data
          self._timeframe = self.p.dataname._timeframe
          self._compression = self.p.dataname._compression
  
          self.p.timeframe = self._timeframe
          self.p.compression = self._compression
  
          # Calculate and save timedelta for timeframe
          self._tdunit = self._tdeltas[self._timeframe]
          self._tdunit *= self._compression
  
      if self._fillbars:
          return self._frombars()
  
      # use existing bar or fetch a bar
      self._dbar = self._dbar or self.p.dataname.next()
      if not self._dbar:
          return False  # no more data
  
      if len(self) == 1:
          # Cannot yet look backwards - deliver data as is
          return self._copyfromdata()
  
      # previous (delivered) close
      pclose = self.lines.close[-1]
      # Get time of previous (already delivered) bar
      dtime_prev = self.lines.datetime.datetime(-1)
      # Get time of current (from data source) bar
      dtime_cur = self.p.dataname.datetime.datetime(0)
  
      # Calculate session end for previous bar
      send = datetime.combine(
          dtime_prev.date(), self.p.dataname.sessionend
      )
  
      if dtime_cur > send:  # if jumped boundary
          # 1. check for missing bars until boundary (end)
          dtime_prev += self._tdunit
          while dtime_prev < send:
              self._fillbars.append((dtime_prev, pclose))
              dtime_prev += self._tdunit
  
          # Calculate session start for new bar
          sstart = datetime.combine(
              dtime_cur.date(), self.p.dataname.sessionstart
          )
  
          # 2. check for missing bars from new boundary (start)
          # check gap from new sessionstart
          while sstart < dtime_cur:
              self._fillbars.append((sstart, pclose))
              sstart += self._tdunit
      else:
          # no boundary jumped - check gap until current time
          dtime_prev += self._tdunit
          while dtime_prev < dtime_cur:
              self._fillbars.append((dtime_prev, pclose))
              dtime_prev += self._tdunit
  
      if self._fillbars:
          self._dbar = True  # flag a pending data bar is available
  
          # return an accumulated bar in current cycle
          return self._frombars()
  
      return self._copyfromdata()
  
file_path: backtrader/backtrader/filters/datafiller.py
imports: from __future__ import absolute_import, division, print_function, unicode_literals
  import collections
  from datetime import datetime, timedelta
  from backtrader import AbstractDataBase, TimeFrame
label_desc: Use image node_id 5 for calling the DataFiller obj's underlying member method code with example usage: obj._load() and returns: self, self, False, self, self