docs: def _write2(self, data, multithread=True, **kwargs):
          '''
          :param data: Data to be written
          :type data: str or mmap object
          :param multithread: If True, sends multiple write requests asynchronously
          :type multithread: boolean
  
          Writes the data *data* to the file.
  
          .. note::
  
              Writing to remote files is append-only. Using :meth:`seek`
              does not affect where the next :meth:`write` will occur.
  
          '''
          if not USING_PYTHON2:
              assert(isinstance(data, bytes))
  
          self._ensure_write_bufsize(**kwargs)
  
          def write_request(data_for_write_req):
              if multithread:
                  self._async_upload_part_request(data_for_write_req, index=self._cur_part, **kwargs)
              else:
                  self.upload_part(data_for_write_req, self._cur_part, **kwargs)
              self._cur_part += 1
  
          if self._write_buf.tell() == 0 and self._write_bufsize == len(data):
              # In the special case of a write that is the same size as
              # our write buffer size, and no unflushed data in the
              # buffer, just directly dispatch the write and bypass the
              # write buffer.
              #
              # This saves a buffer copy, which is especially helpful if
              # 'data' is actually mmap'd from a file.
              #
              # TODO: an additional optimization could be made to allow
              # the last request from an mmap'd upload to take this path
              # too (in general it won't because it's not of length
              # _write_bufsize). This is probably inconsequential though.
              write_request(data)
              return
  
          remaining_space = self._write_bufsize - self._write_buf.tell()
  
          if len(data) <= remaining_space:
              self._write_buf.write(data)
          else:
              self._write_buf.write(data[:remaining_space])
  
              temp_data = self._write_buf.getvalue()
              self._write_buf = BytesIO()
              write_request(temp_data)
  
              # TODO: check if repeat string splitting is bad for
              # performance when len(data) >> _write_bufsize
              self.write(data[remaining_space:], **kwargs)