2025-03-05 10:54:59 +00:00
-------------------------------------------------------------------
Tue Mar 4 15:13:47 UTC 2025 - John Paul Adrian Glaubitz <adrian.glaubitz@suse.com>
- Update to 0.29.0
* Add trio.lowlevel.in_trio_run() and trio.lowlevel.in_trio_task() and document
the semantics (and differences) thereof. See the documentation. (#2757)
* If trio.testing.RaisesGroup does not get the expected exceptions it now raises
an AssertionError with a helpful message, instead of letting the raised exception/
group fall through. The raised exception is available in the __context__ of the
AssertionError and can be seen in the traceback. (#3145)
* Clear Trio’
* Stop using ctypes to mutate tracebacks for strict_exception_groups=False’
collapsing. (#405)
* Fixed spelling error in Windows error code enum for ERROR_INVALID_PARAMETER. (#3166)
* Publicly re-export __version__ for type checking purposes. (#3186)
* The typing of trio.abc.HostnameResolver.getaddrinfo() has been corrected to match
that of the stdlib socket.getaddrinfo, which was updated in mypy 1.15 (via a typeshed
update) to include the possibility of tuple[int, bytes] for the sockaddr field of the
result. This happens in situations where Python was compiled with --disable-ipv6.
* Additionally, the static typing of trio.to_thread.run_sync(), trio.from_thread.run()
and trio.from_thread.run_sync() has been improved and should reflect the underlying
function being run. (#3201)
- Add sed command to remove shebangs from check_type_completeness.py and gen_exports.py
2025-01-28 11:09:05 +00:00
-------------------------------------------------------------------
Tue Jan 28 10:44:39 UTC 2025 - John Paul Adrian Glaubitz <adrian.glaubitz@suse.com>
- 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.
* Ensure that Pyright recognizes our underscore prefixed attributes for attrs
classes.
* Fix trio.testing.RaisesGroup's typing.
* Improve error message when run after gevent's monkey patching.
* Document that trio.sleep_forever is guaranteed to raise an exception now.
* Remove workaround for OpenSSL 1.1.1 DTLS ClientHello bug.
* Drop support for Python 3.8.
* Switch to using PEP570 for positional-only arguments for trio.socket.SocketType's
methods.
* Improve type annotations in several places by removing Any usage.
* Get and enforce 100% coverage.
2024-10-30 19:46:02 +00:00
-------------------------------------------------------------------
Wed Oct 30 19:45:40 UTC 2024 - Dirk Müller <dmueller@suse.com>
- 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.
* Allow sockets to bind any os.PathLike object.
* Update trio.lowlevel.open_process's documentation to allow
bytes.
* Update :func:`trio.sleep_forever` to be NoReturn.
* Add docstrings for memory channels' statistics() and aclose
methods.
2024-09-08 15:07:35 +00:00
-------------------------------------------------------------------
Sun Sep 8 15:06:48 UTC 2024 - Dirk Müller <dmueller@suse.com>
- 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.
2024-06-17 08:24:29 +00:00
-------------------------------------------------------------------
Mon Jun 17 08:23:15 UTC 2024 - Dirk Müller <dmueller@suse.com>
- update to 0.25.1:
* Fix crash when importing trio in embedded Python on Windows,
and other installs that remove docstrings.
2024-03-22 10:52:06 +00:00
-------------------------------------------------------------------
Fri Mar 22 09:37:15 UTC 2024 - Markéta Machová <mmachova@suse.com>
- Update to 0.25.0
* New helper classes: RaisesGroup and Matcher.
2024-06-17 08:24:29 +00:00
* MultiError has been fully removed, and all relevant trio
2024-03-22 10:52:06 +00:00
functions now raise ExceptionGroups instead.
2024-06-17 08:24:29 +00:00
* The strict_exception_groups parameter now defaults to True
2024-03-22 10:52:06 +00:00
in trio.run and trio.lowlevel.start_guest_run.
2024-06-17 08:24:29 +00:00
* Add trio.testing.wait_all_threads_completed, which blocks
2024-03-22 10:52:06 +00:00
until no threads are running tasks.
2024-06-17 08:24:29 +00:00
* Path is now a subclass of pathlib.PurePath, allowing it to
2024-03-22 10:52:06 +00:00
interoperate with other standard pathlib types.
2024-01-12 06:04:25 +00:00
-------------------------------------------------------------------
Thu Jan 11 10:56:14 UTC 2024 - Ben Greiner <code@bnavigator.de>
- We don't need isort for the tests: Avoid it for Ring1
- Clean dependencies
2024-01-03 10:36:30 +00:00
-------------------------------------------------------------------
Wed Jan 3 10:35:04 UTC 2024 - Dirk Müller <dmueller@suse.com>
- 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)
- 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 was
OBS-URL: https://build.opensuse.org/package/show/devel:languages:python/python-trio?expand=0&rev=39
2023-11-07 15:09:46 +00:00
-------------------------------------------------------------------
Tue Nov 7 15:06:29 UTC 2023 - Dirk Müller <dmueller@suse.com>
- 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 was
previously called ``cancellable`` is now named
``abandon_on_cancel``.
* The old ``cancellable`` name is now deprecated.
2023-10-31 16:23:38 +00:00
-------------------------------------------------------------------
Tue Oct 31 15:56:49 UTC 2023 - Matej Cepl <mcepl@cepl.eu>
- 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.
2023-09-19 14:52:58 +00:00
-------------------------------------------------------------------
Tue Sep 19 14:51:16 UTC 2023 - Dirk Müller <dmueller@suse.com>
- remove buildrequires that are not used on sle15
2023-04-21 13:29:57 +00:00
-------------------------------------------------------------------
Fri Apr 21 12:37:56 UTC 2023 - Dirk Müller <dmueller@suse.com>
- add sle15_python_module_pythons (jsc#PED-68)
-------------------------------------------------------------------
Thu Apr 13 22:45:34 UTC 2023 - Matej Cepl <mcepl@suse.com>
- Make calling of %{sle15modernpython} optional.
2022-12-24 00:50:27 +00:00
-------------------------------------------------------------------
Fri Dec 23 18:15:34 UTC 2022 - Ben Greiner <code@bnavigator.de>
- Try again with 0.22.0 and a fixed httpcore
2022-12-19 21:02:27 +00:00
-------------------------------------------------------------------
Mon Dec 19 20:55:58 UTC 2022 - Dirk Müller <dmueller@suse.com>
2022-12-24 00:50:27 +00:00
- go back to 0.21.0 as it breaks httpcore
2022-12-19 21:02:27 +00:00
2022-12-07 10:20:54 +00:00
-------------------------------------------------------------------
Wed Dec 7 10:18:12 UTC 2022 - Daniel Garcia <daniel.garcia@suse.com>
- 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)
2022-11-21 16:04:33 +00:00
-------------------------------------------------------------------
Mon Nov 21 16:04:21 UTC 2022 - Matej Cepl <mcepl@suse.com>
- Fix rpmlint error python-tests-in-package.
2022-09-25 19:16:05 +00:00
-------------------------------------------------------------------
Sun Sep 25 19:11:32 UTC 2022 - Dirk Müller <dmueller@suse.com>
- update to 0.21.0:
* Trio now supports Python 3.11.
* Remove support for Python 3.6.
2021-12-14 18:13:45 +00:00
-------------------------------------------------------------------
2022-03-29 11:37:25 +00:00
Tue Mar 29 09:40:18 UTC 2022 - Ben Greiner <code@bnavigator.de>
- Update to version 0.20.0
* 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, ...). See run_process for more
details. We recommend most users switch to this new API. Also
note that:
- trio.open_process has been deprecated in favor of
trio.lowlevel.open_process,
- The aclose method on Process has been deprecated along with
async with process_obj. (#1104)
* Now context variables set with contextvars are preserved when
running functions in a worker thread with
trio.to_thread.run_sync, or when running functions from the
worker thread in the parent Trio thread with
trio.from_thread.run, and trio.from_thread.run_sync. This is
done by automatically copying the contextvars context.
trio.lowlevel.spawn_system_task now also receives an optional
context argument. (#2160)
* 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 access
Process.returncode after the process exited but before wait
woke up (#2209)
- Drop trio-pr2043-py310ssl-deprecationwarnings.patch
-------------------------------------------------------------------
2021-12-14 18:13:45 +00:00
Sun Dec 12 18:53:24 UTC 2021 - Ben Greiner <code@bnavigator.de>
- Update to version 0.19.0
* Trio now supports Python 3.10. (#1921)
* Use slots for `~.lowlevel.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)
* The event loop now holds on to references of coroutine frames
for only the minimum necessary period of time. (#1864)
* The `~.lowlevel.TrioToken` class can now be used as a target of
a weak reference. (#1924)
- Release 0.18.0
* Add synchronous .close() methods and context manager (with x)
support for .MemorySendChannel and .MemoryReceiveChannel.
(#1797)
* 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 raise
trio.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)
* Remove deprecated max_refill_bytes from `SSLStream`. (#959)
* Remove the deprecated tiebreaker argument to
trio.testing.wait_all_tasks_blocked. (#1558)
* Remove the deprecated trio.hazmat module. (#1722)
* Stop allowing subclassing public classes. This behavior was
deprecated in 0.15.0. (#1726)
- Add trio-pr2043-py310ssl-deprecationwarnings.patch
2021-01-08 15:39:15 +00:00
-------------------------------------------------------------------
Fri Jan 8 15:30:04 UTC 2021 - Markéta Machová <mmachova@suse.com>
- Skip test incompatible with new pytest 6.2
2020-10-12 06:49:07 +00:00
-------------------------------------------------------------------
Sun Oct 11 15:36:02 UTC 2020 - John Vandenberg <jayvdb@gmail.com>
- Remove hashbang and tests in runtime package
- Disable test test_close_at_bad_time_for_send_all due to failure on PPC
- Update to v0.17.0
* 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
* 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
* trio.lowlevel.checkpoint is now much faster
* new, lower-overhead data structure to track upcoming timeouts,
which should make your programs faster
* Trio can now be imported when sys.excepthook is a functools.partial
instance, which might occur in a pytest-qt test function
* The thread cache didn't release its reference to the previous job
* Remove wait_socket_*, notify_socket_closing, notify_fd_closing,
run_sync_in_worker_thread and current_default_worker_thread_limiter
* When using "instruments", you now only "pay for what you use":
if there are no instruments installed that override a particular
hook such as `abc.Instrument.before_task_step`, then Trio doesn't
waste any effort on checking its instruments when the event
corresponding to that hook occurs.
2023-09-19 14:52:58 +00:00
2020-07-23 13:17:36 +00:00
-------------------------------------------------------------------
Thu Jul 23 12:46:45 UTC 2020 - Marketa Calabkova <mcalabkova@suse.com>
- Update to 0.16.0
2023-09-19 14:52:58 +00:00
* If you want to use Trio, but are stuck with some other event loop
2020-07-23 13:17:36 +00:00
like Qt or PyGame, then good news: now you can have both.
* To speed up `trio.to_thread.run_sync`, Trio now caches and re-uses
worker threads.
* Tasks spawned with `nursery.start() <trio.Nursery.start>` aren't treated as
direct children of their nursery until they call ``task_status.started()``.
* Some bugfixes and deprecations
2023-09-19 14:52:58 +00:00
- 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)
OBS-URL: https://build.opensuse.org/package/show/devel:languages:python/python-trio?expand=0&rev=12
2020-06-09 07:38:21 +00:00
-------------------------------------------------------------------
Tue Jun 9 07:36:03 UTC 2020 - Tomáš Chvátal <tchvatal@suse.com>
- 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)
2020-01-11 21:16:07 +00:00
-------------------------------------------------------------------
Sat Jan 11 12:01:37 UTC 2020 - Ondřej Súkup <mimi.vx@gmail.com>
- update to 0.13.0
* Use slots for memory channel state and statistics which should make
2023-09-19 14:52:58 +00:00
memory channels slightly smaller and faster.
2020-01-11 21:16:07 +00:00
* 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.
Accepting request 721060 from home:pgajdos
- version update to 0.12.1
Features
* If you have a `~trio.abc.ReceiveStream` object, you can now use
``async for data in stream: ...`` instead of calling
`~trio.abc.ReceiveStream.receive_some`. Each iteration gives an
arbitrary sized chunk of bytes. And the best part is, the loop
automatically exits when you reach EOF, so you don't have to check for
it yourself anymore. Relatedly, you no longer need to pick a magic
buffer size value before calling
`~trio.abc.ReceiveStream.receive_some`; you can ``await
stream.receive_some()`` with no arguments, and the stream will
automatically pick a reasonable size for you. (`#959 <https://github.com/python-trio/trio/issues/959>`__)
* Threading interfaces have been reworked:
``run_sync_in_worker_thread`` is now `trio.to_thread.run_sync`, and
instead of ``BlockingTrioPortal``, use `trio.from_thread.run` and
`trio.from_thread.run_sync`. What's neat about this is that these
cooperate, so if you're in a thread created by `to_thread.run_sync`,
it remembers which Trio created it, and you can call
``trio.from_thread.*`` directly without having to pass around a
``BlockingTrioPortal`` object everywhere. (`#810 <https://github.com/python-trio/trio/issues/810>`__)
* We cleaned up the distinction between the "abstract channel interface"
and the "memory channel" concrete implementation.
`trio.abc.SendChannel` and `trio.abc.ReceiveChannel` have been slimmed
down, `trio.MemorySendChannel` and `trio.MemoryReceiveChannel` are now
public types that can be used in type hints, and there's a new
`trio.abc.Channel` interface for future bidirectional channels. (`#719 <https://github.com/python-trio/trio/issues/719>`__)
* Add :func:`trio.run_process` as a high-level helper for running a process
and waiting for it to finish, like the standard :func:`subprocess.run` does. (`#822 <https://github.com/python-trio/trio/issues/822>`__)
* On Linux, when wrapping a bare file descriptor in a Trio socket object,
Trio now auto-detects the correct ``family``, ``type``, and ``protocol``.
OBS-URL: https://build.opensuse.org/request/show/721060
OBS-URL: https://build.opensuse.org/package/show/devel:languages:python/python-trio?expand=0&rev=8
2019-08-05 18:07:36 +00:00
-------------------------------------------------------------------
Mon Aug 5 12:56:53 UTC 2019 - pgajdos@suse.com
- version update to 0.12.1
Features
* If you have a `~trio.abc.ReceiveStream` object, you can now use
``async for data in stream: ...`` instead of calling
`~trio.abc.ReceiveStream.receive_some`. Each iteration gives an
arbitrary sized chunk of bytes. And the best part is, the loop
automatically exits when you reach EOF, so you don't have to check for
it yourself anymore. Relatedly, you no longer need to pick a magic
buffer size value before calling
`~trio.abc.ReceiveStream.receive_some`; you can ``await
stream.receive_some()`` with no arguments, and the stream will
automatically pick a reasonable size for you. (`#959 <https://github.com/python-trio/trio/issues/959>`__)
* Threading interfaces have been reworked:
``run_sync_in_worker_thread`` is now `trio.to_thread.run_sync`, and
instead of ``BlockingTrioPortal``, use `trio.from_thread.run` and
`trio.from_thread.run_sync`. What's neat about this is that these
cooperate, so if you're in a thread created by `to_thread.run_sync`,
it remembers which Trio created it, and you can call
``trio.from_thread.*`` directly without having to pass around a
``BlockingTrioPortal`` object everywhere. (`#810 <https://github.com/python-trio/trio/issues/810>`__)
* We cleaned up the distinction between the "abstract channel interface"
and the "memory channel" concrete implementation.
`trio.abc.SendChannel` and `trio.abc.ReceiveChannel` have been slimmed
down, `trio.MemorySendChannel` and `trio.MemoryReceiveChannel` are now
public types that can be used in type hints, and there's a new
`trio.abc.Channel` interface for future bidirectional channels. (`#719 <https://github.com/python-trio/trio/issues/719>`__)
* Add :func:`trio.run_process` as a high-level helper for running a process
and waiting for it to finish, like the standard :func:`subprocess.run` does. (`#822 <https://github.com/python-trio/trio/issues/822>`__)
* On Linux, when wrapping a bare file descriptor in a Trio socket object,
Trio now auto-detects the correct ``family``, ``type``, and ``protocol``.
This is useful, for example, when implementing `systemd socket activation
<http://0pointer.de/blog/projects/socket-activation.html>`__. (`#251 <https://github.com/python-trio/trio/issues/251>`__)
* Trio sockets have a new method `~trio.socket.SocketType.is_readable` that allows
you to check whether a socket is readable. This is useful for HTTP/1.1 clients. (`#760 <https://github.com/python-trio/trio/issues/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 <https://github.com/python-trio/trio/issues/805>`__)
* Add `trio.hazmat.FdStream` for wrapping a Unix file descriptor as a `~trio.abc.Stream`. (`#829 <https://github.com/python-trio/trio/issues/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 <https://github.com/python-trio/trio/issues/882>`__)
* MultiError now defines its ``exceptions`` attribute in ``__init__()``
to better support linters and code autocompletion. (`#1066 <https://github.com/python-trio/trio/issues/1066>`__)
* Use ``__slots__`` in more places internally, which should make Trio slightly faster. (`#984 <https://github.com/python-trio/trio/issues/984>`__)
* 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 <https://github.com/python-trio/trio/issues/1167>`__)
Bugfixes
* Destructor methods (``__del__``) are now protected against ``KeyboardInterrupt``. (`#676 <https://github.com/python-trio/trio/issues/676>`__)
* The :class:`trio.Path` methods :meth:`~trio.Path.glob` and
:meth:`~trio.Path.rglob` now return iterables of :class:`trio.Path`
(not :class:`pathlib.Path`). (`#917 <https://github.com/python-trio/trio/issues/917>`__)
* Inspecting the :attr:`~trio.CancelScope.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 <https://github.com/python-trio/trio/issues/958>`__)
* The :class:`trio.Path` classmethods, :meth:`~trio.Path.home` and
:meth:`~trio.Path.cwd`, are now async functions. Previously, a bug
in the forwarding logic meant :meth:`~trio.Path.cwd` was synchronous
and :meth:`~trio.Path.home` didn't work at all. (`#960 <https://github.com/python-trio/trio/issues/960>`__)
* An exception encapsulated within a :class:`MultiError` doesn't need to be
hashable anymore.
-------------------------------------------------------------------
Mon Aug 5 12:45:29 UTC 2019 - pgajdos@suse.com
- version update to 0.12.1
* no upstream change log found
2019-06-03 08:05:03 +00:00
-------------------------------------------------------------------
Sun Jun 2 12:40:48 UTC 2019 - Jan Engelhardt <jengelh@inai.de>
- Trim filler wording from descriptions.
2019-05-29 09:09:58 +00:00
-------------------------------------------------------------------
Wed May 29 09:09:31 UTC 2019 - Tomáš Chvátal <tchvatal@suse.com>
- Skip tests that fail with TLS 1.3 as upstream is not finished
with supporting it yet
2019-05-22 13:02:57 +00:00
-------------------------------------------------------------------
Wed May 22 13:02:44 UTC 2019 - Tomáš Chvátal <tchvatal@suse.com>
- Fix deadlocks in the testsuite
2019-05-14 21:28:18 +00:00
-------------------------------------------------------------------
Tue May 14 21:27:51 UTC 2019 - Tomáš Chvátal <tchvatal@suse.com>
- Run the tests
- Fix the deps
2019-05-14 20:35:45 +00:00
-------------------------------------------------------------------
Sat May 11 19:16:24 UTC 2019 - Torsten Gruner <t.gruner@katodev.de>
- Initial release version 0.11.0
