Replace MultiError with BaseExceptionGroup

trio/_core/_multierror.py

@@ -181,6 +181,8 @@ class MultiError(BaseExceptionGroup):
     """
 
     def __init__(self, exceptions, *, _collapse=True):
+        self.collapse = _collapse
+
         # Avoid double initialization when _collapse is True and exceptions[0] returned
         # by __new__() happens to be a MultiError and subsequently __init__() is called.
         if _collapse and getattr(self, "exceptions", None) is not None:
@@ -220,7 +222,9 @@ def __repr__(self):
     def derive(self, __excs):
         # We use _collapse=False here to get ExceptionGroup semantics, since derive()
         # is part of the PEP 654 API
-        return MultiError(__excs, _collapse=False)
+        exc = MultiError(__excs, _collapse=False)
+        exc.collapse = self.collapse
+        return exc
 
     @classmethod
     def filter(cls, handler, root_exc):
@@ -414,3 +418,35 @@ def trio_show_traceback(self, etype, value, tb, tb_offset=None):
                 print_exception(value)
 
             ip.set_custom_exc((BaseExceptionGroup,), trio_show_traceback)
+
+
+# Ubuntu's system Python has a sitecustomize.py file that import
+# apport_python_hook and replaces sys.excepthook.
+#
+# The custom hook captures the error for crash reporting, and then calls
+# sys.__excepthook__ to actually print the error.
+#
+# We don't mind it capturing the error for crash reporting, but we want to
+# take over printing the error. So we monkeypatch the apport_python_hook
+# module so that instead of calling sys.__excepthook__, it calls our custom
+# hook.
+#
+# More details: https://github.com/python-trio/trio/issues/1065
+if (
+    sys.version_info < (3, 11)
+    and getattr(sys.excepthook, "__name__", None) == "apport_excepthook"
+):
+    from types import ModuleType
+
+    import apport_python_hook
+    from exceptiongroup import format_exception
+
+    assert sys.excepthook is apport_python_hook.apport_excepthook
+
+    def replacement_webhook(etype, value, tb):
+        sys.stderr.write("".join(format_exception(etype, value, tb)))
+
+    fake_sys = ModuleType("trio_fake_sys")
+    fake_sys.__dict__.update(sys.__dict__)
+    fake_sys.__excepthook__ = replacement_webhook  # type: ignore
+    apport_python_hook.sys = fake_sys

trio/_core/_run.py

@@ -127,13 +127,13 @@ def collapse_exception_group(excgroup):
     exceptions = list(excgroup.exceptions)
     modified = False
     for i, exc in enumerate(exceptions):
-        if isinstance(exc, MultiError):
+        if isinstance(exc, BaseExceptionGroup):
             new_exc = collapse_exception_group(exc)
             if new_exc is not exc:
                 modified = True
                 exceptions[i] = new_exc
 
-    if len(exceptions) == 1:
+    if len(exceptions) == 1 and isinstance(excgroup, MultiError) and excgroup.collapse:
         exceptions[0].__traceback__ = concat_tb(
             excgroup.__traceback__, exceptions[0].__traceback__
         )
@@ -475,7 +475,7 @@ def __enter__(self):
             task._activate_cancel_status(self._cancel_status)
         return self
 
-    def _close(self, exc, collapse=True):
+    def _close(self, exc, collapse=False):
         if self._cancel_status is None:
             new_exc = RuntimeError(
                 "Cancel scope stack corrupted: attempted to exit {!r} "
@@ -540,8 +540,8 @@ def _close(self, exc, collapse=True):
                 if matched:
                     self.cancelled_caught = True
 
-        if collapse and isinstance(exc, MultiError):
-            exc = collapse_exception_group(exc)
+                if exc:
+                    exc = collapse_exception_group(exc)
 
         self._cancel_status.close()
         with self._might_change_registered_deadline():

trio/_core/tests/test_multierror.py

@@ -535,3 +535,22 @@ def test_ipython_custom_exc_handler():
     )
     # Make sure our other warning doesn't show up
     assert "custom sys.excepthook" not in completed.stdout.decode("utf-8")
+
+
+@slow
+@pytest.mark.skipif(
+    not Path("/usr/lib/python3/dist-packages/apport_python_hook.py").exists(),
+    reason="need Ubuntu with python3-apport installed",
+)
+def test_apport_excepthook_monkeypatch_interaction():
+    completed = run_script("apport_excepthook.py")
+    stdout = completed.stdout.decode("utf-8")
+
+    # No warning
+    assert "custom sys.excepthook" not in stdout
+
+    # Proper traceback
+    assert_match_in_seq(
+        ["--- 1 ---", "KeyError", "--- 2 ---", "ValueError"],
+        stdout,
+    )

trio/_core/tests/test_multierror_scripts/apport_excepthook.py

@@ -0,0 +1,13 @@
+# The apport_python_hook package is only installed as part of Ubuntu's system
+# python, and not available in venvs. So before we can import it we have to
+# make sure it's on sys.path.
+import sys
+
+sys.path.append("/usr/lib/python3/dist-packages")
+import apport_python_hook
+
+apport_python_hook.install()
+
+import trio
+
+raise trio.MultiError([KeyError("key_error"), ValueError("value_error")])

trio/_core/tests/test_run.py

@@ -1855,17 +1855,11 @@ def __aiter__(self):
         async def __anext__(self):
             nexts = self.nexts
             items = [None] * len(nexts)
-            got_stop = False
 
-            try:
-                async with _core.open_nursery() as nursery:
-                    for i, f in enumerate(nexts):
-                        nursery.start_soon(self._accumulate, f, items, i)
-            except ExceptionGroup as excgroup:
-                got_stop = bool(excgroup.split(StopAsyncIteration)[0])
+            async with _core.open_nursery() as nursery:
+                for i, f in enumerate(nexts):
+                    nursery.start_soon(self._accumulate, f, items, i)
 
-            if got_stop:
-                raise StopAsyncIteration
             return items
 
     result = []
@@ -2371,3 +2365,67 @@ async def test_nursery_strict_exception_groups():
     assert len(exc.value.exceptions) == 1
     assert type(exc.value.exceptions[0]) is Exception
     assert exc.value.exceptions[0].args == ("foo",)
+
+
+async def test_nursery_collapse_strict():
+    """
+    Test that a single exception from a nested nursery with strict semantics doesn't get
+    collapsed when CancelledErrors are stripped from it.
+    """
+
+    async def raise_error():
+        raise RuntimeError("test error")
+
+    with pytest.raises(MultiError) as exc:
+        async with _core.open_nursery() as nursery:
+            nursery.start_soon(sleep_forever)
+            nursery.start_soon(raise_error)
+            async with _core.open_nursery(strict_exception_groups=True) as nursery2:
+                nursery2.start_soon(sleep_forever)
+                nursery2.start_soon(raise_error)
+                nursery.cancel_scope.cancel()
+
+    exceptions = exc.value.exceptions
+    assert len(exceptions) == 2
+    assert isinstance(exceptions[0], RuntimeError)
+    assert isinstance(exceptions[1], MultiError)
+    assert len(exceptions[1].exceptions) == 1
+    assert isinstance(exceptions[1].exceptions[0], RuntimeError)
+
+
+async def test_nursery_collapse_loose():
+    """
+    Test that a single exception from a nested nursery with loose semantics gets
+    collapsed when CancelledErrors are stripped from it.
+    """
+
+    async def raise_error():
+        raise RuntimeError("test error")
+
+    with pytest.raises(MultiError) as exc:
+        async with _core.open_nursery() as nursery:
+            nursery.start_soon(sleep_forever)
+            nursery.start_soon(raise_error)
+            async with _core.open_nursery() as nursery2:
+                nursery2.start_soon(sleep_forever)
+                nursery2.start_soon(raise_error)
+                nursery.cancel_scope.cancel()
+
+    exceptions = exc.value.exceptions
+    assert len(exceptions) == 2
+    assert isinstance(exceptions[0], RuntimeError)
+    assert isinstance(exceptions[1], RuntimeError)
+
+
+async def test_cancel_scope_no_cancellederror():
+    """
+    Test that when a cancel scope encounters an exception group that does NOT contain
+    a Cancelled exception, it will NOT set the ``cancelled_caught`` flag.
+    """
+
+    with pytest.raises(ExceptionGroup):
+        with _core.CancelScope() as scope:
+            scope.cancel()
+            raise ExceptionGroup("test", [RuntimeError(), RuntimeError()])
+
+    assert not scope.cancelled_caught