Coerce writes to bytes, while avoiding str.encode's common UnicodeDecodeError

example_usage.py

import sys, unicode_io

sys.stdout = unicode_io.IOWrapper(sys.stdout)

unicode_io.py

import sys, io

PY_3 = sys.version_info.major > 2

if PY_3:
    text_type = str
    string_types = str,
    # memoryview = memoryview
    buffer_types = (bytes, bytearray, memoryview)
else:
    text_type = unicode
    string_types = basestring,
    memoryview = buffer
    buffer_types = (bytearray, memoryview)

def _to_bytes(s, encoding):
    if isinstance(s, bytes):
        if encoding == 'utf-8':
            return s
        else:
            return s.decode('utf-8').encode(encoding)

    if isinstance(s, memoryview):
        return bytes(s)

    if not isinstance(s, string_types):
        if PY_3:
            return text_type(s).encode(encoding)
        else:
            return bytes(s)
    else:
        return s.encode(encoding)

class IOWrapper(object):
    def __init__(self, out, encoding='utf-8'):
        self._out = out
        self._encoding = encoding

    def _b(self, value):
        return _to_bytes(value, self._encoding)

    def write(self, value):
        self._out.write(self._b(value))

    def writelines(self, sequence):
        for line in sequence:
            self._out.write(line)

    def fileno(self):
        return self._out.fileno()

    def flush(self):
        self._out.flush()

    @property
    def mode(self):
        return self._out.mode

    @property
    def name(self):
        return self._out.name

    @property
    def newlines(self):
        return self._out.newlines

    def next(self):
        return self._out.next()

    def read(self, size=None):
        return self._out.read(size=size)

    def readinto(self, buffer):
        return self._out.readinto(buffer)

    def readline(self, limit=-1):
        return self._out.readline(limit=limit)

    def readlines(self, hint=-1):
        return self.readlines(hint=hint)

    def seek(self, offset, whence=io.SEEK_SET):
        return self._out.seek(offset, whence=whence)

    @property
    def softspace(self):
        return self._out.softspace

    def tell(self):
        return self._out.tell()

    def truncate(self):
        return self._out.truncate()

    def xreadlines(self):
        return self._out.xreadlines()