Address review comments

* Explain in a comment why the result of sscanf() is not checked.
* Merge make_zlib_version() and make_zlibng_version() into a single
  make_version_info().
* Rename the static names for the *_version_info named tuples, so that
  they match the name of the type.
* Tell in the bz2 docs that bzlib_version and bzlib_version_info are the
  version of the library loaded at runtime, and that the version used for
  building the module is not available.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: serhiy-storchaka

Doc/library/bz2.rst

@@ -311,21 +311,26 @@ One-shot (de)compression
 Miscellaneous
 -------------
 
-Information about the version of the bzip2 compression library in use
-is available through the following constants:
+Information about the version of the bzip2 compression library
+actually loaded by the interpreter is available through the following
+constants.
+The version used for building the module is not available,
+because the bzip2 library does not provide it.
 
 
 .. data:: bzlib_version
 
-   The version string of the bzip2 compression library.
+   The version string of the bzip2 compression library
+   actually loaded by the interpreter.
 
    .. versionadded:: next
 
 
 .. data:: bzlib_version_info
 
    A named tuple containing the three components of the bzip2 compression
-   library version: *major*, *minor*, and *patch*.  All values are integers.
+   library version actually loaded by the interpreter:
+   *major*, *minor*, and *patch*.  All values are integers.
    The components can also be accessed by name, so ``bz2.bzlib_version_info[0]``
    is equivalent to ``bz2.bzlib_version_info.major`` and so on.
 

Modules/_bz2module.c

@@ -748,27 +748,32 @@ static PyType_Spec bz2_decompressor_type_spec = {
 };
 
 
