code: def read_cache(stream):
      
      version, num_entries = read_header(stream)
      count = 0
      entries = {}
  
      read = stream.read
      tell = stream.tell
      while count < num_entries:
          beginoffset = tell()
          ctime = unpack(">8s", read(8))[0]
          mtime = unpack(">8s", read(8))[0]
          (dev, ino, mode, uid, gid, size, sha, flags) = \
              unpack(">LLLLLL20sH", read(20 + 4 * 6 + 2))
          path_size = flags & CE_NAMEMASK
          path = read(path_size).decode(defenc)
  
          real_size = ((tell() - beginoffset + 8) & ~7)
          read((beginoffset + real_size) - tell())
          entry = IndexEntry((mode, sha, flags, path, ctime, mtime, dev, ino, uid, gid, size))
          # entry_key would be the method to use, but we safe the effort
          entries[(path, entry.stage)] = entry
          count += 1
      # END for each entry
  
      # the footer contains extension data and a sha on the content so far
      # Keep the extension footer,and verify we have a sha in the end
      # Extension data format is:
      # 4 bytes ID
      # 4 bytes length of chunk
      # repeated 0 - N times
      extension_data = stream.read(~0)
      assert len(extension_data) > 19, "Index Footer was not at least a sha on content as it was only %i bytes in size"\
                                       % len(extension_data)
  
      content_sha = extension_data[-20:]
  
      # truncate the sha in the end as we will dynamically create it anyway
      extension_data = extension_data[:-20]
  
      return (version, entries, extension_data, content_sha)
docs: Read a cache file from the given stream
      :return: tuple(version, entries_dict, extension_data, content_sha)
      * version is the integer version number
      * entries dict is a dictionary which maps IndexEntry instances to a path at a stage
      * extension_data is '' or 4 bytes of type + 4 bytes of size + size bytes
      * content_sha is a 20 byte sha on all cache file contents