From b10ad220c0da1da8198c6e4a5c2fbf3d1e5f84b4 Mon Sep 17 00:00:00 2001
From: Gobot1234 <gobot1234yt@gmail.com>
Date: Sat, 16 Sep 2023 12:09:21 +0100
Subject: [PATCH 1/4] Even more PyDoc_STR

Regex used ((PyGetSetDef|PyMemberDef|PyMethodDef|PyStructSequence_Field|PyStructSequence_Desc) .* = \{
[\s\S]*
.*?"(?<!\))\}|\{Py_tp_doc, ")
---
 Modules/_collectionsmodule.c                  |   2 +-
 Modules/_ctypes/_ctypes.c                     |  12 +--
 Modules/_ctypes/callproc.c                    |  14 +--
 Modules/_cursesmodule.c                       |   8 +-
 Modules/_datetimemodule.c                     |   2 +-
 Modules/_elementtree.c                        |   8 +-
 Modules/_functoolsmodule.c                    |   6 +-
 Modules/_hashopenssl.c                        |   2 +-
 Modules/_io/bytesio.c                         |   2 +-
 Modules/_io/fileio.c                          |   6 +-
 Modules/_io/winconsoleio.c                    |   6 +-
 Modules/_json.c                               |  26 ++---
 Modules/_lsprof.c                             |  24 ++---
 Modules/_multiprocessing/posixshmem.c         |   2 +-
 Modules/_multiprocessing/semaphore.c          |   8 +-
 Modules/_opcode.c                             |   2 +-
 Modules/_sre/sre.c                            |  20 ++--
 Modules/_testcapi/heaptype.c                  |   4 +-
 Modules/_testmultiphase.c                     |   4 +-
 Modules/_threadmodule.c                       |  12 +--
 Modules/_winapi.c                             |   4 +-
 Modules/_xxtestfuzz/_xxtestfuzz.c             |   2 +-
 Modules/_zoneinfo.c                           |   2 +-
 Modules/arraymodule.c                         |   4 +-
 Modules/cjkcodecs/cjkcodecs.h                 |   2 +-
 Modules/grpmodule.c                           |   8 +-
 Modules/overlapped.c                          |   8 +-
 Modules/posixmodule.c                         |  82 +++++++-------
 Modules/pwdmodule.c                           |  14 +--
 Modules/resource.c                            |  32 +++---
 Modules/selectmodule.c                        |   6 +-
 Modules/signalmodule.c                        |  14 +--
 Modules/socketmodule.c                        |   6 +-
 Modules/timemodule.c                          |  22 ++--
 Modules/xxlimited_35.c                        |   2 +-
 Objects/classobject.c                         |   6 +-
 Objects/complexobject.c                       |   4 +-
 Objects/fileobject.c                          |  16 +--
 Objects/floatobject.c                         |  36 +++----
 Objects/longobject.c                          |  16 +--
 Objects/typeobject.c                          |   6 +-
 Python/errors.c                               |  10 +-
 Python/sysmodule.c                            | 100 +++++++++---------
 Python/thread.c                               |   6 +-
 .../peg_extension/peg_extension.c             |   6 +-
 45 files changed, 292 insertions(+), 292 deletions(-)

diff --git a/Modules/_collectionsmodule.c b/Modules/_collectionsmodule.c
index c8cd53de5e22622..3a3ddd6dcc3ff85 100644
--- a/Modules/_collectionsmodule.c
+++ b/Modules/_collectionsmodule.c
@@ -1579,7 +1579,7 @@ deque_get_maxlen(dequeobject *deque, void *Py_UNUSED(ignored))
 
 static PyGetSetDef deque_getset[] = {
     {"maxlen", (getter)deque_get_maxlen, (setter)NULL,
-     "maximum size of a deque or None if unbounded"},
+     PyDoc_STR("maximum size of a deque or None if unbounded")},
     {0}
 };
 
diff --git a/Modules/_ctypes/_ctypes.c b/Modules/_ctypes/_ctypes.c
index 184af2132c27078..0abb1ac3276e1e9 100644
--- a/Modules/_ctypes/_ctypes.c
+++ b/Modules/_ctypes/_ctypes.c
@@ -1380,9 +1380,9 @@ CharArray_set_value(CDataObject *self, PyObject *value, void *Py_UNUSED(ignored)
 
 static PyGetSetDef CharArray_getsets[] = {
     { "raw", (getter)CharArray_get_raw, (setter)CharArray_set_raw,
-      "value", NULL },
+      PyDoc_STR("value"), NULL },
     { "value", (getter)CharArray_get_value, (setter)CharArray_set_value,
-      "string value"},
+      PyDoc_STR("string value")},
     { NULL, NULL }
 };
 
@@ -1432,7 +1432,7 @@ WCharArray_set_value(CDataObject *self, PyObject *value, void *Py_UNUSED(ignored
 
 static PyGetSetDef WCharArray_getsets[] = {
     { "value", (getter)WCharArray_get_value, (setter)WCharArray_set_value,
-      "string value"},
+      PyDoc_STR("string value")},
     { NULL, NULL }
 };
 
@@ -2762,13 +2762,13 @@ PyCData_dealloc(PyObject *self)
 static PyMemberDef PyCData_members[] = {
     { "_b_base_", _Py_T_OBJECT,
       offsetof(CDataObject, b_base), Py_READONLY,
-      "the base object" },
+      PyDoc_STR("the base object") },
     { "_b_needsfree_", Py_T_INT,
       offsetof(CDataObject, b_needsfree), Py_READONLY,
-      "whether the object owns the memory or not" },
+      PyDoc_STR("whether the object owns the memory or not") },
     { "_objects", _Py_T_OBJECT,
       offsetof(CDataObject, b_objects), Py_READONLY,
-      "internal objects tree (NEVER CHANGE THIS OBJECT!)"},
+      PyDoc_STR("internal objects tree (NEVER CHANGE THIS OBJECT!)") },
     { NULL },
 };
 
diff --git a/Modules/_ctypes/callproc.c b/Modules/_ctypes/callproc.c
index fc08c42bd3574ab..08e7db7e039674c 100644
--- a/Modules/_ctypes/callproc.c
+++ b/Modules/_ctypes/callproc.c
@@ -591,7 +591,7 @@ PyCArg_repr(PyCArgObject *self)
 static PyMemberDef PyCArgType_members[] = {
     { "_obj", _Py_T_OBJECT,
       offsetof(PyCArgObject, obj), Py_READONLY,
-      "the wrapped object" },
+      PyDoc_STR("the wrapped object") },
     { NULL },
 };
 
@@ -2036,8 +2036,8 @@ PyMethodDef _ctypes_module_methods[] = {
     CREATE_POINTER_TYPE_METHODDEF
     CREATE_POINTER_INST_METHODDEF
     {"_unpickle", unpickle, METH_VARARGS },
-    {"buffer_info", buffer_info, METH_O, "Return buffer interface information"},
-    {"resize", resize, METH_VARARGS, "Resize the memory buffer of a ctypes instance"},
+    {"buffer_info", buffer_info, METH_O, PyDoc_STR("Return buffer interface information")},
+    {"resize", resize, METH_VARARGS, PyDoc_STR("Resize the memory buffer of a ctypes instance")},
 #ifdef MS_WIN32
     {"get_last_error", get_last_error, METH_NOARGS},
     {"set_last_error", set_last_error, METH_VARARGS},
@@ -2048,12 +2048,12 @@ PyMethodDef _ctypes_module_methods[] = {
     {"_check_HRESULT", check_hresult, METH_VARARGS},
 #else
     {"dlopen", py_dl_open, METH_VARARGS,
-     "dlopen(name, flag={RTLD_GLOBAL|RTLD_LOCAL}) open a shared library"},
-    {"dlclose", py_dl_close, METH_VARARGS, "dlclose a library"},
-    {"dlsym", py_dl_sym, METH_VARARGS, "find symbol in shared library"},
+     PyDoc_STR("dlopen(name, flag={RTLD_GLOBAL|RTLD_LOCAL}) open a shared library")},
+    {"dlclose", py_dl_close, METH_VARARGS, PyDoc_STR("dlclose a library")},
+    {"dlsym", py_dl_sym, METH_VARARGS, PyDoc_STR("find symbol in shared library")},
 #endif
 #ifdef __APPLE__
-     {"_dyld_shared_cache_contains_path", py_dyld_shared_cache_contains_path, METH_VARARGS, "check if path is in the shared cache"},
+     {"_dyld_shared_cache_contains_path", py_dyld_shared_cache_contains_path, METH_VARARGS, PyDoc_STR("check if path is in the shared cache")},
 #endif
     {"alignment", align_func, METH_O, alignment_doc},
     {"sizeof", sizeof_func, METH_O, sizeof_doc},
diff --git a/Modules/_cursesmodule.c b/Modules/_cursesmodule.c
index d339a8aa798361f..48a1013cf475774 100644
--- a/Modules/_cursesmodule.c
+++ b/Modules/_cursesmodule.c
@@ -2563,7 +2563,7 @@ static PyGetSetDef PyCursesWindow_getsets[] = {
     {"encoding",
      (getter)PyCursesWindow_get_encoding,
      (setter)PyCursesWindow_set_encoding,
-     "the typecode character used to create the array"},
+     PyDoc_STR("the typecode character used to create the array")},
     {NULL, NULL, NULL, NULL }  /* sentinel */
 };
 
@@ -4563,9 +4563,9 @@ PyDoc_STRVAR(ncurses_version__doc__,
 Ncurses version information as a named tuple.");
 
 static PyStructSequence_Field ncurses_version_fields[] = {
-    {"major", "Major release number"},
-    {"minor", "Minor release number"},
-    {"patch", "Patch release number"},
+    {"major", PyDoc_STR("Major release number")},
+    {"minor", PyDoc_STR("Minor release number")},
+    {"patch", PyDoc_STR("Patch release number")},
     {0}
 };
 
diff --git a/Modules/_datetimemodule.c b/Modules/_datetimemodule.c
index 0d356779cfe1920..43d207ce78722ee 100644
--- a/Modules/_datetimemodule.c
+++ b/Modules/_datetimemodule.c
@@ -6915,7 +6915,7 @@ _datetime_exec(PyObject *module)
 static struct PyModuleDef datetimemodule = {
     PyModuleDef_HEAD_INIT,
     .m_name = "_datetime",
-    .m_doc = "Fast implementation of the datetime type.",
+    .m_doc = PyDoc_STR("Fast implementation of the datetime type."),
     .m_size = -1,
     .m_methods = module_methods,
 };
diff --git a/Modules/_elementtree.c b/Modules/_elementtree.c
index 8cb57e693d81d7d..b2c9c60071d4192 100644
--- a/Modules/_elementtree.c
+++ b/Modules/_elementtree.c
@@ -4200,19 +4200,19 @@ static PyGetSetDef element_getsetlist[] = {
     {"tag",
         (getter)element_tag_getter,
         (setter)element_tag_setter,
-        "A string identifying what kind of data this element represents"},
+        PyDoct_STR("A string identifying what kind of data this element represents")},
     {"text",
         (getter)element_text_getter,
         (setter)element_text_setter,
-        "A string of text directly after the start tag, or None"},
+        PyDoct_STR("A string of text directly after the start tag, or None")},
     {"tail",
         (getter)element_tail_getter,
         (setter)element_tail_setter,
-        "A string of text directly after the end tag, or None"},
+        PyDoct_STR("A string of text directly after the end tag, or None")},
     {"attrib",
         (getter)element_attrib_getter,
         (setter)element_attrib_setter,
-        "A dictionary containing the element's attributes"},
+        PyDoct_STR("A dictionary containing the element's attributes")},
     {NULL},
 };
 
diff --git a/Modules/_functoolsmodule.c b/Modules/_functoolsmodule.c
index 389ff4391de0be6..38e284fb9564e84 100644
--- a/Modules/_functoolsmodule.c
+++ b/Modules/_functoolsmodule.c
@@ -341,11 +341,11 @@ PyDoc_STRVAR(partial_doc,
 #define OFF(x) offsetof(partialobject, x)
 static PyMemberDef partial_memberlist[] = {
     {"func",            _Py_T_OBJECT,       OFF(fn),        Py_READONLY,
-     "function object to use in future partial calls"},
+     PyDoc_STR("function object to use in future partial calls")},
     {"args",            _Py_T_OBJECT,       OFF(args),      Py_READONLY,
-     "tuple of arguments to future partial calls"},
+     PyDoc_STR("tuple of arguments to future partial calls")},
     {"keywords",        _Py_T_OBJECT,       OFF(kw),        Py_READONLY,
-     "dictionary of keyword arguments to future partial calls"},
+     PyDoc_STR("dictionary of keyword arguments to future partial calls")},
     {"__weaklistoffset__", Py_T_PYSSIZET,
      offsetof(partialobject, weakreflist), Py_READONLY},
     {"__dictoffset__", Py_T_PYSSIZET,
diff --git a/Modules/_hashopenssl.c b/Modules/_hashopenssl.c
index ee6fb8b4b036435..339c3638d863a61 100644
--- a/Modules/_hashopenssl.c
+++ b/Modules/_hashopenssl.c
@@ -2255,7 +2255,7 @@ static PyModuleDef_Slot hashlib_slots[] = {
 static struct PyModuleDef _hashlibmodule = {
     PyModuleDef_HEAD_INIT,
     .m_name = "_hashlib",
-    .m_doc = "OpenSSL interface for hashlib module",
+    .m_doc = PyDoc_STR("OpenSSL interface for hashlib module"),
     .m_size = sizeof(_hashlibstate),
     .m_methods = EVP_functions,
     .m_slots = hashlib_slots,
diff --git a/Modules/_io/bytesio.c b/Modules/_io/bytesio.c
index f3074203f54ea2a..90b89a8b860d59f 100644
--- a/Modules/_io/bytesio.c
+++ b/Modules/_io/bytesio.c
@@ -1000,7 +1000,7 @@ bytesio_clear(bytesio *self)
 
 static PyGetSetDef bytesio_getsetlist[] = {
     {"closed",  (getter)bytesio_get_closed, NULL,
-     "True if the file is closed."},
+     PyDoc_STR("True if the file is closed.")},
     {NULL},            /* sentinel */
 };
 
diff --git a/Modules/_io/fileio.c b/Modules/_io/fileio.c
index fb416700e225231..5fca08ccc6a2e59 100644
--- a/Modules/_io/fileio.c
+++ b/Modules/_io/fileio.c
@@ -1192,10 +1192,10 @@ get_mode(fileio *self, void *closure)
 }
 
 static PyGetSetDef fileio_getsetlist[] = {
-    {"closed", (getter)get_closed, NULL, "True if the file is closed"},
+    {"closed", (getter)get_closed, NULL, PyDoc_STR("True if the file is closed")},
     {"closefd", (getter)get_closefd, NULL,
-        "True if the file descriptor will be closed by close()."},
-    {"mode", (getter)get_mode, NULL, "String giving the file mode"},
+        PyDoc_STR("True if the file descriptor will be closed by close().")},
+    {"mode", (getter)get_mode, NULL, PyDoc_STR("String giving the file mode")},
     {NULL},
 };
 
diff --git a/Modules/_io/winconsoleio.c b/Modules/_io/winconsoleio.c
index 50b8818aad410b0..5eae71af790ea75 100644
--- a/Modules/_io/winconsoleio.c
+++ b/Modules/_io/winconsoleio.c
@@ -1134,10 +1134,10 @@ get_mode(winconsoleio *self, void *closure)
 }
 
 static PyGetSetDef winconsoleio_getsetlist[] = {
-    {"closed", (getter)get_closed, NULL, "True if the file is closed"},
+    {"closed", (getter)get_closed, NULL, PyDoc_STR("True if the file is closed")},
     {"closefd", (getter)get_closefd, NULL,
-        "True if the file descriptor will be closed by close()."},
-    {"mode", (getter)get_mode, NULL, "String giving the file mode"},
+        PyDoc_STR("True if the file descriptor will be closed by close().")},
+    {"mode", (getter)get_mode, NULL, PyDoc_STR("String giving the file mode")},
     {NULL},
 };
 
diff --git a/Modules/_json.c b/Modules/_json.c
index 41495e2012f1522..be8c170cfc896f1 100644
--- a/Modules/_json.c
+++ b/Modules/_json.c
@@ -28,12 +28,12 @@ typedef struct _PyScannerObject {
 } PyScannerObject;
 
 static PyMemberDef scanner_members[] = {
-    {"strict", Py_T_BOOL, offsetof(PyScannerObject, strict), Py_READONLY, "strict"},
-    {"object_hook", _Py_T_OBJECT, offsetof(PyScannerObject, object_hook), Py_READONLY, "object_hook"},
+    {"strict", Py_T_BOOL, offsetof(PyScannerObject, strict), Py_READONLY, PyDoc_STR("strict")},
+    {"object_hook", _Py_T_OBJECT, offsetof(PyScannerObject, object_hook), Py_READONLY, PyDoc_STR("object_hook")},
     {"object_pairs_hook", _Py_T_OBJECT, offsetof(PyScannerObject, object_pairs_hook), Py_READONLY},
-    {"parse_float", _Py_T_OBJECT, offsetof(PyScannerObject, parse_float), Py_READONLY, "parse_float"},
-    {"parse_int", _Py_T_OBJECT, offsetof(PyScannerObject, parse_int), Py_READONLY, "parse_int"},
-    {"parse_constant", _Py_T_OBJECT, offsetof(PyScannerObject, parse_constant), Py_READONLY, "parse_constant"},
+    {"parse_float", _Py_T_OBJECT, offsetof(PyScannerObject, parse_float), Py_READONLY, PyDoc_STR("parse_float")},
+    {"parse_int", _Py_T_OBJECT, offsetof(PyScannerObject, parse_int), Py_READONLY, PyDoc_STR("parse_int")},
+    {"parse_constant", _Py_T_OBJECT, offsetof(PyScannerObject, parse_constant), Py_READONLY, PyDoc_STR("parse_constant")},
     {NULL}
 };
 
@@ -52,14 +52,14 @@ typedef struct _PyEncoderObject {
 } PyEncoderObject;
 
 static PyMemberDef encoder_members[] = {
-    {"markers", _Py_T_OBJECT, offsetof(PyEncoderObject, markers), Py_READONLY, "markers"},
-    {"default", _Py_T_OBJECT, offsetof(PyEncoderObject, defaultfn), Py_READONLY, "default"},
-    {"encoder", _Py_T_OBJECT, offsetof(PyEncoderObject, encoder), Py_READONLY, "encoder"},
-    {"indent", _Py_T_OBJECT, offsetof(PyEncoderObject, indent), Py_READONLY, "indent"},
-    {"key_separator", _Py_T_OBJECT, offsetof(PyEncoderObject, key_separator), Py_READONLY, "key_separator"},
-    {"item_separator", _Py_T_OBJECT, offsetof(PyEncoderObject, item_separator), Py_READONLY, "item_separator"},
-    {"sort_keys", Py_T_BOOL, offsetof(PyEncoderObject, sort_keys), Py_READONLY, "sort_keys"},
-    {"skipkeys", Py_T_BOOL, offsetof(PyEncoderObject, skipkeys), Py_READONLY, "skipkeys"},
+    {"markers", _Py_T_OBJECT, offsetof(PyEncoderObject, markers), Py_READONLY, PyDoc_STR("markers")},
+    {"default", _Py_T_OBJECT, offsetof(PyEncoderObject, defaultfn), Py_READONLY, PyDoc_STR("default")},
+    {"encoder", _Py_T_OBJECT, offsetof(PyEncoderObject, encoder), Py_READONLY, PyDoc_STR("encoder")},
+    {"indent", _Py_T_OBJECT, offsetof(PyEncoderObject, indent), Py_READONLY, PyDoc_STR("indent")},
+    {"key_separator", _Py_T_OBJECT, offsetof(PyEncoderObject, key_separator), Py_READONLY, PyDoc_STR("key_separator")},
+    {"item_separator", _Py_T_OBJECT, offsetof(PyEncoderObject, item_separator), Py_READONLY, PyDoc_STR("item_separator")},
+    {"sort_keys", Py_T_BOOL, offsetof(PyEncoderObject, sort_keys), Py_READONLY, PyDoc_STR("sort_keys")},
+    {"skipkeys", Py_T_BOOL, offsetof(PyEncoderObject, skipkeys), Py_READONLY, PyDoc_STR("skipkeys")},
     {NULL}
 };
 
diff --git a/Modules/_lsprof.c b/Modules/_lsprof.c
index d23a756ace887d1..23e7029fbb1740d 100644
--- a/Modules/_lsprof.c
+++ b/Modules/_lsprof.c
@@ -419,21 +419,21 @@ pending_exception(ProfilerObject *pObj)
 /************************************************************/
 
 static PyStructSequence_Field profiler_entry_fields[] = {
-    {"code",         "code object or built-in function name"},
-    {"callcount",    "how many times this was called"},
-    {"reccallcount", "how many times called recursively"},
-    {"totaltime",    "total time in this entry"},
-    {"inlinetime",   "inline time in this entry (not in subcalls)"},
-    {"calls",        "details of the calls"},
+    {"code",         PyDoc_STR("code object or built-in function name")},
+    {"callcount",    PyDoc_STR("how many times this was called")},
+    {"reccallcount", PyDoc_STR("how many times called recursively")},
+    {"totaltime",    PyDoc_STR("total time in this entry")},
+    {"inlinetime",   PyDoc_STR("inline time in this entry (not in subcalls)")},
+    {"calls",        PyDoc_STR("details of the calls")},
     {0}
 };
 
 static PyStructSequence_Field profiler_subentry_fields[] = {
-    {"code",         "called code object or built-in function name"},
-    {"callcount",    "how many times this is called"},
-    {"reccallcount", "how many times this is called recursively"},
-    {"totaltime",    "total time spent in this call"},
-    {"inlinetime",   "inline time (not in further subcalls)"},
+    {"code",         PyDoc_STR("called code object or built-in function name")},
+    {"callcount",    PyDoc_STR("how many times this is called")},
+    {"reccallcount", PyDoc_STR("how many times this is called recursively")},
+    {"totaltime",    PyDoc_STR("total time spent in this call")},
+    {"inlinetime",   PyDoc_STR("inline time (not in further subcalls)")},
     {0}
 };
 
@@ -1014,7 +1014,7 @@ static PyModuleDef_Slot _lsprofslots[] = {
 static struct PyModuleDef _lsprofmodule = {
     PyModuleDef_HEAD_INIT,
     .m_name = "_lsprof",
-    .m_doc = "Fast profiler",
+    .m_doc = PyDoc_STR("Fast profiler"),
     .m_size = sizeof(_lsprof_state),
     .m_methods = moduleMethods,
     .m_slots = _lsprofslots,
diff --git a/Modules/_multiprocessing/posixshmem.c b/Modules/_multiprocessing/posixshmem.c
index debef3267f77d1f..aa70a26d1fde97d 100644
--- a/Modules/_multiprocessing/posixshmem.c
+++ b/Modules/_multiprocessing/posixshmem.c
@@ -117,7 +117,7 @@ static PyModuleDef_Slot module_slots[] = {
 static struct PyModuleDef _posixshmemmodule = {
     PyModuleDef_HEAD_INIT,
     .m_name = "_posixshmem",
-    .m_doc = "POSIX shared memory module",
+    .m_doc = PyDoc_STR("POSIX shared memory module"),
     .m_size = 0,
     .m_methods = module_methods,
     .m_slots = module_slots,
diff --git a/Modules/_multiprocessing/semaphore.c b/Modules/_multiprocessing/semaphore.c
index f8f2afda28d06db..3b81acd031752f7 100644
--- a/Modules/_multiprocessing/semaphore.c
+++ b/Modules/_multiprocessing/semaphore.c
@@ -740,13 +740,13 @@ static PyMethodDef semlock_methods[] = {
 
 static PyMemberDef semlock_members[] = {
     {"handle", T_SEM_HANDLE, offsetof(SemLockObject, handle), Py_READONLY,
-     ""},
+     PyDoc_STR("")},
     {"kind", Py_T_INT, offsetof(SemLockObject, kind), Py_READONLY,
-     ""},
+     PyDoc_STR("")},
     {"maxvalue", Py_T_INT, offsetof(SemLockObject, maxvalue), Py_READONLY,
-     ""},
+     PyDoc_STR("")},
     {"name", Py_T_STRING, offsetof(SemLockObject, name), Py_READONLY,
-     ""},
+     PyDoc_STR("")},
     {NULL}
 };
 
diff --git a/Modules/_opcode.c b/Modules/_opcode.c
index dac9c019b249e9a..c7851ff0830f018 100644
--- a/Modules/_opcode.c
+++ b/Modules/_opcode.c
@@ -383,7 +383,7 @@ static PyModuleDef_Slot module_slots[] = {
 static struct PyModuleDef opcodemodule = {
     PyModuleDef_HEAD_INIT,
     .m_name = "_opcode",
-    .m_doc = "Opcode support module.",
+    .m_doc = PyDoc_STR("Opcode support module."),
     .m_size = 0,
     .m_methods = opcode_functions,
     .m_slots = module_slots,
diff --git a/Modules/_sre/sre.c b/Modules/_sre/sre.c
index 07da5da13f70d39..d25f29b9d2c0248 100644
--- a/Modules/_sre/sre.c
+++ b/Modules/_sre/sre.c
@@ -3017,18 +3017,18 @@ static PyMethodDef pattern_methods[] = {
 
 static PyGetSetDef pattern_getset[] = {
     {"groupindex", (getter)pattern_groupindex, (setter)NULL,
-      "A dictionary mapping group names to group numbers."},
+      PyDoc_STR("A dictionary mapping group names to group numbers.")},
     {NULL}  /* Sentinel */
 };
 
 #define PAT_OFF(x) offsetof(PatternObject, x)
 static PyMemberDef pattern_members[] = {
     {"pattern",    _Py_T_OBJECT,    PAT_OFF(pattern),       Py_READONLY,
-     "The pattern string from which the RE object was compiled."},
+     PyDoc_STR("The pattern string from which the RE object was compiled.")},
     {"flags",      Py_T_INT,       PAT_OFF(flags),         Py_READONLY,
-     "The regex matching flags."},
+     PyDoc_STR("The regex matching flags.")},
     {"groups",     Py_T_PYSSIZET,  PAT_OFF(groups),        Py_READONLY,
-     "The number of capturing groups in the pattern."},
+     PyDoc_STR("The number of capturing groups in the pattern.")},
     {"__weaklistoffset__", Py_T_PYSSIZET, offsetof(PatternObject, weakreflist), Py_READONLY},
     {NULL}  /* Sentinel */
 };
@@ -3073,9 +3073,9 @@ static PyMethodDef match_methods[] = {
 
 static PyGetSetDef match_getset[] = {
     {"lastindex", (getter)match_lastindex_get, (setter)NULL,
-     "The integer index of the last matched capturing group."},
+     PyDoc_STR("The integer index of the last matched capturing group.")},
     {"lastgroup", (getter)match_lastgroup_get, (setter)NULL,
-     "The name of the last matched capturing group."},
+     PyDoc_STR("The name of the last matched capturing group.")},
     {"regs",      (getter)match_regs_get,      (setter)NULL},
     {NULL}
 };
@@ -3083,13 +3083,13 @@ static PyGetSetDef match_getset[] = {
 #define MATCH_OFF(x) offsetof(MatchObject, x)
 static PyMemberDef match_members[] = {
     {"string",  _Py_T_OBJECT,   MATCH_OFF(string),  Py_READONLY,
-     "The string passed to match() or search()."},
+     PyDoc_STR("The string passed to match() or search().")},
     {"re",      _Py_T_OBJECT,   MATCH_OFF(pattern), Py_READONLY,
-     "The regular expression object."},
+     PyDoc_STR("The regular expression object.")},
     {"pos",     Py_T_PYSSIZET, MATCH_OFF(pos),     Py_READONLY,
-     "The index into the string at which the RE engine started looking for a match."},
+     PyDoc_STR("The index into the string at which the RE engine started looking for a match.")},
     {"endpos",  Py_T_PYSSIZET, MATCH_OFF(endpos),  Py_READONLY,
-     "The index into the string beyond which the RE engine will not go."},
+     PyDoc_STR("The index into the string beyond which the RE engine will not go.")},
     {NULL}
 };
 
diff --git a/Modules/_testcapi/heaptype.c b/Modules/_testcapi/heaptype.c
index d14a1763184207a..6e0903a91118162 100644
--- a/Modules/_testcapi/heaptype.c
+++ b/Modules/_testcapi/heaptype.c
@@ -315,8 +315,8 @@ test_type_from_ephemeral_spec(PyObject *self, PyObject *Py_UNUSED(ignored))
 }
 
 PyType_Slot repeated_doc_slots[] = {
-    {Py_tp_doc, "A class used for tests·"},
-    {Py_tp_doc, "A class used for tests"},
+    {Py_tp_doc, PyDoc_STR("A class used for tests·")},
+    {Py_tp_doc, PyDoc_STR("A class used for tests")},
     {0, 0},
 };
 
diff --git a/Modules/_testmultiphase.c b/Modules/_testmultiphase.c
index fdef06168bfc86b..1677e4510c7cdf0 100644
--- a/Modules/_testmultiphase.c
+++ b/Modules/_testmultiphase.c
@@ -105,7 +105,7 @@ Example_setattr(ExampleObject *self, const char *name, PyObject *v)
 }
 
 static PyType_Slot Example_Type_slots[] = {
-    {Py_tp_doc, "The Example type"},
+    {Py_tp_doc, PyDoc_STR("The Example type")},
     {Py_tp_finalize, Example_finalize},
     {Py_tp_traverse, Example_traverse},
     {Py_tp_getattro, Example_getattro},
@@ -279,7 +279,7 @@ static PyMethodDef StateAccessType_methods[] = {
 };
 
 static PyType_Slot StateAccessType_Type_slots[] = {
-    {Py_tp_doc, "Type for testing per-module state access from methods."},
+    {Py_tp_doc, PyDoc_STR("Type for testing per-module state access from methods.")},
     {Py_tp_methods, StateAccessType_methods},
     {0, NULL}
 };
diff --git a/Modules/_threadmodule.c b/Modules/_threadmodule.c
index 7692bacccc4909c..117a6f67b815845 100644
--- a/Modules/_threadmodule.c
+++ b/Modules/_threadmodule.c
@@ -688,7 +688,7 @@ static PyMemberDef local_dummy_type_members[] = {
 
 static PyType_Slot local_dummy_type_slots[] = {
     {Py_tp_dealloc, (destructor)localdummy_dealloc},
-    {Py_tp_doc, "Thread-local dummy"},
+    {Py_tp_doc, PyDoc_STR("Thread-local dummy")},
     {Py_tp_members, local_dummy_type_members},
     {0, 0}
 };
@@ -970,7 +970,7 @@ static PyType_Slot local_type_slots[] = {
     {Py_tp_dealloc, (destructor)local_dealloc},
     {Py_tp_getattro, (getattrofunc)local_getattro},
     {Py_tp_setattro, (setattrofunc)local_setattro},
-    {Py_tp_doc, "Thread-local data"},
+    {Py_tp_doc, PyDoc_STR("Thread-local data")},
     {Py_tp_traverse, (traverseproc)local_traverse},
     {Py_tp_clear, (inquiry)local_clear},
     {Py_tp_new, local_new},
@@ -1513,10 +1513,10 @@ PyDoc_STRVAR(ExceptHookArgs__doc__,
 Type used to pass arguments to threading.excepthook.");
 
 static PyStructSequence_Field ExceptHookArgs_fields[] = {
-    {"exc_type", "Exception type"},
-    {"exc_value", "Exception value"},
-    {"exc_traceback", "Exception traceback"},
-    {"thread", "Thread"},
+    {"exc_type", PyDoc_STR("Exception type")},
+    {"exc_value", PyDoc_STR("Exception value")},
+    {"exc_traceback", PyDoc_STR("Exception traceback")},
+    {"thread", PyDoc_STR("Thread")},
     {0}
 };
 
diff --git a/Modules/_winapi.c b/Modules/_winapi.c
index eec33499b983fe7..2adcf173edeaac6 100644
--- a/Modules/_winapi.c
+++ b/Modules/_winapi.c
@@ -322,14 +322,14 @@ static PyMethodDef overlapped_methods[] = {
 static PyMemberDef overlapped_members[] = {
     {"event", T_HANDLE,
      offsetof(OverlappedObject, overlapped) + offsetof(OVERLAPPED, hEvent),
-     Py_READONLY, "overlapped event handle"},
+     Py_READONLY, PyDoc_STR("overlapped event handle")},
     {NULL}
 };
 
 static PyType_Slot winapi_overlapped_type_slots[] = {
     {Py_tp_traverse, overlapped_traverse},
     {Py_tp_dealloc, overlapped_dealloc},
-    {Py_tp_doc, "OVERLAPPED structure wrapper"},
+    {Py_tp_doc, PyDoc_STR("OVERLAPPED structure wrapper")},
     {Py_tp_methods, overlapped_methods},
     {Py_tp_members, overlapped_members},
     {0,0}
diff --git a/Modules/_xxtestfuzz/_xxtestfuzz.c b/Modules/_xxtestfuzz/_xxtestfuzz.c
index a2dbabce71ed67c..15298a1952bfcb1 100644
--- a/Modules/_xxtestfuzz/_xxtestfuzz.c
+++ b/Modules/_xxtestfuzz/_xxtestfuzz.c
@@ -24,7 +24,7 @@ static PyObject* _fuzz_run(PyObject* self, PyObject* args) {
 }
 
 static PyMethodDef module_methods[] = {
-    {"run", (PyCFunction)_fuzz_run, METH_VARARGS, ""},
+    {"run", (PyCFunction)_fuzz_run, METH_VARARGS, PyDoc_STR("")},
     {NULL},
 };
 
diff --git a/Modules/_zoneinfo.c b/Modules/_zoneinfo.c
index eb4e522465181fe..d2f9a3bf7ee7142 100644
--- a/Modules/_zoneinfo.c
+++ b/Modules/_zoneinfo.c
@@ -2842,7 +2842,7 @@ static PyModuleDef_Slot zoneinfomodule_slots[] = {
 static struct PyModuleDef zoneinfomodule = {
     .m_base = PyModuleDef_HEAD_INIT,
     .m_name = "_zoneinfo",
-    .m_doc = "C implementation of the zoneinfo module",
+    .m_doc = PyDoc_STR("C implementation of the zoneinfo module"),
     .m_size = sizeof(zoneinfo_state),
     .m_methods = module_methods,
     .m_slots = zoneinfomodule_slots,
diff --git a/Modules/arraymodule.c b/Modules/arraymodule.c
index 309a36919f34650..52612c144cf5d69 100644
--- a/Modules/arraymodule.c
+++ b/Modules/arraymodule.c
@@ -2332,9 +2332,9 @@ array_get_itemsize(arrayobject *a, void *closure)
 
 static PyGetSetDef array_getsets [] = {
     {"typecode", (getter) array_get_typecode, NULL,
-     "the typecode character used to create the array"},
+     PyDoc_STR("the typecode character used to create the array")},
     {"itemsize", (getter) array_get_itemsize, NULL,
-     "the size, in bytes, of one array item"},
+     PyDoc_STR("the size, in bytes, of one array item")},
     {NULL}
 };
 
diff --git a/Modules/cjkcodecs/cjkcodecs.h b/Modules/cjkcodecs/cjkcodecs.h
index 766f82983025e46..e8088a90e45b488 100644
--- a/Modules/cjkcodecs/cjkcodecs.h
+++ b/Modules/cjkcodecs/cjkcodecs.h
@@ -496,7 +496,7 @@ _cjk_free(void *mod)
 }
 
 static struct PyMethodDef _cjk_methods[] = {
-    {"getcodec", (PyCFunction)getcodec, METH_O, ""},
+    {"getcodec", (PyCFunction)getcodec, METH_O, PyDoc_STR("")},
     {NULL, NULL},
 };
 
diff --git a/Modules/grpmodule.c b/Modules/grpmodule.c
index 20e83de84e8340f..3c76f813c90562e 100644
--- a/Modules/grpmodule.c
+++ b/Modules/grpmodule.c
@@ -14,10 +14,10 @@ module grp
 /*[clinic end generated code: output=da39a3ee5e6b4b0d input=cade63f2ed1bd9f8]*/
 
 static PyStructSequence_Field struct_group_type_fields[] = {
-   {"gr_name", "group name"},
-   {"gr_passwd", "password"},
-   {"gr_gid", "group id"},
-   {"gr_mem", "group members"},
+   {"gr_name", PyDoc_STR("group name")},
+   {"gr_passwd", PyDoc_STR("password")},
+   {"gr_gid", PyDoc_STR("group id")},
+   {"gr_mem", PyDoc_STR("group members")},
    {0}
 };
 
diff --git a/Modules/overlapped.c b/Modules/overlapped.c
index e23db22dadb18bb..4efd53dfa3d2974 100644
--- a/Modules/overlapped.c
+++ b/Modules/overlapped.c
@@ -1950,18 +1950,18 @@ static PyMethodDef Overlapped_methods[] = {
 static PyMemberDef Overlapped_members[] = {
     {"error", Py_T_ULONG,
      offsetof(OverlappedObject, error),
-     Py_READONLY, "Error from last operation"},
+     Py_READONLY, PyDoc_STR("Error from last operation")},
     {"event", T_HANDLE,
      offsetof(OverlappedObject, overlapped) + offsetof(OVERLAPPED, hEvent),
-     Py_READONLY, "Overlapped event handle"},
+     Py_READONLY, PyDoc_STR("Overlapped event handle")},
     {NULL}
 };
 
 static PyGetSetDef Overlapped_getsets[] = {
     {"address", (getter)Overlapped_getaddress, NULL,
-     "Address of overlapped structure"},
+     PyDoc_STR("Address of overlapped structure")},
     {"pending", (getter)Overlapped_getpending, NULL,
-     "Whether the operation is pending"},
+     PyDoc_STR("Whether the operation is pending")},
     {NULL},
 };
 
diff --git a/Modules/posixmodule.c b/Modules/posixmodule.c
index c4340397fbe577c..f478e11aef53d99 100644
--- a/Modules/posixmodule.c
+++ b/Modules/posixmodule.c
@@ -2133,52 +2133,52 @@ or st_flags, they are available as attributes only.\n\
 See os.stat for more information.");
 
 static PyStructSequence_Field stat_result_fields[] = {
-    {"st_mode",    "protection bits"},
-    {"st_ino",     "inode"},
-    {"st_dev",     "device"},
-    {"st_nlink",   "number of hard links"},
-    {"st_uid",     "user ID of owner"},
-    {"st_gid",     "group ID of owner"},
-    {"st_size",    "total size, in bytes"},
+    {"st_mode",    PyDoc_STR("protection bits")},
+    {"st_ino",     PyDoc_STR("inode")},
+    {"st_dev",     PyDoc_STR("device")},
+    {"st_nlink",   PyDoc_STR("number of hard links")},
+    {"st_uid",     PyDoc_STR("user ID of owner")},
+    {"st_gid",     PyDoc_STR("group ID of owner")},
+    {"st_size",    PyDoc_STR("total size, in bytes")},
     /* The NULL is replaced with PyStructSequence_UnnamedField later. */
-    {NULL,   "integer time of last access"},
-    {NULL,   "integer time of last modification"},
-    {NULL,   "integer time of last change"},
-    {"st_atime",   "time of last access"},
-    {"st_mtime",   "time of last modification"},
-    {"st_ctime",   "time of last change"},
-    {"st_atime_ns",   "time of last access in nanoseconds"},
-    {"st_mtime_ns",   "time of last modification in nanoseconds"},
-    {"st_ctime_ns",   "time of last change in nanoseconds"},
+    {NULL,   PyDoc_STR("integer time of last access")},
+    {NULL,   PyDoc_STR("integer time of last modification")},
+    {NULL,   PyDoc_STR("integer time of last change")},
+    {"st_atime",   PyDoc_STR("time of last access")},
+    {"st_mtime",   PyDoc_STR("time of last modification")},
+    {"st_ctime",   PyDoc_STR("time of last change")},
+    {"st_atime_ns",   PyDoc_STR("time of last access in nanoseconds")},
+    {"st_mtime_ns",   PyDoc_STR("time of last modification in nanoseconds")},
+    {"st_ctime_ns",   PyDoc_STR("time of last change in nanoseconds")},
 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
-    {"st_blksize", "blocksize for filesystem I/O"},
+    {"st_blksize", PyDoc_STR("blocksize for filesystem I/O")},
 #endif
 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
-    {"st_blocks",  "number of blocks allocated"},
+    {"st_blocks",  PyDoc_STR("number of blocks allocated")},
 #endif
 #ifdef HAVE_STRUCT_STAT_ST_RDEV
-    {"st_rdev",    "device type (if inode device)"},
+    {"st_rdev",    PyDoc_STR("device type (if inode device)")},
 #endif
 #ifdef HAVE_STRUCT_STAT_ST_FLAGS
-    {"st_flags",   "user defined flags for file"},
+    {"st_flags",   PyDoc_STR("user defined flags for file")},
 #endif
 #ifdef HAVE_STRUCT_STAT_ST_GEN
-    {"st_gen",    "generation number"},
+    {"st_gen",    PyDoc_STR("generation number")},
 #endif
 #if defined(HAVE_STRUCT_STAT_ST_BIRTHTIME) || defined(MS_WINDOWS)
-    {"st_birthtime",   "time of creation"},
+    {"st_birthtime",   PyDoc_STR("time of creation")},
 #endif
 #ifdef MS_WINDOWS
-    {"st_birthtime_ns", "time of creation in nanoseconds"},
+    {"st_birthtime_ns", PyDoc_STR("time of creation in nanoseconds")},
 #endif
 #ifdef HAVE_STRUCT_STAT_ST_FILE_ATTRIBUTES
-    {"st_file_attributes", "Windows file attribute bits"},
+    {"st_file_attributes", PyDoc_STR("Windows file attribute bits")},
 #endif
 #ifdef HAVE_STRUCT_STAT_ST_FSTYPE
-    {"st_fstype",  "Type of filesystem"},
+    {"st_fstype",  PyDoc_STR("Type of filesystem")},
 #endif
 #ifdef HAVE_STRUCT_STAT_ST_REPARSE_TAG
-    {"st_reparse_tag", "Windows reparse tag"},
+    {"st_reparse_tag", PyDoc_STR("Windows reparse tag")},
 #endif
     {0}
 };
@@ -5857,11 +5857,11 @@ os_remove_impl(PyObject *module, path_t *path, int dir_fd)
 
 
 static PyStructSequence_Field uname_result_fields[] = {
-    {"sysname",    "operating system name"},
-    {"nodename",   "name of machine on network (implementation-defined)"},
-    {"release",    "operating system release"},
-    {"version",    "operating system version"},
-    {"machine",    "hardware identifier"},
+    {"sysname",    PyDoc_STR("operating system name")},
+    {"nodename",   PyDoc_STR("name of machine on network (implementation-defined)")},
+    {"release",    PyDoc_STR("operating system release")},
+    {"version",    PyDoc_STR("operating system version")},
+    {"machine",    PyDoc_STR("hardware identifier")},
     {NULL}
 };
 
@@ -7820,7 +7820,7 @@ os_sched_param_impl(PyTypeObject *type, PyObject *sched_priority)
 PyDoc_VAR(os_sched_param__doc__);
 
 static PyStructSequence_Field sched_param_fields[] = {
-    {"sched_priority", "the scheduling priority"},
+    {"sched_priority", PyDoc_STR("the scheduling priority")},
     {0}
 };
 
@@ -9928,11 +9928,11 @@ os_symlink_impl(PyObject *module, path_t *src, path_t *dst,
 
 
 static PyStructSequence_Field times_result_fields[] = {
-    {"user",    "user time"},
-    {"system",   "system time"},
-    {"children_user",    "user time of children"},
-    {"children_system",    "system time of children"},
-    {"elapsed",    "elapsed time since an arbitrary point in the past"},
+    {"user",    PyDoc_STR("user time")},
+    {"system",   PyDoc_STR("system time")},
+    {"children_user",    PyDoc_STR("user time of children")},
+    {"children_system",    PyDoc_STR("system time of children")},
+    {"elapsed",    PyDoc_STR("elapsed time since an arbitrary point in the past")},
     {NULL}
 };
 
@@ -14227,8 +14227,8 @@ PyDoc_STRVAR(TerminalSize_docstring,
     "A tuple of (columns, lines) for holding terminal window size");
 
 static PyStructSequence_Field TerminalSize_fields[] = {
-    {"columns", "width of the terminal window in characters"},
-    {"lines", "height of the terminal window in characters"},
+    {"columns", PyDoc_STR("width of the terminal window in characters")},
+    {"lines", PyDoc_STR("height of the terminal window in characters")},
     {NULL, NULL}
 };
 
@@ -14882,9 +14882,9 @@ os_DirEntry___fspath___impl(DirEntry *self)
 
 static PyMemberDef DirEntry_members[] = {
     {"name", Py_T_OBJECT_EX, offsetof(DirEntry, name), Py_READONLY,
-     "the entry's base filename, relative to scandir() \"path\" argument"},
+     PyDoc_STR("the entry's base filename, relative to scandir() \"path\" argument")},
     {"path", Py_T_OBJECT_EX, offsetof(DirEntry, path), Py_READONLY,
-     "the entry's full path name; equivalent to os.path.join(scandir_path, entry.name)"},
+     PyDoc_STR("the entry's full path name; equivalent to os.path.join(scandir_path, entry.name)")},
     {NULL}
 };
 
diff --git a/Modules/pwdmodule.c b/Modules/pwdmodule.c
index b7034369c4731ee..6cf0d5c21ce9792 100644
--- a/Modules/pwdmodule.c
+++ b/Modules/pwdmodule.c
@@ -14,13 +14,13 @@ module pwd
 /*[clinic end generated code: output=da39a3ee5e6b4b0d input=60f628ef356b97b6]*/
 
 static PyStructSequence_Field struct_pwd_type_fields[] = {
-    {"pw_name", "user name"},
-    {"pw_passwd", "password"},
-    {"pw_uid", "user id"},
-    {"pw_gid", "group id"},
-    {"pw_gecos", "real name"},
-    {"pw_dir", "home directory"},
-    {"pw_shell", "shell program"},
+    {"pw_name", PyDoc_STR("user name")},
+    {"pw_passwd", PyDoc_STR("password")},
+    {"pw_uid", PyDoc_STR("user id")},
+    {"pw_gid", PyDoc_STR("group id")},
+    {"pw_gecos", PyDoc_STR("real name")},
+    {"pw_dir", PyDoc_STR("home directory")},
+    {"pw_shell", PyDoc_STR("shell program")},
     {0}
 };
 
diff --git a/Modules/resource.c b/Modules/resource.c
index d65509ec3436a20..781dc5cf7955c2a 100644
--- a/Modules/resource.c
+++ b/Modules/resource.c
@@ -44,22 +44,22 @@ PyDoc_STRVAR(struct_rusage__doc__,
 "or via the attributes ru_utime, ru_stime, ru_maxrss, and so on.");
 
 static PyStructSequence_Field struct_rusage_fields[] = {
-    {"ru_utime",        "user time used"},
-    {"ru_stime",        "system time used"},
-    {"ru_maxrss",       "max. resident set size"},
-    {"ru_ixrss",        "shared memory size"},
-    {"ru_idrss",        "unshared data size"},
-    {"ru_isrss",        "unshared stack size"},
-    {"ru_minflt",       "page faults not requiring I/O"},
-    {"ru_majflt",       "page faults requiring I/O"},
-    {"ru_nswap",        "number of swap outs"},
-    {"ru_inblock",      "block input operations"},
-    {"ru_oublock",      "block output operations"},
-    {"ru_msgsnd",       "IPC messages sent"},
-    {"ru_msgrcv",       "IPC messages received"},
-    {"ru_nsignals",     "signals received"},
-    {"ru_nvcsw",        "voluntary context switches"},
-    {"ru_nivcsw",       "involuntary context switches"},
+    {"ru_utime",        PyDoc_STR("user time used")},
+    {"ru_stime",        PyDoc_STR("system time used")},
+    {"ru_maxrss",       PyDoc_STR("max. resident set size")},
+    {"ru_ixrss",        PyDoc_STR("shared memory size")},
+    {"ru_idrss",        PyDoc_STR("unshared data size")},
+    {"ru_isrss",        PyDoc_STR("unshared stack size")},
+    {"ru_minflt",       PyDoc_STR("page faults not requiring I/O")},
+    {"ru_majflt",       PyDoc_STR("page faults requiring I/O")},
+    {"ru_nswap",        PyDoc_STR("number of swap outs")},
+    {"ru_inblock",      PyDoc_STR("block input operations")},
+    {"ru_oublock",      PyDoc_STR("block output operations")},
+    {"ru_msgsnd",       PyDoc_STR("IPC messages sent")},
+    {"ru_msgrcv",       PyDoc_STR("IPC messages received")},
+    {"ru_nsignals",     PyDoc_STR("signals received")},
+    {"ru_nvcsw",        PyDoc_STR("voluntary context switches")},
+    {"ru_nivcsw",       PyDoc_STR("involuntary context switches")},
     {0}
 };
 
diff --git a/Modules/selectmodule.c b/Modules/selectmodule.c
index c56e682b21e2a1e..bf537b60c5d7941 100644
--- a/Modules/selectmodule.c
+++ b/Modules/selectmodule.c
@@ -1089,7 +1089,7 @@ select_devpoll_fileno_impl(devpollObject *self)
 
 static PyGetSetDef devpoll_getsetlist[] = {
     {"closed", (getter)devpoll_get_closed, NULL,
-     "True if the devpoll object is closed"},
+     PyDoc_STR("True if the devpoll object is closed")},
     {0},
 };
 
@@ -1683,7 +1683,7 @@ select_epoll___exit___impl(pyEpoll_Object *self, PyObject *exc_type,
 
 static PyGetSetDef pyepoll_getsetlist[] = {
     {"closed", (getter)pyepoll_get_closed, NULL,
-     "True if the epoll handler is closed"},
+     PyDoc_STR("True if the epoll handler is closed")},
     {0},
 };
 
@@ -2260,7 +2260,7 @@ select_kqueue_control_impl(kqueue_queue_Object *self, PyObject *changelist,
 
 static PyGetSetDef kqueue_queue_getsetlist[] = {
     {"closed", (getter)kqueue_queue_get_closed, NULL,
-     "True if the kqueue handler is closed"},
+     PyDoc_STR("True if the kqueue handler is closed")},
     {0},
 };
 
diff --git a/Modules/signalmodule.c b/Modules/signalmodule.c
index 8d6556727b3a5a7..84fd125c596294f 100644
--- a/Modules/signalmodule.c
+++ b/Modules/signalmodule.c
@@ -1092,13 +1092,13 @@ signal_valid_signals_impl(PyObject *module)
 
 #if defined(HAVE_SIGWAITINFO) || defined(HAVE_SIGTIMEDWAIT)
 static PyStructSequence_Field struct_siginfo_fields[] = {
-    {"si_signo",        "signal number"},
-    {"si_code",         "signal code"},
-    {"si_errno",        "errno associated with this signal"},
-    {"si_pid",          "sending process ID"},
-    {"si_uid",          "real user ID of sending process"},
-    {"si_status",       "exit value or signal"},
-    {"si_band",         "band event for SIGPOLL"},
+    {"si_signo",        PyDoc_STR("signal number")},
+    {"si_code",         PyDoc_STR("signal code")},
+    {"si_errno",        PyDoc_STR("errno associated with this signal")},
+    {"si_pid",          PyDoc_STR("sending process ID")},
+    {"si_uid",          PyDoc_STR("real user ID of sending process")},
+    {"si_status",       PyDoc_STR("exit value or signal")},
+    {"si_band",         PyDoc_STR("band event for SIGPOLL")},
     {0}
 };
 
diff --git a/Modules/socketmodule.c b/Modules/socketmodule.c
index 90592ffc152fc19..330c949b1057f30 100644
--- a/Modules/socketmodule.c
+++ b/Modules/socketmodule.c
@@ -5206,9 +5206,9 @@ static PyMethodDef sock_methods[] = {
 
 /* SockObject members */
 static PyMemberDef sock_memberlist[] = {
-       {"family", Py_T_INT, offsetof(PySocketSockObject, sock_family), Py_READONLY, "the socket family"},
-       {"type", Py_T_INT, offsetof(PySocketSockObject, sock_type), Py_READONLY, "the socket type"},
-       {"proto", Py_T_INT, offsetof(PySocketSockObject, sock_proto), Py_READONLY, "the socket protocol"},
+       {"family", Py_T_INT, offsetof(PySocketSockObject, sock_family), Py_READONLY, PyDoc_STR("the socket family")},
+       {"type", Py_T_INT, offsetof(PySocketSockObject, sock_type), Py_READONLY, PyDoc_STR("the socket type")},
+       {"proto", Py_T_INT, offsetof(PySocketSockObject, sock_proto), Py_READONLY, PyDoc_STR("the socket protocol")},
        {0},
 };
 
diff --git a/Modules/timemodule.c b/Modules/timemodule.c
index 6a872a285d289b8..412bd4309f7ed59 100644
--- a/Modules/timemodule.c
+++ b/Modules/timemodule.c
@@ -438,17 +438,17 @@ Delay execution for a given number of seconds.  The argument may be\n\
 a floating point number for subsecond precision.");
 
 static PyStructSequence_Field struct_time_type_fields[] = {
-    {"tm_year", "year, for example, 1993"},
-    {"tm_mon", "month of year, range [1, 12]"},
-    {"tm_mday", "day of month, range [1, 31]"},
-    {"tm_hour", "hours, range [0, 23]"},
-    {"tm_min", "minutes, range [0, 59]"},
-    {"tm_sec", "seconds, range [0, 61])"},
-    {"tm_wday", "day of week, range [0, 6], Monday is 0"},
-    {"tm_yday", "day of year, range [1, 366]"},
-    {"tm_isdst", "1 if summer time is in effect, 0 if not, and -1 if unknown"},
-    {"tm_zone", "abbreviation of timezone name"},
-    {"tm_gmtoff", "offset from UTC in seconds"},
+    {"tm_year", PyDoc_STR("year, for example, 1993")},
+    {"tm_mon", PyDoc_STR("month of year, range [1, 12]")},
+    {"tm_mday", PyDoc_STR("day of month, range [1, 31]")},
+    {"tm_hour", PyDoc_STR("hours, range [0, 23]")},
+    {"tm_min", PyDoc_STR("minutes, range [0, 59]")},
+    {"tm_sec", PyDoc_STR("seconds, range [0, 61])")},
+    {"tm_wday", PyDoc_STR("day of week, range [0, 6], Monday is 0")},
+    {"tm_yday", PyDoc_STR("day of year, range [1, 366]")},
+    {"tm_isdst", PyDoc_STR("1 if summer time is in effect, 0 if not, and -1 if unknown")},
+    {"tm_zone", PyDoc_STR("abbreviation of timezone name")},
+    {"tm_gmtoff", PyDoc_STR("offset from UTC in seconds")},
     {0}
 };
 
diff --git a/Modules/xxlimited_35.c b/Modules/xxlimited_35.c
index 1ff3ef1cb6f296e..50797a998764b91 100644
--- a/Modules/xxlimited_35.c
+++ b/Modules/xxlimited_35.c
@@ -110,7 +110,7 @@ Xxo_setattr(XxoObject *self, const char *name, PyObject *v)
 }
 
 static PyType_Slot Xxo_Type_slots[] = {
-    {Py_tp_doc, "The Xxo type"},
+    {Py_tp_doc, PyDoc_STR("The Xxo type")},
     {Py_tp_traverse, Xxo_traverse},
     {Py_tp_clear, Xxo_clear},
     {Py_tp_finalize, Xxo_finalize},
diff --git a/Objects/classobject.c b/Objects/classobject.c
index 618d88894debbea..22ccc4b6bc17f15 100644
--- a/Objects/classobject.c
+++ b/Objects/classobject.c
@@ -154,9 +154,9 @@ static PyMethodDef method_methods[] = {
 
 static PyMemberDef method_memberlist[] = {
     {"__func__", _Py_T_OBJECT, MO_OFF(im_func), Py_READONLY,
-     "the function (or other callable) implementing a method"},
+     PyDoc_STR("the function (or other callable) implementing a method")},
     {"__self__", _Py_T_OBJECT, MO_OFF(im_self), Py_READONLY,
-     "the instance to which a method is bound"},
+     PyDoc_STR("the instance to which a method is bound")},
     {NULL}      /* Sentinel */
 };
 
@@ -376,7 +376,7 @@ PyInstanceMethod_Function(PyObject *im)
 
 static PyMemberDef instancemethod_memberlist[] = {
     {"__func__", _Py_T_OBJECT, IMO_OFF(func), Py_READONLY,
-     "the function (or other callable) implementing a method"},
+     PyDoc_STR("the function (or other callable) implementing a method")},
     {NULL}      /* Sentinel */
 };
 
diff --git a/Objects/complexobject.c b/Objects/complexobject.c
index 0e96f54584677cc..4cdcfb3376e648c 100644
--- a/Objects/complexobject.c
+++ b/Objects/complexobject.c
@@ -721,9 +721,9 @@ static PyMethodDef complex_methods[] = {
 
 static PyMemberDef complex_members[] = {
     {"real", Py_T_DOUBLE, offsetof(PyComplexObject, cval.real), Py_READONLY,
-     "the real part of a complex number"},
+     PyDoc_STR("the real part of a complex number")},
     {"imag", Py_T_DOUBLE, offsetof(PyComplexObject, cval.imag), Py_READONLY,
-     "the imaginary part of a complex number"},
+     PyDoc_STR("the imaginary part of a complex number")},
     {0},
 };
 
diff --git a/Objects/fileobject.c b/Objects/fileobject.c
index 9c2402502188381..8414740034ba994 100644
--- a/Objects/fileobject.c
+++ b/Objects/fileobject.c
@@ -388,11 +388,11 @@ stdprinter_isatty(PyStdPrinter_Object *self, PyObject *Py_UNUSED(ignored))
 }
 
 static PyMethodDef stdprinter_methods[] = {
-    {"close",           (PyCFunction)stdprinter_noop, METH_NOARGS, ""},
-    {"flush",           (PyCFunction)stdprinter_noop, METH_NOARGS, ""},
-    {"fileno",          (PyCFunction)stdprinter_fileno, METH_NOARGS, ""},
-    {"isatty",          (PyCFunction)stdprinter_isatty, METH_NOARGS, ""},
-    {"write",           (PyCFunction)stdprinter_write, METH_VARARGS, ""},
+    {"close",           (PyCFunction)stdprinter_noop, METH_NOARGS, PyDoc_STR("")},
+    {"flush",           (PyCFunction)stdprinter_noop, METH_NOARGS, PyDoc_STR("")},
+    {"fileno",          (PyCFunction)stdprinter_fileno, METH_NOARGS, PyDoc_STR("")},
+    {"isatty",          (PyCFunction)stdprinter_isatty, METH_NOARGS, PyDoc_STR("")},
+    {"write",           (PyCFunction)stdprinter_write, METH_VARARGS, PyDoc_STR("")},
     {NULL,              NULL}  /*sentinel */
 };
 
@@ -415,9 +415,9 @@ get_encoding(PyStdPrinter_Object *self, void *closure)
 }
 
 static PyGetSetDef stdprinter_getsetlist[] = {
-    {"closed", (getter)get_closed, NULL, "True if the file is closed"},
-    {"encoding", (getter)get_encoding, NULL, "Encoding of the file"},
-    {"mode", (getter)get_mode, NULL, "String giving the file mode"},
+    {"closed", (getter)get_closed, NULL, PyDoc_STR("True if the file is closed")},
+    {"encoding", (getter)get_encoding, NULL, PyDoc_STR("Encoding of the file")},
+    {"mode", (getter)get_mode, NULL, PyDoc_STR("String giving the file mode")},
     {0},
 };
 
diff --git a/Objects/floatobject.c b/Objects/floatobject.c
index 776c7092edd057b..c891d906de68a60 100644
--- a/Objects/floatobject.c
+++ b/Objects/floatobject.c
@@ -63,24 +63,24 @@ information about the precision and internal representation. Please study\n\
 your system's :file:`float.h` for more information.");
 
 static PyStructSequence_Field floatinfo_fields[] = {
-    {"max",             "DBL_MAX -- maximum representable finite float"},
-    {"max_exp",         "DBL_MAX_EXP -- maximum int e such that radix**(e-1) "
-                    "is representable"},
-    {"max_10_exp",      "DBL_MAX_10_EXP -- maximum int e such that 10**e "
-                    "is representable"},
-    {"min",             "DBL_MIN -- Minimum positive normalized float"},
-    {"min_exp",         "DBL_MIN_EXP -- minimum int e such that radix**(e-1) "
-                    "is a normalized float"},
-    {"min_10_exp",      "DBL_MIN_10_EXP -- minimum int e such that 10**e is "
-                    "a normalized float"},
-    {"dig",             "DBL_DIG -- maximum number of decimal digits that "
-                    "can be faithfully represented in a float"},
-    {"mant_dig",        "DBL_MANT_DIG -- mantissa digits"},
-    {"epsilon",         "DBL_EPSILON -- Difference between 1 and the next "
-                    "representable float"},
-    {"radix",           "FLT_RADIX -- radix of exponent"},
-    {"rounds",          "FLT_ROUNDS -- rounding mode used for arithmetic "
-                    "operations"},
+    {"max",             PyDoc_STR("DBL_MAX -- maximum representable finite float")},
+    {"max_exp",         PyDoc_STR("DBL_MAX_EXP -- maximum int e such that radix**(e-1) "
+                    "is representable")},
+    {"max_10_exp",      PyDoc_STR("DBL_MAX_10_EXP -- maximum int e such that 10**e "
+                    "is representable")},
+    {"min",             PyDoc_STR("DBL_MIN -- Minimum positive normalized float")},
+    {"min_exp",         PyDoc_STR("DBL_MIN_EXP -- minimum int e such that radix**(e-1) "
+                    "is a normalized float")},
+    {"min_10_exp",      PyDoc_STR("DBL_MIN_10_EXP -- minimum int e such that 10**e is "
+                    "a normalized float")},
+    {"dig",             PyDoc_STR("DBL_DIG -- maximum number of decimal digits that "
+                    "can be faithfully represented in a float")},
+    {"mant_dig",        PyDoc_STR("DBL_MANT_DIG -- mantissa digits")},
+    {"epsilon",         PyDoc_STR("DBL_EPSILON -- Difference between 1 and the next "
+                    "representable float")},
+    {"radix",           PyDoc_STR("FLT_RADIX -- radix of exponent")},
+    {"rounds",          PyDoc_STR("FLT_ROUNDS -- rounding mode used for arithmetic "
+                    "operations")},
     {0}
 };
 
diff --git a/Objects/longobject.c b/Objects/longobject.c
index e73de7422290056..77d68ac072aef66 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -6154,18 +6154,18 @@ int_is_integer_impl(PyObject *self)
 
 static PyMethodDef long_methods[] = {
     {"conjugate",       long_long_meth, METH_NOARGS,
-     "Returns self, the complex conjugate of any int."},
+     PyDoc_STR("Returns self, the complex conjugate of any int.")},
     INT_BIT_LENGTH_METHODDEF
     INT_BIT_COUNT_METHODDEF
     INT_TO_BYTES_METHODDEF
     INT_FROM_BYTES_METHODDEF
     INT_AS_INTEGER_RATIO_METHODDEF
     {"__trunc__",       long_long_meth, METH_NOARGS,
-     "Truncating an Integral returns itself."},
+     PyDoc_STR("Truncating an Integral returns itself.")},
     {"__floor__",       long_long_meth, METH_NOARGS,
-     "Flooring an Integral returns itself."},
+     PyDoc_STR("Flooring an Integral returns itself.")},
     {"__ceil__",        long_long_meth, METH_NOARGS,
-     "Ceiling of an Integral returns itself."},
+     PyDoc_STR("Ceiling of an Integral returns itself.")},
     INT___ROUND___METHODDEF
     INT___GETNEWARGS___METHODDEF
     INT___FORMAT___METHODDEF
@@ -6300,10 +6300,10 @@ A named tuple that holds information about Python's\n\
 internal representation of integers.  The attributes are read only.");
 
 static PyStructSequence_Field int_info_fields[] = {
-    {"bits_per_digit", "size of a digit in bits"},
-    {"sizeof_digit", "size in bytes of the C type used to represent a digit"},
-    {"default_max_str_digits", "maximum string conversion digits limitation"},
-    {"str_digits_check_threshold", "minimum positive value for int_max_str_digits"},
+    {"bits_per_digit", PyDoc_STR("size of a digit in bits")},
+    {"sizeof_digit", PyDoc_STR("size in bytes of the C type used to represent a digit")},
+    {"default_max_str_digits", PyDoc_STR("maximum string conversion digits limitation")},
+    {"str_digits_check_threshold", PyDoc_STR("minimum positive value for int_max_str_digits")},
     {NULL, NULL}
 };
 
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
index 84c50507691cbe4..3ba5dd5bf4125a9 100644
--- a/Objects/typeobject.c
+++ b/Objects/typeobject.c
@@ -10199,11 +10199,11 @@ typedef struct {
 
 static PyMemberDef super_members[] = {
     {"__thisclass__", _Py_T_OBJECT, offsetof(superobject, type), Py_READONLY,
-     "the class invoking super()"},
+     PyDoc_STR("the class invoking super()")},
     {"__self__",  _Py_T_OBJECT, offsetof(superobject, obj), Py_READONLY,
-     "the instance invoking super(); may be None"},
+     PyDoc_STR("the instance invoking super(); may be None")},
     {"__self_class__", _Py_T_OBJECT, offsetof(superobject, obj_type), Py_READONLY,
-     "the type of the instance invoking super(); may be None"},
+     PyDoc_STR("the type of the instance invoking super(); may be None")},
     {0}
 };
 
diff --git a/Python/errors.c b/Python/errors.c
index f670b78c1f14efd..72c5d90c1ae7798 100644
--- a/Python/errors.c
+++ b/Python/errors.c
@@ -1327,11 +1327,11 @@ Type used to pass arguments to sys.unraisablehook.");
 static PyTypeObject UnraisableHookArgsType;
 
 static PyStructSequence_Field UnraisableHookArgs_fields[] = {
-    {"exc_type", "Exception type"},
-    {"exc_value", "Exception value"},
-    {"exc_traceback", "Exception traceback"},
-    {"err_msg", "Error message"},
-    {"object", "Object causing the exception"},
+    {"exc_type", PyDoc_STR("Exception type")},
+    {"exc_value", PyDoc_STR("Exception value")},
+    {"exc_traceback", PyDoc_STR("Exception traceback")},
+    {"err_msg", PyDoc_STR("Error message")},
+    {"object", PyDoc_STR("Object causing the exception")},
     {0}
 };
 
diff --git a/Python/sysmodule.c b/Python/sysmodule.c
index fed12812a77089f..c68f6852337da48 100644
--- a/Python/sysmodule.c
+++ b/Python/sysmodule.c
@@ -1331,8 +1331,8 @@ A named tuple providing information about asynchronous\n\
 generators hooks.  The attributes are read only.");
 
 static PyStructSequence_Field asyncgen_hooks_fields[] = {
-    {"firstiter", "Hook to intercept first iteration"},
-    {"finalizer", "Hook to intercept finalization"},
+    {"firstiter", PyDoc_STR("Hook to intercept first iteration")},
+    {"finalizer", PyDoc_STR("Hook to intercept finalization")},
     {0}
 };
 
@@ -1440,17 +1440,17 @@ A named tuple providing parameters used for computing\n\
 hashes. The attributes are read only.");
 
 static PyStructSequence_Field hash_info_fields[] = {
-    {"width", "width of the type used for hashing, in bits"},
-    {"modulus", "prime number giving the modulus on which the hash "
-                "function is based"},
-    {"inf", "value to be used for hash of a positive infinity"},
-    {"nan", "value to be used for hash of a nan"},
-    {"imag", "multiplier used for the imaginary part of a complex number"},
-    {"algorithm", "name of the algorithm for hashing of str, bytes and "
-                  "memoryviews"},
-    {"hash_bits", "internal output size of hash algorithm"},
-    {"seed_bits", "seed size of hash algorithm"},
-    {"cutoff", "small string optimization cutoff"},
+    {"width", PyDoc_STR("width of the type used for hashing, in bits")},
+    {"modulus", PyDoc_STR("prime number giving the modulus on which the hash "
+                "function is based")},
+    {"inf", PyDoc_STR("value to be used for hash of a positive infinity")},
+    {"nan", PyDoc_STR("value to be used for hash of a nan")},
+    {"imag", PyDoc_STR("multiplier used for the imaginary part of a complex number")},
+    {"algorithm", PyDoc_STR("name of the algorithm for hashing of str, bytes and "
+                  "memoryviews")},
+    {"hash_bits", PyDoc_STR("internal output size of hash algorithm")},
+    {"seed_bits", PyDoc_STR("seed size of hash algorithm")},
+    {"cutoff", PyDoc_STR("small string optimization cutoff")},
     {NULL, NULL}
 };
 
@@ -1517,16 +1517,16 @@ sys_getrecursionlimit_impl(PyObject *module)
 static PyTypeObject WindowsVersionType = {0, 0, 0, 0, 0, 0};
 
 static PyStructSequence_Field windows_version_fields[] = {
-    {"major", "Major version number"},
-    {"minor", "Minor version number"},
-    {"build", "Build number"},
-    {"platform", "Operating system platform"},
-    {"service_pack", "Latest Service Pack installed on the system"},
-    {"service_pack_major", "Service Pack major version number"},
-    {"service_pack_minor", "Service Pack minor version number"},
-    {"suite_mask", "Bit mask identifying available product suites"},
-    {"product_type", "System product type"},
-    {"platform_version", "Diagnostic version number"},
+    {"major", PyDoc_STR"Major version number")},
+    {"minor", PyDoc_STR"Minor version number")},
+    {"build", PyDoc_STR"Build number")},
+    {"platform", PyDoc_STR"Operating system platform")},
+    {"service_pack", PyDoc_STR"Latest Service Pack installed on the system")},
+    {"service_pack_major", PyDoc_STR"Service Pack major version number")},
+    {"service_pack_minor", PyDoc_STR"Service Pack minor version number")},
+    {"suite_mask", PyDoc_STR"Bit mask identifying available product suites")},
+    {"product_type", PyDoc_STR"System product type")},
+    {"platform_version", PyDoc_STR"Diagnostic version number")},
     {0}
 };
 
@@ -2917,24 +2917,24 @@ Flags provided through command line arguments or environment vars.");
 static PyTypeObject FlagsType;
 
 static PyStructSequence_Field flags_fields[] = {
-    {"debug",                   "-d"},
-    {"inspect",                 "-i"},
-    {"interactive",             "-i"},
-    {"optimize",                "-O or -OO"},
-    {"dont_write_bytecode",     "-B"},
-    {"no_user_site",            "-s"},
-    {"no_site",                 "-S"},
-    {"ignore_environment",      "-E"},
-    {"verbose",                 "-v"},
-    {"bytes_warning",           "-b"},
-    {"quiet",                   "-q"},
-    {"hash_randomization",      "-R"},
-    {"isolated",                "-I"},
-    {"dev_mode",                "-X dev"},
-    {"utf8_mode",               "-X utf8"},
-    {"warn_default_encoding",   "-X warn_default_encoding"},
-    {"safe_path", "-P"},
-    {"int_max_str_digits",      "-X int_max_str_digits"},
+    {"debug",                   PyDoc_STR("-d")},
+    {"inspect",                 PyDoc_STR("-i")},
+    {"interactive",             PyDoc_STR("-i")},
+    {"optimize",                PyDoc_STR("-O or -OO")},
+    {"dont_write_bytecode",     PyDoc_STR("-B")},
+    {"no_user_site",            PyDoc_STR("-s")},
+    {"no_site",                 PyDoc_STR("-S")},
+    {"ignore_environment",      PyDoc_STR("-E")},
+    {"verbose",                 PyDoc_STR("-v")},
+    {"bytes_warning",           PyDoc_STR("-b")},
+    {"quiet",                   PyDoc_STR("-q")},
+    {"hash_randomization",      PyDoc_STR("-R")},
+    {"isolated",                PyDoc_STR("-I")},
+    {"dev_mode",                PyDoc_STR("-X dev")},
+    {"utf8_mode",               PyDoc_STR("-X utf8")},
+    {"warn_default_encoding",   PyDoc_STR("-X warn_default_encoding")},
+    {"safe_path", PyDoc_STR("-P")},
+    {"int_max_str_digits",      PyDoc_STR("-X int_max_str_digits")},
     {0}
 };
 
@@ -3014,11 +3014,11 @@ Version information as a named tuple.");
 static PyTypeObject VersionInfoType;
 
 static PyStructSequence_Field version_info_fields[] = {
-    {"major", "Major release number"},
-    {"minor", "Minor release number"},
-    {"micro", "Patch release number"},
-    {"releaselevel", "'alpha', 'beta', 'candidate', or 'final'"},
-    {"serial", "Serial release number"},
+    {"major", PyDoc_STR("Major release number")},
+    {"minor", PyDoc_STR("Minor release number")},
+    {"micro", PyDoc_STR("Patch release number")},
+    {"releaselevel", PyDoc_STR("'alpha', 'beta', 'candidate', or 'final'")},
+    {"serial", PyDoc_STR("Serial release number")},
     {0}
 };
 
@@ -3158,10 +3158,10 @@ WebAssembly Emscripten platform information.");
 static PyTypeObject *EmscriptenInfoType;
 
 static PyStructSequence_Field emscripten_info_fields[] = {
-    {"emscripten_version", "Emscripten version (major, minor, micro)"},
-    {"runtime", "Runtime (Node.JS version, browser user agent)"},
-    {"pthreads", "pthread support"},
-    {"shared_memory", "shared memory support"},
+    {"emscripten_version", PyDoc_STR("Emscripten version (major, minor, micro)")},
+    {"runtime", PyDoc_STR("Runtime (Node.JS version, browser user agent)")},
+    {"pthreads", PyDoc_STR("pthread support")},
+    {"shared_memory", PyDoc_STR("shared memory support")},
     {0}
 };
 
diff --git a/Python/thread.c b/Python/thread.c
index 1ac2db2937e3738..6f0a5a64733306a 100644
--- a/Python/thread.c
+++ b/Python/thread.c
@@ -111,9 +111,9 @@ PyDoc_STRVAR(threadinfo__doc__,
 A named tuple holding information about the thread implementation.");
 
 static PyStructSequence_Field threadinfo_fields[] = {
-    {"name",    "name of the thread implementation"},
-    {"lock",    "name of the lock implementation"},
-    {"version", "name and version of the thread library"},
+    {"name",    PyDoc_STR("name of the thread implementation")},
+    {"lock",    PyDoc_STR("name of the lock implementation")},
+    {"version", PyDoc_STR("name and version of the thread library")},
     {0}
 };
 
diff --git a/Tools/peg_generator/peg_extension/peg_extension.c b/Tools/peg_generator/peg_extension/peg_extension.c
index 7df134b5ade8bbe..5d625bee9677877 100644
--- a/Tools/peg_generator/peg_extension/peg_extension.c
+++ b/Tools/peg_generator/peg_extension/peg_extension.c
@@ -150,8 +150,8 @@ dump_memo_stats(PyObject *Py_UNUSED(self), PyObject *Py_UNUSED(ignored))
 }
 
 static PyMethodDef ParseMethods[] = {
-    {"parse_file", _PyCFunction_CAST(parse_file), METH_VARARGS|METH_KEYWORDS, "Parse a file."},
-    {"parse_string", _PyCFunction_CAST(parse_string), METH_VARARGS|METH_KEYWORDS, "Parse a string."},
+    {"parse_file", _PyCFunction_CAST(parse_file), METH_VARARGS|METH_KEYWORDS, PyDoc_STR("Parse a file.")},
+    {"parse_string", _PyCFunction_CAST(parse_string), METH_VARARGS|METH_KEYWORDS, PyDoc_STR("Parse a string.")},
     {"clear_memo_stats", clear_memo_stats, METH_NOARGS},
     {"dump_memo_stats", dump_memo_stats, METH_NOARGS},
     {"get_memo_stats", get_memo_stats, METH_NOARGS},
@@ -161,7 +161,7 @@ static PyMethodDef ParseMethods[] = {
 static struct PyModuleDef parsemodule = {
     PyModuleDef_HEAD_INIT,
     .m_name = "parse",
-    .m_doc = "A parser.",
+    .m_doc = PyDoc_STR("A parser."),
     .m_methods = ParseMethods,
 };
 

From 511029a90abf59beb0963b75c78bf7afef8ee596 Mon Sep 17 00:00:00 2001
From: Gobot1234 <gobot1234yt@gmail.com>
Date: Sat, 16 Sep 2023 16:30:03 +0100
Subject: [PATCH 2/4] Fix typo

---
 Modules/_elementtree.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Modules/_elementtree.c b/Modules/_elementtree.c
index b2c9c60071d4192..1bfc716553495bc 100644
--- a/Modules/_elementtree.c
+++ b/Modules/_elementtree.c
@@ -4200,19 +4200,19 @@ static PyGetSetDef element_getsetlist[] = {
     {"tag",
         (getter)element_tag_getter,
         (setter)element_tag_setter,
-        PyDoct_STR("A string identifying what kind of data this element represents")},
+        PyDoc_STR("A string identifying what kind of data this element represents")},
     {"text",
         (getter)element_text_getter,
         (setter)element_text_setter,
-        PyDoct_STR("A string of text directly after the start tag, or None")},
+        PyDoc_STR("A string of text directly after the start tag, or None")},
     {"tail",
         (getter)element_tail_getter,
         (setter)element_tail_setter,
-        PyDoct_STR("A string of text directly after the end tag, or None")},
+        PyDoc_STR("A string of text directly after the end tag, or None")},
     {"attrib",
         (getter)element_attrib_getter,
         (setter)element_attrib_setter,
-        PyDoct_STR("A dictionary containing the element's attributes")},
+        PyDoc_STR("A dictionary containing the element's attributes")},
     {NULL},
 };
 

From a6fedf2a0a30d3f08b76443313d4a01a69988230 Mon Sep 17 00:00:00 2001
From: James Hilton-Balfe <gobot1234yt@gmail.com>
Date: Sun, 1 Oct 2023 11:45:43 +0100
Subject: [PATCH 3/4] Apply round 1 of code suggestions

Co-authored-by: Nikita Sobolev <mail@sobolevn.me>
---
 Modules/_winapi.c  |  2 +-
 Python/sysmodule.c | 20 ++++++++++----------
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/Modules/_winapi.c b/Modules/_winapi.c
index 2adcf173edeaac6..53a0a5f9bcef83f 100644
--- a/Modules/_winapi.c
+++ b/Modules/_winapi.c
@@ -329,7 +329,7 @@ static PyMemberDef overlapped_members[] = {
 static PyType_Slot winapi_overlapped_type_slots[] = {
     {Py_tp_traverse, overlapped_traverse},
     {Py_tp_dealloc, overlapped_dealloc},
-    {Py_tp_doc, PyDoc_STR("OVERLAPPED structure wrapper")},
+    {Py_tp_doc, PyDoc_STR("Overlapped structure wrapper")},
     {Py_tp_methods, overlapped_methods},
     {Py_tp_members, overlapped_members},
     {0,0}
diff --git a/Python/sysmodule.c b/Python/sysmodule.c
index c68f6852337da48..25fcdb3972eddc6 100644
--- a/Python/sysmodule.c
+++ b/Python/sysmodule.c
@@ -1517,16 +1517,16 @@ sys_getrecursionlimit_impl(PyObject *module)
 static PyTypeObject WindowsVersionType = {0, 0, 0, 0, 0, 0};
 
 static PyStructSequence_Field windows_version_fields[] = {
-    {"major", PyDoc_STR"Major version number")},
-    {"minor", PyDoc_STR"Minor version number")},
-    {"build", PyDoc_STR"Build number")},
-    {"platform", PyDoc_STR"Operating system platform")},
-    {"service_pack", PyDoc_STR"Latest Service Pack installed on the system")},
-    {"service_pack_major", PyDoc_STR"Service Pack major version number")},
-    {"service_pack_minor", PyDoc_STR"Service Pack minor version number")},
-    {"suite_mask", PyDoc_STR"Bit mask identifying available product suites")},
-    {"product_type", PyDoc_STR"System product type")},
-    {"platform_version", PyDoc_STR"Diagnostic version number")},
+    {"major", PyDoc_STR("Major version number")},
+    {"minor", PyDoc_STR("Minor version number")},
+    {"build", PyDoc_STR("Build number")},
+    {"platform", PyDoc_STR("Operating system platform")},
+    {"service_pack", PyDoc_STR("Latest Service Pack installed on the system")},
+    {"service_pack_major", PyDoc_STR("Service Pack major version number")},
+    {"service_pack_minor", PyDoc_STR("Service Pack minor version number")},
+    {"suite_mask", PyDoc_STR("Bit mask identifying available product suites")},
+    {"product_type", PyDoc_STR("System product type")},
+    {"platform_version", PyDoc_STR("Diagnostic version number")},
     {0}
 };
 

From 3149e38ea2d96cfba3b3825740cd9fad3bfb4480 Mon Sep 17 00:00:00 2001
From: Gobot1234 <gobot1234yt@gmail.com>
Date: Sun, 1 Oct 2023 11:58:24 +0100
Subject: [PATCH 4/4] Remove empty PyDoc_STR

---
 Modules/_multiprocessing/semaphore.c | 12 ++++--------
 Modules/_xxtestfuzz/_xxtestfuzz.c    |  2 +-
 Modules/cjkcodecs/cjkcodecs.h        |  2 +-
 Objects/fileobject.c                 | 10 +++++-----
 4 files changed, 11 insertions(+), 15 deletions(-)

diff --git a/Modules/_multiprocessing/semaphore.c b/Modules/_multiprocessing/semaphore.c
index 3b81acd031752f7..328f8f313465bbf 100644
--- a/Modules/_multiprocessing/semaphore.c
+++ b/Modules/_multiprocessing/semaphore.c
@@ -739,14 +739,10 @@ static PyMethodDef semlock_methods[] = {
  */
 
 static PyMemberDef semlock_members[] = {
-    {"handle", T_SEM_HANDLE, offsetof(SemLockObject, handle), Py_READONLY,
-     PyDoc_STR("")},
-    {"kind", Py_T_INT, offsetof(SemLockObject, kind), Py_READONLY,
-     PyDoc_STR("")},
-    {"maxvalue", Py_T_INT, offsetof(SemLockObject, maxvalue), Py_READONLY,
-     PyDoc_STR("")},
-    {"name", Py_T_STRING, offsetof(SemLockObject, name), Py_READONLY,
-     PyDoc_STR("")},
+    {"handle", T_SEM_HANDLE, offsetof(SemLockObject, handle), Py_READONLY},
+    {"kind", Py_T_INT, offsetof(SemLockObject, kind), Py_READONLY},
+    {"maxvalue", Py_T_INT, offsetof(SemLockObject, maxvalue), Py_READONLY},
+    {"name", Py_T_STRING, offsetof(SemLockObject, name), Py_READONLY},
     {NULL}
 };
 
diff --git a/Modules/_xxtestfuzz/_xxtestfuzz.c b/Modules/_xxtestfuzz/_xxtestfuzz.c
index 15298a1952bfcb1..6c2b0fdddf23180 100644
--- a/Modules/_xxtestfuzz/_xxtestfuzz.c
+++ b/Modules/_xxtestfuzz/_xxtestfuzz.c
@@ -24,7 +24,7 @@ static PyObject* _fuzz_run(PyObject* self, PyObject* args) {
 }
 
 static PyMethodDef module_methods[] = {
-    {"run", (PyCFunction)_fuzz_run, METH_VARARGS, PyDoc_STR("")},
+    {"run", (PyCFunction)_fuzz_run, METH_VARARGS},
     {NULL},
 };
 
diff --git a/Modules/cjkcodecs/cjkcodecs.h b/Modules/cjkcodecs/cjkcodecs.h
index e8088a90e45b488..910d8ee84c4c23a 100644
--- a/Modules/cjkcodecs/cjkcodecs.h
+++ b/Modules/cjkcodecs/cjkcodecs.h
@@ -496,7 +496,7 @@ _cjk_free(void *mod)
 }
 
 static struct PyMethodDef _cjk_methods[] = {
-    {"getcodec", (PyCFunction)getcodec, METH_O, PyDoc_STR("")},
+    {"getcodec", (PyCFunction)getcodec, METH_O},
     {NULL, NULL},
 };
 
diff --git a/Objects/fileobject.c b/Objects/fileobject.c
index 8414740034ba994..ff11608ed6847e3 100644
--- a/Objects/fileobject.c
+++ b/Objects/fileobject.c
@@ -388,11 +388,11 @@ stdprinter_isatty(PyStdPrinter_Object *self, PyObject *Py_UNUSED(ignored))
 }
 
 static PyMethodDef stdprinter_methods[] = {
-    {"close",           (PyCFunction)stdprinter_noop, METH_NOARGS, PyDoc_STR("")},
-    {"flush",           (PyCFunction)stdprinter_noop, METH_NOARGS, PyDoc_STR("")},
-    {"fileno",          (PyCFunction)stdprinter_fileno, METH_NOARGS, PyDoc_STR("")},
-    {"isatty",          (PyCFunction)stdprinter_isatty, METH_NOARGS, PyDoc_STR("")},
-    {"write",           (PyCFunction)stdprinter_write, METH_VARARGS, PyDoc_STR("")},
+    {"close",           (PyCFunction)stdprinter_noop, METH_NOARGS},
+    {"flush",           (PyCFunction)stdprinter_noop, METH_NOARGS},
+    {"fileno",          (PyCFunction)stdprinter_fileno, METH_NOARGS},
+    {"isatty",          (PyCFunction)stdprinter_isatty, METH_NOARGS},
+    {"write",           (PyCFunction)stdprinter_write, METH_VARARGS},
     {NULL,              NULL}  /*sentinel */
 };