code: def readv(self, chunks):
          
          self.sftp._log(
              DEBUG, "readv({}, {!r})".format(hexlify(self.handle), chunks)
          )
  
          read_chunks = []
          for offset, size in chunks:
              # don't fetch data that's already in the prefetch buffer
              if self._data_in_prefetch_buffers(
                  offset
              ) or self._data_in_prefetch_requests(offset, size):
                  continue
  
              # break up anything larger than the max read size
              while size > 0:
                  chunk_size = min(size, self.MAX_REQUEST_SIZE)
                  read_chunks.append((offset, chunk_size))
                  offset += chunk_size
                  size -= chunk_size
  
          self._start_prefetch(read_chunks)
          # now we can just devolve to a bunch of read()s :)
          for x in chunks:
              self.seek(x[0])
              yield self.read(x[1])
docs: Read a set of blocks from the file by (offset, length).  This is more
          efficient than doing a series of `.seek` and `.read` calls, since the
          prefetch machinery is used to retrieve all the requested blocks at
          once.
  
          :param chunks:
              a list of ``(offset, length)`` tuples indicating which sections of
              the file to read
          :return: a list of blocks read, in the same order as in ``chunks``
  
          .. versionadded:: 1.5.4