From e5fbabbb47f45f738d42d0a558f37d221937adf0 Mon Sep 17 00:00:00 2001
From: Pablo Galindo Salgado <Pablogsal@gmail.com>
Date: Mon, 14 Sep 2026 16:31:59 -0400
Subject: [PATCH 1/4] gh-153568: Don't materialize parser token text that is
 never read (#153576)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* gh-153568: Don't materialize parser token text that is never read

Only tokens whose text is actually consumed get a bytes object;
operators and structural tokens no longer allocate one.

* Update Parser/pegen.c

Co-authored-by: Maurycy Pawłowski-Wieroński <maurycy@maurycy.com>

* gh-153568: Preserve keyword token text

---------

Co-authored-by: Maurycy Pawłowski-Wieroński <maurycy@maurycy.com>
---
 ...07-11-15-01-45.gh-issue-153568.toktext.rst |  2 +
 Parser/pegen.c                                | 43 ++++++++++++++++---
 2 files changed, 39 insertions(+), 6 deletions(-)
 create mode 100644 Misc/NEWS.d/next/Core_and_Builtins/2026-07-11-15-01-45.gh-issue-153568.toktext.rst

diff --git a/Misc/NEWS.d/next/Core_and_Builtins/2026-07-11-15-01-45.gh-issue-153568.toktext.rst b/Misc/NEWS.d/next/Core_and_Builtins/2026-07-11-15-01-45.gh-issue-153568.toktext.rst
new file mode 100644
index 00000000000000..36504dceb86bb4
--- /dev/null
+++ b/Misc/NEWS.d/next/Core_and_Builtins/2026-07-11-15-01-45.gh-issue-153568.toktext.rst
@@ -0,0 +1,2 @@
+Speed up the parser by not materializing the text of tokens whose text is
+never read.
diff --git a/Parser/pegen.c b/Parser/pegen.c
index c70244b1b36a1f..b13cb8d400f9c3 100644
--- a/Parser/pegen.c
+++ b/Parser/pegen.c
@@ -197,6 +197,32 @@ _get_keyword_or_name_type(Parser *p, const char *text, Py_ssize_t length)
     return NAME;
 }
 
