docs: def run_cell(self, cell, cell_index=0):
          """
          Run cell with caching
          :param cell: cell to run
          :param cell_index: cell index (optional)
          :return:
          """
  
          hash = self.cell_hash(cell, cell_index)
          fname_session = '/tmp/pynb-cache-{}-session.dill'.format(hash)
          fname_value = '/tmp/pynb-cache-{}-value.dill'.format(hash)
          cell_snippet = str(" ".join(cell.source.split())).strip()[:40]
  
          if self.disable_cache:
              logging.info('Cell {}: Running: "{}.."'.format(hash, cell_snippet))
              return super().run_cell(cell, cell_index)
  
          if not self.ignore_cache:
              if self.cache_valid and os.path.isfile(fname_session) and os.path.isfile(fname_value):
                  logging.info('Cell {}: Loading: "{}.."'.format(hash, cell_snippet))
                  self.prev_fname_session = fname_session
                  with open(fname_value, 'rb') as f:
                      value = dill.load(f)
                      return value
  
          # If cache does not exist or not valid:
          #
          # 1) Invalidate subsequent cell caches
          # 2) Load session from previous cached cell (if existing)
          # 3) Run cell
          # 4) Cache cell session
          # 5) Cache cell value
  
          logging.info('Cell {}: Running: "{}.."'.format(hash, cell_snippet))
  
          # 1) Invalidate subsequent cell caches
          self.cache_valid = False
  
          # 2) Load session from previous cached cell (if existing and required)
          if self.prev_fname_session:
              if self.prev_fname_session_loaded != self.prev_fname_session:
                  self.session_load(hash, self.prev_fname_session)
  
          # 2) Run cell
          value = super().run_cell(cell, cell_index)
  
          # We make sure that injected cells do not interfere with the cell index...
          # value[0]['content']['execution_count'] = cell_index
  
          # 3) Cache cell session
          cached = self.session_dump(cell, hash, fname_session)
  
          # 4) Cache cell value, if no errors while dumping the cell session in 3).
  
          if cached:
              self.prev_fname_session_loaded = fname_session
              self.prev_fname_session = fname_session
  
              logging.debug('Cell {}: dumping value to {}'.format(hash, fname_value))
  
              with open(fname_value, 'wb') as f:
                  dill.dump(value, f)
  
              logging.debug('Cell {}: cached'.format(hash))
  
          return value