Move sys._set_exception() to _contextlib._setup_genmgr_ctx

Since this is only used for a contextlib-specific hack, having it
exposed in the sys module (even with an underscore) might not be a good
idea.

Author: pR0Ps

Lib/contextlib.py

@@ -20,6 +20,12 @@
            "chdir"]
 
 
+try:
+    from _contextlib import _setup_genmgr_ctx
+except ImportError:
+    _setup_genmgr_ctx = None
+
+
 class AbstractContextManager(abc.ABC):
 
     """An abstract base class for context managers."""
@@ -239,7 +245,8 @@ def __exit__(self, typ, value, traceback):
                 # context to be what it was just before the generator's yield
                 # statement before throwing the current exception into it.
                 # (see gh-111676).
-                sys._set_exception(exc_context)
+                if _setup_genmgr_ctx is not None:
+                    _setup_genmgr_ctx(exc_context)
                 self.gen.throw(value)
             except StopIteration as exc:
                 # Suppress StopIteration *unless* it's the same exception that

Lib/test/test_contextlib.py

@@ -1671,5 +1671,138 @@ def test_exception(self):
         self.assertEqual(os.getcwd(), old_cwd)
 
 
+try:
+    from _contextlib import _setup_genmgr_ctx
+except ImportError:
+    _setup_genmgr_ctx = None
+
+if _setup_genmgr_ctx:
+    class SetExceptionTests(unittest.TestCase):
+
+        def tearDown(self):
+            # make sure we don't leave the global exception set
+            _setup_genmgr_ctx(None);
+
+        def test_set_exc_invalid_values(self):
+            for x in (0, "1", b"2"):
+                with self.assertRaises(TypeError):
+                    _setup_genmgr_ctx(x);
+
+        def test_clear_exc(self):
+            try:
+                raise ValueError()
+            except ValueError:
+                self.assertIsInstance(sys.exception(), ValueError)
+                _setup_genmgr_ctx(None)
+                self.assertIsNone(sys.exception())
+
+        def test_set_exc(self):
+            exc = ValueError()
+            self.assertIsNone(sys.exception())
+            _setup_genmgr_ctx(exc)
+            self.assertIs(sys.exception(), exc)
+
+        def test_set_exc_replaced_by_new_exception_and_restored(self):
+            exc = ValueError()
+            _setup_genmgr_ctx(exc)
+            self.assertIs(sys.exception(), exc)
+            try:
+                raise TypeError()
+            except TypeError:
+                self.assertIsInstance(sys.exception(), TypeError)
+                self.assertIs(sys.exception().__context__, exc)
+
+            self.assertIs(sys.exception(), exc)
+
+        def test_set_exc_popped_on_exit_except(self):
+            exc = ValueError()
+            try:
+                raise TypeError()
+            except TypeError:
+                self.assertIsInstance(sys.exception(), TypeError)
+                _setup_genmgr_ctx(exc)
+                self.assertIs(sys.exception(), exc)
+            self.assertIsNone(sys.exception())
+
+        def test_cleared_exc_overridden_and_restored(self):
+            try:
+                raise ValueError()
+            except ValueError:
+                try:
+                    raise TypeError()
+                except TypeError:
+                    self.assertIsInstance(sys.exception(), TypeError)
+                    _setup_genmgr_ctx(None)
+                    self.assertIsNone(sys.exception())
+                    try:
+                        raise IndexError()
+                    except IndexError:
+                        self.assertIsInstance(sys.exception(), IndexError)
+                        self.assertIsNone(sys.exception().__context__)
+                    self.assertIsNone(sys.exception())
+                self.assertIsInstance(sys.exception(), ValueError)
+            self.assertIsNone(sys.exception())
+
+        def test_clear_exc_in_generator(self):
+            def inner():
+                self.assertIsNone(sys.exception())
+                yield
+                self.assertIsInstance(sys.exception(), ValueError)
+                _setup_genmgr_ctx(None)
+                self.assertIsNone(sys.exception())
+                yield
+                self.assertIsNone(sys.exception())
+
+            # with a single exception in exc_info stack
+            g = inner()
+            next(g)
+            try:
+                raise ValueError()
+            except:
+                self.assertIsInstance(sys.exception(), ValueError)
+                next(g)
+                self.assertIsInstance(sys.exception(), ValueError)
+            self.assertIsNone(sys.exception())
+            with self.assertRaises(StopIteration):
+                next(g)
+            self.assertIsNone(sys.exception())
+
+            # with multiple exceptions in exc_info stack by chaining generators
+            def outer():
+                g = inner()
+                self.assertIsNone(sys.exception())
+                yield next(g)
+                self.assertIsInstance(sys.exception(), TypeError)
+                try:
+                    raise ValueError()
+                except:
+                    self.assertIsInstance(sys.exception(), ValueError)
+                    self.assertIsInstance(sys.exception().__context__, TypeError)
+                    yield next(g)
+                    # at this point the TypeError from the caller has been handled
+                    # by the caller's except block. Even still, it should still be
+                    # referenced as the __context__ of the current exception.
+                    self.assertIsInstance(sys.exception(), ValueError)
+                    self.assertIsInstance(sys.exception().__context__, TypeError)
+                # not handling an exception, caller isn't handling one either
+                self.assertIsNone(sys.exception())
+                with self.assertRaises(StopIteration):
+                    next(g)
+                self.assertIsNone(sys.exception())
+
+            g = outer()
+            next(g)
+            try:
+                raise TypeError()
+            except:
+                self.assertIsInstance(sys.exception(), TypeError)
+                next(g)
+                self.assertIsInstance(sys.exception(), TypeError)
+            self.assertIsNone(sys.exception())
+            with self.assertRaises(StopIteration):
+                next(g)
+            self.assertIsNone(sys.exception())
+
+
 if __name__ == "__main__":
     unittest.main()

