![[BACK]](/icons/back.gif){kind=icon}
Up to [cvs.NetBSD.org] / pkgsrc / www / py-aiohttp
Request diff between arbitrary revisions
Keyword substitution: kv
Default branch: MAIN
py-aiohttp: updated to 3.11.9 3.11.9 (2024-12-01) Bug fixes - Fixed invalid method logging unexpected being logged at exception level on subsequent connections Miscellaneous internal changes - Improved performance of parsing headers when using the C parser 3.11.8 (2024-11-27) Miscellaneous internal changes - Improved performance of creating :class:`aiohttp.ClientResponse` objects when there are no cookies - Improved performance of creating :class:`aiohttp.ClientResponse` objects - Improved performances of creating objects during the HTTP request lifecycle - Improved performance of constructing :class:`aiohttp.web.Response` with headers - Improved performance of making requests when there are no auto headers to skip - Downgraded logging of invalid HTTP method exceptions on the first request to debug level HTTP requests starting with an invalid method are relatively common, especially when connected to the public internet, because browsers or other clients may try to speak SSL to a plain-text server or vice-versa. These exceptions can quickly fill the log with noise when nothing is wrong.
py-aiohttp: updated to 3.11.7 3.11.7 (2024-11-21) Bug fixes - Fixed the HTTP client not considering the connector's ``force_close`` value when setting the ``Connection`` header Miscellaneous internal changes - Improved performance of serializing HTTP headers 3.11.6 (2024-11-19) Bug fixes - Restored the ``force_close`` method to the ``ResponseHandler`` 3.11.5 (2024-11-19) Bug fixes - Fixed the ``ANY`` method not appearing in :meth:`~aiohttp.web.UrlDispatcher.routes` 3.11.4 (2024-11-18) Bug fixes - Fixed ``StaticResource`` not allowing the ``OPTIONS`` method after calling ``set_options_route`` Miscellaneous internal changes - Improved performance of creating web responses when there are no cookies 3.11.3 (2024-11-18) Bug fixes - Removed non-existing ``__author__`` from ``dir(aiohttp)`` - Restored the ``FlowControlDataQueue`` class This class is no longer used internally, and will be permanently removed in the next major version. Miscellaneous internal changes - Improved performance of resolving resources when multiple methods are registered for the same route
py-aiohttp: updated to 3.11.2 3.11.2 (2024-11-14) Bug fixes - Fixed improperly closed WebSocket connections generating an unhandled exception 3.11.1 (2024-11-14) Bug fixes - Added a backward compatibility layer to :class:`aiohttp.RequestInfo` to allow creating these objects without a ``real_url``
py-aiohttp: updated to 3.11.0 3.11.0 (2024-11-13) Bug fixes - Raise :exc:`aiohttp.ServerFingerprintMismatch` exception on client-side if request through http proxy with mismatching server fingerprint digest: `aiohttp.ClientSession(headers=headers, connector=TCPConnector(ssl=aiohttp.Fingerprint(mismatch_digest), trust_env=True).request(...)` - Modified websocket :meth:`aiohttp.ClientWebSocketResponse.receive_str`, :py:meth:`aiohttp.ClientWebSocketResponse.receive_bytes`, :py:meth:`aiohttp.web.WebSocketResponse.receive_str` & :py:meth:`aiohttp.web.WebSocketResponse.receive_bytes` methods to raise new :py:exc:`aiohttp.WSMessageTypeError` exception, instead of generic :py:exc:`TypeError`, when websocket messages of incorrect types are received - Made ``TestClient.app`` a ``Generic`` so type checkers will know the correct type (avoiding unneeded ``client.app is not None`` checks) - Fixed the keep-alive connection pool to be FIFO instead of LIFO Keep-alive connections are more likely to be reused before they disconnect. Features - Added ``strategy`` parameter to :meth:`aiohttp.web.StreamResponse.enable_compression` The value of this parameter is passed to the :func:`zlib.compressobj` function, allowing people to use a more sufficient compression algorithm for their data served by :mod:`aiohttp.web` - Added ``server_hostname`` parameter to ``ws_connect``. - Exported :py:class:`~aiohttp.ClientWSTimeout` to top-level namespace - Added ``secure``/``httponly``/``samesite`` parameters to ``.del_cookie()`` - Updated :py:class:`~aiohttp.ClientSession`'s auth logic to include default auth only if the request URL's origin matches _base_url; otherwise, the auth will not be included - Added ``proxy`` and ``proxy_auth`` parameters to :py:class:`~aiohttp.ClientSession` - Added ``default_to_multipart`` parameter to ``FormData``. - Added :py:meth:`~aiohttp.ClientWebSocketResponse.send_frame` and :py:meth:`~aiohttp.web.WebSocketResponse.send_frame` for WebSockets - Updated :py:class:`~aiohttp.ClientSession` to support paths in ``base_url`` parameter. - Improved performance of reading WebSocket messages with a Cython implementation - Added ``writer_limit`` to the :py:class:`~aiohttp.web.WebSocketResponse` to be able to adjust the limit before the writer forces the buffer to be drained - Added an :attr:`~aiohttp.abc.AbstractAccessLogger.enabled` property to :class:`aiohttp.abc.AbstractAccessLogger` to dynamically check if logging is enabled Deprecations (removal in next major release) - Deprecate obsolete `timeout: float` and `receive_timeout: Optional[float]` in :py:meth:`~aiohttp.ClientSession.ws_connect`. Change default websocket receive timeout from `None` to `10.0`. Removals and backward incompatible breaking changes - Dropped support for Python 3.8 - Increased minimum yarl version to 1.17.0 - Removed the ``is_ipv6_address`` and ``is_ip4_address`` helpers are they are no longer used - Changed ``ClientRequest.connection_key`` to be a `NamedTuple` to improve client performance - ``FlowControlDataQueue`` has been replaced with the ``WebSocketDataQueue`` - Changed ``ClientRequest.request_info`` to be a `NamedTuple` to improve client performance Packaging updates and notes for downstreams - Switched to using the :mod:`propcache <propcache.api>` package for property caching The :mod:`propcache <propcache.api>` package is derived from the property caching code in :mod:`yarl` and has been broken out to avoid maintaining it for multiple projects. - Separated ``aiohttp.http_websocket`` into multiple files to make it easier to maintain Contributor-facing changes - Changed diagram images generator from ``blockdiag`` to ``GraphViz``. Generating documentation now requires the GraphViz executable to be included in $PATH or sphinx build configuration. Miscellaneous internal changes - Added flake8 settings to avoid some forms of implicit concatenation. - Enabled keep-alive support on proxies (which was originally disabled several years ago) - Changed web entry point to not listen on TCP when only a Unix path is passed - Disabled automatic retries of failed requests in :class:`aiohttp.test_utils.TestClient`'s client session (which could potentially hide errors in tests) - Changed web ``keepalive_timeout`` default to around an hour in order to reduce race conditions on reverse proxies - Reduced memory required for stream objects created during the client request lifecycle - Improved performance of the internal ``DataQueue`` - Improved performance of calling ``receive`` for WebSockets for the most common message types - Replace internal helper methods ``method_must_be_empty_body`` and ``status_code_must_be_empty_body`` with simple `set` lookups - Improved performance of :py:class:`aiohttp.BaseConnector` when there is no ``limit_per_host`` - Improved performance of sending HTTP requests when there is no body - Improved performance of the ``WebsocketWriter`` when the protocol is not paused - Implemented zero copy writes for ``StreamWriter``
py-aiohttp: updated to 3.10.11 3.10.11 (2024-11-13) Bug fixes - Authentication provided by a redirect now takes precedence over provided ``auth`` when making requests with the client - Fixed :py:meth:`WebSocketResponse.close() <aiohttp.web.WebSocketResponse.close>` to discard non-close messages within its timeout window after sending close - Fixed a deadlock that could occur while attempting to get a new connection slot after a timeout The connector was not cancellation-safe. - Fixed the WebSocket flow control calculation undercounting with multi-byte data - Fixed incorrect parsing of chunk extensions with the pure Python parser - Fixed system routes polluting the middleware cache Removals and backward incompatible breaking changes - Improved performance of the connector when a connection can be reused If ``BaseConnector.connect`` has been subclassed and replaced with custom logic, the ``ceil_timeout`` must be added. Miscellaneous internal changes - Improved performance of the client request lifecycle when there are no cookies - Improved performance of serializing HTTP headers - Passing ``enable_cleanup_closed`` to :py:class:`aiohttp.TCPConnector` is now ignored on Python 3.12.7+ and 3.13.1+ since the underlying bug that caused asyncio to leak SSL connections has been fixed upstream
py-*: remove unused tool dependency py-setuptools includes the py-wheel functionality nowadays
py-aiohttp: updated to 3.10.10 3.10.10 (2024-10-10) Bug fixes - Fixed error messages from :py:class:`~aiohttp.resolver.AsyncResolver` being swallowed Features - Added :exc:`aiohttp.ClientConnectorDNSError` for differentiating DNS resolution errors from other connector errors Miscellaneous internal changes - Simplified DNS resolution throttling code to reduce chance of race conditions
py-aiohttp: update to 3.10.9. 3.10.9 (2024-10-04) =================== Bug fixes --------- - Fixed proxy headers being used in the ``ConnectionKey`` hash when a proxy was not being used -- by :user:`bdraco`. If default headers are used, they are also used for proxy headers. This could have led to creating connections that were not needed when one was already available. *Related issues and pull requests on GitHub:* :issue:`9368`. - Widened the type of the ``trace_request_ctx`` parameter of :meth:`ClientSession.request() <aiohttp.ClientSession.request>` and friends -- by :user:`layday`. *Related issues and pull requests on GitHub:* :issue:`9397`. Removals and backward incompatible breaking changes --------------------------------------------------- - Fixed failure to try next host after single-host connection timeout -- by :user:`brettdh`. The default client :class:`aiohttp.ClientTimeout` params has changed to include a ``sock_connect`` timeout of 30 seconds so that this correct behavior happens by default. *Related issues and pull requests on GitHub:* :issue:`7342`. Miscellaneous internal changes ------------------------------ - Improved performance of resolving hosts with Python 3.12+ -- by :user:`bdraco`. *Related issues and pull requests on GitHub:* :issue:`9342`. - Reduced memory required for timer objects created during the client request lifecycle -- by :user:`bdraco`. *Related issues and pull requests on GitHub:* :issue:`9406`.
py-aiohttp: updated to 3.10.8 3.10.8 (2024-09-28) Bug fixes - Fixed cancellation leaking upwards on timeout 3.10.7 (2024-09-27) Bug fixes - Fixed assembling the :class:`~yarl.URL` for web requests when the host contains a non-default port or IPv6 address Miscellaneous internal changes - Improved performance of determining if a URL is absolute - Replaced code that can now be handled by ``yarl`` 3.10.6 (2024-09-24) Bug fixes - Added :exc:`aiohttp.ClientConnectionResetError`. Client code that previously threw :exc:`ConnectionResetError` will now throw this - Fixed an unclosed transport ``ResourceWarning`` on web handlers - Fixed resolve_host() 'Task was destroyed but is pending' errors - Fixed handling of some file-like objects (e.g. ``tarfile.extractfile()``) which raise ``AttributeError`` instead of ``OSError`` when ``fileno`` fails for streaming payload data - Fixed web router not matching pre-encoded URLs (requires yarl 1.9.6+) - Fixed an error when trying to add a route for multiple methods with a path containing a regex pattern - Fixed ``Response.text`` when body is a ``Payload`` - Fixed compressed requests failing when no body was provided - Fixed client incorrectly reusing a connection when the previous message had not been fully sent - Fixed race condition that could cause server to close connection incorrectly at keepalive timeout - Fixed Python parser chunked handling with multiple Transfer-Encoding values - Fixed error handling after 100-continue so server sends 500 response instead of disconnecting - Stopped adding a default Content-Type header when response has no content - Added support for URL credentials with empty (zero-length) username, e.g. ``https://:password@host`` - Stopped logging exceptions from ``web.run_app()`` that would be raised regardless - Implemented binding to IPv6 addresses in the pytest server fixture. - Fixed the incorrect use of flags for ``getnameinfo()`` in the Resolver - Fixed StreamResponse.prepared to return True after EOF is sent - Changed ``make_mocked_request()`` to use empty payload by default - Used more precise type for ``ClientResponseError.headers``, fixing some type errors when using them - Changed behavior when returning an invalid response to send a 500 response - Fixed response reading from closed session to throw an error immediately instead of timing out - Fixed ``CancelledError`` from one cleanup context stopping other contexts from completing - Fixed changing scheme/host in ``Response.clone()`` for absolute URLs - Fixed ``Site.name`` when host is an empty string - Updated Python parser to reject messages after a close message, matching C parser behaviour - Fixed creation of ``SSLContext`` inside of :py:class:`aiohttp.TCPConnector` with multiple event loops in different threads - Fixed (on Python 3.11+) some edge cases where a task cancellation may get incorrectly suppressed - Fixed exception information getting lost on ``HttpProcessingError`` - Fixed ``If-None-Match`` not using weak comparison - Fixed badly encoded charset crashing when getting response text instead of falling back to charset detector. - Rejected `\n` in `reason` values to avoid sending broken HTTP messages - Changed :py:meth:`ClientResponse.raise_for_status() <aiohttp.ClientResponse.raise_for_status>` to only release the connection when invoked outside an ``async with`` context Features - Improved type on ``params`` to match the underlying type allowed by ``yarl`` - Declared Python 3.13 supported Removals and backward incompatible breaking changes - Improved middleware performance - Increased minimum yarl version to 1.12.0 Improved documentation - Clarified that ``GracefulExit`` needs to be handled in ``AppRunner`` and ``ServerRunner`` when using ``handle_signals=True``. - Clarified that auth parameter in ClientSession will persist and be included with any request to any origin, even during redirects to different origins. - Clarified which timeout exceptions happen on which timeouts - Updated ``ClientSession`` parameters to match current code Packaging updates and notes for downstreams - Fixed ``test_client_session_timeout_zero`` to not require internet access Miscellaneous internal changes - Improved performance of making requests when there are no auto headers to skip - Exported ``aiohttp.TraceRequestHeadersSentParams`` - Avoided tracing overhead in the http writer when there are no active traces -- by user:`bdraco`. - Improved performance of reify Cython implementation - Use :meth:`URL.extend_query() <yarl.URL.extend_query>` to extend query params (requires yarl 1.11.0+) - Improved performance of checking if a host is an IP Address - Significantly improved performance of middlewares - Improved performance of web requests - Improved performance of starting web requests when there is no response prepare hook - Significantly improved performance of expiring cookies - Significantly sped up filtering cookies
py-aiohttp: updated to 3.10.5 3.10.5 (2024-08-19) Bug fixes - Fixed :meth:`aiohttp.ClientResponse.json()` not setting ``status`` when :exc:`aiohttp.ContentTypeError` is raised Miscellaneous internal changes - Improved performance of the WebSocket reader
py-aiohttp: updated to 3.10.4 3.10.4 (2024-08-17) =================== Bug fixes --------- - Fixed decoding base64 chunk in BodyPartReader - Fixed a race closing the server-side WebSocket where the close code would not reach the client - Fixed unconsumed exceptions raised by the WebSocket heartbeat If the heartbeat ping raised an exception, it would not be consumed and would be logged as an warning. - Fixed an edge case in the Python parser when chunk separators happen to align with network chunks Improved documentation ---------------------- - Added ``aiohttp-apischema`` to supported libraries Miscellaneous internal changes ------------------------------ - Improved performance of starting request handlers with Python 3.12+ This change is a followup to :issue:`8661` to make the same optimization for Python 3.12+ where the request is connected.
py-aiohttp: updated to 3.10.3 3.10.3 (2024-08-10) Bug fixes - Fixed multipart reading when stream buffer splits the boundary over several read() calls - Fixed :py:class:`aiohttp.TCPConnector` doing blocking I/O in the event loop to create the ``SSLContext`` The blocking I/O would only happen once per verify mode. However, it could cause the event loop to block for a long time if the ``SSLContext`` creation is slow, which is more likely during startup when the disk cache is not yet present. Miscellaneous internal changes - Improved performance of :py:meth:`~aiohttp.ClientWebSocketResponse.receive` and :py:meth:`~aiohttp.web.WebSocketResponse.receive` when there is no timeout. The timeout context manager is now avoided when there is no timeout as it accounted for up to 50% of the time spent in the :py:meth:`~aiohttp.ClientWebSocketResponse.receive` and :py:meth:`~aiohttp.web.WebSocketResponse.receive` methods. - Improved performance of starting request handlers with Python 3.12+ - Improved performance of HTTP keep-alive checks Previously, when processing a request for a keep-alive connection, the keep-alive check would happen every second; the check is now rescheduled if it fires too early instead. - Improved performance of generating random WebSocket mask 3.10.2 (2024-08-08) Bug fixes - Fixed server checks for circular symbolic links to be compatible with Python 3.13 - Fixed request body not being read when ignoring an Upgrade request - Fixed an edge case where shutdown would wait for timeout when the handler was already completed - Fixed connecting to ``npipe://``, ``tcp://``, and ``unix://`` urls - Fixed WebSocket ping tasks being prematurely garbage collected There was a small risk that WebSocket ping tasks would be prematurely garbage collected because the event loop only holds a weak reference to the task. The garbage collection risk has been fixed by holding a strong reference to the task. Additionally, the task is now scheduled eagerly with Python 3.12+ to increase the chance it can be completed immediately and avoid having to hold any references to the task. - Fixed incorrectly following symlinks for compressed file variants Removals and backward incompatible breaking changes - Removed ``Request.wait_for_disconnection()``, which was mistakenly added briefly in 3.10.0 Contributor-facing changes - Fixed monkey patches for ``Path.stat()`` and ``Path.is_dir()`` for Python 3.13 compatibility Miscellaneous internal changes - Improved WebSocket performance when messages are sent or received frequently The WebSocket heartbeat scheduling algorithm was improved to reduce the ``asyncio`` scheduling overhead by decreasing the number of ``asyncio.TimerHandle`` creations and cancellations. - Minor improvements to various type annotations
py-aiohttp: updated to 3.10.1 3.10.1 (2024-08-03) Bug fixes - Fixed WebSocket server heartbeat timeout logic to terminate :py:meth:`~aiohttp.ClientWebSocketResponse.receive` and return :py:class:`~aiohttp.ServerTimeoutError` -- by :user:`arcivanov`. When a WebSocket pong message was not received, the :py:meth:`~aiohttp.ClientWebSocketResponse.receive` operation did not terminate. This change causes ``_pong_not_received`` to feed the ``reader`` an error message, causing pending :py:meth:`~aiohttp.ClientWebSocketResponse.receive` to terminate and return the error message. The error message contains the exception :py:class:`~aiohttp.ServerTimeoutError`. - Fixed url dispatcher index not matching when a variable is preceded by a fixed string after a slash -- by :user:`bdraco`. Removals and backward incompatible breaking changes - Creating :py:class:`aiohttp.TCPConnector`, :py:class:`aiohttp.ClientSession`, :py:class:`~aiohttp.resolver.ThreadedResolver` :py:class:`aiohttp.web.Server`, or :py:class:`aiohttp.CookieJar` instances without a running event loop now raises a :exc:`RuntimeError` -- by :user:`asvetlov`. Creating these objects without a running event loop was deprecated in :issue:`3372` which was released in version 3.5.0. This change first appeared in version 3.10.0 as :issue:`6378`.
py-aiohttp: updated to 3.10.0
3.10.0 (2024-07-30)
Bug fixes
- Fixed server response headers for ``Content-Type`` and ``Content-Encoding`` for
static compressed files
Server will now respond with a ``Content-Type`` appropriate for the compressed
file (e.g. ``"application/gzip"``), and omit the ``Content-Encoding`` header.
Users should expect that most clients will no longer decompress such responses
by default.
- Fixed duplicate cookie expiration calls in the CookieJar implementation
- Adjusted ``FileResponse`` to check file existence and access when preparing the response
The :py:class:`~aiohttp.web.FileResponse` class was modified to respond with
403 Forbidden or 404 Not Found as appropriate. Previously, it would cause a
server error if the path did not exist or could not be accessed. Checks for
existence, non-regular files, and permissions were expected to be done in the
route handler. For static routes, this now permits a compressed file to exist
without its uncompressed variant and still be served. In addition, this
changes the response status for files without read permission to 403, and for
non-regular files from 404 to 403 for consistency.
- Fixed ``AsyncResolver`` to match ``ThreadedResolver`` behavior
On system with IPv6 support, the :py:class:`~aiohttp.resolver.AsyncResolver` would not fallback
to providing A records when AAAA records were not available.
Additionally, unlike the :py:class:`~aiohttp.resolver.ThreadedResolver`, the :py:class:`~aiohttp.resolver.AsyncResolver`
did not handle link-local addresses correctly.
This change makes the behavior consistent with the :py:class:`~aiohttp.resolver.ThreadedResolver`.
- Fixed ``ws_connect`` not respecting `receive_timeout`` on WS(S) connection.
- Removed blocking I/O in the event loop for static resources and refactored
exception handling
File system calls when handling requests for static routes were moved to a
separate thread to potentially improve performance. Exception handling
was tightened in order to only return 403 Forbidden or 404 Not Found responses
for expected scenarios; 500 Internal Server Error would be returned for any
unknown errors.
Features
- Added a Request.wait_for_disconnection() method, as means of allowing request handlers to be notified of premature client disconnections.
- Added 5 new exceptions: :py:exc:`~aiohttp.InvalidUrlClientError`, :py:exc:`~aiohttp.RedirectClientError`,
:py:exc:`~aiohttp.NonHttpUrlClientError`, :py:exc:`~aiohttp.InvalidUrlRedirectClientError`,
:py:exc:`~aiohttp.NonHttpUrlRedirectClientError`
:py:exc:`~aiohttp.InvalidUrlRedirectClientError`, :py:exc:`~aiohttp.NonHttpUrlRedirectClientError`
are raised instead of :py:exc:`ValueError` or :py:exc:`~aiohttp.InvalidURL` when the redirect URL is invalid. Classes
:py:exc:`~aiohttp.InvalidUrlClientError`, :py:exc:`~aiohttp.RedirectClientError`,
:py:exc:`~aiohttp.NonHttpUrlClientError` are base for them.
The :py:exc:`~aiohttp.InvalidURL` now exposes a ``description`` property with the text explanation of the error details.
- Added a feature to retry closed connections automatically for idempotent methods.
- Implemented filter_cookies() with domain-matching and path-matching on the keys, instead of testing every single cookie.
This may break existing cookies that have been saved with `CookieJar.save()`. Cookies can be migrated with this script::
import pickle
with file_path.open("rb") as f:
cookies = pickle.load(f)
morsels = [(name, m) for c in cookies.values() for name, m in c.items()]
cookies.clear()
for name, m in morsels:
cookies[(m["domain"], m["path"].rstrip("/"))][name] = m
with file_path.open("wb") as f:
pickle.dump(cookies, f, pickle.HIGHEST_PROTOCOL)
- Separated connection and socket timeout errors, from ServerTimeoutError.
- Implemented happy eyeballs
- Added server capability to check for static files with Brotli compression via a ``.br`` extension
Removals and backward incompatible breaking changes
- The shutdown logic in 3.9 waited on all tasks, which caused issues with some libraries.
In 3.10 we've changed this logic to only wait on request handlers. This means that it's
important for developers to correctly handle the lifecycle of background tasks using a
library such as ``aiojobs``. If an application is using ``handler_cancellation=True`` then
it is also a good idea to ensure that any :func:`asyncio.shield` calls are replaced with
:func:`aiojobs.aiohttp.shield`.
Improved documentation
- Added documentation for ``aiohttp.web.FileResponse``.
- Improved the docs for the `ssl` params.
Contributor-facing changes
- Enabled HTTP parser tests originally intended for 3.9.2 release
Miscellaneous internal changes
- Improved URL handler resolution time by indexing resources in the UrlDispatcher.
For applications with a large number of handlers, this should increase performance significantly.
- Added `nacl_middleware <https://github.com/CosmicDNA/nacl_middleware>`_ to the list of middlewares in the third party section of the documentation.
- Minor improvements to static typing
- Added a 3.11-specific overloads to ``ClientSession``
- Simplified path checks for ``UrlDispatcher.add_static()`` method
- Avoided creating a future on every websocket receive
- Updated identity checks for all ``WSMsgType`` type compares
- When using Python 3.12 or later, the writer is no longer scheduled on the event loop if it can finish synchronously. Avoiding event loop scheduling reduces latency and improves performance.
- Restored :py:class:`~aiohttp.resolver.AsyncResolver` to be the default resolver.
py-aiohttp: updated to 3.9.5 3.9.5 (2024-04-16) Bug fixes - Fixed "Unclosed client session" when initialization of :py:class:`~aiohttp.ClientSession` fails - Fixed regression (from :pr:`8280`) with adding ``Content-Disposition`` to the ``form-data`` part after appending to writer - Added default ``Content-Disposition`` in ``multipart/form-data`` responses to avoid broken form-data responses
py-aiohttp: updated to 3.9.4 3.9.4 (2024-04-11) Bug fixes - The asynchronous internals now set the underlying causes when assigning exceptions to the future objects - Treated values of ``Accept-Encoding`` header as case-insensitive when checking for gzip files - Improved the DNS resolution performance on cache hit This is achieved by avoiding an :mod:`asyncio` task creation in this case. - Changed the type annotations to allow ``dict`` on :meth:`aiohttp.MultipartWriter.append`, :meth:`aiohttp.MultipartWriter.append_json` and :meth:`aiohttp.MultipartWriter.append_form` - Ensure websocket transport is closed when client does not close it The transport could remain open if the client did not close it. This change ensures the transport is closed when the client does not close it. - Leave websocket transport open if receive times out or is cancelled This restores the behavior prior to the change in 7978. - Fixed content not being read when an upgrade request was not supported with the pure Python implementation. - Fixed a race condition with incoming connections during server shutdown - Fixed ``multipart/form-data`` compliance with :rfc:`7578` - Fixed blocking I/O in the event loop while processing files in a POST request - Escaped filenames in static view - Fixed the pure python parser to mark a connection as closing when a response has no length Features - Upgraded *llhttp* to 9.2.1, and started rejecting obsolete line folding in Python parser to match Deprecations (removal in next major release) - Deprecated ``content_transfer_encoding`` parameter in :py:meth:`FormData.add_field() <aiohttp.FormData.add_field>` Improved documentation - Added a note about canceling tasks to avoid delaying server shutdown
py-aiohttp: updated to 3.9.3 3.9.3 (2024-01-29) Bug fixes - Fixed backwards compatibility breakage (in 3.9.2) of ``ssl`` parameter when set outside of ``ClientSession`` (e.g. directly in ``TCPConnector``)
py-aiohttp: updated to 3.9.2 3.9.2 (2024-01-28) Bug fixes - Fixed server-side websocket connection leak. - Fixed ``web.FileResponse`` doing blocking I/O in the event loop. - Fixed double compress when compression enabled and compressed file exists in server file responses. - Added runtime type check for ``ClientSession`` ``timeout`` parameter. - Fixed an unhandled exception in the Python HTTP parser on header lines starting with a colon Invalid request lines with anything but a dot between the HTTP major and minor version are now rejected. Invalid header field names containing question mark or slash are now rejected. Such requests are incompatible with :rfc:`9110#section-5.6.2` and are not known to be of any legitimate use. - Improved validation of paths for static resources requests to the server Features - Added support for passing :py:data:`True` to ``ssl`` parameter in ``ClientSession`` while deprecating :py:data:`None` Breaking changes - Fixed an unhandled exception in the Python HTTP parser on header lines starting with a colon Invalid request lines with anything but a dot between the HTTP major and minor version are now rejected. Invalid header field names containing question mark or slash are now rejected. Such requests are incompatible with :rfc:`9110#section-5.6.2` and are not known to be of any legitimate use. Improved documentation - Fixed examples of ``fallback_charset_resolver`` function in the :doc:`client_advanced` document. - The Sphinx setup was updated to avoid showing the empty changelog draft section in the tagged release documentation builds on Read The Docs
py-aiohttp: updated to 3.9.1 3.9.1 (2023-11-26) Bugfixes - Fixed importing aiohttp under PyPy on Windows. - Fixed async concurrency safety in websocket compressor. - Fixed ``ClientResponse.close()`` releasing the connection instead of closing. - Fixed a regression where connection may get closed during upgrade. - Fixed messages being reported as upgraded without an Upgrade header in Python parser.
py-aiohttp: update to 3.9.0. Bugfixes.
python/wheel.mk: simplify a lot, and switch to 'installer' for installation This follows the recommended bootstrap method (flit_core, build, installer). However, installer installs different files than pip, so update PLISTs for all packages using wheel.mk and bump their PKGREVISIONs.
py-aiohttp: updated to 3.8.6 3.8.6 (2023-10-07) Security bugfixes - Upgraded the vendored copy of llhttp_ to v9.1.3 - Updated Python parser to comply with RFCs 9110/9112 Deprecation - Added ``fallback_charset_resolver`` parameter in ``ClientSession`` to allow a user-supplied character set detection function. Character set detection will no longer be included in 3.9 as a default. If this feature is needed, please use `fallback_charset_resolver <https://docs.aiohttp.org/en/stable/client_advanced.html#character-set-detection>`_. Features - Enabled lenient response parsing for more flexible parsing in the client (this should resolve some regressions when dealing with badly formatted HTTP responses). Bugfixes - Fixed ``PermissionError`` when ``.netrc`` is unreadable due to permissions. - Fixed output of parsing errors pointing to a ``\n``. - Fixed ``GunicornWebWorker`` max_requests_jitter not working. - Fixed sorting in ``filter_cookies`` to use cookie with longest path. - Fixed display of ``BadStatusLine`` messages from llhttp_.
py-aiohttp: updated to 3.8.5 3.8.5 (2023-07-19) Security bugfixes - Upgraded the vendored copy of llhttp_ to v8.1.1 Features - Added information to C parser exceptions to show which character caused the error. Bugfixes - Fixed a transport is :data:`None` error
py-aiohttp: updated to 3.8.4 3.8.4 (2023-02-12) Bugfixes -------- - Fixed incorrectly overwriting cookies with the same name and domain, but different path. - Fixed ``ConnectionResetError`` not being raised after client disconnection in SSL environments.
py-aiohttp: unrestrict charset-normalizer dependency pkgsrc has a newer version Bump PKGREVISION. Fix pkglint while here.
py-aiohttp: updated to 3.8.3 3.8.3 (2022-09-21) ================== This is the last :doc:`aiohttp <index>` release tested under Python 3.6. The 3.9 stream is dropping it from the CI and the distribution package metadata. Bugfixes -------- - Increased the upper boundary of the :doc:`multidict:index` dependency to allow for the version 6 -- by :user:`hugovk`. It used to be limited below version 7 in :doc:`aiohttp <index>` v3.8.1 but was lowered in v3.8.2 via :pr:`6550` and never brought back, causing problems with dependency pins when upgrading. :doc:`aiohttp <index>` v3.8.3 fixes that by recovering the original boundary of ``< 7``.
py-aiohttp: add missing DEPENDS
Update www/py-aiohttp to 3.8.1 Several versions skipped, check https://github.com/aio-libs/aiohttp/releases for change log.
*: bump PKGREVISION for egg.mk users They now have a tool dependency on py-setuptools instead of a DEPENDS
Do not mention Python 3.6
py-aiohttp: updated to 3.7.4 3.7.4 (2021-02-25) Bugfixes (SECURITY BUG) Started preventing open redirects in the aiohttp.web.normalize_path_middleware middleware. For more details, see https://github.com/aio-libs/aiohttp/security/advisories/GHSA-v6wp-4m6f-gcjg. Thanks to Beast Glatisant for finding the first instance of this issue and Jelmer Vernooij for reporting and tracking it down in aiohttp. Fix interpretation difference of the pure-Python and the Cython-based HTTP parsers construct a yarl.URL object for HTTP request-target. Before this fix, the Python parser would turn the URI's absolute-path for //some-path into / while the Cython code preserved it as //some-path. Now, both do the latter.
py-aiohttp: Bump chardet requirements in setup.py too Previously it was only relaxed in pkgsrc DEPENDS resulting in possible runtime errors. PKGREVISION++
py-aiohttp: remove upper bound in dependency
py-aiohttp: updated to 3.7.3 3.7.3 ===== Features -------- - Use Brotli instead of brotlipy - Made exceptions pickleable. Also changed the repr of some exceptions. Bugfixes -------- - Raise a ClientResponseError instead of an AssertionError for a blank HTTP Reason Phrase. - Fix ``web_middlewares.normalize_path_middleware`` behavior for patch without slash. - Fix overshadowing of overlapped sub-applications prefixes. - Make `BaseConnector.close()` a coroutine and wait until the client closes all connections. Drop deprecated "with Connector():" syntax. - Reset the ``sock_read`` timeout each time data is received for a ``aiohttp.client`` response. - Fixed type annotation for add_view method of UrlDispatcher to accept any subclass of View - Fixed querying the address families from DNS that the current host supports. - Change return type of MultipartReader.__aiter__() and BodyPartReader.__aiter__() to AsyncIterator. - Provide x86 Windows wheels. Improved Documentation ---------------------- - Add documentation for ``aiohttp.web.FileResponse``. - Removed deprecation warning in tracing example docs - Fixed wrong "Usage" docstring of ``aiohttp.client.request``. - Add aiohttp-pydantic to third party libraries
py-aiohttp: updated to 3.7.2 3.7.2 Bugfixes - Fixed static files handling for loops without ``.sendfile()`` support
py-aiohttp: updated to 3.7.1 3.7.1 Bugfixes - Fixed a type error caused by the conditional import of `Protocol`. - Server doesn't send Content-Length for 1xx or 204 - Fix run_app typing - Always require ``typing_extensions`` library. - Fix a variable-shadowing bug causing `ThreadedResolver.resolve` to return the resolved IP as the ``hostname`` in each record, which prevented validation of HTTPS connections. - Added annotations to all public attributes. - Fix flaky test_when_timeout_smaller_second - Ensure sending a zero byte file does not throw an exception - Fix a bug in ``web.run_app()`` about Python version checking on Windows
py-aiohttp: Always depends on py-typing-extensions web_urldispatcher imports it unconditionally.
Update www/py-aiohttp to 3.7.0 This fixes py-yarl in pkgsrc being too new for py-aiohttp. 3.7.0 (2020-10-24) ================== Features -------- - Response headers are now prepared prior to running ``on_response_prepare`` hooks, directly before headers are sent to the client. `#1958 <https://github.com/aio-libs/aiohttp/issues/1958>`_ - Add a ``quote_cookie`` option to ``CookieJar``, a way to skip quotation wrapping of cookies containing special characters. `#2571 <https://github.com/aio-libs/aiohttp/issues/2571>`_ - Call ``AccessLogger.log`` with the current exception available from ``sys.exc_info()``. `#3557 <https://github.com/aio-libs/aiohttp/issues/3557>`_ - `web.UrlDispatcher.add_routes` and `web.Application.add_routes` return a list of registered `AbstractRoute` instances. `AbstractRouteDef.register` (and all subclasses) return a list of registered resources registered resource. `#3866 <https://github.com/aio-libs/aiohttp/issues/3866>`_ - Added properties of default ClientSession params to ClientSession class so it is available for introspection `#3882 <https://github.com/aio-libs/aiohttp/issues/3882>`_ - Don't cancel web handler on peer disconnection, raise `OSError` on reading/writing instead. `#4080 <https://github.com/aio-libs/aiohttp/issues/4080>`_ - Implement BaseRequest.get_extra_info() to access a protocol transports' extra info. `#4189 <https://github.com/aio-libs/aiohttp/issues/4189>`_ - Added `ClientSession.timeout` property. `#4191 <https://github.com/aio-libs/aiohttp/issues/4191>`_ - allow use of SameSite in cookies. `#4224 <https://github.com/aio-libs/aiohttp/issues/4224>`_ - Use ``loop.sendfile()`` instead of custom implementation if available. `#4269 <https://github.com/aio-libs/aiohttp/issues/4269>`_ - Apply SO_REUSEADDR to test server's socket. `#4393 <https://github.com/aio-libs/aiohttp/issues/4393>`_ - Use .raw_host instead of slower .host in client API `#4402 <https://github.com/aio-libs/aiohttp/issues/4402>`_ - Allow configuring the buffer size of input stream by passing ``read_bufsize`` argument. `#4453 <https://github.com/aio-libs/aiohttp/issues/4453>`_ - Pass tests on Python 3.8 for Windows. `#4513 <https://github.com/aio-libs/aiohttp/issues/4513>`_ - Add `method` and `url` attributes to `TraceRequestChunkSentParams` and `TraceResponseChunkReceivedParams`. `#4674 <https://github.com/aio-libs/aiohttp/issues/4674>`_ - Add ClientResponse.ok property for checking status code under 400. `#4711 <https://github.com/aio-libs/aiohttp/issues/4711>`_ - Don't ceil timeouts that are smaller than 5 seconds. `#4850 <https://github.com/aio-libs/aiohttp/issues/4850>`_ - TCPSite now listens by default on all interfaces instead of just IPv4 when `None` is passed in as the host. `#4894 <https://github.com/aio-libs/aiohttp/issues/4894>`_ - Bump ``http_parser`` to 2.9.4 `#5070 <https://github.com/aio-libs/aiohttp/issues/5070>`_ Bugfixes -------- - Fix keepalive connections not being closed in time `#3296 <https://github.com/aio-libs/aiohttp/issues/3296>`_ - Fix failed websocket handshake leaving connection hanging. `#3380 <https://github.com/aio-libs/aiohttp/issues/3380>`_ - Fix tasks cancellation order on exit. The run_app task needs to be cancelled first for cleanup hooks to run with all tasks intact. `#3805 <https://github.com/aio-libs/aiohttp/issues/3805>`_ - Don't start heartbeat until _writer is set `#4062 <https://github.com/aio-libs/aiohttp/issues/4062>`_ - Fix handling of multipart file uploads without a content type. `#4089 <https://github.com/aio-libs/aiohttp/issues/4089>`_ - Preserve view handler function attributes across middlewares `#4174 <https://github.com/aio-libs/aiohttp/issues/4174>`_ - Fix the string representation of ``ServerDisconnectedError``. `#4175 <https://github.com/aio-libs/aiohttp/issues/4175>`_ - Raising RuntimeError when trying to get encoding from not read body `#4214 <https://github.com/aio-libs/aiohttp/issues/4214>`_ - Remove warning messages from noop. `#4282 <https://github.com/aio-libs/aiohttp/issues/4282>`_ - Raise ClientPayloadError if FormData re-processed. `#4345 <https://github.com/aio-libs/aiohttp/issues/4345>`_ - Fix a warning about unfinished task in ``web_protocol.py`` `#4408 <https://github.com/aio-libs/aiohttp/issues/4408>`_ - Fixed 'deflate' compression. According to RFC 2616 now. `#4506 <https://github.com/aio-libs/aiohttp/issues/4506>`_ - Fixed OverflowError on platforms with 32-bit time_t `#4515 <https://github.com/aio-libs/aiohttp/issues/4515>`_ - Fixed request.body_exists returns wrong value for methods without body. `#4528 <https://github.com/aio-libs/aiohttp/issues/4528>`_ - Fix connecting to link-local IPv6 addresses. `#4554 <https://github.com/aio-libs/aiohttp/issues/4554>`_ - Fix a problem with connection waiters that are never awaited. `#4562 <https://github.com/aio-libs/aiohttp/issues/4562>`_ - Always make sure transport is not closing before reuse a connection. Reuse a protocol based on keepalive in headers is unreliable. For example, uWSGI will not support keepalive even it serves a HTTP 1.1 request, except explicitly configure uWSGI with a ``--http-keepalive`` option. Servers designed like uWSGI could cause aiohttp intermittently raise a ConnectionResetException when the protocol poll runs out and some protocol is reused. `#4587 <https://github.com/aio-libs/aiohttp/issues/4587>`_ - Handle the last CRLF correctly even if it is received via separate TCP segment. `#4630 <https://github.com/aio-libs/aiohttp/issues/4630>`_ - Fix the register_resource function to validate route name before splitting it so that route name can include python keywords. `#4691 <https://github.com/aio-libs/aiohttp/issues/4691>`_ - Improve typing annotations for ``web.Request``, ``aiohttp.ClientResponse`` and ``multipart`` module. `#4736 <https://github.com/aio-libs/aiohttp/issues/4736>`_ - Fix resolver task is not awaited when connector is cancelled `#4795 <https://github.com/aio-libs/aiohttp/issues/4795>`_ - Fix a bug "Aiohttp doesn't return any error on invalid request methods" `#4798 <https://github.com/aio-libs/aiohttp/issues/4798>`_ - Fix HEAD requests for static content. `#4809 <https://github.com/aio-libs/aiohttp/issues/4809>`_ - Fix incorrect size calculation for memoryview `#4890 <https://github.com/aio-libs/aiohttp/issues/4890>`_ - Add HTTPMove to _all__. `#4897 <https://github.com/aio-libs/aiohttp/issues/4897>`_ - Fixed the type annotations in the ``tracing`` module. `#4912 <https://github.com/aio-libs/aiohttp/issues/4912>`_ - Fix typing for multipart ``__aiter__``. `#4931 <https://github.com/aio-libs/aiohttp/issues/4931>`_ - Fix for race condition on connections in BaseConnector that leads to exceeding the connection limit. `#4936 <https://github.com/aio-libs/aiohttp/issues/4936>`_ - Add forced UTF-8 encoding for ``application/rdap+json`` responses. `#4938 <https://github.com/aio-libs/aiohttp/issues/4938>`_ - Fix inconsistency between Python and C http request parsers in parsing pct-encoded URL. `#4972 <https://github.com/aio-libs/aiohttp/issues/4972>`_ - Fix connection closing issue in HEAD request. `#5012 <https://github.com/aio-libs/aiohttp/issues/5012>`_ - Fix type hint on BaseRunner.addresses (from ``List[str]`` to ``List[Any]``) `#5086 <https://github.com/aio-libs/aiohttp/issues/5086>`_ - Make `web.run_app()` more responsive to Ctrl+C on Windows for Python < 3.8. It slightly increases CPU load as a side effect. `#5098 <https://github.com/aio-libs/aiohttp/issues/5098>`_ Improved Documentation ---------------------- - Fix example code in client quick-start `#3376 <https://github.com/aio-libs/aiohttp/issues/3376>`_ - Updated the docs so there is no contradiction in ``ttl_dns_cache`` default value `#3512 <https://github.com/aio-libs/aiohttp/issues/3512>`_ - Add 'Deploy with SSL' to docs. `#4201 <https://github.com/aio-libs/aiohttp/issues/4201>`_ - Change typing of the secure argument on StreamResponse.set_cookie from ``Optional[str]`` to ``Optional[bool]`` `#4204 <https://github.com/aio-libs/aiohttp/issues/4204>`_ - Changes ``ttl_dns_cache`` type from int to Optional[int]. `#4270 <https://github.com/aio-libs/aiohttp/issues/4270>`_ - Simplify README hello word example and add a documentation page for people coming from requests. `#4272 <https://github.com/aio-libs/aiohttp/issues/4272>`_ - Improve some code examples in the documentation involving websockets and starting a simple HTTP site with an AppRunner. `#4285 <https://github.com/aio-libs/aiohttp/issues/4285>`_ - Fix typo in code example in Multipart docs `#4312 <https://github.com/aio-libs/aiohttp/issues/4312>`_ - Fix code example in Multipart section. `#4314 <https://github.com/aio-libs/aiohttp/issues/4314>`_ - Update contributing guide so new contributors read the most recent version of that guide. Update command used to create test coverage reporting. `#4810 <https://github.com/aio-libs/aiohttp/issues/4810>`_ - Spelling: Change "canonize" to "canonicalize". `#4986 <https://github.com/aio-libs/aiohttp/issues/4986>`_ - Add ``aiohttp-sse-client`` library to third party usage list. `#5084 <https://github.com/aio-libs/aiohttp/issues/5084>`_ Misc ---- - `#2856 <https://github.com/aio-libs/aiohttp/issues/2856>`_, `#4218 <https://github.com/aio-libs/aiohttp/issues/4218>`_, `#4250 <https://github.com/aio-libs/aiohttp/issues/4250>`_
py-aiohttp: updated to 3.6.3 3.6.3: Bugfixes - Pin yarl to ``<1.6.0`` to avoid buggy behavior that will be fixed by the next aiohttp release.
py-aiohttp: updated to 3.6.2 3.6.2: Features - Made exceptions pickleable. Also changed the repr of some exceptions. - Use Iterable type hint instead of Sequence for Application *middleware* parameter. Bugfixes - Reset the sock_read timeout each time data is received for a aiohttp.ClientResponse. - Fix handling of expired cookies so they are not stored in CookieJar. - Fix misleading message in the string representation of ClientConnectorError; self.ssl == None means default SSL context, not SSL disabled - Don't clobber HTTP status when using FileResponse. Improved Documentation - Added minimal required logging configuration to logging documentation. - Update docs to reflect proxy support. - Fix typo in code example in testing docs.
py-aiohttp: updated to 3.6.1 3.6.1: Features - Compatibility with Python 3.8. Bugfixes - correct some exception string format - Emit a warning when ``ssl.OP_NO_COMPRESSION`` is unavailable because the runtime is built against an outdated OpenSSL. - Update multidict requirement to >= 4.5 Improved Documentation - Provide pytest-aiohttp namespace for pytest fixtures in docs.
py-aiohttp: updated to 3.6.0 3.6.0: Features - Add support for Named Pipes (Site and Connector) under Windows. This feature requires Proactor event loop to work. - Removed `Transfer-Encoding: chunked` header from websocket responses to be compatible with more http proxy servers. - Accept non-GET request for starting websocket handshake on server side. Bugfixes - Raise a ClientResponseError instead of an AssertionError for a blank HTTP Reason Phrase. - Fix an issue where cookies would sometimes not be set during a redirect. - Change normalize_path_middleware to use 308 redirect instead of 301. This behavior should prevent clients from being unable to use PUT/POST methods on endpoints that are redirected because of a trailing slash. - Drop the processed task from ``all_tasks()`` list early. It prevents logging about a task with unhandled exception when the server is used in conjunction with ``asyncio.run()``. - ``Signal`` type annotation changed from `Signal[Callable[['TraceConfig'], Awaitable[None]]]` to `Signal[Callable[ClientSession, SimpleNamespace, ...]`. - Use sanitized URL as Location header in redirects - Improve typing annotations for multipart.py along with changes required by mypy in files that references multipart.py. - Close session created inside ``aiohttp.request`` when unhandled exception occurs - Cleanup per-chunk data in generic data read. Memory leak fixed. - Use correct type for add_view and family - Fix _keepalive field in __slots__ of web_protocol.RequestHandler. - Properly handle ConnectionResetError, to silence the "Cannot write to closing transport" exception when clients disconnect uncleanly. - Suppress pytest warnings due to test util classes - Fix overshadowing of overlapped subbaps prefixes. - Fixed return type annotation for WSMessage.json() - Properly expose TooManyRedirects publicly as documented. - Fix missing brackets for IPv6 in proxy CONNECT request - Make the signature of `aiohttp.test_utils.TestClient.request` match `asyncio.ClientSession.request` according to the docs - Use correct style for re-exported imports, makes mypy ``--strict`` mode happy. - Fixed type annotation for add_view method of UrlDispatcher to accept any subclass of View - Made cython HTTP parser set Reason-Phrase of the response to an empty string if it is missing. - Add URL to the string representation of ClientResponseError. - Accept istr keys in LooseHeaders type hints. - Fixed race conditions in _resolve_host caching and throttling when tracing is enabled. - For URLs like "unix://localhost/..." set Host HTTP header to "localhost" instead of "localhost:None".
Omit mentions of python 34 and 35, after those were removed. - Includes some whitespace changes, to be handled in a separate commit.
py-aiohttp: updated to 3.5.4 3.5.4: Bugfixes - Fix stream .read() / .readany() / .iter_any() which used to return a partial content only in case of compressed content
py-aiohttp: updated to 3.5.3 3.5.3: Bugfixes - Fix type stubs for aiohttp.web.run_app(access_log=True) and fix edge case of access_log=True and the event loop being in debug mode. - Fix aiohttp.ClientTimeout type annotations to accept None for fields - Send custom per-request cookies even if session jar is empty - Restore Linux binary wheels publishing on PyPI
py-aiohttp: updated to 3.5.2 3.5.2: Features - FileResponse from web_fileresponse.py uses a ThreadPoolExecutor to work with files asynchronously. I/O based payloads from payload.py uses a ThreadPoolExecutor to work with I/O objects asynchronously. - Internal Server Errors in plain text if the browser does not support HTML. Bugfixes - Preserve MultipartWriter parts headers on write. Refactor the way how Payload.headers are handled. Payload instances now always have headers and Content-Type defined. Fix Payload Content-Disposition header reset after initial creation. - Log suppressed exceptions in GunicornWebWorker. - Remove wildcard imports. - Use the same task for app initialization and web server handling in gunicorn workers. It allows to use Python3.7 context vars smoothly. - Fix handling of chunked+gzipped response when first chunk does not give uncompressed data - Replace collections.MutableMapping with collections.abc.MutableMapping to avoid a deprecation warning. - Payload.size type annotation changed from Optional[float] to Optional[int]. - Ignore done tasks when cancels pending activities on web.run_app finalization.
py-aiohttp: updated to 3.5.1 3.5.1 - Fix a regression about ClientSession._requote_redirect_url modification in debug mode.
py-aiohttp: updated to 3.5.0 3.5.0 (2018-12-22) Features The library type annotations are checked in strict mode now. Add support for setting cookies for individual request Application.add_domain implementation The default app in the request returned by test_utils.make_mocked_request can now have objects assigned to it and retrieved using the [] operator. Make request.url accessible when transport is closed. Add zlib_executor_size argument to Response constructor to allow compression to run in a background executor to avoid blocking the main thread and potentially triggering health check failures. Enable users to set ClientTimeout in aiohttp.request Don’t raise a warning if NETRC environment variable is not set and ~/.netrc file doesn’t exist. Add default logging handler to web.run_app If the Application.debug flag is set and the default logger aiohttp.access is used, access logs will now be output using a stderr StreamHandler if no handlers are attached. Furthermore, if the default logger has no log level set, the log level will be set to DEBUG. Add method argument to session.ws_connect(). Sometimes server API requires a different HTTP method for WebSocket connection establishment. For example, Docker exec needs POST. Create a task per request handling. Bugfixes Enable passing access_log_class via handler_args Return empty bytes with end-of-chunk marker in empty stream reader. Accept CIMultiDictProxy instances for headers argument in web.Response constructor. Don’t uppercase HTTP method in parser Make method match regexp RFC-7230 compliant Add app.pre_frozen state to properly handle startup signals in sub-applications. Enhanced parsing and validation of helpers.BasicAuth.decode. Change imports from collections module in preparation for 3.8. Ensure Host header is added first to ClientRequest to better replicate browser Fix forward compatibility with Python 3.8: importing ABCs directly from the collections module will not be supported anymore. Keep the query string by normalize_path_middleware. Fix missing parameter raise_for_status for aiohttp.request() Bracket IPv6 addresses in the HOST header Fix default message for server ping and pong frames. Fix tests/test_connector.py typo and tests/autobahn/server.py duplicate loop def. Fix false-negative indicator end_of_HTTP_chunk in StreamReader.readchunk function Release HTTP response before raising status exception Fix task cancellation when sendfile() syscall is used by static file handling. Fix stack trace for asyncio.TimeoutError which was not logged, when it is caught in the handler. Improved Documentation Improve documentation of Application.make_handler parameters. Fix BaseRequest.raw_headers doc. Fix typo in TypeError exception reason in web.Application._handle Make server access log format placeholder %b documentation reflect behavior and docstring. Deprecations and Removals Deprecate modification of session.requote_redirect_url Deprecate stream.unread_data() Deprecated use of boolean in resp.enable_compression() Encourage creation of aiohttp public objects inside a coroutine Drop dead Connection.detach() and Connection.writer. Both methods were broken for more than 2 years. Deprecate app.loop, request.loop, client.loop and connector.loop properties. Deprecate explicit debug argument. Use asyncio debug mode instead. Deprecate body parameter in HTTPException (and derived classes) constructor. Deprecate bare connector close, use async with connector: and await connector.close() instead. Deprecate obsolete read_timeout and conn_timeout in ClientSession constructor.
py-aiohttp: updated to 3.4.4 3.4.4: Fix installation from sources when compiling toolkit is not available 3.4.3: Add app.pre_frozen state to properly handle startup signals in sub-applications.
py-aiohttp: updated to 3.4.2 3.4.2: Fix iter_chunks type annotation
py-aiohttp: updated to 3.4.1 3.4.1: - Fix empty header parsing regression. - Fix BaseRequest.raw_headers doc. - Fix documentation building on ReadTheDocs
py-aiohttp: rearrange PYTHON_VERSIONS_INCOMPATIBLE
py-aiohttp: updated to 3.4.0 3.4.0: Features Add type hints Add raise_for_status request parameter Add type hints to HTTP client Minor server optimizations Preserve the cause when HTTPException is raised from another exception. Add close_boundary option in MultipartWriter.write method. Support streaming Added a remove_slash option to the normalize_path_middleware factory. The class AbstractRouteDef is importable from aiohttp.web. Bugfixes Prevent double closing when client connection is released before the last data_received() callback. Make redirect with normalize_path_middleware work when using url encoded paths. Postpone web task creation to connection establishment. Fix sock_read timeout. When using a server-request body as the data= argument of a client request, iterate over the content with readany instead of readline to avoid Line too long errors. fix UrlDispatcher has no attribute add_options, add web.options correct filename in content-disposition with multipart body Many HTTP proxies has buggy keepalive support. Let's not reuse connection but close it after processing every response. raise 413 "Payload Too Large" rather than raising ValueError in request.post() Add helpful debug message to 413 responses Fix StreamResponse equality, now that they are MutableMapping objects. Fix server request objects comparison Do not hang on 206 Partial Content response with Content-Encoding: gzip Fix timeout precondition checkers Improved Documentation Add a new FAQ entry that clarifies that you should not reuse response objects in middleware functions. Add FAQ section "Why is creating a ClientSession outside of an event loop dangerous?" Fix link to Rambler Fix TCPSite documentation on the Server Reference page. Fix documentation build configuration file for Windows. Remove no longer existing lingering_timeout parameter of Application.make_handler from documentation. Mention that app.make_handler is deprecated, recommend to use runners API instead. Deprecations and Removals Drop loop.current_task() from helpers.current_task() Drop reader parameter from request.multipart().
py-aiohttp: updated to 3.3.2 3.3.2: - Many HTTP proxies has buggy keepalive support. Let's not reuse connection but close it after processing every response. - Provide vendor source files in tarball 3.3.1: - Fix sock_read timeout. - When using a server-request body as the data= argument of a client request, iterate over the content with readany instead of readline to avoid Line too long errors. 3.3.0: Features - Raise ConnectionResetError instead of CancelledError on trying to write to a closed stream. - Implement ClientTimeout class and support socket read timeout. - Enable logging when aiohttp.web is used as a program - Add canonical property to resources - Forbid reading response BODY after release - Implement base protocol class to avoid a dependency from internal asyncio.streams.FlowControlMixin - Cythonize @helpers.reify, 5% boost on macro benchmark - Optimize HTTP parser - Implement runner.addresses property. - Use bytearray instead of a list of bytes in websocket reader. It improves websocket message reading a little. - Remove heartbeat on closing connection on keepalive timeout. The used hack violates HTTP protocol. - Limit websocket message size on reading to 4 MB by default. Bugfixes - Don't reuse a connection with the same URL but different proxy/TLS settings - When parsing the Forwarded header, the optional port number is now preserved. Improved Documentation - Make Change Log more visible in docs - Make style and grammar improvements on the FAQ page. - Document that signal handlers should be async functions since aiohttp 3.0 Deprecations and Removals - Deprecate custom application's router.
py-aiohttp: updated to 3.2.1 3.2.1: Don’t reuse a connection with the same URL but different proxy/TLS settings
py-aiohttp: updated to 3.2.0 3.2.0 Features Raise TooManyRedirects exception when client gets redirected too many times instead of returning last response. Extract route definitions into separate web_routedef.py file Raise an exception on request body reading after sending response. ClientResponse and RequestInfo now have real_url property, which is request url without fragment part being stripped Speed up connector limiting Added and links property for ClientResponse object Add request.config_dict for exposing nested applications data. Speed up HTTP headers serialization, server micro-benchmark runs 5% faster now. Apply assertions in debug mode only Bugfixes expose property app for TestClient Call on_chunk_sent when write_eof takes as a param the last chunk A closing bracket was added to __repr__ of resources Fix compression of FileResponse Fixes some bugs in the limit connection feature Improved Documentation Drop async_timeout usage from documentation for client API in favor of timeout parameter. Improve Gunicorn logging documentation Replace multipart writer .serialize() method with .write() in documentation. Deprecations and Removals Deprecate Application.make_handler()
py-aiohttp: updated to 3.1.3 3.1.3: Fix cancellation broadcast during DNS resolve
py-aiohttp: updated to 3.1.2 3.1.2: Make LineTooLong exception more detailed about actual data size Call on_chunk_sent when write_eof takes as a param the last chunk
py-aiohttp: updated to 3.1.1 3.1.1: Support asynchronous iterators (and asynchronous generators as well) in both client and server API as request / response BODY payloads.
py-aiohttp: updated to 3.1.0 3.1.0: Features - Relax JSON content-type checking in the ClientResponse.json() to allow "application/xxx+json" instead of strict "application/json". - Bump C HTTP parser to version 2.8 - Accept a coroutine as an application factory in web.run_app and gunicorn worker. - Implement application cleanup context - Make writer.write_headers a coroutine. - Add tracking signals for getting request/response bodies. - Deprecate ClientResponseError.code in favor of .status to keep similarity with response classes. - Implement app.add_routes() method. - Implement web.static() and RouteTableDef.static() API. - Install a test event loop as default by asyncio.set_event_loop(). The change affects aiohttp test utils but backward compatibility is not broken for 99.99% of use cases. - Refactor ClientResponse constructor: make logically required constructor arguments mandatory, drop _post_init() method. - Use app.add_routes() in server docs everywhere - Websockets refactoring, all websocket writer methods are converted into coroutines. - Provide Content-Range header for Range requests Bugfixes - Fix websocket client return EofStream. - Fix websocket demo. - Property BaseRequest.http_range now returns a python-like slice when requesting the tail of the range. It's now indicated by a negative value in range.start rather then in range.stop - Close a connection if an unexpected exception occurs while sending a request - Fix firing DNS tracing events. Improved Documentation - Change ClientResponse.json() documentation to reflect that it now allows "application/xxx+json" content-types - Document behavior when cchardet detects encodings that are unknown to Python. - Add diagrams for tracing request life style. - Drop removed functionality for passing StreamReader as data at client side.
py-aiohttp: updated to 3.0.9 3.0.9: Close a connection if an unexpected exception occurs while sending a request
py-aiohttp: updated to 3.0.8 3.0.8: Use asyncio.current_task() on Python 3.7
py-aiohttp: updated to 3.0.7 3.0.7: Fix SSL proxy support by client. Restore a imperative check in setup.py for python version. The check works in parallel to environment marker. As effect a error about unsupported Python versions is raised even on outdated systems with very old setuptools version installed.
py-aiohttp: updated to 3.0.6 3.0.6: Add _reuse_address and _reuse_port to web_runner.TCPSite.__slots__.
py-aiohttp: updated to 3.0.5 3.0.5: Fix InvalidStateError on processing a sequence of two RequestHandler.data_received calls on web server.
py-aiohttp: updated to 3.0.4 3.0.4: Fix IndexError in HTTP request handling by server. Fix MultipartWriter.append* no longer returning part/payload.
py-aiohttp: updated to 3.0.3 3.0.2: Security Fix Prevent Windows absolute URLs in static files. Paths like /static/D:\path and /static/\\hostname\drive\path are forbidden. 3.0.1: Technical release for fixing distribution problems.
py-aiohttp: updated to 3.0.1 aiohttp 3.0 release: Major release, many already deprecated things are removed Minimal supported Python version is 3.5.3. aiohttp uses shiny async/await syntax everywhere internally (while old yield from is still supported). Read https://docs.aiohttp.org/en/stable/whats_new_3_0.html for brief information about most important changes.
py-aiohttp: updated to version 2.3.10 2.3.10: - Fix 100% CPU usage on HTTP GET and websocket connection just after it - Patch broken `ssl.match_hostname()` on Python<3.7
py-aiohttp: updated to 2.3.9 2.3.9: Fix colon handing in path for dynamic resources
py-aiohttp: updated to 2.3.8 2.3.8: Do not use yarl.unquote internal function in aiohttp. Fix incorrectly unquoted path part in URL dispatcher Fix compatibility with yarl==1.0.0
py-aiohttp: updated to 2.3.7 2.3.7: Fixed race-condition for iterating addresses from the DNSCache. Fix docstring for request.host Fix docstring for request.remote
py-aiohttp: updated to 2.3.6 2.3.6: Correct request.app context (for handlers not just middlewares).
py-aiohttp: updated to 2.3.5 2.3.5: Fix compatibility with pytest 3.3+ 2.3.4: Make request.app point to proper application instance when using nested applications (with middlewares). Change base class of ClientConnectorSSLError to ClientSSLError from ClientConnectorError. Return client connection back to free pool on error in connector.connect().
py-aiohttp: updated to 2.3.3 2.3.3: Having a ; in Response content type does not assume it contains a charset anymore. Use getattr(asyncio, ‘async’) for keeping compatibility with Python 3.7. Ignore NotImplementedError raised by set_child_watcher from uvloop. Fix warning in ClientSession.__del__ by stopping to try to close it. Fixed typo’s in Third-party libraries page. And added async-v20 to the list
py-aiohttp: updated to 2.3.2 2.3.2: Fix passing client max size on cloning request obj. Fix ClientConnectorSSLError and ClientProxyConnectionError for proxy connector. Drop generated _http_parser shared object from tarball distribution. Fix connector convert OSError to ClientConnectorError. Fix connection attempts for multiple dns hosts. Fix ValueError for AF_INET6 sockets if a preexisting INET6 socket to the aiohttp.web.run_app function. _SessionRequestContextManager closes the session properly now. Rename from_env to trust_env in client reference. 2.3.1: Relax attribute lookup in warning about old-styled middleware
py-aiohttp: update to 2.3.0 2.3.0: Features -------- Add SSL related params to ClientSession.request Make enable_compression work on HTTP/1.0 Deprecate registering synchronous web handlers Switch to multidict 3.0. All HTTP headers preserve casing now but compared in case-insensitive way. Improvement for normalize_path_middleware. Added possibility to handle URLs with query string. Use towncrier for CHANGES.txt build Implement trust_env=True param in ClientSession. Added variable to customize proxy headers Implement router.add_routes and router decorators. Deprecated BaseRequest.has_body in favor of BaseRequest.can_read_body Added BaseRequest.body_exists attribute that stays static for the lifetime of the request Provide BaseRequest.loop attribute Make _CoroGuard awaitable and fix ClientSession.close warning message Responses to redirects without Location header are returned instead of raising a RuntimeError Added get_client, get_server, setUpAsync and tearDownAsync methods to AioHTTPTestCase Add automatically a SafeChildWatcher to the test loop add ability to disable automatic response decompression Add support for throttling DNS request, avoiding the requests saturation when there is a miss in the DNS cache and many requests getting into the connector at the same time. Use request for getting access log information instead of message/transport pair. Add RequestBase.remote property for accessing to IP of client initiated HTTP request. json() raises a ContentTypeError exception if the content-type does not meet the requirements instead of raising a generic ClientResponseError. Make the HTTP client able to return HTTP chunks when chunked transfer encoding is used. add append_version arg into StaticResource.url and StaticResource.url_for methods for getting an url with hash (version) of the file. Fix parsing the Forwarded header. * commas and semicolons are allowed inside quoted-strings; * empty forwarded-pairs (as in for=_1;;by=_2) are allowed; * non-standard parameters are allowed (although this alone could be easily done in the previous parser). Don’t require ssl module to run. aiohttp does not require SSL to function. The code paths involved with SSL will only be hit upon SSL usage. Raise RuntimeError if HTTPS protocol is required but ssl module is not present. Accept coroutine fixtures in pytest plugin Call shutdown_asyncgens before event loop closing on Python 3.6. Speed up Signals when there are no receivers Raise InvalidURL instead of ValueError on fetches with invalid URL. Move DummyCookieJar into cookiejar.py run_app: Make print=None disable printing Support brotli encoding (generic-purpose lossless compression algorithm) Add server support for WebSockets Per-Message Deflate. Add client option to add deflate compress header in WebSockets request header. If calling ClientSession.ws_connect() with compress=15 the client will support deflate compress negotiation. Support verify_ssl, fingerprint, ssl_context and proxy_headers by client.ws_connect. Added aiohttp.ClientConnectorSSLError when connection fails due ssl.SSLError aiohttp.web.Application.make_handler support access_log_class Build HTTP parser extension in non-strict mode by default. Bugfixes -------- Clear auth information on redirecting to other domain Fix missing app.loop on startup hooks during tests Fix issue with synchronous session closing when using ClientSession as an asynchronous context manager. Fix issue with CookieJar incorrectly expiring cookies in some edge cases. Force use of IPv4 during test, this will make tests run in a Docker container Warnings about unawaited coroutines now correctly point to the user’s code. Fix issue with IndexError being raised by the StreamReader.iter_chunks() generator. Support HTTP 308 Permanent redirect in client class. Fix FileResponse sending empty chunked body on 304. Do not add Content-Length: 0 to GET/HEAD/TRACE/OPTIONS requests by default. Fix parsing the Forwarded header according to RFC 7239. Securely determining remote/scheme/host Fix header name parsing, if name is split into multiple lines Handle session close during connection, KeyError: <aiohttp.connector._TransportPlaceholder> Fixes uncaught TypeError in helpers.guess_filename if name is not a string Raise OSError on async DNS lookup if resolved domain is an alias for another one, which does not have an A or CNAME record. Fix incorrect warning in StreamReader. Properly clone state of web request Fix C HTTP parser for cases when status line is split into different TCP packets. Fix web.FileResponse overriding user supplied Content-Type
2.2.5: Don’t raise deprecation warning on loop.run_until_complete(client.close())
2.2.4: Fix issue with synchronous session closing when using ClientSession as an asynchronous context manager.
HTTP client/server for asyncio (PEP 3156). Features: * Supports both Client and HTTP Server. * Supports both Server WebSockets and Client WebSockets out-of-the-box. * Web-server has Middlewares, Signals and pluggable routing.