docs: def _read_bytes_from_framed_body(self, b):
          """Reads the requested number of bytes from a streaming framed message body.
  
          :param int b: Number of bytes to read
          :returns: Bytes read from source stream and decrypted
          :rtype: bytes
          """
          plaintext = b""
          final_frame = False
          _LOGGER.debug("collecting %d bytes", b)
          while len(plaintext) < b and not final_frame:
              _LOGGER.debug("Reading frame")
              frame_data, final_frame = deserialize_frame(
                  stream=self.source_stream, header=self._header, verifier=self.verifier
              )
              _LOGGER.debug("Read complete for frame %d", frame_data.sequence_number)
              if frame_data.sequence_number != self.last_sequence_number + 1:
                  raise SerializationError("Malformed message: frames out of order")
              self.last_sequence_number += 1
              aad_content_string = aws_encryption_sdk.internal.utils.get_aad_content_string(
                  content_type=self._header.content_type, is_final_frame=frame_data.final_frame
              )
              associated_data = assemble_content_aad(
                  message_id=self._header.message_id,
                  aad_content_string=aad_content_string,
                  seq_num=frame_data.sequence_number,
                  length=len(frame_data.ciphertext),
              )
              plaintext += decrypt(
                  algorithm=self._header.algorithm,
                  key=self._derived_data_key,
                  encrypted_data=frame_data,
                  associated_data=associated_data,
              )
              plaintext_length = len(plaintext)
              _LOGGER.debug("bytes collected: %d", plaintext_length)
          if final_frame:
              _LOGGER.debug("Reading footer")
              self.footer = deserialize_footer(stream=self.source_stream, verifier=self.verifier)
  
          return plaintext