Log message:
py-trio: updated to 0.29.0

Trio 0.29.0 (2025-02-14)

Features

- Add :func:`trio.lowlevel.in_trio_run` and :func:`trio.lowlevel.in_trio_task` \ 
and document the semantics (and differences) thereof. See :ref:`the \ 
documentation <trio_contexts>`.
- If `trio.testing.RaisesGroup` does not get the expected exceptions it now \ 
raises an `AssertionError` with a helpful message, instead of letting the raised \ 
exception/group fall through. The raised exception is available in the \ 
``__context__`` of the `AssertionError` and can be seen in the traceback.

Bugfixes

- Clear Trio's cache of worker threads upon `os.fork`.

Miscellaneous internal changes

- Stop using ctypes to mutate tracebacks for ``strict_exception_groups=False``'s \ 
exception collapsing.
- Fixed spelling error in Windows error code enum for ``ERROR_INVALID_PARAMETER``.
- Publicly re-export ``__version__`` for type checking purposes.
- The typing of :func:`trio.abc.HostnameResolver.getaddrinfo` has been corrected to
  match that of the stdlib `socket.getaddrinfo`, which was updated in mypy 1.15 (via
  a typeshed update) to include the possibility of ``tuple[int, bytes]`` for the
  ``sockaddr`` field of the result. This happens in situations where Python was \ 
compiled
  with ``--disable-ipv6``.

  Additionally, the static typing of :func:`trio.to_thread.run_sync`,
  :func:`trio.from_thread.run` and :func:`trio.from_thread.run_sync` has been
  improved and should reflect the underlying function being run.

Log message:
py-trio: updated to 0.28.0

Trio 0.28.0 (2024-12-25)

Bugfixes

- :func:`inspect.iscoroutinefunction` and the like now give correct answers when
  called on KI-protected functions.
- Rework KeyboardInterrupt protection to track code objects, rather than frames,
  as protected or not. The new implementation no longer needs to access
  ``frame.f_locals`` dictionaries, so it won't artificially extend the lifetime of
  local variables. Since KeyboardInterrupt protection is now imposed statically
  (when a protected function is defined) rather than each time the function runs,
  its previously-noticeable performance overhead should now be near zero.
  The lack of a call-time wrapper has some other benefits as well:

  * :func:`inspect.iscoroutinefunction` and the like now give correct answers when
    called on KI-protected functions.

  * Calling a synchronous KI-protected function no longer pushes an additional stack
    frame, so tracebacks are clearer.

  * A synchronous KI-protected function invoked from C code (such as a weakref
    finalizer) is now guaranteed to start executing; previously there would be a \ 
brief
    window in which KeyboardInterrupt could be raised before the protection was
    established.

  One minor drawback of the new approach is that multiple instances of the same
  closure share a single KeyboardInterrupt protection state (because they share a
  single code object). That means that if you apply
  `@enable_ki_protection <trio.lowlevel.enable_ki_protection>` to some of them
  and not others, you won't get the protection semantics you asked for. See the
  documentation of `@enable_ki_protection <trio.lowlevel.enable_ki_protection>`
  for more details and a workaround.
- Rework foreign async generator finalization to track async generator
  ids rather than mutating ``ag_frame.f_locals``. This fixes an issue
  with the previous implementation: locals' lifetimes will no longer be
  extended by materialization in the ``ag_frame.f_locals`` dictionary that
  the previous finalization dispatcher logic needed to access to do its work.
- Ensure that Pyright recognizes our underscore prefixed attributes for attrs \ 
classes.
- Fix `trio.testing.RaisesGroup`'s typing.

Improved documentation

- Improve error message when run after gevent's monkey patching.
- Document that :func:`trio.sleep_forever` is guaranteed to raise an exception now.

Removals without deprecations

- Remove workaround for OpenSSL 1.1.1 DTLS ClientHello bug.
- Drop support for Python 3.8.

