-------------------------------------------------------------------
Tue Oct 13 11:45:10 UTC 2026 - Markéta Machová <mmachova@suse.com>

- Add patch tls.patch to fix test failure with recent pythons

-------------------------------------------------------------------
Fri Oct  9 01:56:13 UTC 2026 - Steve Kowalik <steven.kowalik@suse.com>

- Update to 4.15.1:
  * Implemented a compatibility fix for supporting direct access of anyio.*
    submodules from the main package even when those submodules were not
    directly imported first
  * Added support for the newer keyword-only arguments on anyio.Path methods
    to match the standard library pathlib.Path
  * Added amap, gather, and as_completed utility functions to simplify common
    patterns
  * Added --anyio-mode command-line option as an alternative to the
    anyio_mode ini setting, and fix the pytest plugin's auto mode detection
    to recognize the mode when set via either mechanism(e.g: pytest_asyncio).
  * Added the anyio.Future synchronization primitive which behaves similar to
    asyncio.Future, allowing tasks to wait for a value (or exception) from
    another task
  * Added guidance for managing multiple memory object stream producers and
    consumers with cloned streams
  * Added StapledObjectStream.send_nowait() that delegates to the underlying
    ObjectSendStream, if it implements it
  * Changed the default name for a task spawned with
    TaskGroup.create_task(func()) to match the default task name for the
    analogous task spawned with TaskGroup.start_soon(func) or
    TaskGroup.start(func) in more situations.
  * Changed the anyio and anyio.abc modules to lazily import the necessary
    submodules.
  * Fixed SpooledTemporaryFile.readinto() and readinto1() reading twice
    before rollover, so the destination buffer was overwritten by the second
    read and the file position advanced twice, silently losing data
  * Fixed anyio.run leaking, or at least, delaying collection of loop and
    root_task due to the root task being cached in a RunVar.
  * Fixed UNIXSocketStream.aclose() raising asyncio.InvalidStateError when a
    concurrent receive or send operation had just been cancelled on the
    asyncio backend
  * Fixed the pytest plugin importing the deprecated _pytest.python.CallSpec2
    alias
  * Fixed an asyncio worker thread race that could raise RuntimeError when
    the event loop closed between checking its state and scheduling the
    worker result
  * Fixed inconsistencies between Trio and asyncio when target TaskGroup is
    cancelled before a task created with .start() calls TaskStatus.started()
  * Fixed TemporaryDirectory not cleaning up when the host task was cancelled
    while exiting the context manager, as the cleanup now runs in a shielded
    cancel scope
- Drop patches:
  * robust_test_shielded_cancel_sleep_time.patch
  * fix-uvloop-closed-loop-race.patch
- Refresh patch extend_timeouts.patch

-------------------------------------------------------------------
Tue Aug  4 15:57:57 UTC 2026 - Matej Cepl <mcepl@cepl.eu>

- Instead of using sed make a proper patch extend_timeouts.patch
  to increase timeout in test_pytest_plugin module
