Narrow Python pinned-runtime generation to tags

sdk/python/scripts/update_sdk_artifacts.py

@@ -97,17 +97,17 @@ def pinned_runtime_version() -> str:
     return module.pinned_runtime_version()  # type: ignore[no-any-return]
 
 
-def runtime_git_ref(version: str) -> str:
+def runtime_git_tag(version: str) -> str:
     return f"rust-v{version}"
 
 
-def pinned_runtime_git_ref() -> str:
-    return runtime_git_ref(pinned_runtime_version())
+def pinned_runtime_git_tag() -> str:
+    return runtime_git_tag(pinned_runtime_version())
 
 
-def ensure_git_ref_available(git_ref: str) -> None:
+def ensure_git_tag_available(git_tag: str) -> None:
     result = subprocess.run(
-        ["git", "rev-parse", "--verify", git_ref],
+        ["git", "rev-parse", "--verify", git_tag],
         cwd=str(repo_root()),
         text=True,
         capture_output=True,
@@ -115,20 +115,20 @@ def ensure_git_ref_available(git_ref: str) -> None:
     )
     if result.returncode == 0:
         return
-    run(["git", "fetch", "origin", "tag", git_ref, "--depth=1"], repo_root())
+    run(["git", "fetch", "origin", "tag", git_tag, "--depth=1"], repo_root())
 
 
-def read_git_file(git_ref: str, repo_path: str) -> str:
-    return run_capture(["git", "show", f"{git_ref}:{repo_path}"], repo_root())
+def read_git_tag_file(git_tag: str, repo_path: str) -> str:
+    return run_capture(["git", "show", f"{git_tag}:{repo_path}"], repo_root())
 
 
-def materialize_schema_files_from_git_ref(git_ref: str, out_dir: Path) -> tuple[Path, Path]:
+def materialize_schema_files_from_git_tag(git_tag: str, out_dir: Path) -> tuple[Path, Path]:
     out_dir.mkdir(parents=True, exist_ok=True)
 
     schema_bundle = out_dir / "codex_app_server_protocol.v2.schemas.json"
     schema_bundle.write_text(
-        read_git_file(
-            git_ref,
+        read_git_tag_file(
+            git_tag,
             "codex-rs/app-server-protocol/schema/json/"
             "codex_app_server_protocol.v2.schemas.json",
         )
@@ -136,8 +136,8 @@ def materialize_schema_files_from_git_ref(git_ref: str, out_dir: Path) -> tuple[
 
     server_notification = out_dir / "ServerNotification.json"
     server_notification.write_text(
-        read_git_file(
-            git_ref,
+        read_git_tag_file(
+            git_tag,
             "codex-rs/app-server-protocol/schema/json/ServerNotification.json",
         )
     )
@@ -647,7 +647,8 @@ class PublicFieldSpec:
 @dataclass(frozen=True)
 class CliOps:
     generate_types: Callable[[], None]
-    generate_types_for_pinned_runtime: Callable[[str | None], None]
+    generate_types_for_pinned_runtime: Callable[[], None]
+    generate_types_for_runtime_tag: Callable[[str], None]
     stage_python_sdk_package: Callable[[Path, str, str], Path]
     stage_python_runtime_package: Callable[[Path, str, Path], Path]
     current_sdk_version: Callable[[], str]
@@ -1003,12 +1004,11 @@ def generate_types(
     generate_public_api_flat_methods()
 
 
-def generate_types_for_pinned_runtime(git_ref: str | None = None) -> None:
-    pinned_ref = git_ref or pinned_runtime_git_ref()
-    ensure_git_ref_available(pinned_ref)
+def generate_types_for_runtime_tag(runtime_tag: str) -> None:
+    ensure_git_tag_available(runtime_tag)
     with tempfile.TemporaryDirectory(prefix="codex-python-pinned-schema-") as temp_root:
-        schema_bundle, server_notification_schema = materialize_schema_files_from_git_ref(
-            pinned_ref,
+        schema_bundle, server_notification_schema = materialize_schema_files_from_git_tag(
+            runtime_tag,
             Path(temp_root),
         )
         generate_types(
@@ -1017,6 +1017,10 @@ def generate_types_for_pinned_runtime(git_ref: str | None = None) -> None:
         )
 
 
+def generate_types_for_pinned_runtime() -> None:
+    generate_types_for_runtime_tag(pinned_runtime_git_tag())
+
+
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(description="Single SDK maintenance entrypoint")
     subparsers = parser.add_subparsers(dest="command", required=True)
@@ -1024,14 +1028,10 @@ def build_parser() -> argparse.ArgumentParser:
     subparsers.add_parser(
         "generate-types", help="Regenerate Python protocol-derived types"
     )
-    pinned_types_parser = subparsers.add_parser(
+    subparsers.add_parser(
         "generate-types-for-pinned-runtime",
         help="Regenerate Python protocol-derived types from the pinned runtime version",
     )
-    pinned_types_parser.add_argument(
-        "--git-ref",
-        help="Optional git ref to source vendored schema files from",
-    )
 
     stage_sdk_parser = subparsers.add_parser(
         "stage-sdk",
@@ -1082,6 +1082,7 @@ def default_cli_ops() -> CliOps:
     return CliOps(
         generate_types=generate_types,
         generate_types_for_pinned_runtime=generate_types_for_pinned_runtime,
+        generate_types_for_runtime_tag=generate_types_for_runtime_tag,
         stage_python_sdk_package=stage_python_sdk_package,
         stage_python_runtime_package=stage_python_runtime_package,
         current_sdk_version=current_sdk_version,
@@ -1092,9 +1093,9 @@ def run_command(args: argparse.Namespace, ops: CliOps) -> None:
     if args.command == "generate-types":
         ops.generate_types()
     elif args.command == "generate-types-for-pinned-runtime":
-        ops.generate_types_for_pinned_runtime(args.git_ref)
+        ops.generate_types_for_pinned_runtime()
     elif args.command == "stage-sdk":
-        ops.generate_types_for_pinned_runtime(runtime_git_ref(args.runtime_version))
+        ops.generate_types_for_runtime_tag(runtime_git_tag(args.runtime_version))
         ops.stage_python_sdk_package(
             args.staging_dir,
             args.sdk_version or ops.current_sdk_version(),

sdk/python/tests/test_artifact_workflow_and_binaries.py

@@ -167,11 +167,11 @@ def test_examples_readme_matches_pinned_runtime_version() -> None:
     )
 
 
-def test_pinned_runtime_git_ref_matches_runtime_setup_pin() -> None:
+def test_pinned_runtime_git_tag_matches_runtime_setup_pin() -> None:
     script = _load_update_script_module()
     runtime_setup = _load_runtime_setup_module()
 
-    assert script.pinned_runtime_git_ref() == (
+    assert script.pinned_runtime_git_tag() == (
         f"rust-v{runtime_setup.pinned_runtime_version()}"
     )
 
@@ -182,7 +182,20 @@ def test_parser_supports_generate_types_for_pinned_runtime() -> None:
     args = script.parse_args(["generate-types-for-pinned-runtime"])
 
     assert args.command == "generate-types-for-pinned-runtime"
-    assert args.git_ref is None
+    assert not hasattr(args, "git_ref")
+
+
+def test_parser_rejects_git_ref_override_for_pinned_runtime_generation() -> None:
+    script = _load_update_script_module()
+
+    with pytest.raises(SystemExit):
+        script.parse_args(
+            [
+                "generate-types-for-pinned-runtime",
+                "--git-ref",
+                "rust-v1.2.3",
+            ]
+        )
 
 
 def test_release_metadata_retries_without_invalid_auth(monkeypatch: pytest.MonkeyPatch) -> None:
@@ -335,8 +348,11 @@ def test_stage_sdk_runs_type_generation_before_staging(tmp_path: Path) -> None:
     def fake_generate_types() -> None:
         raise AssertionError("stage-sdk should use pinned-runtime generation")
 
-    def fake_generate_types_for_pinned_runtime(git_ref: str | None = None) -> None:
-        calls.append(f"generate_types_for_pinned_runtime:{git_ref}")
+    def fake_generate_types_for_pinned_runtime() -> None:
+        raise AssertionError("stage-sdk should use explicit runtime-tag generation")
+
+    def fake_generate_types_for_runtime_tag(runtime_tag: str) -> None:
+        calls.append(f"generate_types_for_runtime_tag:{runtime_tag}")
 
     def fake_stage_sdk_package(
         _staging_dir: Path, _sdk_version: str, _runtime_version: str
@@ -355,6 +371,7 @@ def test_stage_sdk_runs_type_generation_before_staging(tmp_path: Path) -> None:
     ops = script.CliOps(
         generate_types=fake_generate_types,
         generate_types_for_pinned_runtime=fake_generate_types_for_pinned_runtime,
+        generate_types_for_runtime_tag=fake_generate_types_for_runtime_tag,
         stage_python_sdk_package=fake_stage_sdk_package,
         stage_python_runtime_package=fake_stage_runtime_package,
         current_sdk_version=fake_current_sdk_version,
@@ -362,7 +379,7 @@ def test_stage_sdk_runs_type_generation_before_staging(tmp_path: Path) -> None:
 
     script.run_command(args, ops)
 
-    assert calls == ["generate_types_for_pinned_runtime:rust-v1.2.3", "stage_sdk"]
+    assert calls == ["generate_types_for_runtime_tag:rust-v1.2.3", "stage_sdk"]
 
 
 def test_stage_runtime_stages_binary_without_type_generation(tmp_path: Path) -> None:
@@ -383,9 +400,12 @@ def test_stage_runtime_stages_binary_without_type_generation(tmp_path: Path) ->
     def fake_generate_types() -> None:
         calls.append("generate_types")
 
-    def fake_generate_types_for_pinned_runtime(_git_ref: str | None = None) -> None:
+    def fake_generate_types_for_pinned_runtime() -> None:
         calls.append("generate_types_for_pinned_runtime")
 
+    def fake_generate_types_for_runtime_tag(_runtime_tag: str) -> None:
+        calls.append("generate_types_for_runtime_tag")
+
     def fake_stage_sdk_package(
         _staging_dir: Path, _sdk_version: str, _runtime_version: str
     ) -> Path:
@@ -403,6 +423,7 @@ def test_stage_runtime_stages_binary_without_type_generation(tmp_path: Path) ->
     ops = script.CliOps(
         generate_types=fake_generate_types,
         generate_types_for_pinned_runtime=fake_generate_types_for_pinned_runtime,
+        generate_types_for_runtime_tag=fake_generate_types_for_runtime_tag,
         stage_python_sdk_package=fake_stage_sdk_package,
         stage_python_runtime_package=fake_stage_runtime_package,
         current_sdk_version=fake_current_sdk_version,