docs: def write(self, data):
          """Write data to the file. There is no return value.
  
          `data` can be either a string of bytes or a file-like object
          (implementing :meth:`read`). If the file has an
          :attr:`encoding` attribute, `data` can also be a
          :class:`unicode` (:class:`str` in python 3) instance, which
          will be encoded as :attr:`encoding` before being written.
  
          Due to buffering, the data may not actually be written to the
          database until the :meth:`close` method is called. Raises
          :class:`ValueError` if this file is already closed. Raises
          :class:`TypeError` if `data` is not an instance of
          :class:`str` (:class:`bytes` in python 3), a file-like object,
          or an instance of :class:`unicode` (:class:`str` in python 3).
          Unicode data is only allowed if the file has an :attr:`encoding`
          attribute.
  
          :Parameters:
            - `data`: string of bytes or file-like object to be written
              to the file
          """
          if self._closed:
              raise ValueError("cannot write to a closed file")
  
          try:
              # file-like
              read = data.read
          except AttributeError:
              # string
              if not isinstance(data, (text_type, bytes)):
                  raise TypeError("can only write strings or file-like objects")
              if isinstance(data, text_type):
                  try:
                      data = data.encode(self.encoding)
                  except AttributeError:
                      raise TypeError("must specify an encoding for file in "
                                      "order to write %s" % (text_type.__name__,))
              read = StringIO(data).read
  
          if self._buffer.tell() > 0:
              # Make sure to flush only when _buffer is complete
              space = self.chunk_size - self._buffer.tell()
              if space:
                  try:
                      to_write = read(space)
                  except:
                      self.abort()
                      raise
                  self._buffer.write(to_write)
                  if len(to_write) < space:
                      return  # EOF or incomplete
              self.__flush_buffer()
          to_write = read(self.chunk_size)
          while to_write and len(to_write) == self.chunk_size:
              self.__flush_data(to_write)
              to_write = read(self.chunk_size)
          self._buffer.write(to_write)