code: def fromfile(file_,
                   threadpool_size=None,
                   ignore_lock=False):
          
          close_file = False
          if not hasattr(file_, 'read'):
              file_ = open(file_, 'rb')
              close_file = True
          try:
              header_data = file_.read(BlockStorageRAM._index_offset)
              block_size, block_count, user_header_size, locked = \
                  struct.unpack(
                      BlockStorageRAM._index_struct_string,
                      header_data)
              if locked and (not ignore_lock):
                  raise IOError(
                      "Can not open block storage device because it is "
                      "locked by another process. To ignore this check, "
                      "call this method with the keyword 'ignore_lock' "
                      "set to True.")
              header_offset = len(header_data) + \
                              user_header_size
              f = bytearray(header_offset + \
                            (block_size * block_count))
              f[:header_offset] = header_data + file_.read(user_header_size)
              f[header_offset:] = file_.read(block_size * block_count)
          finally:
              if close_file:
                  file_.close()
  
          return BlockStorageRAM(f,
                                 threadpool_size=threadpool_size,
                                 ignore_lock=ignore_lock)
docs: Instantiate BlockStorageRAM device from a file saved in block
          storage format. The file_ argument can be a file object or a
          string that represents a filename. If called with a file
          object, it should be opened in binary mode, and the caller is
          responsible for closing the file.
  
          This method returns a BlockStorageRAM instance.