first comit

venv/lib/python3.10/site-packages/exceptiongroup/__init__.py

@@ -0,0 +1,46 @@
+__all__ = [
+    "BaseExceptionGroup",
+    "ExceptionGroup",
+    "catch",
+    "format_exception",
+    "format_exception_only",
+    "print_exception",
+    "print_exc",
+    "suppress",
+]
+
+import os
+import sys
+
+from ._catch import catch
+from ._version import version as __version__  # noqa: F401
+
+if sys.version_info < (3, 11):
+    from ._exceptions import BaseExceptionGroup, ExceptionGroup
+    from ._formatting import (
+        format_exception,
+        format_exception_only,
+        print_exc,
+        print_exception,
+    )
+
+    if os.getenv("EXCEPTIONGROUP_NO_PATCH") != "1":
+        from . import _formatting  # noqa: F401
+
+    BaseExceptionGroup.__module__ = __name__
+    ExceptionGroup.__module__ = __name__
+else:
+    from traceback import (
+        format_exception,
+        format_exception_only,
+        print_exc,
+        print_exception,
+    )
+
+    BaseExceptionGroup = BaseExceptionGroup
+    ExceptionGroup = ExceptionGroup
+
+if sys.version_info < (3, 12, 1):
+    from ._suppress import suppress
+else:
+    from contextlib import suppress

