update to python 3.14.10

Author: chcg

.github/workflows/CI_build.yml

@@ -44,9 +44,9 @@ jobs:
       if: matrix.build_configuration == 'Release'
       working-directory: installer
       run: |
-           $env:PYTHONBUILDDIR_ARM64='${{ github.workspace }}\packages\pythonarm64.3.14.9\tools'
-           $env:PYTHONBUILDDIR_X64='${{ github.workspace }}\packages\python.3.14.9\tools'
-           $env:PYTHONBUILDDIR='${{ github.workspace }}\packages\pythonx86.3.14.9\tools'
+           $env:PYTHONBUILDDIR_ARM64='${{ github.workspace }}\packages\pythonarm64.3.14.10\tools'
+           $env:PYTHONBUILDDIR_X64='${{ github.workspace }}\packages\python.3.14.10\tools'
+           $env:PYTHONBUILDDIR='${{ github.workspace }}\packages\pythonx86.3.14.10\tools'
            Rename-Item -Path ".\buildPaths.bat.orig" -NewName "buildPaths.bat"
            dotnet tool install --global wix --version 7.0.0
            .\buildAll.bat ${{ matrix.build_platform }}

PythonLib/full/_pydecimal.py

@@ -444,6 +444,95 @@ def IEEEContext(bits, /):
 
 ##### Decimal class #######################################################
 