- Add robust_test_shielded_cancel_sleep_time.patch making that
  test more robust (gh#agronholm/anyio!1264).
- Add fix-uvloop-closed-loop-race.patch to protect against a race
  condition in the test_cancel_worker_thread test
  (gh#agronholm/anyio!1266).

-------------------------------------------------------------------
Sat Jul 25 20:15:56 UTC 2026 - Matej Cepl <mcepl@cepl.eu>

- Update to 4.14.2:
    - Changed ByteReceiveStream.receive() implementations to
      raise a ValueError when max_bytes is not a positive integer
    - Fixed CapacityLimiter.total_tokens rejecting float("inf")
      when the limiter was instantiated outside of an event loop.
      The adapter setter checked for infinity by identity (value
      is math.inf), so only the exact math.inf singleton was
      accepted, while every backend setter (using math.isinf())
      accepts any positive infinity
    - Fixed to_process.run_sync() deadlocking when the worker
      function writes enough data to sys.stderr to fill the
      (undrained) pipe buffer. The worker process now redirects
      sys.stderr to os.devnull as well, matching the documented
      behavior
    - Fixed TLSStream.wrap() matching an internationalized
      (unicode) host name against the peer certificate using IDNA
      2003 (via the standard library) instead of IDNA 2008, which
      could cause the host name to be matched against the wrong
      certificate
    - Fixed anyio.open_process() (and run_process()) ignoring the
      extra_groups argument, as it mistakenly passed the value of
      the group argument instead
    - Fixed CapacityLimiter.acquire_nowait() and
      CapacityLimiter.acquire_nowait_on_behalf_of() raising
      trio.WouldBlock instead of anyio.WouldBlock on the trio
      backend when there are no tokens available
    - Fixed CapacityLimiter on the asyncio backend over-granting
      tokens (borrowed_tokens exceeding total_tokens and
      available_tokens going negative) when a non-blocking
      acquire was made in the window between a token being
      released and the notified waiter resuming. The freed token
      is now reserved for the woken waiter right away, so the
      non-blocking acquire correctly raises WouldBlock
    - Fixed unnecessary CPU spin when delivering cancellation
      from CancelScope on asyncio under certain conditions,
      including improper cancel scope nesting
- Update to 4.14.1:
    - Fixed teardown of higher-scoped async fixtures failing on
      asyncio with RuntimeError: Attempted to exit cancel scope
      in a different task than it was entered in when an async
      test raise an outcome exception (e.g., pytest.skip(),
      pytest.xfail(), or pytest.fail())
    - Fixed CapacityLimiter.total_tokens rejecting a value of
      0 when the limiter was instantiated outside of an event
      loop, contradicting the documented behavior of allowing
      0 total tokens
- Update to 4.14.0:
    - Added support for Python 3.15
    - Added an asynchronous implementation of the itertools
      module
    - Added the local_port parameter to connect_tcp() to allow
      binding to a specific local port before connecting
    - Added support for custom capacity limiters in async path
      and file I/O functions and classes
    - Added the create_task() task group method for easier
      asyncio migration (returns a TaskHandle)
    - Changed TaskGroup.start_soon() to return a TaskHandle
    - Added an option for TaskGroup.start() to return
      a TaskHandle
    - Added the cancel() convenience method to TaskGroup as
      a shortcut for cancelling the task group's cancel scope
    - Improved the error message when a known backend is not
      installed to suggest the install command
    - Improved anyio.Path to preserve subclass types by returning
      Self in methods that return path objects
    - Changed the parameter type annotation in
      anyio.Path.write_bytes() to accept any ReadableBuffer, thus
      allowing it to accept bytearray and memoryview to match
      pathlib.Path.write_bytes()
    - Changed several type annotations to only accept callables
      returning coroutine-like objects instead of arbitrary
      awaitables:
          TaskGroup.start_soon()
          TaskGroup.start()
          anyio.from_thread.run()
    - This reverts an earlier change from v3.7.0 which was made
      in error.
    - Changed anyio.run to support callables returning arbitrary
      awaitables at runtime on all backends. Previously, this
      only worked on asyncio
    - Changed several classes (and their subclasses) to have
      __slots__ (with __weakref__):
          anyio.CancelScope
          anyio.CapacityLimiter
          anyio.Condition
          anyio.Event
          anyio.Lock
          anyio.ResourceGuard
          anyio.Semaphore
    - Fixed cancellation exception escaping a cancel scope when
      triggered via check_cancelled() in a worker thread
    - Fixed TaskGroup raising AttributeError instead of a clear
      error when entered more than once
    - Fixed lost type information when passing arguments to
      lru_cache
    - Fixed test resumption after KeyboardInterrupt in async
      generator fixtures on the asyncio backend
    - Fixed import of __main__ in to_process workers when
      entrypoint script doesn't end in .py, such as when using
      console_script entrypoints.
    - Fixed SocketListener.from_socket() returning a TCP listener
      for AF_UNIX listening sockets, causing accept() to fail
      with ENOTSUP
    - Fixed UDPSocket.aclose() and ConnectedUDPSocket.aclose() on
      asyncio returning before the underlying socket FD was
      actually released
    - Fixed trio backend test runner hanging indefinitely instead
      of raising an error when dynamically accessing an async
      fixture via request.getfixturevalue
    - Fixed cancelling tasks started through a BlockingPortal
      after the portal has been stopped
    - Fixed backend_options being ignored when running the Trio
      backend via anyio.run(); the options are now passed as
      keyword arguments to trio.run() again, as documented (a
      regression from AnyIO 3)
    - Fixed asyncio Lock and Semaphore deadlocks caused by
      cancelled waiters left queued during release

-------------------------------------------------------------------
Sun Apr 26 14:00:38 UTC 2026 - Dirk Müller <dmueller@suse.com>

- update to 4.13.0:
  * Dropped support for Python 3.9
  * Added a ttl parameter to the anyio.functools.lru_cache
    wrapper
  * Widened the type annotations of file I/O streams to accept
    IO[bytes] instead of just BinaryIO
  * Fixed anyio.Path not being compatible with Python 3.15 due to
    the removal of pathlib.Path.is_reserved() and the addition of
    pathlib.Path.__vfspath__()
  * Fixed the BrokenResourceError raised by the asyncio
    SocketStream not having the original exception as its cause
  * Fixed the TypeError raised when using "func" as a parameter
    name in pytest.mark.parametrize when using the pytest plugin
  * Fixed the pytest plugin not running tests that had the anyio
    marker added programmatically via
    pytest_collection_modifyitems
  * Fixed cancellation exceptions leaking from a CancelScope on
    asyncio when they are contained in an exception group
    alongside non-cancellation exceptions
  * Fixed Condition.wait() not passing on a notification when the
    task is cancelled but already received a notification
  * Fixed inverted condition in the process pool shutdown phase
    which would cause still-running pooled processes not to be
    terminated

-------------------------------------------------------------------
Wed Mar  4 21:31:28 UTC 2026 - Dirk Müller <dmueller@suse.com>

- update to 4.12.1:
  * Changed all functions currently raising the private
    NoCurrentAsyncBackend exception (since v4.12.0) to instead
    raise the public NoEventLoopError exception
  * Fixed anyio.functools.lru_cache not working with instance
    methods

-------------------------------------------------------------------
Mon Dec  8 07:58:08 UTC 2025 - Steve Kowalik <steven.kowalik@suse.com>

- Update to 4.12.0:
  * Added support for asyncio's task call graphs on Python 3.14 and later
    when using AnyIO's task groups
  * Added an asynchronous implementation of the functools module
  * Added support for uvloop=True on Windows via the winloop implementation
  * Added support for use as a context manager to anyio.lowlevel.RunVar
  * Added __all__ declarations to public submodules (anyio.lowlevel etc.)
  * Added the ability to set the token count of a CapacityLimiter to zero
  * Added parameters case_sensitive and recurse_symlinks along with support
    for path-like objects to anyio.Path.glob() and anyio.Path.rglob()
  * Dropped sniffio as a direct dependency and added the
    get_available_backends() function
  * Fixed Process.stdin.send() not raising ClosedResourceError and
    BrokenResourceError on asyncio
  * Fixed Process.stdin.send() not checkpointing before writing data on
    asyncio
  * Fixed a race condition where cancelling a Future from
    BlockingPortal.start_task_soon() would sometimes not cancel the async
    function
  * Fixed the presence of the pytest plugin causing breakage with older
    versions of pytest (<= 6.1.2)
  * Fixed a rarely occurring RuntimeError: Set changed size during iteration
    while shutting down the process pool when using the asyncio backend

-------------------------------------------------------------------
Thu Nov 27 03:35:12 UTC 2025 - Steve Kowalik <steven.kowalik@suse.com>

- Skip a test that will break with pytest 9.

-------------------------------------------------------------------
Wed Sep 24 08:21:38 UTC 2025 - Nico Krapp <nico.krapp@suse.com>

- Update to 4.11.0
  * Added support for cancellation reasons (the reason parameter to 
    CancelScope.cancel()) (#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)
  * Added pytest option (anyio_mode = "auto") to make the pytest plugin
    automatically handle all async tests (#971)
  * Added the anyio.Condition.wait_for() method for feature parity with
    asyncio (#974)
  * Changed the default type argument of anyio.abc.TaskStatus from Any to
    None (#964)
  * Fixed TCP listener behavior to guarantee the same ephemeral port is used for
    all socket listeners when local_port=0 (#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)

-------------------------------------------------------------------
Wed Aug 13 05:32:04 UTC 2025 - Daniel Garcia <daniel.garcia@suse.com>

- Skip flaky test_keyboardinterrupt_during_test, the timeout increase
  doesn't always help.
- Fix build for Leap

-------------------------------------------------------------------
Tue Aug 12 08:54:42 UTC 2025 - Dominique Leuenberger <dimstar@opensuse.org>

- Update to 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
  + 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
  + Added the ability to specify the thread name in start_blocking
   _portal()
  + 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.
  + Incorporated several documentation improvements from the
    EuroPython 2025 sprint
  + 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.
  + Fixed rollover boundary check in SpooledTemporaryFile so that
    rollover only occurs when the buffer size exceeds max_size
  + Migrated testing and documentation dependencies from extras to
    dependency groups
  + Fixed compatibility of anyio.to_interpreter with Python 3.14.0
  + Fixed SyntaxWarning on Python 3.14 about return in finally
  + Fixed RunVar name conflicts. RunVar instances with the same
    name should not share storage
  + Renamed the BrokenWorkerIntepreter exception to
    BrokenWorkerInterpreter. The old name is available as a
    deprecated alias.
  + 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

-------------------------------------------------------------------
Thu Aug  7 09:33:03 UTC 2025 - Daniel Garcia <daniel.garcia@suse.com>

- Increase timeout in in test_keyboardinterrupt_during_test, it helps
  with flaky tests in i586 arches.

-------------------------------------------------------------------
Mon Jul 21 05:03:47 UTC 2025 - Steve Kowalik <steven.kowalik@suse.com>

- Inject multibuild to break a build loop. 

-------------------------------------------------------------------
Fri Jul 18 08:45:09 UTC 2025 - Felix Stegmeier <felix.stegmeier@suse.com>

- Update to 4.9.0:
  * Added async support for temporary file handling (#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; PR by @tapetersen)
  * Fixed anyio.Path.iterdir() making a blocking call in Python 3.13
    (#873; PR by @cbornet and @agronholm)
  * Fixed connect_tcp() producing cyclic references in tracebacks when
    raising exceptions (#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)


-------------------------------------------------------------------
Mon Feb 10 09:17:39 UTC 2025 - Nico Krapp <nico.krapp@suse.com>

- Update to 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; PR by @graingert)
  * Fixed AssertionError when using nest-asyncio (#840)
  * Fixed return type annotation of various context managers' 
    __exit__ method (#847; PR by @Enegg)
- from 4.7.0:
  * Updated TaskGroup to work with asyncio's eager task factories (#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)
  * 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; PR by @graingert)
  * Fixed the return type annotations of readinto() and readinto1() 
    methods in the anyio.AsyncFile class (#825)
  * Fixed TaskInfo.has_pending_cancellation() on asyncio returning 
    false positives in cleanup code on Python >= 3.11 
    (#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; PR by @gschaffner)

-------------------------------------------------------------------
Tue Oct 22 16:00:48 UTC 2024 - Dirk Müller <dmueller@suse.com>

- update to 4.6.2:
  * Fixed regression caused by (\#807) that prevented the use
    of parametrized async fixtures
- update to 4.6.1:
  * Fixed TaskGroup and CancelScope producing cyclic references
    in tracebacks when raising exceptions (\#806) (PR by
    @graingert)

-------------------------------------------------------------------
Wed Oct  2 18:02:06 UTC 2024 - Antonio Larrosa <alarrosa@suse.com>

- update to 4.6.0:
  * Dropped support for Python 3.8 (as #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)
  * Fixed cancel scopes on asyncio not propagating CancelledError
    on exit when the enclosing cancel scope has been effectively
    cancelled (#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
- update to 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)
  * Added support for more keyword arguments for run_process() and
    open_process(): startupinfo, creationflags, pass_fds, user,
    group, extra_groups and umask (#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; PR by @Danipulok)
  * Fixed to_process.run_sync() failing to initialize if
    __main__.__file__ pointed to a file in a nonexistent directory
    (#696)
  * Fixed AssertionError: feed_data after feed_eof on asyncio when
    a subprocess is closed early, before its output has been read
    (#490)
  * Fixed TaskInfo.has_pending_cancellation() on asyncio not
    respecting shielded scopes (#771; PR by @gschaffner)
  * Fixed SocketStream.receive() returning bytearray instead of
    bytes when using asyncio with ProactorEventLoop (Windows)
    (#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; PR by @tapetersen)
  * Fixed KeyboardInterrupt (ctrl+c) hanging the asyncio pytest
    runner

-------------------------------------------------------------------
Wed Jun 12 09:21:08 UTC 2024 - Dirk Müller <dmueller@suse.com>

- update to 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__
  * 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()
  * 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; PR by
    Dominik Schwabe) Fixed the entire task group being cancelled
    if a TaskGroup.start() call gets cancelled (#685, #710)
  * 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()
  * Fixed the entire task group being cancelled if a
    TaskGroup.start() call gets cancelled
  * 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
  * 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
  * 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
  * 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
  * 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

-------------------------------------------------------------------
Mon Mar 11 23:36:15 UTC 2024 - Steve Kowalik <steven.kowalik@suse.com>

- Update to 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
  * Fixed ``Process.stdin.aclose()``, ``Process.stdout.aclose()``, and
    ``Process.stderr.aclose()``
- Add exceptiongroup to {Build,}Requires.

-------------------------------------------------------------------
Tue Jan  2 20:50:56 UTC 2024 - Dirk Müller <dmueller@suse.com>

- update to 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)
  * 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
  * 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

-------------------------------------------------------------------
Fri Dec  1 16:52:20 UTC 2023 - Dirk Müller <dmueller@suse.com>

- update to 4.1.0:
  * Adapted to API changes made in Trio v0.23
  * 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)
  * 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
  * 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
    ``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``
  * Dropped support for Python 3.7
  * Added support for Python 3.12
  * 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
- drop tests-test_fileio.py-don-t-follow-symlinks-in-dev.patch
  (upstream)

-------------------------------------------------------------------
Thu Nov 16 15:31:07 UTC 2023 - Dirk Müller <dmueller@suse.com>

- update to 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)
  * 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()``
  * 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)
  * 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
  * 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
- drop fix-failing-tls-tests.patch
  support-trio-0.22.patch: obsolete

-------------------------------------------------------------------
Thu Nov 16 15:30:25 UTC 2023 - Dirk Müller <dmueller@suse.com>

- update to 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)
  * **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

-------------------------------------------------------------------
Thu Nov  2 10:42:51 UTC 2023 - Jiri Slaby <jslaby@suse.cz>

- add tests-test_fileio.py-don-t-follow-symlinks-in-dev.patch (kernel
  6.6 fix)

-------------------------------------------------------------------
Thu May  4 07:29:22 UTC 2023 - Steve Kowalik <steven.kowalik@suse.com>

- Add patch fix-failing-tls-tests.patch:
  * Fix test failures with Python TLS changes.

-------------------------------------------------------------------
Fri Apr 21 12:21:49 UTC 2023 - Dirk Müller <dmueller@suse.com>

- add sle15_python_module_pythons (jsc#PED-68)

-------------------------------------------------------------------
Thu Apr 13 22:39:54 UTC 2023 - Matej Cepl <mcepl@suse.com>

- Make calling of %{sle15modernpython} optional.

-------------------------------------------------------------------
Tue Mar  7 06:29:28 UTC 2023 - Steve Kowalik <steven.kowalik@suse.com>

- Add patch support-trio-0.22.patch:
  * Support trio >= 0.22 just enough for asyncclick.

-------------------------------------------------------------------
Fri Dec 16 15:06:08 UTC 2022 - Markéta Machová <mmachova@suse.com>

- Skip trio exception tests for now
  * https://github.com/agronholm/anyio/issues/508
  * https://github.com/agronholm/anyio/commit/787cb0c2e53c2a3307873d202fbd49dc5eac4e96

-------------------------------------------------------------------
Mon Nov 21 21:04:03 UTC 2022 - Dirk Müller <dmueller@suse.com>

- update to 3.6.2:
  - Pinned Trio to < 0.22 to avoid incompatibility with AnyIO's ``ExceptionGroup`` class
    causing ``AttributeError: 'NonBaseMultiError' object has no attribute '_exceptions'``
    (AnyIO 4 is unaffected)
  - Fixed exception handler in the asyncio test runner not properly handling a context
    that does not contain the ``exception`` key
  - Fixed ``TypeError`` in ``get_current_task()`` on asyncio when using a custom ``Task`` factory
  - Updated type annotations on ``run_process()`` and ``open_process()``:
    * ``command`` now accepts accepts bytes and sequences of bytes
    * ``stdin``, ``stdout`` and ``stderr`` now accept file-like objects
  - Changed the pytest plugin to run both the setup and teardown phases of asynchronous
    generator fixtures within a single task to enable use cases such as cancel scopes and
    task groups where a context manager straddles the ``yield``
- drop anyio-pytest7.patch (upstream)

-------------------------------------------------------------------
Sun Mar 27 18:32:27 UTC 2022 - Ben Greiner <code@bnavigator.de>

- Add anyio-pytest7.patch -- gh#agronholm/anyio#420

-------------------------------------------------------------------
Tue Feb 15 16:06:39 UTC 2022 - Dirk Müller <dmueller@suse.com>

- skip some tests for older distros (lack of TLSv1.3 support)

-------------------------------------------------------------------
Sat Jan 15 16:36:24 UTC 2022 - Dirk Müller <dmueller@suse.com>

- update to 3.5.0:
  - Added ``start_new_session`` keyword argument to ``run_process()`` and ``open_process()``
  - Fixed deadlock in synchronization primitives on asyncio which can happen if a task acquiring a
    primitive is hit with a native (not AnyIO) cancellation with just the right timing, leaving the
    next acquiring task waiting forever
  - Added workaround for bpo-46313_ to enable compatibility with OpenSSL 3.0

-------------------------------------------------------------------
Mon Nov 29 12:01:51 UTC 2021 - Dirk Müller <dmueller@suse.com>

- update to 3.4.0:
  * Added context propagation to/from worker threads in ``to_thread.run_sync()``,
  ``from_thread.run()`` and ``from_thread.run_sync()``
  * Fixed race condition in ``Lock`` and ``Semaphore`` classes when a task waiting on ``acquire()``
  is cancelled while another task is waiting to acquire the same primitive
  * Fixed async context manager's ``__aexit__()`` method not being called in
  ``BlockingPortal.wrap_async_context_manager()`` if the host task is cancelled
  * Fixed worker threads being marked as being event loop threads in sniffio
  * Fixed task parent ID not getting set to the correct value on asyncio
  * Enabled the test suite to run without IPv6 support, trio or pytest plugin autoloading

-------------------------------------------------------------------
Tue Oct 26 20:18:21 UTC 2021 - Dirk Müller <dmueller@suse.com>

- update to 3.3.4:
  * Fixed ``BrokenResourceError`` instead of ``EndOfStream`` being raised in
   ``TLSStream`` when the peer abruptly closes the connection while
   ``TLSStream`` is receiving data with ``standard_compatible=False`` set

-------------------------------------------------------------------
Sat Oct 16 21:03:37 UTC 2021 - Dirk Müller <dmueller@suse.com>

- update to 3.3.3:
  * Fixed UNIX socket listener not setting accepted sockets to non-blocking
    mode on asyncio
  * Changed unconnected UDP sockets to be always bound to a local port (on
    "any" interface) to avoid errors on asyncio + Windows
  * Fixed cancellation problem on asyncio where level-triggered cancellation
    for **all** parent cancel scopes would not resume after exiting a
    shielded nested scope

-------------------------------------------------------------------
Fri Sep 17 19:23:22 UTC 2021 - Ben Greiner <code@bnavigator.de>

- Update to v3.3.1
  * Added missing documentation for the ExceptionGroup.exceptions
   attribute
  * Changed the asyncio test runner not to use uvloop by default
    (to match the behavior of anyio.run())
  * Fixed RuntimeError on asyncio when a CancelledError is raised
    from a task spawned through a BlockingPortal (#357)
  * Fixed asyncio warning about a Future with an exception that
    was never retrieved which happened when a socket was already
    written to but the peer abruptly closed the connection
- Release 3.3.0
  * Added asynchronous Path class
  * Added the wrap_file() function for wrapping existing files as
    asynchronous file objects
  * Relaxed the type of the path initializer argument to
    FileReadStream and FileWriteStream so they accept any
    path-like object (including the new asynchronous Path class)
  * Dropped unnecessary dependency on the async_generator library
  * Changed the generics in AsyncFile so that the methods
    correctly return either str or bytes based on the argument to
    open_file()
  * Fixed an asyncio bug where under certain circumstances, a
    stopping worker thread would still accept new assignments,
    leading to a hang
- Release 3.2.1
  * Fixed idle thread pruning on asyncio sometimes causing an
    expired worker thread to be assigned a task
- Release 3.2.0
  * Added Python 3.10 compatibility
  * Added the ability to close memory object streams synchronously
    (including support for use as a synchronous context manager)
  * Changed the default value of the use_uvloop asyncio backend
    option to False to prevent unsafe event loop policy changes in
    different threads
  * Fixed to_thread.run_sync() hanging on the second call on
    asyncio when used with loop.run_until_complete()
  * Fixed to_thread.run_sync() prematurely marking a worker thread
    inactive when a task await on the result is cancelled
  * Fixed ResourceWarning about an unclosed socket when UNIX
    socket connect fails on asyncio
  * Fixed the type annotation of open_signal_receiver() as a
    synchronous context manager
  * Fixed the type annotation of DeprecatedAwaitable(|List|Float).
    __await__ to match the typing.Awaitable protocol
- Unskip python36: uvloop is only optional

-------------------------------------------------------------------
Fri Sep 17 06:59:56 UTC 2021 - Dominique Leuenberger <dimstar@opensuse.org>

- Do not build for python 3.6: the required dependency uvloop does
  no longer support Python 3.6 since version 0.16.

-------------------------------------------------------------------
Thu Jun  3 09:17:54 UTC 2021 - Antonio Larrosa <alarrosa@suse.com>

- Update to 3.1.0:
  * Added env and cwd keyword arguments to run_process() and
    open_process.
  * Added support for mutation of CancelScope.shield
    (PR by John Belmonte)
  * Added the sleep_forever() and sleep_until() functions
  * Changed asyncio task groups so that if the host and child tasks
    have only raised CancelledErrors, just one CancelledError will
    now be raised instead of an ExceptionGroup, allowing asyncio to
    ignore it when it propagates out of the task
  * Changed task names to be converted to str early on asyncio
    (PR by Thomas Grainger)
  * Fixed sniffio._impl.AsyncLibraryNotFoundError: unknown async
    library, or not in async context on asyncio and Python 3.6 when
    to_thread.run_sync() is used from loop.run_until_complete()
  * Fixed odd ExceptionGroup: 0 exceptions were raised in the task
    group appearing under certain circumstances on asyncio
  * Fixed wait_all_tasks_blocked() returning prematurely on asyncio
    when a previously blocked task is cancelled
    (PR by Thomas Grainger)
  * Fixed declared return type of TaskGroup.start() (it was
    declared as None, but anything can be returned from it)
  * Fixed TextStream.extra_attributes raising AttributeError
    (PR by Thomas Grainger)
  * Fixed await maybe_async(current_task()) returning None
    (PR by Thomas Grainger)
  * Fixed: pickle.dumps(current_task()) now correctly raises
    TypeError instead of pickling to None (PR by Thomas Grainger)
  * Fixed return type annotation of Event.wait() (bool → None)
    (PR by Thomas Grainger)
  * Fixed return type annotation of RunVar.get() to return either
    the type of the default value or the type of the contained
    value (PR by Thomas Grainger)
  * Fixed a deprecation warning message to refer to maybe_async()
    and not maybe_awaitable() (PR by Thomas Grainger)
  * Filled in argument and return types for all functions and
    methods previously missing them (PR by Thomas Grainger)

- Update to 3.0.1:
  * Fixed to_thread.run_sync() raising RuntimeError on asyncio
    when no "root" task could be found for setting up a cleanup
    callback. This was a problem at least on Tornado and possibly
    also Twisted in asyncio compatibility mode. The life of worker
    threads is now bound to the the host task of the topmost cancel
    scope hierarchy starting from the current one, or if no cancel
    scope is active, the current task.

- Update to 3.0.0:
  * Curio support has been dropped (see the :doc:`FAQ <faq>` as for
    why)
  * API changes:
    - BACKWARDS INCOMPATIBLE Submodules under anyio.abc. have been
      made private (use only anyio.abc from now on).
    - BACKWARDS INCOMPATIBLE The following method was previously a
      coroutine method and has been converted into a synchronous
      one:
      * MemoryObjectReceiveStream.receive_nowait()
    - The following functions and methods are no longer
      asynchronous but can still be awaited on (doing so will emit
      a deprecation warning):
      * current_time()
      * current_effective_deadline()
      * get_current_task()
      * get_running_tasks()
      * CancelScope.cancel()
      * CapacityLimiter.acquire_nowait()
      * CapacityLimiter.acquire_on_behalf_of_nowait()
      * Condition.release()
      * Event.set()
      * Lock.release()
      * MemoryObjectSendStream.send_nowait()
      * Semaphore.release()
    - The following functions now return synchronous context
      managers instead of asynchronous context managers (and emit
      deprecation warnings if used as async context managers):
      * fail_after()
      * move_on_after()
      * open_cancel_scope() (now just CancelScope(); see below)
      * open_signal_receiver()
    - The following functions and methods have been renamed/moved
      (will now emit deprecation warnings when you use them by
      their old names):
      * create_blocking_portal() →
        anyio.from_thread.BlockingPortal()
      * create_capacity_limiter() → anyio.CapacityLimiter()
      * create_event() → anyio.Event()
      * create_lock() → anyio.Lock()
      * create_condition() → anyio.Condition()
      * create_semaphore() → anyio.Semaphore()
      * current_default_worker_thread_limiter() →
        anyio.to_thread.current_default_thread_limiter()
      * open_cancel_scope() → anyio.CancelScope()
      * run_sync_in_worker_thread() → anyio.to_thread.run_sync()
      * run_async_from_thread() → anyio.from_thread.run()
      * run_sync_from_thread() → anyio.from_thread.run_sync()
      * BlockingPortal.spawn_task → BlockingPortal.start_task_soon
      * CapacityLimiter.set_total_tokens() → limiter.total_tokens
        = ...
      * TaskGroup.spawn() → TaskGroup.start_soon()
    - BACKWARDS INCOMPATIBLE start_blocking_portal() must now be
      used as a context manager (it no longer returns a
      BlockingPortal, but a context manager that yields one)
    - BACKWARDS INCOMPATIBLE The
      BlockingPortal.stop_from_external_thread() method (use
      portal.call(portal.stop) instead now)
    - BACKWARDS INCOMPATIBLE The SocketStream and SocketListener
      classes were made non-generic
    - Made all non-frozen dataclasses hashable with eq=False
    - Removed __slots__ from BlockingPortal
    See the :doc:`migration documentation <migration>` for
    instructions on how to deal with these changes.
  * Improvements to running synchronous code:
    - Added the run_sync_from_thread() function
    - Added the run_sync_in_process() function for running code in
      worker processes (big thanks to Richard Sheridan for his help
      on this one!)
  * Improvements to sockets and streaming:
    - Added the UNIXSocketStream class which is capable of sending
      and receiving file descriptors
    - Added the FileReadStream and FileWriteStream classes
    - create_unix_listener() now removes any existing socket at the
      given path before proceeding (instead of raising OSError:
      Address already in use)
  * Improvements to task groups and cancellation:
    - Added the TaskGroup.start() method and a corresponding
      BlockingPortal.start_task() method
    - Added the name argument to BlockingPortal.start_task_soon()
      (renamed from BlockingPortal.spawn_task())
    - Changed CancelScope.deadline to be writable
    - Added the following functions in the anyio.lowlevel module:
      * checkpoint()
      * checkpoint_if_cancelled()
      * cancel_shielded_checkpoint()
  * Improvements and changes to synchronization primitives:
    - Added the Lock.acquire_nowait(), Condition.acquire_nowait()
      and Semaphore.acquire_nowait() methods
    - Added the statistics() method to Event, Lock, Condition,
      Semaphore, CapacityLimiter, MemoryObjectReceiveStream and
      MemoryObjectSendStream
    - Lock and Condition can now only be released by the task that
      acquired them. This behavior is now consistent on all
      backends whereas previously only Trio enforced this.
    - The CapacityLimiter.total_tokens property is now writable and
      CapacityLimiter.set_total_tokens() has been deprecated
    - Added the max_value property to Semaphore
  * Asyncio specific improvements (big thanks to Thomas Grainger
    for his effort on most of these!):
    - Cancel scopes are now properly enforced with native asyncio
      coroutine functions (without any explicit AnyIO checkpoints)
    - Changed the asyncio CancelScope to raise a RuntimeError if a
      cancel scope is being exited before it was even entered
    - Changed the asyncio test runner to capture unhandled
      exceptions from asynchronous callbacks and unbound native
      tasks which are then raised after the test function (or async
      fixture setup or teardown) completes
    - Changed the asyncio TaskGroup.start_soon() (formerly spawn())
      method to call the target function immediately before
      starting the task, for consistency across backends
    - Changed the asyncio TaskGroup.start_soon() (formerly spawn())
      method to avoid the use of a coroutine wrapper on Python 3.8+
      and added a hint for hiding the wrapper in tracebacks on
      earlier Pythons (supported by Pytest, Sentry etc.)
    - Changed the default thread limiter on asyncio to use a RunVar
      so it is scoped to the current event loop, thus avoiding
      potential conflict among multiple running event loops
    - Thread pooling is now used on asyncio with
      run_sync_in_worker_thread()
    - Fixed current_effective_deadline() raising KeyError on
      asyncio when no cancel scope is active
  * Added the RunVar class for scoping variables to the running
    event loop

-------------------------------------------------------------------
Mon Mar 15 05:57:41 UTC 2021 - Steve Kowalik <steven.kowalik@suse.com>

- Update to 2.2.0:
  * Added the ``maybe_async()`` and ``maybe_async_cm()`` functions to facilitate forward compatibility with AnyIO 3
  * Fixed socket stream bug on asyncio where receiving a half-close from the peer would shut down the entire connection
  * Fixed native task names not being set on asyncio on Python 3.8+
  * Fixed ``TLSStream.send_eof()`` raising ``ValueError`` instead of the expected ``NotImplementedError``
  * Fixed ``open_signal_receiver()`` on asyncio and curio hanging if the cancel scope was cancelled before the function could run
  * Fixed Trio test runner causing unwarranted test errors on ``BaseException``s
  * Fixed formatted output of ``ExceptionGroup`` containing too many newlines
  * Added the ``spawn_task()`` and ``wrap_async_context_manager()`` methods to ``BlockingPortal``
  * Added the ``handshake_timeout`` and ``error_handler`` parameters to ``TLSListener``
  * Fixed ``Event`` objects on the trio backend not inheriting from ``anyio.abc.Event``
  * Fixed ``run_sync_in_worker_thread()`` raising ``UnboundLocalError`` on asyncio when cancelled
  * Fixed ``send()`` on socket streams not raising any exception on asyncio, and an unwrapped
  * ``BrokenPipeError`` on trio and curio when the peer has disconnected
  * Fixed ``MemoryObjectSendStream.send()`` raising ``BrokenResourceError`` when the last receiver is closed right after receiving the item
  * Fixed ``ValueError: Invalid file descriptor: -1`` when closing a ``SocketListener`` on asyncio

-------------------------------------------------------------------
Sat Jan 30 18:29:29 UTC 2021 - Ben Greiner <code@bnavigator.de>

- Initial specfile for version 2.0.2
- required by jupyter_server 1.2.3
