This module contains additional types of
stream (file-like) objects
and helper functions.
Difference to CPython
Conceptual hierarchy of stream base classes is simplified in Pycopy, as described in this section.
(Abstract) base stream classes, which serve as a foundation for behavior of all the concrete classes, adhere to few dichotomies (pair-wise classifications) in CPython. In Pycopy, they are somewhat simplified and made implicit to achieve higher efficiencies and save resources.
An important dichotomy in CPython is unbuffered vs buffered streams. In
Pycopy, all streams are unbuffered by default. This is because all
modern OSes, and even many RTOSes and filesystem drivers already perform
buffering on their side. Adding another layer of buffering is counter-
productive (an issue known as “bufferbloat”) and takes precious memory.
Note that there are still cases where buffering may be useful, so
BufferedWriter classes are provided in
some Pycopy ports.
But in CPython, another important dichotomy is tied with “bufferedness” - it is whether a stream may incur short read/writes or not. A short read is when a user asks e.g. 10 bytes from a stream, but gets less, similarly for writes. In CPython, unbuffered streams are automatically susceptible to short operations, while buffered are guaranteed against them. The “no short read/writes” is an important trait, as it allows to develop more concise and efficient programs - something which is highly desirable for Pycopy. So, while Pycopy doesn’t support buffered streams, it still provides for no-short-operations streams. Whether there will be short operations or not depends on each particular class’ needs, but developers are strongly advised to favor no-short-operations behavior for the reasons stated above. For example, Pycopy sockets are guaranteed to avoid short read/writes (for blocking operations - see below). Actually, at this time, there is no example of a short-operations (blocking) stream class in the core, and one would be a port-specific class, where such a need is governed by hardware peculiarities.
The no-short-operations behavior gets tricky in case of non-blocking streams, blocking vs non-blocking behavior being another CPython dichotomy, fully supported by Pycopy. Non-blocking streams never wait for data either to arrive or be written - they read/write whatever possible, or signal lack of data (or lack of ability to write data). Clearly, this conflicts with “no-short-operations” policy, and indeed, a case of non-blocking buffered (and thus no-short-ops) streams is convoluted in CPython - in some places, such combination is prohibited, in some it’s undefined or just not documented, in some cases it raises verbose exceptions. The matter is much simpler in Pycopy: non-blocking stream are important for efficient asynchronous operations, so this property prevails the “no-short-ops” one. So, while blocking streams will avoid short reads/writes whenever possible (the only case to get a short read is if the end of file is reached, or in a case of error (but errors don’t return short data, but raise exceptions)), non-blocking streams may produce short data to avoid blocking the operation.
The final dichotomy is binary vs text streams. Pycopy of course supports these, but while in CPython text streams are inherently buffered, they aren’t necessarily in Pycopy. (Indeed, that’s one of the cases for which buffering may be useful.)
Note that for efficiency, Pycopy doesn’t provide abstract base classes corresponding to the hierarchy above, and it’s not possible to implement, or subclass, a stream class in pure Python.
Abstract stream interface¶
Warning: AbstractStream is an implied abstract class, described here for illustrative purposes. There is no actual class with this name, but all other stream classes implement subset of the functionality described here.
Read size bytes or characters from the stream, or until EOF if size is -1 or not specified. Return
byteswith the data read. Return
Noneif stream is in non-blocking mode and no data is available.
Read a line (sequence of bytes or characters) from the stream until
'\n'character is seen (or until EOF, or until no more data is available in non-blocking mode). The line, with
'\n'included, is returned. If positional maxsize argument is provided, at most maxsize bytes are read (in which case the returned string might not end with
'\n'). If stream is in non-blocking mode and no data available,
Read bytes into a buf
buffer. The size of data read is equal to the size of buffer (unless EOF/lack of non-blocking data occurs first), unless maxsize is specified, which allows to read less data. Returns number of bytes actually read. This method is available only for binary streams.
Pycopy extension: buf can be a
BytesIOobject. Data will be written at the current offset of the BytesIO object, and up to remaining allocation size of data will be written, in other words, this operation will not grow the internal buffer of BytesIO object.
Writes to the stream data, which should be
strfor text streams, or arbitrary
bufferfor binary streams. Returns number of items (bytes or characters) actually written, or
Noneif non-blocking stream could not accept any data.
write(data, offset, size)
Pycopy extension: write a substring of data, starting at offset (or 0), and with the given size. For example,
write(b'12345', 1, 2)will write
b'23'to the stream. These methods are useful as an optimization when working with short-write streams (e.g., non-blocking streams), to avoid slicing or creating
memoryviewobject to write the remaining chunk of data.
Flush any data or metadata, cached internally (in Pycopy objects) or externally (e.g. in OS) to the underlying medium. For example, for files, all data will be written to disk, for network streams - data will be sent over network, etc.
Close the stream. No other operations on stream are possible after the closure (will lead to error or underfines behavior). However, the close() operation itself should be idempotent, i.e. it should be possible to call it multiple times without an error (2nd and following calls should not lead to any effect).
Move internal stream offset pointer for random-access streams. Read/write operations are performed from the position specified by this pointer. whence parameter can be:
- 0 - offset is against the start of stream (known as SEEK_SET)
- 1 - offset is against the current positions (known as SEEK_CUR)
- 2 - offset is against the end of stream (known as SEEK_END)
Note that the symbolic names (SEEK_SET/SEEK_CUR/SEEK_END) are NOT provided by the
uiomodule, to minimize the code size. Instead, well-known values 0, 1, 2 can be used. Your application may define these symbolic names itself, or use
pycopy-libwhich provides them.
This method is available only for random-access streams.
Resize the stream to the given size, or the current stream position if size is not provided. Note that this operation can both grow and shrink stream with respect to its current size. This method is available only for random-access streams.
If val is
False, the stream is swtiched to non-blocking mode. Otherwise, if
True, it is switched to blocking mode.
Set timeout for stream operations. This is generalization of
setblocking()method. If val is 0, the stream is switched to non-blocking mode. if val is
None, the stream is switched to blocking mode. Otherwise, val represents a timeout in seconds for stream operations. If an operation is not completed in the time alloted,
This is type of a file open in binary mode, e.g. using
open(name, "rb"). You should not instantiate this class directly.
This is type of a file open in text mode, e.g. using
open(name, "rt"). You should not instantiate this class directly.
In-memory file-like objects for input/output.
StringIOis used for text-mode I/O (similar to a normal file opened with “t” modifier).
BytesIOis used for binary-mode I/O (similar to a normal file opened with “b” modifier). Initial contents of file-like objects can be specified with string parameter (should be normal string for
StringIOor bytes object for
BytesIO). All the usual file methods like
close()are available on these objects, and additionally, following methods:
Get the current contents of the underlying buffer which holds data.
+=operator.) This is equivalent to
write()method, but gives syntax similar to string
+=operator. Usage example:
# Don't do it like this, it's *very* slow. buf = "" for i in range(50000): buf += "a" print(buf) # Instead, do it like this, this is both fast and efficient of # memory. buf = uio.StringIO() for i in range(50000): buf += "a" print(buf.getvalue())
Difference to CPython
This method is a Pycopy extension.
Create an empty
BytesIOobject, preallocated to hold up to alloc_size number of bytes. That means that writing that amount of bytes won’t lead to reallocation of the buffer, and thus won’t hit out-of-memory situation or lead to memory fragmentation. These constructors are a Pycopy extension and are recommended for usage only in special cases and in system-level libraries, not for end-user applications.
Difference to CPython
These constructors are a Pycopy extension.