gh-155358: [WIP] Deprecate tuple API of structseq objects

vstinner · vstinner · commit 89d3b2010cf8 · 2026-08-07T20:01:39.000+02:00
diff --git a/Include/internal/pycore_interp_structs.h b/Include/internal/pycore_interp_structs.h
@@ -823,6 +823,17 @@ typedef _Py_CODEUNIT *(*_PyJitEntryFuncPtr)(struct _PyExecutorObject *exec, _PyI
 
 #define _PyInterpreterGuard_GUARDS_NOT_ALLOWED UINTPTR_MAX
 
+typedef struct {
+    PyTypeObject *async_gen_hooks_type;
+    PyTypeObject *flags_type;
+#if defined(MS_WINDOWS)
+    PyTypeObject *windows_version_type;
+#endif
+#ifdef __EMSCRIPTEN__
+    PyTypeObject *emscripten_info_type;
+#endif
+} _PySys_State;
+
 /* PyInterpreterState holds the global state for one of the runtime's
    interpreters.  Typically the initial (main) interpreter is the only one.
 
@@ -899,6 +910,7 @@ struct _is {
 
     // Dictionary of the sys module
     PyObject *sysdict;
+    _PySys_State sys_state;
 
     // Dictionary of the builtins module
     PyObject *builtins;
diff --git a/Include/internal/pycore_pylifecycle.h b/Include/internal/pycore_pylifecycle.h
@@ -32,7 +32,7 @@ extern PyStatus _PySys_Create(
 extern PyStatus _PySys_ReadPreinitWarnOptions(PyWideStringList *options);
 extern PyStatus _PySys_ReadPreinitXOptions(PyConfig *config);
 extern int _PySys_UpdateConfig(PyThreadState *tstate);
-extern void _PySys_FiniTypes(PyInterpreterState *interp);
+extern void _PySys_Fini(PyInterpreterState *interp);
 extern int _PyBuiltins_AddExceptions(PyObject * bltinmod);
 extern PyStatus _Py_HashRandomization_Init(const PyConfig *);
 
diff --git a/Include/internal/pycore_structseq.h b/Include/internal/pycore_structseq.h
@@ -14,7 +14,8 @@ extern "C" {
 // Export for '_curses' shared extension
 PyAPI_FUNC(PyTypeObject*) _PyStructSequence_NewType(
     PyStructSequence_Desc *desc,
-    unsigned long tp_flags);
+    unsigned long tp_flags,
+    int deprecate_tuple_api);
 
 extern int _PyStructSequence_InitBuiltinWithFlags(
     PyInterpreterState *interp,
diff --git a/Lib/http/server.py b/Lib/http/server.py
@@ -857,7 +857,7 @@ def send_head(self):
 
             self.send_response(HTTPStatus.OK)
             self.send_header("Content-type", ctype)
-            self.send_header("Content-Length", str(fs[6]))
+            self.send_header("Content-Length", str(fs.st_size))
             self.send_header("Last-Modified",
                 self.date_time_string(fs.st_mtime))
             self._send_extra_response_headers()
diff --git a/Lib/test/test_grp.py b/Lib/test/test_grp.py
@@ -4,6 +4,7 @@
 import string
 import sys
 import unittest
+import warnings
 from test.support import import_helper
 
 
@@ -14,16 +15,19 @@ class GroupDatabaseTestCase(unittest.TestCase):
     def check_value(self, value):
         # check that a grp tuple has the entries and
         # attributes promised by the docs
-        self.assertEqual(len(value), 4)
-        self.assertEqual(value[0], value.gr_name)
         self.assertIsInstance(value.gr_name, str)
-        self.assertEqual(value[1], value.gr_passwd)
         self.assertIsInstance(value.gr_passwd, str)
-        self.assertEqual(value[2], value.gr_gid)
         self.assertIsInstance(value.gr_gid, int)
-        self.assertEqual(value[3], value.gr_mem)
         self.assertIsInstance(value.gr_mem, list)
 
+        with warnings.catch_warnings(category=DeprecationWarning):
+            warnings.simplefilter("ignore", category=DeprecationWarning)
+            self.assertEqual(len(value), 4)
+            self.assertEqual(value[0], value.gr_name)
+            self.assertEqual(value[1], value.gr_passwd)
+            self.assertEqual(value[2], value.gr_gid)
+            self.assertEqual(value[3], value.gr_mem)
+
     def test_values(self):
         entries = grp.getgrall()
 
diff --git a/Lib/test/test_os/test_os.py b/Lib/test/test_os/test_os.py
@@ -665,7 +665,9 @@ def check_stat_attributes(self, fname):
         result = os.stat(fname)
 
         # Make sure direct access works
-        self.assertEqual(result[stat.ST_SIZE], 3)
+        with warnings.catch_warnings(category=DeprecationWarning):
+            warnings.simplefilter("ignore", category=DeprecationWarning)
+            self.assertEqual(result[stat.ST_SIZE], 3)
         self.assertEqual(result.st_size, 3)
 
         # Make sure all the attributes are there
@@ -677,8 +679,10 @@ def check_stat_attributes(self, fname):
                     def trunc(x): return int(x)
                 else:
                     def trunc(x): return x
-                self.assertEqual(trunc(getattr(result, attr)),
-                                  result[getattr(stat, name)])
+                with warnings.catch_warnings(category=DeprecationWarning):
+                    warnings.simplefilter("ignore", category=DeprecationWarning)
+                    self.assertEqual(trunc(getattr(result, attr)),
+                                      result[getattr(stat, name)])
                 self.assertIn(attr, members)
 
         time_attributes = ['st_atime', 'st_mtime', 'st_ctime']
@@ -692,7 +696,9 @@ def trunc(x): return x
         self.check_timestamp_agreement(result, time_attributes)
 
         try:
-            result[200]
+            with warnings.catch_warnings(category=DeprecationWarning):
+                warnings.simplefilter("ignore", category=DeprecationWarning)
+                result[200]
             self.fail("No exception raised")
         except IndexError:
             pass
@@ -1055,9 +1061,11 @@ def support_subsecond(self, filename):
         # Heuristic to check if the filesystem supports timestamp with
         # subsecond resolution: check if float and int timestamps are different
         st = os.stat(filename)
-        return ((st.st_atime != st[7])
-                or (st.st_mtime != st[8])
-                or (st.st_ctime != st[9]))
+        with warnings.catch_warnings(category=DeprecationWarning):
+            warnings.simplefilter("ignore", category=DeprecationWarning)
+            return ((st.st_atime != st[7])
+                    or (st.st_mtime != st[8])
+                    or (st.st_ctime != st[9]))
 
     def support_atime(self, filename):
         # Heuristic to check if the filesystem stores the access time.
diff --git a/Lib/test/test_os/test_posix.py b/Lib/test/test_os/test_posix.py
@@ -1816,8 +1816,8 @@ def test_link_dir_fd(self):
                 self.skipTest('posix.link(): %s' % e)
             self.addCleanup(posix.unlink, fulllinkname)
             # should have same inodes
-            self.assertEqual(posix.stat(fullname)[1],
-                posix.stat(fulllinkname)[1])
+            self.assertEqual(posix.stat(fullname).st_ino,
+                             posix.stat(fulllinkname).st_ino)
 
     @unittest.skipUnless(os.mkdir in os.supports_dir_fd, "test needs dir_fd support in os.mkdir()")
     def test_mkdir_dir_fd(self):
diff --git a/Lib/test/test_pwd.py b/Lib/test/test_pwd.py
@@ -2,6 +2,7 @@
 import string
 import sys
 import unittest
+import warnings
 from test.support import import_helper
 
 pwd = import_helper.import_module('pwd')
@@ -13,22 +14,25 @@ def test_values(self):
         entries = pwd.getpwall()
 
         for e in entries:
-            self.assertEqual(len(e), 7)
-            self.assertEqual(e[0], e.pw_name)
             self.assertIsInstance(e.pw_name, str)
-            self.assertEqual(e[1], e.pw_passwd)
             self.assertIsInstance(e.pw_passwd, str)
-            self.assertEqual(e[2], e.pw_uid)
             self.assertIsInstance(e.pw_uid, int)
-            self.assertEqual(e[3], e.pw_gid)
             self.assertIsInstance(e.pw_gid, int)
-            self.assertEqual(e[4], e.pw_gecos)
             self.assertIn(type(e.pw_gecos), (str, type(None)))
-            self.assertEqual(e[5], e.pw_dir)
             self.assertIsInstance(e.pw_dir, str)
-            self.assertEqual(e[6], e.pw_shell)
             self.assertIsInstance(e.pw_shell, str)
 
+            with warnings.catch_warnings(category=DeprecationWarning):
+                warnings.simplefilter("ignore", category=DeprecationWarning)
+                self.assertEqual(len(e), 7)
+                self.assertEqual(e[0], e.pw_name)
+                self.assertEqual(e[1], e.pw_passwd)
+                self.assertEqual(e[2], e.pw_uid)
+                self.assertEqual(e[3], e.pw_gid)
+                self.assertEqual(e[4], e.pw_gecos)
+                self.assertEqual(e[5], e.pw_dir)
+                self.assertEqual(e[6], e.pw_shell)
+
             # The following won't work, because of duplicate entries
             # for one uid
             #    self.assertEqual(pwd.getpwuid(e.pw_uid), e)
@@ -50,7 +54,7 @@ def test_values_extended(self):
         # check whether the entry returned by getpwuid()
         # for each uid is among those from getpwall() for this uid
         for e in entries:
-            if not e[0] or e[0] == '+':
+            if not e.pw_name or e.pw_name == '+':
                 continue # skip NIS entries etc.
             self.assertIn(pwd.getpwnam(e.pw_name), entriesbyname[e.pw_name])
             self.assertIn(pwd.getpwuid(e.pw_uid), entriesbyuid[e.pw_uid])
diff --git a/Lib/test/test_structseq.py b/Lib/test/test_structseq.py
@@ -6,6 +6,7 @@
 import textwrap
 import time
 import unittest
+import warnings
 from test.support import script_helper
 
 
@@ -228,7 +229,9 @@ def test_copying_with_unnamed_fields(self):
         self.assertEqual(r2.st_mode, r.st_mode)
         self.assertEqual(r2.st_atime, r.st_atime)
         self.assertEqual(r2.st_atime_ns, r.st_atime_ns)
-        self.assertIs(r2[0], r[0])
+        with warnings.catch_warnings(category=DeprecationWarning):
+            warnings.simplefilter("ignore", category=DeprecationWarning)
+            self.assertIs(r2[0], r[0])
         self.assertIs(r2.st_mode, r.st_mode)
         self.assertIs(r2.st_atime, r.st_atime)
         self.assertIs(r2.st_atime_ns, r.st_atime_ns)
@@ -239,7 +242,9 @@ def test_copying_with_unnamed_fields(self):
         self.assertEqual(r3.st_mode, r.st_mode)
         self.assertEqual(r3.st_atime, r.st_atime)
         self.assertEqual(r3.st_atime_ns, r.st_atime_ns)
-        self.assertIsNot(r3[0], r[0])
+        with warnings.catch_warnings(category=DeprecationWarning):
+            warnings.simplefilter("ignore", category=DeprecationWarning)
+            self.assertIsNot(r3[0], r[0])
         self.assertIsNot(r3.st_mode, r.st_mode)
         self.assertIsNot(r3.st_atime, r.st_atime)
         self.assertIsNot(r3.st_atime_ns, r.st_atime_ns)
diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py
@@ -874,8 +874,10 @@ def test_sys_flags_indexable_attributes(self):
             attr_type = bool if attr in ("dev_mode", "safe_path") else int
             self.assertEqual(type(getattr(sys.flags, attr)), attr_type, attr)
             attr_value = getattr(sys.flags, attr)
-            self.assertEqual(sys.flags[attr_idx], attr_value,
-                             msg=f"sys.flags .{attr} vs [{attr_idx}]")
+            with warnings.catch_warnings(category=DeprecationWarning):
+                warnings.simplefilter("ignore", category=DeprecationWarning)
+                self.assertEqual(sys.flags[attr_idx], attr_value,
+                                 msg=f"sys.flags .{attr} vs [{attr_idx}]")
         self.assertTrue(repr(sys.flags))
         self.assertEqual(len(sys.flags), 18, msg="Do not increase, see GH-122575")
 
@@ -1965,16 +1967,20 @@ def test_asyncgen_hooks(self):
         sys.set_asyncgen_hooks(firstiter=firstiter)
         hooks = sys.get_asyncgen_hooks()
         self.assertIs(hooks.firstiter, firstiter)
-        self.assertIs(hooks[0], firstiter)
         self.assertIs(hooks.finalizer, None)
-        self.assertIs(hooks[1], None)
+        with warnings.catch_warnings(category=DeprecationWarning):
+            warnings.simplefilter("ignore", category=DeprecationWarning)
+            self.assertIs(hooks[0], firstiter)
+            self.assertIs(hooks[1], None)
 
         sys.set_asyncgen_hooks(finalizer=finalizer)
         hooks = sys.get_asyncgen_hooks()
         self.assertIs(hooks.firstiter, firstiter)
-        self.assertIs(hooks[0], firstiter)
         self.assertIs(hooks.finalizer, finalizer)
-        self.assertIs(hooks[1], finalizer)
+        with warnings.catch_warnings(category=DeprecationWarning):
+            warnings.simplefilter("ignore", category=DeprecationWarning)
+            self.assertIs(hooks[0], firstiter)
+            self.assertIs(hooks[1], finalizer)
 
         sys.set_asyncgen_hooks(*old)
         cur = sys.get_asyncgen_hooks()
diff --git a/Lib/test/test_time.py b/Lib/test/test_time.py
@@ -815,7 +815,8 @@ def test_localtime_timezone(self):
         # Try and make UNIX times from the localtime and a 9-tuple
         # created from the localtime. Test to see that the times are
         # the same.
-        t = time.mktime(lt); t9 = time.mktime(lt[:9])
+        t = time.mktime(lt)
+        t9 = time.mktime(lt[:9])
         self.assertEqual(t, t9)
 
         # Make localtimes from the UNIX times and compare them to
diff --git a/Modules/_cursesmodule.c b/Modules/_cursesmodule.c
@@ -9025,7 +9025,8 @@ cursesmodule_exec(PyObject *module)
     /* ncurses_version */
     PyTypeObject *version_type;
     version_type = _PyStructSequence_NewType(&ncurses_version_desc,
-                                             Py_TPFLAGS_DISALLOW_INSTANTIATION);
+                                             Py_TPFLAGS_DISALLOW_INSTANTIATION,
+                                             0);
     if (version_type == NULL) {
         return -1;
     }