+# Observation: For all q >= 0 and a >= 1, q < 10**a iff len(str(q)) <= a.
+#
+# The constants below are used to speed-up "q < 10 ** a" checks to avoid
+# computing len(str(q)) as much as possible. Those speed-ups are based on
+# the following claims.
+#
+# See https://github.com/python/cpython/issues/140036 for details.
+
+_LOG_10_BASE_2_LO = float.fromhex('0x1.a934f0979a371p+1')
+assert pow(2, _LOG_10_BASE_2_LO) < 10
+
+_LOG_10_BASE_2_HI = float.fromhex('0x1.a934f0979a372p+1')
+assert pow(2, _LOG_10_BASE_2_HI) > 10
+
+
+def _tento(n):
+    """Compute 10 ** n with 1 base-5 exponentiation and 1 bit-shift."""
+    return (5 ** n) << n
+
+
+def _is_less_than_pow10a_use_str(q, a):
+    """Try to efficiently check len(str(q)) <= a, or equivalently q < 10**a.
+
+    If the comparison cannot be obtained from q.bit_length(),
+    then str(q) is explicitly computed and may raise ValueError.
+
+    Return (len(str(q)) <= a, None) or (len(str(q)) <= a, str(q)).
+    """
+    if q.bit_length() < a * _LOG_10_BASE_2_LO:
+        # Claim: If 0 < z <= log2(10) and q.bit_length() < a*z, then q < 10**a.
+        # Proof: By contradiction, q >= 10**a. By definition,
+        #   log2(q) >= a*log2(10) >= a*z > q.bit_length().
+        # In particular, q > 2**q.bit_length(), which is impossible.
+
+        # assert q < 10 ** a
+        return True, None
+    elif q.bit_length() >= 1 + a * _LOG_10_BASE_2_HI:
+        # Claim: If z > log2(10) and q.bit_length() >= 1 + a*z, then q > 10**a.
+        # Proof: Since q >= 2**(q.bit_length()-1), we have
+        #   q >= 2**(q.bit_length()-1) >= 2**(a*z) > 2**(a*log2(10)) = 10**a.
+
+        # assert q > 10 ** a
+        return False, None
+    # Handle cases that fail due to floating point precision loss
+    # when computing _LOG_10_BASE_2_LO and _LOG_10_BASE_2_HI, or
+    # that cannot be distinguished with (q.bit_length(), a) only.
+    #
+    # For instance, (q1, a) = (95, 2) and (q2, a) = (105, 2) produce
+    # different results but q1.bit_length() == q2.bit_length() == 7.
+    str_q = str(q)  # can raise a ValueError
+    is_valid = len(str_q) <= a
+    return is_valid, str_q
+
+
+def _is_less_than_pow10a(q, a, *, exact=True, ulp_order=20):
+    """Check that len(str(q)) <= a without computing str(q).
+
+    When *exact* is false, computing len(str(q)) is replaced by f(q):
+
+        f(q) = floor(log10(q) + ulp(log10(q)) * ulp_order + 1.0)
+
+    Most of the time, f(q) = len(str(q)) but in some cases, it may
+    happen that f(q) > len(str(q)).
+
+    When *exact* is true, computing len(str(q)) requires one bigint
+    exponentiation that only depends on q.
+    """
+    if q < 10:
+        return a >= 1
+
+    z = _math.log10(q)
+    t = _math.ulp(z) * ulp_order
+
+    if exact:
+        intlo = int(z - t)
+        inthi = int(z + t)
+        diff = inthi - intlo
+        assert diff in (0, 1)
+        if diff == 1:
+            lo = _tento(inthi)  # may be slow
+            if q < lo:
+                inthi -= 1
+                assert q >= (lo // 10)
+        ndigits = inthi + 1
+    else:
+        ndigits = int(z + t + 1.0)
+    return ndigits <= a
+
+
 # Do not subclass Decimal from numbers.Real and do not register it as such
 # (because Decimals are not interoperable with floats).  See the notes in
 # numbers.py for more detail.
@@ -1357,8 +1446,13 @@ def _divide(self, other, context):
             else:
                 op2.int *= 10**(op2.exp - op1.exp)
             q, r = divmod(op1.int, op2.int)
-            if q < 10**context.prec:
-                return (_dec_from_triple(sign, str(q), 0),
+            is_valid, str_q = _is_less_than_pow10a_use_str(q, context.prec)
+            if is_valid:
+                if str_q is None:
+                    str_q = str(q)
+                # assert q < 10 ** context.prec
+                # assert len(str(q)) <= context.prec
+                return (_dec_from_triple(sign, str_q, 0),
                         _dec_from_triple(self._sign, str(r), ideal_exp))
 
         # Here the quotient is too large to be representable
@@ -1513,7 +1607,9 @@ def remainder_near(self, other, context=None):
             r -= op2.int
             q += 1
 
-        if q >= 10**context.prec:
+        if not _is_less_than_pow10a(q, context.prec):
+            # assert q >= 10 ** context.prec
+            # assert len(str(q)) > context.prec
             return context._raise_error(DivisionImpossible)
 
         # result has same sign as self unless r is negative

PythonLib/full/_pyio.py

@@ -528,7 +528,7 @@ def nreadahead():
                     return 1
                 n = (readahead.find(b"\n") + 1) or len(readahead)
                 if size >= 0:
-                    n = min(n, size)
+                    n = min(n, size - len(res))
                 return n
         else:
             def nreadahead():

PythonLib/full/_pyrepl/simple_interact.py

@@ -136,9 +136,14 @@ def maybe_run_command(statement: str) -> bool:
                 sys.stdout.flush()
             except Exception:
                 pass
-
-            ps1 = getattr(sys, "ps1", ">>> ")
-            ps2 = getattr(sys, "ps2", "... ")
+            try:
+                ps1 = str(getattr(sys, "ps1", ">>> "))
+            except Exception:
+                ps1 = ">>> "
+            try:
+                ps2 = str(getattr(sys, "ps2", "... "))
+            except Exception:
+                ps2 = "... "
             try:
                 statement = multiline_input(more_lines, ps1, ps2)
             except EOFError:

PythonLib/full/asyncio/sslproto.py

@@ -659,13 +659,21 @@ def _do_shutdown(self):
             self._on_shutdown_complete(None)
 
     def _on_shutdown_complete(self, shutdown_exc):
-        if self._shutdown_timeout_handle is not None:
-            self._shutdown_timeout_handle.cancel()
-            self._shutdown_timeout_handle = None
-
         if shutdown_exc:
+            if self._shutdown_timeout_handle is not None:
+                self._shutdown_timeout_handle.cancel()
+                self._shutdown_timeout_handle = None
             self._fatal_error(shutdown_exc)
         else:
+            # transport.close() flushes its write buffer first, which a peer
+            # that does not read can delay forever.  Keep the timeout (or
+            # start it, if the peer initiated the shutdown) until
+            # connection_lost().
+            if self._shutdown_timeout_handle is None:
+                self._shutdown_timeout_handle = self._loop.call_later(
+                    self._ssl_shutdown_timeout,
+                    self._check_shutdown_timeout
+                )
             self._loop.call_soon(self._transport.close)
 
     def _abort(self, exc):

PythonLib/full/asyncio/unix_events.py

@@ -948,7 +948,15 @@ def _do_waitpid(self, loop, expected_pid, callback, args):
             # This makes the reaping of the child and notification of the return code
             # atomic with respect to the event loop thread.
             try:
-                os.waitid(os.P_PID, expected_pid, os.WEXITED | os.WNOWAIT)
+                while True:
+                    res = os.waitid(os.P_PID, expected_pid, os.WEXITED | os.WNOWAIT)
+                    # On macOS, waitid() with WEXITED incorrectly returns stopped
+                    # child processes (si_code == CLD_STOPPED). Consume the stop
+                    # notification so we wait for actual process termination.
+                    if res.si_code == os.CLD_STOPPED:
+                        os.waitid(os.P_PID, expected_pid, os.WSTOPPED | os.WNOHANG)
+                        continue
+                    break
             except ChildProcessError:
                 # The child process is already reaped
                 pass

PythonLib/full/hmac.py

@@ -39,6 +39,27 @@ def digest_wrapper(d=b''):
     return digest_wrapper
 
 
+def _select_blocksize(obj, default, stacklevel=3):
+    if hasattr(obj, 'block_size'):
+        blocksize = obj.block_size
+        if blocksize < 16:
+            import warnings
+
+            warnings.warn(f"block_size of {blocksize} seems too small; "
+                          f"using our default of {default}.",
+                          RuntimeWarning, stacklevel=stacklevel)
+            blocksize = default
+    else:
+        import warnings
+
+        warnings.warn("No block_size attribute on given digest object; "
+                      f"Assuming {default}.",
+                      RuntimeWarning, stacklevel=stacklevel)
+        blocksize = default
+    return blocksize
+
+
+
 class HMAC:
     """RFC 2104 HMAC class.  Also complies with RFC 4231.
 
@@ -106,28 +127,14 @@ def _init_builtin_hmac(self, key, msg, digestmod):
         self.block_size = self._hmac.block_size
 
     def _init_old(self, key, msg, digestmod):
-        import warnings
-
         digest_cons = _get_digest_constructor(digestmod)
 
         self._hmac = None
         self._outer = digest_cons()
         self._inner = digest_cons()
         self.digest_size = self._inner.digest_size
 
-        if hasattr(self._inner, 'block_size'):
-            blocksize = self._inner.block_size
-            if blocksize < 16:
-                warnings.warn(f"block_size of {blocksize} seems too small; "
-                              f"using our default of {self.blocksize}.",
-                              RuntimeWarning, 2)
-                blocksize = self.blocksize  # pragma: no cover
-        else:
-            warnings.warn("No block_size attribute on given digest object; "
-                          f"Assuming {self.blocksize}.",
-                          RuntimeWarning, 2)
-            blocksize = self.blocksize  # pragma: no cover
-
+        blocksize = _select_blocksize(self._inner, self.blocksize)
         if len(key) > blocksize:
             key = digest_cons(key).digest()
 
@@ -261,7 +268,7 @@ def _compute_digest_fallback(key, msg, digest):
     digest_cons = _get_digest_constructor(digest)
     inner = digest_cons()
     outer = digest_cons()
-    blocksize = getattr(inner, 'block_size', 64)
+    blocksize = _select_blocksize(inner, HMAC.blocksize)
     if len(key) > blocksize:
         key = digest_cons(key).digest()
     key = key.ljust(blocksize, b'\0')

PythonLib/full/http/cookiejar.py

@@ -974,6 +974,12 @@ def set_ok_version(self, cookie, request):
             _debug("   Set-Cookie2 without version attribute (%s=%s)",
                    cookie.name, cookie.value)
             return False
+        if cookie.version < 0:
+            # Neither the Netscape (version 0) nor the RFC 2965 (version > 0)
+            # rules would apply, so the domain checks would all be skipped.
+            _debug("   negative version attribute (%s=%s)",
+                   cookie.name, cookie.value)
+            return False
         if cookie.version > 0 and not self.rfc2965:
             _debug("   RFC 2965 cookies are switched off")
             return False
@@ -1114,6 +1120,9 @@ def return_ok(self, cookie, request):
         return True
 
     def return_ok_version(self, cookie, request):
+        if cookie.version < 0:
+            _debug("   negative version attribute")
+            return False
         if cookie.version > 0 and not self.rfc2965:
             _debug("   RFC 2965 cookies are switched off")
             return False
@@ -1502,6 +1511,8 @@ def _cookie_from_cookie_tuple(self, tup, request):
                 version = int(version)
             except ValueError:
                 return None  # invalid version, ignore cookie
+            if version < 0:
+                return None  # invalid version, ignore cookie
         secure = standard.get("secure", False)
         # (discard is also set if expires is Absent)
         discard = standard.get("discard", False)

PythonLib/full/logging/handlers.py

@@ -446,6 +446,7 @@ def doRollover(self):
                 timeTuple = time.localtime(t + addend)
         dfn = self.rotation_filename(self.baseFilename + "." +
                                      time.strftime(self.suffix, timeTuple))
+        self.rolloverAt = self.computeRollover(currentTime)
         if os.path.exists(dfn):
             # Already rolled over.
             return
@@ -459,7 +460,6 @@ def doRollover(self):
                 os.remove(s)
         if not self.delay:
             self.stream = self._open()
-        self.rolloverAt = self.computeRollover(currentTime)
 
 class WatchedFileHandler(logging.FileHandler):
     """

PythonLib/full/mailbox.py

@@ -1488,6 +1488,7 @@ def _install_message(self, message):
                 vis_buffer = io.BytesIO()
                 vis_generator = email.generator.BytesGenerator(vis_buffer, False, 0)
                 vis_generator.flatten(message.get_visible())
+                vis_buffer.seek(0)
                 while True:
                     line = vis_buffer.readline()
                     self._file.write(line.replace(b'\n', linesep))