opensportslib 0.3.1.dev19__tar.gz → 0.3.1.dev21__tar.gz

{opensportslib-0.3.1.dev19/opensportslib.egg-info → opensportslib-0.3.1.dev21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensportslib
-Version: 0.3.1.dev19
+Version: 0.3.1.dev21
 Summary: OpenSportsLib is the professional library, designed for advanced video understanding in sports. It provides state-of-the-art tools for action recognition, spotting, retrieval, and captioning, making it ideal for researchers, analysts, and developers working with sports video data.
 Author: Jeet Vora
 Requires-Python: >=3.12
@@ -114,8 +114,9 @@ It provides a unified framework to **train, evaluate, and run inference** for ke
 - **Action classification**
 - **Action localization / spotting**
 - **Visual Question Answering (VQA)**
-- **Action retrieval**
-- **Action description / captioning**
+
+Retrieval and action description/captioning are roadmap areas. They do not yet
+have first-class task wrappers or training workflows in this package.
 
 OpenSportsLib is designed for **researchers, ML engineers, and sports analytics teams** who want reproducible and extensible workflows for sports video AI.
 
@@ -622,6 +623,10 @@ opensportslib setup --vqa_qwen
 
 We welcome contributions to OpenSportsLib.
 
+All PRs must target `dev`. Before a PR can merge, every GitHub-linked commit
+author must accept the [Individual Contributor License Agreement](.github/CLA.md)
+when prompted by the `CLA check`.
+
 Please check:
 
 - [CONTRIBUTING.md](CONTRIBUTING.md)

{opensportslib-0.3.1.dev19 → opensportslib-0.3.1.dev21}/README.md

@@ -75,8 +75,9 @@ It provides a unified framework to **train, evaluate, and run inference** for ke
 - **Action classification**
 - **Action localization / spotting**
 - **Visual Question Answering (VQA)**
-- **Action retrieval**
-- **Action description / captioning**
+
+Retrieval and action description/captioning are roadmap areas. They do not yet
+have first-class task wrappers or training workflows in this package.
 
 OpenSportsLib is designed for **researchers, ML engineers, and sports analytics teams** who want reproducible and extensible workflows for sports video AI.
 
@@ -583,6 +584,10 @@ opensportslib setup --vqa_qwen
 
 We welcome contributions to OpenSportsLib.
 
+All PRs must target `dev`. Before a PR can merge, every GitHub-linked commit
+author must accept the [Individual Contributor License Agreement](.github/CLA.md)
+when prompted by the `CLA check`.
+
 Please check:
 
 - [CONTRIBUTING.md](CONTRIBUTING.md)

{opensportslib-0.3.1.dev19 → opensportslib-0.3.1.dev21/opensportslib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensportslib
-Version: 0.3.1.dev19
+Version: 0.3.1.dev21
 Summary: OpenSportsLib is the professional library, designed for advanced video understanding in sports. It provides state-of-the-art tools for action recognition, spotting, retrieval, and captioning, making it ideal for researchers, analysts, and developers working with sports video data.
 Author: Jeet Vora
 Requires-Python: >=3.12
@@ -114,8 +114,9 @@ It provides a unified framework to **train, evaluate, and run inference** for ke
 - **Action classification**
 - **Action localization / spotting**
 - **Visual Question Answering (VQA)**
-- **Action retrieval**
-- **Action description / captioning**
+
+Retrieval and action description/captioning are roadmap areas. They do not yet
+have first-class task wrappers or training workflows in this package.
 
 OpenSportsLib is designed for **researchers, ML engineers, and sports analytics teams** who want reproducible and extensible workflows for sports video AI.
 
@@ -622,6 +623,10 @@ opensportslib setup --vqa_qwen
 
 We welcome contributions to OpenSportsLib.
 
+All PRs must target `dev`. Before a PR can merge, every GitHub-linked commit
+author must accept the [Individual Contributor License Agreement](.github/CLA.md)
+when prompted by the `CLA check`.
+
 Please check:
 
 - [CONTRIBUTING.md](CONTRIBUTING.md)

{opensportslib-0.3.1.dev19 → opensportslib-0.3.1.dev21}/opensportslib.egg-info/SOURCES.txt

@@ -149,6 +149,8 @@ scripts/redact_test_stream.py
 scripts/release_versions.py
 scripts/run_h5_header_rule_inference.py
 scripts/summarize_test_report.py
+scripts/verify_release_manifests.py
+scripts/write_release_manifest.py
 tests/__init__.py
 tests/conftest.py
 tests/helpers/__init__.py
@@ -210,6 +212,7 @@ tests/unit/models/test_vqa_xvars_videochatgpt.py
 tests/unit/tools/test_conversion.py
 tests/unit/tools/test_extract_xvars_features.py
 tests/unit/tools/test_hf_transfer.py
+tests/unit/tools/test_release_manifest.py
 tests/unit/tools/test_report_summary.py
 tests/unit/tools/test_setup.py
 tools/convert/build_sn_vqa_2026_vqa.py

{opensportslib-0.3.1.dev19 → opensportslib-0.3.1.dev21}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opensportslib"
-version = "0.3.1.dev19"
+version = "0.3.1.dev21"
 description = "OpenSportsLib is the professional library, designed for advanced video understanding in sports. It provides state-of-the-art tools for action recognition, spotting, retrieval, and captioning, making it ideal for researchers, analysts, and developers working with sports video data."
 readme = "README.md"
 requires-python = ">=3.12"

opensportslib-0.3.1.dev21/scripts/verify_release_manifests.py

@@ -0,0 +1,32 @@
+"""Verify the Qwen, X-VARS, and GAR release manifests describe one passing commit."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+
+REQUIRED_PROFILES = {"qwen", "xvars", "gar"}
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("manifests", nargs="+", help="release-manifest.json paths copied from release servers")
+    args = parser.parse_args()
+    records = [json.loads(Path(path).read_text(encoding="utf-8")) for path in args.manifests]
+    profiles = {record.get("profile") for record in records}
+    commits = {record.get("commit") for record in records}
+    failed = [record.get("profile") for record in records if record.get("result") != "passed"]
+    if profiles != REQUIRED_PROFILES:
+        raise SystemExit(f"Expected manifests for {sorted(REQUIRED_PROFILES)}, got {sorted(profiles)}.")
+    if len(commits) != 1 or "unknown" in commits:
+        raise SystemExit(f"Release manifests must identify one known commit, got {sorted(commits)}.")
+    if failed:
+        raise SystemExit(f"Release profiles failed: {failed}.")
+    print(f"Release manifests verified for commit {next(iter(commits))}: {', '.join(sorted(profiles))}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

opensportslib-0.3.1.dev21/scripts/write_release_manifest.py

@@ -0,0 +1,50 @@
+"""Write one non-secret, commit-bound release profile manifest."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--report-dir", required=True)
+    parser.add_argument("--profile", required=True, choices=("qwen", "xvars", "gar"))
+    parser.add_argument("--scale", required=True, choices=("full", "bounded"))
+    parser.add_argument("--exit-code", required=True, type=int)
+    args = parser.parse_args()
+
+    try:
+        commit = subprocess.check_output(
+            ["git", "rev-parse", "HEAD"], text=True, stderr=subprocess.DEVNULL
+        ).strip()
+    except subprocess.CalledProcessError:
+        commit = "unknown"
+    report_dir = Path(args.report_dir)
+    metadata = report_dir / "release-metadata.jsonl"
+    records = []
+    if metadata.exists():
+        for line in metadata.read_text(encoding="utf-8").splitlines():
+            if line.strip():
+                records.append(json.loads(line))
+    manifest = {
+        "created_at": datetime.now(timezone.utc).isoformat(),
+        "commit": commit,
+        "profile": args.profile,
+        "scale": args.scale,
+        "result": "passed" if args.exit_code == 0 else "failed",
+        "exit_code": args.exit_code,
+        "metadata_records": records,
+    }
+    (report_dir / "release-manifest.json").write_text(
+        json.dumps(manifest, indent=2, sort_keys=True, default=str) + "\n",
+        encoding="utf-8",
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{opensportslib-0.3.1.dev19 → opensportslib-0.3.1.dev21}/tests/conftest.py

@@ -28,6 +28,7 @@ MARKERS = {
     "vqa": "Visual-question-answering task coverage.",
     "vqa_qwen": "Requires the Qwen VQA dependency profile.",
     "vqa_xvars": "Requires the X-VARS VQA dependency profile.",
+    "release_gar": "SoccerNet-GAR/PyG release profile.",
 }
 
 

{opensportslib-0.3.1.dev19 → opensportslib-0.3.1.dev21}/tests/release/_release_common.py

@@ -15,6 +15,8 @@ from __future__ import annotations
 import importlib.util
 import json
 import os
+import subprocess
+import sys
 from copy import deepcopy
 from pathlib import Path
 from typing import Any
@@ -24,6 +26,9 @@ import pytest
 REPO_ROOT = Path(__file__).resolve().parents[2]
 
 RELEASE_ENV_FLAG = "RUN_OSL_RELEASE_TESTS"
+RELEASE_SCALE_ENV = "OSL_RELEASE_SCALE"
+RELEASE_PROFILE_ENV = "OSL_RELEASE_PROFILE"
+RELEASE_PROFILES = {"qwen", "xvars", "gar"}
 
 # Where materialized configs / run outputs (checkpoints, logs, predictions)
 # are cached. Override with OSL_RELEASE_CACHE_DIR to point at a disk with
@@ -111,15 +116,42 @@ def _env_int(name: str, default: int) -> int:
     return int(raw)
 
 
-def epochs_for(default: int) -> int:
-    """TRAIN.epochs override. OSL_RELEASE_EPOCHS=0 means 'keep config default'."""
-    value = _env_int("OSL_RELEASE_EPOCHS", default)
-    return default if value == 0 else value
+def release_scale() -> str:
+    """Return ``full`` (the release default) or explicit bounded debug mode."""
+    value = os.environ.get(RELEASE_SCALE_ENV, "full").strip().lower()
+    if value not in {"full", "bounded"}:
+        raise ValueError(f"{RELEASE_SCALE_ENV} must be 'full' or 'bounded', got {value!r}.")
+    return value
+
+
+def release_profile() -> str:
+    value = os.environ.get(RELEASE_PROFILE_ENV, "qwen").strip().lower()
+    if value not in RELEASE_PROFILES:
+        raise ValueError(f"{RELEASE_PROFILE_ENV} must be one of {sorted(RELEASE_PROFILES)}, got {value!r}.")
+    return value
+
+
+def training_overrides(bounded_default: int) -> dict[str, int]:
+    """Return an epoch override only when the caller explicitly requests one.
+
+    Full release runs preserve the canonical preset schedule. ``0`` has the
+    same preserve-default meaning; bounded mode retains the previous small
+    release schedule unless an explicit positive override is supplied.
+    """
+    raw = os.environ.get("OSL_RELEASE_EPOCHS")
+    if raw is not None and raw != "":
+        value = int(raw)
+        if value < 0:
+            raise ValueError("OSL_RELEASE_EPOCHS must be zero or a positive integer.")
+        return {} if value == 0 else {"epochs": value}
+    return {"epochs": bounded_default} if release_scale() == "bounded" else {}
 
 
 def max_items_for(env_name: str, default: int | None) -> int | None:
     """Generic dataset-subset-size override. 0 (or 'all') means 'download everything'."""
     raw = os.environ.get(env_name)
+    if (raw is None or raw == "") and release_scale() == "full":
+        return None
     if raw is None or raw == "":
         return default
     if raw.strip().lower() == "all":
@@ -289,6 +321,7 @@ def snapshot_dataset(
     local_dir: Path,
     *,
     allow_patterns: list[str] | None = None,
+    revision: str = "main",
 ) -> Path:
     """Download (or update) a full dataset repo, or a pattern-restricted
     subset of it, into local_dir. Safe to call repeatedly (resumable)."""
@@ -301,10 +334,52 @@ def snapshot_dataset(
         local_dir=str(local_dir),
         token=hf_token(),
         allow_patterns=allow_patterns,
+        revision=revision,
     )
     return local_dir
 
 
+def require_model_repo(repo_id: str) -> None:
+    """Fail with release remediation when a published model cannot be read."""
+    require_repo_access(repo_id, repo_type="model")
+
+
+def download_model_snapshot(repo_id: str, local_dir: Path, *, revision: str = "main") -> Path:
+    """Download/cache a model repository and write non-secret provenance."""
+    from huggingface_hub import snapshot_download
+
+    local_dir.mkdir(parents=True, exist_ok=True)
+    path = Path(snapshot_download(
+        repo_id=repo_id, repo_type="model", revision=revision,
+        local_dir=str(local_dir), token=hf_token(),
+    ))
+    record_release_metadata("model", repo_id=repo_id, revision=revision, local_path=str(path))
+    return path
+
+
+def run_xvars_preprocessing(dataset_root: Path, output_root: Path, *, weights_path: Path) -> None:
+    """Run the project-owned X-VARS feature and index builders once per cache."""
+    marker = output_root / ".osl_xvars_prepared.json"
+    if marker.exists():
+        record_release_metadata("xvars_preprocess", status="cached", marker=str(marker))
+        return
+    output_root.mkdir(parents=True, exist_ok=True)
+    extractor = REPO_ROOT / "tools" / "convert" / "extract_xvars_clip_features.py"
+    indexer = REPO_ROOT / "tools" / "convert" / "build_xvars_indexes.py"
+    command = [
+        sys.executable, str(extractor), "--dataset-root", str(dataset_root),
+        "--dataset-output-root", str(output_root), "--mode", "strict_xvars",
+        "--weights-path", str(weights_path),
+    ]
+    subprocess.check_call(command)
+    subprocess.check_call([
+        sys.executable, str(indexer), "--dataset-root", str(dataset_root),
+        "--features-root", str(output_root),
+    ])
+    marker.write_text(json.dumps({"weights_path": str(weights_path)}), encoding="utf-8")
+    record_release_metadata("xvars_preprocess", status="complete", output_root=str(output_root))
+
+
 def download_files(repo_id: str, filenames: list[str], local_dir: Path) -> list[Path]:
     from huggingface_hub import hf_hub_download
 

{opensportslib-0.3.1.dev19 → opensportslib-0.3.1.dev21}/tests/release/test_00_environment.py

@@ -6,7 +6,7 @@ import importlib.util
 
 import pytest
 
-from tests.release._release_common import require_release_enabled
+from tests.release._release_common import release_profile, require_release_enabled
 
 
 pytestmark = [pytest.mark.release, pytest.mark.gpu]
@@ -19,10 +19,20 @@ def test_release_environment_has_cuda_and_required_training_packages():
     assert torch.cuda.is_available(), "Release verification requires an accessible CUDA GPU."
     assert torch.cuda.device_count() >= 1, "CUDA reported available but exposed no devices."
 
-    required = {
-        "nvidia.dali": "run `opensportslib setup --dali`",
-        "peft": "run `opensportslib setup --vqa_qwen`",
-        "trl": "run `opensportslib setup --vqa_qwen`",
-    }
+    profile = release_profile()
+    required = {}
+    if profile == "qwen":
+        required.update({
+            "peft": "run `opensportslib setup --vqa_qwen`",
+            "nvidia.dali": "run `opensportslib setup --dali`",
+            "trl": "run `opensportslib setup --vqa_qwen`",
+        })
+    elif profile == "xvars":
+        required.update({
+            "peft": "run `opensportslib setup --vqa_xvars`",
+            "trl": "run `opensportslib setup --vqa_xvars`",
+        })
+    elif profile == "gar":
+        required["torch_geometric"] = "run `opensportslib setup --pyg` on a supported platform"
     missing = [f"{name} ({hint})" for name, hint in required.items() if importlib.util.find_spec(name) is None]
     assert not missing, "Release environment is missing required packages: " + ", ".join(missing)

{opensportslib-0.3.1.dev19 → opensportslib-0.3.1.dev21}/tests/release/test_classification_release.py

@@ -66,7 +66,7 @@ from ._release_common import (
     DATA_DIR,
     classes_from_osl_json,
     download_shard_split,
-    epochs_for,
+    training_overrides,
     materialize_config,
     max_items_for,
     prefer_osl_ready_dataset,
@@ -93,6 +93,8 @@ CLS_PRIMARY_REPO = os.environ.get("OSL_RELEASE_CLS_REPO", "OpenSportsLab/OSL-XFo
 CLS_PRIMARY_REVISION = os.environ.get("OSL_RELEASE_CLS_REVISION", "224p")
 CLS_FALLBACK_REPO = os.environ.get("OSL_RELEASE_CLS_FALLBACK_REPO", "OpenSportsLab/OSL-cls-UEFA-fouls")
 TRACKING_CLS_REPO = os.environ.get("OSL_RELEASE_TRACKING_CLS_REPO", "OpenSportsLab/SoccerNet-GAR")
+TRACKING_CLS_REVISION = os.environ.get("OSL_RELEASE_TRACKING_CLS_REVISION", "tracking")
+PUBLISHED_CLASSIFICATION_MODEL = "OpenSportsLab/OSL-cls-action-mvitv2"
 
 os.environ.setdefault("WANDB_MODE", "disabled")
 os.environ.setdefault("OSL_PRETRAINED_WEIGHTS", "0")
@@ -321,8 +323,9 @@ def _run_classification_pipeline(config_path: str, dataset: dict, run_name: str)
         config_path=config_path, checkpoint_path=str(checkpoint),
     )
 
-    report_step(f"[{run_name}] infer()")
-    predictions = model.infer(test_set=str(split_paths["test"]), weights=checkpoint, use_wandb=False)
+    report_step(f"[{run_name}] fresh checkpoint load + infer()")
+    restored_model = ClassificationModel(config=config_path, weights=checkpoint)
+    predictions = restored_model.infer(test_set=str(split_paths["test"]), use_wandb=False)
     assert isinstance(predictions, dict) and predictions.get("data"), f"[{run_name}] empty predictions"
 
     report_step(f"[{run_name}] save_predictions()")
@@ -332,7 +335,7 @@ def _run_classification_pipeline(config_path: str, dataset: dict, run_name: str)
     record_release_metadata("prediction", task="classification", model_family=run_name, prediction_path=str(pred_path))
 
     report_step(f"[{run_name}] evaluate()")
-    metrics = model.evaluate(test_set=str(split_paths["test"]), use_wandb=False)
+    metrics = restored_model.evaluate(test_set=str(split_paths["test"]), predictions=predictions, use_wandb=False)
     assert isinstance(metrics, dict), f"[{run_name}] evaluate() did not return metrics"
     record_release_metadata(
         "result", task="classification", model_family=run_name,
@@ -341,6 +344,30 @@ def _run_classification_pipeline(config_path: str, dataset: dict, run_name: str)
     print(f"[{run_name}] metrics: {metrics}")
 
 
+@pytest.mark.release
+def test_published_classification_model_inference(classification_dataset):
+    """Published model artifact must load with its canonical inference path."""
+    require_release_enabled()
+    from ._release_common import require_model_repo
+
+    require_model_repo(PUBLISHED_CLASSIFICATION_MODEL)
+    dataset = classification_dataset
+    overrides = system_block("published_classification_mvitv2")
+    overrides["DATA"] = {
+        "common": {
+            "data_root": str(dataset["data_root"]), "classes": dataset["classes"],
+            "splits": {split: {"annotation_path": str(path), "source_path": str(dataset["source_paths"][split])}
+                       for split, path in dataset["split_paths"].items()},
+        }
+    }
+    config_path = materialize_config("classification", "video", overrides, out_name="published_cls_mvitv2.yaml")
+    model = ClassificationModel(config=config_path, weights=PUBLISHED_CLASSIFICATION_MODEL)
+    predictions = model.infer(test_set=str(dataset["split_paths"]["test"]), use_wandb=False)
+    assert isinstance(predictions, dict) and predictions.get("data")
+    metrics = model.evaluate(test_set=str(dataset["split_paths"]["test"]), predictions=predictions, use_wandb=False)
+    record_release_metadata("published_model_result", task="classification", model_id=PUBLISHED_CLASSIFICATION_MODEL, metrics=metrics)
+
+
 @pytest.mark.release
 @pytest.mark.parametrize("backbone", MVNETWORK_BACKBONES)
 def test_classification_mvnetwork_backbone(classification_dataset, backbone):
@@ -375,7 +402,7 @@ def test_classification_mvnetwork_backbone(classification_dataset, backbone):
             "task_head": {"params": {"num_classes": len(dataset["classes"])}},
         }
     }
-    overrides["TRAIN"] = {"epochs": epochs_for(2)}
+    overrides["TRAIN"] = training_overrides(2)
 
     config_path = materialize_config("classification", "video", overrides, out_name=f"cls_{backbone}.yaml")
     _run_classification_pipeline(config_path, dataset, backbone)
@@ -421,7 +448,7 @@ def test_classification_video_mae_huggingface_backend(classification_dataset):
             "task_head": {"params": {"num_classes": len(dataset["classes"])}},
         }
     }
