Merge branch 'master' into eliminate-unbounded-queue

.github/workflows/ci.yml

@@ -94,7 +94,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python: ['pypy-3.9', 'pypy-3.10', '3.8', '3.9', '3.10', '3.11', '3.12-dev', 'pypy-3.9-nightly', 'pypy-3.10-nightly']
+        python: ['pypy-3.9', 'pypy-3.10', '3.8', '3.9', '3.10', '3.11', '3.12', 'pypy-3.9-nightly', 'pypy-3.10-nightly']
         check_formatting: ['0']
         no_test_requirements: ['0']
         extra_name: ['']

.pre-commit-config.yaml

@@ -23,7 +23,7 @@ repos:
     hooks:
       - id: black
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.1.11
+    rev: v0.1.14
     hooks:
       - id: ruff
         types: [file]

docs-requirements.txt

@@ -42,7 +42,7 @@ importlib-resources==6.1.1
     # via towncrier
 incremental==22.10.0
     # via towncrier
-jinja2==3.1.2
+jinja2==3.1.3
     # via
     #   -r docs-requirements.in
     #   sphinx

docs/source/reference-core.rst

@@ -768,9 +768,14 @@ inside the handler function(s) with the ``nonlocal`` keyword::
         async with trio.open_nursery() as nursery:
             nursery.start_soon(broken1)
 
+.. _strict_exception_groups:
+
 "Strict" versus "loose" ExceptionGroup semantics
 ++++++++++++++++++++++++++++++++++++++++++++++++
 
+..
+    TODO: rewrite this (and possible other) sections from the new strict-by-default perspective, under the heading "Deprecated: non-strict ExceptionGroups" - to explain that it only exists for backwards-compatibility, will be removed in future, and that we recommend against it for all new code.
+
 Ideally, in some abstract sense we'd want everything that *can* raise an
 `ExceptionGroup` to *always* raise an `ExceptionGroup` (rather than, say, a single
 `ValueError`). Otherwise, it would be easy to accidentally write something like ``except
@@ -796,9 +801,10 @@ to set the default behavior for any nursery in your program that doesn't overrid
   wrapping, so you'll get maximum compatibility with code that was written to
   support older versions of Trio.
 
-To maintain backwards compatibility, the default is ``strict_exception_groups=False``.
-The default will eventually change to ``True`` in a future version of Trio, once
-Python 3.11 and later versions are in wide use.
+The default is set to ``strict_exception_groups=True``, in line with the default behaviour
+of ``TaskGroup`` in asyncio and anyio.  We've also found that non-strict mode makes it
+too easy to neglect the possibility of several exceptions being raised concurrently,
+causing nasty latent bugs when errors occur under load.
 
 .. _exceptiongroup: https://pypi.org/project/exceptiongroup/
 

newsfragments/2786.breaking.rst

@@ -0,0 +1,10 @@
+The :ref:`strict_exception_groups <strict_exception_groups>` parameter now defaults to `True` in `trio.run` and `trio.lowlevel.start_guest_run`. `trio.open_nursery` still defaults to the same value as was specified in `trio.run`/`trio.lowlevel.start_guest_run`, but if you didn't specify it there then all subsequent calls to `trio.open_nursery` will change.
+This is unfortunately very tricky to change with a deprecation period, as raising a `DeprecationWarning` whenever :ref:`strict_exception_groups <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` or `StopIteration` 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 an `ExceptionGroup`. It previously could do this in very rare circumstances, but with :ref:`strict_exception_groups <strict_exception_groups>` set to `True` it will now do so whenever exceptions occur in ``deliver_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 an `ExceptionGroup` is *no longer* added.
+* `trio.TrioInternalError` ``.__cause__`` might be wrapped in one or more `ExceptionGroups <ExceptionGroup>`

pyproject.toml

@@ -91,26 +91,29 @@ allowed-confusables = ["–"]
 src = ["src/trio", "notes-to-self"]
 
 select = [
-  "RUF",  # Ruff-specific rules
-  "F",  # pyflakes
-  "E",  # Error
-  "W",  # Warning
-  "I",  # isort
-  "UP",  # pyupgrade
-  "B",  # flake8-bugbear
-  "YTT",  # flake8-2020
-  "ASYNC",  # flake8-async
-  "PYI",  # flake8-pyi
-  "SIM",  # flake8-simplify
-  "TCH",  # flake8-type-checking
-  "PT",  # flake8-pytest-style
+    "ASYNC", # flake8-async
+    "B",     # flake8-bugbear
+    "C4",    # flake8-comprehensions
+    "E",     # Error
+    "F",     # pyflakes
+    "FA",    # flake8-future-annotations
+    "I",     # isort
+    "PT",    # flake8-pytest-style
+    "PYI",   # flake8-pyi
+    "RUF",   # Ruff-specific rules
+    "SIM",   # flake8-simplify
+    "TCH",   # flake8-type-checking
+    "UP",    # pyupgrade
+    "W",     # Warning
+    "YTT",   # flake8-2020
 ]
 extend-ignore = [
-    'F403',  # undefined-local-with-import-star
-    'F405',  # undefined-local-with-import-star-usage
-    'E402',  # module-import-not-at-top-of-file (usually OS-specific)
-    'E501',  # line-too-long
-    'SIM117',  # multiple-with-statements (messes up lots of context-based stuff and looks bad)
+    'E402',   # module-import-not-at-top-of-file (usually OS-specific)
+    'E501',   # line-too-long
+    'F403',   # undefined-local-with-import-star
+    'F405',   # undefined-local-with-import-star-usage
+    'PT012',  # multiple statements in pytest.raises block
+    'SIM117', # multiple-with-statements (messes up lots of context-based stuff and looks bad)
 ]
 
 include = ["*.py", "*.pyi", "**/pyproject.toml"]

