Merge branch 'main' into 694-update

Author: warsaw

pep_sphinx_extensions/pep_zero_generator/pep_index_generator.py

@@ -60,17 +60,45 @@ def write_peps_json(peps: list[parser.PEP], path: Path) -> None:
     Path(path, "api", "peps.json").write_text(json_peps, encoding="utf-8")
 
 
+def build_release_peps(peps: list[parser.PEP]) -> dict[str, int]:
+    """Map each Python version to its release-schedule PEP number.
+
+    Handles release PEPs that cover multiple versions jointly
+    (e.g. "2.6, 3.0"), so individual versions also resolve.
+    """
+    release_peps: dict[str, int] = {}
+
+    for pep in peps:
+        if pep.python_version and "release" in pep.topic:
+            for version in map(str.strip, pep.python_version.split(",")):
+                release_peps[version] = pep.number
+
+    return release_peps
+
+
 def create_pep_zero(app: Sphinx, env: BuildEnvironment, docnames: list[str]) -> None:
     peps = _parse_peps(Path(app.srcdir))
 
-    numerical_index_text = writer.PEPZeroWriter().write_numerical_index(peps)
+    release_peps = build_release_peps(peps)
+
+    numerical_index_text = writer.PEPZeroWriter(
+        release_peps
+    ).write_numerical_index(peps)
     subindices.update_sphinx("numerical", numerical_index_text, docnames, env)
 
-    pep0_text = writer.PEPZeroWriter().write_pep0(peps, builder=env.settings["builder"])
+    pep0_text = writer.PEPZeroWriter(
+        release_peps
+    ).write_pep0(peps, builder=env.settings["builder"])
     pep0_path = subindices.update_sphinx("pep-0000", pep0_text, docnames, env)
     peps.append(parser.PEP(pep0_path))
 
-    subindices.generate_subindices(SUBINDICES_BY_TOPIC, peps, docnames, env)
+    subindices.generate_subindices(
+        SUBINDICES_BY_TOPIC,
+        peps,
+        release_peps,
+        docnames,
+        env,
+    )
 
     write_peps_json(peps, Path(app.outdir))
 

pep_sphinx_extensions/pep_zero_generator/subindices.py

