Path to this page:
./
devel/py-anyio,
High level compatibility layer for multiple asynchronous event loops
Branch: CURRENT,
Version: 4.6.2.post1,
Package name: py312-anyio-4.6.2.post1,
Maintainer: pkgsrc-usersAnyIO is a asynchronous compatibility API that allows applications and
libraries written against it to run unmodified on asyncio, curio and trio.
It bridges the following functionality:
* Task groups
* Cancellation
* Threads
* Signal handling
* Asynchronous file I/O
* Synchronization primitives (locks, conditions, events, semaphores, queues)
* High level networking (TCP, UDP and UNIX sockets)
Master sites:
Filesize: 169.357 KB
Version history: (Expand)
- (2024-10-22) Updated to version: py312-anyio-4.6.2.post1
- (2024-10-14) Updated to version: py312-anyio-4.6.2
- (2024-09-22) Updated to version: py312-anyio-4.6.0
- (2024-05-27) Updated to version: py311-anyio-4.4.0
- (2024-02-19) Updated to version: py311-anyio-4.3.0
- (2024-01-01) Updated to version: py311-anyio-4.2.0
CVS history: (Expand)
2024-02-19 12:25:24 by Adam Ciarcinski | Files touched by this commit (2) | |
Log message:
py-anyio: updated to 4.3.0
4.3.0
Added support for the Python 3.12 walk_up keyword argument in \
anyio.Path.relative_to()
Fixed passing total_tokens to anyio.CapacityLimiter() as a keyword argument not \
working on the trio backend
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
Fixed Process.stdin.aclose(), Process.stdout.aclose(), and \
Process.stderr.aclose() not including a checkpoint on asyncio
Fixed documentation on how to provide your own typed attributes
|
2024-01-01 18:01:58 by Adam Ciarcinski | Files touched by this commit (2) | |
Log message:
py-anyio: updated to 4.2.0
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()``
- 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()``
- 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
- 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
|
2023-11-26 11:25:50 by Adam Ciarcinski | Files touched by this commit (2) | |
Log message:
py-anyio: updated to 4.1.0
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
- Fixed ``RuntimeError: Runner is closed`` when running higher-scoped async generator
fixtures in some cases
- Fixed discrepancy between ``asyncio`` and ``trio`` where reraising a cancellation
exception in an ``except*`` block would incorrectly bubble out of its cancel scope
|
2023-10-28 21:57:26 by Thomas Klausner | Files touched by this commit (516) | |
Log message:
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.
|
2023-10-18 10:58:38 by Adam Ciarcinski | Files touched by this commit (3) | |
Log message:
py-anyio: updated to 4.0.0
**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
|
2023-07-08 07:33:19 by Adam Ciarcinski | Files touched by this commit (2) | |
Log message:
py-anyio: updated to 3.7.1
3.7.1
- Fixed sending large buffers via UNIX stream sockets on asyncio
- Fixed several minor documentation issues (broken links to classes, missing \
classes or
attributes)
|
2023-05-29 19:58:23 by Adam Ciarcinski | Files touched by this commit (3) | |
Log message:
py-anyio: updated to 3.7.0
**3.7.0**
- Dropped support for Python 3.6
- Improved type annotations:
- Several functions and methods that were previously annotated as accepting
``Coroutine[Any, Any, Any]`` as the return type of the callable have been \
amended to
accept ``Awaitable[Any]`` instead, to allow a slightly broader set of \
coroutine-like
inputs, like ``async_generator_asend`` objects returned from the ``asend()`` \
method
of async generators, and to match the ``trio`` annotations:
- ``anyio.run()``
- ``anyio.from_thread.run()``
- ``TaskGroup.start_soon()``
- ``TaskGroup.start()``
- ``BlockingPortal.call()``
- ``BlockingPortal.start_task_soon()``
- ``BlockingPortal.start_task()``
Note that this change involved only changing the type annotations; run-time
functionality was not altered.
- The ``TaskStatus`` class is now a generic protocol, and should be parametrized to
indicate the type of the value passed to ``task_status.started()``
- The ``Listener`` class is now covariant in its stream type
- ``create_memory_object_stream()`` now allows passing only ``item_type``
- Object receive streams are now covariant and object send streams are \
correspondingly
contravariant
- Changed ``TLSAttribute.shared_ciphers`` to match the documented semantics of
``SSLSocket.shared_ciphers`` of always returning ``None`` for client-side streams
- Fixed ``CapacityLimiter`` on the asyncio backend to order waiting tasks in the FIFO
order (instead of LIFO) (PR by Conor Stevenson)
- Fixed ``CancelScope.cancel()`` not working on asyncio if called before entering the
scope
- Fixed ``open_signal_receiver()`` inconsistently yielding integers instead of
``signal.Signals`` instances on the ``trio`` backend
- Fixed ``to_thread.run_sync()`` hanging on asyncio if the target callable raises
``StopIteration``
- Fixed ``start_blocking_portal()`` raising an unwarranted
``RuntimeError: This portal is not running`` if a task raises an exception \
that causes
the event loop to be closed
- Fixed ``current_effective_deadline()`` not returning ``-inf`` on asyncio when the
currently active cancel scope has been cancelled (PR by Ganden Schaffner)
- Fixed the ``OP_IGNORE_UNEXPECTED_EOF`` flag in an SSL context created by default in
``TLSStream.wrap()`` being inadvertently set on Python 3.11.3 and 3.10.11
- Fixed ``CancelScope`` to properly handle asyncio task uncancellation on Python 3.11
(PR by Nikolay Bryskin)
- Fixed ``OSError`` when trying to use ``create_tcp_listener()`` to bind to a \
link-local
IPv6 address (and worked around related bugs in ``uvloop``)
- Worked around a `PyPy bug \
<https://foss.heptapod.net/pypy/pypy/-/issues/3938>`_
when using ``anyio.getaddrinfo()`` with for IPv6 link-local addresses containing
interface names
|
2023-03-29 11:34:15 by Thomas Klausner | Files touched by this commit (96) |
Log message:
*: use PYTHON_VERSION instead of _PYTHON_VERSION
|