The io library rejects unbuffered text I/O, but this is not documented - and in fact can be manually worked around:
    binstdout = io.open(sys.stdout.fileno(), 'wt', 0)
    sys.stdout = io.TextIOWrapper(binstdout, encoding=sys.stdout.encoding)
will get a sys.stdout that is unbuffered.

Note that writing to a pipe doesn't really need to care about buffering anyway, if the user writes 300 characters, the codec will output a single block and the IO made will be one write:

This test script:
import sys
import io
stream = io.TextIOWrapper(io.open(sys.stdout.fileno(), 'wb', 0), encoding='utf8')
for r in range(10):
  stream.write(u'\u1234'*500)

When run under strace -c does exactly 10 writes: so the performance is predictable. IMO it doesn't make sense to prohibit unbuffered text write I/O. readers may be another matter, but that doesn't suffer the same latency issues.

The proposed workaround seems to work ("wb" instead of "wt"!), with the following restrictions:

- it's not really unbuffered: the encoder has its own buffers (OK, in the stdlib only 'idna' encoding will retain data)

- it won't work for reading: TextIOWrapper calls the read1() method, which is only defined by BufferedIO objects.

IMO this explains why it's not a supported combination in io.open().

Huh, I didn't realise idna would retain data! But that will still be within the TextIOWrapper itself, right?

And a stream opened 'wt' cannot be read from anyway, so the read1 limitation is irrelevant.

> But that will still be within the TextIOWrapper itself, right?

Yes. And I just noticed that the _io module (the C version) will also buffer encoded bytes, up to f._CHUNK_SIZE.

On the other hand, TextIOWrapper is broken for buffering codecs, encode() is never called with final=True

    >>> import io
    >>> buffer = io.BytesIO()      # <-- not really buffered, right?
    >>> output = io.TextIOWrapper(buffer, encoding='idna')
    >>> output.write("www.somesite.com")
    16
    >>> print(buffer.getvalue())
    b''                            # <-- ok, _CHUNK_SIZE buffering
    >>> output.flush()
    >>> print(buffer.getvalue())
    b'www.somesite.'               # <-- the last word is missing!
    >>> output.close()
    >>> print(buffer.getvalue())
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ValueError: I/O operation on closed file.


And it's even worse with python 2.7::

    >>> import io as io
    >>> buffer = io.BytesIO()
    >>> output = io.TextIOWrapper(buffer, encoding='idna')
    >>> output.write("www.somesite.com")
    Traceback (most recent call last):
      File "<stdin>", line 3, in <module>
    TypeError: must be unicode, not str

> - it won't work for reading: TextIOWrapper calls the read1() method, which is only defined by BufferedIO objects.

Since 3.3 TextIOWrapper works with raw IO objects (issue12591).

> Yes. And I just noticed that the _io module (the C version) will also buffer encoded bytes, up to f._CHUNK_SIZE.

Use write_through=True to disable this.

> > - it won't work for reading: TextIOWrapper calls the read1()
> > method, which is only defined by BufferedIO objects.
> 
> Since 3.3 TextIOWrapper works with raw IO objects (issue12591).

It won't be technically unbuffered, though.

It is documented that buffering=0 is not supported in text mode. Look a handful of paragraphs down from <https://docs.python.org/release/3.7.2/library/functions.html#open>:

“Pass 0 to switch buffering off (only allowed in binary mode)”

Amaury’s problem with the IDNA buffering encoder has now been reported separately in Issue 35611.