'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'

def write(self, data):

    if self._closed:
        raise ValueError('cannot    write    to    a    closed    file')
    try:
        read = data.read
    except AttributeError:
        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):
        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
        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)