Miscellaneous internal changes

- Switch to using PEP570 for positional-only arguments for \ 
`~trio.socket.SocketType`'s methods.
- Improve type annotations in several places by removing `Any` usage.
- Get and enforce 100% coverage

Log message:
py-*: remove unused tool dependency

py-setuptools includes the py-wheel functionality nowadays

Log message:
py-trio: update to 0.27.0

Trio 0.27.0 (2024-10-17)

Breaking changes

- :func:`trio.move_on_after` and :func:`trio.fail_after` previously set the \ 
deadline relative to initialization time, instead of more intuitively upon \ 
entering the context manager. This might change timeouts if a program relied on \ 
this behavior. If you want to restore previous behavior you should instead use \ 
``trio.move_on_at(trio.current_time() + ...)``.
  flake8-async has a new rule to catch this, in case you're supporting older \ 
trio versions. See :ref:`ASYNC122`.

Features

- :meth:`CancelScope.relative_deadline` and :meth:`CancelScope.is_relative` \ 
added, as well as a ``relative_deadline`` parameter to ``__init__``. This allows \ 
initializing scopes ahead of time, but where the specified relative deadline \ 
doesn't count down until the scope is entered.
- :class:`trio.Lock` and :class:`trio.StrictFIFOLock` will now raise \ 
:exc:`trio.BrokenResourceError` when :meth:`trio.Lock.acquire` would previously \ 
stall due to the owner of the lock exiting without releasing the lock.
- `trio.move_on_at`, `trio.move_on_after`, `trio.fail_at` and `trio.fail_after` \ 
now accept *shield* as a keyword argument. If specified, it provides an initial \ 
value for the `~trio.CancelScope.shield` attribute of the `trio.CancelScope` \ 
object created by the context manager.
- Added :func:`trio.lowlevel.add_parking_lot_breaker` and \ 
:func:`trio.lowlevel.remove_parking_lot_breaker` to allow creating custom \ 
lock/semaphore implementations that will break their underlying parking lot if a \ 
task exits unexpectedly. :meth:`trio.lowlevel.ParkingLot.break_lot` is also \ 
added, to allow breaking a parking lot intentionally.

Bugfixes

- Allow sockets to bind any ``os.PathLike`` object.
- Update ``trio.lowlevel.open_process``'s documentation to allow bytes.
- Update :func:`trio.sleep_forever` to be `NoReturn`.

Improved documentation

- Add docstrings for memory channels' ``statistics()`` and ``aclose`` methods.

Log message:
py-trio: updated to 0.26.2

Trio 0.26.2 (2024-08-08)

Bugfixes

- Remove remaining ``hash`` usage and fix test configuration issue that \ 
prevented it from being caught.

Log message:
py-trio: updated to 0.26.1

Trio 0.26.1 (2024-08-05)

Bugfixes

- Switched ``attrs`` usage off of ``hash``, which is now deprecated.

Miscellaneous internal changes

- Use PyPI's Trusted Publishers to make releases.

Log message:
py-trio: update to 0.26.0.

Features

    Added an interactive interpreter python -m trio.

    This makes it easier to try things and experiment with trio in the a Python repl.
    Use the await keyword without needing to call trio.run()

$ python -m trio
Trio 0.26.0, Python 3.10.6
Use "await" directly instead of "trio.run()".
Type "help", "copyright", "credits" or \ 
"license" for more information.
>>> import trio
>>> await trio.sleep(1); print("hi")  # prints after one second
hi

