Infra: Link target release to release PEP in PEP 0

pep_sphinx_extensions/pep_zero_generator/pep_index_generator.py

@@ -60,17 +60,56 @@ 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] = {}
+    release_versions = {
+        pep.python_version
+        for pep in peps
+        if pep.python_version and "release" in pep.topic
+    }
+
+    for pep in peps:
+        if not pep.python_version or "release" not in pep.topic:
+            continue
+
+        release_peps[pep.python_version] = pep.number
+
+        if "," in pep.python_version:
+            for version in map(str.strip, pep.python_version.split(",")):
+                if version not in release_versions:
+                    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,26 @@ 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}")
+            pep_number = self.release_peps.get(python_version)
+
+            if pep_number is not None:
+                self.emit_text(
+                    f"     - :pep:`{python_version} <{pep_number}>`"
+                )
+            else:
+                versions = [version.strip() for version in python_version.split(",")]
+
+                linked_versions = []
+                for version in versions:
+                    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,15 @@ 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, 3.0"] == 361
+    assert release_peps["2.6"] == 361
+    assert release_peps["3.0"] == 361

pep_sphinx_extensions/tests/pep_zero_generator/test_writer.py

@@ -86,3 +86,37 @@ def test_sort_authors():
 
     # Assert
     assert out == ["Aardvark, Alfred", "lowercase, laurence", "Zebra, Zoë"]
+
+
+@pytest.mark.parametrize(
+    ("python_version", "release_peps", "expected"),
+    [
+        ("3.14", {"3.14": 745}, "     - :pep:`3.14 <745>`"),
+        ("2.6, 3.0", {"2.6, 3.0": 361}, "     - :pep:`2.6, 3.0 <361>`"),
+        ("2.7, 3.1", {"2.7, 3.1": 375}, "     - :pep:`2.7, 3.1 <375>`"),
+        (
+            "2.4, 2.5, 2.6",
+            {"2.4, 2.5, 2.6": 320},
+            "     - :pep:`2.4, 2.5, 2.6 <320>`",
+        ),
+    ],
+)
+def test_emit_pep_row_links_python_version_to_release_pep(
+    python_version,
+    release_peps,
+    expected,
+):
+    # Arrange
+    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