gh-99633: Add context manager support to contextvars.Context

rhansen · rhansen · commit b21b76f3b137 · 2024-07-10T18:23:45.000-04:00
diff --git a/Doc/library/contextvars.rst b/Doc/library/contextvars.rst
@@ -144,21 +144,87 @@ Manual Context Management
    To get a copy of the current context use the
    :func:`~contextvars.copy_context` function.
 
-   Every thread will have a different top-level :class:`~contextvars.Context`
-   object. This means that a :class:`ContextVar` object behaves in a similar
-   fashion to :func:`threading.local()` when values are assigned in different
-   threads.
+   Each thread has its own effective stack of :class:`~contextvars.Context`
+   objects.  The *current Context* is the Context object at the top of the
+   current thread's stack.  All Context objects in the stacks are considered to
+   be *entered*.  *Entering* a Context, either by calling the
+   :meth:`Context.run` method or using the Context object as a :term:`context
+   manager`, pushes the Context onto the top of the current thread's stack,
+   making it the current Context.  *Exiting* from the current Context, either by
+   returning from the callback passed to :meth:`Context.run` or by exiting the
+   :keyword:`with` statement suite, pops the Context off of the top of the
+   stack, restoring the current Context to what it was before.
+
+   Because each thread has its own Context stack, :class:`ContextVar` objects
+   behave in a similar fashion to :func:`threading.local()` when values are
+   assigned in different threads.
+
+   Attempting to do either of the following will raise a :exc:`RuntimeError`:
+
+   * Entering an already entered Context.  (This includes Contexts entered in
+     other threads.)
+   * Exiting from a Context that is not the current Context.
+
+   After exiting a Context, it can later be re-entered (from any thread).
+
+   Any changes to :class:`ContextVar` values via the :meth:`ContextVar.set`
+   method are recorded in the current Context.  The :meth:`ContextVar.get`
+   method returns the value associated with the current Context.  Thus, exiting
+   a Context effectively reverts any changes made to context variables while the
+   Context was entered.  (If desired, the values can be restored by re-entering
+   the Context.)
 
    Context implements the :class:`collections.abc.Mapping` interface.
 
+   .. versionadded:: 3.14
+      Context implements the :term:`!context management protocol` (:pep:`343`).
+
+   .. method:: __enter__(self)
+               __exit__(self, exc_type, exc_value, exc_tb)
+
+      These methods implement the :term:`!context management protocol`
+      (:pep:`343`), making it possible to use a Context object as a
+      :term:`context manager` with the :keyword:`with` statement.  The
+      :meth:`__enter__` method enters the Context and returns *self*, so the
+      value bound to the identifier given in the :keyword:`with` statement's
+      :keyword:`!as` clause (if present) is the Context object itself.  The
+      :meth:`__exit__` method exits the Context.
+
+      Example:
+
+      .. testcode::
+
+         import contextvars
+
+         var = contextvars.ContextVar("var")
+         var.set("initial")
+         assert var.get() == "initial"
+
+         # Copy the current Context and enter the copy.
+         with contextvars.copy_context() as ctx:
+             var.set("updated")
+             assert var in ctx
+             assert ctx[var] == "updated"
+             assert var.get() == "updated"
+
+         # Exited ctx, so the observed value of var has reverted.
+         assert var.get() == "initial"
+         # But the updated value is still recorded in ctx.
+         assert ctx[var] == "updated"
+
+         # Re-entering ctx restores the updated value of var.
+         with ctx:
+             assert var.get() == "updated"
+
+      .. versionadded:: 3.14
+
    .. method:: run(callable, *args, **kwargs)
 
-      Execute ``callable(*args, **kwargs)`` code in the context object
-      the *run* method is called on.  Return the result of the execution
-      or propagate an exception if one occurred.
+      Enters the Context, executes ``callable(*args, **kwargs)``, then exits the
+      Context.  Returns *callable*'s return value, or propagates an exception if
+      one occurred.
 
-      Any changes to any context variables that *callable* makes will
-      be contained in the context object::
+      Example::
 
         var = ContextVar('var')
         var.set('spam')
@@ -186,10 +252,6 @@ Manual Context Management
         # However, outside of 'ctx', 'var' is still set to 'spam':
         # var.get() == 'spam'
 
-      The method raises a :exc:`RuntimeError` when called on the same
-      context object from more than one OS thread, or when called
-      recursively.
-
    .. method:: copy()
 
       Return a shallow copy of the context object.
diff --git a/Lib/test/test_context.py b/Lib/test/test_context.py
@@ -3,6 +3,7 @@
 import functools
 import gc
 import random
+import threading
 import time
 import unittest
 import weakref
@@ -361,6 +362,74 @@ def sub(num):
             tp.shutdown()
         self.assertEqual(results, list(range(10)))
 
