Version 2.11.902

2.11.902 (2024-10-22)

• Added viable replacement for connection close detection since we stopped using the function wait_for_read
  in property is_connected of a HTTPConnection object. And we harmonized the behavior whether you use async
  or sync.

Version 2.11.901

2.11.901 (2024-10-21)

• Fixed error in is_connected for a Connection. The logic is no longer applicable due to how urllib3-future grows.
  We no longer use the function wait_for_read. Also we stopped using MSG_PEEK for our discrete incoming data watcher
  due to suspicious behavior noticed. Finally we shielded any exception from attempting to close a broken socket.

Version 2.11.900

2.11.900 (2024-10-21)

• Added a discrete task for each instantiated ConnectionPool to watch for unsolicited incoming data.
  This improves the fix shipped in v2.10.906 and avoid having to recycle your multiplexed connection in idle moments.
  A new keyword argument is supported in your PoolManager configuration, namely background_watch_delay.
  This parameter takes a int or float as the delay between checks. Set it to None to void this background task.
  Anything lower than 0.01 will be interpreted as None, therefor disabling the discrete watch.
• Added managed keepalive for HTTP/2 and HTTP/3 over QUIC. A new keyword argument, named keepalive_delay that
  takes a value expressed in seconds for how long urllib3-future should automatically keep the connection alive.
  This is done in direct extension to our "discrete task" mentioned just before. We will send PING frame
  automatically to the remote peer every 60s by default (after idle for 60s to be clear). The window delay for
  sending a PING is configurable via the keepalive_idle_window parameter. Learn more about this in our
  documentation.
• Fixed evaluation of fp in our LowLevelResponse instance to raise AttributeError when it cannot be
  accessed. This will help with cachecontrol[filecache] way of determining if response was consumed entirely.

Version 2.10.906

2.10.906 (2024-10-17)

• Fixed handling aggressive ACKs watcher in some QUIC server implementation leading to a ProtocolError.
  We're actively working toward a solution that will avoid to recycle the QUIC connection.

Version 2.10.905

2.10.905 (2024-10-15)

• Fixed dangling task waiting for timeout when using Happy Eyeballs in a synchronous context.

Version 2.10.904

2.10.904 (2024-10-13)

• Fixed thread/task safety with WebSocket R/W operations.
• Fixed missing propagation of callbacks (e.g. on_post_connection) in retries of failed requests.

Version 2.10.903

2.10.903 (2024-10-13)

• Fixed exception leaks in ExtensionFromHTTP plugins. Now every extension behave and raise urllib3 own exceptions.
• Added automatic connection downgrade HTTP/2 -> HTTP/1.1 or HTTP/3 -> (HTTP/2 or HTTP/1.1) in case of known recoverable issues.
• Fixed a rare issue where the write semaphore (async context) for a datagram socket would be locked forever in case of an error.

Version 2.10.902

2.10.902 (2024-10-09)

• Fixed call to stream(..) on (early) informational responses. The inner fp was set to None and the function
  is_fp_closed is not meant to handle this case. Through you should never expect a body in those responses.
• Fixed read(), and data returns None for (early) informational responses.

Version 2.10.901

2.10.901 (2024-10-08)

• Fixed closed state on a WebSocketExtensionFromHTTP when the remote send a CloseConnection event.
• Fixed an edge case where a DNS-over-HTTPS would start of a non-multiplexed connection but immediately upgrade to a
  multiplexed capable connection would induce an error.
• Allow to disable HTTP/1.1 in a DNS-over-HTTPS resolver.
• Extra "qh3" lower bound aligned with the main constraint >=1.2,<2.

Version 2.10.900

2.10.900 (2024-10-07)

• Added complete support for Informational Response whether it's an early response or not. We introduced a callback named
  on_early_response that takes exactly one parameter, namely a HTTPResponse. You may start leveraging Early Hints!
  This works regardless of the negotiated protocol: HTTP/1.1, HTTP/2 or HTTP/3! As always, you may use that feature
  in a synchronous or asynchronous context.
• Changed qh3 lower bound version to v1.2 in order to support Informational Response in HTTP/3 also.
• Added full automated support for WebSocket through HTTP/1.1, HTTP/2 or HTTP/3.
  In order to leverage this feature, urllib3-future now recognize url scheme ws:// (insecure) and wss:// (secure).
  The response will be of status 101 (Switching Protocol) and the body will be None.
  Most servers out there only support WebSocket through HTTP/1.1, and using HTTP/2 or HTTP/3 usually ends up in stream (reset) error.
  By default, connecting to wss:// or ws:// use HTTP/1.1, but if you desire to leverage the WebSocket through a multiplexed connection,
  use wss+rfc8441:// or ws+rfc8441://.
  A new property has been introduced in HTTPResponse, namely extension to be able to interact with the websocket
  server. Everything is handled automatically, from thread safety to all the protocol logic. See the documentation for more.
  This will require the installation of an optional dependency wsproto, to do so, please install urllib3-future with
  pip install urllib3-future[ws].
• Fixed a rare issue where the :authority (special header) value might be malformed.