Drop the wrapper instead of chaining it

The prefix repeats the class name that the constructor TypeError already
carries, and the C unpickler never wrapped the error, so letting the original
propagate removes the traceback-in-args bug and the divergence at once.

Author: fedonman

Lib/pickle.py

@@ -1623,11 +1623,7 @@ def load_dict(self):
     def _instantiate(self, klass, args):
         if (args or not isinstance(klass, type) or
             hasattr(klass, "__getinitargs__")):
-            try:
-                value = klass(*args)
-            except TypeError as err:
-                raise TypeError("in constructor for %s: %s" %
-                                (klass.__name__, str(err))) from err
+            value = klass(*args)
         else:
             value = klass.__new__(klass)
         self.append(value)

Lib/test/pickletester.py

@@ -848,27 +848,17 @@ def test_load_classic_instance(self):
 
     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).
+        # during INST/OBJ unpickling propagates unchanged.  The pure-Python
+        # unpickler used to replace it with one that carried the traceback
+        # object in its args.
         #  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")
+        self.assertEqual(cm.exception.args, ("bad constructor",))
 
     def test_maxint64(self):
         maxint64 = (1 << 63) - 1

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

@@ -1,4 +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``.
+The pure-Python :mod:`pickle` unpickler no longer replaces a :exc:`TypeError`
+raised by an old-style instance constructor with a new one carrying the
+traceback object in its ``args``. The original error now propagates, as it
+already did in the C implementation.