+    @isolated_context
+    def test_context_manager_works(self):
+        cvar = contextvars.ContextVar('cvar', default='initial')
+        self.assertEqual(cvar.get(), 'initial')
+        with contextvars.copy_context():
+            self.assertEqual(cvar.get(), 'initial')
+            cvar.set('updated')
+            self.assertEqual(cvar.get(), 'updated')
+        self.assertEqual(cvar.get(), 'initial')
+
+    def test_context_manager_as_binding(self):
+        ctx = contextvars.copy_context()
+        with ctx as ctx_as_binding:
+            self.assertIs(ctx_as_binding, ctx)
+
+    @isolated_context
+    def test_context_manager_enter_again_after_exit(self):
+        cvar = contextvars.ContextVar('cvar', default='initial')
+        self.assertEqual(cvar.get(), 'initial')
+        with contextvars.copy_context() as ctx:
+            cvar.set('updated')
+            self.assertEqual(cvar.get(), 'updated')
+        self.assertEqual(cvar.get(), 'initial')
+        with ctx:
+            self.assertEqual(cvar.get(), 'updated')
+        self.assertEqual(cvar.get(), 'initial')
+
+    @threading_helper.requires_working_threading()
+    def test_context_manager_rejects_exit_from_different_thread(self):
+        ctx = contextvars.copy_context()
+        thread = threading.Thread(target=ctx.__enter__)
+        thread.start()
+        thread.join()
+        with self.assertRaises(RuntimeError):
+            ctx.__exit__(None, None, None)
+
+    def test_context_manager_rejects_recursive_enter_mgr_then_mgr(self):
+        with contextvars.copy_context() as ctx:
+            with self.assertRaises(RuntimeError):
+                with ctx:
+                    pass
+
+    def test_context_manager_rejects_recursive_enter_mgr_then_run(self):
+        with contextvars.copy_context() as ctx:
+            with self.assertRaises(RuntimeError):
+                ctx.run(lambda: None)
+
+    def test_context_manager_rejects_recursive_enter_run_then_mgr(self):
+        ctx = contextvars.copy_context()
+
+        def fn():
+            with self.assertRaises(RuntimeError):
+                with ctx:
+                    pass
+
+        ctx.run(fn)
+
+    def test_context_manager_rejects_noncurrent_exit(self):
+        with contextvars.copy_context() as ctx:
+            with contextvars.copy_context():
+                with self.assertRaises(RuntimeError):
+                    ctx.__exit__(None, None, None)
+
+    def test_context_manager_rejects_nonentered_exit(self):
+        ctx = contextvars.copy_context()
+        with self.assertRaises(RuntimeError):
+            ctx.__exit__(None, None, None)
+
 
 # HAMT Tests
 
diff --git a/Misc/ACKS b/Misc/ACKS
@@ -715,6 +715,7 @@ Michael Handler
 Andreas Hangauer
 Milton L. Hankins
 Carl Bordum Hansen
+Richard Hansen
 Stephen Hansen
 Barry Hantman
 Lynda Hardman
diff --git a/Misc/NEWS.d/next/Library/2022-11-21-01-24-46.gh-issue-99633.vhrNRe.rst b/Misc/NEWS.d/next/Library/2022-11-21-01-24-46.gh-issue-99633.vhrNRe.rst
@@ -0,0 +1 @@
+Add :term:`context manager` methods to :class:`contextvars.Context`.
diff --git a/Python/clinic/context.c.h b/Python/clinic/context.c.h
diff --git a/Python/context.c b/Python/context.c
@@ -153,7 +153,6 @@ _PyContext_Exit(PyThreadState *ts, PyObject *octx)
     }
 
     if (ts->context != (PyObject *)ctx) {
-        /* Can only happen if someone misuses the C API */
         PyErr_SetString(PyExc_RuntimeError,
                         "cannot exit context: thread state references "
                         "a different context object");
@@ -550,6 +549,69 @@ context_tp_contains(PyContext *self, PyObject *key)
 }
 
 
+/*[clinic input]
+_contextvars.Context.__enter__
+
+Context manager enter.
+
+Automatically called by the 'with' statement.  Using the Context object as a
+context manager is an alternative to calling the Context.run() method.  Example
+usage:
+
+    var = contextvars.ContextVar('var')
+    var.set('initial')
+
+    with contextvars.copy_context():
+        # The current Context is a new copy of the previous Context.  Updating a
+        # context variable inside this 'with' statement only affects the new
+        # copy.
+        var.set('updated')
+        do_something_interesting()
+
+    # Now that the 'with' statement is done executing, the value of the 'var'
+    # context variable has reverted back to its value before the 'with'
+    # statement.
+    assert var.get() == 'initial'
+[clinic start generated code]*/
+
+static PyObject *
+_contextvars_Context___enter___impl(PyContext *self)
+/*[clinic end generated code: output=7374aea8983b777a input=22868e8274d3cd32]*/
+{
+    PyThreadState *ts = _PyThreadState_GET();
+    if (_PyContext_Enter(ts, (PyObject *)self)) {
+        return NULL;
+    }
+    return Py_NewRef(self);
+}
+
+
+/*[clinic input]
+_contextvars.Context.__exit__
+    exc_type: object
+    exc_val: object
+    exc_tb: object
+    /
+
+Context manager exit.
+
+Automatically called at the conclusion of a 'with' statement when the Context is
+used as a context manager.  See the Context.__enter__() method for more details.
+[clinic start generated code]*/
+
+static PyObject *
+_contextvars_Context___exit___impl(PyContext *self, PyObject *exc_type,
+                                   PyObject *exc_val, PyObject *exc_tb)
+/*[clinic end generated code: output=4608fa9151f968f1 input=ff70cbbf6a112b1d]*/
+{
+    PyThreadState *ts = _PyThreadState_GET();
+    if (_PyContext_Exit(ts, (PyObject *)self)) {
+        return NULL;
+    }
+    Py_RETURN_NONE;
+}
+
+
 /*[clinic input]
 _contextvars.Context.get
     key: object
@@ -670,6 +732,8 @@ context_run(PyContext *self, PyObject *const *args,
 
 
 static PyMethodDef PyContext_methods[] = {
+    _CONTEXTVARS_CONTEXT___ENTER___METHODDEF
+    _CONTEXTVARS_CONTEXT___EXIT___METHODDEF
     _CONTEXTVARS_CONTEXT_GET_METHODDEF
     _CONTEXTVARS_CONTEXT_ITEMS_METHODDEF
     _CONTEXTVARS_CONTEXT_KEYS_METHODDEF

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	+Add :term:`context manager` methods to :class:`contextvars.Context`.