Lib/test/test_sys.py

@@ -160,131 +160,6 @@ def f():
         self.assertIsInstance(e, ValueError)
         self.assertIs(exc, e)
 
-class SetExceptionTests(unittest.TestCase):
-
-    def tearDown(self):
-        # make sure we don't leave the global exception set
-        sys._set_exception(None);
-
-    def test_set_exc_invalid_values(self):
-        for x in (0, "1", b"2"):
-            with self.assertRaises(TypeError):
-                sys._set_exception(x);
-
-    def test_clear_exc(self):
-        try:
-            raise ValueError()
-        except ValueError:
-            self.assertIsInstance(sys.exception(), ValueError)
-            sys._set_exception(None)
-            self.assertIsNone(sys.exception())
-
-    def test_set_exc(self):
-        exc = ValueError()
-        self.assertIsNone(sys.exception())
-        sys._set_exception(exc)
-        self.assertIs(sys.exception(), exc)
-
-    def test_set_exc_replaced_by_new_exception_and_restored(self):
-        exc = ValueError()
-        sys._set_exception(exc)
-        self.assertIs(sys.exception(), exc)
-        try:
-            raise TypeError()
-        except TypeError:
-            self.assertIsInstance(sys.exception(), TypeError)
-            self.assertIs(sys.exception().__context__, exc)
-
-        self.assertIs(sys.exception(), exc)
-
-    def test_set_exc_popped_on_exit_except(self):
-        exc = ValueError()
-        try:
-            raise TypeError()
-        except TypeError:
-            self.assertIsInstance(sys.exception(), TypeError)
-            sys._set_exception(exc)
-            self.assertIs(sys.exception(), exc)
-        self.assertIsNone(sys.exception())
-
-    def test_cleared_exc_overridden_and_restored(self):
-        try:
-            raise ValueError()
-        except ValueError:
-            try:
-                raise TypeError()
-            except TypeError:
-                self.assertIsInstance(sys.exception(), TypeError)
-                sys._set_exception(None)
-                self.assertIsNone(sys.exception())
-                try:
-                    raise IndexError()
-                except IndexError:
-                    self.assertIsInstance(sys.exception(), IndexError)
-                    self.assertIsNone(sys.exception().__context__)
-                self.assertIsNone(sys.exception())
-            self.assertIsInstance(sys.exception(), ValueError)
-        self.assertIsNone(sys.exception())
-
-    def test_clear_exc_in_generator(self):
-        def inner():
-            self.assertIsNone(sys.exception())
-            yield
-            self.assertIsInstance(sys.exception(), ValueError)
-            sys._set_exception(None)
-            self.assertIsNone(sys.exception())
-            yield
-            self.assertIsNone(sys.exception())
-
-        # with a single exception in exc_info stack
-        g = inner()
-        next(g)
-        try:
-            raise ValueError()
-        except:
-            self.assertIsInstance(sys.exception(), ValueError)
-            next(g)
-            self.assertIsInstance(sys.exception(), ValueError)
-        self.assertIsNone(sys.exception())
-        with self.assertRaises(StopIteration):
-            next(g)
-        self.assertIsNone(sys.exception())
-
-        # with multiple exceptions in exc_info stack by chaining generators
-        def outer():
-            g = inner()
-            self.assertIsNone(sys.exception())
-            yield next(g)
-            self.assertIsInstance(sys.exception(), TypeError)
-            try:
-                raise ValueError()
-            except:
-                self.assertIsInstance(sys.exception(), ValueError)
-                self.assertIsInstance(sys.exception().__context__, TypeError)
-                yield next(g)
-                # at this point the TypeError from the caller has been handled
-                # by the caller's except block. Even still, it should still be
-                # referenced as the __context__ of the current exception.
-                self.assertIsInstance(sys.exception(), ValueError)
-                self.assertIsInstance(sys.exception().__context__, TypeError)
-            # not handling an exception, caller isn't handling one either
-            self.assertIsNone(sys.exception())
-            with self.assertRaises(StopIteration):
-                next(g)
-            self.assertIsNone(sys.exception())
-
-        g = outer()
-        next(g)
-        try:
-            raise TypeError()
-        except:
-            self.assertIsInstance(sys.exception(), TypeError)
-            next(g)
-            self.assertIsInstance(sys.exception(), TypeError)
-        self.assertIsNone(sys.exception())
-        with self.assertRaises(StopIteration):
-            next(g)
-        self.assertIsNone(sys.exception())
 
 class ExceptHookTest(unittest.TestCase):
 