src/trio/_core/_run.py

@@ -80,15 +80,6 @@
 
     PosArgT = TypeVarTuple("PosArgT")
 
-    # Needs to be guarded, since Unpack[] would be evaluated at runtime.
-    class _NurseryStartFunc(Protocol[Unpack[PosArgT], StatusT_co]):
-        """Type of functions passed to `nursery.start() <trio.Nursery.start>`."""
-
-        def __call__(
-            self, *args: Unpack[PosArgT], task_status: TaskStatus[StatusT_co]
-        ) -> Awaitable[object]:
-            ...
-
 
 DEADLINE_HEAP_MIN_PRUNE_THRESHOLD: Final = 1000
 
@@ -937,7 +928,7 @@ class NurseryManager:
 
     """
 
-    strict_exception_groups: bool = attr.ib(default=False)
+    strict_exception_groups: bool = attr.ib(default=True)
 
     @enable_ki_protection
     async def __aenter__(self) -> Nursery:
@@ -1004,9 +995,10 @@ def open_nursery(
     have exited.
 
     Args:
-      strict_exception_groups (bool): If true, even a single raised exception will be
-          wrapped in an exception group. This will eventually become the default
-          behavior. If not specified, uses the value passed to :func:`run`.
+      strict_exception_groups (bool): Unless set to False, even a single raised exception
+          will be wrapped in an exception group. If not specified, uses the value passed
+          to :func:`run`, which defaults to true. Setting it to False will be deprecated
+          and ultimately removed in a future version of Trio.
 
     """
     if strict_exception_groups is None:
@@ -2171,7 +2163,7 @@ def run(
     clock: Clock | None = None,
     instruments: Sequence[Instrument] = (),
     restrict_keyboard_interrupt_to_checkpoints: bool = False,
-    strict_exception_groups: bool = False,
+    strict_exception_groups: bool = True,
 ) -> RetT:
     """Run a Trio-flavored async function, and return the result.
 
@@ -2228,9 +2220,10 @@ def run(
           main thread (this is a Python limitation), or if you use
           :func:`open_signal_receiver` to catch SIGINT.
 
-      strict_exception_groups (bool): If true, nurseries will always wrap even a single
-          raised exception in an exception group. This can be overridden on the level of
-          individual nurseries. This will eventually become the default behavior.
+      strict_exception_groups (bool): Unless set to False, nurseries will always wrap
+          even a single raised exception in an exception group. This can be overridden
+          on the level of individual nurseries. Setting it to False will be deprecated
+          and ultimately removed in a future version of Trio.
 
     Returns:
       Whatever ``async_fn`` returns.
@@ -2288,7 +2281,7 @@ def start_guest_run(
     clock: Clock | None = None,
     instruments: Sequence[Instrument] = (),
     restrict_keyboard_interrupt_to_checkpoints: bool = False,
-    strict_exception_groups: bool = False,
+    strict_exception_groups: bool = True,
 ) -> None:
     """Start a "guest" run of Trio on top of some other "host" event loop.
 

src/trio/_core/_tests/test_ki.py

@@ -9,6 +9,8 @@
 import outcome
 import pytest
 
+from trio.testing import RaisesGroup
+
 try:
     from async_generator import async_generator, yield_
 except ImportError:  # pragma: no cover
@@ -293,7 +295,8 @@ async def check_unprotected_kill() -> None:
             nursery.start_soon(sleeper, "s2", record_set)
             nursery.start_soon(raiser, "r1", record_set)
 
-    with pytest.raises(KeyboardInterrupt):
+    # raises inside a nursery, so the KeyboardInterrupt is wrapped in an ExceptionGroup
+    with RaisesGroup(KeyboardInterrupt):
         _core.run(check_unprotected_kill)
     assert record_set == {"s1 ok", "s2 ok", "r1 raise ok"}
 
@@ -309,7 +312,8 @@ async def check_protected_kill() -> None:
             nursery.start_soon(_core.enable_ki_protection(raiser), "r1", record_set)
             # __aexit__ blocks, and then receives the KI
 
-    with pytest.raises(KeyboardInterrupt):
+    # raises inside a nursery, so the KeyboardInterrupt is wrapped in an ExceptionGroup
+    with RaisesGroup(KeyboardInterrupt):
         _core.run(check_protected_kill)
     assert record_set == {"s1 ok", "s2 ok", "r1 cancel ok"}
 
@@ -331,6 +335,7 @@ def kill_during_shutdown() -> None:
 
         token.run_sync_soon(kill_during_shutdown)
 
+    # no nurseries involved, so the KeyboardInterrupt isn't wrapped
     with pytest.raises(KeyboardInterrupt):
         _core.run(check_kill_during_shutdown)
 
@@ -344,6 +349,7 @@ def before_run(self) -> None:
     async def main_1() -> None:
         await _core.checkpoint()
 
+    # no nurseries involved, so the KeyboardInterrupt isn't wrapped
     with pytest.raises(KeyboardInterrupt):
         _core.run(main_1, instruments=[InstrumentOfDeath()])