diff --git a/Modules/_interpchannelsmodule.c b/Modules/_interpchannelsmodule.c
@@ -9,6 +9,7 @@
 #include "pycore_crossinterp.h"   // _PyXIData_t
 #include "pycore_interp.h"        // _PyInterpreterState_LookUpID()
 #include "pycore_pystate.h"       // _PyInterpreterState_GetIDObject()
+#include "pycore_structseq.h"     // _PyStructSequence_NewType()
 
 #ifdef MS_WINDOWS
 #ifndef WIN32_LEAN_AND_MEAN
@@ -3576,7 +3577,7 @@ module_exec(PyObject *mod)
     /* Add other types */
 
     // ChannelInfo
-    state->ChannelInfoType = PyStructSequence_NewType(&channel_info_desc);
+    state->ChannelInfoType = _PyStructSequence_NewType(&channel_info_desc, 0, 1);
     if (state->ChannelInfoType == NULL) {
         goto error;
     }
diff --git a/Modules/_lsprof.c b/Modules/_lsprof.c
@@ -6,6 +6,7 @@
 #include "pycore_call.h"          // _PyObject_CallNoArgs()
 #include "pycore_ceval.h"         // _PyEval_SetProfile()
 #include "pycore_pystate.h"       // _PyThreadState_GET()