See interactive debugging for further detail. (#2972)

    trio.testing.RaisesGroup can now catch an unwrapped exception with \ 
unwrapped=True. This means that the behaviour of except* can be fully replicated \ 
in combination with flatten_subgroups=True (formerly strict=False). (#2989)

Bugfixes

    Fixed a bug where trio.testing.RaisesGroup(..., strict=False) would check \ 
the number of exceptions in the raised ExceptionGroup before flattening \ 
subgroups, leading to incorrectly failed matches.
    It now properly supports end ($) regex markers in the match message, by no \ 
longer including " (x sub-exceptions)" in the string it matches \ 
against. (#2989)

Deprecations and removals

    Deprecated strict parameter from trio.testing.RaisesGroup, previous \ 
functionality of strict=False is now in flatten_subgroups=True. (#2989)

Log message:
py-trio: updated to 0.25.1

Trio 0.25.1 (2024-05-16)

Bugfixes

- Fix crash when importing trio in embedded Python on Windows, and other \ 
installs that remove docstrings.

Log message:
py-trio: updated to 0.25.0

Trio 0.25.0 (2024-03-17)
------------------------

Breaking changes

- The :ref:`strict_exception_groups <strict_exception_groups>` parameter \ 
now defaults to `True` in `trio.run` and `trio.lowlevel.start_guest_run`. \ 
`trio.open_nursery` still defaults to the same value as was specified in \ 
`trio.run`/`trio.lowlevel.start_guest_run`, but if you didn't specify it there \ 
then all subsequent calls to `trio.open_nursery` will change.
  This is unfortunately very tricky to change with a deprecation period, as \ 
raising a `DeprecationWarning` whenever :ref:`strict_exception_groups \ 
<strict_exception_groups>` is not specified would raise a lot of \ 
unnecessary warnings.

  Notable side effects of changing code to run with ``strict_exception_groups==True``

  * If an iterator raises `StopAsyncIteration` or `StopIteration` inside a \ 
nursery, then python will not recognize wrapped instances of those for stopping \ 
iteration.
  * `trio.run_process` is now documented that it can raise an `ExceptionGroup`. \ 
It previously could do this in very rare circumstances, but with \ 
:ref:`strict_exception_groups <strict_exception_groups>` set to `True` it \ 
will now do so whenever exceptions occur in ``deliver_cancel`` or with problems \ 
communicating with the subprocess.

    * Errors in opening the process is now done outside the internal nursery, so \ 
if code previously ran with ``strict_exception_groups=True`` there are cases now \ 
where an `ExceptionGroup` is *no longer* added.
  * `trio.TrioInternalError` ``.__cause__`` might be wrapped in one or more \ 
`ExceptionGroups <ExceptionGroup>`

Features

- Add `trio.testing.wait_all_threads_completed`, which blocks until no threads \ 
are running tasks. This is intended to be used in the same way as \ 
`trio.testing.wait_all_tasks_blocked`.
- :class:`Path` is now a subclass of :class:`pathlib.PurePath`, allowing it to \ 
interoperate with other standard
  :mod:`pathlib` types.

  Instantiating :class:`Path` now returns a concrete platform-specific subclass, \ 
one of :class:`PosixPath` or
  :class:`WindowsPath`, matching the behavior of :class:`pathlib.Path`.

Bugfixes

- The pthread functions are now correctly found on systems using vanilla \ 
versions of musl libc.

Miscellaneous internal changes

- use the regular readme for the PyPI long_description

Log message:
py-trio: updated to 0.24.0

Trio 0.24.0 (2024-01-10)

Features

- New helper classes: :class:`~.testing.RaisesGroup` and :class:`~.testing.Matcher`.

  In preparation for changing the default of ``strict_exception_groups`` to \ 
`True`, we're introducing a set of helper classes that can be used in place of \ 
`pytest.raises \ 
<https://docs.pytest.org/en/stable/reference/reference.html#pytest.raises>`_ \ 
in tests, to check for an expected `ExceptionGroup`.
  These are provisional, and only planned to be supplied until there's a good \ 
solution in ``pytest``.

Deprecations and removals

- ``MultiError`` has been fully removed, and all relevant trio functions now \ 
raise ExceptionGroups instead. This should not affect end users that have \ 
transitioned to using ``except*`` or catching ExceptionGroup/BaseExceptionGroup.