@@ -35,6 +35,7 @@ def update_sphinx(filename: str, text: str, docnames: list[str], env: BuildEnvir
 def generate_subindices(
     subindices: dict[str, str],
     peps: list[PEP],
+    release_peps: dict[str, int],
     docnames: list[str],
     env: BuildEnvironment,
 ) -> None:
@@ -58,8 +59,11 @@ def generate_subindices(
 
 {additional_description}
 """
-        subindex_text = writer.PEPZeroWriter().write_pep0(
-            filtered_peps, header, subindex_intro, is_pep0=False,
+        subindex_text = writer.PEPZeroWriter(release_peps).write_pep0(
+            filtered_peps,
+            header,
+            subindex_intro,
+            is_pep0=False,
         )
         update_sphinx(f"topic/{subindex}", subindex_text, docnames, env)
 

pep_sphinx_extensions/pep_zero_generator/writer.py

@@ -59,8 +59,9 @@ class PEPZeroWriter:
         801: "Warsaw",
     }
 
-    def __init__(self):
+    def __init__(self, release_peps: dict[str, int] | None = None):
         self.output: list[str] = []
+        self.release_peps = release_peps or {}
 
     def emit_text(self, content: str) -> None:
         # Appends content argument to the output list
@@ -87,7 +88,17 @@ def emit_pep_row(
         self.emit_text(f"     - :pep:`{title.replace('`', '')} <{number}>`")
         self.emit_text(f"     - {authors}")
         if python_version is not None:
-            self.emit_text(f"     - {python_version}")
+            linked_versions = []
+
+            for version in map(str.strip, python_version.split(",")):
+                release_pep = self.release_peps.get(version)
+
+                if release_pep is not None:
+                    linked_versions.append(f":pep:`{version} <{release_pep}>`")
+                else:
+                    linked_versions.append(version)
+
+            self.emit_text(f"     - {', '.join(linked_versions)}")
 
     def emit_column_headers(self, *, include_version=True) -> None:
         """Output the column headers for the PEP indices."""

pep_sphinx_extensions/tests/pep_zero_generator/test_pep_index_generator.py

@@ -9,3 +9,13 @@ def test_create_pep_json():
     out = pep_index_generator.create_pep_json(peps)
 
     assert '"url": "https://peps.python.org/pep-0008/"' in out
+
+
+def test_build_release_peps_links_individual_versions_from_joint_release_pep():
+    peps = [
+        parser.PEP(PEP_ROOT / "pep-0361.rst"),  # "2.6, 3.0" joint release PEP
+    ]
+
+    release_peps = pep_index_generator.build_release_peps(peps)
+
+    assert release_peps == {"2.6": 361, "3.0": 361}

pep_sphinx_extensions/tests/pep_zero_generator/test_writer.py

@@ -86,3 +86,42 @@ def test_sort_authors():
 
     # Assert
     assert out == ["Aardvark, Alfred", "lowercase, laurence", "Zebra, Zoë"]
+
+
+@pytest.mark.parametrize(
+    ("python_version", "expected"),
+    [
+        ("3.14", "     - :pep:`3.14 <745>`"),
+        (
+            "2.4, 2.5, 2.6",
+            "     - :pep:`2.4 <320>`, :pep:`2.5 <356>`, :pep:`2.6 <361>`",
+        ),
+        ("2.4, 2.9", "     - :pep:`2.4 <320>`, 2.9"),
+        ("1.5.2", "     - 1.5.2"),
+        ("", "     - "),
+    ],
+)
+def test_emit_pep_row_links_python_version_to_release_pep(
+    python_version,
+    expected,
+):
+    # Arrange
+    release_peps = {
+        "2.4": 320,
+        "2.5": 356,
+        "2.6": 361,
+        "3.14": 745,
+    }
+    pep0_writer = writer.PEPZeroWriter(release_peps=release_peps)
+
+    # Act
+    pep0_writer.emit_pep_row(
+        shorthand="Active",
+        number=999,
+        title="Test PEP",
+        authors="Test Author",
+        python_version=python_version,
+    )
+
+    # Assert
+    assert expected in pep0_writer.output

peps/pep-0011.rst

@@ -107,6 +107,7 @@ Tier 2
 Target Triple                 Notes                      Contacts
 ============================= ========================== ========
 aarch64-unknown-linux-gnu     glibc, clang               Victor Stinner, Gregory P. Smith
+aarch64-pc-windows-msvc                                  Steve Dower, Diego Russo, Chris Eibl
 wasm32-unknown-wasip1         WASI SDK, Wasmtime         Brett Cannon, Michael Droettboom, Savannah Ostrowski
 x86_64-apple-darwin           macOS, clang               Sam Gross, Barry Warsaw, Ronald Oussoren
 x86_64-unknown-linux-gnu      glibc, clang               Victor Stinner, Gregory P. Smith
@@ -126,7 +127,6 @@ Tier 3
 Target Triple                    Notes                       Contacts
 ================================ =========================== ========
 aarch64-linux-android                                        Russell Keith-Magee, Petr Viktorin
-aarch64-pc-windows-msvc                                      Steve Dower
 arm64-apple-ios                  iOS on device               Russell Keith-Magee, Ned Deily
 arm64-apple-ios-simulator        iOS on M1 macOS simulator   Russell Keith-Magee, Ned Deily
 armv7l-unknown-linux-gnueabihf   32-bit Raspberry Pi OS, gcc Gregory P. Smith

peps/pep-0793.rst

@@ -2,14 +2,16 @@ PEP: 793
 Title: PyModExport: A new entry point for C extension modules
 Author: Petr Viktorin <encukou@gmail.com>
 Discussions-To: https://discuss.python.org/t/93444
-Status: Accepted
+Status: Final
 Type: Standards Track
 Created: 23-May-2025
 Python-Version: 3.15
 Post-History: `14-Mar-2025 <https://discuss.python.org/t/84498/>`__,
               `27-May-2025 <https://discuss.python.org/t/93444/>`__,
 Resolution: `23-Oct-2025 <https://discuss.python.org/t/93444/46>`__
 
+.. canonical-doc:: :ref:`py3.15:extension-modules`
+
 
 Abstract
 ========
@@ -21,7 +23,7 @@ This allows extension authors to avoid using a statically allocated
 ``PyObject``, lifting the most common obstacle to making one compiled library
 file usable with both regular and free-threaded builds of CPython.
 
-To make this viable, we also specify new module slot types to replace
+To make this viable, we also specify new module slot IDs to replace
 ``PyModuleDef``'s fields, and to allow adding a *token* similar to the
 ``Py_tp_token`` used for type objects.
 
@@ -131,8 +133,8 @@ This proposal does away with fixed fields and proposes using a slots array
 directly, without a wrapper struct.
 
 The ``PyModuleDef_Slot`` struct does have some downsides compared to fixed fields.
-We believe these are fixable, but leave that out of scope of this PEP
-(see “Improving slots in general” in the Possible Future Directions section).
+We believe these are fixable, but leave that out of scope of this PEP.
+(Note: this was done in :pep:`820`, still in Python 3.15.)
 
 
 Tokens
@@ -187,6 +189,8 @@ like this:
 
     PyModuleDef_Slot *PyModExport_<NAME>(void);
 
+.. note:: :pep:`820` changed the return type to ``PySlot *``.
+
 where ``<NAME>`` is the name of the module.
 For non-ASCII names, it will instead look for ``PyModExportU_<NAME>``,
 with ``<NAME>`` encoded as for existing ``PyInitU_*`` hooks
@@ -223,14 +227,13 @@ A new function will be added to create a module from an array of slots:
 
     PyObject *PyModule_FromSlotsAndSpec(const PyModuleDef_Slot *slots, PyObject *spec)
 
+.. note:: :pep:`820` changed the first argument type to ``PySlot *``.
+
 The *slots* argument must point to an array of ``PyModuleDef_Slot`` structures,
 terminated by a slot with ``slot=0`` (typically written as ``{0}`` in C).
-There are no required slots, though *slots* must not be ``NULL``.
-It follows that minimal input contains only the terminator slot.
-
-.. note::
-
-   If :pep:`803` is accepted, the ``Py_mod_abi`` slot will be mandatory.
+The ``Py_mod_abi`` slot is required (see :pep:`803`); all other slots
+are optional.
+It follows that *slots* must not be ``NULL``.
 
 The *spec* argument is a duck-typed ModuleSpec-like object, meaning that any
 attributes defined for ``importlib.machinery.ModuleSpec`` have matching
@@ -373,7 +376,7 @@ Bits & Pieces
 -------------
 
 A ``PyMODEXPORT_FUNC`` macro will be added, similar to the ``PyMODINIT_FUNC``
-macro but with ``PyModuleDef_Slot *`` as the return type.
+macro but with ``PySlot *`` as the return type.
 
 A ``PyModule_GetStateSize`` function will be added to retrieve the size set
 by ``Py_mod_state_size`` or ``PyModuleDef.m_size``.
@@ -397,6 +400,9 @@ The ``PyInit_*`` export hook will be
 
 New API summary
 ---------------
+
+.. note:: This summary was updated with a change from :pep:`820`.
+
 Python will load a new module export hook, with two variants:
 
 .. code-block:: c
@@ -408,7 +414,7 @@ The following functions will be added:
 
 .. code-block:: c
 
-    PyObject *PyModule_FromSlotsAndSpec(const PyModuleDef_Slot *, PyObject *spec)
+    PyObject *PyModule_FromSlotsAndSpec(const PySlot *, PyObject *spec)
     int PyModule_Exec(PyObject *)
     int PyModule_GetToken(PyObject *, void**)
     PyObject *PyType_GetModuleByToken(PyTypeObject *type, const void *token)
@@ -477,6 +483,15 @@ Here is a guide to convert an existing module to the new API, including
 some tricky edge cases.
 It should be moved to a HOWTO in the documentation.
 
+.. note::
+
+   The guide is available at :ref:`py3.15:abi3t-howto-modexport`.
+   (It is part of the ``abi3t`` migration HOWTO since switching to
+   ``PyModExport`` doesn't bring benefits in 3.15 if you don't also
+   adopt ``abi3t``.)
+
+   This section contains the original, outdated guide.
+
 This guide is meant for hand-written modules. For code generators and language
 wrappers, the :ref:`pep793-shim` below may be more useful.
 
@@ -585,24 +600,29 @@ The following implementation can be copied and pasted to a project; only the
 names ``PyInit_examplemodule`` (twice) and ``PyModExport_examplemodule`` should
 need adjusting.
 
-When added to the :ref:`pep793-example` below and compiled with a
-non-free-threaded build of this PEP's reference implementation, the resulting
-extension is compatible with non-free-threading 3.9+ builds, in addition to a
+.. note::
+
+   This section was updated for :pep:`820`.
+
+When compiled together with the :ref:`pep793-example` below on a
+non-free-threaded build of Python 3.15, the resulting
+extension is compatible with non-free-threading 3.11+ builds, in addition to a
 free-threading build of the reference implementation.
 (The module must be named without a version tag, e.g. ``examplemodule.so``,
 and be placed on ``sys.path``.)
 
 Full support for creating such modules will require backports of some new
 API, and support in build/install tools. This is out of scope of this PEP.
 (In particular, the demo “cheats” by using a subset of Limited API 3.15 that
-*happens to work* on 3.9; a proper implementation would use Limited API 3.9
-with backport shims for new API like ``Py_mod_name``.)
+*happens to work* on 3.11, and includes a few hacks.
+A proper implementation would use Limited API 3.11 with cleaner backport shims
+for new API like ``Py_mod_name``.)
 
 This implementation places a few additional requirements on the slots array:
 
-- Slots that correspond to ``PyModuleDef`` members must come first.
+- ``Py_mod_slots`` and ``Py_slot_subslots`` are not supported.
 - A ``Py_mod_name`` slot is required.
-- Any ``Py_mod_token`` must be set to ``&module_def_and_token``, defined here.
+- Any ``Py_mod_token`` must be set to the ``MOD_TOKEN`` defined here.
 
 .. literalinclude:: pep-0793/shim.c
    :language: c
@@ -626,6 +646,10 @@ be added as a new HOWTO.
 Example
 =======
 
+.. note::
+
+   The example was updated for :pep:`820`.
+
 .. literalinclude:: pep-0793/examplemodule.c
    :language: c
 
@@ -693,6 +717,10 @@ These ideas are out of scope for *this* proposal.
 Improving slots in general
 --------------------------
 
+.. note::
+
+   This idea was implemented in :pep:`820`.
+
 Slots -- and specifically the existing ``PyModuleDef_Slot`` -- do have a few
 shortcomings. The most important are: