code: def read_into(self, buf: bytearray, partial: bool = False) -> Awaitable[int]:
          
          future = self._start_read()
  
          # First copy data already in read buffer
          available_bytes = self._read_buffer_size
          n = len(buf)
          if available_bytes >= n:
              end = self._read_buffer_pos + n
              buf[:] = memoryview(self._read_buffer)[self._read_buffer_pos : end]
              del self._read_buffer[:end]
              self._after_user_read_buffer = self._read_buffer
          elif available_bytes > 0:
              buf[:available_bytes] = memoryview(self._read_buffer)[
                  self._read_buffer_pos :
              ]
  
          # Set up the supplied buffer as our temporary read buffer.
          # The original (if it had any data remaining) has been
          # saved for later.
          self._user_read_buffer = True
          self._read_buffer = buf
          self._read_buffer_pos = 0
          self._read_buffer_size = available_bytes
          self._read_bytes = n
          self._read_partial = partial
  
          try:
              self._try_inline_read()
          except:
              future.add_done_callback(lambda f: f.exception())
              raise
          return future
docs: Asynchronously read a number of bytes.
  
          ``buf`` must be a writable buffer into which data will be read.
  
          If ``partial`` is true, the callback is run as soon as any bytes
          have been read.  Otherwise, it is run when the ``buf`` has been
          entirely filled with read data.
  
          .. versionadded:: 5.0
  
          .. versionchanged:: 6.0
  
             The ``callback`` argument was removed. Use the returned
             `.Future` instead.