opensportslib 0.3.0.dev4__tar.gz → 0.3.0.dev5__tar.gz

{opensportslib-0.3.0.dev4/opensportslib.egg-info → opensportslib-0.3.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensportslib
-Version: 0.3.0.dev4
+Version: 0.3.0.dev5
 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

{opensportslib-0.3.0.dev4 → opensportslib-0.3.0.dev5}/opensportslib/apis/localization.py

@@ -19,6 +19,7 @@ from opensportslib.core.config.accessors import (
     get_model_family,
 )
 from opensportslib.core.utils.config import expand
+from opensportslib.core.config.loader import _dali_available
 
 
 class LocalizationModel(BaseTaskModel):
@@ -126,7 +127,7 @@ class LocalizationModel(BaseTaskModel):
         from opensportslib.core.utils.config import select_device
 
         device = select_device(self.config.SYSTEM)
-        backend = "dali" if self._device_type(device) == "cuda" else "opencv"
+        backend = "dali" if self._device_type(device) == "cuda" and _dali_available() else "opencv"
         current_backend = get_loader_backend(self.config)
         set_loader_backend(self.config, backend)
 

{opensportslib-0.3.0.dev4 → opensportslib-0.3.0.dev5}/opensportslib/core/config/loader.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import importlib.util
 import json
 from copy import deepcopy
 from pathlib import Path
@@ -135,12 +136,36 @@ def load_raw_config(path: str | Path) -> dict[str, Any]:
     raise ValueError("Unsupported config format. Use YAML or JSON.")
 
 
-def _normalize_cpu_loader_backend(payload: dict[str, Any]) -> dict[str, Any]:
+def _torch_cuda_available() -> bool:
+    try:
+        import torch
+    except Exception:
+        return False
+    return bool(torch.cuda.is_available())
+
+
+def _dali_available() -> bool:
+    return importlib.util.find_spec("nvidia.dali") is not None
+
+
+def _preferred_loader_backend(payload: dict[str, Any]) -> str | None:
     system = payload.get("SYSTEM", {})
     if not isinstance(system, dict):
-        return payload
+        return None
 
-    if str(system.get("device", "auto")).lower() != "cpu":
+    mode = str(system.get("device", "auto")).lower()
+    if mode == "cpu":
+        return "opencv"
+    if mode == "cuda":
+        return "dali" if _dali_available() else "opencv"
+    if mode == "auto":
+        return "dali" if (_torch_cuda_available() and _dali_available()) else "opencv"
+    return None
+
+
+def _normalize_cpu_loader_backend(payload: dict[str, Any]) -> dict[str, Any]:
+    preferred_backend = _preferred_loader_backend(payload)
+    if preferred_backend is None:
         return payload
 
     data = payload.get("DATA", {})
@@ -155,18 +180,19 @@ def _normalize_cpu_loader_backend(payload: dict[str, Any]) -> dict[str, Any]:
     if not isinstance(runtime, dict):
         runtime = {}
         common["runtime"] = runtime
-    runtime["loader_backend"] = "opencv"
+    runtime["loader_backend"] = preferred_backend
 
     splits = common.get("splits", {})
     if not isinstance(splits, dict):
         return payload
 
-    for split_cfg in splits.values():
-        if not isinstance(split_cfg, dict):
-            continue
-        split_type = split_cfg.get("type")
-        if split_type in _CPU_OPENCV_SPLIT_TYPES:
-            split_cfg["type"] = _CPU_OPENCV_SPLIT_TYPES[split_type]
+    if preferred_backend == "opencv":
+        for split_cfg in splits.values():
+            if not isinstance(split_cfg, dict):
+                continue
+            split_type = split_cfg.get("type")
+            if split_type in _CPU_OPENCV_SPLIT_TYPES:
+                split_cfg["type"] = _CPU_OPENCV_SPLIT_TYPES[split_type]
 
     return payload
 

{opensportslib-0.3.0.dev4 → opensportslib-0.3.0.dev5/opensportslib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensportslib
-Version: 0.3.0.dev4
+Version: 0.3.0.dev5
 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

{opensportslib-0.3.0.dev4 → opensportslib-0.3.0.dev5}/opensportslib.egg-info/SOURCES.txt

@@ -152,6 +152,7 @@ tests/test_h5_header_skeleton_spotter.py
 tests/test_h5_tracking_dataset.py
 tests/test_hf_transfer_tools.py
 tests/test_localization_dali_filenames.py
+tests/test_localization_hf_backend_override.py
 tests/test_package_smoke.py
 tests/test_pretrained_config_merge_policy.py
 tests/test_public_apis_smoke.py

{opensportslib-0.3.0.dev4 → opensportslib-0.3.0.dev5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opensportslib"
-version = "0.3.0.dev4"
+version = "0.3.0.dev5"
 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.0.dev4 → opensportslib-0.3.0.dev5}/tests/test_config_architecture.py

@@ -81,7 +81,7 @@ def test_localization_experiment_composes_all_layers():
     assert cfg["SYSTEM"]["paths"]["log_dir"] == "./logs"
     assert cfg["SYSTEM"]["paths"]["save_dir"] == "./checkpoints"
     assert cfg["SYSTEM"]["paths"]["work_dir"] == "./checkpoints"
-    assert cfg["DATA"]["common"]["runtime"]["loader_backend"] == "dali"
+    assert cfg["DATA"]["common"]["runtime"]["loader_backend"] in {"dali", "opencv"}
     assert cfg["MODEL"]["components"]["video_encoder"]["source"]["name"] == "rny008_gsm"
 
 
@@ -99,6 +99,20 @@ def test_resolve_config_cpu_normalizes_canonical_dali_localization_config():
     assert resolved["DATA"]["common"]["splits"]["test"]["type"] == "VideoGameWithOpencvVideo"
 
 
+def test_resolve_config_cuda_without_dali_normalizes_to_opencv(monkeypatch):
+    cfg = load_config("opensportslib/configs/localization/video_dali.yaml", as_namespace=False)
+    cfg["SYSTEM"]["device"] = "cuda"
+
+    monkeypatch.setattr("opensportslib.core.config.loader._dali_available", lambda: False)
+
+    resolved = resolve_config(cfg, as_namespace=False)
+
+    assert resolved["DATA"]["common"]["runtime"]["loader_backend"] == "opencv"
+    assert resolved["DATA"]["common"]["splits"]["train"]["type"] == "VideoGameWithOpencv"
+    assert resolved["DATA"]["common"]["splits"]["valid"]["type"] == "VideoGameWithOpencv"
+    assert resolved["DATA"]["common"]["splits"]["test"]["type"] == "VideoGameWithOpencvVideo"
+
+
 def test_vqa_xvars_experiment_composes_all_layers():
     cfg = load_config("opensportslib/configs/vqa/xvars.yaml", as_namespace=False)
 

opensportslib-0.3.0.dev5/tests/test_localization_hf_backend_override.py

@@ -0,0 +1,205 @@
+import os
+import sys
+from types import ModuleType, SimpleNamespace
+
+from opensportslib.apis.localization import LocalizationModel
+from opensportslib.core.config.accessors import get_loader_backend
+
+
+def _split(split_type, batch_size=4, shuffle=False):
+    return SimpleNamespace(
+        type=split_type,
+        annotation_path="/tmp/annotations.json",
+        source_path="/tmp/data",
+        dataloader=SimpleNamespace(batch_size=batch_size, shuffle=shuffle),
+    )
+
+
+def _make_config(loader_backend="dali"):
+    return SimpleNamespace(
+        TASK="localization",
+        DATA=SimpleNamespace(
+            common=SimpleNamespace(
+                runtime=SimpleNamespace(loader_backend=loader_backend),
+                classes=["PASS", "SHOT"],
+                splits=SimpleNamespace(
+                    train=_split("VideoGameWithDali", shuffle=True),
+                    valid=_split("VideoGameWithDali", shuffle=True),
+                    test=_split("VideoGameWithDaliVideo"),
+                ),
+            ),
+            inputs=SimpleNamespace(
+                video=SimpleNamespace(
+                    modality="video",
+                    representation="raw",
+                    sampling=SimpleNamespace(),
+                    transform=SimpleNamespace(),
+                    params=SimpleNamespace(),
+                )
+            ),
+        ),
+        MODEL=SimpleNamespace(task="localization", components=SimpleNamespace(), topology=[]),
+        SYSTEM=SimpleNamespace(
+            device="cpu",
+            gpu=SimpleNamespace(count=0, id=0),
+            reproducibility=SimpleNamespace(seed=0, use_seed=False),
+            paths=SimpleNamespace(save_dir="/tmp", work_dir="/tmp", log_dir="/tmp"),
+        ),
+        TRAIN=SimpleNamespace(
+            execution=SimpleNamespace(multi_gpu=False),
+            trainer=SimpleNamespace(type="trainer_e2e"),
+        ),
+    )
+
+
+def _make_api(config):
+    api = LocalizationModel.__new__(LocalizationModel)
+    api.config = config
+    api.config_path = "/tmp/localization.yaml"
+    api.model = None
+    api.processor = None
+    api.trainer = None
+    api.last_loaded_weights = None
+    api.best_checkpoint = None
+    api.train_flag = False
+    return api
+
+
+def test_hf_localization_cpu_switches_to_opencv_and_normalizes_dataloader(monkeypatch):
+    api = _make_api(_make_config(loader_backend="dali"))
+    api.config = _make_config(loader_backend="dali")
+
+    monkeypatch.setattr(
+        "opensportslib.core.utils.config.select_device",
+        lambda system: SimpleNamespace(type="cpu"),
+    )
+
+    api._adapt_hf_backend_for_device("OpenSportsLab/OSL-loc-snbas-2025-e2e")
+
+    assert get_loader_backend(api.config) == "opencv"
+    assert api.config.DATA.common.splits.train.type == "VideoGameWithOpencv"
+    assert api.config.DATA.common.splits.valid.type == "VideoGameWithOpencv"
+    assert api.config.DATA.common.splits.test.type == "VideoGameWithOpencvVideo"
+    assert api.config.DATA.common.splits.valid.dataloader.num_workers == 0
+    assert api.config.DATA.common.splits.valid.dataloader.pin_memory is False
+
+
+def test_hf_localization_auto_cuda_switches_to_dali(monkeypatch):
+    api = _make_api(_make_config(loader_backend="opencv"))
+    api.config.DATA.common.splits.train.type = "VideoGameWithOpencv"
+    api.config.DATA.common.splits.valid.type = "VideoGameWithOpencv"
+    api.config.DATA.common.splits.test.type = "VideoGameWithOpencvVideo"
+    api.config.SYSTEM.device = "auto"
+
+    monkeypatch.setattr(
+        "opensportslib.core.utils.config.select_device",
+        lambda system: SimpleNamespace(type="cuda"),
+    )
+    monkeypatch.setattr("opensportslib.apis.localization._dali_available", lambda: True)
+
+    api._adapt_hf_backend_for_device("OpenSportsLab/OSL-loc-snbas-2023-e2e")
+
+    assert get_loader_backend(api.config) == "dali"
+    assert api.config.DATA.common.splits.train.type == "VideoGameWithDali"
+    assert api.config.DATA.common.splits.valid.type == "VideoGameWithDali"
+    assert api.config.DATA.common.splits.test.type == "VideoGameWithDaliVideo"
+
+
+def test_hf_localization_cuda_without_dali_falls_back_to_opencv(monkeypatch):
+    api = _make_api(_make_config(loader_backend="dali"))
+
+    monkeypatch.setattr(
+        "opensportslib.core.utils.config.select_device",
+        lambda system: SimpleNamespace(type="cuda"),
+    )
+    monkeypatch.setattr("opensportslib.apis.localization._dali_available", lambda: False)
+
+    api._adapt_hf_backend_for_device("OpenSportsLab/OSL-loc-snbas-2023-e2e")
+
+    assert get_loader_backend(api.config) == "opencv"
+    assert api.config.DATA.common.splits.train.type == "VideoGameWithOpencv"
+    assert api.config.DATA.common.splits.valid.type == "VideoGameWithOpencv"
+    assert api.config.DATA.common.splits.test.type == "VideoGameWithOpencvVideo"
+
+
+def test_local_weights_do_not_trigger_hf_backend_override(monkeypatch):
+    api = _make_api(_make_config(loader_backend="dali"))
+
+    monkeypatch.setattr(
+        "opensportslib.core.utils.config.select_device",
+        lambda system: SimpleNamespace(type="cpu"),
+    )
+
+    api._adapt_hf_backend_for_device("/tmp/model.pt")
+
+    assert get_loader_backend(api.config) == "dali"
+    assert api.config.DATA.common.splits.train.type == "VideoGameWithDali"
+    assert not hasattr(api.config.DATA.common.splits.valid.dataloader, "num_workers")
+
+
+def test_localization_infer_applies_hf_backend_override_before_dataset_build(
+    tmp_path,
+    monkeypatch,
+):
+    test_set = tmp_path / "test.json"
+    test_set.write_text("{}", encoding="utf-8")
+    observed = {}
+
+    class FakeData:
+        cfg = SimpleNamespace(dataloader=SimpleNamespace(batch_size=1, shuffle=False))
+        default_args = {}
+
+        def building_dataset(self, cfg, gpu, default_args):
+            del cfg, gpu, default_args
+            return ["dataset"]
+
+        def building_dataloader(self, dataset, cfg, gpu, dali):
+            del dataset, cfg, gpu
+            observed["dali"] = dali
+            return ["batch"]
+
+    class FakeInferer:
+        def infer(self, cfg, data, dataloader):
+            del data, dataloader
+            observed["backend"] = get_loader_backend(cfg)
+            observed["dataset_type"] = cfg.DATA.common.splits.test.type
+            return {"task": "localization"}
+
+    fake_load_annotations = ModuleType("opensportslib.core.utils.load_annotations")
+    fake_load_annotations.check_config = lambda config, split: None
+    fake_load_annotations.whether_infer_split = lambda test_cfg: False
+    monkeypatch.setitem(sys.modules, "opensportslib.core.utils.load_annotations", fake_load_annotations)
+
+    fake_localization_trainer = ModuleType("opensportslib.core.trainer.localization_trainer")
+    fake_localization_trainer.build_inferer = lambda cfg, model: FakeInferer()
+    monkeypatch.setitem(
+        sys.modules,
+        "opensportslib.core.trainer.localization_trainer",
+        fake_localization_trainer,
+    )
+
+    fake_builder = ModuleType("opensportslib.datasets.builder")
+    fake_builder.build_dataset = lambda config, split: FakeData()
+    monkeypatch.setitem(sys.modules, "opensportslib.datasets.builder", fake_builder)
+
+    fake_wandb = ModuleType("opensportslib.core.utils.wandb")
+    fake_wandb.init_wandb = lambda *args, **kwargs: None
+    monkeypatch.setitem(sys.modules, "opensportslib.core.utils.wandb", fake_wandb)
+
+    monkeypatch.setattr("opensportslib.core.utils.config.resolve_config_omega", lambda config, weights=None: config)
+    monkeypatch.setattr(
+        "opensportslib.core.utils.config.select_device",
+        lambda system: SimpleNamespace(type="cpu"),
+    )
+    monkeypatch.setattr(LocalizationModel, "load_weights", lambda self, weights=None, **kwargs: setattr(self, "model", object()))
+
+    api = _make_api(_make_config(loader_backend="dali"))
+    os.environ["RUN_ID"] = "test-run"
+    api.last_loaded_weights = "OpenSportsLab/OSL-loc-snbas-2025-e2e"
+
+    predictions = api.infer(test_set=str(test_set), use_wandb=False)
+
+    assert predictions == {"task": "localization"}
+    assert observed["backend"] == "opencv"
+    assert observed["dataset_type"] == "VideoGameWithOpencvVideo"
+    assert observed["dali"] is False