Merge branch 'main' into pep750-concat-update

Author: davepeck

Doc/c-api/exceptions.rst

@@ -233,75 +233,6 @@
 # Temporary undocumented names.
 # In future this list must be empty.
 nitpick_ignore += [
-    # C API: Standard Python exception classes
-    ('c:data', 'PyExc_ArithmeticError'),
-    ('c:data', 'PyExc_AssertionError'),
-    ('c:data', 'PyExc_AttributeError'),
-    ('c:data', 'PyExc_BaseException'),
-    ('c:data', 'PyExc_BaseExceptionGroup'),
-    ('c:data', 'PyExc_BlockingIOError'),
-    ('c:data', 'PyExc_BrokenPipeError'),
-    ('c:data', 'PyExc_BufferError'),
-    ('c:data', 'PyExc_ChildProcessError'),
-    ('c:data', 'PyExc_ConnectionAbortedError'),
-    ('c:data', 'PyExc_ConnectionError'),
-    ('c:data', 'PyExc_ConnectionRefusedError'),
-    ('c:data', 'PyExc_ConnectionResetError'),
-    ('c:data', 'PyExc_EOFError'),
-    ('c:data', 'PyExc_Exception'),
-    ('c:data', 'PyExc_FileExistsError'),
-    ('c:data', 'PyExc_FileNotFoundError'),
-    ('c:data', 'PyExc_FloatingPointError'),
-    ('c:data', 'PyExc_GeneratorExit'),
-    ('c:data', 'PyExc_ImportError'),
-    ('c:data', 'PyExc_IndentationError'),
-    ('c:data', 'PyExc_IndexError'),
-    ('c:data', 'PyExc_InterruptedError'),
-    ('c:data', 'PyExc_IsADirectoryError'),
-    ('c:data', 'PyExc_KeyboardInterrupt'),
-    ('c:data', 'PyExc_KeyError'),
-    ('c:data', 'PyExc_LookupError'),
-    ('c:data', 'PyExc_MemoryError'),
-    ('c:data', 'PyExc_ModuleNotFoundError'),
-    ('c:data', 'PyExc_NameError'),
-    ('c:data', 'PyExc_NotADirectoryError'),
-    ('c:data', 'PyExc_NotImplementedError'),
-    ('c:data', 'PyExc_OSError'),
-    ('c:data', 'PyExc_OverflowError'),
-    ('c:data', 'PyExc_PermissionError'),
-    ('c:data', 'PyExc_ProcessLookupError'),
-    ('c:data', 'PyExc_PythonFinalizationError'),
-    ('c:data', 'PyExc_RecursionError'),
-    ('c:data', 'PyExc_ReferenceError'),
-    ('c:data', 'PyExc_RuntimeError'),
-    ('c:data', 'PyExc_StopAsyncIteration'),
-    ('c:data', 'PyExc_StopIteration'),
-    ('c:data', 'PyExc_SyntaxError'),
-    ('c:data', 'PyExc_SystemError'),
-    ('c:data', 'PyExc_SystemExit'),
-    ('c:data', 'PyExc_TabError'),
-    ('c:data', 'PyExc_TimeoutError'),
-    ('c:data', 'PyExc_TypeError'),
-    ('c:data', 'PyExc_UnboundLocalError'),
-    ('c:data', 'PyExc_UnicodeDecodeError'),
-    ('c:data', 'PyExc_UnicodeEncodeError'),
-    ('c:data', 'PyExc_UnicodeError'),
-    ('c:data', 'PyExc_UnicodeTranslateError'),
-    ('c:data', 'PyExc_ValueError'),
-    ('c:data', 'PyExc_ZeroDivisionError'),
-    # C API: Standard Python warning classes
-    ('c:data', 'PyExc_BytesWarning'),
-    ('c:data', 'PyExc_DeprecationWarning'),
-    ('c:data', 'PyExc_EncodingWarning'),
-    ('c:data', 'PyExc_FutureWarning'),
-    ('c:data', 'PyExc_ImportWarning'),
-    ('c:data', 'PyExc_PendingDeprecationWarning'),
-    ('c:data', 'PyExc_ResourceWarning'),
-    ('c:data', 'PyExc_RuntimeWarning'),
-    ('c:data', 'PyExc_SyntaxWarning'),
-    ('c:data', 'PyExc_UnicodeWarning'),
-    ('c:data', 'PyExc_UserWarning'),
-    ('c:data', 'PyExc_Warning'),
     # Undocumented public C macros
     ('c:macro', 'Py_BUILD_ASSERT'),
     ('c:macro', 'Py_BUILD_ASSERT_EXPR'),

Doc/conf.py

@@ -243,8 +243,8 @@ wider range of codecs when working with binary files:
 .. function:: iterencode(iterator, encoding, errors='strict', **kwargs)
 
    Uses an incremental encoder to iteratively encode the input provided by
-   *iterator*. This function is a :term:`generator`.
-   The *errors* argument (as well as any
+   *iterator*. *iterator* must yield :class:`str` objects.
+   This function is a :term:`generator`. The *errors* argument (as well as any
    other keyword argument) is passed through to the incremental encoder.
 
    This function requires that the codec accept text :class:`str` objects
@@ -255,8 +255,8 @@ wider range of codecs when working with binary files:
 .. function:: iterdecode(iterator, encoding, errors='strict', **kwargs)
 
    Uses an incremental decoder to iteratively decode the input provided by
-   *iterator*. This function is a :term:`generator`.
-   The *errors* argument (as well as any
+   *iterator*. *iterator* must yield :class:`bytes` objects.
+   This function is a :term:`generator`. The *errors* argument (as well as any
    other keyword argument) is passed through to the incremental decoder.
 
    This function requires that the codec accept :class:`bytes` objects

Doc/library/codecs.rst

@@ -618,7 +618,7 @@ def readlines(self, sizehint=None, keepends=True):
             method and are included in the list entries.
 
             sizehint, if given, is ignored since there is no efficient
-            way to finding the true end-of-line.
+            way of finding the true end-of-line.
 
         """
         data = self.read()
@@ -709,13 +709,13 @@ def read(self, size=-1):
 
         return self.reader.read(size)
 
-    def readline(self, size=None):
+    def readline(self, size=None, keepends=True):
 
-        return self.reader.readline(size)
+        return self.reader.readline(size, keepends)
 
-    def readlines(self, sizehint=None):
+    def readlines(self, sizehint=None, keepends=True):
 
-        return self.reader.readlines(sizehint)
+        return self.reader.readlines(sizehint, keepends)
 
     def __next__(self):
 

Lib/codecs.py

@@ -436,7 +436,7 @@ def f(): """doc"""
             # test both direct compilation and compilation via AST
                 codeobjs = []
                 codeobjs.append(compile(codestr, "<test>", "exec", optimize=optval))
-                tree = ast.parse(codestr)
+                tree = ast.parse(codestr, optimize=optval)
                 codeobjs.append(compile(tree, "<test>", "exec", optimize=optval))
                 for code in codeobjs:
                     ns = {}
@@ -624,7 +624,7 @@ def test_compile_ast(self):
         for opt in [opt1, opt2]:
             opt_right = opt.value.right
             self.assertIsInstance(opt_right, ast.Constant)
-            self.assertEqual(opt_right.value, True)
+            self.assertEqual(opt_right.value, __debug__)
 
     def test_delattr(self):
         sys.spam = 1

Lib/test/test_builtin.py

@@ -2,33 +2,45 @@
 
 
 class TStringBaseCase:
+    def assertInterpolationEqual(self, i, exp):
+        """Test Interpolation equality.
+
+        The *i* argument must be an Interpolation instance.
+
+        The *exp* argument must be a tuple of the form
+        (value, expression, conversion, format_spec) where the final three
+        items may be omitted and are assumed to be '', None and '' respectively.
+        """
+        if len(exp) == 4:
+            actual = (i.value, i.expression, i.conversion, i.format_spec)
+            self.assertEqual(actual, exp)
+        elif len(exp) == 3:
+            self.assertEqual((i.value, i.expression, i.conversion), exp)
+            self.assertEqual(i.format_spec, "")
+        elif len(exp) == 2:
+            self.assertEqual((i.value, i.expression), exp)
+            self.assertEqual(i.conversion, None)
+            self.assertEqual(i.format_spec, "")
+        elif len(exp) == 1:
+            self.assertEqual((i.value,), exp)
+            self.assertEqual(i.expression, "")
+            self.assertEqual(i.conversion, None)
+            self.assertEqual(i.format_spec, "")
+
     def assertTStringEqual(self, t, strings, interpolations):
         """Test template string literal equality.
 
         The *strings* argument must be a tuple of strings equal to *t.strings*.
 
         The *interpolations* argument must be a sequence of tuples which are
-        compared against *t.interpolations*. Each tuple consists of
-        (value, expression, conversion, format_spec), though the final two
-        items may be omitted, and are assumed to be None and '' respectively.
+        compared against *t.interpolations*. Each tuple must match the form
+        described in the `assertInterpolationEqual` method.
         """
         self.assertEqual(t.strings, strings)
         self.assertEqual(len(t.interpolations), len(interpolations))
 
         for i, exp in zip(t.interpolations, interpolations, strict=True):
-            if len(exp) == 4:
-                actual = (i.value, i.expression, i.conversion, i.format_spec)
-                self.assertEqual(actual, exp)
-                continue
-
-            if len(exp) == 3:
-                self.assertEqual((i.value, i.expression, i.conversion), exp)
-                self.assertEqual(i.format_spec, '')
-                continue
-
-            self.assertEqual((i.value, i.expression), exp)
-            self.assertEqual(i.format_spec, '')
-            self.assertIsNone(i.conversion)
+            self.assertInterpolationEqual(i, exp)
 
 
 def convert(value, conversion):

Lib/test/test_string/_support.py

@@ -45,6 +45,19 @@ def test_basic_creation(self):
         self.assertEqual(len(t.interpolations), 0)
         self.assertEqual(fstring(t), 'Hello,\nworld')
 
+    def test_interpolation_creation(self):
+        i = Interpolation('Maria', 'name', 'a', 'fmt')
+        self.assertInterpolationEqual(i, ('Maria', 'name', 'a', 'fmt'))
+
+        i = Interpolation('Maria', 'name', 'a')
+        self.assertInterpolationEqual(i, ('Maria', 'name', 'a'))
+
+        i = Interpolation('Maria', 'name')
+        self.assertInterpolationEqual(i, ('Maria', 'name'))
+
+        i = Interpolation('Maria')
+        self.assertInterpolationEqual(i, ('Maria',))
+
     def test_creation_interleaving(self):
         # Should add strings on either side
         t = Template(Interpolation('Maria', 'name', None, ''))

Lib/test/test_string/test_templatelib.py

@@ -2673,8 +2673,12 @@ def test_compress_locking(self):
         input = b'a'* (16*_1K)
         num_threads = 8
 
+        # gh-136394: the first output of .compress() includes the frame header
+        # we run the first .compress() call outside of the threaded portion
+        # to make the test order-independent
+
         comp = ZstdCompressor()
-        parts = []
+        parts = [comp.compress(input, ZstdCompressor.FLUSH_BLOCK)]
         for _ in range(num_threads):
             res = comp.compress(input, ZstdCompressor.FLUSH_BLOCK)
             if res:
@@ -2683,7 +2687,7 @@ def test_compress_locking(self):
         expected = b''.join(parts) + rest1
 
         comp = ZstdCompressor()
-        output = []
+        output = [comp.compress(input, ZstdCompressor.FLUSH_BLOCK)]
         def run_method(method, input_data, output_data):
             res = method(input_data, ZstdCompressor.FLUSH_BLOCK)
             if res:

Lib/test/test_zstd.py

@@ -0,0 +1,5 @@
+Improve performance of ``PyLongObject`` conversion functions
+``PyLong_AsLongAndOverflow()``, ``PyLong_AsSsize_t()``, ``PyLong_AsUnsignedLong()``, ``PyLong_AsSize_t()``,
+``PyLong_AsUnsignedLongMask()``, ``PyLong_AsUnsignedLongLongMask()``, ``PyLong_AsLongLongAndOverflow()``
+for integers larger than 2**30 up to 30%.
+

Misc/NEWS.d/next/Core_and_Builtins/2025-06-17-08-37-45.gh-issue-82088.TgPvLg.rst

@@ -0,0 +1 @@
+``Interpolation.expression`` now has a default, the empty string.