+#include "pycore_structseq.h"     // _PyStructSequence_NewType()
 #include "pycore_time.h"          // _PyTime_FromSecondsObject()
 #include "pycore_typeobject.h"    // _PyType_GetModuleState()
 #include "pycore_unicodeobject.h" // _PyUnicode_EqualToASCIIString()
@@ -1105,15 +1106,15 @@ _lsprof_exec(PyObject *module)
         return -1;
     }
 
-    state->stats_entry_type = PyStructSequence_NewType(&profiler_entry_desc);
+    state->stats_entry_type = _PyStructSequence_NewType(&profiler_entry_desc, 0, 1);
     if (state->stats_entry_type == NULL) {
         return -1;
     }
     if (PyModule_AddType(module, state->stats_entry_type) < 0) {
         return -1;
     }
 
-    state->stats_subentry_type = PyStructSequence_NewType(&profiler_subentry_desc);
+    state->stats_subentry_type = _PyStructSequence_NewType(&profiler_subentry_desc, 0, 1);
     if (state->stats_subentry_type == NULL) {
         return -1;
     }
diff --git a/Modules/_threadmodule.c b/Modules/_threadmodule.c
@@ -10,6 +10,7 @@
 #include "pycore_object_deferred.h" // _PyObject_SetDeferredRefcount()
 #include "pycore_pylifecycle.h"
 #include "pycore_pystate.h"       // _PyThreadState_SetCurrent()
+#include "pycore_structseq.h"     // _PyStructSequence_NewType()
 #include "pycore_time.h"          // _PyTime_FromSeconds()
 #include "pycore_tuple.h"         // _PyTuple_FromPairSteal
 #include "pycore_weakref.h"       // _PyWeakref_GET_REF()
@@ -2755,7 +2756,7 @@ thread_module_exec(PyObject *module)
     }
 
     // _ExceptHookArgs type
-    state->excepthook_type = PyStructSequence_NewType(&ExceptHookArgs_desc);
+    state->excepthook_type = _PyStructSequence_NewType(&ExceptHookArgs_desc, 0, 1);
     if (state->excepthook_type == NULL) {
         return -1;
     }
diff --git a/Modules/grpmodule.c b/Modules/grpmodule.c
@@ -6,6 +6,7 @@
 #endif
 
 #include "Python.h"
+#include "pycore_structseq.h"     // _PyStructSequence_NewType()
 #include "posixmodule.h"
 
 #include <errno.h>                // ERANGE
@@ -359,7 +360,7 @@ grpmodule_exec(PyObject *module)
 {
     grpmodulestate *state = get_grp_state(module);
 
-    state->StructGrpType = PyStructSequence_NewType(&struct_group_type_desc);
+    state->StructGrpType = _PyStructSequence_NewType(&struct_group_type_desc, 0, 1);
     if (state->StructGrpType == NULL) {
         return -1;
     }
diff --git a/Modules/posixmodule.c b/Modules/posixmodule.c
diff --git a/Modules/pwdmodule.c b/Modules/pwdmodule.c
diff --git a/Modules/resource.c b/Modules/resource.c
diff --git a/Modules/signalmodule.c b/Modules/signalmodule.c
diff --git a/Objects/structseq.c b/Objects/structseq.c
diff --git a/Python/pylifecycle.c b/Python/pylifecycle.c
diff --git a/Python/sysmodule.c b/Python/sysmodule.c
