Use ContextVar.get_changed() for decimal context.

Ensure that decimal.getcontext() returns a per-task copy of the
decimal.Context() so that mutations are isolated between async tasks
and threads using sys.flags.thread_inherit_context.

Author: nascheme

Lib/_pydecimal.py

@@ -361,11 +361,19 @@ def getcontext():
     New contexts are copies of DefaultContext.
     """
     try:
-        return _current_context_var.get()
+        context, changed = _current_context_var.get_changed()
     except LookupError:
         context = Context()
         _current_context_var.set(context)
         return context
+    if not changed:
+        # The context value was inherited from another task/thread.  Because
+        # the Context() instance is mutable, copy it to ensure that if it is
+        # changed, those changes are isolated from other tasks/threads.
+        context = context.copy()
+        _current_context_var.set(context)
+    return context
+
 
 def setcontext(context):
     """Set this thread's context to context."""

Lib/test/test_decimal.py

@@ -1770,6 +1770,59 @@ def test_threading(self):
         DefaultContext.Emax = save_emax
         DefaultContext.Emin = save_emin
 
+    @threading_helper.requires_working_threading()
+    def test_inherited_context_isolation(self):
+        # Test that when threads inherit contextvars (e.g. via
+        # sys.flags.thread_inherit_context), each thread gets its own
+        # copy of the decimal context so mutations don't leak between
+        # threads.  Also verifies correct behavior with asyncio tasks.
+        Decimal = self.decimal.Decimal
+        getcontext = self.decimal.getcontext
+        setcontext = self.decimal.setcontext
+        Context = self.decimal.Context
+        Underflow = self.decimal.Underflow
+
+        # Set up parent context with specific precision
+        parent_ctx = getcontext()
+        parent_ctx.prec = 20
+
+        barrier = threading.Barrier(2, timeout=2)
+        results = {}
+
+        def child(name, prec_delta):
+            barrier.wait()
+            ctx = getcontext()
+            # Each child should see a context with the parent's precision
+            results[name + '_initial_prec'] = ctx.prec
+            results[name + '_ctx_id'] = id(ctx)
+            # Mutate this thread's context
+            ctx.prec += prec_delta
+            results[name + '_modified_prec'] = ctx.prec
+
+        # Spawn threads that inherit the parent's contextvars.
+        t1 = threading.Thread(target=child, args=('t1', 5),
+                              context=contextvars.copy_context())
+        t2 = threading.Thread(target=child, args=('t2', 10),
+                              context=contextvars.copy_context())
+        t1.start()
+        t2.start()
+        t1.join()
+        t2.join()
+
+        # Each thread should have started with the parent's precision
+        self.assertEqual(results['t1_initial_prec'], 20)
+        self.assertEqual(results['t2_initial_prec'], 20)
+
+        # Each thread should have its own context (different id)
+        self.assertNotEqual(results['t1_ctx_id'], results['t2_ctx_id'])
+
+        # Mutations should be independent
+        self.assertEqual(results['t1_modified_prec'], 25)
+        self.assertEqual(results['t2_modified_prec'], 30)
+
+        # Parent context should be unaffected
+        self.assertEqual(getcontext().prec, 20)
+
 
 @requires_cdecimal
 class CThreadingTest(ThreadingTest, unittest.TestCase):

Misc/NEWS.d/next/Library/2026-03-26-10-27-07.gh-issue-141148._XpYnI.rst

@@ -0,0 +1,4 @@
+Ensure that :func:`decimal.getcontext` returns a per-task copy of the
+:class:`decimal.Context` so that mutations are isolated between asyncio
+tasks and threads using :data:`sys.flags.thread_inherit_context`.  Added
+:meth:`contextvars.ContextVar.get_changed` to support this.

Modules/_decimal/_decimal.c

@@ -1914,9 +1914,9 @@ PyDec_SetCurrentContext(PyObject *self, PyObject *v)
 }
 #else
 static PyObject *
-init_current_context(decimal_state *state)
+init_current_context(decimal_state *state, PyObject *prev_context)
 {
-    PyObject *tl_context = context_copy(state, state->default_context_template);
+    PyObject *tl_context = context_copy(state, prev_context);
     if (tl_context == NULL) {
         return NULL;
     }
@@ -1936,15 +1936,25 @@ static inline PyObject *
 current_context(decimal_state *state)
 {
     PyObject *tl_context;
-    if (PyContextVar_Get(state->current_context_var, NULL, &tl_context) < 0) {
+    int changed;
+    if (PyContextVar_GetChanged(state->current_context_var, NULL, &tl_context,
+                                &changed) < 0) {
         return NULL;
     }
 
     if (tl_context != NULL) {
-        return tl_context;
+        if (!changed) {
+            /* inherited context object from another thread for async task */
+            PyObject *new_context = init_current_context(state, tl_context);
+            Py_DECREF(tl_context);
+            return new_context;
+        }
+        else {
+            return tl_context;
+        }
     }
 
-    return init_current_context(state);
+    return init_current_context(state, state->default_context_template);
 }
 
 /* ctxobj := borrowed reference to the current context */