-    overrides["TRAIN"] = {"epochs": epochs_for(2)}
+    overrides["TRAIN"] = training_overrides(2)
 
     config_path = materialize_config("classification", "video", overrides, out_name="cls_video_mae.yaml")
     _run_classification_pipeline(config_path, dataset, "video_mae")
@@ -480,9 +507,9 @@ def tracking_classification_dataset():
 
     require_release_enabled()
     require_repo_access(TRACKING_CLS_REPO)
-    require_repo_populated(TRACKING_CLS_REPO)
-    root = DATA_DIR / "classification" / TRACKING_CLS_REPO.split("/")[-1]
-    snapshot_dataset(TRACKING_CLS_REPO, root)
+    require_repo_populated(TRACKING_CLS_REPO, revision=TRACKING_CLS_REVISION)
+    root = DATA_DIR / "classification" / f"{TRACKING_CLS_REPO.split('/')[-1]}-{TRACKING_CLS_REVISION}"
+    snapshot_dataset(TRACKING_CLS_REPO, root, revision=TRACKING_CLS_REVISION)
     split_paths = {}
     for split in ("train", "valid", "test"):
         candidates = sorted(root.rglob(f"*{split}*.json"))
@@ -500,6 +527,7 @@ def tracking_classification_dataset():
 
 
 @pytest.mark.release
+@pytest.mark.release_gar
 def test_classification_tracking_graph_conv(tracking_classification_dataset):
     """Tracking-modality classification (graph_conv backbone,
     classification/sngar_tracking.yaml canonical config). Uses
@@ -521,7 +549,7 @@ def test_classification_tracking_graph_conv(tracking_classification_dataset):
         "inputs": {"video": {"params": {"max_samples": max_items_for("OSL_RELEASE_MAX_CLIPS", 40)}}},
     }
     overrides["MODEL"] = {"components": {"task_head": {"params": {"num_classes": len(dataset["classes"])}}}}
-    overrides["TRAIN"] = {"epochs": epochs_for(1)}
+    overrides["TRAIN"] = training_overrides(1)
     config_path = materialize_config(
         "classification", "sngar_tracking", overrides, out_name="cls_graph_conv.yaml"
     )
@@ -555,7 +583,7 @@ def test_classification_frames_npy_backbones(frames_npy_dataset, backbone):
         "video_adapter": {"params": {"hidden_dim": hidden_dim}},
         "task_head": {"params": {"hidden_dim": hidden_dim, "num_classes": len(dataset["classes"])}},
     }}
-    overrides["TRAIN"] = {"epochs": epochs_for(1)}
+    overrides["TRAIN"] = training_overrides(1)
     config_path = materialize_config(
         "classification", "sngar_frames", overrides, out_name=f"cls_frames_{backbone}.yaml"
     )

{opensportslib-0.3.1.dev19 → opensportslib-0.3.1.dev21}/tests/release/test_localization_release.py

@@ -55,7 +55,7 @@ from ._release_common import (
     classes_from_osl_json,
     download_files,
     download_shard_split,
-    epochs_for,
+    training_overrides,
     hf_token,
     materialize_config,
     max_items_for,
@@ -63,6 +63,7 @@ from ._release_common import (
     prefer_osl_ready_dataset,
     report_step,
     record_release_metadata,
+    release_scale,
     require_release_enabled,
     require_repo_access,
     snapshot_dataset,
@@ -98,6 +99,7 @@ E2E_FALLBACK_REPO = os.environ.get("OSL_RELEASE_LOC_E2E_FALLBACK_REPO", "OpenSpo
 # the (non-sharded, 2210-file) SoccerNet-ActionSpotting-Features dataset only
 # if that branch isn't up.
 FEATURES_PRIMARY_REPO = os.environ.get("OSL_RELEASE_LOC_FEATURES_REPO", "OpenSportsLab/OSL-SoccerNet")
+PUBLISHED_LOCALIZATION_MODEL = "OpenSportsLab/OSL-loc-snbas-2025-e2e"
 FEATURES_PRIMARY_REVISION = os.environ.get("OSL_RELEASE_LOC_FEATURES_REVISION", "ResNET_PCA512")
 FEATURES_FALLBACK_REPO = os.environ.get(
     "OSL_RELEASE_LOC_FEATURES_FALLBACK_REPO", "OpenSportsLab/SoccerNet-ActionSpotting-Features"
@@ -200,10 +202,10 @@ def _e2e_overrides(run_name: str, dataset: dict, backbone: str, head: str, *, lo
             "task_head": {"source": {"name": head}},
         }
     }
-    overrides["TRAIN"] = {
-        "epochs": epochs_for(2),
-        "scheduler": {"num_epochs": epochs_for(2)},
-    }
+    train_overrides = training_overrides(2)
+    overrides["TRAIN"] = train_overrides
+    if "epochs" in train_overrides:
+        overrides["TRAIN"]["scheduler"] = {"num_epochs": train_overrides["epochs"]}
     return overrides
 
 
@@ -226,8 +228,9 @@ def _run_localization_pipeline(config_path: str, dataset: dict, run_name: str) -
         config_path=config_path, checkpoint_path=str(checkpoint),
     )
 
-    report_step(f"[{run_name}] infer()")
-    predictions = model.infer(test_set=str(split_paths["test"]), weights=checkpoint, use_wandb=False)
+    report_step(f"[{run_name}] fresh checkpoint load + infer()")
+    restored_model = LocalizationModel(config=config_path, weights=checkpoint)
+    predictions = restored_model.infer(test_set=str(split_paths["test"]), use_wandb=False)
     assert isinstance(predictions, dict) and predictions.get("data"), f"[{run_name}] empty predictions"
 
     report_step(f"[{run_name}] save_predictions()")
@@ -237,7 +240,7 @@ def _run_localization_pipeline(config_path: str, dataset: dict, run_name: str) -
     record_release_metadata("prediction", task="localization", model_family=run_name, prediction_path=str(pred_path))
 
     report_step(f"[{run_name}] evaluate()")
-    metrics = model.evaluate(test_set=str(split_paths["test"]), use_wandb=False)
+    metrics = restored_model.evaluate(test_set=str(split_paths["test"]), predictions=predictions, use_wandb=False)
     record_release_metadata(
         "result", task="localization", model_family=run_name,
         runtime_seconds=round(time.perf_counter() - started, 3),
@@ -245,6 +248,22 @@ def _run_localization_pipeline(config_path: str, dataset: dict, run_name: str) -
     print(f"[{run_name}] metrics: {metrics}")
 
 
+@pytest.mark.release
+def test_published_localization_model_inference(e2e_localization_dataset):
+    require_release_enabled()
+    from ._release_common import require_model_repo
+
+    require_model_repo(PUBLISHED_LOCALIZATION_MODEL)
+    dataset = e2e_localization_dataset
+    overrides = _e2e_overrides("published_loc_e2e", dataset, "rny008_gsm", "gru", loader_backend="dali")
+    config_path = materialize_config("localization", "video_dali", overrides, out_name="published_loc_e2e.yaml")
+    model = LocalizationModel(config=config_path, weights=PUBLISHED_LOCALIZATION_MODEL)
+    predictions = model.infer(test_set=str(dataset["split_paths"]["test"]), use_wandb=False)
+    assert isinstance(predictions, dict) and predictions.get("data")
+    metrics = model.evaluate(test_set=str(dataset["split_paths"]["test"]), predictions=predictions, use_wandb=False)
+    record_release_metadata("published_model_result", task="localization", model_id=PUBLISHED_LOCALIZATION_MODEL, metrics=metrics)
+
+
 # Curated backbone x head coverage. Full cross product of every
 # backbone_type/head_type check_config() allows (see opensportslib/core/utils/
 # load_annotations.py::check_config) would be 9 backbones x 4 heads = 36 runs;
@@ -253,7 +272,11 @@ def _run_localization_pipeline(config_path: str, dataset: dict, run_name: str) -
 # coverage on a dedicated release-test machine.
 E2E_BACKBONES = ["rn18", "rn50", "rny002", "rny008_gsm", "convnextt"]
 E2E_HEADS = ["gru", "deeper_gru", "mstcn", "asformer"]
-E2E_MATRIX = [(b, "gru") for b in E2E_BACKBONES] + [("rn18", h) for h in E2E_HEADS if h != "gru"]
+E2E_MATRIX = (
+    [(backbone, head) for backbone in E2E_BACKBONES for head in E2E_HEADS]
+    if release_scale() == "full"
+    else [(b, "gru") for b in E2E_BACKBONES] + [("rn18", h) for h in E2E_HEADS if h != "gru"]
+)
 
 
 @pytest.mark.release
@@ -364,7 +387,7 @@ def _feature_family_overrides(run_name: str, dataset: dict) -> dict:
             },
         },
     }
-    overrides["TRAIN"] = {"epochs": epochs_for(3)}
+    overrides["TRAIN"] = training_overrides(3)
     return overrides