docs: def _flush(self, buffer, start, end):
          """
          Flush the write buffer of the stream if applicable.
  
          Args:
              buffer (memoryview): Buffer content.
              start (int): Start of buffer position to flush.
                  Supported only with page blobs.
              end (int): End of buffer position to flush.
                  Supported only with page blobs.
          """
          buffer_size = len(buffer)
          if not buffer_size:
              return
  
          # Write range normally
          with self._size_lock:
              if end > self._size:
                  # Require to resize the blob if note enough space
                  with _handle_azure_exception():
                      self._resize(content_length=end, **self._client_kwargs)
                  self._reset_head()
  
          if buffer_size > self.MAX_FLUSH_SIZE:
              # Too large buffer, needs to split in multiples requests
              futures = []
              for part_start in range(0, buffer_size, self.MAX_FLUSH_SIZE):
  
                  # Split buffer
                  buffer_part = buffer[
                        part_start:part_start + self.MAX_FLUSH_SIZE]
                  if not len(buffer_part):
                      # No more data
                      break
  
                  # Upload split buffer in parallel
                  start_range = start + part_start
                  futures.append(self._workers.submit(
                      self._update_range, data=buffer_part.tobytes(),
                      start_range=start_range,
                      end_range=start_range + len(buffer_part) - 1,
                      **self._client_kwargs))
  
              with _handle_azure_exception():
                  # Wait for upload completion
                  for future in _as_completed(futures):
                      future.result()
  
          else:
              # Buffer lower than limit, do one requests.
              with _handle_azure_exception():
                  self._update_range(
                      data=buffer.tobytes(), start_range=start,
                      end_range=end - 1, **self._client_kwargs)