Update anyio to 4.12.0

[pyup-bot]

This PR updates anyio from 1.2.1 to 4.12.0.

Changelog

4.12.0

- Added support for asyncio's [task call graphs](https://docs.python.org/3/library/asyncio-graph.html) on Python 3.14 and later when using AnyIO's task groups ([\#1025](https://github.com/agronholm/anyio/pull/1025))
- Added an asynchronous implementation of the `functools` module ([\1001](https://github.com/agronholm/anyio/pull/1001))
- Added support for `uvloop=True` on Windows via the [winloop](https://github.com/Vizonex/Winloop) implementation ([\#960](https://github.com/agronholm/anyio/pull/960); PR by Vizonex)
- Added support for use as a context manager to `anyio.lowlevel.RunVar` ([\1003](https://github.com/agronholm/anyio/pull/1003))
- Added `__all__` declarations to public submodules (`anyio.lowlevel` etc.) ([\1009](https://github.com/agronholm/anyio/pull/1009))
- Added the ability to set the token count of a `CapacityLimiter` to zero ([\1019](https://github.com/agronholm/anyio/pull/1019); requires Python 3.10 or later when using Trio)
- Added parameters `case_sensitive` and `recurse_symlinks` along with support for path-like objects to `anyio.Path.glob()` and `anyio.Path.rglob()` ([\1033](https://github.com/agronholm/anyio/pull/1033); PR by northisup)
- Dropped `sniffio` as a direct dependency and added the `get_available_backends()` function ([\1021](https://github.com/agronholm/anyio/pull/1021))
- Fixed `Process.stdin.send()` not raising `ClosedResourceError` and `BrokenResourceError` on asyncio. Previously, a non-AnyIO exception was raised in such cases ([\671](https://github.com/agronholm/anyio/issues/671); PR by gschaffner)
- Fixed `Process.stdin.send()` not checkpointing before writing data on asyncio ([\1002](https://github.com/agronholm/anyio/issues/1002); PR by gschaffner)
- Fixed a race condition where cancelling a `Future` from `BlockingPortal.start_task_soon()` would sometimes not cancel the async function ([\1011](https://github.com/agronholm/anyio/issues/1011); PR by gschaffner)
- Fixed the presence of the pytest plugin causing breakage with older versions of pytest (\<= 6.1.2) ([\1028](https://github.com/agronholm/anyio/issues/1028); PR by saper)
- Fixed a rarely occurring `RuntimeError: Set changed size during iteration` while shutting down the process pool when using the asyncio backend ([\985](https://github.com/agronholm/anyio/issues/985))

4.11.0

- Added support for cancellation reasons (the `reason` parameter to `CancelScope.cancel()`) ([\975](https://github.com/agronholm/anyio/pull/975))
- Bumped the minimum version of Trio to v0.31.0
- Added the ability to enter the event loop from foreign (non-worker) threads by passing the return value of `anyio.lowlevel.current_token()` to `anyio.from_thread.run()` and `anyio.from_thread.run_sync()` as the `token` keyword argument ([\256](https://github.com/agronholm/anyio/issues/256))
- Added pytest option (`anyio_mode = "auto"`) to make the pytest plugin automatically handle all async tests ([\971](https://github.com/agronholm/anyio/pull/971))
- Added the `anyio.Condition.wait_for()` method for feature parity with asyncio ([\974](https://github.com/agronholm/anyio/pull/974))
- Changed the default type argument of `anyio.abc.TaskStatus` from `Any` to `None` ([\964](https://github.com/agronholm/anyio/pull/964))
- Fixed TCP listener behavior to guarantee the same ephemeral port is used for all socket listeners when `local_port=0` ([\857](https://github.com/agronholm/anyio/issues/857); PR by 11kkw and agronholm)
- Fixed inconsistency between Trio and asyncio where a TCP stream that previously raised a `BrokenResourceError` on `send()` would still raise `BrokenResourceError` after the stream was closed on asyncio, but `ClosedResourceError` on Trio. They now both raise a `ClosedResourceError` in this scenario. ([\671](https://github.com/agronholm/anyio/issues/671))

4.10.0

-   Added the `feed_data()` method to the `BufferedByteReceiveStream` class, allowing users to inject data directly into the buffer
-   Added various class methods to wrap existing sockets as listeners or socket streams:
 -   `SocketListener.from_socket()`
 -   `SocketStream.from_socket()`
 -   `UNIXSocketStream.from_socket()`
 -   `UDPSocket.from_socket()`
 -   `ConnectedUDPSocket.from_socket()`
 -   `UNIXDatagramSocket.from_socket()`
 -   `ConnectedUNIXDatagramSocket.from_socket()`
-   Added a hierarchy of connectable stream classes for transparently connecting to various remote or local endpoints for exchanging bytes or objects
-   Added context manager mix-in classes (`anyio.ContextManagerMixin` and `anyio.AsyncContextManagerMixin`) to help write classes that embed other context managers, particularly cancel scopes or task groups ([\905](https://github.com/agronholm/anyio/pull/905); PR by agronholm and tapetersen)
-   Added the ability to specify the thread name in `start_blocking_portal()` ([\818](https://github.com/agronholm/anyio/issues/818); PR by davidbrochart)
-   Added `anyio.notify_closing` to allow waking `anyio.wait_readable` and `anyio.wait_writable` before closing a socket. Among other things, this prevents an OSError on the `ProactorEventLoop`. ([\896](https://github.com/agronholm/anyio/pull/896); PR by graingert)
-   Incorporated several documentation improvements from the EuroPython 2025 sprint (special thanks to the sprinters: Emmanuel Okedele, Jan Murre, Euxenia Miruna Goia and Christoffer Fjord)
-   Added a documentation page explaining why one might want to use AnyIO's APIs instead of asyncio's
-   Updated the `to_interpreters` module to use the public `concurrent.interpreters` API on Python 3.14 or later
-   Fixed `anyio.Path.copy()` and `anyio.Path.copy_into()` failing on Python 3.14.0a7
-   Fixed return annotation of `__aexit__` on async context managers. CMs which can suppress exceptions should return `bool`, or `None` otherwise. ([\913](https://github.com/agronholm/anyio/pull/913); PR by Enegg)
-   Fixed rollover boundary check in `SpooledTemporaryFile` so that rollover only occurs when the buffer size exceeds `max_size` ([\915](https://github.com/agronholm/anyio/pull/915); PR by 11kkw)
-   Migrated testing and documentation dependencies from extras to dependency groups
-   Fixed compatibility of `anyio.to_interpreter` with Python 3.14.0b2 ([\926](https://github.com/agronholm/anyio/issues/926); PR by hroncok)
-   Fixed `SyntaxWarning` on Python 3.14 about `return` in `finally` ([\816](https://github.com/agronholm/anyio/issues/816))
-   Fixed RunVar name conflicts. RunVar instances with the same name should not share storage ([\880](https://github.com/agronholm/anyio/issues/880); PR by vimfu)
-   Renamed the `BrokenWorkerIntepreter` exception to `BrokenWorkerInterpreter`. The old name is available as a deprecated alias. ([\938](https://github.com/agronholm/anyio/pull/938); PR by ayussh-verma)
-   Fixed an edge case in `CapacityLimiter` on asyncio where a task, waiting to acquire a limiter gets cancelled and is subsequently granted a token from the limiter, but before the cancellation is delivered, and then fails to notify the next waiting task ([\947](https://github.com/agronholm/anyio/issues/947))

4.9.0

- Added async support for temporary file handling ([\344](https://github.com/agronholm/anyio/issues/344); PR by 11kkw)
-   Added 4 new fixtures for the AnyIO `pytest` plugin:
 -   `free_tcp_port_factory`: session scoped fixture returning a callable that generates unused TCP port numbers
 -   `free_udp_port_factory`: session scoped fixture returning a callable that generates unused UDP port numbers
 -   `free_tcp_port`: function scoped fixture that invokes the `free_tcp_port_factory` fixture to generate a free TCP port number
 -   `free_udp_port`: function scoped fixture that invokes the `free_udp_port_factory` fixture to generate a free UDP port number
-   Added `stdin` argument to `anyio.run_process()` akin to what `anyio.open_process()`, `asyncio.create_subprocess()`, `trio.run_process()`, and `subprocess.run()` already accept (PR by jmehnle)
-   Added the `info` property to `anyio.Path` on Python 3.14
-   Changed `anyio.getaddrinfo()` to ignore (invalid) IPv6 name resolution results when IPv6 support is disabled in Python
-   Changed `EndOfStream` raised from `MemoryObjectReceiveStream.receive()` to leave out the `AttributeError` from the exception chain which was merely an implementation detail and caused some confusion
-   Fixed traceback formatting growing quadratically with level of `TaskGroup` nesting on asyncio due to exception chaining when raising `ExceptionGroups` in `TaskGroup.__aexit__` ([\863](https://github.com/agronholm/anyio/issues/863); PR by tapetersen)
-   Fixed `anyio.Path.iterdir()` making a blocking call in Python 3.13 ([\873](https://github.com/agronholm/anyio/issues/873); PR by cbornet and agronholm)
-   Fixed `connect_tcp()` producing cyclic references in tracebacks when raising exceptions ([\809](https://github.com/agronholm/anyio/pull/809); PR by graingert)
-   Fixed `anyio.to_thread.run_sync()` needlessly holding on to references of the context, function, arguments and others until the next work item on asyncio (PR by Wankupi)

4.8.0

-   Added **experimental** support for running functions in subinterpreters on Python 3.13 and later
-   Added support for the `copy()`, `copy_into()`, `move()` and `move_into()` methods in `anyio.Path`, available in Python 3.14
-   Changed `TaskGroup` on asyncio to always spawn tasks non-eagerly, even if using a task factory created via `asyncio.create_eager_task_factory()`, to preserve expected Trio-like task scheduling semantics (PR by agronholm and graingert)
-   Configure `SO_RCVBUF`, `SO_SNDBUF` and `TCP_NODELAY` on the selector thread waker socket pair (this should improve the performance of `wait_readable()` and `wait_writable()` when using the `ProactorEventLoop`) ([\836](https://github.com/agronholm/anyio/pull/836); PR by graingert)
-   Fixed `AssertionError` when using `nest-asyncio` ([\840](https://github.com/agronholm/anyio/issues/840))
-   Fixed return type annotation of various context managers' `__exit__` method ([\847](https://github.com/agronholm/anyio/issues/847); PR by Enegg)

4.7.0

-   Updated `TaskGroup` to work with asyncio's eager task factories ([\764](https://github.com/agronholm/anyio/issues/764))
-   Added the `wait_readable()` and `wait_writable()` functions which will accept an object with a `.fileno()` method or an integer handle, and deprecated their now obsolete versions (`wait_socket_readable()` and `wait_socket_writable()`) (PR by davidbrochart)
-   Changed `EventAdapter` (an `Event` with no bound async backend) to allow `set()` to work even before an async backend is bound to it ([\819](https://github.com/agronholm/anyio/issues/819))
-   Added support for `wait_readable()` and `wait_writable()` on `ProactorEventLoop` (used on asyncio + Windows by default)
-   Fixed a misleading `ValueError` in the context of DNS failures ([\815](https://github.com/agronholm/anyio/issues/815); PR by graingert)
-   Fixed the return type annotations of `readinto()` and `readinto1()` methods in the `anyio.AsyncFile` class ([\825](https://github.com/agronholm/anyio/issues/825))
-   Fixed `TaskInfo.has_pending_cancellation()` on asyncio returning false positives in cleanup code on Python \>= 3.11 ([\832](https://github.com/agronholm/anyio/issues/832); PR by gschaffner)
-   Fixed cancelled cancel scopes on asyncio calling `asyncio.Task.uncancel` when propagating a `CancelledError` on exit to a cancelled parent scope ([\790](https://github.com/agronholm/anyio/pull/790); PR by gschaffner)

4.6.2

-   Fixed regression caused by ([\807](https://github.com/agronholm/anyio/pull/807)) that prevented the use of parametrized async fixtures

4.6.1

This release contains all the changes from both v4.5.1 and v4.6.0, plus:

-   Fixed TaskGroup and CancelScope producing cyclic references in tracebacks when raising exceptions ([\806](https://github.com/agronholm/anyio/pull/806)) (PR by graingert)

4.6.0

-   Dropped support for Python 3.8 (as [\698](https://github.com/agronholm/anyio/issues/698) cannot be resolved without cancel message support)
-   Fixed 100% CPU use on asyncio while waiting for an exiting task group to finish while said task group is within a cancelled cancel scope ([\695](https://github.com/agronholm/anyio/issues/695))
-   Fixed cancel scopes on asyncio not propagating `CancelledError` on exit when the enclosing cancel scope has been effectively cancelled ([\698](https://github.com/agronholm/anyio/issues/698))
-   Fixed asyncio task groups not yielding control to the event loop at exit if there were no child tasks to wait on
-   Fixed inconsistent task uncancellation with asyncio cancel scopes belonging to a task group when said task group has child tasks running

4.5.2

-   Fixed regression caused by ([\807](https://github.com/agronholm/anyio/pull/807)) that prevented the use of parametrized async fixtures.

4.5.1

As Python 3.8 support was dropped in v4.6.0, this interim release was created to bring a regression fix to Python 3.8, and adds a few other fixes also present in v4.6.1.

-   Fixed acquring a lock twice in the same task on asyncio hanging instead of raising a `RuntimeError` ([\798](https://github.com/agronholm/anyio/issues/798))
-   Fixed an async fixture's `self` being different than the test's `self` in class-based tests ([\633](https://github.com/agronholm/anyio/issues/633)) (PR by agronholm and graingert)
-   Fixed `TypeError` with `TLSStream` on Windows when a certificate verification error occurs when using a [truststore](https://github.com/sethmlarson/truststore) SSL certificate ([\#795](https://github.com/agronholm/anyio/issues/795))
-   Corrected documentation on `anyio.Path` regarding the limitations imposed by the current Python version on several of its methods, and made the `is_junction` method unavailable on Python versions earlier than 3.12 ([\794](https://github.com/agronholm/anyio/issues/794))

4.5.0

-   Improved the performance of `anyio.Lock` and `anyio.Semaphore` on asyncio (even up to 50 %)
-   Added the `fast_acquire` parameter to `anyio.Lock` and `anyio.Semaphore` to further boost performance at the expense of safety (`acquire()` will not yield control back if there is no contention)
-   Added support for the `from_uri()`, `full_match()`, `parser` methods/properties in `anyio.Path`, newly added in Python 3.13 ([\737](https://github.com/agronholm/anyio/issues/737))
-   Added support for more keyword arguments for `run_process()` and `open_process()`: `startupinfo`, `creationflags`, `pass_fds`, `user`, `group`, `extra_groups` and `umask` ([\742](https://github.com/agronholm/anyio/issues/742))
-   Improved the type annotations and support for `PathLike` in `run_process()` and `open_process()` to allow for path-like arguments, just like `subprocess.Popen`
-   Changed the `ResourceWarning` from an unclosed memory object stream to include its address for easier identification
-   Changed `start_blocking_portal()` to always use daemonic threads, to accommodate the "loitering event loop" use case
-   Bumped the minimum version of Trio to v0.26.1
-   Fixed `__repr__()` of `MemoryObjectItemReceiver`, when `item` is not defined ([\767](https://github.com/agronholm/anyio/pull/767); PR by Danipulok)
-   Fixed `to_process.run_sync()` failing to initialize if `__main__.__file__` pointed to a file in a nonexistent directory ([\696](https://github.com/agronholm/anyio/issues/696))
-   Fixed `AssertionError: feed_data after feed_eof` on asyncio when a subprocess is closed early, before its output has been read ([\490](https://github.com/agronholm/anyio/issues/490))
-   Fixed `TaskInfo.has_pending_cancellation()` on asyncio not respecting shielded scopes ([\771](https://github.com/agronholm/anyio/issues/771); PR by gschaffner)
-   Fixed `SocketStream.receive()` returning `bytearray` instead of `bytes` when using asyncio with `ProactorEventLoop` (Windows) ([\776](https://github.com/agronholm/anyio/issues/776))
-   Fixed quitting the debugger in a pytest test session while in an active task group failing the test instead of exiting the test session (because the exit exception arrives in an exception group)
-   Fixed support for Linux abstract namespaces in UNIX sockets that was broken in v4.2 ([\781](https://github.com/agronholm/anyio/issues/781); PR by tapetersen)
-   Fixed `KeyboardInterrupt` (ctrl+c) hanging the asyncio pytest runner

4.4.0

-   Added the `BlockingPortalProvider` class to aid with constructing synchronous counterparts to asynchronous interfaces that would otherwise require multiple blocking portals
-   Added `__slots__` to `AsyncResource` so that child classes can use `__slots__` ([\733](https://github.com/agronholm/anyio/pull/733); PR by Justin Su)
-   Added the `TaskInfo.has_pending_cancellation()` method
-   Fixed erroneous `RuntimeError: called 'started' twice on the same task status` when cancelling a task in a TaskGroup created with the `start()` method before the first checkpoint is reached after calling `task_status.started()` ([\706](https://github.com/agronholm/anyio/issues/706); PR by Dominik Schwabe)
-   Fixed two bugs with `TaskGroup.start()` on asyncio:
 -   Fixed erroneous `RuntimeError: called 'started' twice on the same task status` when cancelling a task in a TaskGroup created with the `start()` method before the first checkpoint is reached after calling `task_status.started()` ([\706](https://github.com/agronholm/anyio/issues/706); PR by Dominik Schwabe)
 -   Fixed the entire task group being cancelled if a `TaskGroup.start()` call gets cancelled ([\685](https://github.com/agronholm/anyio/issues/685), [\#710](https://github.com/agronholm/anyio/issues/710))
-   Fixed a race condition that caused crashes when multiple event loops of the same backend were running in separate threads and simultaneously attempted to use AnyIO for their first time ([\425](https://github.com/agronholm/anyio/issues/425); PR by David Jiricek and Ganden Schaffner)
-   Fixed cancellation delivery on asyncio incrementing the wrong cancel scope's cancellation counter when cascading a cancel operation to a child scope, thus failing to uncancel the host task ([\716](https://github.com/agronholm/anyio/issues/716))
-   Fixed erroneous `TypedAttributeLookupError` if a typed attribute getter raises `KeyError`
-   Fixed the asyncio backend not respecting the `PYTHONASYNCIODEBUG` environment variable when setting the `debug` flag in `anyio.run()`
-   Fixed `SocketStream.receive()` not detecting EOF on asyncio if there is also data in the read buffer ([\701](https://github.com/agronholm/anyio/issues/701))
-   Fixed `MemoryObjectStream` dropping an item if the item is delivered to a recipient that is waiting to receive an item but has a cancellation pending ([\728](https://github.com/agronholm/anyio/issues/728))
-   Emit a `ResourceWarning` for `MemoryObjectReceiveStream` and `MemoryObjectSendStream` that were garbage collected without being closed (PR by Andrey Kazantcev)
-   Fixed `MemoryObjectSendStream.send()` not raising `BrokenResourceError` when the last corresponding `MemoryObjectReceiveStream` is closed while waiting to send a falsey item ([\731](https://github.com/agronholm/anyio/issues/731); PR by Ganden Schaffner)

4.3.0

-   Added support for the Python 3.12 `walk_up` keyword argument in `anyio.Path.relative_to()` (PR by Colin Taylor)

-   Fixed passing `total_tokens` to `anyio.CapacityLimiter()` as a keyword argument not working on the `trio` backend ([\515](https://github.com/agronholm/anyio/issues/515))

-   Fixed `Process.aclose()` not performing the minimum level of necessary cleanup when cancelled. Previously:

 -   Cancellation of `Process.aclose()` could leak an orphan process
 -   Cancellation of `run_process()` could very briefly leak an orphan process.
 -   Cancellation of `Process.aclose()` or `run_process()` on Trio could leave standard streams unclosed

 (PR by Ganden Schaffner)

-   Fixed `Process.stdin.aclose()`, `Process.stdout.aclose()`, and `Process.stderr.aclose()` not including a checkpoint on asyncio (PR by Ganden Schaffner)

-   Fixed documentation on how to provide your own typed attributes

4.2.0

-   Add support for `byte`-based paths in `connect_unix`, `create_unix_listeners`, `create_unix_datagram_socket`, and `create_connected_unix_datagram_socket`. (PR by Lura Skye)

-   Enabled the `Event` and `CapacityLimiter` classes to be instantiated outside an event loop thread

-   Broadly improved/fixed the type annotations. Among other things, many functions and methods that take variadic positional arguments now make use of PEP 646 `TypeVarTuple` to allow the positional arguments to be validated by static type checkers. These changes affected numerous methods and functions, including:

 -   `anyio.run()`
 -   `TaskGroup.start_soon()`
 -   `anyio.from_thread.run()`
 -   `anyio.from_thread.run_sync()`
 -   `anyio.to_thread.run_sync()`
 -   `anyio.to_process.run_sync()`
 -   `BlockingPortal.call()`
 -   `BlockingPortal.start_task_soon()`
 -   `BlockingPortal.start_task()`

 (also resolves [\560](https://github.com/agronholm/anyio/issues/560))

-   Fixed various type annotations of `anyio.Path` to match Typeshed:

 -   `anyio.Path.__lt__()`
 -   `anyio.Path.__le__()`
 -   `anyio.Path.__gt__()`
 -   `anyio.Path.__ge__()`
 -   `anyio.Path.__truediv__()`
 -   `anyio.Path.__rtruediv__()`
 -   `anyio.Path.hardlink_to()`
 -   `anyio.Path.samefile()`
 -   `anyio.Path.symlink_to()`
 -   `anyio.Path.with_segments()`

 (PR by Ganden Schaffner)

-   Fixed adjusting the total number of tokens in a `CapacityLimiter` on asyncio failing to wake up tasks waiting to acquire the limiter in certain edge cases (fixed with help from Egor Blagov)

-   Fixed `loop_factory` and `use_uvloop` options not being used on the asyncio backend ([\643](https://github.com/agronholm/anyio/issues/643))

-   Fixed cancellation propagating on asyncio from a task group to child tasks if the task hosting the task group is in a shielded cancel scope ([\642](https://github.com/agronholm/anyio/issues/642))

4.1.0

-   Adapted to API changes made in Trio v0.23:
 -   Call `trio.to_thread.run_sync()` using the `abandon_on_cancel` keyword argument instead of `cancellable`
 -   Removed a checkpoint when exiting a task group
 -   Renamed the `cancellable` argument in `anyio.to_thread.run_sync()` to `abandon_on_cancel` (and deprecated the old parameter name)
 -   Bumped minimum version of Trio to v0.23
-   Added support for voluntary thread cancellation via `anyio.from_thread.check_cancelled()`
-   Bumped minimum version of trio to v0.23
-   Exposed the `ResourceGuard` class in the public API ([\627](https://github.com/agronholm/anyio/issues/627))
-   Fixed `RuntimeError: Runner is closed` when running higher-scoped async generator fixtures in some cases ([\619](https://github.com/agronholm/anyio/issues/619))
-   Fixed discrepancy between `asyncio` and `trio` where reraising a cancellation exception in an `except*` block would incorrectly bubble out of its cancel scope ([\634](https://github.com/agronholm/anyio/issues/634))

4.0.0

-   **BACKWARDS INCOMPATIBLE** Replaced AnyIO\'s own `ExceptionGroup`  class with the PEP 654 `BaseExceptionGroup` and `ExceptionGroup`
-   **BACKWARDS INCOMPATIBLE** Changes to cancellation semantics:
 -   Any exceptions raising out of a task groups are now nested inside an `ExceptionGroup` (or `BaseExceptionGroup` if one or more `BaseException` were included)
 -   Fixed task group not raising a cancellation exception on asyncio at exit if no child tasks were spawned and an outer cancellation scope had been cancelled before
 -   Ensured that exiting a `TaskGroup` always hits a yield point, regardless of whether there are running child tasks to be waited on
 -   On asyncio, cancel scopes will defer cancelling tasks that are scheduled to resume with a finished future
 -   On asyncio and Python 3.9/3.10, cancel scopes now only suppress cancellation exceptions if the cancel message matches the scope
 -   Task groups on all backends now raise a single cancellation exception when an outer cancel scope is cancelled, and no exceptions other than cancellation exceptions are raised in the group
-   **BACKWARDS INCOMPATIBLE** Changes the pytest plugin to run all tests and fixtures in the same task, allowing fixtures to set context variables for tests and other fixtures
-   **BACKWARDS INCOMPATIBLE** Changed `anyio.Path.relative_to()` and `anyio.Path.is_relative_to()` to only accept one argument, as passing multiple arguments is deprecated as of Python 3.12
-   **BACKWARDS INCOMPATIBLE** Dropped support for spawning tasks from old-style coroutine functions (`asyncio.coroutine`)
-   **BACKWARDS INCOMPATIBLE** The `policy` option on the `asyncio` backend was changed to `loop_factory` to accommodate `asyncio.Runner`
-   Changed `anyio.run()` to use `asyncio.Runner` (or a back-ported version of it on Pythons older than 3.11) on the `asyncio` backend
-   Dropped support for Python 3.7
-   Added support for Python 3.12
-   Bumped minimum version of trio to v0.22
-   Added the `anyio.Path.is_junction()` and `anyio.Path.walk()` methods
-   Added `create_unix_datagram_socket` and `create_connected_unix_datagram_socket` to create UNIX datagram sockets (PR by Jean Hominal)
-   Fixed `from_thread.run` and `from_thread.run_sync` not setting sniffio on asyncio. As a result:
 -   Fixed `from_thread.run_sync` failing when used to call sniffio-dependent functions on asyncio
 -   Fixed `from_thread.run` failing when used to call sniffio-dependent functions on asyncio from a thread running trio or curio
 -   Fixed deadlock when using `from_thread.start_blocking_portal(backend="asyncio")` in a thread running trio or curio (PR by Ganden Schaffner)
-   Improved type annotations:
 -   The `item_type` argument of `create_memory_object_stream` was deprecated. To indicate the item type handled by the stream, use `create_memory_object_stream[T_Item]()` instead. Type checking should no longer fail when annotating memory object streams with uninstantiable item types (PR by Ganden Schaffner)
-   Added the `CancelScope.cancelled_caught` property which tells users if the cancel scope suppressed a cancellation exception
-   Fixed `fail_after()` raising an unwarranted `TimeoutError` when the cancel scope was cancelled before reaching its deadline
-   Fixed `MemoryObjectReceiveStream.receive()` causing the receiving task on asyncio to remain in a cancelled state if the operation was cancelled after an item was queued to be received by the task (but before the task could actually receive the item)
-   Fixed `TaskGroup.start()` on asyncio not responding to cancellation from the outside
-   Fixed tasks started from `BlockingPortal` not notifying synchronous listeners (`concurrent.futures.wait()`) when they\'re cancelled
-   Removed unnecessary extra waiting cycle in `Event.wait()` on asyncio in the case where the event was not yet set
-   Fixed processes spawned by `anyio.to_process()` being "lost" as unusable to the process pool when processes that have idled over 5 minutes are pruned at part of the `to_process.run_sync()` call, leading to increased memory consumption (PR by Anael Gorfinkel)

4.0.0rc1

-   Fixed the type annotation of `TaskGroup.start_soon()` to accept any awaitables (already in v3.7.0 but was missing from 4.0.0rc1)
-   Changed `CancelScope` to also consider the cancellation count (in addition to the cancel message) on asyncio to determine if a cancellation exception should be swallowed on scope exit, to combat issues where third party libraries catch the `CancelledError` and raise another, thus erasing the original cancel message
-   Worked around a [CPython bug](https://github.com/python/cpython/issues/108668) that caused `TLSListener.handle_handshake_error()` on asyncio to log `"NoneType: None"` instead of the error (PR by Ganden Schaffner)
-   Re-added the `item_type` argument to `create_memory_object_stream()` (but using it raises a deprecation warning and does nothing with regards to the static types of the returned streams)
-   Fixed processes spawned by `anyio.to_process()` being "lost" as unusable to the process pool when processes that have idled over 5 minutes are pruned at part of the `to_process.run_sync()` call, leading to increased memory consumption (PR by Anael Gorfinkel)

Links

• PyPI: https://pypi.org/project/anyio
• Changelog: https://data.safetycli.com/changelogs/anyio/