venv/lib/python3.10/site-packages/exceptiongroup/_catch.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import inspect
+import sys
+from collections.abc import Callable, Iterable, Mapping
+from contextlib import AbstractContextManager
+from types import TracebackType
+from typing import TYPE_CHECKING, Any
+
+if sys.version_info < (3, 11):
+    from ._exceptions import BaseExceptionGroup
+
+if TYPE_CHECKING:
+    _Handler = Callable[[BaseException], Any]
+
+
+class _Catcher:
+    def __init__(self, handler_map: Mapping[tuple[type[BaseException], ...], _Handler]):
+        self._handler_map = handler_map
+
+    def __enter__(self) -> None:
+        pass
+
+    def __exit__(
+        self,
+        etype: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> bool:
+        if exc is not None:
+            unhandled = self.handle_exception(exc)
+            if unhandled is exc:
+                return False
+            elif unhandled is None:
+                return True
+            else:
+                if isinstance(exc, BaseExceptionGroup):
+                    try:
+                        raise unhandled from exc.__cause__
+                    except BaseExceptionGroup:
+                        # Change __context__ to __cause__ because Python 3.11 does this
+                        # too
+                        unhandled.__context__ = exc.__cause__
+                        raise
+
+                raise unhandled from exc
+
+        return False
+
+    def handle_exception(self, exc: BaseException) -> BaseException | None:
+        excgroup: BaseExceptionGroup | None
+        if isinstance(exc, BaseExceptionGroup):
+            excgroup = exc
+        else:
+            excgroup = BaseExceptionGroup("", [exc])
+
+        new_exceptions: list[BaseException] = []
+        for exc_types, handler in self._handler_map.items():
+            matched, excgroup = excgroup.split(exc_types)
+            if matched:
+                try:
+                    try:
+                        raise matched
+                    except BaseExceptionGroup:
+                        result = handler(matched)
+                except BaseExceptionGroup as new_exc:
+                    if new_exc is matched:
+                        new_exceptions.append(new_exc)
+                    else:
+                        new_exceptions.extend(new_exc.exceptions)
+                except BaseException as new_exc:
+                    new_exceptions.append(new_exc)
+                else:
+                    if inspect.iscoroutine(result):
+                        raise TypeError(
+                            f"Error trying to handle {matched!r} with {handler!r}. "
+                            "Exception handler must be a sync function."
+                        ) from exc
+
+            if not excgroup:
+                break
+
+        if new_exceptions:
+            if len(new_exceptions) == 1:
+                return new_exceptions[0]
+
+            return BaseExceptionGroup("", new_exceptions)
+        elif (
+            excgroup and len(excgroup.exceptions) == 1 and excgroup.exceptions[0] is exc
+        ):
+            return exc
+        else:
+            return excgroup
+
+
+def catch(
+    __handlers: Mapping[type[BaseException] | Iterable[type[BaseException]], _Handler]
+) -> AbstractContextManager[None]:
+    if not isinstance(__handlers, Mapping):
+        raise TypeError("the argument must be a mapping")
+
+    handler_map: dict[
+        tuple[type[BaseException], ...], Callable[[BaseExceptionGroup]]
+    ] = {}
+    for type_or_iterable, handler in __handlers.items():
+        iterable: tuple[type[BaseException]]
+        if isinstance(type_or_iterable, type) and issubclass(
+            type_or_iterable, BaseException
+        ):
+            iterable = (type_or_iterable,)
+        elif isinstance(type_or_iterable, Iterable):
+            iterable = tuple(type_or_iterable)
+        else:
+            raise TypeError(
+                "each key must be either an exception classes or an iterable thereof"
+            )
+
+        if not callable(handler):
+            raise TypeError("handlers must be callable")
+
+        for exc_type in iterable:
+            if not isinstance(exc_type, type) or not issubclass(
+                exc_type, BaseException
+            ):
+                raise TypeError(
+                    "each key must be either an exception classes or an iterable "
+                    "thereof"
+                )
+
+            if issubclass(exc_type, BaseExceptionGroup):
+                raise TypeError(
+                    "catching ExceptionGroup with catch() is not allowed. "
+                    "Use except instead."
+                )
+
+        handler_map[iterable] = handler
+
+    return _Catcher(handler_map)

venv/lib/python3.10/site-packages/exceptiongroup/_exceptions.py

@@ -0,0 +1,327 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from functools import partial
+from inspect import getmro, isclass
+from typing import TYPE_CHECKING, Generic, Type, TypeVar, cast, overload
+
+if TYPE_CHECKING:
+    from typing import Self
+
+_BaseExceptionT_co = TypeVar("_BaseExceptionT_co", bound=BaseException, covariant=True)
+_BaseExceptionT = TypeVar("_BaseExceptionT", bound=BaseException)
+_ExceptionT_co = TypeVar("_ExceptionT_co", bound=Exception, covariant=True)
+_ExceptionT = TypeVar("_ExceptionT", bound=Exception)
+
+
+def check_direct_subclass(
+    exc: BaseException, parents: tuple[type[BaseException]]
+) -> bool:
+    for cls in getmro(exc.__class__)[:-1]:
+        if cls in parents:
+            return True
+
+    return False
+
+
+def get_condition_filter(
+    condition: type[_BaseExceptionT]
+    | tuple[type[_BaseExceptionT], ...]
+    | Callable[[_BaseExceptionT_co], bool],
+) -> Callable[[_BaseExceptionT_co], bool]:
+    if isclass(condition) and issubclass(
+        cast(Type[BaseException], condition), BaseException
+    ):
+        return partial(check_direct_subclass, parents=(condition,))
+    elif isinstance(condition, tuple):
+        if all(isclass(x) and issubclass(x, BaseException) for x in condition):
+            return partial(check_direct_subclass, parents=condition)
+    elif callable(condition):
+        return cast("Callable[[BaseException], bool]", condition)
+
+    raise TypeError("expected a function, exception type or tuple of exception types")
+
+
+class BaseExceptionGroup(BaseException, Generic[_BaseExceptionT_co]):
+    """A combination of multiple unrelated exceptions."""
+
+    def __new__(
+        cls, __message: str, __exceptions: Sequence[_BaseExceptionT_co]
+    ) -> Self:
+        if not isinstance(__message, str):
+            raise TypeError(f"argument 1 must be str, not {type(__message)}")
+        if not isinstance(__exceptions, Sequence):
+            raise TypeError("second argument (exceptions) must be a sequence")
+        if not __exceptions:
+            raise ValueError(
+                "second argument (exceptions) must be a non-empty sequence"
+            )
+
+        for i, exc in enumerate(__exceptions):
+            if not isinstance(exc, BaseException):
+                raise ValueError(
+                    f"Item {i} of second argument (exceptions) is not an exception"
+                )
+
+        if cls is BaseExceptionGroup:
+            if all(isinstance(exc, Exception) for exc in __exceptions):
+                cls = ExceptionGroup
+
+        if issubclass(cls, Exception):
+            for exc in __exceptions:
+                if not isinstance(exc, Exception):
+                    if cls is ExceptionGroup:
+                        raise TypeError(
+                            "Cannot nest BaseExceptions in an ExceptionGroup"
+                        )
+                    else:
+                        raise TypeError(
+                            f"Cannot nest BaseExceptions in {cls.__name__!r}"
+                        )
+
+        instance = super().__new__(cls, __message, __exceptions)
+        instance._message = __message
+        instance._exceptions = __exceptions
+        return instance
+
+    def add_note(self, note: str) -> None:
+        if not isinstance(note, str):
+            raise TypeError(
+                f"Expected a string, got note={note!r} (type {type(note).__name__})"
+            )
+
+        if not hasattr(self, "__notes__"):
+            self.__notes__: list[str] = []
+
+        self.__notes__.append(note)
+
+    @property
+    def message(self) -> str:
+        return self._message
+
+    @property
+    def exceptions(
+        self,
+    ) -> tuple[_BaseExceptionT_co | BaseExceptionGroup[_BaseExceptionT_co], ...]:
+        return tuple(self._exceptions)
+
+    @overload
+    def subgroup(
+        self, __condition: type[_ExceptionT] | tuple[type[_ExceptionT], ...]
+    ) -> ExceptionGroup[_ExceptionT] | None:
+        ...
+
+    @overload
+    def subgroup(
+        self, __condition: type[_BaseExceptionT] | tuple[type[_BaseExceptionT], ...]
+    ) -> BaseExceptionGroup[_BaseExceptionT] | None:
+        ...
+
+    @overload
+    def subgroup(
+        self, __condition: Callable[[_BaseExceptionT_co | Self], bool]
+    ) -> BaseExceptionGroup[_BaseExceptionT_co] | None:
+        ...
+
+    def subgroup(
+        self,
+        __condition: type[_BaseExceptionT]
+        | tuple[type[_BaseExceptionT], ...]
+        | Callable[[_BaseExceptionT_co | Self], bool],
+    ) -> BaseExceptionGroup[_BaseExceptionT] | None:
+        condition = get_condition_filter(__condition)
+        modified = False
+        if condition(self):
+            return self
+
+        exceptions: list[BaseException] = []
+        for exc in self.exceptions:
+            if isinstance(exc, BaseExceptionGroup):
+                subgroup = exc.subgroup(__condition)
+                if subgroup is not None:
+                    exceptions.append(subgroup)
+
+                if subgroup is not exc:
+                    modified = True
+            elif condition(exc):
+                exceptions.append(exc)
+            else:
+                modified = True
+
+        if not modified:
+            return self
+        elif exceptions:
+            group = self.derive(exceptions)
+            group.__cause__ = self.__cause__
+            group.__context__ = self.__context__
+            group.__traceback__ = self.__traceback__
+            return group
+        else:
+            return None
+
+    @overload
+    def split(
+        self, __condition: type[_ExceptionT] | tuple[type[_ExceptionT], ...]
+    ) -> tuple[
+        ExceptionGroup[_ExceptionT] | None,
+        BaseExceptionGroup[_BaseExceptionT_co] | None,
+    ]:
+        ...
+
+    @overload
+    def split(
+        self, __condition: type[_BaseExceptionT] | tuple[type[_BaseExceptionT], ...]
+    ) -> tuple[
+        BaseExceptionGroup[_BaseExceptionT] | None,
+        BaseExceptionGroup[_BaseExceptionT_co] | None,
+    ]:
+        ...
+
+    @overload
+    def split(
+        self, __condition: Callable[[_BaseExceptionT_co | Self], bool]
+    ) -> tuple[
+        BaseExceptionGroup[_BaseExceptionT_co] | None,
+        BaseExceptionGroup[_BaseExceptionT_co] | None,
+    ]:
+        ...
+
+    def split(
+        self,
+        __condition: type[_BaseExceptionT]
+        | tuple[type[_BaseExceptionT], ...]
+        | Callable[[_BaseExceptionT_co], bool],
+    ) -> (
+        tuple[
+            ExceptionGroup[_ExceptionT] | None,
+            BaseExceptionGroup[_BaseExceptionT_co] | None,
+        ]
+        | tuple[
+            BaseExceptionGroup[_BaseExceptionT] | None,
+            BaseExceptionGroup[_BaseExceptionT_co] | None,
+        ]
+        | tuple[
+            BaseExceptionGroup[_BaseExceptionT_co] | None,
+            BaseExceptionGroup[_BaseExceptionT_co] | None,
+        ]
+    ):
+        condition = get_condition_filter(__condition)
+        if condition(self):
+            return self, None
+
+        matching_exceptions: list[BaseException] = []
+        nonmatching_exceptions: list[BaseException] = []
+        for exc in self.exceptions:
+            if isinstance(exc, BaseExceptionGroup):
+                matching, nonmatching = exc.split(condition)
+                if matching is not None:
+                    matching_exceptions.append(matching)
+
+                if nonmatching is not None:
+                    nonmatching_exceptions.append(nonmatching)
+            elif condition(exc):
+                matching_exceptions.append(exc)
+            else:
+                nonmatching_exceptions.append(exc)
+
+        matching_group: Self | None = None
+        if matching_exceptions:
+            matching_group = self.derive(matching_exceptions)
+            matching_group.__cause__ = self.__cause__
+            matching_group.__context__ = self.__context__
+            matching_group.__traceback__ = self.__traceback__
+
+        nonmatching_group: Self | None = None
+        if nonmatching_exceptions:
+            nonmatching_group = self.derive(nonmatching_exceptions)
+            nonmatching_group.__cause__ = self.__cause__
+            nonmatching_group.__context__ = self.__context__
+            nonmatching_group.__traceback__ = self.__traceback__
+
+        return matching_group, nonmatching_group
+
+    @overload
+    def derive(self, __excs: Sequence[_ExceptionT]) -> ExceptionGroup[_ExceptionT]:
+        ...
+
+    @overload
+    def derive(
+        self, __excs: Sequence[_BaseExceptionT]
+    ) -> BaseExceptionGroup[_BaseExceptionT]:
+        ...
+
+    def derive(
+        self, __excs: Sequence[_BaseExceptionT]
+    ) -> BaseExceptionGroup[_BaseExceptionT]:
+        eg = BaseExceptionGroup(self.message, __excs)
+        if hasattr(self, "__notes__"):
+            # Create a new list so that add_note() only affects one exceptiongroup
+            eg.__notes__ = list(self.__notes__)
+
+        return eg
+
+    def __str__(self) -> str:
+        suffix = "" if len(self._exceptions) == 1 else "s"
+        return f"{self.message} ({len(self._exceptions)} sub-exception{suffix})"
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self.message!r}, {self._exceptions!r})"
+
+
+class ExceptionGroup(BaseExceptionGroup[_ExceptionT_co], Exception):
+    def __new__(cls, __message: str, __exceptions: Sequence[_ExceptionT_co]) -> Self:
+        return super().__new__(cls, __message, __exceptions)
+
+    if TYPE_CHECKING:
+
+        @property
+        def exceptions(
+            self,
+        ) -> tuple[_ExceptionT_co | ExceptionGroup[_ExceptionT_co], ...]:
+            ...
+
+        @overload  # type: ignore[override]
+        def subgroup(
+            self, __condition: type[_ExceptionT] | tuple[type[_ExceptionT], ...]
+        ) -> ExceptionGroup[_ExceptionT] | None:
+            ...
+
+        @overload
+        def subgroup(
+            self, __condition: Callable[[_ExceptionT_co | Self], bool]
+        ) -> ExceptionGroup[_ExceptionT_co] | None:
+            ...
+
+        def subgroup(
+            self,
+            __condition: type[_ExceptionT]
+            | tuple[type[_ExceptionT], ...]
+            | Callable[[_ExceptionT_co], bool],
+        ) -> ExceptionGroup[_ExceptionT] | None:
+            return super().subgroup(__condition)
+
+        @overload
+        def split(
+            self, __condition: type[_ExceptionT] | tuple[type[_ExceptionT], ...]
+        ) -> tuple[
+            ExceptionGroup[_ExceptionT] | None, ExceptionGroup[_ExceptionT_co] | None
+        ]:
+            ...
+
+        @overload
+        def split(
+            self, __condition: Callable[[_ExceptionT_co | Self], bool]
+        ) -> tuple[
+            ExceptionGroup[_ExceptionT_co] | None, ExceptionGroup[_ExceptionT_co] | None
+        ]:
+            ...
+
+        def split(
+            self: Self,
+            __condition: type[_ExceptionT]
+            | tuple[type[_ExceptionT], ...]
+            | Callable[[_ExceptionT_co], bool],
+        ) -> tuple[
+            ExceptionGroup[_ExceptionT_co] | None, ExceptionGroup[_ExceptionT_co] | None
+        ]:
+            return super().split(__condition)

