opensportslib 0.3.0.dev4__tar.gz → 0.3.0.dev6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensportslib
-Version: 0.3.0.dev4
+Version: 0.3.0.dev6
 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.dev6}/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.dev6}/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.dev6}/opensportslib/datasets/localization_dataset.py

@@ -74,6 +74,15 @@ def _build_dali_filenames_and_labels(labels):
     return filenames, label_indices
 
 
+def _normalize_dali_devices(devices, sample_count):
+    devices = list(devices or [])
+    if not devices:
+        return [0]
+    if sample_count <= 0:
+        return devices[:1]
+    return devices[: max(1, min(len(devices), int(sample_count)))]
+
+
 def _dali_frame_num_to_local_frame(frame_num, stride):
     return frame_num // stride + 1
 
@@ -1538,13 +1547,16 @@ if DALI_AVAILABLE:
             else:
                 self.batch_size = batch_size
 
-            self.batch_size_per_pipe = distribute_elements(self.batch_size, len(devices))
+            self._filenames, self._video_indices = _build_dali_filenames_and_labels(
+                self._labels
+            )
+            self.devices = _normalize_dali_devices(devices, len(self._filenames))
+            self.batch_size_per_pipe = distribute_elements(self.batch_size, len(self.devices))
 
             self.batch_size = batch_size
             self.nb_videos = dataset_len * 2 if mixup else dataset_len
             self.mixup = mixup
             self.output_map = output_map
-            self.devices = devices
             self.is_eval = is_eval
             self.crop_dim = crop_dim
             self.dilate_len = dilate_len
@@ -1555,9 +1567,6 @@ if DALI_AVAILABLE:
             self.TARGET_WIDTH = TARGET_WIDTH
 
             self._stride = get_stride(input_fps, extract_fps)
-            self._filenames, self._video_indices = _build_dali_filenames_and_labels(
-                self._labels
-            )
 
             self.pipes = [
                 self.video_pipe(
@@ -1570,9 +1579,9 @@ if DALI_AVAILABLE:
                     num_threads=8,
                     device_id=i,
                     shard_id=index,
-                    num_shards=len(devices),
+                    num_shards=len(self.devices),
                 )
-                for index, i in enumerate(devices)
+                for index, i in enumerate(self.devices)
             ]
 
             for pipe in self.pipes:
@@ -1931,16 +1940,16 @@ if DALI_AVAILABLE:
             self._stride_dali = stride_dali
             self._flip = flip
             self._multi_crop = multi_crop
-            self.batch_size = batch_size // len(devices)
+            self._filenames, self._video_indices = _build_dali_filenames_and_labels(
+                self._labels
+            )
+            self.devices = _normalize_dali_devices(devices, len(self._filenames))
+            self.batch_size = batch_size // len(self.devices)
             self.global_batch_size = batch_size
-            self.devices = devices
             self.IMAGENET_MEAN = IMAGENET_MEAN
             self.IMAGENET_STD = IMAGENET_STD
             self.TARGET_HEIGHT = TARGET_HEIGHT
             self.TARGET_WIDTH = TARGET_WIDTH
-            self._filenames, self._video_indices = _build_dali_filenames_and_labels(
-                self._labels
-            )
             clip_count = 0
             for video in self._labels:
                 num_clips = _count_dali_video_samples(
@@ -1961,9 +1970,9 @@ if DALI_AVAILABLE:
                     num_threads=8,
                     device_id=i,
                     shard_id=index,
-                    num_shards=len(devices),
+                    num_shards=len(self.devices),
                 )
-                for index, i in enumerate(devices)
+                for index, i in enumerate(self.devices)
             ]
 
             for pipe in self.pipes:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensportslib
-Version: 0.3.0.dev4
+Version: 0.3.0.dev6
 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.dev6}/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.dev6}/pyproject.toml

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

@@ -4,6 +4,7 @@ from opensportslib.datasets.localization_dataset import (
     _build_dali_filenames_and_labels,
     _count_dali_video_samples,
     _dali_frame_num_to_local_frame,
+    _normalize_dali_devices,
     _pad_dali_iterator_size,
     _resolve_dali_video_sample,
 )
@@ -56,4 +57,10 @@ def test_resolve_dali_video_sample_uses_relative_path_and_one_based_start():
     video_name, start = _resolve_dali_video_sample(labels, 0, 24, 12)
 
     assert video_name == "train/match one.mp4"
-    assert start == 3
+    assert start == 3
+
+
+def test_normalize_dali_devices_caps_shards_to_sample_count():
+    assert _normalize_dali_devices([0, 1, 2, 3], 1) == [0]
+    assert _normalize_dali_devices([0, 1, 2, 3], 2) == [0, 1]
+    assert _normalize_dali_devices([], 1) == [0]

opensportslib-0.3.0.dev6/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