As to 2. – it seems that io.TextIOWrapper in CPython cannot be created with an object that does not implement readable(), writable() and seekable() methods (and a closed attribute), so we should check for them when creating the TextIOWrapper ourselves. That means that BufferedReader and BufferedWriter need to implement them.

What’s interesting, TextIOWrapper depends on the value returned by them at the initialization and disregards later changes, so if the wrapper value returns True from writable() at the initialization, it will be treated as such until closed, and also the wrapper has some internal buffering, see:

>>> class PseudoFile:
...   def write(self, buf):
...     print(f'printing buffer: {buf.decode("utf-8")}')
...     return 4
...   def read(self):
...     return b'a'
...   def flush(self):
...     print('flushing')
...   def readable(self):
...     return True
...   def writable(self):
...     res = self._num == 0
...     self._num += 1
...     return res
...   def seekable(self):
...     return False
...   def __init__(self):
...     self.closed = False
...     self._num = 0
... 
>>> 
>>> pseudoWrapper = io.TextIOWrapper(PseudoFile())
>>> pseudoWrapper.buffer.writable()
False
>>> pseudoWrapper.write('noël')
5
>>> pseudoWrapper.write('noël')
5
>>> pseudoWrapper.flush()
printing buffer: noëlnoël
flushing

Also, the TextIOWrapper seems to always return the length of the string written (in unicode code points, hence the string noël has length 5, even though it is 4 graphemes encoded in 6 bytes – it uses two codepoints for ë), and doesn’t care that the wrapped writer always reports that it has written only 4 bytes (see the def write(self) in PseudoFile), which would make a corrupt, non-unicode, string here. It doesn’t try to re-write the not-yet-written bytes, and doesn’t throw any exception on the wrong number.

@silmeth is this resolved now? There have been a fair amount of io module changes since this was opened, but I'm not sure if they addressed what you discussed here.

It seems it is not. There is some progress (eg. files are opened by default in text, not binary, mode, as before), but still:

• files are not closeable,
• TextIOWrapper is not writable (done in make TextIOBase writable, handle malformed utf-8 in read() #1119),
• fileno is a property.

(and I believe the other two are also still true but didn’t test them, they are lower priority anyway, and the last one is not IO-specific)

Run on master, commit f34f16b2cc0422116f9044df1f4818bcc6941a4c:

% RUSTPYTHONPATH=~/Projekty/RustPython/Lib cargo run --release
    Finished release [optimized] target(s) in 0.18s
     Running `target/release/rustpython`
Welcome to the magnificent Rust Python 0.0.1 interpreter 😱 🖖
>>>>> # Correct text mode (with TextIOWrapper):
>>>>> file = open('/tmp/tst', 'w')
>>>>> file
<TextIOWrapper object at 0x560ef58f43e0>
>>>>> 
>>>>> # No writing for text files:
>>>>> file.write('\ntest string')
Traceback (most recent call last):
  File "<stdin>", line 0, in <module>
AttributeError: "'TextIOWrapper' object has no attribute 'write'"
>>>>> 
>>>>> # No closing:
>>>>> file.close()
Traceback (most recent call last):
  File "<stdin>", line 0, in <module>
AttributeError: "'TextIOWrapper' object has no attribute 'close'"
>>>>> file.buffer.close()
Traceback (most recent call last):
  File "<stdin>", line 0, in <module>
AttributeError: "'BufferedWriter' object has no attribute 'close'"
>>>>> file.buffer.raw.close()
Traceback (most recent call last):
  File "<stdin>", line 0, in <module>
AttributeError: "'FileIO' object has no attribute 'close'"
>>>>> 
>>>>> # fileno is still a property, not a method:
>>>>> file.buffer.raw.fileno
3

cf. with CPython 3.7:

% python3
Python 3.7.3 (default, Apr  3 2019, 05:39:12) 
[GCC 8.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> file = open('/tmp/tst', 'w')
>>> file
<_io.TextIOWrapper name='/tmp/tst' mode='w' encoding='UTF-8'>
>>> file.write('\ntest string')
12
>>> file.buffer.close()
>>> file.close()
>>> file.buffer.raw.fileno
<built-in method fileno of _io.FileIO object at 0x7f4eb195fc60>

it seems close is now implemented. can someone check this issue is done or not?

Step 2 works:

Welcome to the magnificent Rust Python 0.1.2 interpreter 😱 🖖
>>>>> file = open('/tmp/tst', 'wt')
>>>>> file.write('\ntest string')
12
>>>>> 

Writing w/o text mode works

Welcome to the magnificent Rust Python 0.1.2 interpreter 😱 🖖
>>>>> file = open('/tmp/tst', 'w')
>>>>> file.write('\ntest string')
12

Closing buffers etc. works

>>>>> file.buffer
<_io.BufferedWriter name='/tmp/tst'>
>>>>> file.buffer.close()
>>>>> file.buffer.raw
<FileIO object at 0x56000ba4ebb0>
>>>>> file.buffer.raw.close()

fileno is a method now rather than a property

>>>>> file.buffer.raw.fileno
<bound method of <FileIO object at 0x56000ba4ebb0>>

The behavior file.raw for both implementations is completely different from what was originally documented in this issue and is now identical between cPython and RustPython. It appears that in newer versions of Python you cannot access the raw buffer at all, so none of the modifications in step 4 and 5 are possible.

>>>>> file.raw
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'TextIOWrapper' object has no attribute 'raw'

>>> file.raw
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: '_io.TextIOWrapper' object has no attribute 'raw'

The Python documentation says:

raw

The underlying raw stream (a RawIOBase instance) that BufferedIOBase deals with. This is not part of the BufferedIOBase API and may not exist on some implementations.

Given all of this, I think the issue can be closed.

@youknowone ^

Thank you for confirming!