venv/lib/python3.10/site-packages/exceptiongroup/_formatting.py

@@ -0,0 +1,603 @@
+# traceback_exception_init() adapted from trio
+#
+# _ExceptionPrintContext and traceback_exception_format() copied from the standard
+# library
+from __future__ import annotations
+
+import collections.abc
+import sys
+import textwrap
+import traceback
+from functools import singledispatch
+from types import TracebackType
+from typing import Any, List, Optional
+
+from ._exceptions import BaseExceptionGroup
+
+max_group_width = 15
+max_group_depth = 10
+_cause_message = (
+    "\nThe above exception was the direct cause of the following exception:\n\n"
+)
+
+_context_message = (
+    "\nDuring handling of the above exception, another exception occurred:\n\n"
+)
+
+
+def _format_final_exc_line(etype, value):
+    valuestr = _safe_string(value, "exception")
+    if value is None or not valuestr:
+        line = f"{etype}\n"
+    else:
+        line = f"{etype}: {valuestr}\n"
+
+    return line
+
+
+def _safe_string(value, what, func=str):
+    try:
+        return func(value)
+    except BaseException:
+        return f"<{what} {func.__name__}() failed>"
+
+
+class _ExceptionPrintContext:
+    def __init__(self):
+        self.seen = set()
+        self.exception_group_depth = 0
+        self.need_close = False
+
+    def indent(self):
+        return " " * (2 * self.exception_group_depth)
+
+    def emit(self, text_gen, margin_char=None):
+        if margin_char is None:
+            margin_char = "|"
+        indent_str = self.indent()
+        if self.exception_group_depth:
+            indent_str += margin_char + " "
+
+        if isinstance(text_gen, str):
+            yield textwrap.indent(text_gen, indent_str, lambda line: True)
+        else:
+            for text in text_gen:
+                yield textwrap.indent(text, indent_str, lambda line: True)
+
+
+def exceptiongroup_excepthook(
+    etype: type[BaseException], value: BaseException, tb: TracebackType | None
+) -> None:
+    sys.stderr.write("".join(traceback.format_exception(etype, value, tb)))
+
+
+class PatchedTracebackException(traceback.TracebackException):
+    def __init__(
+        self,
+        exc_type: type[BaseException],
+        exc_value: BaseException,
+        exc_traceback: TracebackType | None,
+        *,
+        limit: int | None = None,
+        lookup_lines: bool = True,
+        capture_locals: bool = False,
+        compact: bool = False,
+        _seen: set[int] | None = None,
+    ) -> None:
+        kwargs: dict[str, Any] = {}
+        if sys.version_info >= (3, 10):
+            kwargs["compact"] = compact
+
+        is_recursive_call = _seen is not None
+        if _seen is None:
+            _seen = set()
+        _seen.add(id(exc_value))
+
+        self.stack = traceback.StackSummary.extract(
+            traceback.walk_tb(exc_traceback),
+            limit=limit,
+            lookup_lines=lookup_lines,
+            capture_locals=capture_locals,
+        )
+        self.exc_type = exc_type
+        # Capture now to permit freeing resources: only complication is in the
+        # unofficial API _format_final_exc_line
+        self._str = _safe_string(exc_value, "exception")
+        try:
+            self.__notes__ = getattr(exc_value, "__notes__", None)
+        except KeyError:
+            # Workaround for https://github.com/python/cpython/issues/98778 on Python
+            # <= 3.9, and some 3.10 and 3.11 patch versions.
+            HTTPError = getattr(sys.modules.get("urllib.error", None), "HTTPError", ())
+            if sys.version_info[:2] <= (3, 11) and isinstance(exc_value, HTTPError):
+                self.__notes__ = None
+            else:
+                raise
+
+        if exc_type and issubclass(exc_type, SyntaxError):
+            # Handle SyntaxError's specially
+            self.filename = exc_value.filename
+            lno = exc_value.lineno
+            self.lineno = str(lno) if lno is not None else None
+            self.text = exc_value.text
+            self.offset = exc_value.offset
+            self.msg = exc_value.msg
+            if sys.version_info >= (3, 10):
+                end_lno = exc_value.end_lineno
+                self.end_lineno = str(end_lno) if end_lno is not None else None
+                self.end_offset = exc_value.end_offset
+        elif (
+            exc_type
+            and issubclass(exc_type, (NameError, AttributeError))
+            and getattr(exc_value, "name", None) is not None
+        ):
+            suggestion = _compute_suggestion_error(exc_value, exc_traceback)
+            if suggestion:
+                self._str += f". Did you mean: '{suggestion}'?"
+
+        if lookup_lines:
+            # Force all lines in the stack to be loaded
+            for frame in self.stack:
+                frame.line
+
+        self.__suppress_context__ = (
+            exc_value.__suppress_context__ if exc_value is not None else False
+        )
+
+        # Convert __cause__ and __context__ to `TracebackExceptions`s, use a
+        # queue to avoid recursion (only the top-level call gets _seen == None)
+        if not is_recursive_call:
+            queue = [(self, exc_value)]
+            while queue:
+                te, e = queue.pop()
+
+                if e and e.__cause__ is not None and id(e.__cause__) not in _seen:
+                    cause = PatchedTracebackException(
+                        type(e.__cause__),
+                        e.__cause__,
+                        e.__cause__.__traceback__,
+                        limit=limit,
+                        lookup_lines=lookup_lines,
+                        capture_locals=capture_locals,
+                        _seen=_seen,
+                    )
+                else:
+                    cause = None
+
+                if compact:
+                    need_context = (
+                        cause is None and e is not None and not e.__suppress_context__
+                    )
+                else:
+                    need_context = True
+                if (
+                    e
+                    and e.__context__ is not None
+                    and need_context
+                    and id(e.__context__) not in _seen
+                ):
+                    context = PatchedTracebackException(
+                        type(e.__context__),
+                        e.__context__,
+                        e.__context__.__traceback__,
+                        limit=limit,
+                        lookup_lines=lookup_lines,
+                        capture_locals=capture_locals,
+                        _seen=_seen,
+                    )
+                else:
+                    context = None
+
+                # Capture each of the exceptions in the ExceptionGroup along with each
+                # of their causes and contexts
+                if e and isinstance(e, BaseExceptionGroup):
+                    exceptions = []
+                    for exc in e.exceptions:
+                        texc = PatchedTracebackException(
+                            type(exc),
+                            exc,
+                            exc.__traceback__,
+                            lookup_lines=lookup_lines,
+                            capture_locals=capture_locals,
+                            _seen=_seen,
+                        )
+                        exceptions.append(texc)
+                else:
+                    exceptions = None
+
+                te.__cause__ = cause
+                te.__context__ = context
+                te.exceptions = exceptions
+                if cause:
+                    queue.append((te.__cause__, e.__cause__))
+                if context:
+                    queue.append((te.__context__, e.__context__))
+                if exceptions:
+                    queue.extend(zip(te.exceptions, e.exceptions))
+
+    def format(self, *, chain=True, _ctx=None):
+        if _ctx is None:
+            _ctx = _ExceptionPrintContext()
+
+        output = []
+        exc = self
+        if chain:
+            while exc:
+                if exc.__cause__ is not None:
+                    chained_msg = _cause_message
+                    chained_exc = exc.__cause__
+                elif exc.__context__ is not None and not exc.__suppress_context__:
+                    chained_msg = _context_message
+                    chained_exc = exc.__context__
+                else:
+                    chained_msg = None
+                    chained_exc = None
+
+                output.append((chained_msg, exc))
+                exc = chained_exc
+        else:
+            output.append((None, exc))
+
+        for msg, exc in reversed(output):
+            if msg is not None:
+                yield from _ctx.emit(msg)
+            if exc.exceptions is None:
+                if exc.stack:
+                    yield from _ctx.emit("Traceback (most recent call last):\n")
+                    yield from _ctx.emit(exc.stack.format())
+                yield from _ctx.emit(exc.format_exception_only())
+            elif _ctx.exception_group_depth > max_group_depth:
+                # exception group, but depth exceeds limit
+                yield from _ctx.emit(f"... (max_group_depth is {max_group_depth})\n")
+            else:
+                # format exception group
+                is_toplevel = _ctx.exception_group_depth == 0
+                if is_toplevel:
+                    _ctx.exception_group_depth += 1
+
+                if exc.stack:
+                    yield from _ctx.emit(
+                        "Exception Group Traceback (most recent call last):\n",
+                        margin_char="+" if is_toplevel else None,
+                    )
+                    yield from _ctx.emit(exc.stack.format())
+
+                yield from _ctx.emit(exc.format_exception_only())
+                num_excs = len(exc.exceptions)
+                if num_excs <= max_group_width:
+                    n = num_excs
+                else:
+                    n = max_group_width + 1
+                _ctx.need_close = False
+                for i in range(n):
+                    last_exc = i == n - 1
+                    if last_exc:
+                        # The closing frame may be added by a recursive call
+                        _ctx.need_close = True
+
+                    if max_group_width is not None:
+                        truncated = i >= max_group_width
+                    else:
+                        truncated = False
+                    title = f"{i + 1}" if not truncated else "..."
+                    yield (
+                        _ctx.indent()
+                        + ("+-" if i == 0 else "  ")
+                        + f"+---------------- {title} ----------------\n"
+                    )
+                    _ctx.exception_group_depth += 1
+                    if not truncated:
+                        yield from exc.exceptions[i].format(chain=chain, _ctx=_ctx)
+                    else:
+                        remaining = num_excs - max_group_width
+                        plural = "s" if remaining > 1 else ""
+                        yield from _ctx.emit(
+                            f"and {remaining} more exception{plural}\n"
+                        )
+
+                    if last_exc and _ctx.need_close:
+                        yield _ctx.indent() + "+------------------------------------\n"
+                        _ctx.need_close = False
+                    _ctx.exception_group_depth -= 1
+
+                if is_toplevel:
+                    assert _ctx.exception_group_depth == 1
+                    _ctx.exception_group_depth = 0
+
+    def format_exception_only(self):
+        """Format the exception part of the traceback.
+        The return value is a generator of strings, each ending in a newline.
+        Normally, the generator emits a single string; however, for
+        SyntaxError exceptions, it emits several lines that (when
+        printed) display detailed information about where the syntax
+        error occurred.
+        The message indicating which exception occurred is always the last
+        string in the output.
+        """
+        if self.exc_type is None:
+            yield traceback._format_final_exc_line(None, self._str)
+            return
+
+        stype = self.exc_type.__qualname__
+        smod = self.exc_type.__module__
+        if smod not in ("__main__", "builtins"):
+            if not isinstance(smod, str):
+                smod = "<unknown>"
+            stype = smod + "." + stype
+
+        if not issubclass(self.exc_type, SyntaxError):
+            yield _format_final_exc_line(stype, self._str)
+        elif traceback_exception_format_syntax_error is not None:
+            yield from traceback_exception_format_syntax_error(self, stype)
+        else:
+            yield from traceback_exception_original_format_exception_only(self)
+
+        if isinstance(self.__notes__, collections.abc.Sequence):
+            for note in self.__notes__:
+                note = _safe_string(note, "note")
+                yield from [line + "\n" for line in note.split("\n")]
+        elif self.__notes__ is not None:
+            yield _safe_string(self.__notes__, "__notes__", func=repr)
+
+
+traceback_exception_original_format = traceback.TracebackException.format
+traceback_exception_original_format_exception_only = (
+    traceback.TracebackException.format_exception_only
+)
+traceback_exception_format_syntax_error = getattr(
+    traceback.TracebackException, "_format_syntax_error", None
+)
+if sys.excepthook is sys.__excepthook__:
+    traceback.TracebackException.__init__ = (  # type: ignore[assignment]
+        PatchedTracebackException.__init__
+    )
+    traceback.TracebackException.format = (  # type: ignore[assignment]
+        PatchedTracebackException.format
+    )
+    traceback.TracebackException.format_exception_only = (  # type: ignore[assignment]
+        PatchedTracebackException.format_exception_only
+    )
+    sys.excepthook = exceptiongroup_excepthook
+
+# Ubuntu's system Python has a sitecustomize.py file that imports
+# 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 getattr(sys.excepthook, "__name__", None) in (
+    "apport_excepthook",
+    # on ubuntu 22.10 the hook was renamed to partial_apport_excepthook
+    "partial_apport_excepthook",
+):
+    # patch traceback like above
+    traceback.TracebackException.__init__ = (  # type: ignore[assignment]
+        PatchedTracebackException.__init__
+    )
+    traceback.TracebackException.format = (  # type: ignore[assignment]
+        PatchedTracebackException.format
+    )
+    traceback.TracebackException.format_exception_only = (  # type: ignore[assignment]
+        PatchedTracebackException.format_exception_only
+    )
+
+    from types import ModuleType
+
+    import apport_python_hook
+
+    assert sys.excepthook is apport_python_hook.apport_excepthook
+
+    # monkeypatch the sys module that apport has imported
+    fake_sys = ModuleType("exceptiongroup_fake_sys")
+    fake_sys.__dict__.update(sys.__dict__)
+    fake_sys.__excepthook__ = exceptiongroup_excepthook
+    apport_python_hook.sys = fake_sys
+
+
+@singledispatch
+def format_exception_only(__exc: BaseException) -> List[str]:
+    return list(
+        PatchedTracebackException(
+            type(__exc), __exc, None, compact=True
+        ).format_exception_only()
+    )
+
+
+@format_exception_only.register
+def _(__exc: type, value: BaseException) -> List[str]:
+    return format_exception_only(value)
+
+
+@singledispatch
+def format_exception(
+    __exc: BaseException,
+    limit: Optional[int] = None,
+    chain: bool = True,
+) -> List[str]:
+    return list(
+        PatchedTracebackException(
+            type(__exc), __exc, __exc.__traceback__, limit=limit, compact=True
+        ).format(chain=chain)
+    )
+
+
+@format_exception.register
+def _(
+    __exc: type,
+    value: BaseException,
+    tb: TracebackType,
+    limit: Optional[int] = None,
+    chain: bool = True,
+) -> List[str]:
+    return format_exception(value, limit, chain)
+
+
+@singledispatch
+def print_exception(
+    __exc: BaseException,
+    limit: Optional[int] = None,
+    file: Any = None,
+    chain: bool = True,
+) -> None:
+    if file is None:
+        file = sys.stderr
+
+    for line in PatchedTracebackException(
+        type(__exc), __exc, __exc.__traceback__, limit=limit
+    ).format(chain=chain):
+        print(line, file=file, end="")
+
+
+@print_exception.register
+def _(
+    __exc: type,
+    value: BaseException,
+    tb: TracebackType,
+    limit: Optional[int] = None,
+    file: Any = None,
+    chain: bool = True,
+) -> None:
+    print_exception(value, limit, file, chain)
+
+
+def print_exc(
+    limit: Optional[int] = None,
+    file: Any | None = None,
+    chain: bool = True,
+) -> None:
+    value = sys.exc_info()[1]
+    print_exception(value, limit, file, chain)
+
+
+# Python levenshtein edit distance code for NameError/AttributeError
+# suggestions, backported from 3.12
+
+_MAX_CANDIDATE_ITEMS = 750
+_MAX_STRING_SIZE = 40
+_MOVE_COST = 2
+_CASE_COST = 1
+_SENTINEL = object()
+
+
+def _substitution_cost(ch_a, ch_b):
+    if ch_a == ch_b:
+        return 0
+    if ch_a.lower() == ch_b.lower():
+        return _CASE_COST
+    return _MOVE_COST
+
+
+def _compute_suggestion_error(exc_value, tb):
+    wrong_name = getattr(exc_value, "name", None)
+    if wrong_name is None or not isinstance(wrong_name, str):
+        return None
+    if isinstance(exc_value, AttributeError):
+        obj = getattr(exc_value, "obj", _SENTINEL)
+        if obj is _SENTINEL:
+            return None
+        obj = exc_value.obj
+        try:
+            d = dir(obj)
+        except Exception:
+            return None
+    else:
+        assert isinstance(exc_value, NameError)
+        # find most recent frame
+        if tb is None:
+            return None
+        while tb.tb_next is not None:
+            tb = tb.tb_next
+        frame = tb.tb_frame
+
+        d = list(frame.f_locals) + list(frame.f_globals) + list(frame.f_builtins)
+    if len(d) > _MAX_CANDIDATE_ITEMS:
+        return None
+    wrong_name_len = len(wrong_name)
+    if wrong_name_len > _MAX_STRING_SIZE:
+        return None
+    best_distance = wrong_name_len
+    suggestion = None
+    for possible_name in d:
+        if possible_name == wrong_name:
+            # A missing attribute is "found". Don't suggest it (see GH-88821).
+            continue
+        # No more than 1/3 of the involved characters should need changed.
+        max_distance = (len(possible_name) + wrong_name_len + 3) * _MOVE_COST // 6
+        # Don't take matches we've already beaten.
+        max_distance = min(max_distance, best_distance - 1)
+        current_distance = _levenshtein_distance(
+            wrong_name, possible_name, max_distance
+        )
+        if current_distance > max_distance:
+            continue
+        if not suggestion or current_distance < best_distance:
+            suggestion = possible_name
+            best_distance = current_distance
+    return suggestion
+
+
+def _levenshtein_distance(a, b, max_cost):
+    # A Python implementation of Python/suggestions.c:levenshtein_distance.
+
+    # Both strings are the same
+    if a == b:
+        return 0
+
+    # Trim away common affixes
+    pre = 0
+    while a[pre:] and b[pre:] and a[pre] == b[pre]:
+        pre += 1
+    a = a[pre:]
+    b = b[pre:]
+    post = 0
+    while a[: post or None] and b[: post or None] and a[post - 1] == b[post - 1]:
+        post -= 1
+    a = a[: post or None]
+    b = b[: post or None]
+    if not a or not b:
+        return _MOVE_COST * (len(a) + len(b))
+    if len(a) > _MAX_STRING_SIZE or len(b) > _MAX_STRING_SIZE:
+        return max_cost + 1
+
+    # Prefer shorter buffer
+    if len(b) < len(a):
+        a, b = b, a
+
+    # Quick fail when a match is impossible
+    if (len(b) - len(a)) * _MOVE_COST > max_cost:
+        return max_cost + 1
+
+    # Instead of producing the whole traditional len(a)-by-len(b)
+    # matrix, we can update just one row in place.
+    # Initialize the buffer row
+    row = list(range(_MOVE_COST, _MOVE_COST * (len(a) + 1), _MOVE_COST))
+
+    result = 0
+    for bindex in range(len(b)):
+        bchar = b[bindex]
+        distance = result = bindex * _MOVE_COST
+        minimum = sys.maxsize
+        for index in range(len(a)):
+            # 1) Previous distance in this row is cost(b[:b_index], a[:index])
+            substitute = distance + _substitution_cost(bchar, a[index])
+            # 2) cost(b[:b_index], a[:index+1]) from previous row
+            distance = row[index]
+            # 3) existing result is cost(b[:b_index+1], a[index])
+
+            insert_delete = min(result, distance) + _MOVE_COST
+            result = min(insert_delete, substitute)
+
+            # cost(b[:b_index+1], a[:index+1])
+            row[index] = result
+            if result < minimum:
+                minimum = result
+        if minimum > max_cost:
+            # Everything in this row is too big, so bail early.
+            return max_cost + 1
+    return result

