File size: 5,177 Bytes
065fee7 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 |
.. _aiohttp-streams:
Streaming API
=============
.. currentmodule:: aiohttp
``aiohttp`` uses streams for retrieving *BODIES*:
:attr:`aiohttp.web.BaseRequest.content` and
:attr:`aiohttp.ClientResponse.content` are properties with stream API.
.. class:: StreamReader
The reader from incoming stream.
User should never instantiate streams manually but use existing
:attr:`aiohttp.web.BaseRequest.content` and
:attr:`aiohttp.ClientResponse.content` properties for accessing raw
BODY data.
Reading Methods
---------------
.. method:: StreamReader.read(n=-1)
:async:
Read up to *n* bytes. If *n* is not provided, or set to ``-1``, read until
EOF and return all read bytes.
If the EOF was received and the internal buffer is empty, return an
empty bytes object.
:param int n: how many bytes to read, ``-1`` for the whole stream.
:return bytes: the given data
.. method:: StreamReader.readany()
:async:
Read next data portion for the stream.
Returns immediately if internal buffer has a data.
:return bytes: the given data
.. method:: StreamReader.readexactly(n)
:async:
Read exactly *n* bytes.
Raise an :exc:`asyncio.IncompleteReadError` if the end of the
stream is reached before *n* can be read, the
:attr:`asyncio.IncompleteReadError.partial` attribute of the
exception contains the partial read bytes.
:param int n: how many bytes to read.
:return bytes: the given data
.. method:: StreamReader.readline()
:async:
Read one line, where “line” is a sequence of bytes ending
with ``\n``.
If EOF is received, and ``\n`` was not found, the method will
return the partial read bytes.
If the EOF was received and the internal buffer is empty, return an
empty bytes object.
:return bytes: the given line
.. method:: StreamReader.readuntil(separator="\n")
:async:
Read until separator, where `separator` is a sequence of bytes.
If EOF is received, and `separator` was not found, the method will
return the partial read bytes.
If the EOF was received and the internal buffer is empty, return an
empty bytes object.
.. versionadded:: 3.8
:return bytes: the given data
.. method:: StreamReader.readchunk()
:async:
Read a chunk of data as it was received by the server.
Returns a tuple of (data, end_of_HTTP_chunk).
When chunked transfer encoding is used, end_of_HTTP_chunk is a :class:`bool`
indicating if the end of the data corresponds to the end of a HTTP chunk,
otherwise it is always ``False``.
:return tuple[bytes, bool]: a chunk of data and a :class:`bool` that is ``True``
when the end of the returned chunk corresponds
to the end of a HTTP chunk.
Asynchronous Iteration Support
------------------------------
Stream reader supports asynchronous iteration over BODY.
By default it iterates over lines::
async for line in response.content:
print(line)
Also there are methods for iterating over data chunks with maximum
size limit and over any available data.
.. method:: StreamReader.iter_chunked(n)
:async:
Iterates over data chunks with maximum size limit::
async for data in response.content.iter_chunked(1024):
print(data)
.. method:: StreamReader.iter_any()
:async:
Iterates over data chunks in order of intaking them into the stream::
async for data in response.content.iter_any():
print(data)
.. method:: StreamReader.iter_chunks()
:async:
Iterates over data chunks as received from the server::
async for data, _ in response.content.iter_chunks():
print(data)
If chunked transfer encoding is used, the original http chunks formatting
can be retrieved by reading the second element of returned tuples::
buffer = b""
async for data, end_of_http_chunk in response.content.iter_chunks():
buffer += data
if end_of_http_chunk:
print(buffer)
buffer = b""
Helpers
-------
.. method:: StreamReader.exception()
Get the exception occurred on data reading.
.. method:: is_eof()
Return ``True`` if EOF was reached.
Internal buffer may be not empty at the moment.
.. seealso::
:meth:`StreamReader.at_eof()`
.. method:: StreamReader.at_eof()
Return ``True`` if the buffer is empty and EOF was reached.
.. method:: StreamReader.read_nowait(n=None)
Returns data from internal buffer if any, empty bytes object otherwise.
Raises :exc:`RuntimeError` if other coroutine is waiting for stream.
:param int n: how many bytes to read, ``-1`` for the whole internal
buffer.
:return bytes: the given data
.. method:: StreamReader.unread_data(data)
Rollback reading some data from stream, inserting it to buffer head.
:param bytes data: data to push back into the stream.
.. warning:: The method does not wake up waiters.
E.g. :meth:`~StreamReader.read()` will not be resumed.
.. method:: wait_eof()
:async:
Wait for EOF. The given data may be accessible by upcoming read calls.
|