gh-110222: Add support of PyStructSequence in copy.replace()

Lib/collections/__init__.py

@@ -457,7 +457,7 @@ def _make(cls, iterable):
     def _replace(self, /, **kwds):
         result = self._make(_map(kwds.pop, field_names, self))
         if kwds:
-            raise ValueError(f'Got unexpected field names: {list(kwds)!r}')
+            raise ValueError(f'Got unexpected field name(s): {list(kwds)!r}')
         return result
 
     _replace.__doc__ = (f'Return a new {typename} object replacing specified '

Lib/test/test_copy.py

@@ -4,6 +4,8 @@
 import copyreg
 import weakref
 import abc
+import os
+import time
 from operator import le, lt, ge, gt, eq, ne, attrgetter
 
 import unittest
@@ -945,6 +947,28 @@ def test_namedtuple(self):
         with self.assertRaisesRegex(ValueError, 'unexpected field name'):
             copy.replace(p, x=1, error=2)
 
+    def test_structseq(self):
+        t = time.gmtime(0)
+        self.assertEqual(copy.replace(t), (1970, 1, 1, 0, 0, 0, 3, 1, 0))
+        self.assertEqual(copy.replace(t, tm_year=2000),
+                         (2000, 1, 1, 0, 0, 0, 3, 1, 0))
+        self.assertEqual(copy.replace(t, tm_mon=2),
+                         (1970, 2, 1, 0, 0, 0, 3, 1, 0))
+        self.assertEqual(copy.replace(t, tm_year=2000, tm_mon=2),
+                         (2000, 2, 1, 0, 0, 0, 3, 1, 0))
+        with self.assertRaisesRegex(ValueError, 'unexpected field name'):
+            copy.replace(t, tm_year=2000, error=2)
+
+        assert os.stat_result.n_unnamed_fields > 0
+        r = os.stat_result(range(os.stat_result.n_sequence_fields), {'st_atime_ns': -1})
+        self.assertHasAttr(r, 'st_atime_ns')
+        self.assertEqual(r.st_atime_ns, -1)
+        with self.assertRaisesRegex(AttributeError, 'readonly attribute'):
+            r.st_atime_ns = -2
+        r2 = copy.replace(r, st_atime_ns=-3)
+        self.assertHasAttr(r2, 'st_atime_ns')
+        self.assertEqual(r2.st_atime_ns, -3)
+
     def test_dataclass(self):
         from dataclasses import dataclass
         @dataclass

Misc/NEWS.d/next/Library/2023-10-02-15-07-28.gh-issue-110222.zl_oHh.rst

@@ -0,0 +1 @@
+Add support of struct sequence objects in :func:`copy.replace`.

Objects/structseq.c

@@ -8,6 +8,7 @@
 */
 
 #include "Python.h"
+#include "pycore_dict.h"          // _PyDict_Pop()
 #include "pycore_tuple.h"         // _PyTuple_FromArray()
 #include "pycore_object.h"        // _PyObject_GC_TRACK()
 
@@ -365,9 +366,99 @@ structseq_reduce(PyStructSequence* self, PyObject *Py_UNUSED(ignored))
     return NULL;
 }
 
+
+static PyObject *
+structseq_replace(PyStructSequence *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *tup = NULL;
+    PyObject *dict = NULL;
+    PyObject *result;
+    Py_ssize_t n_fields, n_visible_fields, n_unnamed_fields, i;
+
+    if (!_PyArg_NoPositional("__replace__", args)) {
+        return NULL;
+    }
+
+    n_fields = REAL_SIZE(self);
+    if (n_fields < 0) {
+        return NULL;
+    }
+    n_visible_fields = VISIBLE_SIZE(self);
+    n_unnamed_fields = UNNAMED_FIELDS(self);
+    if (n_unnamed_fields < 0) {
+        return NULL;
+    }
+    tup = _PyTuple_FromArray(self->ob_item, n_visible_fields);
+    if (!tup) {
+        goto error;
+    }
+
+    dict = PyDict_New();
+    if (!dict) {
+        goto error;
+    }
+
+    if (kwargs != NULL) {
+        for (i = 0; i < n_visible_fields; i++) {
+            const char *name = Py_TYPE(self)->tp_members[i].name;
+            PyObject *key = PyUnicode_FromString(name);
+            if (!key) {
+                goto error;
+            }
+            PyObject *ob = _PyDict_Pop(kwargs, key, self->ob_item[i]);
+            Py_DECREF(key);
+            if (!ob) {
+                goto error;
+            }
+            PyTuple_SetItem(tup, i, ob);
+        }
+        for (i = n_visible_fields; i < n_fields; i++) {
+            const char *name = Py_TYPE(self)->tp_members[i - n_unnamed_fields].name;
+            PyObject *key = PyUnicode_FromString(name);
+            if (!key) {
+                goto error;
+            }
+            PyObject *ob = _PyDict_Pop(kwargs, key, self->ob_item[i]);
+            if (PyDict_SetItem(dict, key, ob) < 0) {
+                goto error;
+            }
+        }
+        if (PyDict_Size(kwargs) > 0) {
+            PyObject *names = PyDict_Keys(kwargs);
+            if (names) {
+                PyErr_Format(PyExc_ValueError, "Got unexpected field name(s): %R", names);
+                Py_DECREF(names);
+            }
+            goto error;
+        }
+    }
+    else
+    {
+        for (i = n_visible_fields; i < n_fields; i++) {
+            const char *name = Py_TYPE(self)->tp_members[i - n_unnamed_fields].name;
+            if (PyDict_SetItemString(dict, name, self->ob_item[i]) < 0) {
+                goto error;
+            }
+        }
+    }
+
+    result = structseq_new_impl(Py_TYPE(self), tup, dict);
+
+    Py_DECREF(tup);
+    Py_DECREF(dict);
+
+    return result;
+
+error:
+    Py_XDECREF(tup);
+    Py_XDECREF(dict);
+    return NULL;
+}
+
 static PyMethodDef structseq_methods[] = {
     {"__reduce__", (PyCFunction)structseq_reduce, METH_NOARGS, NULL},
-    {NULL, NULL}
+    {"__replace__", _PyCFunction_CAST(structseq_replace), METH_VARARGS | METH_KEYWORDS, NULL},
+    {NULL, NULL}  // sentinel
 };
 
 static Py_ssize_t