Misc/NEWS.d/next/Core_and_Builtins/2023-12-19-17-27-08.gh-issue-111375.XeHOl_.rst

@@ -31,6 +31,7 @@ _weakref _weakref.c
 
 # commonly used core modules
 _abc _abc.c
+_contextlib _contextlibmodule.c
 _functools _functoolsmodule.c
 _locale _localemodule.c
 _opcode _opcode.c

Modules/Setup.bootstrap.in

@@ -0,0 +1,64 @@
+
+/* Contextlib module */
+
+#include "Python.h"
+
+#include "clinic/_contextlibmodule.c.h"
+
+/*[clinic input]
+module _contextlib
+[clinic start generated code]*/
+/*[clinic end generated code: output=da39a3ee5e6b4b0d input=60c4760e25c64b5e]*/
+
+
+/*[clinic input]
+_contextlib._setup_genmgr_ctx
+    exception: object
+
+Force the provided exception to be set as the current exception
+
+Subsequent calls to sys.exception()/sys.exc_info() will return
+the provided exception until another exception is caught in the
+current thread or the execution stack returns to a frame where
+another exception is being handled.
+[clinic start generated code]*/
+
+static PyObject *
+_contextlib__setup_genmgr_ctx_impl(PyObject *module, PyObject *exception)
+/*[clinic end generated code: output=d8996a9f8f52204b input=d61410ba5659bf6f]*/
+{
+    if (!Py_IsNone(exception) && !PyExceptionInstance_Check(exception)){
+        PyErr_SetString(
+            PyExc_TypeError,
+            "must be an exception/None"
+        );
+        return NULL;
+    }
+    PyErr_SetHandledException(exception);
+    Py_RETURN_NONE;
+}
+
+
+/* module level code ********************************************************/
+
+PyDoc_STRVAR(_contextlib_doc,
+"Helpers for contextlib.");
+
+static PyMethodDef contextlib_methods[] = {
+    _CONTEXTLIB__SETUP_GENMGR_CTX_METHODDEF
+    {NULL,              NULL}           /* sentinel */
+};
+
+static struct PyModuleDef _contextlibmodule = {
+    PyModuleDef_HEAD_INIT,
+    .m_name = "_contextlib",
+    .m_doc = _contextlib_doc,
+    .m_size = -1,
+    .m_methods = contextlib_methods,
+};
+
+PyMODINIT_FUNC
+PyInit__contextlib(void)
+{
+    return PyModule_Create(&_contextlibmodule);
+}