Merge clean grammar changes into features

Author: rajdeepdeyon2022-hub

Doc/library/decimal.rst

@@ -1182,6 +1182,14 @@ In addition to the three supplied contexts, new contexts can be created with the
 
       Return a duplicate of the context.
 
+      :class:`!Context` objects also support :func:`copy.replace`,
+      which returns a duplicate with the specified fields replaced.
+      Fields which are not specified keep the values
+      they have in the original context.
+
+      .. versionchanged:: next
+         Added support for :func:`copy.replace`.
+
    .. method:: copy_decimal(num, /)
 
       Return a copy of the Decimal instance num.

Lib/_pydecimal.py

@@ -4005,6 +4005,20 @@ def copy(self):
         return nc
     __copy__ = copy
 
+    def __replace__(self, /, **changes):
+        """Returns a copy of self with the specified attributes replaced."""
+        unexpected = changes.keys() - _context_attributes
+        if unexpected:
+            raise TypeError(f'__replace__() got an unexpected keyword '
+                            f'argument {min(unexpected)!r}')
+        nc = self.copy()
+        for name, value in changes.items():
+            if name in ('flags', 'traps') and isinstance(value, list):
+                # As in the constructor, accept a list of signals.
+                value = dict((s, int(s in value)) for s in _signals + value)
+            setattr(nc, name, value)
+        return nc
+
     def _raise_error(self, condition, explanation = None, *args):
         """Handles an error
 

Lib/logging/__init__.py

@@ -1709,7 +1709,11 @@ def removeHandler(self, hdlr):
         """
         with _lock:
             if hdlr in self.handlers:
-                self.handlers.remove(hdlr)
+                # Replace the list instead of mutating it in place, so that
+                # callHandlers() can iterate it without a lock (gh-79366).
+                handlers = self.handlers.copy()
+                handlers.remove(hdlr)
+                self.handlers = handlers
 
     def hasHandlers(self):
         """

Lib/test/test_decimal.py

@@ -3070,6 +3070,41 @@ def test_copy(self):
         self.assertEqual(k1, k2)
         self.assertEqual(c.flags, d.flags)
 
+    def test_replace(self):
+        Context = self.decimal.Context
+        Inexact = self.decimal.Inexact
+        Overflow = self.decimal.Overflow
+        ROUND_UP = self.decimal.ROUND_UP
+
+        c = Context(prec=10, Emin=-99, capitals=0)
+        c.flags[Inexact] = True
+        d = copy.replace(c, prec=20, rounding=ROUND_UP)
+        self.assertEqual(d.prec, 20)
+        self.assertEqual(d.rounding, ROUND_UP)
+        # Not replaced attributes are inherited from the original context.
+        self.assertEqual(d.Emin, -99)
+        self.assertEqual(d.capitals, 0)
+        self.assertEqual(d.Emax, c.Emax)
+        self.assertEqual(d.clamp, c.clamp)
+        self.assertTrue(d.flags[Inexact])
+        self.assertEqual(d.traps, c.traps)
+        # The copy is deep and the original context is left unchanged.
+        self.assertIsNot(d.flags, c.flags)
+        self.assertIsNot(d.traps, c.traps)
+        self.assertEqual(c.prec, 10)
+        self.assertEqual(c.rounding, Context().rounding)
+
+        # As in the constructor, flags and traps can be given as a list.
+        d = copy.replace(c, flags=[Overflow])
+        self.assertTrue(d.flags[Overflow])
+        self.assertFalse(d.flags[Inexact])
+
+        self.assertRaises(TypeError, copy.replace, c, prek=1)
+        self.assertRaises(TypeError, copy.replace, c, prec='spam')
+        # Unlike in the constructor, None is not a valid value.
+        self.assertRaises(TypeError, copy.replace, c, prec=None)
+        self.assertRaises(TypeError, copy.replace, c, flags=None)
+
     def test__clamp(self):
         # In Python 3.2, the private attribute `_clamp` was made
         # public (issue 8540), with the old `_clamp` becoming a
@@ -3763,6 +3798,13 @@ def test_localcontext_kwargs(self):
         self.assertRaises(TypeError, self.decimal.localcontext, Emin="")
         self.assertRaises(TypeError, self.decimal.localcontext, Emax="")
 
+        # None is not a valid value for any of these attributes.
+        for name in ('prec', 'rounding', 'Emin', 'Emax', 'capitals', 'clamp',
+                     'flags', 'traps'):
+            with self.subTest(name=name):
+                self.assertRaises(TypeError, self.decimal.localcontext,
+                                  **{name: None})
+
     def test_local_context_kwargs_does_not_overwrite_existing_argument(self):
         ctx = self.decimal.getcontext()
         orig_prec = ctx.prec

Lib/test/test_logging.py

@@ -814,6 +814,23 @@ def lock_holder_thread_fn():
 
             support.wait_process(pid, exitcode=0)
 
+    def test_remove_handler_while_emitting(self):
+        # Removing a handler while callHandlers() iterates over the handlers
+        # should not cause the following handlers to be skipped (gh-79366).
+        logger = logging.Logger('test_remove_handler_while_emitting')
+        calls = []
+        class RemovingHandler(logging.Handler):
+            def emit(self, record):
+                calls.append('removing')
+                logger.removeHandler(self)
+        class CountingHandler(logging.Handler):
+            def emit(self, record):
+                calls.append('counting')
+        logger.addHandler(RemovingHandler())
+        logger.addHandler(CountingHandler())
+        logger.error('spam')
+        self.assertEqual(calls, ['removing', 'counting'])
+
 
 class BadStream(object):
     def write(self, data):

Lib/test/test_zoneinfo/test_zoneinfo.py

@@ -316,6 +316,18 @@ def test_unambiguous(self):
                 self.assertEqual(dt.utcoffset(), offset.utcoffset, dt)
                 self.assertEqual(dt.dst(), offset.dst, dt)
 
+    def test_datetime_subclass_negative_components(self):
+        class MinusOneDateTime(datetime):
+            hour = minute = second = -1
+
+        zi = self.zone_from_key("UTC")
+        dt = MinusOneDateTime(2024, 1, 1, tzinfo=zi)
+
+        self.assertEqual(dt.utcoffset(), ZERO)
+        self.assertEqual(dt.dst(), ZERO)
+        self.assertEqual(dt.tzname(), "UTC")
+        self.assertEqual(zi.fromutc(dt), datetime(2024, 1, 1, tzinfo=zi))
+
     def test_folds_and_gaps(self):
         test_cases = []
         for key in self.zones():

Misc/NEWS.d/next/Library/2026-07-23-06-53-01.gh-issue-79366.3gMT7I.rst

@@ -0,0 +1,3 @@
+Fixed a race condition in :mod:`logging`:
+if a handler was removed while a record was being emitted,
+the following handlers of the same logger could be skipped.

Misc/NEWS.d/next/Library/2026-07-29-21-37-39.gh-issue-154892.eQyJ3Z.rst

@@ -0,0 +1,3 @@
+Fix a bug in the C accelerator for :mod:`zoneinfo` where
+:class:`datetime.datetime` subclasses returning ``-1`` for ``hour``,
+``minute``, or ``second`` could incorrectly raise a :exc:`SystemError`.

Misc/NEWS.d/next/Library/2026-08-01-19-02-00.gh-issue-155041.Dc1Ctx.rst

@@ -0,0 +1 @@
+:class:`decimal.Context` objects now support :func:`copy.replace`.

Misc/NEWS.d/next/Library/2026-08-01-21-00-00.gh-issue-155051.Lc1Non.rst

@@ -0,0 +1,3 @@
+:func:`decimal.localcontext` now raises :exc:`TypeError` if a keyword argument
+is ``None``, as the pure Python implementation already did.  Previously the C
+implementation silently ignored it.