Upgrading aiohttp 2 to 3
Breaking2.3.10 → 3.14.5Breaking84Security67Platform11Deprecated28New167Changed222Fixed504Other264
SecuritySet-Cookie parsing now sets exactly one cookie per header and ignores unrecognized attributes, per RFC 6265.#13800 ↗
BreakingUpgrade verdict
78 breaking changes and 10 platform requirement changes and 64 security fixes.
In plain terms
- Each Set-Cookie header now yields exactly one cookie. Extra name=value pairs and unknown attributes are ignored, a leading pair like Path=/ is treated as the cookie itself, and legacy $Path and $Domain attributes are ignored.
- Brotli decompression now has a default size limit of 32MiB per call, and older Brotli libraries are no longer supported.
- The is_ipv6_address and is_ip4_address helper functions have been removed.
- Connections now give up on a host after 30 seconds by default, so the client can move on to the next host instead of hanging.
Must act Top 5 of 179 that need code or config changes
Python requirement changed in 3.14.0: >=3.4.2 → >=3.10.
Adds aiohappyeyeballs >=2.5.0, aiosignal >=1.4.0, attrs >=17.3.0, frozenlist >=1.1.1, multidict <8.0,>=4.5, propcache >=0.2.0, yarl <2.0,>=1.25.1.
Installs 8 packages in all (was 0).
What you must change
Breaking78
Set-Cookie parsing now creates exactly one cookie per field as RFC 6265 and browsers do; extra name=value pairs and unknown attributes no longer create cookies.
Set-Cookie$Path$Domain$VersionRaises Brotli and brotlicffi minimum version to 1.2 and caps decompression output at 32MiB per call by default.
BrotlibrotlicffiRemoves the is_ipv6_address and is_ip4_address helpers as they are no longer used.
is_ipv6_addressis_ip4_addressFixes failure to try the next host after a single-host connection timeout by adding a default 30 second sock_connect timeout to ClientTimeout.
aiohttp.ClientTimeoutsock_connectRemoves the set_current_app method from UrlMappingMatchInfo as part of improved middleware performance.
set_current_appUrlMappingMatchInfoRemoves Request.wait_for_disconnection(), which was mistakenly added briefly in 3.10.0.
Request.wait_for_disconnection()Removes Signal from __all__ and replaces aiohttp.Signal with aiosignal.Signal in docs.
Signal__all__aiohttp.Signalaiosignal.SignalStaticResource prefixes no longer match URLs with a non-folder prefix, so routes.static('/foo', '/foo') no longer matches /foobar.
StaticResourceroutes.static()Removes the deprecated loop argument from asyncio.sleep and asyncio.gather calls.
asyncio.sleepasyncio.gatherloopMakes BaseConnector.close() a coroutine that waits for all connections to close and drops the deprecated with Connector() syntax.
BaseConnector.close()Connector()Drops the dead Connection.detach() and Connection.writer, both broken for more than 2 years.
Connection.detach()Connection.writerDrops loop.current_task() from helpers.current_task().
helpers.current_task()loop.current_task()Drops the reader parameter from request.multipart().
request.multipart()readerRefactors the ClientResponse constructor to make logically required arguments mandatory and drops the _post_init() method.
ClientResponse_post_init()Drops the removed functionality for passing StreamReader as data on the client side.
StreamReaderRemoves many previously deprecated features in this major release.
Drops StreamReaderPayload and DataQueuePayload.
StreamReaderPayloadDataQueuePayloadDrops md5 and sha1 finger-prints.
md5sha1Drops WSMessage.tp.
WSMessage.tpDrops aiohttp.Timeout in favor of async_timeout.timeout.
aiohttp.Timeoutasync_timeout.timeoutDrops the resolve parameter from TCPConnector.
TCPConnectorresolveRemoves StreamResponse.drain() from the public API and converts StreamResponse.write to an async function.
StreamResponse.drain()StreamResponse.writeDrops the deprecated slow_request_timeout param and **kwargs from RequestHandler.
RequestHandlerslow_request_timeout**kwargsDrops the deprecated resource.url().
resource.url()Removes the %u and %l format specifiers from the access log format.
%u%lDrops the deprecated request.GET property.
request.GETDrops access to TCP tuning options from PayloadWriter and Response classes.
PayloadWriterResponseDrops the deprecated encoding parameter from the client API.
encodingRemoves the legacy StreamWriter class.
StreamWriterDrops the
resp = await aiohttp.request(...) syntax in favor of async with aiohttp.request(...) as resp:.aiohttp.request()Renames PayloadWriter to StreamWriter.
PayloadWriterStreamWriterDrops StreamReaderPayload and DataQueuePayload.
StreamReaderPayloadDataQueuePayloadDrops md5 and sha1 finger-prints.
md5sha1Drops the WSMessage.tp attribute.
WSMessage.tpDrops aiohttp.Timeout in favor of async_timeout.timeout.
aiohttp.Timeoutasync_timeout.timeoutDrops the resolve parameter from TCPConnector.
TCPConnectorresolveRemoves StreamResponse.drain() from the public API and converts StreamResponse.write to an async function.
StreamResponse.drain()StreamResponse.writeDrops the deprecated slow_request_timeout parameter and **kwargs from RequestHandler.
RequestHandlerslow_request_timeoutDrops the deprecated resource.url().
resource.url()Removes the %u and %l format specifiers from the access log format.
%u%lDrops the deprecated request.GET property.
request.GETDrops access to TCP tuning options from PayloadWriter and Response classes.
PayloadWriterResponseDrops the deprecated encoding parameter from the client API.
encodingRemoves the legacy StreamWriter class.
StreamWriterDrops the
resp = await aiohttp.request(...) syntax in favor of async with aiohttp.request(...) as resp:.aiohttp.request()WebSocket receive queue now holds only a weak reference to WebSocketReader while parsing is stalled; direct constructors must keep a strong reference.
WebSocketReaderset_parser()Removes the internal writer proxy for upload progress; AbstractStreamWriter gains an optional on_body_write callback that write() and write_eof() must invoke.
AbstractStreamWriteron_body_writewrite()write_eof()Payload.bytes_writtenTCPConnector now rejects legacy non-canonical numeric IPv4 host forms such as 2130706433, 017700000001 and 127.1 with InvalidUrlClientError.
TCPConnectorInvalidUrlClientErrorStops calling socket.getfqdn as fallback for BaseRequest.host; falls back to transport sockname or empty string.
socket.getfqdnaiohttp.web.BaseRequest.hostsocknameTightens outbound header serialization to reject ASCII control characters 0x00-0x08, 0x0A-0x1F and 0x7F in status lines, field-names and field-values.
WebSocket receive_str and receive_bytes methods now raise aiohttp.WSMessageTypeError instead of TypeError when messages of incorrect types are received.
aiohttp.ClientWebSocketResponse.receive_straiohttp.ClientWebSocketResponse.receive_bytesaiohttp.web.WebSocketResponse.receive_straiohttp.web.WebSocketResponse.receive_bytesaiohttp.WSMessageTypeErrorReplaces FlowControlDataQueue with WebSocketDataQueue.
FlowControlDataQueueWebSocketDataQueueReplaces FlowControlDataQueue with WebSocketDataQueue.
FlowControlDataQueueWebSocketDataQueueChanges ClientRequest.connection_key to be a NamedTuple to improve client performance.
ClientRequest.connection_keyImproves connector performance when a connection can be reused; subclasses of BaseConnector.connect with custom logic must add ceil_timeout.
BaseConnector.connectceil_timeoutCreating TCPConnector, ClientSession, ThreadedResolver, web.Server, or CookieJar without a running event loop now raises RuntimeError.
aiohttp.TCPConnectoraiohttp.ClientSessionaiohttp.resolver.ThreadedResolveraiohttp.web.Serveraiohttp.CookieJarRuntimeErrorChanges shutdown logic to wait only on request handlers instead of all tasks.
handler_cancellationasyncio.shieldaiojobs.aiohttp.shieldaiojobsImplements filter_cookies() with domain and path matching on keys, which may break cookies saved with CookieJar.save().
filter_cookies()CookieJar.save()Fixes an unhandled exception in the Python HTTP parser on header lines starting with a colon and rejects invalid request lines and header field names.
Disables implicit fallback to pure Python mode; the build fails if C accelerators cannot compile, unless AIOHTTP_NO_EXTENSIONS=1 is set.
AIOHTTP_NO_EXTENSIONSStops automatically releasing the ClientResponse object on calls to the ok property for failed requests.
ClientResponseClientResponse.okokMakes writer.write_headers a coroutine.
writer.write_headersRefactors websockets so all websocket writer methods are converted into coroutines.
Renames pytest fixtures, adding the aiohttp_ prefix.
aiohttp_Adds the aiohttp- prefix to pytest-aiohttp command line parameters.
pytest-aiohttpaiohttp-Makes send_str(), send_bytes(), send_json(), ping() and pong() genuine async functions.
send_str()send_bytes()send_json()ping()pong()Drops undocumented app.on_pre_signal and app.on_post_signal; signal handlers must be coroutines and regular functions are no longer supported.
app.on_pre_signalapp.on_post_signalSimplifies stream classes by dropping ChunksQueue and FlowControlChunksQueue and merging FlowControlStreamReader into StreamReader.
ChunksQueueFlowControlChunksQueueFlowControlStreamReaderStreamReaderForbids non-string values in resource.url_for() parameters.
resource.url_for()MultipartWriter.boundary is now str instead of bytes.
MultipartWriter.boundaryRenames pytest fixtures, adding the aiohttp_ prefix.
aiohttp_Adds an aiohttp- prefix to pytest-aiohttp command line parameters.
pytest-aiohttpaiohttp-Makes send_str(), send_bytes(), send_json(), ping() and pong() genuine async functions.
send_str()send_bytes()send_json()ping()pong()Drops undocumented app.on_pre_signal and app.on_post_signal; signal handlers must be coroutines, regular functions are no longer supported.
app.on_pre_signalapp.on_post_signalSimplifies stream classes by dropping ChunksQueue and FlowControlChunksQueue and merging FlowControlStreamReader into StreamReader.
ChunksQueueFlowControlChunksQueueFlowControlStreamReaderStreamReaderForbids non-string values in resource.url_for() parameters.
resource.url_for()Forbids synchronous context managers for ClientSession and the test server/client.
ClientSessionForbids synchronous context managers for ClientSession and the test server/client.
ClientSessionSecurity64
Set-Cookie parsing now sets exactly one cookie per header and ignores unrecognized attributes, per RFC 6265.
DummyCookieJarCookieJarSet-CookieAIOHTTP: Absolute-form request targets can spoof Request.scheme
ModerateAIOHTTP: Secure attribute not enforced for shared cookie
CookieJar.filter_cookies()SecureDomainModerateaiohttp: Multiple instances of excessive or unbounded memory/CPU use
Highaiohttp server lacks an initial request/header timeout
HighAIOHTTP: Connector pool exhaustion via Max-Age overflow
ModerateAIOHTTP: File descriptor exhaustion in multipart requests
HighAIOHTTP: Cookie from subdomain can remove Host-Only Scope from existing cookies
LowAIOHTTP: Pure-Python parser request smuggling
ModerateAIOHTTP: Out-of-bounds heap read in C HTTP response parser error path (malformed chunked response)
AIOHTTP: WebSocket client accepts compressed frames without negotiated permessage-deflate
AIOHTTP: HTTP request smuggling via WebSocket upgrade
AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to 3.14.1, during cleanup it is possible for a compressed request body to be decompressed into memory in one chunk. An attacker may be able to send a compressed payload in specific situations that could be decompressed into memory, potentially leading to DoS (a zip bomb edge case). This vulnerability is fixed in 3.14.1.
High · CVSS 7.5AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to 3.14.1, the server_hostname TLS SNI check can be bypassed when an existing connection is reused. If an application makes multiple requests to the same domain, but with different per-request server_hostname parameters, then the later calls may succeed by reusing the existing connection when they should have been rejected due to the TLS SNI check. This vulnerability is fixed in 3.14.1.
High · CVSS 7.5AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to 3.14.1, payload resources are not closed correctly when a client disconnects in the middle of a write. If a payload is using an open file or similar limited resource, then an attacker may be able to cause resource starvation temporarily until garbage collection or similar closes the file. This vulnerability is fixed in 3.14.1.
High · CVSS 7.5AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to 3.14.1, host-only cookies that are saved with CookieJar.save() and then restored later with CookieJar.load() lose their host-only status. This vulnerability is fixed in 3.14.1.
High · CVSS 7.5AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to 3.14.1, it is possible to bypass the max_line_size check in parts of an HTTP request in the C parser. If using the optimised C parser (the default in pre-built wheels), then an attacker may be able to send oversized lines through the HTTP parser and use an excessive amount of memory, potentially leading to DoS. This vulnerability is fixed in 3.14.1.
High · CVSS 7.5AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to 3.14.1, no limit was present on the number of pipelined requests that could be queued. An attacker may be able to use pipelined requests to use excessive amounts of memory, potentially leading to DoS. This vulnerability is fixed in 3.14.1.
High · CVSS 7.5AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to 3.14.1, DigestAuthMiddleware can send an authentication response after following a cross-origin redirect. This likely requires an open redirect vulnerability or similar on the target domain for an attacker to be able to execute. Further, the attacker is only receiving the digest, so should only be able to extract the user's credentials if the cryptography is weak or there is some kind of password reuse. This vulnerability is fixed in 3.14.1.
Medium · CVSS 6.1AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to 3.14.1, if an attacker sends large incomplete websocket frame payloads, it may be possible to bypass the usual size limits on memory use. This vulnerability is fixed in 3.14.1.
High · CVSS 7.5Cookiejar.save() now uses 0x600 permissions to better protect saved cookies from other users.
Cookiejar.save()AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to version 3.14.0, cookies set with the
High · CVSS 7.5cookies parameter on requests are sent after following a cross-origin redirect. If a developer uses the cookies parameter on a per-request basis then sensitive data might be leaked to an attacker if they manage to control a redirect. Version 3.14.0 patches the issue. If unable to upgrade, using a Cookie header in the headers parameter is not vulnerable.AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to version 3.14.0, using `
High · CVSS 7.3CookieJar.load()` with untrusted input may allow arbitrary code execution. Most applications using this function will be doing so with the user's own data, so this is unlikely to affect many applications. Version 3.14.0 patches the issue. If an application does allow attacker controlled files to be loaded, a workaround on older releases would be to sanitize the files before loading.AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to 3.14.0, attacker-controlled input included into multipart/payload headers can be used to modify a request to inject additional headers or similar. In the unlikely situation that an application is passing user-controlled strings into MultipartWriter.append(headers=...) or Payload.headers, then an attacker may be able to modify the request to inject headers or change the contents of the request. This vulnerability is fixed in 3.14.0.
High · CVSS 7.5Rejects duplicate singleton headers in the C extension HTTP parser to match the pure Python parser and prevent host-based access control bypasses.
HostContent-TypeContent-LengthAIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to version 3.13.4, a response with an excessive number of multipart headers may be allowed to use more memory than intended, potentially allowing a DoS vulnerability. This issue has been patched in version 3.13.4.
AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to version 3.13.4, insufficient restrictions in header/trailer handling could cause uncapped memory usage. This issue has been patched in version 3.13.4.
AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to version 3.13.4, an attacker who controls the reason parameter when creating a Response may be able to inject extra headers or similar exploits. This issue has been patched in version 3.13.4.
Medium · CVSS 5.3AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to version 3.13.4, multiple Host headers were allowed in aiohttp. This issue has been patched in version 3.13.4.
Medium · CVSS 5.3AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to version 3.13.4, when following redirects to a different origin, aiohttp drops the Authorization header, but retains the Cookie and Proxy-Authorization headers. This issue has been patched in version 3.13.4.
Medium · CVSS 5.3AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to version 3.13.4, on Windows the static resource handler may expose information about a NTLMv2 remote path. This issue has been patched in version 3.13.4.
High · CVSS 7.5AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to version 3.13.4, an attacker who controls the content_type parameter in aiohttp could use this to inject extra headers or similar exploits. This issue has been patched in version 3.13.4.
Medium · CVSS 5.3AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to version 3.13.4, the C parser (the default for most installs) accepted null bytes and control characters in response headers. This issue has been patched in version 3.13.4.
AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to version 3.13.4, for some multipart form fields, aiohttp read the entire field into memory before checking client_max_size. This issue has been patched in version 3.13.4.
Medium · CVSS 5.3AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to version 3.13.4, an unbounded DNS cache could result in excessive memory usage possibly resulting in a DoS situation. This issue has been patched in version 3.13.4.
High · CVSS 7.5AIOHTTP vulnerable to DoS when bypassing asserts
AIOHTTP vulnerable to brute-force leak of internal static file path components
AIOHTTP's HTTP Parser auto_decompress feature is vulnerable to zip bomb
High · CVSS 7.5AIOHTTP's unicode processing of header values could cause parsing discrepancies
AIOHTTP vulnerable to denial of service through large payloads
AIOHTTP vulnerable to DoS through chunked messages
AIOHTTP Vulnerable to Cookie Parser Warning Storm
AIOHTTP has unicode match groups in regexes for ASCII protocol elements
AIOHTTP is vulnerable to HTTP Request/Response Smuggling through incorrect parsing of chunked trailer sections
aiohttp has a memory leak when middleware is enabled when requesting a resource with a non-allowed method
High · CVSS 7.5aiohttp allows request smuggling due to incorrect parsing of chunk extensions
Rejects newline characters in reason values to avoid sending broken HTTP messages.
reasonRejects newline characters in reason values to avoid sending broken HTTP messages.
reasonIn aiohttp, compressed files as symlinks are not protected from path traversal
Medium · CVSS 4.8aiohttp vulnerable to Denial of Service when trying to parse malformed POST requests
High · CVSS 7.5aiohttp Cross-site Scripting vulnerability on index pages for static file handling
Medium · CVSS 6.1aiohttp is an asynchronous HTTP client/server framework for asyncio and Python. Security-sensitive parts of the Python HTTP parser retained minor differences in allowable character sets, that must trigger error handling to robustly match frame boundaries of proxies in order to protect against injection of additional requests. Additionally, validation could trigger exceptions that were not handled consistently with processing of other malformed input. Being more lenient than internet standards require could, depending on deployment environment, assist in request smuggling. The unhandled exception could cause excessive resource consumption on the application server and/or its logging facilities. This vulnerability exists due to an incomplete fix for CVE-2023-47627. Version 3.9.2 fixes this vulnerability.
Medium · CVSS 6.5aiohttp is an asynchronous HTTP client/server framework for asyncio and Python. When using aiohttp as a web server and configuring static routes, it is necessary to specify the root path for static files. Additionally, the option 'follow_symlinks' can be used to determine whether to follow symbolic links outside the static root directory. When 'follow_symlinks' is set to True, there is no validation to check if reading a file is within the root directory. This can lead to directory traversal vulnerabilities, resulting in unauthorized access to arbitrary files on the system, even when symlinks are not present. Disabling follow_symlinks and using a reverse proxy are encouraged mitigations. Version 3.9.2 fixes this issue.
High · CVSS 7.5Fixes arbitrary sequence types being allowed to inject values via the version parameter.
aiohttp is an asynchronous HTTP client/server framework for asyncio and Python. Improper validation made it possible for an attacker to modify the HTTP request (e.g. to insert a new header) or create a new HTTP request if the attacker controls the HTTP version. The vulnerability only occurs if the attacker can control the HTTP version of the request. This issue has been patched in version 3.9.0.
Medium · CVSS 5.3aiohttp is an asynchronous HTTP client/server framework for asyncio and Python. Improper validation makes it possible for an attacker to modify the HTTP request (e.g. insert a new header) or even create a new HTTP request if the attacker controls the HTTP method. The vulnerability occurs only if the attacker can control the HTTP method (GET, POST etc.) of the request. If the attacker can control the HTTP version of the request it will be able to modify the request (request smuggling). This issue has been patched in version 3.9.0.
Medium · CVSS 5.3Upgrades the vendored copy of llhttp to v9.1.3.
llhttpModerateUpdates the Python parser to comply with RFCs 9110/9112.
High · CVSS 7.5Upgrades the vendored copy of llhttp to v8.1.1 to address a security advisory.
llhttpAdds validation of HTTP header keys and values to prevent header injection.
Stops sending secure cookies over insecure transports; CookieJar(treat_as_secure_origin=...) can override the default checker.
CookieJartreat_as_secure_originaiohttp is an asynchronous HTTP client/server framework for asyncio and Python. Affected versions of aiohttp have a security vulnerability regarding the inconsistent interpretation of the http protocol. HTTP/1.1 is a persistent protocol, if both Content-Length(CL) and Transfer-Encoding(TE) header values are present it can lead to incorrect interpretation of two entities that parse the HTTP and we can poison other sockets with this incorrect interpretation. A possible Proof-of-Concept (POC) would be a configuration with a reverse proxy(frontend) that accepts both CL and TE headers and aiohttp as backend. As aiohttp parses anything with chunked, we can pass a chunked123 as TE, the frontend entity will ignore this header and will parse Content-Length. The impact of this vulnerability is that it is possible to bypass any proxy rule, poisoning sockets to other users like passing Authentication Headers, also if it is present an Open Redirect an attacker could combine it to redirect random users to another website and log the request. This vulnerability has been addressed in release 3.8.0 of aiohttp. Users are advised to upgrade. There are no known workarounds for this vulnerability.
Medium · CVSS 6.5Prevents open redirects in the aiohttp.web.normalize_path_middleware middleware.
aiohttp.web.normalize_path_middlewarePrevents Windows absolute URLs in static files, forbidding paths like /static/D:\path and /static/\\hostname\drive\path.
Platform10
Drops support for Python 3.9.
Adds support for Python 3.14.
Drops support for Python 3.8.
Declares Python 3.13 supported.
Drops Python 3.6 support.
Drops Python 3.7 support.
Drops Python 3.5 support; aiohttp now requires Python 3.6 or higher.
Raises the minimum supported Python version to 3.5.3.
Drops Python 3.4 and Python 3.5.0 through 3.5.2; minimum supported versions are 3.5.3 and 3.6.0, and yield from is removed in favor of async/await.
Drops Python 3.4 and Python 3.5.0 through 3.5.2; minimum supported versions are 3.5.3 and 3.6.0, and yield from is removed in favor of async/await.
Deprecations to plan for
Deprecated27
Deprecates ClientResponse.output_size and ClientResponse.upload_complete in favor of aiohttp.UploadTracker.
ClientResponse.output_sizeClientResponse.upload_completeaiohttp.UploadTrackerDeprecates aiohttp.BasicAuth and the auth / proxy_auth parameters, to be removed in aiohttp 4.0.
aiohttp.BasicAuthauthproxy_authaiohttp.encode_basic_authheadersproxy_headersAdds a deprecation warning to aiohttp.pytest_plugin, directing users to pytest-aiohttp.
aiohttp.pytest_pluginpytest-aiohttpDeprecates the ssl_shutdown_timeout parameter, to be removed in aiohttp 4.0.
ssl_shutdown_timeoutDeprecates timeout and receive_timeout in ClientSession.ws_connect and changes the default websocket receive timeout from None to 10.0.
aiohttp.ClientSession.ws_connecttimeoutreceive_timeoutDeprecates the content_transfer_encoding parameter in FormData.add_field(), removal in next major release.
FormData.add_field()content_transfer_encodingAdds shutdown_timeout parameter to BaseRunner while deprecating it from BaseSite.
BaseRunnerBaseSiteshutdown_timeoutAdds fallback_charset_resolver to ClientSession; default charset detection is removed in 3.9.
ClientSessionfallback_charset_resolverDeprecates modification of session.requote_redirect_url.
session.requote_redirect_urlDeprecates stream.unread_data().
stream.unread_data()Deprecates use of a boolean in resp.enable_compression().
resp.enable_compression()Encourages creation of aiohttp public objects inside a coroutine.
Deprecates the app.loop, request.loop, client.loop and connector.loop properties.
app.looprequest.loopclient.loopconnector.loopDeprecates the explicit debug argument; use asyncio debug mode instead.
debugDeprecates the body parameter in the HTTPException constructor and derived classes.
HTTPExceptionbodyDeprecates bare connector close; use async with connector: and await connector.close() instead.
connector.close()Deprecates the obsolete read_timeout and conn_timeout arguments in the ClientSession constructor.
ClientSessionread_timeoutconn_timeoutDocuments that app.make_handler is deprecated and recommends the runners API instead.
app.make_handlerDeprecates the custom application's router.
Deprecates Application.make_handler().
Application.make_handler()Deprecates ClientResponseError.code in favor of .status to match response classes.
ClientResponseError.codeClientResponseError.statusAdds a DeprecationWarning for returning HTTPException.
HTTPExceptionDeprecationWarningDeprecates the verify_ssl, ssl_context and fingerprint parameters in the client API.
verify_sslssl_contextfingerprintDeprecates inheriting from ClientSession and web.Application and custom user attributes on ClientSession, web.Request and web.Application.
ClientSessionweb.Applicationweb.RequestAdds a DeprecationWarning for returning HTTPException.
HTTPExceptionDeprecationWarningDeprecates the verify_ssl, ssl_context and fingerprint parameters in the client API.
verify_sslssl_contextfingerprintDeprecates subclassing ClientSession and web.Application and custom user attributes on ClientSession, web.Request and web.Application.
ClientSessionweb.Applicationweb.RequestAPI changes
Generated by DepDelta from published Python source. Not mixed with prose notes.
- removed:
variable workers - added:
export AddrInfoType - added:
export AsyncIterablePayload - added:
export AsyncResolver - added:
export BadContentDispositionHeader - added:
export BadContentDispositionParam - added:
export BaseConnector - added:
export BasicAuth - added:
export BodyPartReader - added:
export BufferedReaderPayload - added:
export BytesIOPayload - added:
export BytesPayload - added:
export ChainMapProxy - added:
export ClientConnectionError - added:
export ClientConnectionResetError - added:
export ClientConnectorCertificateError - added:
export ClientConnectorDNSError - added:
export ClientConnectorError - added:
export ClientConnectorSSLError - added:
export ClientError - added:
export ClientHandlerType - added:
export ClientHttpProxyError - added:
export ClientMiddlewareType - added:
export ClientOSError - added:
export ClientPayloadError - added:
export ClientProxyConnectionError - added:
export ClientRequest - added:
export ClientResponse - added:
export ClientResponseError - added:
export ClientSSLError - added:
export ClientSession - added:
export ClientTimeout - added:
export ClientWSTimeout - added:
export ClientWebSocketResponse - added:
export ConnectionTimeoutError - added:
export ContentTypeError - added:
export CookieJar - added:
export DataQueue - added:
export DefaultResolver - added:
export DigestAuthMiddleware - added:
export DummyCookieJar - added:
export EMPTY_PAYLOAD - added:
export ETag - added:
export EofStream - added:
export Fingerprint - added:
export FlowControlDataQueue - added:
export FormData - added:
export IOBasePayload - added:
export InvalidURL - added:
export InvalidUrlClientError - added:
export InvalidUrlRedirectClientError - added:
export JsonPayload - added:
export MultipartReader - added:
export MultipartWriter - added:
export NamedPipeConnector - added:
export NonHttpUrlClientError - added:
export NonHttpUrlRedirectClientError - added:
export PAYLOAD_REGISTRY - added:
export Payload - added:
export RedirectClientError - added:
export RequestInfo - added:
export ServerConnectionError - added:
export ServerDisconnectedError - added:
export ServerFingerprintMismatch - added:
export ServerTimeoutError - added:
export SocketFactoryType - added:
export SocketTimeoutError - added:
export StreamReader - added:
export StringIOPayload - added:
export StringPayload - added:
export TCPConnector - added:
export TextIOPayload - added:
export ThreadedResolver - added:
export TooManyRedirects - added:
export TraceConfig - added:
export TraceConnectionCreateEndParams - added:
export TraceConnectionCreateStartParams - added:
export TraceConnectionQueuedEndParams - added:
export TraceConnectionQueuedStartParams - added:
export TraceConnectionReuseconnParams - added:
export TraceDnsCacheHitParams - added:
export TraceDnsCacheMissParams - added:
export TraceDnsResolveHostEndParams - added:
export TraceDnsResolveHostStartParams - added:
export TraceRequestChunkSentParams - added:
export TraceRequestEndParams - added:
export TraceRequestExceptionParams - added:
export TraceRequestHeadersSentParams - added:
export TraceRequestRedirectParams - added:
export TraceRequestStartParams - added:
export TraceResponseChunkReceivedParams - added:
export UnixConnector - added:
export UploadAbortedError - added:
export UploadTracker - added:
export WSMessageTypeError - added:
export WSServerHandshakeError - added:
export content_disposition_filename - added:
export encode_basic_auth - added:
export get_payload - added:
export parse_content_disposition - added:
export payload_type - added:
export request - added:
export set_zlib_backend - added:
export streamer
- removed:
class AbstractPayloadWriter(ABC) - removed:
method AbstractMatchInfo.expect_handler(request) - removed:
method AbstractMatchInfo.handler(request) - removed:
method AbstractPayloadWriter.drain() - removed:
method AbstractPayloadWriter.write(chunk) - removed:
method AbstractPayloadWriter.write_eof(chunk=…) - removed:
property AbstractMatchInfo.apps - removed:
property AbstractMatchInfo.http_exception - removed:
property AbstractRouter.frozen - removed:
property AbstractView.request - removed:
variable PY_35 - changed:
class AbstractCookieJar(Sized, Iterable) → class AbstractCookieJar(Sized, IterableBase) - changed:
constructor AbstractAccessLogger(logger, log_format) → constructor AbstractAccessLogger(logger: logging.Logger, log_format: str) -> None - changed:
constructor AbstractCookieJar(*, loop=…) → constructor AbstractCookieJar(*, loop: asyncio.AbstractEventLoop | None=…) -> None - changed:
constructor AbstractRouter() → constructor AbstractRouter() -> None - changed:
constructor AbstractView(request) → constructor AbstractView(request: Request) -> None - changed:
method AbstractAccessLogger.log(request, response, time) → method AbstractAccessLogger.log(request: BaseRequest, response: StreamResponse, time: float) -> None - changed:
method AbstractCookieJar.clear() → method AbstractCookieJar.clear(predicate: ClearCookiePredicate | None=…) -> None - changed:
method AbstractCookieJar.filter_cookies(request_url) → method AbstractCookieJar.filter_cookies(request_url: URL) -> BaseCookie[str] - changed:
method AbstractCookieJar.update_cookies(cookies, response_url=…) → method AbstractCookieJar.update_cookies(cookies: LooseCookies, response_url: URL=…) -> None - changed:
method AbstractMatchInfo.add_app(app) → method AbstractMatchInfo.add_app(app: Application) -> None - changed:
method AbstractMatchInfo.freeze() → method AbstractMatchInfo.freeze() -> None - changed:
method AbstractMatchInfo.get_info() → method AbstractMatchInfo.get_info() -> dict[str, Any] - changed:
method AbstractResolver.close() → async method AbstractResolver.close() -> None - changed:
method AbstractResolver.resolve(hostname) → async method AbstractResolver.resolve(host: str, port: int=…, family: socket.AddressFamily=…) -> list[ResolveResult] - changed:
method AbstractRouter.freeze() → method AbstractRouter.freeze() -> None - changed:
method AbstractRouter.post_init(app) → method AbstractRouter.post_init(app: Application) -> None - changed:
method AbstractRouter.resolve(request) → async method AbstractRouter.resolve(request: Request) -> AbstractMatchInfo - added:
async method AbstractStreamWriter.drain() -> None - added:
async method AbstractStreamWriter.write(chunk: bytes | bytearray | memoryview) -> None - added:
async method AbstractStreamWriter.write_eof(chunk: bytes=…) -> None - added:
async method AbstractStreamWriter.write_headers(status_line: str, headers: CIMultiDict[str]) -> None - added:
class AbstractStreamWriter(ABC) - added:
class ResolveResult(TypedDict) - added:
field AbstractStreamWriter.buffer_size: int - added:
field AbstractStreamWriter.length: int | None - added:
field AbstractStreamWriter.on_body_write: Callable[[int, int], None] | None - added:
field AbstractStreamWriter.output_size: int - added:
field ResolveResult.family: int - added:
field ResolveResult.flags: int - added:
field ResolveResult.host: str - added:
field ResolveResult.hostname: str - added:
field ResolveResult.port: int - added:
field ResolveResult.proto: int - added:
method AbstractCookieJar.clear_domain(domain: str) -> None - added:
method AbstractCookieJar.update_cookies_from_headers(headers: Sequence[str], response_url: URL) -> None - added:
method AbstractStreamWriter.enable_chunking() -> None - added:
method AbstractStreamWriter.enable_compression(encoding: str=…, strategy: int | None=…) -> None - added:
method AbstractStreamWriter.send_headers() -> None - added:
property AbstractAccessLogger.enabled -> bool - added:
property AbstractCookieJar.cookies -> MappingProxyType[tuple[str, str], SimpleCookie] - added:
property AbstractCookieJar.host_only_cookies -> frozenset[tuple[str, str, str]] - added:
property AbstractCookieJar.quote_cookie -> bool - added:
property AbstractCookieJar.treat_as_secure_origin -> frozenset[URL] - added:
property AbstractCookieJar.unsafe -> bool - added:
property AbstractMatchInfo.apps -> tuple[Application, ...] - added:
property AbstractMatchInfo.expect_handler -> Callable[[Request], Awaitable[StreamResponse | None]] - added:
property AbstractMatchInfo.handler -> Callable[[Request], Awaitable[StreamResponse]] - added:
property AbstractMatchInfo.http_exception -> HTTPException | None - added:
property AbstractRouter.frozen -> bool - added:
property AbstractStreamWriter.transport -> asyncio.WriteTransport | None - added:
property AbstractView.request -> Request - added:
variable Application - added:
variable BaseRequest - added:
variable ClearCookiePredicate - added:
variable HTTPException - added:
variable IterableBase - added:
variable Request - added:
variable StreamResponse
- removed:
class BaseCookie(dict) - removed:
class SimpleCookie(BaseCookie) - removed:
constructor BaseCookie(input=…) - removed:
export CookieError - removed:
method BaseCookie.js_output(attrs=…) - removed:
method BaseCookie.load(rawdata) - removed:
method BaseCookie.output(attrs=…, header=…, sep=…) - removed:
method BaseCookie.value_decode(val) - removed:
method BaseCookie.value_encode(val) - removed:
method SimpleCookie.value_decode(val) - removed:
method SimpleCookie.value_encode(val)
- added:
class BaseProtocol(asyncio.Protocol) - added:
constructor BaseProtocol(loop: asyncio.AbstractEventLoop, parser: HttpParser[Any] | None=…) -> None - added:
method BaseProtocol.connection_lost(exc: BaseException | None) -> None - added:
method BaseProtocol.connection_made(transport: asyncio.BaseTransport) -> None - added:
method BaseProtocol.pause_reading() -> None - added:
method BaseProtocol.pause_writing() -> None - added:
method BaseProtocol.resume_reading(resume_parser: bool=…) -> None - added:
method BaseProtocol.resume_writing() -> None - added:
property BaseProtocol.connected -> bool - added:
property BaseProtocol.writing_paused -> bool - added:
variable PAUSE_RESUME_READING_ERRORS
- removed:
field ClientSession.requote_redirect_url - removed:
property ClientSession.closed - removed:
property ClientSession.connector - removed:
property ClientSession.cookie_jar - removed:
property ClientSession.loop - removed:
property ClientSession.version - removed:
variable DEFAULT_TIMEOUT - changed:
constructor ClientSession(*, connector=…, loop=…, cookies=…, headers=…, skip_auto_headers=…, auth=…, json_serialize=…, request_class=…, response_class=…, ws_response_class=…, version=…, cookie_jar=…, connector_owner=…, raise_for_status=…, read_timeout=…, conn_timeout=…, auto_decompress=…, trust_env=…) → constructor ClientSession(base_url: StrOrURL | None=…, *, connector: BaseConnector | None=…, loop: asyncio.AbstractEventLoop | None=…, cookies: LooseCookies | None=…, headers: LooseHeaders | None=…, proxy: StrOrURL | None=…, proxy_auth: BasicAuth | None=…, skip_auto_headers: Iterable[str] | None=…, auth: BasicAuth | None=…, json_serialize: JSONEncoder=…, json_serialize_bytes: JSONBytesEncoder | N… - changed:
function request(method, url, *, params=…, data=…, json=…, headers=…, skip_auto_headers=…, cookies=…, auth=…, allow_redirects=…, max_redirects=…, encoding=…, version=…, compress=…, chunked=…, expect100=…, connector=…, loop=…, read_until_eof=…, proxy=…, proxy_auth=…) → function request(method: str, url: StrOrURL, *, version: HttpVersion=…, connector: BaseConnector | None=…, loop: asyncio.AbstractEventLoop | None=…, **kwargs: Any) -> _SessionRequestContextManager - changed:
method ClientSession.close() → async method ClientSession.close() -> None - changed:
method ClientSession.delete(url, **kwargs) → method ClientSession.delete(url: StrOrURL, **kwargs: Any) -> _RequestContextManager - changed:
method ClientSession.detach() → method ClientSession.detach() -> None - changed:
method ClientSession.get(url, *, allow_redirects=…, **kwargs) → method ClientSession.get(url: StrOrURL, *, allow_redirects: bool=…, **kwargs: Any) -> _RequestContextManager - changed:
method ClientSession.head(url, *, allow_redirects=…, **kwargs) → method ClientSession.head(url: StrOrURL, *, allow_redirects: bool=…, **kwargs: Any) -> _RequestContextManager - changed:
method ClientSession.options(url, *, allow_redirects=…, **kwargs) → method ClientSession.options(url: StrOrURL, *, allow_redirects: bool=…, **kwargs: Any) -> _RequestContextManager - changed:
method ClientSession.patch(url, *, data=…, **kwargs) → method ClientSession.patch(url: StrOrURL, *, data: Any=…, **kwargs: Any) -> _RequestContextManager - changed:
method ClientSession.post(url, *, data=…, **kwargs) → method ClientSession.post(url: StrOrURL, *, data: Any=…, **kwargs: Any) -> _RequestContextManager - changed:
method ClientSession.put(url, *, data=…, **kwargs) → method ClientSession.put(url: StrOrURL, *, data: Any=…, **kwargs: Any) -> _RequestContextManager - changed:
method ClientSession.request(method, url, **kwargs) → method ClientSession.request(method: str, url: StrOrURL, **kwargs: Any) -> _RequestContextManager - changed:
method ClientSession.ws_connect(url, *, protocols=…, timeout=…, receive_timeout=…, autoclose=…, autoping=…, heartbeat=…, auth=…, origin=…, headers=…, proxy=…, proxy_auth=…, verify_ssl=…, fingerprint=…, ssl_context=…, proxy_headers=…, compress=…) → method ClientSession.ws_connect(url: StrOrURL, *, decode_text: Literal[True]=…, **kwargs: Unpack[_WSConnectOptions]) -> _BaseRequestContextManager[ClientWebSocketResponse[Literal[True]]] | (url: StrOrURL, *, decode_text: Literal[False], **kwargs: Unpack[_WSConnectOptions]) -> _BaseRequestContextManager[ClientWebSocketResponse[Literal[False]]] | (url: StrOrURL, *, decode_text: bool=…, **kwargs: Un… - added:
class ClientTimeout - added:
export BaseConnector - added:
export ClientConnectionError - added:
export ClientConnectionResetError - added:
export ClientConnectorCertificateError - added:
export ClientConnectorDNSError - added:
export ClientConnectorError - added:
export ClientConnectorSSLError - added:
export ClientError - added:
export ClientHttpProxyError - added:
export ClientOSError - added:
export ClientPayloadError - added:
export ClientProxyConnectionError - added:
export ClientRequest - added:
export ClientResponse - added:
export ClientResponseError - added:
export ClientSSLError - added:
export ClientWSTimeout - added:
export ClientWebSocketResponse - added:
export ConnectionTimeoutError - added:
export ContentTypeError - added:
export Fingerprint - added:
export InvalidURL - added:
export InvalidUrlClientError - added:
export InvalidUrlRedirectClientError - added:
export NamedPipeConnector - added:
export NonHttpUrlClientError - added:
export NonHttpUrlRedirectClientError - added:
export RedirectClientError - added:
export RequestInfo - added:
export ServerConnectionError - added:
export ServerDisconnectedError - added:
export ServerFingerprintMismatch - added:
export ServerTimeoutError - added:
export SocketTimeoutError - added:
export TCPConnector - added:
export TooManyRedirects - added:
export UnixConnector - added:
export UploadAbortedError - added:
export UploadTracker - added:
export WSMessageTypeError - added:
export WSServerHandshakeError - added:
field ClientSession.ATTRS - added:
field ClientTimeout.ceil_threshold: float - added:
field ClientTimeout.connect: float | None - added:
field ClientTimeout.sock_connect: float | None - added:
field ClientTimeout.sock_read: float | None - added:
field ClientTimeout.total: float | None - added:
property ClientSession.auth -> BasicAuth | None - added:
property ClientSession.auto_decompress -> bool - added:
property ClientSession.closed -> bool - added:
property ClientSession.connector -> BaseConnector | None - added:
property ClientSession.connector_owner -> bool - added:
property ClientSession.cookie_jar -> AbstractCookieJar - added:
property ClientSession.headers -> CIMultiDict[str] - added:
property ClientSession.json_serialize -> JSONEncoder - added:
property ClientSession.loop -> asyncio.AbstractEventLoop - added:
property ClientSession.raise_for_status -> bool | Callable[[ClientResponse], Awaitable[None]] - added:
property ClientSession.requote_redirect_url -> bool - added:
property ClientSession.skip_auto_headers -> frozenset[istr] - added:
property ClientSession.timeout -> ClientTimeout - added:
property ClientSession.trace_configs -> list[TraceConfig] - added:
property ClientSession.trust_env -> bool - added:
property ClientSession.version -> tuple[int, int]
- removed:
property ClientConnectorCertificateError.certificate_error - removed:
property ClientConnectorCertificateError.host - removed:
property ClientConnectorCertificateError.port - removed:
property ClientConnectorCertificateError.ssl - removed:
property ClientConnectorError.host - removed:
property ClientConnectorError.os_error - removed:
property ClientConnectorError.port - removed:
property ClientConnectorError.ssl - removed:
property InvalidURL.url - changed:
class ClientConnectorCertificateError(*certificate_errors_bases) → class ClientConnectorCertificateError(*cert_errors_bases) - changed:
constructor ClientConnectorCertificateError(connection_key, certificate_error) → constructor ClientConnectorCertificateError(connection_key: ConnectionKey, certificate_error: Exception) -> None - changed:
constructor ClientConnectorError(connection_key, os_error) → constructor ClientConnectorError(connection_key: ConnectionKey, os_error: OSError) -> None - changed:
constructor ClientResponseError(request_info, history, *, code=…, message=…, headers=…) → constructor ClientResponseError(request_info: RequestInfo, history: tuple[ClientResponse, ...], *, code: int | None=…, status: int | None=…, message: str=…, headers: MultiMapping[str] | None=…) -> None - changed:
constructor InvalidURL(url) → constructor InvalidURL(url: StrOrURL, description: str | None=…) -> None - changed:
constructor ServerDisconnectedError(message=…) → constructor ServerDisconnectedError(message: RawResponseMessage | str | None=…) -> None - changed:
constructor ServerFingerprintMismatch(expected, got, host, port) → constructor ServerFingerprintMismatch(expected: bytes, got: bytes, host: str, port: int) -> None - added:
class ClientConnectionResetError(ClientConnectionError, ConnectionResetError) - added:
class ClientConnectorDNSError(ClientConnectorError) - added:
class ConnectionTimeoutError(ServerTimeoutError) - added:
class InvalidUrlClientError(InvalidURL) - added:
class InvalidUrlRedirectClientError(InvalidUrlClientError, RedirectClientError) - added:
class NonHttpUrlClientError(ClientError) - added:
class NonHttpUrlRedirectClientError(NonHttpUrlClientError, RedirectClientError) - added:
class RedirectClientError(ClientError) - added:
class SocketTimeoutError(ServerTimeoutError) - added:
class UploadAbortedError(ClientError) - added:
class WSMessageTypeError(TypeError) - added:
property ClientConnectorCertificateError.certificate_error -> Exception - added:
property ClientConnectorCertificateError.host -> str - added:
property ClientConnectorCertificateError.port -> int | None - added:
property ClientConnectorCertificateError.ssl -> bool - added:
property ClientConnectorError.host -> str - added:
property ClientConnectorError.os_error -> OSError - added:
property ClientConnectorError.port -> int | None - added:
property ClientConnectorError.ssl -> Union[SSLContext, bool, Fingerprint] - added:
property ClientResponseError.code -> int - added:
property InvalidURL.description -> str | None - added:
property InvalidURL.url -> StrOrURL
- added:
class DigestAuthChallenge(TypedDict) - added:
class DigestAuthMiddleware - added:
constructor DigestAuthMiddleware(login: str, password: str, preemptive: bool=…) -> None - added:
field DigestAuthChallenge.algorithm: str - added:
field DigestAuthChallenge.domain: str - added:
field DigestAuthChallenge.nonce: str - added:
field DigestAuthChallenge.opaque: str - added:
field DigestAuthChallenge.qop: str - added:
field DigestAuthChallenge.realm: str - added:
field DigestAuthChallenge.stale: str - added:
function escape_quotes(value: str) -> str - added:
function parse_header_pairs(header: str) -> dict[str, str] - added:
function unescape_quotes(value: str) -> str - added:
variable CHALLENGE_FIELDS: Final[tuple[Literal['realm', 'nonce', 'qop', 'algorithm', 'opaque', 'domain', 'stale'], ...]] - added:
variable DigestFunctions: dict[str, Callable[[bytes], hashlib._Hash]] - added:
variable QUOTED_AUTH_FIELDS: Final[frozenset[str]] - added:
variable SUPPORTED_ALGORITHMS: Final[tuple[str, ...]]
- added:
function build_client_middlewares(handler: ClientHandlerType, middlewares: Sequence[ClientMiddlewareType]) -> ClientHandlerType - added:
variable ClientHandlerType - added:
variable ClientMiddlewareType
- removed:
method ResponseHandler.connection_made(transport) - removed:
property ResponseHandler.should_close - removed:
property ResponseHandler.upgraded - changed:
class ResponseHandler(DataQueue, asyncio.streams.FlowControlMixin) → class ResponseHandler(BaseProtocol, DataQueue[tuple[RawResponseMessage, StreamReader]]) - changed:
constructor ResponseHandler(*, loop=…, **kwargs) → constructor ResponseHandler(loop: asyncio.AbstractEventLoop) -> None - changed:
method ResponseHandler.close() → method ResponseHandler.close() -> None - changed:
method ResponseHandler.connection_lost(exc) → method ResponseHandler.connection_lost(exc: BaseException | None) -> None - changed:
method ResponseHandler.data_received(data) → method ResponseHandler.data_received(data: bytes) -> None - changed:
method ResponseHandler.eof_received() → method ResponseHandler.eof_received() -> None - changed:
method ResponseHandler.is_connected() → method ResponseHandler.is_connected() -> bool - changed:
method ResponseHandler.pause_reading() → method ResponseHandler.pause_reading() -> None - changed:
method ResponseHandler.resume_reading() → method ResponseHandler.resume_reading(resume_parser: bool=…) -> None - changed:
method ResponseHandler.set_exception(exc) → method ResponseHandler.set_exception(exc: BaseException, exc_cause: BaseException=…) -> None - changed:
method ResponseHandler.set_parser(parser, payload) → method ResponseHandler.set_parser(parser: Any, payload: Any, data_received_cb: Callable[[], None] | None=…) -> None - changed:
method ResponseHandler.set_response_params(*, timer=…, skip_payload=…, skip_status_codes=…, read_until_eof=…, auto_decompress=…) → method ResponseHandler.set_response_params(*, timer: BaseTimerContext | None=…, skip_payload: bool=…, read_until_eof: bool=…, auto_decompress: bool=…, read_timeout: float | None=…, read_bufsize: int=…, timeout_ceil_threshold: float=…, max_line_size: int=…, max_field_size: int=…, max_headers: int=…) -> None - added:
method ResponseHandler.abort() -> None - added:
method ResponseHandler.force_close() -> None - added:
method ResponseHandler.start_timeout() -> None - added:
property ResponseHandler.closed -> None | asyncio.Future[None] - added:
property ResponseHandler.read_timeout -> float | None - added:
property ResponseHandler.should_close -> bool - added:
property ResponseHandler.upgraded -> bool
- removed:
field ClientRequest.body - removed:
field ClientRequest.response_class - removed:
field ClientResponse.flow_control_class - removed:
field ClientResponse.headers - removed:
field ClientResponse.raw_headers - removed:
method ClientRequest.keep_alive() - removed:
method ClientRequest.update_fingerprint(fingerprint) - removed:
property ClientRequest.connection_key - removed:
property ClientRequest.fingerprint - removed:
property ClientRequest.host - removed:
property ClientRequest.port - removed:
property ClientRequest.request_info - removed:
property ClientRequest.ssl_context - removed:
property ClientRequest.verify_ssl - removed:
property ClientResponse.closed - removed:
property ClientResponse.connection - removed:
property ClientResponse.history - removed:
property ClientResponse.host - removed:
property ClientResponse.request_info - removed:
property ClientResponse.url - removed:
property ClientResponse.url_obj - removed:
variable RequestInfo - changed:
constructor ClientRequest(method, url, *, params=…, headers=…, skip_auto_headers=…, data=…, cookies=…, auth=…, version=…, compress=…, chunked=…, expect100=…, loop=…, response_class=…, proxy=…, proxy_auth=…, timer=…, session=…, auto_decompress=…, verify_ssl=…, fingerprint=…, ssl_context=…, proxy_headers=…) → constructor ClientRequest(method: str, url: URL, *, params: Query=…, headers: LooseHeaders | None=…, skip_auto_headers: Iterable[str] | None=…, data: Any=…, cookies: LooseCookies | None=…, auth: BasicAuth | None=…, version: http.HttpVersion=…, compress: str | bool | None=…, chunked: bool | None=…, expect100: bool=…, loop: asyncio.AbstractEventLoop | None=…, response_class: type[ClientResponse] |… - changed:
constructor ClientResponse(method, url, *, writer=…, continue100=…, timer=…, request_info=…, auto_decompress=…) → constructor ClientResponse(method: str, url: URL, *, writer: asyncio.Task[None] | None, continue100: Optional[asyncio.Future[bool]], timer: BaseTimerContext, request_info: RequestInfo, traces: list[Trace], loop: asyncio.AbstractEventLoop, session: ClientSession, stream_writer: AbstractStreamWriter) -> None - changed:
field ClientResponse.content → field ClientResponse.content: StreamReader - changed:
field ClientResponse.reason → field ClientResponse.reason: str | None - changed:
field ClientResponse.status → field ClientResponse.status: int - changed:
field ClientResponse.version → field ClientResponse.version: HttpVersion | None - changed:
method ClientRequest.close() → async method ClientRequest.close() -> None - changed:
method ClientRequest.send(conn) → async method ClientRequest.send(conn: Connection) -> ClientResponse - changed:
method ClientRequest.terminate() → method ClientRequest.terminate() -> None - changed:
method ClientRequest.update_auth(auth) → method ClientRequest.update_auth(auth: BasicAuth | None, trust_env: bool=…) -> None - changed:
method ClientRequest.update_auto_headers(skip_auto_headers) → method ClientRequest.update_auto_headers(skip_auto_headers: Iterable[str] | None) -> None - changed:
method ClientRequest.update_body_from_data(body) → method ClientRequest.update_body_from_data(body: Any, _stacklevel: int=…) -> None - changed:
method ClientRequest.update_content_encoding(data) → method ClientRequest.update_content_encoding(data: Any) -> None - changed:
method ClientRequest.update_cookies(cookies) → method ClientRequest.update_cookies(cookies: LooseCookies | None) -> None - changed:
method ClientRequest.update_expect_continue(expect=…) → method ClientRequest.update_expect_continue(expect: bool=…) -> None - changed:
method ClientRequest.update_headers(headers) → method ClientRequest.update_headers(headers: LooseHeaders | None) -> None - changed:
method ClientRequest.update_host(url) → method ClientRequest.update_host(url: URL) -> None - changed:
method ClientRequest.update_proxy(proxy, proxy_auth, proxy_headers) → method ClientRequest.update_proxy(proxy: URL | None, proxy_auth: BasicAuth | None, proxy_headers: LooseHeaders | None) -> None - changed:
method ClientRequest.update_transfer_encoding() → method ClientRequest.update_transfer_encoding() -> None - changed:
method ClientRequest.update_version(version) → method ClientRequest.update_version(version: http.HttpVersion | str) -> None - changed:
method ClientRequest.write_bytes(writer, conn) → async method ClientRequest.write_bytes(writer: AbstractStreamWriter, conn: Connection, content_length: int | None=…) -> None - changed:
method ClientResponse.close() → method ClientResponse.close() -> None - changed:
method ClientResponse.json(*, encoding=…, loads=…, content_type=…) → async method ClientResponse.json(*, encoding: str | None=…, loads: JSONDecoder=…, content_type: str | None=…) -> Any - changed:
method ClientResponse.raise_for_status() → method ClientResponse.raise_for_status() -> None - changed:
method ClientResponse.read() → async method ClientResponse.read() -> bytes - changed:
method ClientResponse.release() → method ClientResponse.release() -> Any - changed:
method ClientResponse.start(connection, read_until_eof=…) → async method ClientResponse.start(connection: Connection) -> ClientResponse - changed:
method ClientResponse.text(encoding=…, errors=…) → async method ClientResponse.text(encoding: str | None=…, errors: str=…) -> str - changed:
method ClientResponse.wait_for_close() → async method ClientResponse.wait_for_close() -> None - added:
async method ClientRequest.update_body(body: Any) -> None - added:
class Fingerprint - added:
class RequestInfo(_RequestInfo) - added:
constructor Fingerprint(fingerprint: bytes) -> None - added:
field ClientRequest.method - added:
field ClientRequest.url - added:
field Fingerprint.HASHFUNC_BY_DIGESTLEN - added:
method ClientRequest.is_ssl() -> bool - added:
method ClientResponse.content_disposition() -> ContentDisposition | None - added:
method ClientResponse.get_encoding() -> str - added:
method ClientResponse.headers() -> CIMultiDictProxy[str] - added:
method ClientResponse.history() -> tuple[ClientResponse, ...] - added:
method ClientResponse.host() -> str - added:
method ClientResponse.links() -> MultiDictProxy[MultiDictProxy[str | URL]] - added:
method ClientResponse.raw_headers() -> RawHeaders - added:
method ClientResponse.real_url() -> URL - added:
method ClientResponse.request_info() -> RequestInfo - added:
method ClientResponse.url() -> URL - added:
method ClientResponse.url_obj() -> URL - added:
method Fingerprint.check(transport: asyncio.Transport) -> None - added:
property ClientRequest.body -> payload.Payload | Literal[b''] - added:
property ClientRequest.connection_key -> ConnectionKey - added:
property ClientRequest.host -> str - added:
property ClientRequest.port -> int | None - added:
property ClientRequest.request_info -> RequestInfo - added:
property ClientRequest.session -> ClientSession - added:
property ClientRequest.skip_auto_headers -> CIMultiDict[None] - added:
property ClientRequest.ssl -> Union[SSLContext, bool, Fingerprint] - added:
property ClientResponse.closed -> bool - added:
property ClientResponse.connection -> Optional[Connection] - added:
property ClientResponse.cookies -> SimpleCookie - added:
property ClientResponse.ok -> bool - added:
property ClientResponse.output_size -> int - added:
property ClientResponse.upload_complete -> asyncio.Future[None] - added:
property Fingerprint.fingerprint -> bytes
- removed:
property ClientWebSocketResponse.client_notakeover - removed:
property ClientWebSocketResponse.close_code - removed:
property ClientWebSocketResponse.closed - removed:
property ClientWebSocketResponse.compress - removed:
property ClientWebSocketResponse.protocol - changed:
class ClientWebSocketResponse → class ClientWebSocketResponse(Generic[_DecodeText]) - changed:
constructor ClientWebSocketResponse(reader, writer, protocol, response, timeout, autoclose, autoping, loop, *, receive_timeout=…, heartbeat=…, compress=…, client_notakeover=…) → constructor ClientWebSocketResponse(reader: WebSocketDataQueue, writer: WebSocketWriter, protocol: str | None, response: ClientResponse, timeout: ClientWSTimeout, autoclose: bool, autoping: bool, loop: asyncio.AbstractEventLoop, *, heartbeat: float | None=…, compress: int=…, client_notakeover: bool=…) -> None - changed:
method ClientWebSocketResponse.close(*, code=…, message=…) → async method ClientWebSocketResponse.close(*, code: int=…, message: bytes=…) -> bool - changed:
method ClientWebSocketResponse.exception() → method ClientWebSocketResponse.exception() -> BaseException | None - changed:
method ClientWebSocketResponse.get_extra_info(name, default=…) → method ClientWebSocketResponse.get_extra_info(name: str, default: Any=…) -> Any - changed:
method ClientWebSocketResponse.ping(message=…) → async method ClientWebSocketResponse.ping(message: bytes=…) -> None - changed:
method ClientWebSocketResponse.pong(message=…) → async method ClientWebSocketResponse.pong(message: bytes=…) -> None - changed:
method ClientWebSocketResponse.receive(timeout=…) → async method ClientWebSocketResponse.receive(timeout: float | None=…) -> WSMessageDecodeText | (timeout: float | None=…) -> WSMessageNoDecodeText | (timeout: float | None=…) -> WSMessageDecodeText | WSMessageNoDecodeText - changed:
method ClientWebSocketResponse.receive_bytes(*, timeout=…) → async method ClientWebSocketResponse.receive_bytes(*, timeout: float | None=…) -> bytes - changed:
method ClientWebSocketResponse.receive_json(*, loads=…, timeout=…) → async method ClientWebSocketResponse.receive_json(*, loads: JSONDecoder=…, timeout: float | None=…) -> Any | (*, loads: Callable[[bytes], Any]=…, timeout: float | None=…) -> Any | (*, loads: JSONDecoder | Callable[[bytes], Any]=…, timeout: float | None=…) -> Any - changed:
method ClientWebSocketResponse.receive_str(*, timeout=…) → async method ClientWebSocketResponse.receive_str(*, timeout: float | None=…) -> str | (*, timeout: float | None=…) -> bytes | (*, timeout: float | None=…) -> str | bytes - changed:
method ClientWebSocketResponse.send_bytes(data) → async method ClientWebSocketResponse.send_bytes(data: bytes, compress: int | None=…) -> None - changed:
method ClientWebSocketResponse.send_json(data, *, dumps=…) → async method ClientWebSocketResponse.send_json(data: Any, compress: int | None=…, *, dumps: JSONEncoder=…) -> None - changed:
method ClientWebSocketResponse.send_str(data) → async method ClientWebSocketResponse.send_str(data: str, compress: int | None=…) -> None - added:
async method ClientWebSocketResponse.send_frame(message: bytes, opcode: WSMsgType, compress: int | None=…) -> None - added:
async method ClientWebSocketResponse.send_json_bytes(data: Any, compress: int | None=…, *, dumps: JSONBytesEncoder) -> None - added:
class ClientWSTimeout - added:
field ClientWSTimeout.ws_close - added:
field ClientWSTimeout.ws_receive - added:
property ClientWebSocketResponse.client_notakeover -> bool - added:
property ClientWebSocketResponse.close_code -> int | None - added:
property ClientWebSocketResponse.closed -> bool - added:
property ClientWebSocketResponse.compress -> int - added:
property ClientWebSocketResponse.protocol -> str | None - added:
variable DEFAULT_WS_CLIENT_TIMEOUT
- added:
async method DecompressionBaseHandler.decompress(data: Buffer, max_length: int=…) -> bytes - added:
async method ZLibCompressor.compress(data: Buffer) -> bytes - added:
class BrotliDecompressor(DecompressionBaseHandler) - added:
class CompressObjArgs(TypedDict) - added:
class ConcatDecompressionHandler(DecompressionBaseHandler, Generic[_DecompressObjT]) - added:
class DecompressionBaseHandler(ABC) - added:
class MemberDecompressObjProtocol(Protocol) - added:
class TooManyMembersError(ValueError) - added:
class ZLibBackendProtocol(Protocol) - added:
class ZLibBackendWrapper - added:
class ZLibCompressObjProtocol(Protocol) - added:
class ZLibCompressor - added:
class ZLibDecompressObjProtocol(Protocol) - added:
class ZLibDecompressor(ConcatDecompressionHandler[ZLibDecompressObjProtocol]) - added:
class ZSTDDecompressor(ConcatDecompressionHandler['ZstdDecompressor']) - added:
constructor BrotliDecompressor(executor: Executor | None=…, max_sync_chunk_size: int | None=…) -> None - added:
constructor DecompressionBaseHandler(executor: Executor | None=…, max_sync_chunk_size: int | None=…) - added:
constructor ZLibBackendWrapper(_zlib_backend: ZLibBackendProtocol) - added:
constructor ZLibCompressor(encoding: str | None=…, suppress_deflate_header: bool=…, level: int | None=…, wbits: int | None=…, strategy: int | None=…, executor: Executor | None=…, max_sync_chunk_size: int | None=…) - added:
constructor ZLibDecompressor(encoding: str | None=…, suppress_deflate_header: bool=…, executor: Executor | None=…, max_sync_chunk_size: int | None=…) - added:
constructor ZSTDDecompressor(executor: Executor | None=…, max_sync_chunk_size: int | None=…) -> None - added:
field CompressObjArgs.level: int - added:
field CompressObjArgs.strategy: int - added:
field CompressObjArgs.wbits: int - added:
field ZLibBackendProtocol.MAX_WBITS: int - added:
field ZLibBackendProtocol.Z_BEST_SPEED: int - added:
field ZLibBackendProtocol.Z_FINISH: int - added:
field ZLibBackendProtocol.Z_FULL_FLUSH: int - added:
field ZLibBackendProtocol.Z_SYNC_FLUSH: int - added:
function encoding_to_mode(encoding: str | None=…, suppress_deflate_header: bool=…) -> int - added:
function set_zlib_backend(new_zlib_backend: ZLibBackendProtocol) -> None - added:
method BrotliDecompressor.decompress_sync(data: Buffer, max_length: int=…) -> bytes - added:
method BrotliDecompressor.flush() -> bytes - added:
method DecompressionBaseHandler.decompress_sync(data: Buffer, max_length: int=…) -> bytes - added:
method MemberDecompressObjProtocol.decompress(data: Buffer, max_length: int=…) -> bytes - added:
method ZLibBackendProtocol.compress(data: Buffer, /, level: int=…, wbits: int=…) -> bytes - added:
method ZLibBackendProtocol.compressobj(level: int=…, method: int=…, wbits: int=…, memLevel: int=…, strategy: int=…, zdict: Buffer | None=…) -> ZLibCompressObjProtocol - added:
method ZLibBackendProtocol.decompress(data: Buffer, /, wbits: int=…, bufsize: int=…) -> bytes - added:
method ZLibBackendProtocol.decompressobj(wbits: int=…, zdict: Buffer=…) -> ZLibDecompressObjProtocol - added:
method ZLibBackendWrapper.compress(data: Buffer, *args: Any, **kwargs: Any) -> bytes - added:
method ZLibBackendWrapper.compressobj(*args: Any, **kwargs: Any) -> ZLibCompressObjProtocol - added:
method ZLibBackendWrapper.decompress(data: Buffer, *args: Any, **kwargs: Any) -> bytes - added:
method ZLibBackendWrapper.decompressobj(*args: Any, **kwargs: Any) -> ZLibDecompressObjProtocol - added:
method ZLibCompressObjProtocol.compress(data: Buffer) -> bytes - added:
method ZLibCompressObjProtocol.flush(mode: int=…, /) -> bytes - added:
method ZLibCompressor.compress_sync(data: Buffer) -> bytes - added:
method ZLibCompressor.flush(mode: int | None=…) -> bytes - added:
method ZLibDecompressObjProtocol.decompress(data: Buffer, max_length: int=…) -> bytes - added:
method ZLibDecompressObjProtocol.flush(length: int=…, /) -> bytes - added:
method ZLibDecompressor.decompress_sync(data: Buffer, max_length: int=…) -> bytes - added:
method ZLibDecompressor.flush(length: int=…) -> bytes - added:
method ZSTDDecompressor.decompress_sync(data: Buffer, max_length: int=…) -> bytes - added:
method ZSTDDecompressor.flush() -> bytes - added:
property BrotliDecompressor.data_available -> bool - added:
property DecompressionBaseHandler.data_available -> bool - added:
property MemberDecompressObjProtocol.eof -> bool - added:
property MemberDecompressObjProtocol.unused_data -> bytes - added:
property ZLibBackendWrapper.MAX_WBITS -> int - added:
property ZLibBackendWrapper.Z_BEST_SPEED -> int - added:
property ZLibBackendWrapper.Z_FINISH -> int - added:
property ZLibBackendWrapper.Z_FULL_FLUSH -> int - added:
property ZLibBackendWrapper.Z_SYNC_FLUSH -> int - added:
property ZLibBackendWrapper.name -> str - added:
property ZLibDecompressObjProtocol.eof -> bool - added:
property ZLibDecompressObjProtocol.unconsumed_tail -> bytes - added:
property ZLibDecompressObjProtocol.unused_data -> bytes - added:
property ZLibDecompressor.data_available -> bool - added:
property ZLibDecompressor.eof -> bool - added:
property ZSTDDecompressor.data_available -> bool - added:
variable Buffer - added:
variable HAS_BROTLI - added:
variable HAS_ZSTD - added:
variable MAX_DECOMPRESS_MEMBERS - added:
variable MAX_SYNC_CHUNK_SIZE - added:
variable MEMBER_WINDOW_MAX - added:
variable MEMBER_WINDOW_MIN - added:
variable ZLIB_MAX_LENGTH_UNLIMITED - added:
variable ZLibBackend: ZLibBackendWrapper - added:
variable ZSTD_MAX_LENGTH_UNLIMITED
- removed:
property BaseConnector.closed - removed:
property BaseConnector.force_close - removed:
property BaseConnector.limit - removed:
property BaseConnector.limit_per_host - removed:
property TCPConnector.cached_hosts - removed:
property TCPConnector.family - removed:
property TCPConnector.fingerprint - removed:
property TCPConnector.ssl_context - removed:
property TCPConnector.use_dns_cache - removed:
property TCPConnector.verify_ssl - removed:
property UnixConnector.path - changed:
class BaseConnector(object) → class BaseConnector - changed:
constructor BaseConnector(*, keepalive_timeout=…, force_close=…, limit=…, limit_per_host=…, enable_cleanup_closed=…, loop=…) → constructor BaseConnector(*, keepalive_timeout: _SENTINEL | None | float=…, force_close: bool=…, limit: int=…, limit_per_host: int=…, enable_cleanup_closed: bool=…, loop: asyncio.AbstractEventLoop | None=…, timeout_ceil_threshold: float=…) -> None - changed:
constructor TCPConnector(*, verify_ssl=…, fingerprint=…, resolve=…, use_dns_cache=…, ttl_dns_cache=…, family=…, ssl_context=…, local_addr=…, resolver=…, keepalive_timeout=…, force_close=…, limit=…, limit_per_host=…, enable_cleanup_closed=…, loop=…) → constructor TCPConnector(*, verify_ssl: bool=…, fingerprint: bytes | None=…, use_dns_cache: bool=…, ttl_dns_cache: int | None=…, dns_cache_max_size: int=…, family: socket.AddressFamily=…, ssl_context: SSLContext | None=…, ssl: bool | Fingerprint | SSLContext=…, local_addr: tuple[str, int] | None=…, resolver: AbstractResolver | None=…, keepalive_timeout: None | float | _SENTINEL=…, force_close: bo… - changed:
constructor UnixConnector(path, force_close=…, keepalive_timeout=…, limit=…, limit_per_host=…, loop=…) → constructor UnixConnector(path: str, force_close: bool=…, keepalive_timeout: _SENTINEL | float | None=…, limit: int=…, limit_per_host: int=…, loop: asyncio.AbstractEventLoop | None=…) -> None - changed:
method BaseConnector.close() → method BaseConnector.close(*, abort_ssl: bool=…) -> Awaitable[None] - changed:
method BaseConnector.connect(req) → async method BaseConnector.connect(req: ClientRequest, traces: list[Trace], timeout: ClientTimeout) -> Connection - changed:
method TCPConnector.clear_dns_cache(host=…, port=…) → method TCPConnector.clear_dns_cache(host: str | None=…, port: int | None=…) -> None - changed:
method TCPConnector.close() → async method TCPConnector.close(*, abort_ssl: bool=…) -> None - added:
class NamedPipeConnector(BaseConnector) - added:
constructor NamedPipeConnector(path: str, force_close: bool=…, keepalive_timeout: _SENTINEL | float | None=…, limit: int=…, limit_per_host: int=…, loop: asyncio.AbstractEventLoop | None=…) -> None - added:
export AddrInfoType - added:
export SocketFactoryType - added:
field BaseConnector.allowed_protocol_schema_set - added:
field NamedPipeConnector.allowed_protocol_schema_set - added:
field TCPConnector.allowed_protocol_schema_set - added:
field UnixConnector.allowed_protocol_schema_set - added:
property BaseConnector.closed -> bool - added:
property BaseConnector.force_close -> bool - added:
property BaseConnector.limit -> int - added:
property BaseConnector.limit_per_host -> int - added:
property NamedPipeConnector.path -> str - added:
property TCPConnector.family -> int - added:
property TCPConnector.use_dns_cache -> bool - added:
property UnixConnector.path -> str
- changed:
constructor CookieJar(*, unsafe=…, loop=…) → constructor CookieJar(*, unsafe: bool=…, quote_cookie: bool=…, treat_as_secure_origin: StrOrURL | Iterable[StrOrURL] | None=…, loop: asyncio.AbstractEventLoop | None=…) -> None - changed:
constructor DummyCookieJar(*, loop=…) → constructor DummyCookieJar(*, loop: asyncio.AbstractEventLoop | None=…) -> None - changed:
method CookieJar.clear() → method CookieJar.clear(predicate: ClearCookiePredicate | None=…) -> None - changed:
method CookieJar.filter_cookies(request_url=…) → method CookieJar.filter_cookies(request_url: URL=…) -> BaseCookie[str] - changed:
method CookieJar.load(file_path) → method CookieJar.load(file_path: PathLike) -> None - changed:
method CookieJar.save(file_path) → method CookieJar.save(file_path: PathLike) -> None - changed:
method CookieJar.update_cookies(cookies, response_url=…) → method CookieJar.update_cookies(cookies: LooseCookies, response_url: URL=…) -> None - changed:
method DummyCookieJar.clear() → method DummyCookieJar.clear(predicate: ClearCookiePredicate | None=…) -> None - changed:
method DummyCookieJar.filter_cookies(request_url) → method DummyCookieJar.filter_cookies(request_url: URL) -> BaseCookie[str] - changed:
method DummyCookieJar.update_cookies(cookies, response_url=…) → method DummyCookieJar.update_cookies(cookies: LooseCookies, response_url: URL=…) -> None - added:
field CookieJar.SUB_MAX_TIME - added:
method CookieJar.clear_domain(domain: str) -> None - added:
method CookieJar.update_cookies_from_headers(headers: Sequence[str], response_url: URL) -> None - added:
method DummyCookieJar.clear_domain(domain: str) -> None - added:
method DummyCookieJar.update_cookies_from_headers(headers: Sequence[str], response_url: URL) -> None - added:
property CookieJar.cookies -> MappingProxyType[tuple[str, str], SimpleCookie] - added:
property CookieJar.host_only_cookies -> frozenset[tuple[str, str, str]] - added:
property CookieJar.quote_cookie -> bool - added:
property CookieJar.treat_as_secure_origin -> frozenset[URL] - added:
property CookieJar.unsafe -> bool - added:
property DummyCookieJar.cookies -> MappingProxyType[tuple[str, str], SimpleCookie] - added:
property DummyCookieJar.host_only_cookies -> frozenset[tuple[str, str, str]] - added:
property DummyCookieJar.quote_cookie -> bool - added:
property DummyCookieJar.unsafe -> bool
- removed:
property FormData.is_multipart - changed:
constructor FormData(fields=…, quote_fields=…, charset=…) → constructor FormData(fields: Iterable[Any]=…, quote_fields: bool=…, charset: str | None=…, *, default_to_multipart: bool=…) -> None - changed:
method FormData.add_field(name, value, *, content_type=…, filename=…, content_transfer_encoding=…) → method FormData.add_field(name: str, value: Any, *, content_type: str | None=…, filename: str | None=…, content_transfer_encoding: str | None=…) -> None - changed:
method FormData.add_fields(*fields) → method FormData.add_fields(*fields: Any) -> None - added:
property FormData.is_multipart -> bool
- removed:
class PyFrozenList(MutableSequence) - removed:
constructor PyFrozenList(items=…) - removed:
method PyFrozenList.freeze() - removed:
method PyFrozenList.insert(pos, item) - removed:
property PyFrozenList.frozen - removed:
variable FrozenList
- removed:
variable WEBSOCKET - changed:
variable ACCEPT → variable ACCEPT: Final[istr] - changed:
variable ACCEPT_CHARSET → variable ACCEPT_CHARSET: Final[istr] - changed:
variable ACCEPT_ENCODING → variable ACCEPT_ENCODING: Final[istr] - changed:
variable ACCEPT_LANGUAGE → variable ACCEPT_LANGUAGE: Final[istr] - changed:
variable ACCEPT_RANGES → variable ACCEPT_RANGES: Final[istr] - changed:
variable ACCESS_CONTROL_ALLOW_CREDENTIALS → variable ACCESS_CONTROL_ALLOW_CREDENTIALS: Final[istr] - changed:
variable ACCESS_CONTROL_ALLOW_HEADERS → variable ACCESS_CONTROL_ALLOW_HEADERS: Final[istr] - changed:
variable ACCESS_CONTROL_ALLOW_METHODS → variable ACCESS_CONTROL_ALLOW_METHODS: Final[istr] - changed:
variable ACCESS_CONTROL_ALLOW_ORIGIN → variable ACCESS_CONTROL_ALLOW_ORIGIN: Final[istr] - changed:
variable ACCESS_CONTROL_EXPOSE_HEADERS → variable ACCESS_CONTROL_EXPOSE_HEADERS: Final[istr] - changed:
variable ACCESS_CONTROL_MAX_AGE → variable ACCESS_CONTROL_MAX_AGE: Final[istr] - changed:
variable ACCESS_CONTROL_REQUEST_HEADERS → variable ACCESS_CONTROL_REQUEST_HEADERS: Final[istr] - changed:
variable ACCESS_CONTROL_REQUEST_METHOD → variable ACCESS_CONTROL_REQUEST_METHOD: Final[istr] - changed:
variable AGE → variable AGE: Final[istr] - changed:
variable ALLOW → variable ALLOW: Final[istr] - changed:
variable AUTHORIZATION → variable AUTHORIZATION: Final[istr] - changed:
variable CACHE_CONTROL → variable CACHE_CONTROL: Final[istr] - changed:
variable CONNECTION → variable CONNECTION: Final[istr] - changed:
variable CONTENT_DISPOSITION → variable CONTENT_DISPOSITION: Final[istr] - changed:
variable CONTENT_ENCODING → variable CONTENT_ENCODING: Final[istr] - changed:
variable CONTENT_LANGUAGE → variable CONTENT_LANGUAGE: Final[istr] - changed:
variable CONTENT_LENGTH → variable CONTENT_LENGTH: Final[istr] - changed:
variable CONTENT_LOCATION → variable CONTENT_LOCATION: Final[istr] - changed:
variable CONTENT_MD5 → variable CONTENT_MD5: Final[istr] - changed:
variable CONTENT_RANGE → variable CONTENT_RANGE: Final[istr] - changed:
variable CONTENT_TRANSFER_ENCODING → variable CONTENT_TRANSFER_ENCODING: Final[istr] - changed:
variable CONTENT_TYPE → variable CONTENT_TYPE: Final[istr] - changed:
variable COOKIE → variable COOKIE: Final[istr] - changed:
variable DATE → variable DATE: Final[istr] - changed:
variable DESTINATION → variable DESTINATION: Final[istr] - changed:
variable DIGEST → variable DIGEST: Final[istr] - changed:
variable ETAG → variable ETAG: Final[istr] - changed:
variable EXPECT → variable EXPECT: Final[istr] - changed:
variable EXPIRES → variable EXPIRES: Final[istr] - changed:
variable FORWARDED → variable FORWARDED: Final[istr] - changed:
variable FROM → variable FROM: Final[istr] - changed:
variable HOST → variable HOST: Final[istr] - changed:
variable IF_MATCH → variable IF_MATCH: Final[istr] - changed:
variable IF_MODIFIED_SINCE → variable IF_MODIFIED_SINCE: Final[istr] - changed:
variable IF_NONE_MATCH → variable IF_NONE_MATCH: Final[istr] - changed:
variable IF_RANGE → variable IF_RANGE: Final[istr] - changed:
variable IF_UNMODIFIED_SINCE → variable IF_UNMODIFIED_SINCE: Final[istr] - changed:
variable KEEP_ALIVE → variable KEEP_ALIVE: Final[istr] - changed:
variable LAST_EVENT_ID → variable LAST_EVENT_ID: Final[istr] - changed:
variable LAST_MODIFIED → variable LAST_MODIFIED: Final[istr] - changed:
variable LINK → variable LINK: Final[istr] - changed:
variable LOCATION → variable LOCATION: Final[istr] - changed:
variable MAX_FORWARDS → variable MAX_FORWARDS: Final[istr] - changed:
variable METH_ALL → variable METH_ALL: Final[set[str]] - changed:
variable METH_ANY → variable METH_ANY: Final[str] - changed:
variable METH_CONNECT → variable METH_CONNECT: Final[str] - changed:
variable METH_DELETE → variable METH_DELETE: Final[str] - changed:
variable METH_GET → variable METH_GET: Final[str] - changed:
variable METH_HEAD → variable METH_HEAD: Final[str] - changed:
variable METH_OPTIONS → variable METH_OPTIONS: Final[str] - changed:
variable METH_PATCH → variable METH_PATCH: Final[str] - changed:
variable METH_POST → variable METH_POST: Final[str] - changed:
variable METH_PUT → variable METH_PUT: Final[str] - changed:
variable METH_TRACE → variable METH_TRACE: Final[str] - changed:
variable ORIGIN → variable ORIGIN: Final[istr] - changed:
variable PRAGMA → variable PRAGMA: Final[istr] - changed:
variable PROXY_AUTHENTICATE → variable PROXY_AUTHENTICATE: Final[istr] - changed:
variable PROXY_AUTHORIZATION → variable PROXY_AUTHORIZATION: Final[istr] - changed:
variable RANGE → variable RANGE: Final[istr] - changed:
variable REFERER → variable REFERER: Final[istr] - changed:
variable RETRY_AFTER → variable RETRY_AFTER: Final[istr] - changed:
variable SEC_WEBSOCKET_ACCEPT → variable SEC_WEBSOCKET_ACCEPT: Final[istr] - changed:
variable SEC_WEBSOCKET_EXTENSIONS → variable SEC_WEBSOCKET_EXTENSIONS: Final[istr] - changed:
variable SEC_WEBSOCKET_KEY → variable SEC_WEBSOCKET_KEY: Final[istr] - changed:
variable SEC_WEBSOCKET_KEY1 → variable SEC_WEBSOCKET_KEY1: Final[istr] - changed:
variable SEC_WEBSOCKET_PROTOCOL → variable SEC_WEBSOCKET_PROTOCOL: Final[istr] - changed:
variable SEC_WEBSOCKET_VERSION → variable SEC_WEBSOCKET_VERSION: Final[istr] - changed:
variable SERVER → variable SERVER: Final[istr] - changed:
variable SET_COOKIE → variable SET_COOKIE: Final[istr] - changed:
variable TE → variable TE: Final[istr] - changed:
variable TRAILER → variable TRAILER: Final[istr] - changed:
variable TRANSFER_ENCODING → variable TRANSFER_ENCODING: Final[istr] - changed:
variable UPGRADE → variable UPGRADE: Final[istr] - changed:
variable URI → variable URI: Final[istr] - changed:
variable USER_AGENT → variable USER_AGENT: Final[istr] - changed:
variable VARY → variable VARY: Final[istr] - changed:
variable VIA → variable VIA: Final[istr] - changed:
variable WANT_DIGEST → variable WANT_DIGEST: Final[istr] - changed:
variable WARNING → variable WARNING: Final[istr] - changed:
variable WWW_AUTHENTICATE → variable WWW_AUTHENTICATE: Final[istr] - changed:
variable X_FORWARDED_FOR → variable X_FORWARDED_FOR: Final[istr] - changed:
variable X_FORWARDED_HOST → variable X_FORWARDED_HOST: Final[istr] - changed:
variable X_FORWARDED_PROTO → variable X_FORWARDED_PROTO: Final[istr] - added:
variable ACCEPT_CH: Final[istr] - added:
variable ALT_SVC: Final[istr] - added:
variable ALT_USED: Final[istr] - added:
variable AUTHENTICATION_INFO: Final[istr] - added:
variable BAGGAGE: Final[istr] - added:
variable CACHE_STATUS: Final[istr] - added:
variable CDN_CACHE_CONTROL: Final[istr] - added:
variable CDN_LOOP: Final[istr] - added:
variable CLEAR_SITE_DATA: Final[istr] - added:
variable CONTENT_DIGEST: Final[istr] - added:
variable CONTENT_ID: Final[istr] - added:
variable CONTENT_SECURITY_POLICY: Final[istr] - added:
variable CONTENT_SECURITY_POLICY_REPORT_ONLY: Final[istr] - added:
variable CROSS_ORIGIN_EMBEDDER_POLICY: Final[istr] - added:
variable CROSS_ORIGIN_OPENER_POLICY: Final[istr] - added:
variable CROSS_ORIGIN_RESOURCE_POLICY: Final[istr] - added:
variable EARLY_DATA: Final[istr] - added:
variable HOST_ALL: Final - added:
variable NEL: Final[istr] - added:
variable ORIGIN_AGENT_CLUSTER: Final[istr] - added:
variable PERMISSIONS_POLICY: Final[istr] - added:
variable PRIORITY: Final[istr] - added:
variable PROXY_AUTHENTICATION_INFO: Final[istr] - added:
variable REFERRER_POLICY: Final[istr] - added:
variable REPORTING_ENDPOINTS: Final[istr] - added:
variable REPORT_TO: Final[istr] - added:
variable REPR_DIGEST: Final[istr] - added:
variable SEC_CH_UA: Final[istr] - added:
variable SEC_CH_UA_MOBILE: Final[istr] - added:
variable SEC_CH_UA_PLATFORM: Final[istr] - added:
variable SEC_FETCH_DEST: Final[istr] - added:
variable SEC_FETCH_MODE: Final[istr] - added:
variable SEC_FETCH_SITE: Final[istr] - added:
variable SEC_FETCH_USER: Final[istr] - added:
variable SEC_GPC: Final[istr] - added:
variable SEC_PURPOSE: Final[istr] - added:
variable SERVER_TIMING: Final[istr] - added:
variable STRICT_TRANSPORT_SECURITY: Final[istr] - added:
variable TIMING_ALLOW_ORIGIN: Final[istr] - added:
variable TRACEPARENT: Final[istr] - added:
variable TRACESTATE: Final[istr] - added:
variable UPGRADE_INSECURE_REQUESTS: Final[istr] - added:
variable WANT_CONTENT_DIGEST: Final[istr] - added:
variable WANT_REPR_DIGEST: Final[istr] - added:
variable X_CONTENT_TYPE_OPTIONS: Final[istr] - added:
variable X_CORRELATION_ID: Final[istr] - added:
variable X_FORWARDED_PORT: Final[istr] - added:
variable X_FRAME_OPTIONS: Final[istr] - added:
variable X_POWERED_BY: Final[istr] - added:
variable X_RATELIMIT_LIMIT: Final[istr] - added:
variable X_RATELIMIT_REMAINING: Final[istr] - added:
variable X_RATELIMIT_RESET: Final[istr] - added:
variable X_REAL_IP: Final[istr] - added:
variable X_REQUESTED_WITH: Final[istr] - added:
variable X_REQUEST_ID: Final[istr] - added:
variable X_XSS_PROTECTION: Final[istr]
- removed:
variable Timeout - changed:
method BasicAuth.encode() → method BasicAuth.encode() -> str - changed:
static method BasicAuth.decode(auth_header, encoding=…) → static method BasicAuth.decode(auth_header: str, encoding: str=…) -> BasicAuth - changed:
static method BasicAuth.from_url(url, *, encoding=…) → static method BasicAuth.from_url(url: URL, *, encoding: str=…) -> Optional[BasicAuth] - added:
class ChainMapProxy(Mapping[str | AppKey[Any], Any]) - added:
class ETag - added:
constructor ChainMapProxy(maps: Iterable[Mapping[str | AppKey[Any], Any]]) -> None - added:
export reify - added:
field ETag.is_weak: bool - added:
field ETag.value: str - added:
method ChainMapProxy.get(key: AppKey[_T], default: _S) -> _T | _S | (key: AppKey[_T], default: None=…) -> _T | None | (key: str, default: Any=…) -> Any
- removed:
export PayloadWriter - removed:
export do_handshake - changed:
variable RESPONSES → variable RESPONSES: Mapping[int, tuple[str, str]] - changed:
variable SERVER_SOFTWARE → variable SERVER_SOFTWARE: str - added:
export HeadersParser - added:
export WSMessageDecodeText - added:
export WSMessageNoDecodeText - added:
export WSMessageTextBytes - added:
export ws_ext_gen - added:
export ws_ext_parse
- changed:
constructor HttpProcessingError(*, code=…, message=…, headers=…) → constructor HttpProcessingError(*, code: int | None=…, message: str=…, headers: _CIMultiDict | None=…) -> None
- removed:
variable HttpRequestParser - removed:
variable HttpResponseParser - removed:
variable RawRequestMessage - removed:
variable RawResponseMessage - changed:
class HttpParser → class HttpParser(abc.ABC, Generic[_MsgT]) - changed:
constructor HttpParser(protocol=…, loop=…, max_line_size=…, max_headers=…, max_field_size=…, timer=…, code=…, method=…, readall=…, payload_exception=…, response_with_body=…, read_until_eof=…, auto_decompress=…) → constructor HttpParser(protocol: BaseProtocol | None=…, loop: asyncio.AbstractEventLoop | None=…, limit: int=…, max_line_size: int=…, max_headers: int=…, max_field_size: int=…, timer: BaseTimerContext | None=…, code: int | None=…, method: str | None=…, payload_exception: type[BaseException] | None=…, response_with_body: bool=…, read_until_eof: bool=…, auto_decompress: bool=…, max_msg_queue_size:… - changed:
method HttpParser.feed_data(data, SEP=…, EMPTY=…, CONTENT_LENGTH=…, METH_CONNECT=…, SEC_WEBSOCKET_KEY1=…) → method HttpParser.feed_data(data: bytes, SEP: _SEP=…, EMPTY: bytes=…, CONTENT_LENGTH: istr=…, METH_CONNECT: str=…, SEC_WEBSOCKET_KEY1: istr=…) -> tuple[list[tuple[_MsgT, StreamReader]], bool, bytes] - changed:
method HttpParser.feed_eof() → method HttpParser.feed_eof() -> _MsgT | None - changed:
method HttpParser.parse_headers(lines) → method HttpParser.parse_headers(lines: list[bytes]) -> tuple[CIMultiDictProxy[str], RawHeaders, bool | None, str | None, bool, bool] - added:
class HeadersParser - added:
class HttpRequestParser(HttpParser[RawRequestMessage]) - added:
class HttpResponseParser(HttpParser[RawResponseMessage]) - added:
class RawRequestMessage(NamedTuple) - added:
class RawResponseMessage(NamedTuple) - added:
constructor HeadersParser(max_line_size: int=…, max_headers: int=…, max_field_size: int=…, lax: bool=…) -> None - added:
export HttpRequestParser - added:
export HttpResponseParser - added:
export RawRequestMessage - added:
export RawResponseMessage - added:
field HttpParser.lax: ClassVar[bool] - added:
field HttpResponseParser.lax - added:
field HttpResponseParser.protocol: ResponseHandler - added:
field RawRequestMessage.chunked: bool - added:
field RawRequestMessage.compression: str | None - added:
field RawRequestMessage.headers: CIMultiDictProxy[str] - added:
field RawRequestMessage.method: str - added:
field RawRequestMessage.path: str - added:
field RawRequestMessage.raw_headers: RawHeaders - added:
field RawRequestMessage.should_close: bool - added:
field RawRequestMessage.upgrade: bool - added:
field RawRequestMessage.url: URL - added:
field RawRequestMessage.version: HttpVersion - added:
field RawResponseMessage.chunked: bool - added:
field RawResponseMessage.code: int - added:
field RawResponseMessage.compression: str | None - added:
field RawResponseMessage.headers: CIMultiDictProxy[str] - added:
field RawResponseMessage.raw_headers: RawHeaders - added:
field RawResponseMessage.reason: str - added:
field RawResponseMessage.should_close: bool - added:
field RawResponseMessage.upgrade: bool - added:
field RawResponseMessage.version: HttpVersion - added:
method HeadersParser.parse_headers(lines: list[bytes]) -> tuple[CIMultiDictProxy[str], RawHeaders] - added:
method HttpParser.message_consumed() -> None - added:
method HttpParser.parse_message(lines: list[bytes]) -> _MsgT - added:
method HttpParser.pause_reading() -> None - added:
method HttpParser.set_upgraded(val: bool) -> None - added:
method HttpRequestParser.parse_message(lines: list[bytes]) -> RawRequestMessage - added:
method HttpResponseParser.feed_data(data: bytes, SEP: _SEP | None=…, *args: Any, **kwargs: Any) -> tuple[list[tuple[RawResponseMessage, StreamReader]], bool, bytes] - added:
method HttpResponseParser.parse_message(lines: list[bytes]) -> RawResponseMessage
- removed:
class WSCloseCode(IntEnum) - removed:
class WSMessage(_WSMessageBase) - removed:
class WSMsgType(IntEnum) - removed:
class WebSocketError(Exception) - removed:
class WebSocketReader - removed:
class WebSocketWriter - removed:
constructor WebSocketError(code, message) - removed:
constructor WebSocketReader(queue, compress=…) - removed:
constructor WebSocketWriter(stream, *, use_mask=…, limit=…, random=…, compress=…, notakeover=…) - removed:
field WSCloseCode.GOING_AWAY - removed:
field WSCloseCode.INTERNAL_ERROR - removed:
field WSCloseCode.INVALID_TEXT - removed:
field WSCloseCode.MANDATORY_EXTENSION - removed:
field WSCloseCode.MESSAGE_TOO_BIG - removed:
field WSCloseCode.OK - removed:
field WSCloseCode.POLICY_VIOLATION - removed:
field WSCloseCode.PROTOCOL_ERROR - removed:
field WSCloseCode.SERVICE_RESTART - removed:
field WSCloseCode.TRY_AGAIN_LATER - removed:
field WSCloseCode.UNSUPPORTED_DATA - removed:
field WSMsgType.BINARY - removed:
field WSMsgType.CLOSE - removed:
field WSMsgType.CLOSED - removed:
field WSMsgType.CLOSING - removed:
field WSMsgType.CONTINUATION - removed:
field WSMsgType.ERROR - removed:
field WSMsgType.PING - removed:
field WSMsgType.PONG - removed:
field WSMsgType.TEXT - removed:
field WSMsgType.binary - removed:
field WSMsgType.close - removed:
field WSMsgType.closed - removed:
field WSMsgType.closing - removed:
field WSMsgType.error - removed:
field WSMsgType.ping - removed:
field WSMsgType.pong - removed:
field WSMsgType.text - removed:
function do_handshake(method, headers, stream, protocols=…, write_buffer_size=…, compress=…) - removed:
method WSMessage.json(*, loads=…) - removed:
method WebSocketReader.feed_data(data) - removed:
method WebSocketReader.feed_eof() - removed:
method WebSocketReader.parse_frame(buf) - removed:
method WebSocketWriter.close(code=…, message=…) - removed:
method WebSocketWriter.ping(message=…) - removed:
method WebSocketWriter.pong(message=…) - removed:
method WebSocketWriter.send(message, binary=…) - removed:
property WSMessage.tp - removed:
variable WS_CLOSED_MESSAGE - removed:
variable WS_CLOSING_MESSAGE - removed:
variable WS_KEY - added:
export WSCloseCode - added:
export WSHandshakeError - added:
export WSMessage - added:
export WSMessageDecodeText - added:
export WSMessageNoDecodeText - added:
export WSMessageTextBytes - added:
export WSMsgType - added:
export WS_CLOSED_MESSAGE - added:
export WS_CLOSING_MESSAGE - added:
export WS_KEY - added:
export WebSocketError - added:
export WebSocketReader - added:
export WebSocketWriter - added:
export ws_ext_gen - added:
export ws_ext_parse
- removed:
class PayloadWriter(AbstractPayloadWriter) - removed:
constructor PayloadWriter(stream, loop, acquire=…) - removed:
method PayloadWriter.buffer_data(chunk) - removed:
method PayloadWriter.drain(last=…) - removed:
method PayloadWriter.enable_chunking() - removed:
method PayloadWriter.enable_compression(encoding=…) - removed:
method PayloadWriter.set_tcp_cork(value) - removed:
method PayloadWriter.set_tcp_nodelay(value) - removed:
method PayloadWriter.set_transport(transport) - removed:
method PayloadWriter.write(chunk, *, drain=…, LIMIT=…) - removed:
method PayloadWriter.write_eof(chunk=…) - removed:
method PayloadWriter.write_headers(status_line, headers, SEP=…, END=…) - removed:
method StreamWriter.acquire(writer) - removed:
method StreamWriter.release() - removed:
method StreamWriter.replace(writer, factory) - removed:
method StreamWriter.set_tcp_cork(value) - removed:
method StreamWriter.set_tcp_nodelay(value) - removed:
property PayloadWriter.tcp_cork - removed:
property PayloadWriter.tcp_nodelay - removed:
property StreamWriter.tcp_cork - removed:
property StreamWriter.tcp_nodelay - removed:
variable HttpVersion - changed:
class StreamWriter → class StreamWriter(AbstractStreamWriter) - changed:
constructor StreamWriter(protocol, transport, loop) → constructor StreamWriter(protocol: BaseProtocol, loop: asyncio.AbstractEventLoop, on_chunk_sent: _T_OnChunkSent=…, on_headers_sent: _T_OnHeadersSent=…) -> None - changed:
method StreamWriter.drain() → async method StreamWriter.drain() -> None - added:
async method StreamWriter.write(chunk: Buffer, *, drain: bool=…, LIMIT: int=…) -> None - added:
async method StreamWriter.write_eof(chunk: bytes=…) -> None - added:
async method StreamWriter.write_headers(status_line: str, headers: CIMultiDict[str]) -> None - added:
class HttpVersion(NamedTuple) - added:
field HttpVersion.major: int - added:
field HttpVersion.minor: int - added:
field StreamWriter.chunked: bool - added:
field StreamWriter.length: int | None - added:
method StreamWriter.enable_chunking() -> None - added:
method StreamWriter.enable_compression(encoding: str=…, strategy: int | None=…) -> None - added:
method StreamWriter.send_headers() -> None - added:
method StreamWriter.set_eof() -> None - added:
property StreamWriter.protocol -> BaseProtocol - added:
property StreamWriter.transport -> asyncio.Transport | None
- removed:
class EventResultOrError - removed:
constructor EventResultOrError(loop) - removed:
method EventResultOrError.cancel() - removed:
method EventResultOrError.set(exc=…) - removed:
method EventResultOrError.wait()
- removed:
property MultipartWriter.boundary - removed:
property MultipartWriter.size - changed:
class BodyPartReader(object) → class BodyPartReader - changed:
class MultipartReader(object) → class MultipartReader - changed:
constructor BodyPartReader(boundary, headers, content) → constructor BodyPartReader(boundary: bytes, headers: CIMultiDictProxy[str], content: StreamReader, *, subtype: str=…, default_charset: str | None=…, max_decompress_size: int=…, client_max_size: int=…, max_size_error_cls: type[Exception]=…) -> None - changed:
constructor MultipartReader(headers, content) → constructor MultipartReader(headers: Mapping[str, str], content: StreamReader, *, client_max_size: int=…, max_field_size: int=…, max_headers: int=…, max_size_error_cls: type[Exception]=…) -> None - changed:
constructor MultipartWriter(subtype=…, boundary=…) → constructor MultipartWriter(subtype: str=…, boundary: str | None=…) -> None - changed:
field MultipartReader.multipart_reader_cls → field MultipartReader.multipart_reader_cls: type[MultipartReader] | None - changed:
function content_disposition_filename(params, name=…) → function content_disposition_filename(params: Mapping[str, str], name: str=…) -> str | None - changed:
function parse_content_disposition(header) → function parse_content_disposition(header: str | None) -> tuple[str | None, dict[str, str]] - changed:
method BodyPartReader.at_eof() → method BodyPartReader.at_eof() -> bool - changed:
method BodyPartReader.decode(data) → method BodyPartReader.decode(data: _Buffer) -> _Buffer | bytes - changed:
method BodyPartReader.filename() → method BodyPartReader.filename() -> str | None - changed:
method BodyPartReader.form(*, encoding=…) → async method BodyPartReader.form(*, encoding: str | None=…) -> list[tuple[str, str]] - changed:
method BodyPartReader.get_charset(default=…) → method BodyPartReader.get_charset(default: str) -> str - changed:
method BodyPartReader.json(*, encoding=…) → async method BodyPartReader.json(*, encoding: str | None=…) -> dict[str, Any] | None - changed:
method BodyPartReader.name() → method BodyPartReader.name() -> str | None - changed:
method BodyPartReader.next() → async method BodyPartReader.next() -> bytes | None - changed:
method BodyPartReader.read(*, decode=…) → async method BodyPartReader.read(*, decode: bool=…) -> bytes - changed:
method BodyPartReader.read_chunk(size=…) → async method BodyPartReader.read_chunk(size: int=…) -> bytes - changed:
method BodyPartReader.readline() → async method BodyPartReader.readline() -> bytes - changed:
method BodyPartReader.release() → async method BodyPartReader.release() -> None - changed:
method BodyPartReader.text(*, encoding=…) → async method BodyPartReader.text(*, encoding: str | None=…) -> str - changed:
method MultipartReader.at_eof() → method MultipartReader.at_eof() -> bool - changed:
method MultipartReader.fetch_next_part() → async method MultipartReader.fetch_next_part() -> Union[MultipartReader, BodyPartReader] - changed:
method MultipartReader.next() → async method MultipartReader.next() -> Union[MultipartReader, BodyPartReader] | None - changed:
method MultipartReader.release() → async method MultipartReader.release() -> None - changed:
method MultipartWriter.append(obj, headers=…) → method MultipartWriter.append(obj: Any, headers: Mapping[str, str] | None=…) -> Payload - changed:
method MultipartWriter.append_form(obj, headers=…) → method MultipartWriter.append_form(obj: Sequence[tuple[str, str]] | Mapping[str, str], headers: Mapping[str, str] | None=…) -> Payload - changed:
method MultipartWriter.append_json(obj, headers=…) → method MultipartWriter.append_json(obj: Any, headers: Mapping[str, str] | None=…) -> Payload - changed:
method MultipartWriter.append_payload(payload) → method MultipartWriter.append_payload(payload: Payload) -> Payload - changed:
method MultipartWriter.write(writer) → async method MultipartWriter.write(writer: AbstractStreamWriter, close_boundary: bool=…) -> None - changed:
static method MultipartReader.from_response(response) → static method MultipartReader.from_response(response: ClientResponse) -> MultipartResponseWrapper - added:
async method BodyPartReader.decode_iter(data: _Buffer) -> AsyncIterator[_Buffer | bytes] - added:
async method MultipartWriter.as_bytes(encoding: str=…, errors: str=…) -> bytes - added:
async method MultipartWriter.close() -> None - added:
method MultipartWriter.decode(encoding: str=…, errors: str=…) -> str - added:
property MultipartWriter.boundary -> str - added:
property MultipartWriter.consumed -> bool - added:
property MultipartWriter.size -> int | None
- removed:
class StreamReaderPayload(Payload) - removed:
method StreamReaderPayload.write(writer) - removed:
method TextIOPayload.write(writer) - removed:
property BufferedReaderPayload.size - removed:
property BytesIOPayload.size - removed:
property Payload.content_type - removed:
property Payload.encoding - removed:
property Payload.filename - removed:
property Payload.headers - removed:
property Payload.size - removed:
property TextIOPayload.size - changed:
constructor BytesPayload(value, *args, **kwargs) → constructor BytesPayload(value: bytes | bytearray | memoryview, *args: Any, **kwargs: Any) -> None - changed:
constructor IOBasePayload(value, disposition=…, *args, **kwargs) → constructor IOBasePayload(value: IO[Any], disposition: str=…, *args: Any, **kwargs: Any) -> None - changed:
constructor JsonPayload(value, encoding=…, content_type=…, dumps=…, *args, **kwargs) → constructor JsonPayload(value: Any, encoding: str=…, content_type: str=…, dumps: JSONEncoder=…, *args: Any, **kwargs: Any) -> None - changed:
constructor Payload(value, *, headers=…, content_type=…, filename=…, encoding=…, **kwargs) → constructor Payload(value: Any, headers: _CIMultiDict | dict[str, str] | Iterable[tuple[str, str]] | None=…, content_type: str | None | _SENTINEL=…, filename: str | None=…, encoding: str | None=…, **kwargs: Any) -> None - changed:
constructor StringIOPayload(value, *args, **kwargs) → constructor StringIOPayload(value: IO[str], *args: Any, **kwargs: Any) -> None - changed:
constructor StringPayload(value, *args, encoding=…, content_type=…, **kwargs) → constructor StringPayload(value: str, *args: Any, encoding: str | None=…, content_type: str | None=…, **kwargs: Any) -> None - changed:
constructor TextIOPayload(value, *args, encoding=…, content_type=…, **kwargs) → constructor TextIOPayload(value: TextIO, *args: Any, encoding: str | None=…, content_type: str | None=…, **kwargs: Any) -> None - changed:
constructor payload_type(type) → constructor payload_type(type: Any, *, order: Order=…) -> None - changed:
function get_payload(data, *args, **kwargs) → function get_payload(data: Any, *args: Any, **kwargs: Any) -> Payload - changed:
method BytesPayload.write(writer) → async method BytesPayload.write(writer: AbstractStreamWriter) -> None - changed:
method IOBasePayload.write(writer) → async method IOBasePayload.write(writer: AbstractStreamWriter) -> None - changed:
method Payload.set_content_disposition(disptype, quote_fields=…, **params) → method Payload.set_content_disposition(disptype: str, quote_fields: bool=…, _charset: str=…, **params: Any) -> None - changed:
method Payload.write(writer) → async method Payload.write(writer: AbstractStreamWriter) -> None - added:
async method AsyncIterablePayload.as_bytes(encoding: str=…, errors: str=…) -> bytes - added:
async method AsyncIterablePayload.write(writer: AbstractStreamWriter) -> None - added:
async method AsyncIterablePayload.write_with_length(writer: AbstractStreamWriter, content_length: int | None) -> None - added:
async method BytesIOPayload.as_bytes(encoding: str=…, errors: str=…) -> bytes - added:
async method BytesIOPayload.close() -> None - added:
async method BytesIOPayload.write(writer: AbstractStreamWriter) -> None - added:
async method BytesIOPayload.write_with_length(writer: AbstractStreamWriter, content_length: int | None) -> None - added:
async method BytesPayload.as_bytes(encoding: str=…, errors: str=…) -> bytes - added:
async method BytesPayload.write_with_length(writer: AbstractStreamWriter, content_length: int | None) -> None - added:
async method IOBasePayload.as_bytes(encoding: str=…, errors: str=…) -> bytes - added:
async method IOBasePayload.close() -> None - added:
async method IOBasePayload.write_with_length(writer: AbstractStreamWriter, content_length: int | None) -> None - added:
async method Payload.as_bytes(encoding: str=…, errors: str=…) -> bytes - added:
async method Payload.close() -> None - added:
async method Payload.write_with_length(writer: AbstractStreamWriter, content_length: int | None) -> None - added:
async method TextIOPayload.as_bytes(encoding: str=…, errors: str=…) -> bytes - added:
class AsyncIterablePayload(Payload) - added:
class JsonBytesPayload(BytesPayload) - added:
constructor AsyncIterablePayload(value: _AsyncIterable, *args: Any, **kwargs: Any) -> None - added:
constructor BytesIOPayload(value: io.BytesIO, *args: Any, **kwargs: Any) -> None - added:
constructor JsonBytesPayload(value: Any, dumps: JSONBytesEncoder, content_type: str=…, *args: Any, **kwargs: Any) -> None - added:
method AsyncIterablePayload.decode(encoding: str=…, errors: str=…) -> str - added:
method BufferedReaderPayload.decode(encoding: str=…, errors: str=…) -> str - added:
method BytesIOPayload.decode(encoding: str=…, errors: str=…) -> str - added:
method BytesPayload.decode(encoding: str=…, errors: str=…) -> str - added:
method IOBasePayload.decode(encoding: str=…, errors: str=…) -> str - added:
method Payload.decode(encoding: str=…, errors: str=…) -> str - added:
method TextIOPayload.decode(encoding: str=…, errors: str=…) -> str - added:
property BytesIOPayload.size -> int - added:
property IOBasePayload.size -> int | None - added:
property Payload.autoclose -> bool - added:
property Payload.consumed -> bool - added:
property Payload.content_type -> str - added:
property Payload.encoding -> str | None - added:
property Payload.filename -> str | None - added:
property Payload.headers -> _CIMultiDict - added:
property Payload.size -> int | None
- changed:
constructor streamer(coro) → constructor streamer(coro: Callable[..., Awaitable[None]]) -> None
- removed:
function shorttmpdir() - removed:
variable tokio - changed:
function loop(loop_factory, fast, loop_debug) → function loop(loop_factory: Callable[[], asyncio.AbstractEventLoop], fast: bool, loop_debug: bool) -> Iterator[asyncio.AbstractEventLoop] - changed:
function pytest_fixture_setup(fixturedef, request) → function pytest_fixture_setup(fixturedef) - changed:
function raw_test_server(loop) → function raw_test_server(aiohttp_raw_server) - changed:
function test_client(loop) → function test_client(aiohttp_client) - changed:
function test_server(loop) → function test_server(aiohttp_server) - changed:
function unused_port() → function unused_port(aiohttp_unused_port: Callable[[], int]) -> Callable[[], int] - added:
class AiohttpClient(Protocol) - added:
class AiohttpRawServer(Protocol) - added:
class AiohttpServer(Protocol) - added:
function aiohttp_client(loop: asyncio.AbstractEventLoop) -> Iterator[AiohttpClient] - added:
function aiohttp_raw_server(loop: asyncio.AbstractEventLoop) -> Iterator[AiohttpRawServer] - added:
function aiohttp_server(loop: asyncio.AbstractEventLoop) -> Iterator[AiohttpServer] - added:
function aiohttp_unused_port() -> Callable[[], int] - added:
function proactor_loop() -> Iterator[asyncio.AbstractEventLoop]
- changed:
constructor AsyncResolver(loop=…, *args, **kwargs) → constructor AsyncResolver(loop: asyncio.AbstractEventLoop | None=…, *args: Any, **kwargs: Any) -> None - changed:
constructor ThreadedResolver(loop=…) → constructor ThreadedResolver(loop: asyncio.AbstractEventLoop | None=…) -> None - changed:
method AsyncResolver.close() → async method AsyncResolver.close() -> None - changed:
method AsyncResolver.resolve(host, port=…, family=…) → async method AsyncResolver.resolve(host: str, port: int=…, family: socket.AddressFamily=…) -> list[ResolveResult] - changed:
method ThreadedResolver.close() → async method ThreadedResolver.close() -> None - changed:
method ThreadedResolver.resolve(host, port=…, family=…) → async method ThreadedResolver.resolve(host: str, port: int=…, family: socket.AddressFamily=…) -> list[ResolveResult] - changed:
variable DefaultResolver → variable DefaultResolver: _DefaultType
- removed:
class BaseSignal(FrozenList) - removed:
class DebugSignal(BaseSignal) - removed:
class FuncSignal(BaseSignal) - removed:
class PostSignal(DebugSignal) - removed:
class PreSignal(DebugSignal) - removed:
class Signal(BaseSignal) - removed:
constructor PreSignal() - removed:
constructor Signal(app) - removed:
method DebugSignal.send(ordinal, name, *args, **kwargs) - removed:
method FuncSignal.send(*args, **kwargs) - removed:
method PreSignal.ordinal() - removed:
method Signal.send(*args, **kwargs)
- removed:
class ChunksQueue(DataQueue) - removed:
class FlowControlChunksQueue(FlowControlDataQueue) - removed:
class FlowControlDataQueue(DataQueue) - removed:
class FlowControlStreamReader(StreamReader) - removed:
constructor FlowControlDataQueue(protocol, *, limit=…, loop=…) - removed:
constructor FlowControlStreamReader(protocol, buffer_limit=…, *args, **kwargs) - removed:
field ChunksQueue.readany - removed:
field FlowControlChunksQueue.readany - removed:
field StreamReader.total_bytes - removed:
method ChunksQueue.read() - removed:
method FlowControlChunksQueue.read() - removed:
method FlowControlDataQueue.feed_data(data, size) - removed:
method FlowControlDataQueue.read() - removed:
method FlowControlStreamReader.feed_data(data, size=…) - removed:
method FlowControlStreamReader.read(n=…) - removed:
method FlowControlStreamReader.read_nowait(n=…) - removed:
method FlowControlStreamReader.readany() - removed:
method FlowControlStreamReader.readchunk() - removed:
method FlowControlStreamReader.readexactly(n) - removed:
method FlowControlStreamReader.readline() - changed:
class DataQueue → class DataQueue(Generic[_T]) - changed:
class StreamReader(AsyncStreamReaderMixin) → class StreamReader - changed:
constructor DataQueue(*, loop=…) → constructor DataQueue(loop: asyncio.AbstractEventLoop) -> None - changed:
constructor StreamReader(limit=…, timer=…, loop=…) → constructor StreamReader(protocol: BaseProtocol, limit: int, *, timer: BaseTimerContext | None=…, loop: asyncio.AbstractEventLoop | None=…) -> None - changed:
method DataQueue.at_eof() → method DataQueue.at_eof() -> bool - changed:
method DataQueue.exception() → method DataQueue.exception() -> BaseException | None - changed:
method DataQueue.feed_data(data, size=…) → method DataQueue.feed_data(data: _T, size: int=…) -> None - changed:
method DataQueue.feed_eof() → method DataQueue.feed_eof() -> None - changed:
method DataQueue.is_eof() → method DataQueue.is_eof() -> bool - changed:
method DataQueue.read() → async method DataQueue.read() -> _T - changed:
method DataQueue.set_exception(exc) → method DataQueue.set_exception(exc: BaseException, exc_cause: BaseException=…) -> None - changed:
method StreamReader.at_eof() → method StreamReader.at_eof() -> bool - changed:
method StreamReader.begin_http_chunk_receiving() → method StreamReader.begin_http_chunk_receiving() -> None - changed:
method StreamReader.end_http_chunk_receiving() → method StreamReader.end_http_chunk_receiving() -> None - changed:
method StreamReader.exception() → method StreamReader.exception() -> BaseException | None - changed:
method StreamReader.feed_data(data) → method StreamReader.feed_data(data: bytes, size: int=…) -> bool - changed:
method StreamReader.feed_eof() → method StreamReader.feed_eof() -> None - changed:
method StreamReader.is_eof() → method StreamReader.is_eof() -> bool - changed:
method StreamReader.on_eof(callback) → method StreamReader.on_eof(callback: Callable[[], None]) -> None - changed:
method StreamReader.read(n=…) → async method StreamReader.read(n: int=…) -> bytes - changed:
method StreamReader.read_nowait(n=…) → method StreamReader.read_nowait(n: int=…) -> bytes - changed:
method StreamReader.readany() → async method StreamReader.readany() -> bytes - changed:
method StreamReader.readchunk() → async method StreamReader.readchunk() -> tuple[bytes, bool] - changed:
method StreamReader.readexactly(n) → async method StreamReader.readexactly(n: int) -> bytes - changed:
method StreamReader.readline() → async method StreamReader.readline(*, max_line_length: int | None=…) -> bytes - changed:
method StreamReader.set_exception(exc) → method StreamReader.set_exception(exc: BaseException, exc_cause: BaseException=…) -> None - changed:
method StreamReader.unread_data(data) → method StreamReader.unread_data(data: bytes) -> None - changed:
method StreamReader.wait_eof() → async method StreamReader.wait_eof() -> None - changed:
variable EMPTY_PAYLOAD → variable EMPTY_PAYLOAD: Final[StreamReader] - added:
async method StreamReader.readuntil(separator: bytes=…, *, max_size: int | None=…) -> bytes - added:
method StreamReader.get_read_buffer_limits() -> tuple[int, int] - added:
method StreamReader.iter_any() -> AsyncStreamIterator[bytes] - added:
method StreamReader.iter_chunked(n: int) -> AsyncStreamIterator[bytes] - added:
method StreamReader.iter_chunks() -> ChunkTupleAsyncStreamIterator - added:
method StreamReader.set_read_chunk_size(n: int) -> None - added:
property StreamReader.total_raw_bytes -> int
- added:
function tcp_keepalive(transport: asyncio.Transport) -> None - added:
function tcp_nodelay(transport: asyncio.Transport, value: bool) -> None
- removed:
function run_briefly(loop) - removed:
method AioHTTPTestCase.setUp() - removed:
method AioHTTPTestCase.tearDown() - removed:
property BaseTestServer.closed - removed:
property BaseTestServer.started - removed:
property TestClient.host - removed:
property TestClient.port - removed:
property TestClient.server - removed:
property TestClient.session - changed:
class AioHTTPTestCase(unittest.TestCase) → class AioHTTPTestCase(IsolatedAsyncioTestCase) - changed:
class TestClient → class TestClient(Generic[_Request, _ApplicationNone]) - changed:
constructor BaseTestServer(*, scheme=…, loop=…, host=…, skip_url_asserts=…, **kwargs) → constructor BaseTestServer(*, scheme: str=…, loop: asyncio.AbstractEventLoop | None=…, host: str=…, port: int | None=…, skip_url_asserts: bool=…, socket_factory: Callable[[str, int, socket.AddressFamily], socket.socket]=…, **kwargs: Any) -> None - changed:
constructor RawTestServer(handler, *, scheme=…, host=…, **kwargs) → constructor RawTestServer(handler: _RequestHandler, *, scheme: str=…, host: str=…, port: int | None=…, **kwargs: Any) -> None - changed:
constructor TestClient(server, *, cookie_jar=…, loop=…, **kwargs) → constructor TestClient(server: TestServer, *, cookie_jar: AbstractCookieJar | None=…, **kwargs: Any) -> None | (server: BaseTestServer, *, cookie_jar: AbstractCookieJar | None=…, **kwargs: Any) -> None - changed:
constructor TestServer(app, *, scheme=…, host=…, **kwargs) → constructor TestServer(app: Application, *, scheme: str=…, host: str=…, port: int | None=…, **kwargs: Any) - changed:
function loop_context(loop_factory=…, fast=…) → function loop_context(loop_factory: _LOOP_FACTORY=…, fast: bool=…) -> Iterator[asyncio.AbstractEventLoop] - changed:
function make_mocked_coro(return_value=…, raise_exception=…) → function make_mocked_coro(return_value: Any=…, raise_exception: Any=…) -> Any - changed:
function make_mocked_request(method, path, headers=…, *, match_info=…, version=…, closing=…, app=…, writer=…, payload_writer=…, protocol=…, transport=…, payload=…, sslcontext=…, client_max_size=…, loop=…) → function make_mocked_request(method: str, path: str, headers: Any=…, *, match_info: Any=…, version: HttpVersion=…, closing: bool=…, app: Any=…, writer: Any=…, protocol: Any=…, transport: Any=…, payload: StreamReader=…, sslcontext: SSLContext | None=…, client_max_size: int=…, client_max_fields: int=…, loop: Any=…) -> Request - changed:
function setup_test_loop(loop_factory=…) → function setup_test_loop(loop_factory: _LOOP_FACTORY=…) -> asyncio.AbstractEventLoop - changed:
function teardown_test_loop(loop, fast=…) → function teardown_test_loop(loop: asyncio.AbstractEventLoop, fast: bool=…) -> None - changed:
function unittest_run_loop(func, *args, **kwargs) → function unittest_run_loop(func: Any, *args: Any, **kwargs: Any) -> Any - changed:
function unused_port() → function unused_port() -> int - changed:
method AioHTTPTestCase.get_app() → method AioHTTPTestCase.get_app() -> Application - changed:
method AioHTTPTestCase.get_application() → async method AioHTTPTestCase.get_application() -> Application - changed:
method AioHTTPTestCase.get_client(server) → async method AioHTTPTestCase.get_client(server: TestServer) -> TestClient[Request, Application] - changed:
method AioHTTPTestCase.get_server(app) → async method AioHTTPTestCase.get_server(app: Application) -> TestServer - changed:
method AioHTTPTestCase.setUpAsync() → async method AioHTTPTestCase.setUpAsync() -> None - changed:
method AioHTTPTestCase.tearDownAsync() → async method AioHTTPTestCase.tearDownAsync() -> None - changed:
method BaseTestServer.close() → async method BaseTestServer.close() -> None - changed:
method BaseTestServer.make_url(path) → method BaseTestServer.make_url(path: StrOrURL) -> URL - changed:
method BaseTestServer.start_server(loop=…, **kwargs) → async method BaseTestServer.start_server(loop: asyncio.AbstractEventLoop | None=…, **kwargs: Any) -> None - changed:
method TestClient.close() → async method TestClient.close() -> None - changed:
method TestClient.delete(path, *args, **kwargs) → method TestClient.delete(path: StrOrURL, **kwargs: Any) -> _RequestContextManager - changed:
method TestClient.get(path, *args, **kwargs) → method TestClient.get(path: StrOrURL, **kwargs: Any) -> _RequestContextManager - changed:
method TestClient.head(path, *args, **kwargs) → method TestClient.head(path: StrOrURL, **kwargs: Any) -> _RequestContextManager - changed:
method TestClient.make_url(path) → method TestClient.make_url(path: StrOrURL) -> URL - changed:
method TestClient.options(path, *args, **kwargs) → method TestClient.options(path: StrOrURL, **kwargs: Any) -> _RequestContextManager - changed:
method TestClient.patch(path, *args, **kwargs) → method TestClient.patch(path: StrOrURL, **kwargs: Any) -> _RequestContextManager - changed:
method TestClient.post(path, *args, **kwargs) → method TestClient.post(path: StrOrURL, **kwargs: Any) -> _RequestContextManager - changed:
method TestClient.put(path, *args, **kwargs) → method TestClient.put(path: StrOrURL, **kwargs: Any) -> _RequestContextManager - changed:
method TestClient.request(method, path, *args, **kwargs) → method TestClient.request(method: str, path: StrOrURL, **kwargs: Any) -> _RequestContextManager - changed:
method TestClient.start_server() → async method TestClient.start_server() -> None - changed:
method TestClient.ws_connect(path, *args, **kwargs) → method TestClient.ws_connect(path: StrOrURL, *, decode_text: Literal[True]=…, **kwargs: Any) -> _BaseRequestContextManager[ClientWebSocketResponse[Literal[True]]] | (path: StrOrURL, *, decode_text: Literal[False], **kwargs: Any) -> _BaseRequestContextManager[ClientWebSocketResponse[Literal[False]]] | (path: StrOrURL, *, decode_text: bool=…, **kwargs: Any) -> _BaseRequestContextManager[ClientWebSo… - added:
async method AioHTTPTestCase.asyncSetUp() -> None - added:
async method AioHTTPTestCase.asyncTearDown() -> None - added:
function get_port_socket(host: str, port: int, family: socket.AddressFamily) -> socket.socket - added:
function get_unused_port_socket(host: str, family: socket.AddressFamily=…) -> socket.socket - added:
property BaseTestServer.closed -> bool - added:
property BaseTestServer.handler -> Server - added:
property BaseTestServer.started -> bool - added:
property TestClient.app -> _ApplicationNone - added:
property TestClient.host -> str - added:
property TestClient.port -> int | None - added:
property TestClient.server -> BaseTestServer - added:
property TestClient.session -> ClientSession - added:
variable REUSE_ADDRESS - added:
variable SSLContext - added:
variable Self
- added:
class TraceConfig - added:
class TraceConnectionCreateEndParams - added:
class TraceConnectionCreateStartParams - added:
class TraceConnectionQueuedEndParams - added:
class TraceConnectionQueuedStartParams - added:
class TraceConnectionReuseconnParams - added:
class TraceDnsCacheHitParams - added:
class TraceDnsCacheMissParams - added:
class TraceDnsResolveHostEndParams - added:
class TraceDnsResolveHostStartParams - added:
class TraceRequestChunkSentParams - added:
class TraceRequestEndParams - added:
class TraceRequestExceptionParams - added:
class TraceRequestHeadersSentParams - added:
class TraceRequestRedirectParams - added:
class TraceRequestStartParams - added:
class TraceResponseChunkReceivedParams - added:
constructor TraceConfig(trace_config_ctx_factory: type[SimpleNamespace]=…) -> None - added:
field TraceDnsCacheHitParams.host: str - added:
field TraceDnsCacheMissParams.host: str - added:
field TraceDnsResolveHostEndParams.host: str - added:
field TraceDnsResolveHostStartParams.host: str - added:
field TraceRequestChunkSentParams.chunk: bytes - added:
field TraceRequestChunkSentParams.method: str - added:
field TraceRequestChunkSentParams.url: URL - added:
field TraceRequestEndParams.headers: CIMultiDict[str] - added:
field TraceRequestEndParams.method: str - added:
field TraceRequestEndParams.response: ClientResponse - added:
field TraceRequestEndParams.url: URL - added:
field TraceRequestExceptionParams.exception: BaseException - added:
field TraceRequestExceptionParams.headers: CIMultiDict[str] - added:
field TraceRequestExceptionParams.method: str - added:
field TraceRequestExceptionParams.url: URL - added:
field TraceRequestHeadersSentParams.headers: CIMultiDict[str] - added:
field TraceRequestHeadersSentParams.method: str - added:
field TraceRequestHeadersSentParams.url: URL - added:
field TraceRequestRedirectParams.headers: CIMultiDict[str] - added:
field TraceRequestRedirectParams.method: str - added:
field TraceRequestRedirectParams.response: ClientResponse - added:
field TraceRequestRedirectParams.url: URL - added:
field TraceRequestStartParams.headers: CIMultiDict[str] - added:
field TraceRequestStartParams.method: str - added:
field TraceRequestStartParams.url: URL - added:
field TraceResponseChunkReceivedParams.chunk: bytes - added:
field TraceResponseChunkReceivedParams.method: str - added:
field TraceResponseChunkReceivedParams.url: URL - added:
method TraceConfig.freeze() -> None - added:
method TraceConfig.trace_config_ctx(trace_request_ctx: Any=…) -> SimpleNamespace - added:
property TraceConfig.on_connection_create_end -> _TracingSignal[TraceConnectionCreateEndParams] - added:
property TraceConfig.on_connection_create_start -> _TracingSignal[TraceConnectionCreateStartParams] - added:
property TraceConfig.on_connection_queued_end -> _TracingSignal[TraceConnectionQueuedEndParams] - added:
property TraceConfig.on_connection_queued_start -> _TracingSignal[TraceConnectionQueuedStartParams] - added:
property TraceConfig.on_connection_reuseconn -> _TracingSignal[TraceConnectionReuseconnParams] - added:
property TraceConfig.on_dns_cache_hit -> _TracingSignal[TraceDnsCacheHitParams] - added:
property TraceConfig.on_dns_cache_miss -> _TracingSignal[TraceDnsCacheMissParams] - added:
property TraceConfig.on_dns_resolvehost_end -> _TracingSignal[TraceDnsResolveHostEndParams] - added:
property TraceConfig.on_dns_resolvehost_start -> _TracingSignal[TraceDnsResolveHostStartParams] - added:
property TraceConfig.on_request_chunk_sent -> _TracingSignal[TraceRequestChunkSentParams] - added:
property TraceConfig.on_request_end -> _TracingSignal[TraceRequestEndParams] - added:
property TraceConfig.on_request_exception -> _TracingSignal[TraceRequestExceptionParams] - added:
property TraceConfig.on_request_headers_sent -> _TracingSignal[TraceRequestHeadersSentParams] - added:
property TraceConfig.on_request_redirect -> _TracingSignal[TraceRequestRedirectParams] - added:
property TraceConfig.on_request_start -> _TracingSignal[TraceRequestStartParams] - added:
property TraceConfig.on_response_chunk_received -> _TracingSignal[TraceResponseChunkReceivedParams]
- added:
class Middleware(Protocol) - added:
variable Byteish - added:
variable DEFAULT_JSON_DECODER - added:
variable DEFAULT_JSON_ENCODER - added:
variable Handler - added:
variable JSONBytesEncoder - added:
variable JSONDecoder - added:
variable JSONEncoder - added:
variable LooseCookies - added:
variable LooseCookiesIterables - added:
variable LooseCookiesMappings - added:
variable LooseHeaders - added:
variable PathLike - added:
variable Query - added:
variable RawHeaders - added:
variable StrOrURL
- removed:
class Application(MutableMapping) - removed:
class GracefulExit(SystemExit) - removed:
constructor Application(*, logger=…, router=…, middlewares=…, handler_args=…, client_max_size=…, loop=…, debug=…) - removed:
field GracefulExit.code - removed:
function main(argv) - removed:
function raise_graceful_exit() - removed:
method Application.add_subapp(prefix, subapp) - removed:
method Application.cleanup() - removed:
method Application.freeze() - removed:
method Application.make_handler(*, loop=…, access_log_class=…, **kwargs) - removed:
method Application.shutdown() - removed:
method Application.startup() - removed:
property Application.debug - removed:
property Application.frozen - removed:
property Application.loop - removed:
property Application.middlewares - removed:
property Application.on_cleanup - removed:
property Application.on_loop_available - removed:
property Application.on_post_signal - removed:
property Application.on_pre_signal - removed:
property Application.on_response_prepare - removed:
property Application.on_shutdown - removed:
property Application.on_startup - removed:
property Application.router - changed:
function run_app(app, *, host=…, port=…, path=…, sock=…, shutdown_timeout=…, ssl_context=…, print=…, backlog=…, access_log_format=…, access_log=…, handle_signals=…, loop=…) → function run_app(app: Application | Awaitable[Application], *, host: str | HostSequence | None=…, port: int | None=…, path: PathLike | TypingIterable[PathLike] | None=…, sock: socket.socket | TypingIterable[socket.socket] | None=…, shutdown_timeout: float=…, keepalive_timeout: float=…, ssl_context: SSLContext | None=…, print: Callable[..., None] | None=…, backlog: int=…, access_log_class: type[Ab… - added:
export AbstractResource - added:
export AbstractRoute - added:
export AbstractRouteDef - added:
export AppKey - added:
export AppRunner - added:
export Application - added:
export BaseRequest - added:
export BaseRunner - added:
export BaseSite - added:
export CleanupError - added:
export ContentCoding - added:
export DynamicResource - added:
export FileField - added:
export FileResponse - added:
export GracefulExit - added:
export HTTPAccepted - added:
export HTTPBadGateway - added:
export HTTPBadRequest - added:
export HTTPClientError - added:
export HTTPConflict - added:
export HTTPCreated - added:
export HTTPError - added:
export HTTPException - added:
export HTTPExpectationFailed - added:
export HTTPFailedDependency - added:
export HTTPForbidden - added:
export HTTPFound - added:
export HTTPGatewayTimeout - added:
export HTTPGone - added:
export HTTPInsufficientStorage - added:
export HTTPInternalServerError - added:
export HTTPLengthRequired - added:
export HTTPMethodNotAllowed - added:
export HTTPMisdirectedRequest - added:
export HTTPMove - added:
export HTTPMovedPermanently - added:
export HTTPMultipleChoices - added:
export HTTPNetworkAuthenticationRequired - added:
export HTTPNoContent - added:
export HTTPNonAuthoritativeInformation - added:
export HTTPNotAcceptable - added:
export HTTPNotExtended - added:
export HTTPNotFound - added:
export HTTPNotImplemented - added:
export HTTPNotModified - added:
export HTTPOk - added:
export HTTPPartialContent - added:
export HTTPPaymentRequired - added:
export HTTPPermanentRedirect - added:
export HTTPPreconditionFailed - added:
export HTTPPreconditionRequired - added:
export HTTPProxyAuthenticationRequired - added:
export HTTPRedirection - added:
export HTTPRequestEntityTooLarge - added:
export HTTPRequestHeaderFieldsTooLarge - added:
export HTTPRequestRangeNotSatisfiable - added:
export HTTPRequestTimeout - added:
export HTTPRequestURITooLong - added:
export HTTPResetContent - added:
export HTTPSeeOther - added:
export HTTPServerError - added:
export HTTPServiceUnavailable - added:
export HTTPSuccessful - added:
export HTTPTemporaryRedirect - added:
export HTTPTooManyRequests - added:
export HTTPUnauthorized - added:
export HTTPUnavailableForLegalReasons - added:
export HTTPUnprocessableEntity - added:
export HTTPUnsupportedMediaType - added:
export HTTPUpgradeRequired - added:
export HTTPUseProxy - added:
export HTTPVariantAlsoNegotiates - added:
export HTTPVersionNotSupported - added:
export NamedPipeSite - added:
export NotAppKeyWarning - added:
export PayloadAccessError - added:
export PlainResource - added:
export PrefixedSubAppResource - added:
export Request - added:
export RequestHandler - added:
export RequestKey - added:
export RequestPayloadError - added:
export Resource - added:
export ResourceRoute - added:
export Response - added:
export ResponseKey - added:
export RouteDef - added:
export RouteTableDef - added:
export Server - added:
export ServerRunner - added:
export SockSite - added:
export StaticDef - added:
export StaticResource - added:
export StreamResponse - added:
export TCPSite - added:
export UnixSite - added:
export UrlDispatcher - added:
export UrlMappingMatchInfo - added:
export View - added:
export WSMsgType - added:
export WebSocketReady - added:
export WebSocketResponse - added:
export delete - added:
export get - added:
export head - added:
export json_bytes_response - added:
export json_response - added:
export middleware - added:
export normalize_path_middleware - added:
export options - added:
export patch - added:
export post - added:
export put - added:
export route - added:
export static - added:
export view
- added:
async method Application.cleanup() -> None - added:
async method Application.shutdown() -> None - added:
async method Application.startup() -> None - added:
class Application(MutableMapping[str | AppKey[Any], Any]) - added:
class CleanupError(RuntimeError) - added:
constructor Application(*, logger: logging.Logger=…, router: UrlDispatcher | None=…, middlewares: Iterable[Middleware]=…, handler_args: Mapping[str, Any] | None=…, client_max_size: int=…, client_max_fields: int=…, loop: asyncio.AbstractEventLoop | None=…, debug: Any=…) -> None - added:
field Application.ATTRS - added:
method Application.add_domain(domain: str, subapp: Application) -> MatchedSubAppResource - added:
method Application.add_routes(routes: Iterable[AbstractRouteDef]) -> list[AbstractRoute] - added:
method Application.add_subapp(prefix: str, subapp: Application) -> PrefixedSubAppResource - added:
method Application.freeze() -> None - added:
method Application.get(key: AppKey[_T], default: None=…) -> _T | None | (key: AppKey[_T], default: _U) -> _T | _U | (key: str, default: Any=…) -> Any - added:
method Application.make_handler(*, loop: asyncio.AbstractEventLoop | None=…, access_log_class: type[AbstractAccessLogger]=…, **kwargs: Any) -> Server - added:
method Application.pre_freeze() -> None - added:
property Application.cleanup_ctx -> CleanupContext - added:
property Application.debug -> bool - added:
property Application.frozen -> bool - added:
property Application.loop -> asyncio.AbstractEventLoop - added:
property Application.middlewares -> _Middlewares - added:
property Application.on_cleanup -> _AppSignal - added:
property Application.on_response_prepare -> _RespPrepareSignal - added:
property Application.on_shutdown -> _AppSignal - added:
property Application.on_startup -> _AppSignal - added:
property Application.pre_frozen -> bool - added:
property Application.router -> UrlDispatcher - added:
property CleanupError.exceptions -> list[BaseException]
- changed:
class HTTPFound(_HTTPMove) → class HTTPFound(HTTPMove) - changed:
class HTTPMovedPermanently(_HTTPMove) → class HTTPMovedPermanently(HTTPMove) - changed:
class HTTPMultipleChoices(_HTTPMove) → class HTTPMultipleChoices(HTTPMove) - changed:
class HTTPPermanentRedirect(_HTTPMove) → class HTTPPermanentRedirect(HTTPMove) - changed:
class HTTPSeeOther(_HTTPMove) → class HTTPSeeOther(HTTPMove) - changed:
class HTTPTemporaryRedirect(_HTTPMove) → class HTTPTemporaryRedirect(HTTPMove) - changed:
class HTTPUseProxy(_HTTPMove) → class HTTPUseProxy(HTTPMove) - changed:
constructor HTTPException(*, headers=…, reason=…, body=…, text=…, content_type=…) → constructor HTTPException(*, headers: LooseHeaders | None=…, reason: str | None=…, body: Any=…, text: str | None=…, content_type: str | None=…) -> None - changed:
constructor HTTPMethodNotAllowed(method, allowed_methods, *, headers=…, reason=…, body=…, text=…, content_type=…) → constructor HTTPMethodNotAllowed(method: str, allowed_methods: Iterable[str], *, headers: LooseHeaders | None=…, reason: str | None=…, body: Any=…, text: str | None=…, content_type: str | None=…) -> None - changed:
constructor HTTPUnavailableForLegalReasons(link, *, headers=…, reason=…, body=…, text=…, content_type=…) → constructor HTTPUnavailableForLegalReasons(link: StrOrURL | None, *, headers: LooseHeaders | None=…, reason: str | None=…, body: Any=…, text: str | None=…, content_type: str | None=…) -> None - added:
class HTTPMove(HTTPRedirection) - added:
constructor HTTPMove(location: StrOrURL, *, headers: LooseHeaders | None=…, reason: str | None=…, body: Any=…, text: str | None=…, content_type: str | None=…) -> None - added:
constructor HTTPRequestEntityTooLarge(max_size: float, actual_size: float=…, **kwargs: Any) -> None - added:
property HTTPUnavailableForLegalReasons.link -> URL | None
- changed:
constructor FileResponse(path, chunk_size=…, *args, **kwargs) → constructor FileResponse(path: PathLike, chunk_size: int=…, status: int=…, reason: str | None=…, headers: LooseHeaders | None=…) -> None - changed:
method FileResponse.prepare(request) → async method FileResponse.prepare(request: BaseRequest) -> AbstractStreamWriter | None
- added:
class AccessLogger(AbstractAccessLogger) - added:
class KeyMethod(NamedTuple) - added:
constructor AccessLogger(logger: logging.Logger, log_format: str=…) -> None - added:
field AccessLogger.CLEANUP_RE - added:
field AccessLogger.FORMAT_RE - added:
field AccessLogger.LOG_FORMAT - added:
field AccessLogger.LOG_FORMAT_MAP - added:
field KeyMethod.key: str | tuple[str, str] - added:
field KeyMethod.method: Callable[[BaseRequest, StreamResponse, float], str] - added:
method AccessLogger.compile_format(log_format: str) -> tuple[str, list[KeyMethod]] - added:
method AccessLogger.log(request: BaseRequest, response: StreamResponse, time: float) -> None - added:
property AccessLogger.enabled -> bool
- changed:
function middleware(f) → function middleware(f: _Func) -> _Func - changed:
function normalize_path_middleware(*, append_slash=…, merge_slashes=…, redirect_class=…) → function normalize_path_middleware(*, append_slash: bool=…, remove_slash: bool=…, merge_slashes: bool=…, redirect_class: type[HTTPMove]=…) -> Middleware
- removed:
field RequestHandler.KEEPALIVE_RESCHEDULE_DELAY - removed:
method RequestHandler.handle_parse_error(writer, status, exc=…, message=…) - removed:
method RequestHandler.pause_reading() - removed:
method RequestHandler.resume_reading() - removed:
property RequestHandler.keepalive_timeout - changed:
class RequestHandler(asyncio.streams.FlowControlMixin, asyncio.Protocol) → class RequestHandler(BaseProtocol) - changed:
constructor RequestHandler(manager, *, loop=…, keepalive_timeout=…, tcp_keepalive=…, slow_request_timeout=…, logger=…, access_log_class=…, access_log=…, access_log_format=…, debug=…, max_line_size=…, max_headers=…, max_field_size=…, lingering_time=…, max_concurrent_handlers=…, **kwargs) → constructor RequestHandler(manager: Server, *, loop: asyncio.AbstractEventLoop, keepalive_timeout: float=…, tcp_keepalive: bool=…, logger: Logger=…, access_log_class: type[AbstractAccessLogger]=…, access_log: Logger=…, access_log_format: str=…, debug: bool=…, max_line_size: int=…, max_headers: int=…, max_field_size: int=…, lingering_time: float=…, read_bufsize: int=…, auto_decompress: bool=…, tim… - changed:
method RequestHandler.close() → method RequestHandler.close() -> None - changed:
method RequestHandler.connection_lost(exc) → method RequestHandler.connection_lost(exc: BaseException | None) -> None - changed:
method RequestHandler.connection_made(transport) → method RequestHandler.connection_made(transport: asyncio.BaseTransport) -> None - changed:
method RequestHandler.data_received(data) → method RequestHandler.data_received(data: bytes) -> None - changed:
method RequestHandler.eof_received() → method RequestHandler.eof_received() -> None - changed:
method RequestHandler.force_close(send_last_heartbeat=…) → method RequestHandler.force_close() -> None - changed:
method RequestHandler.handle_error(request, status=…, exc=…, message=…) → method RequestHandler.handle_error(request: BaseRequest, status: int=…, exc: BaseException | None=…, message: str | None=…) -> StreamResponse - changed:
method RequestHandler.keep_alive(val) → method RequestHandler.keep_alive(val: bool) -> None - changed:
method RequestHandler.log_access(request, response, time) → method RequestHandler.log_access(request: BaseRequest, response: StreamResponse, time: float | None) -> None - changed:
method RequestHandler.log_debug(*args, **kw) → method RequestHandler.log_debug(*args: Any, **kw: Any) -> None - changed:
method RequestHandler.log_exception(*args, **kw) → method RequestHandler.log_exception(*args: Any, **kw: Any) -> None - changed:
method RequestHandler.set_parser(parser) → method RequestHandler.set_parser(parser: WebSocketReader, data_received_cb: Callable[[], None] | None=…) -> None - changed:
method RequestHandler.shutdown(timeout=…) → async method RequestHandler.shutdown(timeout: float | None=…) -> None - changed:
method RequestHandler.start(message, payload, handler) → async method RequestHandler.start() -> None - added:
async method RequestHandler.finish_response(request: BaseRequest, resp: StreamResponse, start_time: float | None) -> tuple[StreamResponse, bool] - added:
class PayloadAccessError(Exception) - added:
method RequestHandler.peername() -> str | tuple[str, int, int, int] | tuple[str, int] | None - added:
method RequestHandler.sockname() -> str | tuple[str, int, int, int] | tuple[str, int] | None - added:
method RequestHandler.ssl_context() -> Optional[ssl.SSLContext] - added:
property RequestHandler.keepalive_timeout -> float
- removed:
constructor Request(*args, **kwargs) - removed:
property BaseRequest.GET - removed:
property BaseRequest.body_exists - removed:
property BaseRequest.can_read_body - removed:
property BaseRequest.content - removed:
property BaseRequest.has_body - removed:
property BaseRequest.headers - removed:
property BaseRequest.http_range - removed:
property BaseRequest.keep_alive - removed:
property BaseRequest.loop - removed:
property BaseRequest.message - removed:
property BaseRequest.method - removed:
property BaseRequest.path - removed:
property BaseRequest.protocol - removed:
property BaseRequest.query - removed:
property BaseRequest.query_string - removed:
property BaseRequest.raw_headers - removed:
property BaseRequest.raw_path - removed:
property BaseRequest.rel_url - removed:
property BaseRequest.secure - removed:
property BaseRequest.task - removed:
property BaseRequest.transport - removed:
property BaseRequest.version - removed:
property BaseRequest.writer - removed:
property Request.app - removed:
property Request.match_info - removed:
variable FileField - changed:
class BaseRequest(collections.MutableMapping, HeadersMixin) → class BaseRequest(MutableMapping[str | RequestKey[Any], Any], HeadersMixin) - changed:
constructor BaseRequest(message, payload, protocol, writer, task, loop, *, client_max_size=…, state=…, scheme=…, host=…, remote=…) → constructor BaseRequest(message: RawRequestMessage, payload: StreamReader, protocol: RequestHandler, payload_writer: AbstractStreamWriter, task: asyncio.Task[None], loop: asyncio.AbstractEventLoop, *, client_max_size: int=…, client_max_fields: int=…, state: dict[RequestKey[Any] | str, Any] | None=…, scheme: str | None=…, host: str | None=…, remote: str | None=…) -> None - changed:
method BaseRequest.clone(*, method=…, rel_url=…, headers=…, scheme=…, host=…, remote=…) → method BaseRequest.clone(*, method: str | _SENTINEL=…, rel_url: StrOrURL | _SENTINEL=…, headers: LooseHeaders | _SENTINEL=…, scheme: str | _SENTINEL=…, host: str | _SENTINEL=…, remote: str | _SENTINEL=…, client_max_size: int | _SENTINEL=…, client_max_fields: int | _SENTINEL=…) -> BaseRequest - changed:
method BaseRequest.cookies() → method BaseRequest.cookies() -> Mapping[str, str] - changed:
method BaseRequest.forwarded() → method BaseRequest.forwarded() -> tuple[Mapping[str, str], ...] - changed:
method BaseRequest.host() → method BaseRequest.host() -> str - changed:
method BaseRequest.if_modified_since(_IF_MODIFIED_SINCE=…) → method BaseRequest.if_modified_since() -> datetime.datetime | None - changed:
method BaseRequest.json(*, loads=…) → async method BaseRequest.json(*, loads: JSONDecoder=…) -> Any - changed:
method BaseRequest.multipart(*, reader=…) → async method BaseRequest.multipart() -> MultipartReader - changed:
method BaseRequest.path_qs() → method BaseRequest.path_qs() -> str - changed:
method BaseRequest.post() → async method BaseRequest.post() -> MultiDictProxy[_Post] - changed:
method BaseRequest.read() → async method BaseRequest.read() -> bytes - changed:
method BaseRequest.release() → async method BaseRequest.release() -> None - changed:
method BaseRequest.remote() → method BaseRequest.remote() -> str | None - changed:
method BaseRequest.scheme() → method BaseRequest.scheme() -> str - changed:
method BaseRequest.text() → async method BaseRequest.text() -> str - changed:
method BaseRequest.url() → method BaseRequest.url() -> URL - changed:
method Request.clone(*, method=…, rel_url=…, headers=…, scheme=…, host=…, remote=…) → method Request.clone(*, method: str | _SENTINEL=…, rel_url: StrOrURL | _SENTINEL=…, headers: LooseHeaders | _SENTINEL=…, scheme: str | _SENTINEL=…, host: str | _SENTINEL=…, remote: str | _SENTINEL=…, client_max_size: int | _SENTINEL=…, client_max_fields: int | _SENTINEL=…) -> Request - added:
class FileField - added:
field BaseRequest.ATTRS - added:
field FileField.content_type: str - added:
field FileField.file: IO[bytes] - added:
field FileField.filename: str - added:
field FileField.headers: CIMultiDictProxy[str] - added:
field FileField.name: str - added:
field Request.ATTRS - added:
method BaseRequest.body_exists() -> bool - added:
method BaseRequest.content() -> StreamReader - added:
method BaseRequest.get_extra_info(name: str, default: Any=…) -> Any - added:
method BaseRequest.headers() -> CIMultiDictProxy[str] - added:
method BaseRequest.http_range() -> slice - added:
method BaseRequest.if_match() -> tuple[ETag, ...] | None - added:
method BaseRequest.if_none_match() -> tuple[ETag, ...] | None - added:
method BaseRequest.if_range() -> datetime.datetime | None - added:
method BaseRequest.if_unmodified_since() -> datetime.datetime | None - added:
method BaseRequest.keep_alive() -> bool - added:
method BaseRequest.loop() -> asyncio.AbstractEventLoop - added:
method BaseRequest.message() -> RawRequestMessage - added:
method BaseRequest.method() -> str - added:
method BaseRequest.path() -> str - added:
method BaseRequest.query() -> MultiMapping[str] - added:
method BaseRequest.query_string() -> str - added:
method BaseRequest.raw_headers() -> RawHeaders - added:
method BaseRequest.raw_path() -> str - added:
method BaseRequest.rel_url() -> URL - added:
method BaseRequest.secure() -> bool - added:
method BaseRequest.version() -> HttpVersion - added:
method Request.match_info() -> UrlMappingMatchInfo - added:
property BaseRequest.can_read_body -> bool - added:
property BaseRequest.client_max_fields -> int - added:
property BaseRequest.client_max_size -> int - added:
property BaseRequest.has_body -> bool - added:
property BaseRequest.protocol -> RequestHandler - added:
property BaseRequest.task -> asyncio.Task[None] - added:
property BaseRequest.transport -> asyncio.Transport | None - added:
property BaseRequest.writer -> AbstractStreamWriter - added:
property Request.app -> Application - added:
property Request.config_dict -> ChainMapProxy
- removed:
method StreamResponse.set_tcp_cork(value) - removed:
method StreamResponse.set_tcp_nodelay(value) - removed:
property Response.body - removed:
property Response.content_length - removed:
property Response.text - removed:
property StreamResponse.body_length - removed:
property StreamResponse.charset - removed:
property StreamResponse.chunked - removed:
property StreamResponse.compression - removed:
property StreamResponse.content_length - removed:
property StreamResponse.content_type - removed:
property StreamResponse.cookies - removed:
property StreamResponse.headers - removed:
property StreamResponse.keep_alive - removed:
property StreamResponse.last_modified - removed:
property StreamResponse.output_length - removed:
property StreamResponse.prepared - removed:
property StreamResponse.reason - removed:
property StreamResponse.status - removed:
property StreamResponse.task - removed:
property StreamResponse.tcp_cork - removed:
property StreamResponse.tcp_nodelay - changed:
class StreamResponse(HeadersMixin) → class StreamResponse(MutableMapping[str | ResponseKey[Any], Any], HeadersMixin) - changed:
constructor Response(*, body=…, status=…, reason=…, text=…, headers=…, content_type=…, charset=…) → constructor Response(*, body: Any=…, status: int=…, reason: str | None=…, text: str | None=…, headers: LooseHeaders | None=…, content_type: str | None=…, charset: str | None=…, zlib_executor_size: int=…, zlib_executor: Executor | None=…) -> None - changed:
constructor StreamResponse(*, status=…, reason=…, headers=…) → constructor StreamResponse(*, status: int=…, reason: str | None=…, headers: LooseHeaders | None=…, _real_headers: CIMultiDict[str] | None=…) -> None - changed:
function json_response(data=…, *, text=…, body=…, status=…, reason=…, headers=…, content_type=…, dumps=…) → function json_response(data: Any=…, *, text: str | None=…, body: bytes | None=…, status: int=…, reason: str | None=…, headers: LooseHeaders | None=…, content_type: str=…, dumps: JSONEncoder=…) -> Response - changed:
method Response.write_eof() → async method Response.write_eof(data: bytes=…) -> None - changed:
method StreamResponse.del_cookie(name, *, domain=…, path=…) → method StreamResponse.del_cookie(name: str, *, domain: str | None=…, path: str=…, secure: bool | None=…, httponly: bool | None=…, samesite: str | None=…) -> None - changed:
method StreamResponse.drain() → async method StreamResponse.drain() -> None - changed:
method StreamResponse.enable_chunked_encoding(chunk_size=…) → method StreamResponse.enable_chunked_encoding(chunk_size: int | None=…) -> None - changed:
method StreamResponse.enable_compression(force=…) → method StreamResponse.enable_compression(force: bool | ContentCoding | None=…, strategy: int | None=…) -> None - changed:
method StreamResponse.force_close() → method StreamResponse.force_close() -> None - changed:
method StreamResponse.prepare(request) → async method StreamResponse.prepare(request: BaseRequest) -> AbstractStreamWriter | None - changed:
method StreamResponse.set_cookie(name, value, *, expires=…, domain=…, max_age=…, path=…, secure=…, httponly=…, version=…) → method StreamResponse.set_cookie(name: str, value: str, *, expires: str | None=…, domain: str | None=…, max_age: int | str | None=…, path: str=…, secure: bool | None=…, httponly: bool | None=…, version: str | None=…, samesite: str | None=…, partitioned: bool | None=…) -> None - changed:
method StreamResponse.set_status(status, reason=…, _RESPONSES=…) → method StreamResponse.set_status(status: int, reason: str | None=…) -> None - changed:
method StreamResponse.write(data) → async method StreamResponse.write(data: bytes | bytearray | memoryview) -> None - changed:
method StreamResponse.write_eof(data=…) → async method StreamResponse.write_eof(data: bytes=…) -> None - added:
function json_bytes_response(data: Any=…, *, dumps: JSONBytesEncoder, body: bytes | None=…, status: int=…, reason: str | None=…, headers: LooseHeaders | None=…, content_type: str=…) -> Response - added:
property Response.body -> bytes | bytearray | Payload | None - added:
property Response.content_length -> int | None - added:
property Response.text -> str | None - added:
property StreamResponse.body_length -> int - added:
property StreamResponse.charset -> str | None - added:
property StreamResponse.chunked -> bool - added:
property StreamResponse.compression -> bool - added:
property StreamResponse.content_length -> int | None - added:
property StreamResponse.content_type -> str - added:
property StreamResponse.cookies -> SimpleCookie - added:
property StreamResponse.etag -> ETag | None - added:
property StreamResponse.headers -> CIMultiDict[str] - added:
property StreamResponse.keep_alive -> bool | None - added:
property StreamResponse.last_modified -> datetime.datetime | None - added:
property StreamResponse.output_length -> int - added:
property StreamResponse.prepared -> bool - added:
property StreamResponse.reason -> str - added:
property StreamResponse.status -> int - added:
property StreamResponse.task -> asyncio.Task[None] | None
- added:
class AbstractRouteDef(abc.ABC) - added:
class RouteDef(AbstractRouteDef) - added:
class RouteTableDef(Sequence[AbstractRouteDef]) - added:
class StaticDef(AbstractRouteDef) - added:
constructor RouteTableDef() -> None - added:
field RouteDef.handler: _HandlerType - added:
field RouteDef.kwargs: dict[str, Any] - added:
field RouteDef.method: str - added:
field RouteDef.path: str - added:
field StaticDef.kwargs: dict[str, Any] - added:
field StaticDef.path: PathLike - added:
field StaticDef.prefix: str - added:
function delete(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef - added:
function get(path: str, handler: _HandlerType, *, name: str | None=…, allow_head: bool=…, **kwargs: Any) -> RouteDef - added:
function head(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef - added:
function options(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef - added:
function patch(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef - added:
function post(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef - added:
function put(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef - added:
function route(method: str, path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef - added:
function static(prefix: str, path: PathLike, **kwargs: Any) -> StaticDef - added:
function view(path: str, handler: type[AbstractView], **kwargs: Any) -> RouteDef - added:
method AbstractRouteDef.register(router: UrlDispatcher) -> list[AbstractRoute] - added:
method RouteDef.register(router: UrlDispatcher) -> list[AbstractRoute] - added:
method RouteTableDef.delete(path: str, **kwargs: Any) -> _Deco - added:
method RouteTableDef.get(path: str, **kwargs: Any) -> _Deco - added:
method RouteTableDef.head(path: str, **kwargs: Any) -> _Deco - added:
method RouteTableDef.options(path: str, **kwargs: Any) -> _Deco - added:
method RouteTableDef.patch(path: str, **kwargs: Any) -> _Deco - added:
method RouteTableDef.post(path: str, **kwargs: Any) -> _Deco - added:
method RouteTableDef.put(path: str, **kwargs: Any) -> _Deco - added:
method RouteTableDef.route(method: str, path: str, **kwargs: Any) -> _Deco - added:
method RouteTableDef.static(prefix: str, path: PathLike, **kwargs: Any) -> None - added:
method RouteTableDef.view(path: str, **kwargs: Any) -> _Deco - added:
method StaticDef.register(router: UrlDispatcher) -> list[AbstractRoute]
- added:
async method AppRunner.shutdown() -> None - added:
async method BaseRunner.cleanup() -> None - added:
async method BaseRunner.setup() -> None - added:
async method BaseRunner.shutdown() -> None - added:
async method BaseSite.start() -> None - added:
async method BaseSite.stop() -> None - added:
async method NamedPipeSite.start() -> None - added:
async method ServerRunner.shutdown() -> None - added:
async method SockSite.start() -> None - added:
async method TCPSite.start() -> None - added:
async method UnixSite.start() -> None - added:
class AppRunner(BaseRunner) - added:
class BaseRunner(ABC) - added:
class BaseSite(ABC) - added:
class GracefulExit(SystemExit) - added:
class NamedPipeSite(BaseSite) - added:
class ServerRunner(BaseRunner) - added:
class SockSite(BaseSite) - added:
class TCPSite(BaseSite) - added:
class UnixSite(BaseSite) - added:
constructor AppRunner(app: Application, *, handle_signals: bool=…, access_log_class: type[AbstractAccessLogger]=…, **kwargs: Any) -> None - added:
constructor BaseRunner(*, handle_signals: bool=…, shutdown_timeout: float=…, **kwargs: Any) -> None - added:
constructor BaseSite(runner: BaseRunner, *, shutdown_timeout: float=…, ssl_context: SSLContext | None=…, backlog: int=…) -> None - added:
constructor NamedPipeSite(runner: BaseRunner, path: str, *, shutdown_timeout: float=…) -> None - added:
constructor ServerRunner(web_server: Server, *, handle_signals: bool=…, **kwargs: Any) -> None - added:
constructor SockSite(runner: BaseRunner, sock: socket.socket, *, shutdown_timeout: float=…, ssl_context: SSLContext | None=…, backlog: int=…) -> None - added:
constructor TCPSite(runner: BaseRunner, host: str | None=…, port: int | None=…, *, shutdown_timeout: float=…, ssl_context: SSLContext | None=…, backlog: int=…, reuse_address: bool | None=…, reuse_port: bool | None=…) -> None - added:
constructor UnixSite(runner: BaseRunner, path: PathLike, *, shutdown_timeout: float=…, ssl_context: SSLContext | None=…, backlog: int=…) -> None - added:
field GracefulExit.code - added:
property AppRunner.app -> Application - added:
property BaseRunner.addresses -> list[Any] - added:
property BaseRunner.server -> Server | None - added:
property BaseRunner.sites -> set[BaseSite] - added:
property BaseSite.name -> str - added:
property NamedPipeSite.name -> str - added:
property SockSite.name -> str - added:
property TCPSite.name -> str - added:
property TCPSite.port -> int - added:
property UnixSite.name -> str
- removed:
property Server.connections - changed:
constructor Server(handler, *, request_factory=…, loop=…, **kwargs) → constructor Server(handler: _RequestHandler, *, request_factory: _RequestFactory | None=…, handler_cancellation: bool=…, loop: asyncio.AbstractEventLoop | None=…, **kwargs: Any) -> None - changed:
method Server.connection_lost(handler, exc=…) → method Server.connection_lost(handler: RequestHandler, exc: BaseException | None=…) -> None - changed:
method Server.connection_made(handler, transport) → method Server.connection_made(handler: RequestHandler, transport: asyncio.Transport) -> None - changed:
method Server.shutdown(timeout=…) → async method Server.shutdown(timeout: float | None=…) -> None - added:
method Server.pre_shutdown() -> None - added:
property Server.connections -> list[RequestHandler]
- removed:
class RouteDef(namedtuple('_RouteDef', 'method, path, handler, kwargs')) - removed:
class RouteTableDef(Sequence) - removed:
constructor RouteTableDef() - removed:
function delete(path, handler, **kwargs) - removed:
function get(path, handler, *, name=…, allow_head=…, **kwargs) - removed:
function head(path, handler, **kwargs) - removed:
function patch(path, handler, **kwargs) - removed:
function post(path, handler, **kwargs) - removed:
function put(path, handler, **kwargs) - removed:
function route(method, path, handler, **kwargs) - removed:
method AbstractResource.url(**kwargs) - removed:
method AbstractRoute.url(**kwargs) - removed:
method DynamicResource.url(*, parts, query=…) - removed:
method PlainResource.url(*, query=…) - removed:
method ResourceRoute.url(**kwargs) - removed:
method RouteDef.register(router) - removed:
method RouteTableDef.delete(path, **kwargs) - removed:
method RouteTableDef.get(path, **kwargs) - removed:
method RouteTableDef.head(path, **kwargs) - removed:
method RouteTableDef.patch(path, **kwargs) - removed:
method RouteTableDef.post(path, **kwargs) - removed:
method RouteTableDef.put(path, **kwargs) - removed:
method RouteTableDef.route(method, path, **kwargs) - removed:
method StaticResource.url(*, filename, append_version=…, query=…) - removed:
method UrlMappingMatchInfo.set_current_app(app) - removed:
property AbstractResource.name - removed:
property AbstractRoute.handler - removed:
property AbstractRoute.method - removed:
property AbstractRoute.name - removed:
property AbstractRoute.resource - removed:
property ResourceRoute.name - removed:
property UrlMappingMatchInfo.apps - removed:
property UrlMappingMatchInfo.current_app - removed:
property UrlMappingMatchInfo.expect_handler - removed:
property UrlMappingMatchInfo.handler - removed:
property UrlMappingMatchInfo.http_exception - removed:
property UrlMappingMatchInfo.route - changed:
class AbstractResource(Sized, Iterable) → class AbstractResource(Sized, Iterable['AbstractRoute']) - changed:
class UrlDispatcher(AbstractRouter, collections.abc.Mapping) → class UrlDispatcher(AbstractRouter, Mapping[str, AbstractResource]) - changed:
class UrlMappingMatchInfo(dict, AbstractMatchInfo) → class UrlMappingMatchInfo(BaseDict, AbstractMatchInfo) - changed:
constructor AbstractResource(*, name=…) → constructor AbstractResource(*, name: str | None=…) -> None - changed:
constructor AbstractRoute(method, handler, *, expect_handler=…, resource=…) → constructor AbstractRoute(method: str, handler: Handler | type[AbstractView], *, expect_handler: _ExpectHandler | None=…, resource: AbstractResource | None=…) -> None - changed:
constructor DynamicResource(path, *, name=…) → constructor DynamicResource(path: str, *, name: str | None=…) -> None - changed:
constructor PlainResource(path, *, name=…) → constructor PlainResource(path: str, *, name: str | None=…) -> None - changed:
constructor Resource(*, name=…) → constructor Resource(*, name: str | None=…) -> None - changed:
constructor ResourceRoute(method, handler, resource, *, expect_handler=…) → constructor ResourceRoute(method: str, handler: Handler | type[AbstractView], resource: AbstractResource, *, expect_handler: _ExpectHandler | None=…) -> None - changed:
constructor StaticResource(prefix, directory, *, name=…, expect_handler=…, chunk_size=…, show_index=…, follow_symlinks=…, append_version=…) → constructor StaticResource(prefix: str, directory: PathLike, *, name: str | None=…, expect_handler: _ExpectHandler | None=…, chunk_size: int=…, show_index: bool=…, follow_symlinks: bool=…, append_version: bool=…) -> None - changed:
constructor UrlDispatcher() → constructor UrlDispatcher() -> None - changed:
constructor UrlMappingMatchInfo(match_dict, route) → constructor UrlMappingMatchInfo(match_dict: dict[str, str], route: AbstractRoute) -> None - changed:
method AbstractResource.add_prefix(prefix) → method AbstractResource.add_prefix(prefix: str) -> None - changed:
method AbstractResource.freeze() → method AbstractResource.freeze() -> None - changed:
method AbstractResource.get_info() → method AbstractResource.get_info() -> _InfoDict - changed:
method AbstractResource.resolve(request) → async method AbstractResource.resolve(request: Request) -> _Resolve - changed:
method AbstractResource.url_for(**kwargs) → method AbstractResource.url_for(**kwargs: str) -> URL - changed:
method AbstractRoute.get_info() → method AbstractRoute.get_info() -> _InfoDict - changed:
method AbstractRoute.handle_expect_header(request) → async method AbstractRoute.handle_expect_header(request: Request) -> StreamResponse | None - changed:
method AbstractRoute.url_for(*args, **kwargs) → method AbstractRoute.url_for(*args: str, **kwargs: str) -> URL - changed:
method DynamicResource.add_prefix(prefix) → method DynamicResource.add_prefix(prefix: str) -> None - changed:
method DynamicResource.get_info() → method DynamicResource.get_info() -> _InfoDict - changed:
method DynamicResource.url_for(**parts) → method DynamicResource.url_for(**parts: str) -> URL - changed:
method PlainResource.add_prefix(prefix) → method PlainResource.add_prefix(prefix: str) -> None - changed:
method PlainResource.freeze() → method PlainResource.freeze() -> None - changed:
method PlainResource.get_info() → method PlainResource.get_info() -> _InfoDict - changed:
method PlainResource.url_for() → method PlainResource.url_for() -> URL - changed:
method Resource.add_route(method, handler, *, expect_handler=…) → method Resource.add_route(method: str, handler: type[AbstractView] | Handler, *, expect_handler: _ExpectHandler | None=…) -> ResourceRoute - changed:
method Resource.register_route(route) → method Resource.register_route(route: ResourceRoute) -> None - changed:
method Resource.resolve(request) → async method Resource.resolve(request: Request) -> _Resolve - changed:
method ResourceRoute.get_info() → method ResourceRoute.get_info() -> _InfoDict - changed:
method ResourceRoute.url_for(*args, **kwargs) → method ResourceRoute.url_for(*args: str, **kwargs: str) -> URL - changed:
method StaticResource.get_info() → method StaticResource.get_info() -> _InfoDict - changed:
method StaticResource.resolve(request) → async method StaticResource.resolve(request: Request) -> _Resolve - changed:
method StaticResource.set_options_route(handler) → method StaticResource.set_options_route(handler: Handler) -> None - changed:
method StaticResource.url_for(*, filename, append_version=…) → method StaticResource.url_for(*, filename: PathLike, append_version: bool | None=…) -> URL - changed:
method UrlDispatcher.add_delete(path, handler, **kwargs) → method UrlDispatcher.add_delete(path: str, handler: Handler, **kwargs: Any) -> AbstractRoute - changed:
method UrlDispatcher.add_get(path, handler, *, name=…, allow_head=…, **kwargs) → method UrlDispatcher.add_get(path: str, handler: Handler, *, name: str | None=…, allow_head: bool=…, **kwargs: Any) -> AbstractRoute - changed:
method UrlDispatcher.add_head(path, handler, **kwargs) → method UrlDispatcher.add_head(path: str, handler: Handler, **kwargs: Any) -> AbstractRoute - changed:
method UrlDispatcher.add_patch(path, handler, **kwargs) → method UrlDispatcher.add_patch(path: str, handler: Handler, **kwargs: Any) -> AbstractRoute - changed:
method UrlDispatcher.add_post(path, handler, **kwargs) → method UrlDispatcher.add_post(path: str, handler: Handler, **kwargs: Any) -> AbstractRoute - changed:
method UrlDispatcher.add_put(path, handler, **kwargs) → method UrlDispatcher.add_put(path: str, handler: Handler, **kwargs: Any) -> AbstractRoute - changed:
method UrlDispatcher.add_resource(path, *, name=…) → method UrlDispatcher.add_resource(path: str, *, name: str | None=…) -> Resource - changed:
method UrlDispatcher.add_route(method, path, handler, *, name=…, expect_handler=…) → method UrlDispatcher.add_route(method: str, path: str, handler: Handler | type[AbstractView], *, name: str | None=…, expect_handler: _ExpectHandler | None=…) -> AbstractRoute - changed:
method UrlDispatcher.add_routes(routes) → method UrlDispatcher.add_routes(routes: Iterable[AbstractRouteDef]) -> list[AbstractRoute] - changed:
method UrlDispatcher.add_static(prefix, path, *, name=…, expect_handler=…, chunk_size=…, show_index=…, follow_symlinks=…, append_version=…) → method UrlDispatcher.add_static(prefix: str, path: PathLike, *, name: str | None=…, expect_handler: _ExpectHandler | None=…, chunk_size: int=…, show_index: bool=…, follow_symlinks: bool=…, append_version: bool=…) -> AbstractResource - changed:
method UrlDispatcher.freeze() → method UrlDispatcher.freeze() -> None - changed:
method UrlDispatcher.named_resources() → method UrlDispatcher.named_resources() -> Mapping[str, AbstractResource] - changed:
method UrlDispatcher.register_resource(resource) → method UrlDispatcher.register_resource(resource: AbstractResource) -> None - changed:
method UrlDispatcher.resolve(request) → async method UrlDispatcher.resolve(request: Request) -> UrlMappingMatchInfo - changed:
method UrlDispatcher.resources() → method UrlDispatcher.resources() -> ResourcesView - changed:
method UrlDispatcher.routes() → method UrlDispatcher.routes() -> RoutesView - changed:
method UrlMappingMatchInfo.add_app(app) → method UrlMappingMatchInfo.add_app(app: Application) -> None - changed:
method UrlMappingMatchInfo.freeze() → method UrlMappingMatchInfo.freeze() -> None - changed:
method UrlMappingMatchInfo.get_info() → method UrlMappingMatchInfo.get_info() -> _InfoDict - added:
method AbstractResource.raw_match(path: str) -> bool - added:
method DynamicResource.raw_match(path: str) -> bool - added:
method PlainResource.raw_match(path: str) -> bool - added:
method UrlDispatcher.add_options(path: str, handler: Handler, **kwargs: Any) -> AbstractRoute - added:
method UrlDispatcher.add_view(path: str, handler: type[AbstractView], **kwargs: Any) -> AbstractRoute - added:
method UrlDispatcher.index_resource(resource: AbstractResource) -> None - added:
method UrlDispatcher.unindex_resource(resource: AbstractResource) -> None - added:
property AbstractResource.canonical -> str - added:
property AbstractResource.name -> str | None - added:
property AbstractRoute.handler -> Handler - added:
property AbstractRoute.method -> str - added:
property AbstractRoute.name -> str | None - added:
property AbstractRoute.resource -> AbstractResource | None - added:
property DynamicResource.canonical -> str - added:
property PlainResource.canonical -> str - added:
property ResourceRoute.name -> str | None - added:
property UrlMappingMatchInfo.apps -> tuple[Application, ...] - added:
property UrlMappingMatchInfo.current_app -> Application - added:
property UrlMappingMatchInfo.expect_handler -> _ExpectHandler - added:
property UrlMappingMatchInfo.handler -> Handler - added:
property UrlMappingMatchInfo.http_exception -> HTTPException | None - added:
property UrlMappingMatchInfo.route -> AbstractRoute
- removed:
property WebSocketResponse.close_code - removed:
property WebSocketResponse.closed - removed:
property WebSocketResponse.compress - removed:
property WebSocketResponse.ws_protocol - removed:
variable MsgType - changed:
class WebSocketReady(namedtuple('WebSocketReady', 'ok protocol')) → class WebSocketReady - changed:
class WebSocketResponse(StreamResponse) → class WebSocketResponse(StreamResponse, Generic[_DecodeText]) - changed:
constructor WebSocketResponse(*, timeout=…, receive_timeout=…, autoclose=…, autoping=…, heartbeat=…, protocols=…, compress=…) → constructor WebSocketResponse(*, timeout: float=…, receive_timeout: float | None=…, autoclose: bool=…, autoping: bool=…, heartbeat: float | None=…, protocols: Iterable[str]=…, compress: bool=…, max_msg_size: int=…, writer_limit: int=…, decode_text: bool=…) -> None - changed:
method WebSocketResponse.can_prepare(request) → method WebSocketResponse.can_prepare(request: BaseRequest) -> WebSocketReady - changed:
method WebSocketResponse.close(*, code=…, message=…) → async method WebSocketResponse.close(*, code: int=…, message: bytes=…, drain: bool=…) -> bool - changed:
method WebSocketResponse.exception() → method WebSocketResponse.exception() -> BaseException | None - changed:
method WebSocketResponse.ping(message=…) → async method WebSocketResponse.ping(message: bytes=…) -> None - changed:
method WebSocketResponse.pong(message=…) → async method WebSocketResponse.pong(message: bytes=…) -> None - changed:
method WebSocketResponse.prepare(request) → async method WebSocketResponse.prepare(request: BaseRequest) -> AbstractStreamWriter - changed:
method WebSocketResponse.receive(timeout=…) → async method WebSocketResponse.receive(timeout: float | None=…) -> WSMessageDecodeText | (timeout: float | None=…) -> WSMessageNoDecodeText | (timeout: float | None=…) -> WSMessageDecodeText | WSMessageNoDecodeText - changed:
method WebSocketResponse.receive_bytes(*, timeout=…) → async method WebSocketResponse.receive_bytes(*, timeout: float | None=…) -> bytes - changed:
method WebSocketResponse.receive_json(*, loads=…, timeout=…) → async method WebSocketResponse.receive_json(*, loads: JSONDecoder=…, timeout: float | None=…) -> Any | (*, loads: Callable[[bytes], Any]=…, timeout: float | None=…) -> Any | (*, loads: JSONDecoder | Callable[[bytes], Any]=…, timeout: float | None=…) -> Any - changed:
method WebSocketResponse.receive_str(*, timeout=…) → async method WebSocketResponse.receive_str(*, timeout: float | None=…) -> str | (*, timeout: float | None=…) -> bytes | (*, timeout: float | None=…) -> str | bytes - changed:
method WebSocketResponse.send_bytes(data) → async method WebSocketResponse.send_bytes(data: bytes, compress: int | None=…) -> None - changed:
method WebSocketResponse.send_json(data, *, dumps=…) → async method WebSocketResponse.send_json(data: Any, compress: int | None=…, *, dumps: JSONEncoder=…) -> None - changed:
method WebSocketResponse.send_str(data) → async method WebSocketResponse.send_str(data: str, compress: int | None=…) -> None - changed:
method WebSocketResponse.write(data) → async method WebSocketResponse.write(data: Buffer) -> None - changed:
method WebSocketResponse.write_eof() → async method WebSocketResponse.write_eof() -> None - added:
async method WebSocketResponse.send_frame(message: bytes, opcode: WSMsgType, compress: int | None=…) -> None - added:
async method WebSocketResponse.send_json_bytes(data: Any, compress: int | None=…, *, dumps: JSONBytesEncoder) -> None - added:
field WebSocketReady.ok: bool - added:
field WebSocketReady.protocol: str | None - added:
method WebSocketResponse.get_extra_info(name: str, default: Any=…) -> Any - added:
property WebSocketResponse.close_code -> int | None - added:
property WebSocketResponse.closed -> bool - added:
property WebSocketResponse.compress -> int | bool - added:
property WebSocketResponse.prepared -> bool - added:
property WebSocketResponse.ws_protocol -> str | None
- removed:
class GunicornTokioWebWorker(GunicornWebWorker) - removed:
method GunicornTokioWebWorker.init_process() - removed:
method GunicornWebWorker.close() - removed:
method GunicornWebWorker.make_handler(app) - changed:
constructor GunicornWebWorker(*args, **kw) → constructor GunicornWebWorker(*args: Any, **kw: Any) -> None - changed:
method GunicornUVLoopWebWorker.init_process() → method GunicornUVLoopWebWorker.init_process() -> None - changed:
method GunicornWebWorker.handle_abort(sig, frame) → method GunicornWebWorker.handle_abort(sig: int, frame: FrameType | None) -> None - changed:
method GunicornWebWorker.handle_quit(sig, frame) → method GunicornWebWorker.handle_quit(sig: int, frame: FrameType | None) -> None - changed:
method GunicornWebWorker.init_process() → method GunicornWebWorker.init_process() -> None - changed:
method GunicornWebWorker.init_signals() → method GunicornWebWorker.init_signals() -> None - changed:
method GunicornWebWorker.run() → method GunicornWebWorker.run() -> None