gh-139551: add support for BaseExceptionGroup in IDLE

[Locked-chess-official]

• Issue: IDLE: add support for BaseExceptionGroup #139551

[Locked-chess-official]

Now I have found one different between the IDLE and REPL in this change. However, I don't think it affects:

[Locked-chess-official]

The change that if isinstance(val, BaseExceptionGroup) branch becomes a function alone is difficult because it is a closure function.

[picnixz]

Can you add tests and a What's New entry as well? I think the code could also avoid having all those if prefix: inside the for loops and many times, the additional string is either two spaces or the given prefix.

[picnixz]

Let's swap the if to be consistent with the other ifs.

[picnixz]

I would prefer that - is stored as a variable, say sep = '-' * N where N is the number of '-' you want to print. You would also be able to use "prefix2".

[Locked-chess-official]

The code in traceback.py use many "-" to print instead of sep = '-' * N: (for example now in 3.13.7)

                # 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(colorize=colorize))

                yield from _ctx.emit(exc.format_exception_only(colorize=colorize))
                num_excs = len(exc.exceptions)
                if num_excs <= self.max_group_width:
                    n = num_excs
                else:
                    n = self.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 self.max_group_width is not None:
                        truncated = (i >= self.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, colorize=colorize)
                    else:
                        remaining = num_excs - self.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

[picnixz]

Then I would like you to actually split the lines as it's done, not have everything on a single line (as you can see each group containing - is on its own line).

[picnixz]

Since this is anyway a local function, I'd suggest having other helpers to reduce the complexity of the function.

[picnixz]

For instance, here, I would suggest using a separate function, say print_exc_group() that you would define locally as well.

[picnixz]

The change that if isinstance(val, BaseExceptionGroup) branch becomes a function alone is difficult because it is a closure function.

Even with that, it's not really important. What is the issue with it being a local function? print_exc is already a local function. Just pass the arguments you need to that local function.

[picnixz]

More generally, don't we have a helper in traceback for rendering exception groups actually? Can't we use it?

[Locked-chess-official]

More generally, don't we have a helper in traceback for rendering exception groups actually? Can't we use it?

Maybe not. In IDLE, it need traceback.print_list to print the right tb. If we use it, one tb with file "<pyshell#x>" will have no code and there will be a tb exec(code). So the code must be writed alone here.

[picnixz]

Ok. For now, let's write it as is, and later we can rewrite the exception rendering logic by using the same approach as for traceback.TracebackException where we use a context for indentation. It could reduce the code complexity (compare the current code with traceback.TracebackException.format)

[Locked-chess-official]

I have no idea whether to do it. What should be used is traceback._ExceptionPrintContext wich is a private attribute.

[picnixz]

No, I meant, we should mimic this ourselves. We may need to tweak the context itself, but the approach can be taken. Not in this PR though I would say as it may be too much changes in one PR.