venv/lib/python3.10/site-packages/exceptiongroup/_suppress.py

@@ -0,0 +1,40 @@
+import sys
+from contextlib import AbstractContextManager
+
+if sys.version_info < (3, 11):
+    from ._exceptions import BaseExceptionGroup
+
+
+class suppress(AbstractContextManager):
+    """Backport of :class:`contextlib.suppress` from Python 3.12.1."""
+
+    def __init__(self, *exceptions):
+        self._exceptions = exceptions
+
+    def __enter__(self):
+        pass
+
+    def __exit__(self, exctype, excinst, exctb):
+        # Unlike isinstance and issubclass, CPython exception handling
+        # currently only looks at the concrete type hierarchy (ignoring
+        # the instance and subclass checking hooks). While Guido considers
+        # that a bug rather than a feature, it's a fairly hard one to fix
+        # due to various internal implementation details. suppress provides
+        # the simpler issubclass based semantics, rather than trying to
+        # exactly reproduce the limitations of the CPython interpreter.
+        #
+        # See http://bugs.python.org/issue12029 for more details
+        if exctype is None:
+            return
+
+        if issubclass(exctype, self._exceptions):
+            return True
+
+        if issubclass(exctype, BaseExceptionGroup):
+            match, rest = excinst.split(self._exceptions)
+            if rest is None:
+                return True
+
+            raise rest
+
+        return False

venv/lib/python3.10/site-packages/exceptiongroup/_version.py

@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '1.2.0'
+__version_tuple__ = version_tuple = (1, 2, 0)