-PyDoc_STRVAR(bzlib_version__doc__,
+PyDoc_STRVAR(bzlib_version_info__doc__,
 "_bz2.bzlib_version_info\n\
 \n\
 Bzlib version information as a named tuple.");
 
-static PyStructSequence_Field bzlib_version_fields[] = {
+static PyStructSequence_Field bzlib_version_info_fields[] = {
     {"major", "Major release number"},
     {"minor", "Minor release number"},
     {"patch", "Patch release number"},
     {0}
 };
 
-static PyStructSequence_Desc bzlib_version_desc = {
-    "_bz2.bzlib_version_info",   /* name */
-    bzlib_version__doc__,        /* doc */
-    bzlib_version_fields,        /* fields */
+static PyStructSequence_Desc bzlib_version_info_desc = {
+    "_bz2.bzlib_version_info",        /* name */
+    bzlib_version_info__doc__,        /* doc */
+    bzlib_version_info_fields,        /* fields */
     3
 };
 
+/* BZ2_bzlibVersion() returns a string with a trailing suffix, for example
+   "1.0.8, 13-Jul-2019" for bzip2 or "1.1.0-libbz2-rs-sys-0.2.5" for
+   libbz2-rs.  sscanf() stops at the suffix; components which were not
+   parsed are left zero.  This is deliberate -- a zero is more useful
+   here than a hard error. */
 static PyObject *
-make_bzlib_version(PyTypeObject *type, const char *string)
+make_bzlib_version_info(PyTypeObject *type, const char *string)
 {
     PyObject *version;
     int pos = 0;
@@ -828,12 +833,12 @@ _bz2_exec(PyObject *module)
         return -1;
     }
     PyTypeObject *version_type;
-    version_type = PyStructSequence_NewType(&bzlib_version_desc);
+    version_type = PyStructSequence_NewType(&bzlib_version_info_desc);
     if (version_type == NULL) {
         return -1;
     }
     if (PyModule_Add(module, "bzlib_version_info",
-            make_bzlib_version(version_type, BZ2_bzlibVersion())) < 0)
+            make_bzlib_version_info(version_type, BZ2_bzlibVersion())) < 0)
     {
         Py_DECREF(version_type);
         return -1;

Modules/_lzmamodule.c

@@ -1510,28 +1510,28 @@ _lzma__decode_filter_properties_impl(PyObject *module, lzma_vli filter_id,
 }
 
 
-PyDoc_STRVAR(lzma_version__doc__,
+PyDoc_STRVAR(lzma_version_info__doc__,
 "_lzma.lzma_version_info\n\
 \n\
 Lzma version information as a named tuple.");
 
-static PyStructSequence_Field lzma_version_fields[] = {
+static PyStructSequence_Field lzma_version_info_fields[] = {
     {"major", "Major release number"},
     {"minor", "Minor release number"},
     {"patch", "Patch release number"},
     {"stability", "'alpha', 'beta', or 'stable'"},
     {0}
 };
 
-static PyStructSequence_Desc lzma_version_desc = {
-    "_lzma.lzma_version_info",   /* name */
-    lzma_version__doc__,         /* doc */
-    lzma_version_fields,         /* fields */
+static PyStructSequence_Desc lzma_version_info_desc = {
+    "_lzma.lzma_version_info",        /* name */
+    lzma_version_info__doc__,         /* doc */
+    lzma_version_info_fields,         /* fields */
     4
 };
 
 static PyObject *
-make_lzma_version(PyTypeObject *type, unsigned int number)
+make_lzma_version_info(PyTypeObject *type, unsigned int number)
 {
     PyObject *version;
     int pos = 0;
@@ -1669,18 +1669,18 @@ lzma_exec(PyObject *module)
         return -1;
     }
     PyTypeObject *version_type;
-    version_type = PyStructSequence_NewType(&lzma_version_desc);
+    version_type = PyStructSequence_NewType(&lzma_version_info_desc);
     if (version_type == NULL) {
         return -1;
     }
     if (PyModule_Add(module, "LZMA_VERSION_INFO",
-            make_lzma_version(version_type, LZMA_VERSION)) < 0)
+            make_lzma_version_info(version_type, LZMA_VERSION)) < 0)
     {
         Py_DECREF(version_type);
         return -1;
     }
     if (PyModule_Add(module, "lzma_version_info",
-            make_lzma_version(version_type, lzma_version_number())) < 0)
+            make_lzma_version_info(version_type, lzma_version_number())) < 0)
     {
         Py_DECREF(version_type);
         return -1;

Modules/_zstd/_zstdmodule.c

@@ -571,27 +571,27 @@ static PyMethodDef _zstd_methods[] = {
     {NULL, NULL}
 };
 
-PyDoc_STRVAR(zstd_version__doc__,
+PyDoc_STRVAR(zstd_version_info__doc__,
 "_zstd.zstd_version_info\n\
 \n\
 Zstd version information as a named tuple.");
 
-static PyStructSequence_Field zstd_version_fields[] = {
+static PyStructSequence_Field zstd_version_info_fields[] = {
     {"major", "Major release number"},
     {"minor", "Minor release number"},
     {"patch", "Patch release number"},
     {0}
 };
 
-static PyStructSequence_Desc zstd_version_desc = {
-    "_zstd.zstd_version_info",   /* name */
-    zstd_version__doc__,         /* doc */
-    zstd_version_fields,         /* fields */
+static PyStructSequence_Desc zstd_version_info_desc = {
+    "_zstd.zstd_version_info",        /* name */
+    zstd_version_info__doc__,         /* doc */
+    zstd_version_info_fields,         /* fields */
     3
 };
 
 static PyObject *
-make_zstd_version(PyTypeObject *type, unsigned int number)
+make_zstd_version_info(PyTypeObject *type, unsigned int number)
 {
     PyObject *version;
     int pos = 0;
@@ -681,18 +681,18 @@ do {                                                                         \
         return -1;
     }
     PyTypeObject *version_type;
-    version_type = PyStructSequence_NewType(&zstd_version_desc);
+    version_type = PyStructSequence_NewType(&zstd_version_info_desc);
     if (version_type == NULL) {
         return -1;
     }
     if (PyModule_Add(m, "ZSTD_VERSION_INFO",
-        make_zstd_version(version_type, ZSTD_VERSION_NUMBER)) < 0)
+        make_zstd_version_info(version_type, ZSTD_VERSION_NUMBER)) < 0)
     {
         Py_DECREF(version_type);
         return -1;
     }
     if (PyModule_Add(m, "zstd_version_info",
-        make_zstd_version(version_type, ZSTD_versionNumber())) < 0)
+        make_zstd_version_info(version_type, ZSTD_versionNumber())) < 0)
     {
         Py_DECREF(version_type);
         return -1;

Modules/zlibmodule.c

@@ -2060,105 +2060,75 @@ zlib_getattr(PyObject *self, PyObject *args)
     return NULL;
 }
 
-PyDoc_STRVAR(zlib_version__doc__,
+PyDoc_STRVAR(zlib_version_info__doc__,
 "zlib.zlib_version_info\n\
 \n\
 Zlib version information as a named tuple.");
 
-static PyStructSequence_Field zlib_version_fields[] = {
+static PyStructSequence_Field zlib_version_info_fields[] = {
     {"major", "Major release number"},
     {"minor", "Minor release number"},
     {"revision", "Revision release number"},
     {"subversion", "Subversion release number"},
     {0}
 };
 
-static PyStructSequence_Desc zlib_version_desc = {
-    "zlib.zlib_version_info",   /* name */
-    zlib_version__doc__,        /* doc */
-    zlib_version_fields,        /* fields */
+static PyStructSequence_Desc zlib_version_info_desc = {
+    "zlib.zlib_version_info",        /* name */
+    zlib_version_info__doc__,        /* doc */
+    zlib_version_info_fields,        /* fields */
     4
 };
 
-static PyObject *
-make_zlib_version(PyTypeObject *type, const char *string)
-{
-    PyObject *version;
-    int pos = 0;
-    unsigned int major = 0, minor = 0, revision = 0, subversion = 0;
-
-    sscanf(string, "%u.%u.%u.%u", &major, &minor, &revision, &subversion);
-
-    version = PyStructSequence_New(type);
-    if (version == NULL) {
-        return NULL;
-    }
-
-#define SetIntItem(VALUE) \
-    PyStructSequence_SET_ITEM(version, pos++, PyLong_FromUnsignedLong(VALUE)); \
-    if (PyErr_Occurred()) { \
-        Py_DECREF(version); \
-        return NULL; \
-    }
-
-    SetIntItem(major)
-    SetIntItem(minor)
-    SetIntItem(revision)
-    SetIntItem(subversion)
-#undef SetIntItem
-
-    return version;
-}
-
 #ifdef ZLIBNG_VERSION
-PyDoc_STRVAR(zlibng_version__doc__,
+PyDoc_STRVAR(zlibng_version_info__doc__,
 "zlib.zlibng_version_info\n\
 \n\
 Zlib-ng version information as a named tuple.");
 
-static PyStructSequence_Field zlibng_version_fields[] = {
+static PyStructSequence_Field zlibng_version_info_fields[] = {
     {"major", "Major release number"},
     {"minor", "Minor release number"},
     {"revision", "Revision release number"},
     {0}
 };
 
-static PyStructSequence_Desc zlibng_version_desc = {
-    "zlib.zlibng_version_info",   /* name */
-    zlibng_version__doc__,        /* doc */
-    zlibng_version_fields,        /* fields */
+static PyStructSequence_Desc zlibng_version_info_desc = {
+    "zlib.zlibng_version_info",        /* name */
+    zlibng_version_info__doc__,        /* doc */
+    zlibng_version_info_fields,        /* fields */
     3
 };
+#endif // ZLIBNG_VERSION
 
+/* Create a named tuple from the first *size* components of a version string
+   like "1.2.11" or "1.2.11.1".  sscanf() is expected to fail on trailing
+   garbage and on versions with fewer components (for example "1.2.0.f" or
+   "1.3.1.zlib-ng"); the components which were not parsed are left zero.
+   This is deliberate -- a zero is more useful here than a hard error. */
 static PyObject *
-make_zlibng_version(PyTypeObject *type, const char *string)
+make_version_info(PyTypeObject *type, const char *string, Py_ssize_t size)
 {
-    PyObject *version;
-    int pos = 0;
-    unsigned int major = 0, minor = 0, revision = 0;
+    unsigned int components[4] = {0, 0, 0, 0};
+    assert(size <= (Py_ssize_t)Py_ARRAY_LENGTH(components));
 
-    sscanf(string, "%u.%u.%u", &major, &minor, &revision);
+    sscanf(string, "%u.%u.%u.%u",
+           &components[0], &components[1], &components[2], &components[3]);
 
-    version = PyStructSequence_New(type);
+    PyObject *version = PyStructSequence_New(type);
     if (version == NULL) {
         return NULL;
     }
-
-#define SetIntItem(VALUE) \
-    PyStructSequence_SET_ITEM(version, pos++, PyLong_FromUnsignedLong(VALUE)); \
-    if (PyErr_Occurred()) { \
-        Py_DECREF(version); \
-        return NULL; \
+    for (Py_ssize_t i = 0; i < size; i++) {
+        PyObject *item = PyLong_FromUnsignedLong(components[i]);
+        if (item == NULL) {
+            Py_DECREF(version);
+            return NULL;
+        }
+        PyStructSequence_SET_ITEM(version, i, item);
     }
-
-    SetIntItem(major)
-    SetIntItem(minor)
-    SetIntItem(revision)
-#undef SetIntItem
-
     return version;
 }
-#endif // ZLIBNG_VERSION
 
 
 static PyMethodDef zlib_methods[] =
@@ -2377,30 +2347,30 @@ zlib_exec(PyObject *mod)
     }
 #endif
     PyTypeObject *version_type;
-    version_type = PyStructSequence_NewType(&zlib_version_desc);
+    version_type = PyStructSequence_NewType(&zlib_version_info_desc);
     if (version_type == NULL) {
         return -1;
     }
     if (PyModule_Add(mod, "ZLIB_VERSION_INFO",
-            make_zlib_version(version_type, ZLIB_VERSION)) < 0)
+            make_version_info(version_type, ZLIB_VERSION, 4)) < 0)
     {
         Py_DECREF(version_type);
         return -1;
     }
     if (PyModule_Add(mod, "zlib_version_info",
-            make_zlib_version(version_type, zlibVersion())) < 0)
+            make_version_info(version_type, zlibVersion(), 4)) < 0)
     {
         Py_DECREF(version_type);
         return -1;
     }
     Py_DECREF(version_type);
 #ifdef ZLIBNG_VERSION
-    version_type = PyStructSequence_NewType(&zlibng_version_desc);
+    version_type = PyStructSequence_NewType(&zlibng_version_info_desc);
     if (version_type == NULL) {
         return -1;
     }
     if (PyModule_Add(mod, "ZLIBNG_VERSION_INFO",
-            make_zlibng_version(version_type, ZLIBNG_VERSION)) < 0)
+            make_version_info(version_type, ZLIBNG_VERSION, 3)) < 0)
     {
         Py_DECREF(version_type);
         return -1;