Merge branch 'main' into fix/fnmatch-filter-pathlike

Author: MonikaDvorackova

Doc/builtins/stdtypes.rst

@@ -2129,13 +2129,23 @@ expression support in the :mod:`re` module).
 .. method:: str.capitalize()
 
    Return a copy of the string with its first character capitalized and the
-   rest lowercased.
+   rest lowercased. For example:
+
+   .. doctest::
+
+      >>> 'PYTHON IS AMAZING'.capitalize()
+      'Python is amazing'
+      >>> 'Njemačka starts With a non-ASCII digraph'.capitalize()
+      'Njemačka starts with a non-ascii digraph'
+
+   See also :meth:`title`.
 
    .. versionchanged:: 3.8
       The first character is now put into titlecase rather than uppercase.
       This means that characters like digraphs will only have their first
       letter capitalized, instead of the full character.
 
+
 .. method:: str.casefold()
 
    Return a casefolded copy of the string. Casefolded strings may be used for
@@ -3137,7 +3147,7 @@ expression support in the :mod:`re` module).
         >>> titlecase("they're bill's friends.")
         "They're Bill's Friends."
 
-   See also :meth:`istitle`.
+   See also :meth:`istitle` and :meth:`capitalize`.
 
 
 .. method:: str.translate(table, /)

Doc/library/collections.abc.rst

@@ -111,6 +111,9 @@ Collections Abstract Base Classes
 
 The collections module offers the following :term:`ABCs <abstract base class>`:
 
+The "Abstract Methods" column lists all required abstract methods,
+including those inherited from parent classes.
+
 .. tabularcolumns:: |l|L|L|L|
 
 ============================== ====================== ======================= ====================================================
@@ -120,7 +123,8 @@ ABC                            Inherits from          Abstract Methods        Mi
 :class:`Hashable` [1]_                                ``__hash__``
 :class:`Iterable` [1]_ [2]_                           ``__iter__``
 :class:`Iterator` [1]_         :class:`Iterable`      ``__next__``            ``__iter__``
-:class:`Reversible` [1]_       :class:`Iterable`      ``__reversed__``
+:class:`Reversible` [1]_       :class:`Iterable`      ``__iter__``,
+                                                      ``__reversed__``
 :class:`Generator`  [1]_       :class:`Iterator`      ``send``, ``throw``     ``close``, ``__iter__``, ``__next__``
 :class:`Sized`  [1]_                                  ``__len__``
 :class:`Callable`  [1]_                               ``__call__``
@@ -170,7 +174,8 @@ ABC                            Inherits from          Abstract Methods        Mi
 :class:`ValuesView`            :class:`MappingView`,                          ``__contains__``, ``__iter__``
                                :class:`Collection`
 :class:`Awaitable` [1]_                               ``__await__``
-:class:`Coroutine` [1]_        :class:`Awaitable`     ``send``, ``throw``     ``close``
+:class:`Coroutine` [1]_        :class:`Awaitable`     ``__await__``,          ``close``
+                                                      ``send``, ``throw``
 :class:`AsyncIterable` [1]_                           ``__aiter__``
 :class:`AsyncIterator` [1]_    :class:`AsyncIterable` ``__anext__``           ``__aiter__``
 :class:`AsyncGenerator` [1]_   :class:`AsyncIterator` ``asend``, ``athrow``   ``aclose``, ``__aiter__``, ``__anext__``

Doc/library/pdb.rst

@@ -214,8 +214,8 @@ slightly different way:
 
 .. awaitablefunction:: set_trace_async(*, header=None, commands=None)
 
-   async version of :func:`set_trace`. This function should be used inside an
-   async function with :keyword:`await`.
+   Asynchronous version of :func:`set_trace`. This function should be used inside
+   a :term:`coroutine function` with :keyword:`await`. For instance:
 
    .. code-block:: python
 

Lib/test/test_long.py

@@ -204,7 +204,33 @@ def test_division(self):
         self.check_division(710031681576388032, 26769404391308)
         self.check_division(1933622614268221, 30212853348836)
 
-
+    @support.requires_IEEE_754
+    def test_intradigit_shift(self):
+        # Unit tests for v_lshift and v_rshift in longobject.c.
+        # These two functions are not used by Python << and >>,
+        # exercise them via float conversion and true division.
+
+        # Full limb values.
+        two_limbs = (1 << (2 * SHIFT)) - 1
+        three_limbs = (1 << (3 * SHIFT)) - 1
+        four_limbs = (1 << (4 * SHIFT)) - 1
+        # Multi-limb (not compact) but bit_length() still <= 55.
+        bits50 = (1 << 50) - 1
+
+        # _PyLong_Frexp (float(n)):
+        # v_lshift if n.bit_length() <= 55, else v_rshift.
+        self.check_float_conversion(bits50)
+        self.check_float_conversion(two_limbs)
+        self.check_float_conversion(four_limbs)
+        self.check_float_conversion(10**40)
+
+        # long_true_divide (a / b):
+        # - (a.bit_length() - b.bit_length()) <= 55  => v_lshift,
+        # - (a.bit_length() - b.bit_length()) > 55   => v_rshift.
+        self.check_truediv(three_limbs, two_limbs)
+        self.check_truediv(four_limbs, two_limbs)
+        self.check_truediv(four_limbs, three_limbs)
+        self.check_truediv(10**40, 10**20)
 
     def test_karatsuba(self):
         digits = list(range(1, 5)) + list(range(KARATSUBA_CUTOFF,

Misc/NEWS.d/next/Core_and_Builtins/2026-09-07-09-52-21.gh-issue-156443.tT40sm.rst

@@ -0,0 +1 @@
+Speed up :func:`float` conversion and true division of large :class:`int` values.

Objects/longobject.c

@@ -1905,15 +1905,15 @@ static digit
 v_lshift(digit *z, digit *a, Py_ssize_t m, int d)
 {
     Py_ssize_t i;
-    digit carry = 0;
+    twodigits carry = 0;
 
     assert(0 <= d && d < PyLong_SHIFT);
     for (i=0; i < m; i++) {
         twodigits acc = (twodigits)a[i] << d | carry;
         z[i] = (digit)acc & PyLong_MASK;
-        carry = (digit)(acc >> PyLong_SHIFT);
+        carry = acc >> PyLong_SHIFT;
     }
-    return carry;
+    return (digit)carry;
 }
 
 /* Shift digit vector a[0:m] d bits right, with 0 <= d < PyLong_SHIFT.  Put
@@ -1923,16 +1923,16 @@ static digit
 v_rshift(digit *z, digit *a, Py_ssize_t m, int d)
 {
     Py_ssize_t i;
-    digit carry = 0;
-    digit mask = ((digit)1 << d) - 1U;
+    twodigits carry = 0;
+    twodigits mask = ((twodigits)1 << d) - 1U;
 
     assert(0 <= d && d < PyLong_SHIFT);
     for (i=m; i-- > 0;) {
-        twodigits acc = (twodigits)carry << PyLong_SHIFT | a[i];
-        carry = (digit)acc & mask;
+        twodigits acc = carry << PyLong_SHIFT | a[i];
+        carry = acc & mask;
         z[i] = (digit)(acc >> d);
     }
-    return carry;
+    return (digit)carry;
 }
 
 /* Divide long pin, w/ size digits, by non-zero digit n, storing quotient