b8d171346dAccepting request 1240800 from devel:languages:python
factory
Ana Guerrero
2025-01-29 15:09:57 +00:00
e880a436ae- Update to 0.28.0 * :func:inspect.iscoroutinefunction and the like now give correct answers when called on KI-protected functions. * Rework KeyboardInterrupt protection to track code objects, rather than frames, as protected or not. The new implementation no longer needs to access frame.f_locals dictionaries, so it won't artificially extend the lifetime of local variables. Since KeyboardInterrupt protection is now imposed statically (when a protected function is defined) rather than each time the function runs, its previously-noticeable performance overhead should now be near zero. The lack of a call-time wrapper has some other benefits as well: * :func:inspect.iscoroutinefunction and the like now give correct answers when called on KI-protected functions. * Calling a synchronous KI-protected function no longer pushes an additional stack frame, so tracebacks are clearer. * A synchronous KI-protected function invoked from C code (such as a weakref finalizer) is now guaranteed to start executing; previously there would be a brief window in which KeyboardInterrupt could be raised before the protection was established. * One minor drawback of the new approach is that multiple instances of the same closure share a single KeyboardInterrupt protection state (because they share a single code object). That means that if you apply trio.lowlevel.enable_ki_protection to some of them and not others, you won't get the protection semantics you asked for. See the documentation of trio.lowlevel.enable_ki_protection for more details and a workaround. * Rework foreign async generator finalization to track async generator ids rather than mutating ag_frame.f_locals. This fixes an issue with the previous implementation: locals' lifetimes will no longer be extended by materialization in the ag_frame.f_locals dictionary that the previous finalization dispatcher logic needed to access to do its work.
devel
Markéta Machová2025-01-28 11:09:05 +00:00
4268663a67- update to 0.27.0: * :func:trio.move_on_after and :func:trio.fail_after previously set the deadline relative to initialization time, instead of more intuitively upon entering the context manager. This might change timeouts if a program relied on this behavior. If you want to restore previous behavior you should instead use trio.move_on_at(trio.current_time() + ...). flake8-async has a new rule to catch this, in case you're supporting older trio versions. See :ref:ASYNC122. * :meth:CancelScope.relative_deadline and :meth:CancelScope.is_relative added, as well as a relative_deadline parameter to __init__. This allows initializing scopes ahead of time, but where the specified relative deadline doesn't count down until the scope is entered. * :class:trio.Lock and :class:trio.StrictFIFOLock will now raise :exc:trio.BrokenResourceError when :meth:trio.Lock.acquire would previously stall due to the owner of the lock exiting without releasing the lock. * trio.move_on_at, trio.move_on_after, trio.fail_at and trio.fail_after now accept shield as a keyword argument. If specified, it provides an initial value for the ~trio.CancelScope.shield attribute of the trio.CancelScope object created by the context manager. * Added :func:trio.lowlevel.add_parking_lot_breaker and :func:trio.lowlevel.remove_parking_lot_breaker to allow creating custom lock/semaphore implementations that will break their underlying parking lot if a task exits unexpectedly. :meth:trio.lowlevel.ParkingLot.break_lot is also added, to allow breaking a parking lot intentionally.Dirk Mueller2024-10-30 19:46:02 +00:00
9ab2c162c6Accepting request 1199467 from devel:languages:python
Ana Guerrero
2024-09-09 12:43:26 +00:00
87fafbf12b- update to 0.26.2: * Remove remaining hash usage and fix test configuration issue that prevented it from being caught. * Switched attrs usage off of hash, which is now deprecated. * Use PyPI's Trusted Publishers to make releases. * Added an interactive interpreter python -m trio. This makes it easier to try things and experiment with trio in the a Python repl. Use the await keyword without needing to call trio.run() $ python -m trio Trio 0.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 :ref:interactive debugging for further detail. (#2972) * :class:trio.testing.RaisesGroup can now catch an unwrapped exception with unwrapped=True. This means that the behaviour of :ref:except* <except_star> can be fully replicated in combination with flatten_subgroups=True (formerly strict=False). (#2989) * Fixed a bug where :class:trio.testing.RaisesGroup(..., strict=False) <trio.testing.RaisesGroup> would check the number of exceptions in the raised ExceptionGroup before flattening subgroups, leading to incorrectly failed matches. It now properly supports end ($) regex markers in the match message, by no longer including " (x sub-exceptions)" in the string it matches against. * Deprecated strict parameter from :class:trio.testing.RaisesGroup, previous functionality of strict=False is now in flatten_subgroups=True.Dirk Mueller2024-09-08 15:07:35 +00:00
46d048f9eaAccepting request 1182980 from devel:languages:python
Ana Guerrero
2024-06-24 18:50:50 +00:00
213ff889da- update to 0.25.1: * Fix crash when importing trio in embedded Python on Windows, and other installs that remove docstrings. * MultiError has been fully removed, and all relevant trio * The strict_exception_groups parameter now defaults to True * Add trio.testing.wait_all_threads_completed, which blocks * Path is now a subclass of pathlib.PurePath, allowing it toDirk Mueller2024-06-17 08:24:29 +00:00
e095c1af3aAccepting request 1160629 from devel:languages:python
Ana Guerrero
2024-03-26 18:24:30 +00:00
5e133285edAccepting request 1160593 from home:mcalabkova:branches:devel:languages:pythonMatej Cepl2024-03-22 10:52:06 +00:00
0a329c47ebAccepting request 1138213 from devel:languages:python
Ana Guerrero
2024-01-21 22:07:34 +00:00
853a7b8632Accepting request 1138103 from home:bnavigator:branches:devel:languages:python
Steve Kowalik
2024-01-12 06:04:25 +00:00
5febda2777- update to 0.23.2: * TypeVarTuple is now used to fully type :meth:nursery.start_soon() <trio.Nursery.start_soon>, :func:trio.run(), :func: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. :meth:nursery.start() <trio.Nursery.start> is not fully typed yet however. (#2881) * Make pyright recognize :func:open_memory_channel as generic. (#2873) backlink Unknown interpreted text role "func". * Make pyright recognize :func:open_memory_channel as generic. * Unknown interpreted text role "func". * Moved the metadata into PEP 621-compliant :file:pyproject.toml. (#2860)Dirk Mueller2024-01-03 10:36:30 +00:00
1c941389e3- update to 0.23.1: * Don't crash on import in Anaconda interpreters. * Add type hints. * 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 a Cancelled here is not really useful, and in some rare cases caused confusion or problems, so Trio no longer does that. * If called from a thread spawned by trio.to_thread.run_sync, trio.from_thread.run and trio.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 use trio.from_thread.check_cancelled to efficiently check for cancellation without reentering the Trio thread. * :func: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 to :func:trio.current_time, :func:trio.lowlevel.spawn_system_task, :func:trio.lowlevel.current_trio_token, etc. * When a starting function raises before calling :func:trio.TaskStatus.started, :func:trio.Nursery.start will no longer wrap the exception in an undocumented :exc:ExceptionGroup. * To better reflect the underlying thread handling semantics, the keyword argument for trio.to_thread.run_sync that wasDirk Mueller2023-11-07 15:09:46 +00:00
bb2664b9f8- Update to 0.22.2: * Fix PermissionError when importing trio due to trying to access pthread. * Breaking change: Timeout functions now raise ValueError if passed math.nan. This includes trio.sleep, trio.sleep_until, trio.move_on_at, trio.move_on_after, trio.fail_at and trio.fail_after. * Added support for naming threads created with trio.to_thread.run_sync, requires pthreads so is only available on POSIX platforms with glibc installed. * trio.socket.socket now prints the address it tried to connect to upon failure. * 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. * 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. * Documented that Nursery.start_soon does not guarantee task ordering.Matej Cepl2023-10-31 16:23:38 +00:00
ea511e4b91Accepting request 1112325 from devel:languages:python
Ana Guerrero
2023-09-21 20:13:19 +00:00
e009f3f472- remove buildrequires that are not used on sle15 * If you want to use Trio, but are stuck with some other event loop memory channels slightly smaller and faster.Dirk Mueller2023-09-19 14:52:58 +00:00
599d759a6dAccepting request 1042681 from home:mcalabkova:branches:devel:languages:pythonMarkéta Machová2022-12-13 14:19:37 +00:00
31181b044c- Update to 0.22.0: * MultiError has been deprecated in favor of the standard BaseExceptionGroup (introduced in PEP 654). On Python versions below 3.11, this exception and its derivative ExceptionGroup are provided by the backport. Trio still raises MultiError, but it has been refactored into a subclass of BaseExceptionGroup which users should catch instead of MultiError. Uses of the MultiError.filter() class method should be replaced with BaseExceptionGroup.split(). Uses of the MultiError.catch() class method should be replaced with either except* clauses (on Python 3.11+) or the exceptiongroup.catch() context manager provided by the backport. See the updated documentation for details. # Features * Added support for Datagram TLS, for secure communication over UDP. Currently requires PyOpenSSL. (#2010)Daniel Garcia2022-12-07 10:20:54 +00:00
50f9c7d521- Update to 0.15.1: * Added a helpful error message if an async function is passed to trio.from_thread.run_sync or a sync function to trio.from_thread.run. (#1244) * Previously, when trio.run_process was cancelled, it always killed the subprocess immediately. Now, on Unix, it first gives the process a chance to clean up by sending SIGTERM, and only escalates to SIGKILL if the process is still running after 5 seconds. But if you prefer the old behavior, or want to adjust the timeout, then don't worry: you can now pass a custom deliver_cancel= argument to define your own process killing policy. (#1104) * It turns out that creating a subprocess can block the parent process for a surprisingly long time. So trio.open_process now uses a worker thread to avoid blocking the event loop. (#1109) * On Linux kernels v5.3 or newer, trio.Process.wait now uses the pidfd API to track child processes. This shouldn't have any user-visible change, but it makes working with subprocesses faster and use less memory. (#1241) * The trio.Process.returncode attribute is now automatically updated as needed, instead of only when you call ~trio.Process.poll or ~trio.Process.wait. Also, repr(process_object) now always contains up-to-date information about the process status. (#1315)
Tomáš Chvátal
2020-06-09 07:38:21 +00:00
4560d9c9d9- update to 0.13.0 * Use slots for memory channel state and statistics which should make memory channels slightly smaller and faster. * OpenSSL has a bug in its handling of TLS 1.3 session tickets that can cause deadlocks or data loss in some rare edge cases. These edge cases most frequently happen during tests. * Trio now uses signal.set_wakeup_fd on all platforms. * Trio no longer crashes when an async function is implemented in C or Cython and then passed directly to trio.run or nursery.start_soon. * When a Trio task makes improper use of a non-Trio async library, Trio nowi causes an exception to be raised within the task at the point of the error, rather than abandoning the task and raising an error in its parent. This improves debuggability and resolves the TrioInternalError that would sometimes result from the old strategy. (#552) * In 0.12.0 we deprecated trio.run_sync_in_worker_thread in favor of trio.to_thread.run_sync. But, the deprecation message listed the wrong name for the replacement. * Fix regression introduced with cancellation changes in 0.12.0, where a trio.CancelScope which isn't cancelled could catch a propagating trio.Cancelled exception if shielding were changed while the cancellation was propagating. * Fix a crash that could happen when using MockClock with autojump enabled and a non-zero rate. * If you nest >1000 cancel scopes within each other, Trio now handles that gracefully instead of crashing with a RecursionError. * Fixed the hash behavior of trio.Path to match pathlib.Path. Previously trio.Path's hash was inherited from object instead of from pathlib.PurePath.Ondřej Súkup2020-01-11 21:16:07 +00:00
Ana Guerrero
Markéta Machová
Dirk Mueller
Matej Cepl
Steve Kowalik
Daniel Garcia
Dominique Leuenberger
Tomáš Chvátal
Ondřej Súkup