+// Token types whose text is consumed by grammar actions or helpers, other
+// than NAME-derived tokens (identifiers and keywords), which always keep
+// their text: error actions may print keyword text (e.g. invalid_kwarg's
+// "cannot assign to True"). For every other type the token text is never
+// read again, so materializing a PyBytes for it is wasted work.
+static inline int
+token_needs_text(int type)
+{
+    switch (type) {
+        case NAME:
+        case NUMBER:
+        case STRING:
+        case FSTRING_START:
+        case FSTRING_MIDDLE:
+        case FSTRING_END:
+        case TSTRING_START:
+        case TSTRING_MIDDLE:
+        case TSTRING_END:
+        case TYPE_COMMENT:
+        case NOTEQUAL:  // _PyPegen_check_barry_as_flufl() reads its text
+            return 1;
+        default:
+            return 0;
+    }
+}
+
 static int
 initialize_token(Parser *p, Token *parser_token, struct token *new_token, int token_type) {
     assert(parser_token != NULL);
@@ -205,13 +231,18 @@ initialize_token(Parser *p, Token *parser_token, struct token *new_token, int to
     const char *text = _PyToken_TextView(p->tok, new_token, &length);
     parser_token->type = token_type == NAME
         ? _get_keyword_or_name_type(p, text, length) : token_type;
-    parser_token->bytes = PyBytes_FromStringAndSize(text, length);
-    if (parser_token->bytes == NULL) {
-        return -1;
+    if (token_type == NAME || token_needs_text(parser_token->type)) {
+        parser_token->bytes = PyBytes_FromStringAndSize(text, length);
+        if (parser_token->bytes == NULL) {
+            return -1;
+        }
+        if (_PyArena_AddPyObject(p->arena, parser_token->bytes) < 0) {
+            Py_DECREF(parser_token->bytes);
+            return -1;
+        }
     }
-    if (_PyArena_AddPyObject(p->arena, parser_token->bytes) < 0) {
-        Py_DECREF(parser_token->bytes);
-        return -1;
+    else {
+        parser_token->bytes = NULL;
     }
 
     parser_token->metadata = NULL;

From 7adb4cca1e07d1a14537f36c81f5387342f27951 Mon Sep 17 00:00:00 2001
From: Victor Stinner <vstinner@python.org>
Date: Mon, 14 Sep 2026 23:49:39 +0200
Subject: [PATCH 2/4] gh-155907: Complete PyMarshal C API tests (#157452)

Add tests on PyMarshal_ReadObjectFromString() and
PyMarshal_WriteObjectToString().

Add test on PyMarshal_WriteObjectToFile(NULL).
---
 Lib/test/test_capi/test_marshal.py | 251 +++++++++++++++++++++--------
 Modules/_testcapi/marshal.c        |  92 ++++++++---
 2 files changed, 254 insertions(+), 89 deletions(-)

diff --git a/Lib/test/test_capi/test_marshal.py b/Lib/test/test_capi/test_marshal.py
index 82a20c44fac424..972ff4ed53d687 100644
--- a/Lib/test/test_capi/test_marshal.py
+++ b/Lib/test/test_capi/test_marshal.py
@@ -1,19 +1,54 @@
+# Test PyMarshal C API
+
 import marshal
 import os.path
+import struct
 import unittest
 
 from test import support
 from test.support import import_helper
 from test.support import os_helper
-from test.test_marshal import HelperMixin, omit_last_byte
 
 
 # Skip this test if _testcapi is are not available.
 _testcapi = import_helper.import_module('_testcapi')
 
 
+def noop_func():
+    pass
+
+NULL = None
+SIMPLE_OBJECT = 123
+# Only test a few objects: see test_marshal for more exhaustive tests
+TEST_OBJECTS = (
+    '\u20ac',
+    b'abc',
+    True,
+    123,
+    45.6,
+    7+8j,
+    'long line '*1000,
+    # Check that serializing code object is allowed (allow_code = 1)
+    noop_func.__code__,
+)
+UNMARSHALLABLE = object()
+
+# Invalid marshal data
+JUNK_BYTES = b'\xff' * 32
+
+
+def read_file(filename):
+    with open(filename, 'rb') as fp:
+        return fp.read()
+
+
+def write_file(filename, data):
+    with open(filename, 'wb') as fp:
+        fp.write(data)
+
+
 @support.cpython_only
-class CAPI_TestCase(unittest.TestCase, HelperMixin):
+class CAPI_TestCase(unittest.TestCase):
 
     def test_read_from_file_error(self):
         # A read error is reported as OSError, not EOFError.
@@ -38,89 +73,163 @@ def test_write_to_file_error(self):
             _testcapi.pymarshal_write_object_to_file(obj, '/dev/full',
                                                      marshal.version)
 
-    def test_write_unmarshallable_to_file(self):
-        self.addCleanup(os_helper.unlink, os_helper.TESTFN)
-        with self.assertRaisesRegex(ValueError, 'unmarshallable object'):
-            _testcapi.pymarshal_write_object_to_file(object(), os_helper.TESTFN,
-                                                     marshal.version)
+    def check_object(self, obj2, obj):
+        self.assertEqual(obj2, obj)
+        self.assertEqual(type(obj2), type(obj))
 
     def test_write_long_to_file(self):
-        for v in range(marshal.version + 1):
-            _testcapi.pymarshal_write_long_to_file(0x12345678, os_helper.TESTFN, v)
-            with open(os_helper.TESTFN, 'rb') as f:
-                data = f.read()
-            os_helper.unlink(os_helper.TESTFN)
-            self.assertEqual(data, b'\x78\x56\x34\x12')
+        # Test PyMarshal_WriteLongToFile()
+        write_long_to_file = _testcapi.pymarshal_write_long_to_file
+        filename = os_helper.TESTFN
+        self.addCleanup(os_helper.unlink, filename)
+
+        def mask32(value):
+            res = value & (2 ** 32  - 1)
+            if res >= 2147483648:
+                return res - 4294967296
+            else:
+                return res
+
+        limit = 2 ** 31
+        values = [
+            _testcapi.LONG_MIN, _testcapi.LONG_MAX,
+            -limit, -limit + 2, limit - 2, limit - 1,
+            0, 123, -123,
+        ]
+        # Test values larger than 32-bit on platforms with 64-bit C long
+        if _testcapi.LONG_MAX > (2**31-1):
+            values.extend((-limit - 2, limit, limit + 2))
+
+        for version in range(marshal.version + 1):
+            for value in values:
+                with self.subTest(value=value, version=version):
+                    write_long_to_file(value, filename, version)
+                    data = read_file(filename)
+                    self.assertEqual(len(data), 4)
+                    value2 = struct.unpack('<i', data)[0]
+                    self.assertEqual(value2, mask32(value))
 
     def test_write_object_to_file(self):
-        obj = ('\u20ac', b'abc', 123, 45.6, 7+8j, 'long line '*1000)
-        for v in range(marshal.version + 1):
-            _testcapi.pymarshal_write_object_to_file(obj, os_helper.TESTFN, v)
-            with open(os_helper.TESTFN, 'rb') as f:
-                data = f.read()
-            os_helper.unlink(os_helper.TESTFN)
-            self.assertEqual(marshal.loads(data), obj)
+        # Test PyMarshal_WriteObjectToFile()
+        write_object_to_file = _testcapi.pymarshal_write_object_to_file
+        filename = os_helper.TESTFN
+        self.addCleanup(os_helper.unlink, filename)
+
+        for version in range(marshal.version + 1):
+            for obj in TEST_OBJECTS:
+                with self.subTest(obj=obj, version=version):
+                    write_object_to_file(obj, filename, version)
+                    data = read_file(filename)
+                    self.assertEqual(marshal.loads(data), obj)
+
+            with self.assertRaises(SystemError):
+                write_object_to_file(NULL, filename, version)
+
+            with self.assertRaisesRegex(ValueError, 'unmarshallable object'):
+                write_object_to_file(UNMARSHALLABLE, filename, version)
 
     def test_read_short_from_file(self):
-        with open(os_helper.TESTFN, 'wb') as f:
-            f.write(b'\x34\x12xxxx')
-        r, p = _testcapi.pymarshal_read_short_from_file(os_helper.TESTFN)
-        os_helper.unlink(os_helper.TESTFN)
-        self.assertEqual(r, 0x1234)
-        self.assertEqual(p, 2)
-
-        with open(os_helper.TESTFN, 'wb') as f:
-            f.write(b'\x12')
+        # Test PyMarshal_ReadShortFromFile()
+        read_short_from_file = _testcapi.pymarshal_read_short_from_file
+        filename = os_helper.TESTFN
+        self.addCleanup(os_helper.unlink, filename)
+
+        for value in (-2**15, 2**15-1, 0, 123, -123):
+            with self.subTest(value=value):
+                data = struct.pack('<h', value) + b'xxxx'
+                write_file(filename, data)
+                value2 = read_short_from_file(filename)
+                self.assertEqual(value2, value)
+
+        write_file(filename, b'\x12')  # less than 2 bytes
         with self.assertRaises(EOFError):
-            _testcapi.pymarshal_read_short_from_file(os_helper.TESTFN)
-        os_helper.unlink(os_helper.TESTFN)
+            read_short_from_file(filename)
 
     def test_read_long_from_file(self):
-        with open(os_helper.TESTFN, 'wb') as f:
-            f.write(b'\x78\x56\x34\x12xxxx')
-        r, p = _testcapi.pymarshal_read_long_from_file(os_helper.TESTFN)
-        os_helper.unlink(os_helper.TESTFN)
-        self.assertEqual(r, 0x12345678)
-        self.assertEqual(p, 4)
-
-        with open(os_helper.TESTFN, 'wb') as f:
-            f.write(b'\x56\x34\x12')
+        # Test PyMarshal_ReadLongFromFile()
+        read_long_from_file = _testcapi.pymarshal_read_long_from_file
+        filename = os_helper.TESTFN
+        self.addCleanup(os_helper.unlink, filename)
+
+        for value in (_testcapi.INT_MIN, _testcapi.INT_MAX, 0, 123, -123):
+            with self.subTest(value=value):
+                data = struct.pack('<i', value)
+                write_file(filename, data)
+                value2 = read_long_from_file(filename)
+                self.assertEqual(value2, value)
+
+        write_file(filename, b'\x56\x34\x12')  # less than 4 bytes
+        with self.assertRaises(EOFError):
+            read_long_from_file(filename)
+
+    def check_read_object(self, read_object_func, check_pos=True):
+        filename = os_helper.TESTFN
+        self.addCleanup(os_helper.unlink, filename)
+
+        version = marshal.version
+        for obj in TEST_OBJECTS:
+            with self.subTest(obj=obj):
+                data = marshal.dumps(obj, version)
+                data += b'abc'  # following data is ignored
+                write_file(filename, data)
+                obj2, pos = read_object_func(filename)
+                self.check_object(obj2, obj)
+                if check_pos:
+                    self.assertEqual(pos, len(data))
+
+        data = marshal.dumps(SIMPLE_OBJECT, version)
+        data = data[:-1]  # truncate last byte
+        write_file(filename, data)
         with self.assertRaises(EOFError):
-            _testcapi.pymarshal_read_long_from_file(os_helper.TESTFN)
-        os_helper.unlink(os_helper.TESTFN)
+            read_object_func(filename)
+
+        write_file(filename, JUNK_BYTES)
+        with self.assertRaisesRegex(ValueError, 'bad marshal data'):
+            read_object_func(filename)
 
     def test_read_last_object_from_file(self):
-        obj = ('\u20ac', b'abc', 123, 45.6, 7+8j)
-        for v in range(marshal.version + 1):
-            data = marshal.dumps(obj, v)
-            with open(os_helper.TESTFN, 'wb') as f:
-                f.write(data + b'xxxx')
-            r, p = _testcapi.pymarshal_read_last_object_from_file(os_helper.TESTFN)
-            os_helper.unlink(os_helper.TESTFN)
-            self.assertEqual(r, obj)
-
-            with open(os_helper.TESTFN, 'wb') as f:
-                f.write(omit_last_byte(data))
-            with self.assertRaises(EOFError):
-                _testcapi.pymarshal_read_last_object_from_file(os_helper.TESTFN)
-            os_helper.unlink(os_helper.TESTFN)
+        # Test PyMarshal_ReadLastObjectFromFile()
+        read_last_object_from_file = _testcapi.pymarshal_read_last_object_from_file
+        self.check_read_object(read_last_object_from_file)
 
     def test_read_object_from_file(self):
-        obj = ('\u20ac', b'abc', 123, 45.6, 7+8j)
-        for v in range(marshal.version + 1):
-            data = marshal.dumps(obj, v)
-            with open(os_helper.TESTFN, 'wb') as f:
-                f.write(data + b'xxxx')
-            r, p = _testcapi.pymarshal_read_object_from_file(os_helper.TESTFN)
-            os_helper.unlink(os_helper.TESTFN)
-            self.assertEqual(r, obj)
-            self.assertEqual(p, len(data))
-
-            with open(os_helper.TESTFN, 'wb') as f:
-                f.write(omit_last_byte(data))
-            with self.assertRaises(EOFError):
-                _testcapi.pymarshal_read_object_from_file(os_helper.TESTFN)
-            os_helper.unlink(os_helper.TESTFN)
+        # Test PyMarshal_ReadObjectFromFile()
+        read_object_from_file = _testcapi.pymarshal_read_object_from_file
+        self.check_read_object(read_object_from_file, check_pos=False)
+
+    def test_pymarshal_readobjectfromstring(self):
+        # Test PyMarshal_ReadObjectFromString()
+        readobjectfromstring = _testcapi.pymarshal_readobjectfromstring
+        for obj in TEST_OBJECTS:
+            for version in range(marshal.version + 1):
+                with self.subTest(obj=obj, version=version):
+                    data = marshal.dumps(obj, version)
+                    obj2 = readobjectfromstring(data)
+                    self.check_object(obj2, obj)
+
+        data = marshal.dumps(SIMPLE_OBJECT, marshal.version)
+        data = data[:-1]  # truncate last byte
+        with self.assertRaises(EOFError):
+            readobjectfromstring(data)
+
+        with self.assertRaisesRegex(ValueError, 'bad marshal data'):
+            readobjectfromstring(JUNK_BYTES)
+
+    def test_pymarshal_writeobjecttostring(self):
+        # Test PyMarshal_WriteObjectToString()
+        writeobjecttostring = _testcapi.pymarshal_writeobjecttostring
+        for version in range(marshal.version + 1):
+            for obj in TEST_OBJECTS:
+                with self.subTest(obj=obj, version=version):
+                    data = writeobjecttostring(obj, version)
+                    obj2 = marshal.loads(data)
+                    self.check_object(obj2, obj)
+
+            with self.assertRaisesRegex(ValueError, 'unmarshallable object'):
+                writeobjecttostring(UNMARSHALLABLE, version)
+
+            with self.assertRaises(SystemError):
+                writeobjecttostring(NULL, version)
 
 
 if __name__ == "__main__":
diff --git a/Modules/_testcapi/marshal.c b/Modules/_testcapi/marshal.c
index fe5b8259b88578..cf5c2250dfe609 100644
--- a/Modules/_testcapi/marshal.c
+++ b/Modules/_testcapi/marshal.c
@@ -1,25 +1,28 @@
 // Test PyMarshal C API
 
 #include "parts.h"
+#include "util.h"
 #include "marshal.h"              // PyMarshal_WriteLongToFile()
 
+
+// Test PyMarshal_WriteLongToFile()
 static PyObject*
 pymarshal_write_long_to_file(PyObject* self, PyObject *args)
 {
     long value;
     PyObject *filename;
     int version;
-    FILE *fp;
 
     if (!PyArg_ParseTuple(args, "lOi:pymarshal_write_long_to_file",
                           &value, &filename, &version))
         return NULL;
 
-    fp = Py_fopen(filename, "wb");
+    FILE *fp = Py_fopen(filename, "wb");
     if (fp == NULL) {
         return NULL;
     }
 
+    assert(!PyErr_Occurred());
     PyMarshal_WriteLongToFile(value, fp, version);
 
     fclose(fp);
@@ -29,81 +32,97 @@ pymarshal_write_long_to_file(PyObject* self, PyObject *args)
     Py_RETURN_NONE;
 }
 
+
+// Test PyMarshal_WriteObjectToFile()
 static PyObject*
 pymarshal_write_object_to_file(PyObject* self, PyObject *args)
 {
     PyObject *obj;
     PyObject *filename;
     int version;
-    FILE *fp;
 
     if (!PyArg_ParseTuple(args, "OOi:pymarshal_write_object_to_file",
-                          &obj, &filename, &version))
+                          &obj, &filename, &version)) {
         return NULL;
+    }
+    NULLABLE(obj);
 
-    fp = Py_fopen(filename, "wb");
+    FILE *fp = Py_fopen(filename, "wb");
     if (fp == NULL) {
         return NULL;
     }
 
+    assert(!PyErr_Occurred());
     PyMarshal_WriteObjectToFile(obj, fp, version);
-
     fclose(fp);
     if (PyErr_Occurred()) {
         return NULL;
     }
+
     Py_RETURN_NONE;
 }
 
+
+// Test PyMarshal_ReadShortFromFile()
 static PyObject*
 pymarshal_read_short_from_file(PyObject* self, PyObject *args)
 {
     int value;
     long pos;
     PyObject *filename;
-    FILE *fp;
-
     if (!PyArg_ParseTuple(args, "O:pymarshal_read_short_from_file", &filename))
         return NULL;
 
-    fp = Py_fopen(filename, "rb");
+    FILE *fp = Py_fopen(filename, "rb");
     if (fp == NULL) {
         return NULL;
     }
 
+    assert(!PyErr_Occurred());
     value = PyMarshal_ReadShortFromFile(fp);
     pos = ftell(fp);
 
     fclose(fp);
-    if (PyErr_Occurred())
+    if (PyErr_Occurred()) {
+        assert(value == -1);
         return NULL;
-    return Py_BuildValue("il", value, pos);
+    }
+
+    assert(pos == 2);
+    return PyLong_FromLong(value);
 }
 
+
+// Test PyMarshal_ReadLongFromFile()
 static PyObject*
 pymarshal_read_long_from_file(PyObject* self, PyObject *args)
 {
-    long value, pos;
+    long pos;
     PyObject *filename;
-    FILE *fp;
-
     if (!PyArg_ParseTuple(args, "O:pymarshal_read_long_from_file", &filename))
         return NULL;
 
-    fp = Py_fopen(filename, "rb");
+    FILE *fp = Py_fopen(filename, "rb");
     if (fp == NULL) {
         return NULL;
     }
 
-    value = PyMarshal_ReadLongFromFile(fp);
+    assert(!PyErr_Occurred());
+    long value = PyMarshal_ReadLongFromFile(fp);
     pos = ftell(fp);
 
     fclose(fp);
-    if (PyErr_Occurred())
+    if (PyErr_Occurred()) {
+        assert(value == -1);
         return NULL;
-    return Py_BuildValue("ll", value, pos);
+    }
+
+    assert(pos == 4);
+    return PyLong_FromLong(value);
 }
 
+
+// Test PyMarshal_ReadLastObjectFromFile()
 static PyObject*
 pymarshal_read_last_object_from_file(PyObject* self, PyObject *args)
 {
@@ -116,6 +135,7 @@ pymarshal_read_last_object_from_file(PyObject* self, PyObject *args)
         return NULL;
     }
 
+    assert(!PyErr_Occurred());
     PyObject *obj = PyMarshal_ReadLastObjectFromFile(fp);
     long pos = ftell(fp);
 
@@ -126,6 +146,8 @@ pymarshal_read_last_object_from_file(PyObject* self, PyObject *args)
     return Py_BuildValue("Nl", obj, pos);
 }
 
+
+// Test PyMarshal_ReadObjectFromFile()
 static PyObject*
 pymarshal_read_object_from_file(PyObject* self, PyObject *args)
 {
@@ -138,6 +160,7 @@ pymarshal_read_object_from_file(PyObject* self, PyObject *args)
         return NULL;
     }
 
+    assert(!PyErr_Occurred());
     PyObject *obj = PyMarshal_ReadObjectFromFile(fp);
     long pos = ftell(fp);
 
@@ -149,6 +172,35 @@ pymarshal_read_object_from_file(PyObject* self, PyObject *args)
 }
 
 
+// Test PyMarshal_ReadObjectFromString()
+static PyObject*
+pymarshal_readobjectfromstring(PyObject* self, PyObject *args)
+{
+    const char *str;
+    Py_ssize_t size;
+    if (!PyArg_ParseTuple(args, "s#", &str, &size)) {
+        return NULL;
+    }
+
+    return PyMarshal_ReadObjectFromString(str, size);
+}
+
+
+// Test PyMarshal_WriteObjectToString()
+static PyObject*
+pymarshal_writeobjecttostring(PyObject* self, PyObject *args)
+{
+    PyObject *obj;
+    int version;
+    if (!PyArg_ParseTuple(args, "Oi", &obj, &version)) {
+        return NULL;
+    }
+    NULLABLE(obj);
+
+    return PyMarshal_WriteObjectToString(obj, version);
+}
+
+
 static PyMethodDef test_methods[] = {
     {"pymarshal_write_long_to_file",
         pymarshal_write_long_to_file, METH_VARARGS},
@@ -162,6 +214,10 @@ static PyMethodDef test_methods[] = {
         pymarshal_read_last_object_from_file, METH_VARARGS},
     {"pymarshal_read_object_from_file",
         pymarshal_read_object_from_file, METH_VARARGS},
+    {"pymarshal_readobjectfromstring",
+        pymarshal_readobjectfromstring, METH_VARARGS},
+    {"pymarshal_writeobjecttostring",
+        pymarshal_writeobjecttostring, METH_VARARGS},
     {NULL},
 };
 

From ab5b14789d54c5401f0ceee4ba1d113538adb113 Mon Sep 17 00:00:00 2001
From: Victor Stinner <vstinner@python.org>
Date: Mon, 14 Sep 2026 23:52:44 +0200
Subject: [PATCH 3/4] gh-155742: Use PyBytesWriter in Python/assemble.c
 (#157349)

Replace soft deprecated _PyBytes_Resize() with PyBytesWriter.
---
 Python/assemble.c | 46 ++++++++++++++++++++++++++++++----------------
 1 file changed, 30 insertions(+), 16 deletions(-)

diff --git a/Python/assemble.c b/Python/assemble.c
index 4bbebe30299906..8b92042345f150 100644
--- a/Python/assemble.c
+++ b/Python/assemble.c
@@ -48,8 +48,10 @@ instr_size(instruction *instr)
 }
 
 struct assembler {
-    PyObject *a_bytecode;  /* bytes containing bytecode */
+    PyBytesWriter *a_bytecode_writer; /* writer containing bytecode */
+    PyObject *a_bytecode;      /* bytes containing bytecode */
     int a_offset;              /* offset into bytecode */
+    PyBytesWriter *a_except_table_writer; /* writer containing exception table */
     PyObject *a_except_table;  /* bytes containing exception table */
     int a_except_table_off;    /* offset into exception table */
     /* Location Info */
@@ -64,38 +66,40 @@ assemble_init(struct assembler *a, int firstlineno)
 {
     memset(a, 0, sizeof(struct assembler));
     a->a_lineno = firstlineno;
-    a->a_bytecode = PyBytes_FromStringAndSize(NULL, DEFAULT_CODE_SIZE);
-    if (a->a_bytecode == NULL) {
+    a->a_bytecode_writer = PyBytesWriter_Create(DEFAULT_CODE_SIZE);
+    if (a->a_bytecode_writer == NULL) {
         goto error;
     }
     a->a_linetable_writer = PyBytesWriter_Create(DEFAULT_CNOTAB_SIZE);
     if (a->a_linetable_writer == NULL) {
         goto error;
     }
-    a->a_except_table = PyBytes_FromStringAndSize(NULL, DEFAULT_LNOTAB_SIZE);
-    if (a->a_except_table == NULL) {
+    a->a_except_table_writer = PyBytesWriter_Create(DEFAULT_LNOTAB_SIZE);
+    if (a->a_except_table_writer == NULL) {
         goto error;
     }
     return SUCCESS;
 error:
-    Py_CLEAR(a->a_bytecode);
+    PyBytesWriter_Discard(a->a_bytecode_writer);
     PyBytesWriter_Discard(a->a_linetable_writer);
-    Py_CLEAR(a->a_except_table);
+    PyBytesWriter_Discard(a->a_except_table_writer);
     return ERROR;
 }
 
 static void
 assemble_free(struct assembler *a)
 {
-    Py_XDECREF(a->a_bytecode);
+    PyBytesWriter_Discard(a->a_bytecode_writer);
     PyBytesWriter_Discard(a->a_linetable_writer);
+    PyBytesWriter_Discard(a->a_except_table_writer);
+    Py_XDECREF(a->a_bytecode);
     Py_XDECREF(a->a_linetable);
     Py_XDECREF(a->a_except_table);
 }
 
 static inline void
 write_except_byte(struct assembler *a, int byte) {
-    unsigned char *p = (unsigned char *) PyBytes_AS_STRING(a->a_except_table);
+    unsigned char *p = (unsigned char *) PyBytesWriter_GetData(a->a_except_table_writer);
     p[a->a_except_table_off++] = byte;
 }
 
@@ -133,9 +137,9 @@ assemble_emit_exception_table_entry(struct assembler *a, int start, int end,
                                     int handler_offset,
                                     _PyExceptHandlerInfo *handler)
 {
-    Py_ssize_t len = PyBytes_GET_SIZE(a->a_except_table);
+    Py_ssize_t len = PyBytesWriter_GetSize(a->a_except_table_writer);
     if (a->a_except_table_off + MAX_SIZE_OF_ENTRY >= len) {
-        RETURN_IF_ERROR(_PyBytes_Resize(&a->a_except_table, len * 2));
+        RETURN_IF_ERROR(PyBytesWriter_Resize(a->a_except_table_writer, len * 2));
     }
     int size = end-start;
     assert(end > start);
@@ -412,7 +416,7 @@ write_instr(_Py_CODEUNIT *codestr, instruction *instr, int ilen)
 static int
 assemble_emit_instr(struct assembler *a, instruction *instr)
 {
-    Py_ssize_t len = PyBytes_GET_SIZE(a->a_bytecode);
+    Py_ssize_t len = PyBytesWriter_GetSize(a->a_bytecode_writer);
     _Py_CODEUNIT *code;
 
     int size = instr_size(instr);
@@ -421,9 +425,9 @@ assemble_emit_instr(struct assembler *a, instruction *instr)
             PyErr_NoMemory();
             return ERROR;
         }
-        RETURN_IF_ERROR(_PyBytes_Resize(&a->a_bytecode, len * 2));
+        RETURN_IF_ERROR(PyBytesWriter_Resize(a->a_bytecode_writer, len * 2));
     }
-    code = (_Py_CODEUNIT *)PyBytes_AS_STRING(a->a_bytecode) + a->a_offset;
+    code = (_Py_CODEUNIT *)PyBytesWriter_GetData(a->a_bytecode_writer) + a->a_offset;
     a->a_offset += size;
     write_instr(code, instr, size);
     return SUCCESS;
@@ -444,7 +448,12 @@ assemble_emit(struct assembler *a, instr_sequence *instrs,
 
     RETURN_IF_ERROR(assemble_exception_table(a, instrs));
 
-    RETURN_IF_ERROR(_PyBytes_Resize(&a->a_except_table, a->a_except_table_off));
+    a->a_except_table = PyBytesWriter_FinishWithSize(a->a_except_table_writer,
+                                                     a->a_except_table_off);
+    a->a_except_table_writer = NULL;
+    if (a->a_except_table == NULL) {
+        return ERROR;
+    }
     RETURN_IF_ERROR(_PyCompile_ConstCacheMergeOne(const_cache, &a->a_except_table));
 
     a->a_linetable = PyBytesWriter_FinishWithSize(a->a_linetable_writer,
@@ -455,7 +464,12 @@ assemble_emit(struct assembler *a, instr_sequence *instrs,
     }
     RETURN_IF_ERROR(_PyCompile_ConstCacheMergeOne(const_cache, &a->a_linetable));
 
-    RETURN_IF_ERROR(_PyBytes_Resize(&a->a_bytecode, a->a_offset * sizeof(_Py_CODEUNIT)));
+    a->a_bytecode = PyBytesWriter_FinishWithSize(a->a_bytecode_writer,
+                                                 a->a_offset * sizeof(_Py_CODEUNIT));
+    a->a_bytecode_writer = NULL;
+    if (a->a_bytecode == NULL) {
+        return ERROR;
+    }
     RETURN_IF_ERROR(_PyCompile_ConstCacheMergeOne(const_cache, &a->a_bytecode));
     return SUCCESS;
 }

From c6741161d30953d5c05d2ee11112ce6c97d9d3c1 Mon Sep 17 00:00:00 2001
From: Victor Stinner <vstinner@python.org>
Date: Mon, 14 Sep 2026 23:56:56 +0200
Subject: [PATCH 4/4] gh-155742: Use PyBytesWriter in _zstd.finalize_dict()
 (#157343)

Replace soft deprecated PyBytes_FromStringAndSize() with
PyBytesWriter.
---
 Modules/_zstd/_zstdmodule.c | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/Modules/_zstd/_zstdmodule.c b/Modules/_zstd/_zstdmodule.c
index 9bf9658a99f87c..027768410b3f15 100644
--- a/Modules/_zstd/_zstdmodule.c
+++ b/Modules/_zstd/_zstdmodule.c
@@ -353,7 +353,8 @@ _zstd_finalize_dict_impl(PyObject *module, PyBytesObject *custom_dict_bytes,
 {
     Py_ssize_t chunks_number;
     size_t *chunk_sizes = NULL;
-    PyObject *dst_dict_bytes = NULL;
+    PyBytesWriter *dst_dict_bytes = NULL;
+    PyObject *result = NULL;
     size_t zstd_ret;
     ZDICT_params_t params;
 
@@ -372,7 +373,7 @@ _zstd_finalize_dict_impl(PyObject *module, PyBytesObject *custom_dict_bytes,
     }
 
     /* Allocate dict buffer */
-    dst_dict_bytes = PyBytes_FromStringAndSize(NULL, dict_size);
+    dst_dict_bytes = PyBytesWriter_Create(dict_size);
     if (dst_dict_bytes == NULL) {
         goto error;
     }
@@ -389,7 +390,8 @@ _zstd_finalize_dict_impl(PyObject *module, PyBytesObject *custom_dict_bytes,
     /* Finalize the dictionary */
     Py_BEGIN_ALLOW_THREADS
     zstd_ret = ZDICT_finalizeDictionary(
-                        PyBytes_AS_STRING(dst_dict_bytes), dict_size,
+                        PyBytesWriter_GetData(dst_dict_bytes),
+                        PyBytesWriter_GetSize(dst_dict_bytes),
                         PyBytes_AS_STRING(custom_dict_bytes),
                         Py_SIZE(custom_dict_bytes),
                         PyBytes_AS_STRING(samples_bytes), chunk_sizes,
@@ -404,18 +406,15 @@ _zstd_finalize_dict_impl(PyObject *module, PyBytesObject *custom_dict_bytes,
     }
 
     /* Resize dict_buffer */
-    if (_PyBytes_Resize(&dst_dict_bytes, zstd_ret) < 0) {
-        goto error;
-    }
-
-    goto success;
+    result = PyBytesWriter_FinishWithSize(dst_dict_bytes, zstd_ret);
+    goto done;
 
 error:
-    Py_CLEAR(dst_dict_bytes);
+    PyBytesWriter_Discard(dst_dict_bytes);
 
-success:
+done:
     PyMem_Free(chunk_sizes);
-    return dst_dict_bytes;
+    return result;
 }