Release history¶
Trio 0.26.2 (2024-08-08)¶
Bugfixes¶
Remove remaining
hash
usage and fix test configuration issue that prevented it from being caught. (#3053)
Trio 0.26.1 (2024-08-05)¶
Bugfixes¶
Switched
attrs
usage off ofhash
, which is now deprecated. (#3053)
Miscellaneous internal changes¶
Use PyPI’s Trusted Publishers to make releases. (#2980)
Trio 0.26.0 (2024-07-05)¶
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 calltrio.run()
$ python -m trio Trio 0.21.0+dev, 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 withunwrapped=True
. This means that the behaviour of except* can be fully replicated in combination withflatten_subgroups=True
(formerlystrict=False
). (#2989)
Bugfixes¶
Fixed a bug where
trio.testing.RaisesGroup(..., strict=False)
would check the number of exceptions in the raisedExceptionGroup
before flattening subgroups, leading to incorrectly failed matches. It now properly supports end ($
) regex markers in thematch
message, by no longer including “ (x sub-exceptions)” in the string it matches against. (#2989)
Deprecations and removals¶
Deprecated
strict
parameter fromtrio.testing.RaisesGroup
, previous functionality ofstrict=False
is now inflatten_subgroups=True
. (#2989)
Trio 0.25.1 (2024-05-16)¶
Bugfixes¶
Fix crash when importing trio in embedded Python on Windows, and other installs that remove docstrings. (#2987)
Trio 0.25.0 (2024-03-17)¶
Breaking changes¶
The strict_exception_groups parameter now defaults to
True
intrio.run
andtrio.lowlevel.start_guest_run
.trio.open_nursery
still defaults to the same value as was specified intrio.run
/trio.lowlevel.start_guest_run
, but if you didn’t specify it there then all subsequent calls totrio.open_nursery
will change. This is unfortunately very tricky to change with a deprecation period, as raising aDeprecationWarning
whenever 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
orStopIteration
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 anExceptionGroup
. It previously could do this in very rare circumstances, but with strict_exception_groups set toTrue
it will now do so whenever exceptions occur indeliver_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 anExceptionGroup
is no longer added.
trio.TrioInternalError
.__cause__
might be wrapped in one or moreExceptionGroups
(#2786)
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 astrio.testing.wait_all_tasks_blocked
. (#2937)Path
is now a subclass ofpathlib.PurePath
, allowing it to interoperate with other standardpathlib
types.Instantiating
Path
now returns a concrete platform-specific subclass, one ofPosixPath
orWindowsPath
, matching the behavior ofpathlib.Path
. (#2959)
Bugfixes¶
The pthread functions are now correctly found on systems using vanilla versions of musl libc. (#2939)
Miscellaneous internal changes¶
use the regular readme for the PyPI long_description (#2866)
Trio 0.24.0 (2024-01-10)¶
Features¶
New helper classes:
RaisesGroup
andMatcher
.In preparation for changing the default of
strict_exception_groups
toTrue
, we’re introducing a set of helper classes that can be used in place of pytest.raises in tests, to check for an expectedExceptionGroup
. These are provisional, and only planned to be supplied until there’s a good solution inpytest
. See https://github.com/pytest-dev/pytest/issues/11538 (#2785)
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 usingexcept*
or catching ExceptionGroup/BaseExceptionGroup. (#2891)
Trio 0.23.2 (2023-12-14)¶
Features¶
TypeVarTuple is now used to fully type
nursery.start_soon()
,trio.run()
,trio.to_thread.run_sync()
, and other similar functions accepting(func, *args)
. This means type checkers will be able to verify types are used correctly.nursery.start()
is not fully typed yet however. (#2881)
Bugfixes¶
Make pyright recognize
open_memory_channel()
as generic. (#2873)
Miscellaneous internal changes¶
Trio 0.23.1 (2023-11-04)¶
Bugfixes¶
Don’t crash on import in Anaconda interpreters. (#2855)
Trio 0.23.0 (2023-11-03)¶
Headline features¶
Add type hints. (#543)
Features¶
When exiting a nursery block, the parent task always waits for child tasks to exit. This wait cannot be cancelled. However, previously, if you tried to cancel it, it would inject a
Cancelled
exception, even though it wasn’t cancelled. Most users probably never noticed either way, but injecting aCancelled
here is not really useful, and in some rare cases caused confusion or problems, so Trio no longer does that. (#1457)If called from a thread spawned by
trio.to_thread.run_sync
,trio.from_thread.run
andtrio.from_thread.run_sync
now reuse the task and cancellation status of the host task; this means that context variables and cancel scopes naturally propagate ‘through’ threads spawned by Trio. You can also usetrio.from_thread.check_cancelled
to efficiently check for cancellation without reentering the Trio thread. (#2392)trio.lowlevel.start_guest_run()
now does a bit more setup of the guest run before it returns to its caller, so that the caller can immediately make calls totrio.current_time()
,trio.lowlevel.spawn_system_task()
,trio.lowlevel.current_trio_token()
, etc. (#2696)
Bugfixes¶
When a starting function raises before calling
trio.TaskStatus.started()
,trio.Nursery.start()
will no longer wrap the exception in an undocumentedExceptionGroup
. Previously,trio.Nursery.start()
would incorrectly raise anExceptionGroup
containing it when usingtrio.run(..., strict_exception_groups=True)
. (#2611)
Deprecations and removals¶
To better reflect the underlying thread handling semantics, the keyword argument for
trio.to_thread.run_sync
that was previously calledcancellable
is now namedabandon_on_cancel
. It still does the same thing – allow the thread to be abandoned if the call totrio.to_thread.run_sync
is cancelled – but since we now have other ways to propagate a cancellation without abandoning the thread, “cancellable” has become somewhat of a misnomer. The oldcancellable
name is now deprecated. (#2841)Deprecated support for
math.inf
for thebacklog
argument inopen_tcp_listeners
, making its docstring correct in the fact that onlyTypeError
is raised if invalid arguments are passed. (#2842)
Removals without deprecations¶
Drop support for Python3.7 and PyPy3.7/3.8. (#2668)
Removed special
MultiError
traceback handling for IPython. As of version 8.15ExceptionGroup
is handled natively. (#2702)
Miscellaneous internal changes¶
Trio now indicates its presence to
sniffio
using thesniffio.thread_local
interface that is preferred since sniffio v1.3.0. This should be less likely than the previous approach to causesniffio.current_async_library()
to return incorrect results due to unintended inheritance of contextvars. (#2700)On windows, if SIO_BASE_HANDLE failed and SIO_BSP_HANDLE_POLL didn’t return a different socket, runtime error will now raise from the OSError that indicated the issue so that in the event it does happen it might help with debugging. (#2807)
Trio 0.22.2 (2023-07-13)¶
Bugfixes¶
Trio 0.22.1 (2023-07-02)¶
Breaking changes¶
Timeout functions now raise
ValueError
if passedmath.nan
. This includestrio.sleep
,trio.sleep_until
,trio.move_on_at
,trio.move_on_after
,trio.fail_at
andtrio.fail_after
. (#2493)
Features¶
Added support for naming threads created with
trio.to_thread.run_sync
, requires pthreads so is only available on POSIX platforms with glibc installed. (#1148)trio.socket.socket
now prints the address it tried to connect to upon failure. (#1810)
Bugfixes¶
Fixed a crash that can occur when running Trio within an embedded Python interpreter, by handling the
TypeError
that is raised when trying to (re-)install a C signal handler. (#2333)Fix
sniffio.current_async_library()
when Trio tasks are spawned from a non-Trio context (such as when using trio-asyncio). Previously, a regular Trio task would inherit the non-Trio library name, and spawning a system task would cause the non-Trio caller to start thinking it was Trio. (#2462)Issued a new release as in the git tag for 0.22.0,
trio.__version__
is incorrectly set to 0.21.0+dev. (#2485)
Improved documentation¶
Documented that
Nursery.start_soon
does not guarantee task ordering. (#970)
Trio 0.22.0 (2022-09-28)¶
Headline features¶
MultiError
has been deprecated in favor of the standardBaseExceptionGroup
(introduced in PEP 654). On Python versions below 3.11, this exception and its derivativeExceptionGroup
are provided by the backport. Trio still raisesMultiError
, but it has been refactored into a subclass ofBaseExceptionGroup
which users should catch instead ofMultiError
. Uses of theMultiError.filter()
class method should be replaced withBaseExceptionGroup.split()
. Uses of theMultiError.catch()
class method should be replaced with eitherexcept*
clauses (on Python 3.11+) or theexceptiongroup.catch()
context manager provided by the backport.See the updated documentation for details. (#2211)
Features¶
Added support for Datagram TLS, for secure communication over UDP. Currently requires PyOpenSSL. (#2010)
Trio 0.21.0 (2022-06-07)¶
Features¶
Deprecations and Removals¶
Remove support for Python 3.6. (#2210)
Trio 0.20.0 (2022-02-21)¶
Features¶
You can now conveniently spawn a child process in a background task and interact it with on the fly using
process = await nursery.start(run_process, ...)
. Seerun_process
for more details. We recommend most users switch to this new API. Also note that:trio.open_process
has been deprecated in favor oftrio.lowlevel.open_process
,The
aclose
method onProcess
has been deprecated along withasync with process_obj
. (#1104)
Now context variables set with
contextvars
are preserved when running functions in a worker thread withtrio.to_thread.run_sync
, or when running functions from the worker thread in the parent Trio thread withtrio.from_thread.run
, andtrio.from_thread.run_sync
. This is done by automatically copying thecontextvars
context.trio.lowlevel.spawn_system_task
now also receives an optionalcontext
argument. (#2160)
Bugfixes¶
Trio now avoids creating cyclic garbage when a
MultiError
is generated and filtered, including invisibly within the cancellation system. This means errors raised through nurseries and cancel scopes should result in less GC latency. (#2063)Trio now deterministically cleans up file descriptors that were opened before subprocess creation fails. Previously, they would remain open until the next run of the garbage collector. (#2193)
Add compatibility with OpenSSL 3.0 on newer Python and PyPy versions by working around
SSLEOFError
not being raised properly. (#2203)Fix a bug that could cause
Process.wait
to hang on Linux systems using pidfds, if another task were to accessProcess.returncode
after the process exited but beforewait
woke up (#2209)
Trio 0.19.0 (2021-06-15)¶
Features¶
Trio now supports Python 3.10. (#1921)
Use slots for
Task
which should make them slightly smaller and faster. (#1927)Make
Event
more lightweight by using less objects (about 2 rather than 5, including a nested ParkingLot and attribute dicts) and simpler structures (set rather than OrderedDict). This may benefit applications that create a large number of event instances, such as with the “replace event object on every set()” idiom. (#1948)
Bugfixes¶
Trio 0.18.0 (2021-01-11)¶
Features¶
Add synchronous
.close()
methods and context manager (with x
) support forMemorySendChannel
andMemoryReceiveChannel
. (#1797)
Bugfixes¶
Previously, on Windows, Trio programs using thousands of sockets at the same time could trigger extreme slowdowns in the Windows kernel. Now, Trio works around this issue, so you should be able to use as many sockets as you want. (#1280)
trio.from_thread.run()
no longer crashes the Trio run if it is executed after the system nursery has been closed but before the run has finished. Calls made at this time will now raisetrio.RunFinishedError
. This fixes a regression introduced in Trio 0.17.0. The window in question is only one scheduler tick long in most cases, but may be longer if async generators need to be cleaned up. (#1738)Fix a crash in pypy-3.7 (#1765)
Trio now avoids creating cyclic garbage as often. This should have a minimal impact on most programs, but can slightly reduce how often the cycle collector GC runs on CPython, which can reduce latency spikes. (#1770)
Deprecations and removals¶
Trio 0.17.0 (2020-09-15)¶
Headline features¶
Trio now supports automatic async generator finalization, so more async generators will work even if you don’t wrap them in
async with async_generator.aclosing():
blocks. Please see the documentation for important caveats; in particular, yielding within a nursery or cancel scope remains unsupported. (#265)
Features¶
trio.open_tcp_stream
has a newlocal_address=
keyword argument that can be used on machines with multiple IP addresses to control which IP is used for the outgoing connection. (#275)If you pass a raw IP address into
sendto
, it no longer spends any time trying to resolve the hostname. If you’re using UDP, this should substantially reduce your per-packet overhead. (#1595)trio.lowlevel.checkpoint
is now much faster. (#1613)We switched to a new, lower-overhead data structure to track upcoming timeouts, which should make your programs faster. (#1629)
Bugfixes¶
On macOS and BSDs, explicitly close our wakeup socketpair when we’re done with it. (#1621)
Trio can now be imported when
sys.excepthook
is afunctools.partial
instance, which might occur in apytest-qt
test function. (#1630)The thread cache didn’t release its reference to the previous job. (#1638)
On Windows, Trio now works around the buggy behavior of certain Layered Service Providers (system components that can intercept network activity) that are built on top of a commercially available library called Komodia Redirector. This benefits users of products such as Astrill VPN and Qustodio parental controls. Previously, Trio would crash on startup when run on a system where such a product was installed. (#1659)
Deprecations and removals¶
Remove
wait_socket_*
,notify_socket_closing
,notify_fd_closing
,run_sync_in_worker_thread
andcurrent_default_worker_thread_limiter
. They were deprecated in 0.12.0. (#1596)
Miscellaneous internal changes¶
When using instruments, you now only “pay for what you use”: if there are no instruments installed that override a particular hook such as
before_task_step()
, then Trio doesn’t waste any effort on checking its instruments when the event corresponding to that hook occurs. Previously, installing any instrument would incur all the instrumentation overhead, even for hooks no one was interested in. (#1340)
Trio 0.16.0 (2020-06-10)¶
Headline features¶
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. For details, see: Using “guest mode” to run Trio on top of other event loops. (#399)
Features¶
To speed up
trio.to_thread.run_sync
, Trio now caches and reuses worker threads.And in case you have some exotic use case where you need to spawn threads manually, but want to take advantage of Trio’s cache, you can do that using the new
trio.lowlevel.start_thread_soon
. (#6)Tasks spawned with
nursery.start()
aren’t treated as direct children of their nursery until they calltask_status.started()
. This is visible through the task tree introspection attributes such asTask.parent_nursery
. Sometimes, though, you want to know where the task is going to wind up, even if it hasn’t finished initializing yet. To support this, we added a new attributeTask.eventual_parent_nursery
. For a task spawned withstart()
that hasn’t yet calledstarted()
, this is the nursery that the task was nominally started in, where it will be running once it finishes starting up. In all other cases, it isNone
. (#1558)
Bugfixes¶
Added a helpful error message if an async function is passed to
trio.to_thread.run_sync
. (#1573)
Deprecations and removals¶
Remove
BlockingTrioPortal
: it was deprecated in 0.12.0. (#1574)The
tiebreaker
argument totrio.testing.wait_all_tasks_blocked
has been deprecated. This is a highly obscure feature that was probably never used by anyone excepttrio.testing.MockClock
, andMockClock
doesn’t need it anymore. (#1587)Remove the deprecated
trio.ssl
andtrio.subprocess
modules. (#1594)
Miscellaneous internal changes¶
We refactored
trio.testing.MockClock
so that it no longer needs to run an internal task to manage autojumping. This should be mostly invisible to users, but there is one semantic change: the interaction betweentrio.testing.wait_all_tasks_blocked
and the autojump clock was fixed. Now, the autojump will always wait until after allwait_all_tasks_blocked
calls have finished before firing, instead of it depending on which threshold values you passed. (#1587)
Trio 0.15.1 (2020-05-22)¶
Bugfixes¶
Fix documentation build. (This must be a new release tag to get readthedocs “stable” to include the changes from 0.15.0.)
Added a helpful error message if an async function is passed to
trio.from_thread.run_sync
or a sync function totrio.from_thread.run
. (#1244)
Trio 0.15.0 (2020-05-19)¶
Features¶
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 sendingSIGTERM
, and only escalates toSIGKILL
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 customdeliver_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)We’ve added FreeBSD to the list of platforms we support and test on. (#1118)
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 callpoll
orwait
. Also,repr(process_object)
now always contains up-to-date information about the process status. (#1315)
Bugfixes¶
On Ubuntu systems, the system Python includes a custom unhandled-exception hook to perform crash reporting. Unfortunately, Trio wants to use the same hook to print nice
MultiError
tracebacks, causing a conflict. Previously, Trio would detect the conflict, print a warning, and you just wouldn’t get niceMultiError
tracebacks. Now, Trio has gotten clever enough to integrate its hook with Ubuntu’s, so the two systems should Just Work together. (#1065)Fixed an over-strict test that caused failures on Alpine Linux. Started testing against Alpine in CI. (#1499)
Calling
open_signal_receiver
with no arguments used to succeed without listening for any signals. This was confusing, so now it raises TypeError instead. (#1526)
Deprecations and Removals¶
Remove support for Python 3.5. (#75)
It turns out that everyone got confused by the name
trio.hazmat
. So that name has been deprecated, and the new name istrio.lowlevel
. (#476)Most of the public classes that Trio exports – like
trio.Lock
,trio.SocketStream
, and so on – weren’t designed with subclassing in mind. And we’ve noticed that some users were trying to subclass them anyway, and ending up with fragile code that we’re likely to accidentally break in the future, or else be stuck unable to make changes for fear of breaking subclasses.There are also some classes that were explicitly designed to be subclassed, like the ones in
trio.abc
. Subclassing these is still supported. However, for all other classes, attempts to subclass will now raise a deprecation warning, and in the future will raise an error.If this causes problems for you, feel free to drop by our chat room or file a bug, to discuss alternatives or make a case for why some particular class should be designed to support subclassing. (#1044)
If you want to create a
trio.Process
object, you now have to calltrio.open_process
; callingtrio.Process()
directly was deprecated in v0.12.0 and has now been removed. (#1109)Remove
clear
method ontrio.Event
: it was deprecated in 0.12.0. (#1498)
Trio 0.14.0 (2020-04-27)¶
Features¶
If you’re using Trio’s low-level interfaces like
trio.hazmat.wait_readable
or similar, and then you close a socket or file descriptor, you’re supposed to calltrio.hazmat.notify_closing
first so Trio can clean up properly. But what if you forget? In the past, Trio would tend to either deadlock or explode spectacularly. Now, it’s much more robust to this situation, and should generally survive. (But note that “survive” is not the same as “give you the results you were expecting”, so you should still callnotify_closing
when appropriate. This is about harm reduction and making it easier to debug this kind of mistake, not something you should rely on.)If you’re using higher-level interfaces outside of the
trio.hazmat
module, then you don’t need to worry about any of this; those interfaces already take care of callingnotify_closing
for you. (#1272)
Bugfixes¶
A bug related to the following methods has been introduced in version 0.12.0:
The iteration of the blocking generators produced by pathlib was performed in the trio thread. With this fix, the previous behavior is restored: the blocking generators are converted into lists in a thread dedicated to blocking IO calls. (#1308)
Deprecations and Removals¶
Trio 0.13.0 (2019-11-02)¶
Features¶
On Windows, the IOCP subsystem is generally the best way to implement async I/O operations – but it’s historically been weak at providing
select
-style readiness notifications, liketrio.hazmat.wait_readable
andwait_writable
. We aren’t willing to give those up, so previously Trio’s Windows backend used a hybrid ofselect
+ IOCP. This was complex, slow, and had limited scalability.Fortunately, we found a way to implement
wait_*
with IOCP, so Trio’s Windows backend has been completely rewritten, and now uses IOCP exclusively. As a user, the only difference you should notice is that Trio should now be faster on Windows, and can handle many more sockets. This also simplified the code internally, which should allow for more improvements in the future.However, this is somewhat experimental, so if you use Windows then please keep an eye out and let us know if you run into any problems! (#52)
Use slots for memory channel state and statistics which should make memory channels slightly smaller and faster. (#1195)
Bugfixes¶
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. (Upstream bug reports: openssl/openssl#7948, openssl/openssl#7967.)
trio.SSLStream
now works around this issue, so you don’t have to worry about it. (#819)Trio now uses
signal.set_wakeup_fd
on all platforms. This is mostly an internal refactoring with no user-visible effect, but in theory it should fix a few extremely-rare race conditions on Unix that could have caused signal delivery to be delayed. (#109)Trio no longer crashes when an async function is implemented in C or Cython and then passed directly to
trio.run
ornursery.start_soon
. (#550, #1191)When a Trio task makes improper use of a non-Trio async library, Trio now 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 oftrio.to_thread.run_sync
. But, the deprecation message listed the wrong name for the replacement. The message now gives the correct name. (#810)Fix regression introduced with cancellation changes in 0.12.0, where a
trio.CancelScope
which isn’t cancelled could catch a propagatingtrio.Cancelled
exception if shielding were changed while the cancellation was propagating. (#1175)Fix a crash that could happen when using
MockClock
with autojump enabled and a non-zero rate. (#1190)If you nest >1000 cancel scopes within each other, Trio now handles that gracefully instead of crashing with a
RecursionError
. (#1235)Fixed the hash behavior of
trio.Path
to matchpathlib.Path
. Previouslytrio.Path
’s hash was inherited fromobject
instead of frompathlib.PurePath
. Thus, hashing twotrio.Path
's or atrio.Path
and apathlib.Path
with the same underlying path would yield different results. (#1259)
Trio 0.12.1 (2019-08-01)¶
Bugfixes¶
In v0.12.0, we accidentally moved
BlockingTrioPortal
fromtrio
totrio.hazmat
. It’s now been restored to its proper position. (It’s still deprecated though, and will issue a warning if you use it.) (#1167)
Trio 0.12.0 (2019-07-31)¶
Features¶
If you have a
ReceiveStream
object, you can now useasync for data in stream: ...
instead of callingreceive_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 callingreceive_some
; you canawait stream.receive_some()
with no arguments, and the stream will automatically pick a reasonable size for you. (#959)Threading interfaces have been reworked:
run_sync_in_worker_thread
is nowtrio.to_thread.run_sync
, and instead ofBlockingTrioPortal
, usetrio.from_thread.run
andtrio.from_thread.run_sync
. What’s neat about this is that these cooperate, so if you’re in a thread created byto_thread.run_sync
, it remembers which Trio created it, and you can calltrio.from_thread.*
directly without having to pass around aBlockingTrioPortal
object everywhere. (#810)We cleaned up the distinction between the “abstract channel interface” and the “memory channel” concrete implementation.
trio.abc.SendChannel
andtrio.abc.ReceiveChannel
have been slimmed down,trio.MemorySendChannel
andtrio.MemoryReceiveChannel
are now public types that can be used in type hints, and there’s a newtrio.abc.Channel
interface for future bidirectional channels. (#719)Add
trio.run_process()
as a high-level helper for running a process and waiting for it to finish, like the standardsubprocess.run()
does. (#822)On Linux, when wrapping a bare file descriptor in a Trio socket object, Trio now auto-detects the correct
family
,type
, andprotocol
. This is useful, for example, when implementing systemd socket activation. (#251)Trio sockets have a new method
is_readable
that allows you to check whether a socket is readable. This is useful for HTTP/1.1 clients. (#760)We no longer use runtime code generation to dispatch core functions like
current_time
. Static analysis tools like mypy and pylint should now be able to recognize and analyze all of Trio’s top-level functions (though some class attributes are still dynamic… we’re working on it). (#805)Add
trio.hazmat.FdStream
for wrapping a Unix file descriptor as aStream
. (#829)Trio now gives a reasonable traceback and error message in most cases when its invariants surrounding cancel scope nesting have been violated. (One common source of such violations is an async generator that yields within a cancel scope.) The previous behavior was an inscrutable chain of TrioInternalErrors. (#882)
MultiError
now defines itsexceptions
attribute in__init__()
to better support linters and code autocompletion. (#1066)Use
__slots__
in more places internally, which should make Trio slightly faster. (#984)
Bugfixes¶
Destructor methods (
__del__
) are now protected againstKeyboardInterrupt
. (#676)The
trio.Path
methodsglob()
andrglob()
now return iterables oftrio.Path
(notpathlib.Path
). (#917)Inspecting the
cancel_called
attribute of a not-yet-exited cancel scope whose deadline is in the past now always returnsTrue
, like you might expect. (Previously it would returnFalse
for not-yet-entered cancel scopes, and for active cancel scopes until the first checkpoint after their deadline expiry.) (#958)The
trio.Path
classmethods,home()
andcwd()
, are now async functions. Previously, a bug in the forwarding logic meantcwd()
was synchronous andhome()
didn’t work at all. (#960)An exception encapsulated within a
MultiError
doesn’t need to be hashable anymore.Note
This is only supported if you are running python >= 3.6.4. You can refer to this github PR for details. (#1005)
Improved Documentation¶
To help any user reading through Trio’s function implementations, start using public names (not _core) whenever possible. (#1017)
Deprecations and Removals¶
The
clear
method ontrio.Event
has been deprecated. (#637)BlockingTrioPortal
has been deprecated in favor of the newtrio.from_thread
. (#810)run_sync_in_worker_thread
is deprecated in favor oftrio.to_thread.run_sync
. (#810)current_default_worker_thread_limiter
is deprecated in favor oftrio.to_thread.current_default_thread_limiter
. (#810)Give up on trying to have different low-level waiting APIs on Unix and Windows. All platforms now have
trio.hazmat.wait_readable
,trio.hazmat.wait_writable
, andtrio.hazmat.notify_closing
. The old platform-specific synonymswait_socket_*
,notify_socket_closing
, andnotify_fd_closing
have been deprecated. (#878)It turns out that it’s better to treat subprocess spawning as an async operation. Therefore, direct construction of
Process
objects has been deprecated. Usetrio.open_process
instead. (#1109)
Miscellaneous internal changes¶
The plumbing of Trio’s cancellation system has been substantially overhauled to improve performance and ease future planned improvements. Notably, there is no longer any internal concept of a “cancel stack”, and checkpoints now take constant time regardless of the cancel scope nesting depth. (#58)
We’ve slightly relaxed our definition of which Trio operations act as checkpoints. A Trio async function that exits by throwing an exception is no longer guaranteed to execute a checkpoint; it might or might not. The rules are unchanged for async functions that don’t exit with an exception, async iterators, and async context managers.
trio.testing.assert_checkpoints()
has been updated to reflect the new behavior: if itswith
block exits with an exception, no assertion is made. (#474)Calling
str
on atrio.Cancelled
exception object returns “Cancelled” instead of an empty string. (#674)Change the default timeout in
trio.open_tcp_stream()
to 0.250 seconds, for consistency with RFC 8305. (#762)On win32 we no longer set SO_EXCLUSIVEADDRUSE when binding a socket in
trio.open_tcp_listeners
. (#928)Any attempt to inherit from
CancelScope
orNursery
now raisesTypeError
. (Trio has never been able to safely support subclassing here; this change just makes it more obvious.) Also exposed as public classes for type-checking, etc. (#1021)
Trio 0.11.0 (2019-02-09)¶
Features¶
Add support for “unbound cancel scopes”: you can now construct a
trio.CancelScope
without entering its context, e.g., so you can pass it to another task which will use it to wrap some work that you want to be able to cancel from afar. (#607)The test suite now passes with openssl v1.1.1. Unfortunately this required temporarily disabling TLS v1.3 during tests; see openssl bugs #7948 and #7967. We believe TLS v1.3 should work in most real use cases, but will be monitoring the situation. (#817)
Add
trio.Process.stdio
, which is aStapledStream
ofstdin
andstdout
if both of those are available, andNone
otherwise. This is intended to make it more ergonomic to speak a back-and-forth protocol with a subprocess. (#862)trio.Process
on POSIX systems no longer accepts the error-prone combination ofshell=False
with acommand
that’s a single string, orshell=True
with acommand
that’s a sequence of strings. These forms are accepted by the underlyingsubprocess.Popen
constructor but don’t do what most users expect. Also, added an explanation of quoting to the documentation. (#863)Added an internal mechanism for pytest-trio’s Hypothesis integration to make the task scheduler reproducible and avoid flaky tests. (#890)
SendChannel
,ReceiveChannel
,Listener
, andopen_memory_channel()
can now be referenced using a generic type parameter (the type of object sent over the channel or produced by the listener) using PEP 484 syntax:trio.abc.SendChannel[bytes]
,trio.abc.Listener[trio.SocketStream]
,trio.open_memory_channel[MyMessage](5)
, etc. The added type information does not change the runtime semantics, but permits better integration with external static type checkers. (#908)
Bugfixes¶
Fixed several bugs in the new Unix subprocess pipe support, where (a) operations on a closed pipe could accidentally affect another unrelated pipe due to internal file-descriptor reuse, (b) in very rare circumstances, two tasks calling
send_all
on the same pipe at the same time could end up with intermingled data instead of aBusyResourceError
. (#661)Stop
trio.open_tcp_listeners()
from crashing on systems that have disabled IPv6. (#853)Fixed support for multiple tasks calling
trio.Process.wait()
simultaneously; on kqueue platforms it would previously raise an exception. (#854)trio.Cancelled
exceptions now always propagate until they reach the outermost unshielded cancelled scope, even if more cancellations occur or shielding is changed between when theCancelled
is delivered and when it is caught. (#860)If you have a
SocketStream
that’s already been closed, thenawait socket_stream.send_all(b"")
will now correctly raiseClosedResourceError
. (#874)Simplified the Windows subprocess pipe
send_all
code, and in the process fixed a theoretical bug where closing a pipe at just the wrong time could produce errors or cause data to be redirected to the wrong pipe. (#883)
Deprecations and Removals¶
Deprecate
trio.open_cancel_scope
in favor oftrio.CancelScope
, which more clearly reflects that creating a cancel scope is just an ordinary object construction and does not need to be immediately paired with entering it. (#607)The submodules
trio.ssl
andtrio.subprocess
are now deprecated. Their nontrivial contents (Process
,SSLStream
, andSSLListener
) have been moved to the maintrio
namespace. For the numerous constants, exceptions, and other helpers that were previously reexported from the standardssl
andsubprocess
modules, you should now use those modules directly. (#852)Remove all the APIs deprecated in 0.9.0 or earlier (
trio.Queue
,trio.catch_signals()
,trio.BrokenStreamError
, andtrio.ResourceBusyError
), except fortrio.hazmat.UnboundedQueue
, which stays for now since it is used by the obscure lowlevel functionsmonitor_completion_queue()
andmonitor_kevent()
. (#918)
Miscellaneous internal changes¶
Trio 0.10.0 (2019-01-07)¶
Features¶
Initial subprocess support. Add
trio.subprocess.Process
, an async wrapper around the stdlibsubprocess.Popen
class, which permits spawning subprocesses and communicating with them over standard Trio streams.trio.subprocess
also reexports all the stdlibsubprocess
exceptions and constants for convenience. (#4)You can now create an unbounded
CapacityLimiter
by initializing withmath.inf
(#618)New
trio.hazmat
features to allow cleanly switching live coroutine objects between Trio and other coroutine runners. Frankly, we’re not even sure this is a good idea, but we want to try it out in trio-asyncio, so here we are. For details see Handing off live coroutine objects between coroutine runners. (#649)
Bugfixes¶
Fixed a race condition on macOS, where Trio’s TCP listener would crash if an incoming TCP connection was closed before the listener had a chance to accept it. (#609)
trio.open_tcp_stream()
has been refactored to clean up unsuccessful connection attempts more reliably. (#809)
Deprecations and Removals¶
Remove the APIs deprecated in 0.5.0. (
ClosedStreamError
,ClosedListenerError
,Result
) (#812)
Miscellaneous internal changes¶
There are a number of methods on
trio.ssl.SSLStream
that report information about the negotiated TLS connection, likeselected_alpn_protocol
, and thus cannot succeed until after the handshake has been performed. Previously, we returned None from these methods, like the stdlibssl
module does, but this is confusing, because that can also be a valid return value. Now we raisetrio.ssl.NeedHandshakeError
instead. (#735)
Trio 0.9.0 (2018-10-12)¶
Features¶
New and improved APIs for inter-task communication:
trio.abc.SendChannel
,trio.abc.ReceiveChannel
, andtrio.open_memory_channel()
(which replacestrio.Queue
). This interface uses separate “sender” and “receiver” objects, for consistency with other communication interfaces likeStream
. Also, the two objects can now be closed individually, making it much easier to gracefully shut down a channel. Also, check out the niftyclone
API to make it easy to manage shutdown in multiple-producer/multiple-consumer scenarios. Also, the API has been written to allow for future channel implementations that send objects across process boundaries. Also, it supports unbounded buffering if you really need it. Also, help I can’t stop writing also. See Using channels to pass values between tasks for more details. (#497)
Deprecations and Removals¶
trio.Queue
andtrio.hazmat.UnboundedQueue
have been deprecated, in favor oftrio.open_memory_channel()
. (#497)
Trio 0.8.0 (2018-10-01)¶
Features¶
Trio’s default internal clock is now based on
time.perf_counter()
instead oftime.monotonic()
. This makes time-keeping more precise on Windows, and has no effect on other platforms. (#33)Reworked
trio
,trio.testing
, andtrio.socket
namespace construction, making them more understandable by static analysis tools. This should improve tab completion in editors, reduce false positives from pylint, and is a first step towards providing type hints. (#542)
Deprecations and Removals¶
ResourceBusyError
is now a deprecated alias for the newBusyResourceError
, andBrokenStreamError
is a deprecated alias for the newBrokenResourceError
. (#620)
Trio 0.7.0 (2018-09-03)¶
Features¶
The length of typical exception traces coming from Trio has been greatly reduced. This was done by eliminating many of the exception frames related to details of the implementation. For examples, see the blog post. (#56)
New and improved signal catching API:
open_signal_receiver()
. (#354)The low level
trio.hazmat.wait_socket_readable
,wait_socket_writable
, andnotify_socket_close
now work on bare socket descriptors, instead of requiring asocket.socket()
object. (#400)If you’re using
trio.hazmat.wait_task_rescheduled
and other low-level routines to implement a new sleeping primitive, you can now use the newtrio.hazmat.Task.custom_sleep_data
attribute to pass arbitrary data between the sleeping task, abort function, and waking task. (#616)
Bugfixes¶
Prevent crashes when used with Sentry (raven-python). (#599)
The nursery context manager was rewritten to avoid use of
@asynccontextmanager
and@async_generator
. This reduces extraneous frames in exception traces and addresses bugs regardingStopIteration
andStopAsyncIteration
exceptions not propagating correctly. (#612)Updates the formatting of exception messages raised by
trio.open_tcp_stream()
to correctly handle a hostname passed in as bytes, by converting the hostname to a string. (#633)
Deprecations and Removals¶
trio.catch_signals
has been deprecated in favor ofopen_signal_receiver()
. The main differences are: it takes *-args now to specify the list of signals (soopen_signal_receiver(SIGINT)
instead ofcatch_signals({SIGINT})
), and, the async iterator now yields individual signals, instead of “batches” (#354)Remove all the APIs deprecated in 0.3.0 and 0.4.0. (#623)
Trio 0.6.0 (2018-08-13)¶
Features¶
Add
trio.hazmat.WaitForSingleObject
async function to await Windows handles. (#233)The sniffio library can now detect when Trio is running. (#572)
Bugfixes¶
Make trio.socket._SocketType.connect always close the socket on cancellation (#247)
Fix a memory leak in
trio.CapacityLimiter
, that could occur whenacquire
oracquire_on_behalf_of
was cancelled. (#548)Some version of macOS have a buggy
getaddrinfo
that was causing spurious test failures; we now detect those systems and skip the relevant test when found. (#580)Prevent crashes when used with Sentry (raven-python). (#599)
Trio 0.5.0 (2018-07-20)¶
Features¶
Suppose one task is blocked trying to use a resource – for example, reading from a socket – and while it’s doing this, another task closes the resource. Previously, this produced undefined behavior. Now, closing a resource causes pending operations on that resource to terminate immediately with a
ClosedResourceError
.ClosedStreamError
andClosedListenerError
are now aliases forClosedResourceError
, and deprecated. For this to work, Trio needs to know when a resource has been closed. To facilitate this, new functions have been added:trio.hazmat.notify_fd_close
andtrio.hazmat.notify_socket_close
. If you’re using Trio’s built-in wrappers likeSocketStream
ortrio.socket
, then you don’t need to worry about this, but if you’re using the low-level functions liketrio.hazmat.wait_readable
, you should make sure to call these functions at appropriate times. (#36)Tasks created by
spawn_system_task()
now no longer inherit the creator’scontextvars
context, instead using one created atrun()
. (#289)Add support for
trio.Queue
withcapacity=0
. Queue’s implementation is also faster now. (#473)Switch to using standalone Outcome library for Result objects. (#494)
Deprecations and Removals¶
trio.hazmat.Result
,trio.hazmat.Value
andtrio.hazmat.Error
have been replaced by the equivalent classes in the Outcome library.
Trio 0.4.0 (2018-04-10)¶
Features¶
Add unix client socket support. (#401)
Add support for
contextvars
(see task-local storage), and addtrio.hazmat.RunVar
as a similar API for run-local variables. Deprecatetrio.TaskLocal
andtrio.hazmat.RunLocal
in favor of these new APIs. (#420)Add
trio.hazmat.current_root_task
to get the root task. (#452)
Bugfixes¶
Fix KeyboardInterrupt handling when threading state has been modified by a 3rd-party library. (#461)
Deprecations and Removals¶
Attempting to explicitly raise
trio.Cancelled
will cause aRuntimeError
.cancel_scope.cancel()
should be used instead. (#342)
Miscellaneous internal changes¶
Simplify implementation of primitive traps like
wait_task_rescheduled()
(#395)
Trio 0.3.0 (2017-12-28)¶
Features¶
Simplified nurseries: In Trio, the rule used to be that “parenting is a full time job”, meaning that after a task opened a nursery and spawned some children into it, it had to immediately block in
__aexit__
to supervise the new children, or else exception propagation wouldn’t work. Also there was some elaborate machinery to let you replace this supervision logic with your own custom supervision logic. Thanks to new advances in task-rearing technology, parenting is no longer a full time job! Now the supervision happens automatically in the background, and essentially the body of aasync with trio.open_nursery()
block acts just like a task running inside the nursery. This is important: it makes it possible for libraries to abstract over nursery creation. For example, if you have a Websocket library that needs to run a background task to handle Websocket pings, you can now do that withasync with open_websocket(...) as ws: ...
, and that can run a task in the background without your users having to worry about parenting it. And don’t worry, you can still make custom supervisors; it turned out all that spiffy machinery was actually redundant and didn’t provide much value. (#136)Trio socket methods like
bind
andconnect
no longer require “pre-resolved” numeric addresses; you can now pass regular hostnames and Trio will implicitly resolve them for you. (#377)
Bugfixes¶
Fixed some corner cases in Trio socket method implicit name resolution to better match stdlib behavior. Example:
sock.bind(("", port))
now binds to the wildcard address instead of raising an error. (#277)
Deprecations and Removals¶
Removed everything that was deprecated in 0.2.0; see the 0.2.0 release notes below for details.
As was foretold in the v0.2.0 release notes, the
bind
method on Trio sockets is now async. Please update your calls or – better yet – switch to our shiny new high-level networking API, likeserve_tcp()
. (#241)The
resolve_local_address
andresolve_remote_address
methods on Trio sockets have been deprecated; these are unnecessary now that you can just pass your hostnames directly to the socket methods you want to use. (#377)
Trio 0.2.0 (2017-12-06)¶
Trio 0.2.0 contains changes from 14 contributors, and brings major new features and bug fixes, as well as a number of deprecations and a very small number of backwards incompatible changes. We anticipate that these should be easy to adapt to, but make sure to read about them below, and if you’re using Trio then remember to read and subscribe to issue #1.
Highlights¶
Added a comprehensive API for async filesystem I/O: see Asynchronous filesystem I/O (gh-20)
The new nursery
start()
method makes it easy to perform controlled start-up of long-running tasks. For example, given an appropriatehttp_server_on_random_open_port
function, you could write:port = await nursery.start(http_server_on_random_open_port)
and this would start the server running in the background in the nursery, and then give you back the random port it selected – but not until it had finished initializing and was ready to accept requests!
Added a new abstract API for byte streams, and
trio.testing
gained helpers for creating fake streams for testing your protocol implementation and checking that your custom stream implementation follows the stream contract.If you’re currently using
trio.socket
then you should switch to using our new high-level networking API instead. It takes care of many tiresome details, it’s fully integrated with the abstract stream API, and it provides niceties like a state-of-the-art Happy Eyeballs implementation inopen_tcp_stream()
and server helpers that integrate withnursery.start
.We’ve also added comprehensive support for SSL/TLS encryption, including SNI (both client and server side), STARTTLS, renegotiation during full-duplex usage (subject to OpenSSL limitations), and applying encryption to arbitrary
Stream
s, which allows for interesting applications like TLS-over-TLS. See:trio.open_ssl_over_tcp_stream()
,trio.serve_ssl_over_tcp()
,trio.open_ssl_over_tcp_listeners()
, andtrio.ssl
.Interesting fact: the test suite for
trio.ssl
has so far found bugs in CPython’s ssl module, PyPy’s ssl module, PyOpenSSL, and OpenSSL. (trio.ssl
doesn’t use PyOpenSSL.) Trio’s test suite is fairly thorough.You know thread-local storage? Well, Trio now has an equivalent: task-local storage. There’s also the related, but more obscure, run-local storage; see
RunLocal
. (#2)Added a new guide to for contributors.
Breaking changes and deprecations¶
Trio is a young and ambitious project, but it also aims to become a stable, production-quality foundation for async I/O in Python. Therefore, our approach for now is to provide deprecation warnings where-ever possible, but on a fairly aggressive cycle as we push towards stability. If you use Trio you should read and subscribe to issue #1. We’d also welcome feedback on how this approach is working, whether our deprecation warnings could be more helpful, or anything else.
The tl;dr is: stop using socket.bind
if you can, and then fix
everything your test suite warns you about.
Upcoming breaking changes without warnings (i.e., stuff that works in 0.2.0, but won’t work in 0.3.0):
In the next release, the
bind
method on Trio socket objects will become async (#241). Unfortunately, there’s no good way to provide a warning here. We recommend switching to the new highlevel networking APIs likeserve_tcp()
, which will insulate you from this change.
Breaking changes (i.e., stuff that could theoretically break a program that worked on 0.1.0):
trio.socket
no longer attempts to normalize or modernize socket options across different platforms. The high-level networking API now handles that, freeingtrio.socket
to focus on giving you raw, unadulterated BSD sockets.When a socket
sendall
call was cancelled, it used to attach some metadata to the exception reporting how much data was actually sent. It no longer does this, because in common configurations like anSSLStream
wrapped around aSocketStream
it becomes ambiguous which “level” the partial metadata applies to, leading to confusion and bugs. There is no longer any way to tell how much data was sent after asendall
is cancelled.The
trio.socket.getprotobyname()
function is now async, like it should have been all along. I doubt anyone will ever use it, but that’s no reason not to get the details right.The
trio.socket
functionsgetservbyport
,getservbyname
, andgetfqdn
have been removed, because they were obscure, buggy, and obsolete. Usegetaddrinfo()
instead.
Upcoming breaking changes with warnings (i.e., stuff that in 0.2.0 will work but will print loud complaints, and that won’t work in 0.3.0):
For consistency with the new
start
method, the nurseryspawn
method is being renamed tostart_soon
(#284)trio.socket.sendall
is deprecated; usetrio.open_tcp_stream
andSocketStream.send_all
instead (#291)Trio now consistently uses
run
for functions that take and run an async function (liketrio.run()
!), andrun_sync
for functions that take and run a synchronous function. As part of this:run_in_worker_thread
is becomingrun_sync_in_worker_thread
We took the opportunity to refactor
run_in_trio_thread
andawait_in_trio_thread
into the new classtrio.BlockingTrioPortal
The hazmat function
current_call_soon_thread_and_signal_safe
is being replaced bytrio.hazmat.TrioToken
See #68 for details.
trio.Queue
'sjoin
andtask_done
methods are deprecated without replacement (#321)Trio 0.1.0 provided a set of built-in mechanisms for waiting for and tracking the result of individual tasks. We haven’t yet found any cases where using this actually led to simpler code, though, and this feature is blocking useful improvements, so the following are being deprecated without replacement:
nursery.zombies
nursery.monitor
nursery.reap
nursery.reap_and_unwrap
task.result
task.add_monitor
task.discard_monitor
task.wait
This also lets us move a number of lower-level features out of the main
trio
namespace and intotrio.hazmat
:trio.Task
→trio.hazmat.Task
trio.current_task
→trio.hazmat.current_task
trio.Result
→trio.hazmat.Result
trio.Value
→trio.hazmat.Value
trio.Error
→trio.hazmat.Error
trio.UnboundedQueue
→trio.hazmat.UnboundedQueue
In addition, several introspection attributes are being renamed:
nursery.children
→nursery.child_tasks
task.parent_task
→ usetask.parent_nursery.parent_task
instead
See #136 for more details.
To consolidate introspection functionality in
trio.hazmat
, the following functions are moving:trio.current_clock
→trio.hazmat.current_clock
trio.current_statistics
→trio.hazmat.current_statistics
See #317 for more details.
It was decided that 0.1.0’s “yield point” terminology was confusing; we now use “checkpoint” instead. As part of this, the following functions in
trio.hazmat
are changing names:yield_briefly
→~trio.hazmat.checkpoint
yield_briefly_no_cancel
→cancel_shielded_checkpoint()
yield_if_cancelled
→checkpoint_if_cancelled()
yield_indefinitely
→wait_task_rescheduled()
In addition, the following functions in
trio.testing
are changing names:assert_yields
→assert_checkpoints()
assert_no_yields
→assert_no_checkpoints()
See #157 for more details.
trio.format_exception
is deprecated; usetraceback.format_exception()
instead (#347).trio.current_instruments
is deprecated. For adding or removing instrumentation at run-time, seetrio.hazmat.add_instrument
andtrio.hazmat.remove_instrument
(#257)
Unfortunately, a limitation in PyPy3 5.8 breaks our deprecation handling for some renames. (Attempting to use the old names will give an unhelpful error instead of a helpful warning.) This does not affect CPython, or PyPy3 5.9+.
Other changes¶
run_sync_in_worker_thread
now has a robust mechanism for applying capacity limits to the number of concurrent threads (#10, #57, #156)New support for tests to cleanly hook hostname lookup and socket operations: see Virtual networking for testing. In addition,
trio.socket.SocketType
is now an empty abstract base class, with the actual socket class made private. This shouldn’t effect anyone, since the only thing you could directly use it for in the first place wasisinstance
checks, and those still work (#170)New class
StrictFIFOLock
New exception
ResourceBusyError
The
trio.hazmat.ParkingLot
class (which is used to implement many of Trio’s synchronization primitives) was rewritten to be simpler and faster (#272, #287)It’s generally true that if you’re using Trio you have to use Trio functions, if you’re using asyncio you have to use asyncio functions, and so forth. (See the discussion of the “async sandwich” in the Trio tutorial for more details.) So for example, this isn’t going to work:
async def main(): # asyncio here await asyncio.sleep(1) # trio here trio.run(main)
Trio now reliably detects if you accidentally do something like this, and gives a helpful error message.
Trio now also has special error messages for several other common errors, like doing
trio.run(some_func())
(should betrio.run(some_func)
).trio.socket
now handles non-ascii domain names using the modern IDNA 2008 standard instead of the obsolete IDNA 2003 standard (#11)When an
Instrument
raises an unexpected error, we now route it through thelogging
module instead of printing it directly to stderr. Normally this produces exactly the same effect, but this way it’s more configurable. (#306)Fixed a minor race condition in IOCP thread shutdown on Windows (#81)
Control-C handling on Windows now uses
signal.set_wakeup_fd()
and should be more reliable (#42)trio.run()
takes a new keyword argumentrestrict_keyboard_interrupt_to_checkpoints
New attributes allow more detailed introspection of the task tree:
nursery.child_tasks
,Task.child_nurseries
,nursery.parent_task
,Task.parent_nursery
trio.testing.wait_all_tasks_blocked()
now takes atiebreaker=
argument. The main use is to allowMockClock
's auto-jump functionality to avoid interfering with direct use ofwait_all_tasks_blocked()
in the same test.MultiError.catch()
now correctly preserves__context__
, despite Python’s best attempts to stop us (#165)It is now possible to take weakrefs to
Lock
and many other classes (#331)Fix
sock.accept()
for IPv6 sockets (#164)PyCharm (and hopefully other IDEs) can now offer better completions for the
trio
andtrio.hazmat
modules (#314)Trio now uses yapf to standardize formatting across the source tree, so we never have to think about whitespace again.
Many documentation improvements
Trio 0.1.0 (2017-03-10)¶
Initial release.