gh-154002: Fix exception chaining in pickle._Unpickler._instantiate

When a class constructor raised TypeError during old-style (INST/OBJ)
unpickling, the pure-Python unpickler did
`raise TypeError(msg, err.__traceback__)`, which stored the traceback
object in the exception's args and performed no real chaining
(__cause__ stayed None). Use `raise TypeError(msg) from err` instead.
The C implementation is unaffected; it lets the original error propagate.

Author: fedonman

Lib/pickle.py

@@ -1627,7 +1627,7 @@ def _instantiate(self, klass, args):
                 value = klass(*args)
             except TypeError as err:
                 raise TypeError("in constructor for %s: %s" %
-                                (klass.__name__, str(err)), err.__traceback__)
+                                (klass.__name__, str(err))) from err
         else:
             value = klass.__new__(klass)
         self.append(value)

Lib/test/picklecommon.py

@@ -17,13 +17,20 @@ class E(C):
     def __getinitargs__(self):
         return ()
 
+# For test_load_bad_constructor
+class BadConstructor:
+    def __init__(self, *args):
+        raise TypeError("bad constructor")
+
 import __main__
 __main__.C = C
 C.__module__ = "__main__"
 __main__.D = D
 D.__module__ = "__main__"
 __main__.E = E
 E.__module__ = "__main__"
+__main__.BadConstructor = BadConstructor
+BadConstructor.__module__ = "__main__"
 
 # Simple mutable object.
 class Object(object):

Lib/test/pickletester.py

@@ -846,6 +846,30 @@ def test_load_classic_instance(self):
                        b'q\x00oq\x01}q\x02b.').replace(b'X', xname)
             self.assert_is_copy(X(*args), self.loads(pickle2))
 
+    def test_load_bad_constructor(self):
+        # gh-154002: a TypeError raised by an old-style instance constructor
+        # during INST/OBJ unpickling must be reported with proper exception
+        # chaining, not with the traceback object stored in the exception's
+        # args (which used to happen in the pure-Python unpickler).
+        #  0: (    MARK
+        #  1: I        INT        1
+        #  4: i        INST       '__main__ BadConstructor' (MARK at 0)
+        # 28: .    STOP
+        data = b'(I1\ni__main__\nBadConstructor\n.'
+        with self.assertRaises(TypeError) as cm:
+            self.loads(data)
+        exc = cm.exception
+        # A traceback object must never leak into the exception's args.
+        self.assertNotIn(types.TracebackType, [type(a) for a in exc.args])
+        # Only the pure-Python unpickler wraps the failure; the C one lets the
+        # original TypeError propagate. When it wraps, it must chain the cause.
+        if str(exc).startswith("in constructor for "):
+            self.assertEqual(
+                exc.args,
+                ("in constructor for BadConstructor: bad constructor",))
+            self.assertIsInstance(exc.__cause__, TypeError)
+            self.assertEqual(str(exc.__cause__), "bad constructor")
+
     def test_maxint64(self):
         maxint64 = (1 << 63) - 1
         data = b'I' + str(maxint64).encode("ascii") + b'\n.'

Misc/NEWS.d/next/Library/2026-07-18-18-12-44.gh-issue-154002.Qw9zTn.rst

@@ -0,0 +1,4 @@
+Fix exception handling in the pure-Python :mod:`pickle` unpickler when a
+class constructor raises :exc:`TypeError` while unpickling an old-style
+instance. The original error is now chained with ``from`` instead of having
+its traceback object stored in the raised exception's ``args``.