Release history

Trio 0.16.0+dev (not released yet)


  • trio.open_tcp_stream has a new local_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)


  • 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 a functools.partial instance, which might occur in a pytest-qt test function. (#1630)

  • The thread cache didn’t release its reference to the previous job. (#1638)

Deprecations and removals

  • Remove wait_socket_*, notify_socket_closing, notify_fd_closing, run_sync_in_worker_thread and current_default_worker_thread_limiter. They were deprecated in 0.12.0. (#1596)

Trio 0.16.0 (2020-06-10)

Headline features


  • To speed up trio.to_thread.run_sync, Trio now caches and re-uses 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 call task_status.started(). This is visible through the task tree introspection attributes such as Task.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 attribute Task.eventual_parent_nursery. For a task spawned with start() that hasn’t yet called started(), 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 is None. (#1558)


Deprecations and removals

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 between trio.testing.wait_all_tasks_blocked and the autojump clock was fixed. Now, the autojump will always wait until after all wait_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)


  • 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 to (#1244)

Trio 0.15.0 (2020-05-19)


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

  • 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 call poll or wait. Also, repr(process_object) now always contains up-to-date information about the process status. (#1315)


  • 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 nice MultiError 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 is trio.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 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 call trio.open_process; calling trio.Process() directly was deprecated in v0.12.0 and has now been removed. (#1109)

  • Remove clear method on trio.Event: it was deprecated in 0.12.0. (#1498)

Trio 0.14.0 (2020-04-27)


  • 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 call trio.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 call notify_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 intefaces already take care of calling notify_closing for you. (#1272)


  • 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

  • Deprecate Python 3.5 (#1408)

  • Remove trio.open_cancel_scope which was deprecated in 0.11.0. (#1458)

Trio 0.13.0 (2019-11-02)


  • 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, like trio.hazmat.wait_readable and wait_writable. We aren’t willing to give those up, so previously Trio’s Windows backend used a hybrid of select + 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)


  • 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 or nursery.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 of trio.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 propagating trio.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 match pathlib.Path. Previously trio.Path’s hash was inherited from object instead of from pathlib.PurePath. Thus, hashing two trio.Path's or a trio.Path and a pathlib.Path with the same underlying path would yield different results. (#1259)

Trio 0.12.1 (2019-08-01)


  • In v0.12.0, we accidentally moved BlockingTrioPortal from trio to trio.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)


  • If you have a ReceiveStream object, you can now use async for data in stream: ... instead of calling 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 receive_some; you can await 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 now trio.to_thread.run_sync, and instead of BlockingTrioPortal, use 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)

  • We cleaned up the distinction between the “abstract channel interface” and the “memory channel” concrete implementation. and 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 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 standard does. (#822)

  • On Linux, when wrapping a bare file descriptor in a Trio socket object, Trio now auto-detects the correct family, type, and protocol. 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 a Stream. (#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 its exceptions attribute in __init__() to better support linters and code autocompletion. (#1066)

  • Use __slots__ in more places internally, which should make Trio slightly faster. (#984)


  • Destructor methods (__del__) are now protected against KeyboardInterrupt. (#676)

  • The trio.Path methods glob() and rglob() now return iterables of trio.Path (not pathlib.Path). (#917)

  • Inspecting the cancel_called attribute of a not-yet-exited cancel scope whose deadline is in the past now always returns True, like you might expect. (Previously it would return False 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() and cwd(), are now async functions. Previously, a bug in the forwarding logic meant cwd() was synchronous and home() didn’t work at all. (#960)

  • An exception encapsulated within a MultiError doesn’t need to be hashable anymore.


    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

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 its with block exits with an exception, no assertion is made. (#474)

  • Calling str on a trio.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 or Nursery now raises TypeError. (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)


  • 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 a StapledStream of stdin and stdout if both of those are available, and None 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 of shell=False with a command that’s a single string, or shell=True with a command that’s a sequence of strings. These forms are accepted by the underlying subprocess.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, and open_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:[bytes],[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)


  • 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 a BusyResourceError. (#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 the Cancelled is delivered and when it is caught. (#860)

  • If you have a SocketStream that’s already been closed, then await socket_stream.send_all(b"") will now correctly raise ClosedResourceError. (#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 of trio.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 and trio.subprocess are now deprecated. Their nontrivial contents (Process, SSLStream, and SSLListener) have been moved to the main trio namespace. For the numerous constants, exceptions, and other helpers that were previously reexported from the standard ssl and subprocess 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, and trio.ResourceBusyError), except for trio.hazmat.UnboundedQueue, which stays for now since it is used by the obscure lowlevel functions monitor_completion_queue() and monitor_kevent(). (#918)

Miscellaneous internal changes

  • Entering a cancel scope whose deadline is in the past now immediately cancels it, so Cancelled will be raised by the first checkpoint in the cancel scope rather than the second one. This also affects constructs like with trio.move_on_after(0):. (#320)

Trio 0.10.0 (2019-01-07)



  • 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, like selected_alpn_protocol, and thus cannot succeed until after the handshake has been performed. Previously, we returned None from these methods, like the stdlib ssl module does, but this is confusing, because that can also be a valid return value. Now we raise trio.ssl.NeedHandshakeError instead. (#735)

Trio 0.9.0 (2018-10-12)


  • New and improved APIs for inter-task communication:,, and trio.open_memory_channel() (which replaces trio.Queue). This interface uses separate “sender” and “receiver” objects, for consistency with other communication interfaces like Stream. Also, the two objects can now be closed individually, making it much easier to gracefully shut down a channel. Also, check out the nifty clone 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 0.8.0 (2018-10-01)


  • Trio’s default internal clock is now based on time.perf_counter() instead of time.monotonic(). This makes time-keeping more precise on Windows, and has no effect on other platforms. (#33)

  • Reworked trio, trio.testing, and trio.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

Trio 0.7.0 (2018-09-03)


  • 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, and notify_socket_close now work on bare socket descriptors, instead of requiring a socket.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 new trio.hazmat.Task.custom_sleep_data attribute to pass arbitrary data between the sleeping task, abort function, and waking task. (#616)


  • 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 regarding StopIteration and StopAsyncIteration 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 of open_signal_receiver(). The main differences are: it takes *-args now to specify the list of signals (so open_signal_receiver(SIGINT) instead of catch_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)



  • Make trio.socket._SocketType.connect always close the socket on cancellation (#247)

  • Fix a memory leak in trio.CapacityLimiter, that could occurr when acquire or acquire_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)


  • 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 and ClosedListenerError are now aliases for ClosedResourceError, 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 and trio.hazmat.notify_socket_close. If you’re using Trio’s built-in wrappers like SocketStream or trio.socket, then you don’t need to worry about this, but if you’re using the low-level functions like trio.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’s contextvars context, instead using one created at run(). (#289)

  • Add support for trio.Queue with capacity=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 and trio.hazmat.Error have been replaced by the equivalent classes in the Outcome library.

Trio 0.4.0 (2018-04-10)



  • Fix KeyboardInterrupt handling when threading state has been modified by a 3rd-party library. (#461)

Deprecations and Removals

Miscellaneous internal changes

Trio 0.3.0 (2017-12-28)


  • 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 a async 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 with async 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 and connect no longer require “pre-resolved” numeric addresses; you can now pass regular hostnames and Trio will implicitly resolve them for you. (#377)


  • 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, like serve_tcp(). (#241)

  • The resolve_local_address and resolve_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.


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 like serve_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, freeing trio.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 an SSLStream wrapped around a SocketStream 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 a sendall 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 functions getservbyport, getservbyname, and getfqdn have been removed, because they were obscure, buggy, and obsolete. Use getaddrinfo() 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 nursery spawn method is being renamed to start_soon (#284)

  • trio.socket.sendall is deprecated; use trio.open_tcp_stream and SocketStream.send_all instead (#291)

  • Trio now consistently uses run for functions that take and run an async function (like!), and run_sync for functions that take and run a synchronous function. As part of this:

    • run_in_worker_thread is becoming run_sync_in_worker_thread

    • We took the opportunity to refactor run_in_trio_thread and await_in_trio_thread into the new class trio.BlockingTrioPortal

    • The hazmat function current_call_soon_thread_and_signal_safe is being replaced by trio.hazmat.TrioToken

    See #68 for details.

  • trio.Queue's join and task_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 into trio.hazmat:

    • trio.Tasktrio.hazmat.Task

    • trio.current_tasktrio.hazmat.current_task

    • trio.Resulttrio.hazmat.Result

    • trio.Valuetrio.hazmat.Value

    • trio.Errortrio.hazmat.Error

    • trio.UnboundedQueuetrio.hazmat.UnboundedQueue

    In addition, several introspection attributes are being renamed:

    • nursery.childrennursery.child_tasks

    • task.parent_task → use task.parent_nursery.parent_task instead

    See #136 for more details.

  • To consolidate introspection functionality in trio.hazmat, the following functions are moving:

    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:

    In addition, the following functions in trio.testing are changing names:

    See #157 for more details.

  • trio.format_exception is deprecated; use traceback.format_exception() instead (#347).

  • trio.current_instruments is deprecated. For adding or removing instrumentation at run-time, see trio.hazmat.add_instrument and trio.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 was isinstance 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 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 (should be

  • 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 the logging 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)

  • takes a new keyword argument restrict_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 a tiebreaker= argument. The main use is to allow MockClock's auto-jump functionality to avoid interfering with direct use of wait_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 and trio.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.