code: def _read_to_buffer(self) -> Optional[int]:
          
          try:
              while True:
                  try:
                      if self._user_read_buffer:
                          buf = memoryview(self._read_buffer)[
                              self._read_buffer_size :
                          ]  # type: Union[memoryview, bytearray]
                      else:
                          buf = bytearray(self.read_chunk_size)
                      bytes_read = self.read_from_fd(buf)
                  except (socket.error, IOError, OSError) as e:
                      if errno_from_exception(e) == errno.EINTR:
                          continue
                      # ssl.SSLError is a subclass of socket.error
                      if self._is_connreset(e):
                          # Treat ECONNRESET as a connection close rather than
                          # an error to minimize log spam  (the exception will
                          # be available on self.error for apps that care).
                          self.close(exc_info=e)
                          return None
                      self.close(exc_info=e)
                      raise
                  break
              if bytes_read is None:
                  return 0
              elif bytes_read == 0:
                  self.close()
                  return 0
              if not self._user_read_buffer:
                  self._read_buffer += memoryview(buf)[:bytes_read]
              self._read_buffer_size += bytes_read
          finally:
              # Break the reference to buf so we don't waste a chunk's worth of
              # memory in case an exception hangs on to our stack frame.
              del buf
          if self._read_buffer_size > self.max_buffer_size:
              gen_log.error("Reached maximum read buffer size")
              self.close()
              raise StreamBufferFullError("Reached maximum read buffer size")
          return bytes_read
docs: Reads from the socket and appends the result to the read buffer.
  
          Returns the number of bytes read.  Returns 0 if there is nothing
          to read (i.e. the read returns EWOULDBLOCK or equivalent).  On
          error closes the socket and raises an exception.