./devel/py-anyio, High level compatibility layer for multiple asynchronous event loops

[ CVSweb ] [ Homepage ] [ RSS ] [ Required by ] [ Add to tracker ]


Branch: CURRENT, Version: 4.6.2.post1, Package name: py312-anyio-4.6.2.post1, Maintainer: pkgsrc-users

AnyIO 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)


CVS history: (Expand)


   2024-02-19 12:25:24 by Adam Ciarcinski | Files touched by this commit (2) | Package updated
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) | Package updated
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) | Package updated
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) | Package updated
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) | Package updated
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) | Package updated
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) | Package updated
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