Allow Pdb to move between chained exception.

This lets Pdb receive and exception, instead of a traceback, and when
this is the case and the exception are chained, up/down allow to move
between the chained exceptions when reaching the tot/bottom.

That is to say if you have something like

    def out():
        try:
            middle()                                # B
        except Exception as e:
            raise ValueError("foo(): bar failed")   # A

    def middle():
        try:
            return inner(0)                         # D
        except Exception as e:
            raise ValueError("Middle fail")         # C

    def inner(x):
        1 / x                                       # E

Only A is reachable after calling `out()` and doing post mortem debug.
With this all A-E points are reachable with up/down.

I do not change the default behavior of ``pdb.pm()``, but I think that
arguably the default should be to pass `sys.last_value` so that chained
exception navigation is enabled.

Closes gh-106670

Author: Carreau

Lib/pdb.py

@@ -206,6 +206,7 @@ def namespace(self):
 line_prefix = '\n-> '   # Probably a better default
 
 class Pdb(bdb.Bdb, cmd.Cmd):
+    _chained_exceptions = []
 
     _previous_sigint_handler = None
 
@@ -416,6 +417,15 @@ def preloop(self):
 
     def interaction(self, frame, traceback):
         # Restore the previous signal handler at the Pdb prompt.
+
+        if isinstance(traceback, BaseException):
+            traceback, exception = traceback.__traceback__, traceback
+            self._chained_exceptions = [exception]
+        else:
+            self._chained_exceptions = []
+
+        # list of exceptions in chain exception, we always start with the current one.
+
         if Pdb._previous_sigint_handler:
             try:
                 signal.signal(signal.SIGINT, Pdb._previous_sigint_handler)
@@ -1080,6 +1090,15 @@ def do_up(self, arg):
         stack trace (to an older frame).
         """
         if self.curindex == 0:
+            if len(self._chained_exceptions) > 1:
+                self.message("Oldest frame, moving to last frame upper exception")
+                self._chained_exceptions.pop()
+                self.setup(None, self._chained_exceptions[-1].__traceback__)
+                self.curindex = len(self.stack)
+                arg = "0"
+            else:
+                self.error("Oldest frame")
+                return
             self.error('Oldest frame')
             return
         try:
@@ -1101,8 +1120,17 @@ def do_down(self, arg):
         stack trace (to a newer frame).
         """
         if self.curindex + 1 == len(self.stack):
-            self.error('Newest frame')
-            return
+            if self._chained_exceptions and self._chained_exceptions[-1].__context__:
+                new_ex = self._chained_exceptions[-1].__context__
+
+                self.message("Newest frame, moving into __context__ traceback.")
+                self._chained_exceptions.append(new_ex)
+                self.setup(None, new_ex.__traceback__)
+                self.curindex = -1
+                arg = "1"
+            else:
+                self.error("Newest frame")
+                return
         try:
             count = int(arg or 1)
         except ValueError:
@@ -1895,6 +1923,10 @@ def post_mortem(t=None):
     If no traceback is given, it uses the one of the exception that is
     currently being handled (an exception must be being handled if the
     default is to be used).
+
+    If t is an Exception and is a chained exception (i.e it has a __context__),
+    pdb will be able to move to the sub-exception when reaching the bottom
+    frame.
     """
     # handling the default
     if t is None:

Lib/test/test_pdb.py

@@ -826,6 +826,77 @@ def test_convenience_variables():
     (Pdb) continue
     """
 
+
+def test_post_mortem_chained():
+    """Test post mortem traceback debugging of chained exception
+
+    >>> def test_function_2():
+    ...     try:
+    ...         1/0
+    ...     finally:
+    ...         print('Exception!')
+
+    >>> def test_function_reraise():
+    ...     try:
+    ...         test_function_2()
+    ...     except ZeroDivisionError as e:
+    ...         raise ZeroDivisionError('reraised') from e
+
+    >>> def test_function():
+    ...     import pdb;
+    ...     instance = pdb.Pdb(nosigint=True, readrc=False)
+    ...     try:
+    ...         test_function_reraise()
+    ...     except Exception as e:
+    ...         # same as pdb.post_mortem(e), but with custom pdb instance.
+    ...         instance.reset()
+    ...         instance.interaction(None, e)
+
+    >>> with PdbTestInput([  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
+    ...     'up',
+    ...     'up',
+    ...     'down',
+    ...     'down',
+    ...     'down',
+    ...     'down',
+    ...     'up',
+    ...     'up',
+    ...     'exit',
+    ... ]):
+    ...    try:
+    ...        test_function()
+    ...    except ZeroDivisionError:
+    ...        print('Correctly reraised.')
+    Exception!
+    > <doctest test.test_pdb.test_post_mortem_chained[1]>(5)test_function_reraise()
+    -> raise ZeroDivisionError('reraised') from e
+    (Pdb) up
+    > <doctest test.test_pdb.test_post_mortem_chained[2]>(5)test_function()
+    -> test_function_reraise()
+    (Pdb) up
+    *** Oldest frame
+    (Pdb) down
+    > <doctest test.test_pdb.test_post_mortem_chained[1]>(5)test_function_reraise()
+    -> raise ZeroDivisionError('reraised') from e
+    (Pdb) down
+    Newest frame, moving into __context__ traceback.
+    > <doctest test.test_pdb.test_post_mortem_chained[1]>(3)test_function_reraise()
+    -> test_function_2()
+    (Pdb) down
+    > <doctest test.test_pdb.test_post_mortem_chained[0]>(3)test_function_2()
+    -> 1/0
+    (Pdb) down
+    *** Newest frame
+    (Pdb) up
+    > <doctest test.test_pdb.test_post_mortem_chained[1]>(3)test_function_reraise()
+    -> test_function_2()
+    (Pdb) up
+    Oldest frame, moving to last frame upper exception
+    *** Oldest frame
+    (Pdb) exit
+    """
+
+
 def test_post_mortem():
     """Test post mortem traceback debugging.
 

Misc/NEWS.d/next/Library/2023-07-12-10-59-08.gh-issue-106670.goQ2Sy.rst

@@ -0,0 +1,8 @@
+Allow Pdb to move between chained exceptions on post_mortem debugging.
+
+If Pdb.post_mortem() is called with a chained exception, it will now allow
+the user to move between the chained exceptions using ``up`` and ``down``
+commands.
+
+When reaching the bottom of the stacktrace, Pdb will move the first frame of
+the next exception. And vice-versa, when reaching the top of the stacktrace.