- Update to 0.16.0
* If you want to use Trio, but are stuck with some other event loop
like Qt or PyGame, then good news: now you can have both.
* To speed up `trio.to_thread.run_sync`, Trio now caches and re-uses
worker threads.
* Tasks spawned with `nursery.start() <trio.Nursery.start>` aren't treated as
direct children of their nursery until they call ``task_status.started()``.
* Some bugfixes and deprecations
OBS-URL: https://build.opensuse.org/request/show/822403
OBS-URL: https://build.opensuse.org/package/show/devel:languages:python/python-trio?expand=0&rev=14
* Added a helpful error message if an async function is passed to
trio.from_thread.run_sync or a sync function to trio.from_thread.run. (#1244)
* Previously, when trio.run_process was cancelled, it always killed the subprocess immediately. Now, on Unix, it first gives the process a chance to clean up by sending SIGTERM, and only escalates to SIGKILL if the process is still running after 5 seconds. But if you prefer the old behavior, or want to adjust the timeout, then don't worry: you can now pass a custom deliver_cancel= argument to define your own process killing policy. (#1104)
* It turns out that creating a subprocess can block the parent process for a surprisingly long time. So trio.open_process now uses a worker thread to avoid blocking the event loop. (#1109)
* On Linux kernels v5.3 or newer, trio.Process.wait now uses the pidfd API to track child processes. This shouldn't have any user-visible change, but it makes working with subprocesses faster and use less memory. (#1241)
* The trio.Process.returncode attribute is now automatically updated as needed, instead of only when you call ~trio.Process.poll or ~trio.Process.wait. Also, repr(process_object) now always contains up-to-date information about the process status. (#1315)
OBS-URL: https://build.opensuse.org/package/show/devel:languages:python/python-trio?expand=0&rev=12
* Use slots for memory channel state and statistics which should make
memory channels slightly smaller and faster.
* OpenSSL has a bug in its handling of TLS 1.3 session tickets that can cause
deadlocks or data loss in some rare edge cases. These edge cases most frequently
happen during tests.
* Trio now uses signal.set_wakeup_fd on all platforms.
* Trio no longer crashes when an async function is implemented in C or Cython
and then passed directly to trio.run or nursery.start_soon.
* When a Trio task makes improper use of a non-Trio async library, Trio nowi
causes an exception to be raised within the task at the point of the error,
rather than abandoning the task and raising an error in its parent.
This improves debuggability and resolves the TrioInternalError that would
sometimes result from the old strategy. (#552)
* In 0.12.0 we deprecated trio.run_sync_in_worker_thread in favor
of trio.to_thread.run_sync. But, the deprecation message listed the wrong
name for the replacement.
* Fix regression introduced with cancellation changes in 0.12.0, where
a trio.CancelScope which isn't cancelled could catch a propagating
trio.Cancelled exception if shielding were changed while the cancellation
was propagating.
* Fix a crash that could happen when using MockClock with autojump enabled
and a non-zero rate.
* If you nest >1000 cancel scopes within each other, Trio now handles that
gracefully instead of crashing with a RecursionError.
* Fixed the hash behavior of trio.Path to match pathlib.Path. Previously
trio.Path's hash was inherited from object instead of from pathlib.PurePath.
OBS-URL: https://build.opensuse.org/package/show/devel:languages:python/python-trio?expand=0&rev=10
- version update to 0.12.1
Features
* If you have a `~trio.abc.ReceiveStream` object, you can now use
``async for data in stream: ...`` instead of calling
`~trio.abc.ReceiveStream.receive_some`. Each iteration gives an
arbitrary sized chunk of bytes. And the best part is, the loop
automatically exits when you reach EOF, so you don't have to check for
it yourself anymore. Relatedly, you no longer need to pick a magic
buffer size value before calling
`~trio.abc.ReceiveStream.receive_some`; you can ``await
stream.receive_some()`` with no arguments, and the stream will
automatically pick a reasonable size for you. (`#959 <https://github.com/python-trio/trio/issues/959>`__)
* Threading interfaces have been reworked:
``run_sync_in_worker_thread`` is now `trio.to_thread.run_sync`, and
instead of ``BlockingTrioPortal``, use `trio.from_thread.run` and
`trio.from_thread.run_sync`. What's neat about this is that these
cooperate, so if you're in a thread created by `to_thread.run_sync`,
it remembers which Trio created it, and you can call
``trio.from_thread.*`` directly without having to pass around a
``BlockingTrioPortal`` object everywhere. (`#810 <https://github.com/python-trio/trio/issues/810>`__)
* We cleaned up the distinction between the "abstract channel interface"
and the "memory channel" concrete implementation.
`trio.abc.SendChannel` and `trio.abc.ReceiveChannel` have been slimmed
down, `trio.MemorySendChannel` and `trio.MemoryReceiveChannel` are now
public types that can be used in type hints, and there's a new
`trio.abc.Channel` interface for future bidirectional channels. (`#719 <https://github.com/python-trio/trio/issues/719>`__)
* Add :func:`trio.run_process` as a high-level helper for running a process
and waiting for it to finish, like the standard :func:`subprocess.run` does. (`#822 <https://github.com/python-trio/trio/issues/822>`__)
* On Linux, when wrapping a bare file descriptor in a Trio socket object,
Trio now auto-detects the correct ``family``, ``type``, and ``protocol``.
OBS-URL: https://build.opensuse.org/request/show/721060
OBS-URL: https://build.opensuse.org/package/show/devel:languages:python/python-trio?expand=0&rev=8
