opensportslib 0.3.0.dev1__tar.gz → 0.3.0.dev3__tar.gz

{opensportslib-0.3.0.dev1/opensportslib.egg-info → opensportslib-0.3.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensportslib
-Version: 0.3.0.dev1
+Version: 0.3.0.dev3
 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.dev1 → opensportslib-0.3.0.dev3}/opensportslib/core/config/loader.py

@@ -20,6 +20,10 @@ from .runtime_adapter import maybe_namespace, namespace_to_plain_dict
 _YAML_SUFFIXES = {".yaml", ".yml"}
 _TASK_DIRS = {"classification", "localization", "vqa"}
 _INTERPOLATION_RE = re.compile(r"\$\{([^}]+)\}")
+_CPU_OPENCV_SPLIT_TYPES = {
+    "VideoGameWithDali": "VideoGameWithOpencv",
+    "VideoGameWithDaliVideo": "VideoGameWithOpencvVideo",
+}
 
 
 def _load_single_yaml(path: str | Path) -> Any:
@@ -131,6 +135,42 @@ 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]:
+    system = payload.get("SYSTEM", {})
+    if not isinstance(system, dict):
+        return payload
+
+    if str(system.get("device", "auto")).lower() != "cpu":
+        return payload
+
+    data = payload.get("DATA", {})
+    if not isinstance(data, dict):
+        return payload
+
+    common = data.get("common", {})
+    if not isinstance(common, dict):
+        return payload
+
+    runtime = common.get("runtime", {})
+    if not isinstance(runtime, dict):
+        runtime = {}
+        common["runtime"] = runtime
+    runtime["loader_backend"] = "opencv"
+
+    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]
+
+    return payload
+
+
 def load_config(
     config_path: str | Path,
     *,
@@ -139,6 +179,7 @@ def load_config(
 ) -> Any:
     raw = load_raw_config(config_path)
     canonical = migrate_config(raw, as_namespace=False)
+    canonical = _normalize_cpu_loader_backend(canonical)
     assert_no_legacy_aliases(canonical)
 
     if validate:
@@ -168,6 +209,7 @@ def resolve_config(
 ) -> Any:
     payload = namespace_to_plain_dict(config)
     canonical = migrate_config(payload, as_namespace=False)
+    canonical = _normalize_cpu_loader_backend(canonical)
     assert_no_legacy_aliases(canonical)
     return maybe_namespace(canonical, as_namespace=as_namespace)
 

opensportslib-0.3.0.dev3/opensportslib/tools/__init__.py

@@ -0,0 +1,76 @@
+"""OpenSportsLib dataset conversion and Hugging Face transfer tools."""
+
+from __future__ import annotations
+
+import importlib
+
+
+_EXPORTS = {
+    "convert_json_to_parquet": ("opensportslib.tools.osl_json_to_parquet", "convert_json_to_parquet"),
+    "DEFAULT_SHARD_SIZE": ("opensportslib.tools.osl_json_to_parquet", "DEFAULT_SHARD_SIZE"),
+    "parse_shard_size": ("opensportslib.tools.osl_json_to_parquet", "parse_shard_size"),
+    "convert_parquet_to_json": ("opensportslib.tools.parquet_to_osl_json", "convert_parquet_to_json"),
+    "convert_sn_vqa_2026_to_osl": ("opensportslib.tools.sn_vqa_2026_qwen_native", "convert_sn_vqa_2026_to_osl"),
+    "evaluate_sn_vqa_predictions": ("opensportslib.tools.sn_vqa_2026_qwen_native", "evaluate_sn_vqa_predictions"),
+    "HfTransferCancelled": ("opensportslib.tools.hf_transfer", "HfTransferCancelled"),
+    "HF_REPO_ID_KEY": ("opensportslib.tools.hf_transfer", "HF_REPO_ID_KEY"),
+    "HF_BRANCH_KEY": ("opensportslib.tools.hf_transfer", "HF_BRANCH_KEY"),
+    "HF_SPLIT_KEY": ("opensportslib.tools.hf_transfer", "HF_SPLIT_KEY"),
+    "download_dataset_split_from_hf": ("opensportslib.tools.hf_transfer", "download_dataset_split_from_hf"),
+    "upload_dataset_inputs_from_json_to_hf": ("opensportslib.tools.hf_transfer", "upload_dataset_inputs_from_json_to_hf"),
+    "upload_dataset_as_parquet_to_hf": ("opensportslib.tools.hf_transfer", "upload_dataset_as_parquet_to_hf"),
+    "create_dataset_repo_on_hf": ("opensportslib.tools.hf_transfer", "create_dataset_repo_on_hf"),
+    "dataset_repo_exists_on_hf": ("opensportslib.tools.hf_transfer", "dataset_repo_exists_on_hf"),
+    "create_dataset_branch_on_hf": ("opensportslib.tools.hf_transfer", "create_dataset_branch_on_hf"),
+    "read_hf_source_metadata_from_dataset": ("opensportslib.tools.hf_transfer", "read_hf_source_metadata_from_dataset"),
+    "write_hf_source_metadata_to_dataset_json": ("opensportslib.tools.hf_transfer", "write_hf_source_metadata_to_dataset_json"),
+    "is_hf_repo_not_found_error": ("opensportslib.tools.hf_transfer", "is_hf_repo_not_found_error"),
+    "is_hf_revision_not_found_error": ("opensportslib.tools.hf_transfer", "is_hf_revision_not_found_error"),
+    "is_hf_download_url_not_found_error": ("opensportslib.tools.hf_transfer", "is_hf_download_url_not_found_error"),
+    "get_json_repo_folder": ("opensportslib.tools.hf_transfer", "get_json_repo_folder"),
+    "extract_repo_paths_from_json": ("opensportslib.tools.hf_transfer", "extract_repo_paths_from_json"),
+    "extract_local_input_upload_entries_from_json": ("opensportslib.tools.hf_transfer", "extract_local_input_upload_entries_from_json"),
+}
+
+__all__ = [
+    "convert_json_to_parquet",
+    "DEFAULT_SHARD_SIZE",
+    "parse_shard_size",
+    "convert_parquet_to_json",
+    "convert_sn_vqa_2026_to_osl",
+    "evaluate_sn_vqa_predictions",
+    "HfTransferCancelled",
+    "HF_REPO_ID_KEY",
+    "HF_BRANCH_KEY",
+    "HF_SPLIT_KEY",
+    "download_dataset_split_from_hf",
+    "upload_dataset_inputs_from_json_to_hf",
+    "upload_dataset_as_parquet_to_hf",
+    "create_dataset_repo_on_hf",
+    "dataset_repo_exists_on_hf",
+    "create_dataset_branch_on_hf",
+    "read_hf_source_metadata_from_dataset",
+    "write_hf_source_metadata_to_dataset_json",
+    "is_hf_repo_not_found_error",
+    "is_hf_revision_not_found_error",
+    "is_hf_download_url_not_found_error",
+    "get_json_repo_folder",
+    "extract_repo_paths_from_json",
+    "extract_local_input_upload_entries_from_json",
+]
+
+
+def __getattr__(name: str):
+    try:
+        module_name, attr_name = _EXPORTS[name]
+    except KeyError as exc:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}") from exc
+
+    module = importlib.import_module(module_name)
+    value = getattr(module, attr_name)
+    globals()[name] = value
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(__all__))

{opensportslib-0.3.0.dev1 → opensportslib-0.3.0.dev3}/opensportslib/tools/hf_transfer.py

@@ -5,22 +5,58 @@ import tempfile
 from pathlib import Path
 from typing import Any, Callable
 
-from .osl_json_to_parquet import DEFAULT_SHARD_SIZE, convert_json_to_parquet, parse_shard_size
-from .parquet_to_osl_json import convert_parquet_to_json
-
-
 ProgressCallback = Callable[[str], None]
 CancelCheck = Callable[[], bool]
 
 HF_REPO_ID_KEY = "hf_repo_id"
 HF_BRANCH_KEY = "hf_branch"
 HF_SPLIT_KEY = "hf_split"
+DEFAULT_SHARD_SIZE = 1_000_000_000
 
 
 class HfTransferCancelled(RuntimeError):
     pass
 
 
+def _import_osl_json_to_parquet():
+    try:
+        from .osl_json_to_parquet import DEFAULT_SHARD_SIZE as module_default_shard_size
+        from .osl_json_to_parquet import convert_json_to_parquet as module_convert_json_to_parquet
+        from .osl_json_to_parquet import parse_shard_size as module_parse_shard_size
+    except ImportError as exc:
+        raise RuntimeError(
+            "Missing conversion dependencies for OSL JSON -> Parquet tools. "
+            "Install the package with its data-conversion dependencies, including 'pandas' and 'pyarrow'."
+        ) from exc
+    return module_default_shard_size, module_convert_json_to_parquet, module_parse_shard_size
+
+
+def _import_parquet_to_osl_json():
+    try:
+        from .parquet_to_osl_json import convert_parquet_to_json as module_convert_parquet_to_json
+    except ImportError as exc:
+        raise RuntimeError(
+            "Missing conversion dependencies for Parquet -> OSL JSON tools. "
+            "Install the package with its data-conversion dependencies, including 'pandas' and 'pyarrow'."
+        ) from exc
+    return module_convert_parquet_to_json
+
+
+def parse_shard_size(value: int | str) -> int:
+    _, _, module_parse_shard_size = _import_osl_json_to_parquet()
+    return module_parse_shard_size(value)
+
+
+def convert_json_to_parquet(*args, **kwargs):
+    _, module_convert_json_to_parquet, _ = _import_osl_json_to_parquet()
+    return module_convert_json_to_parquet(*args, **kwargs)
+
+
+def convert_parquet_to_json(*args, **kwargs):
+    module_convert_parquet_to_json = _import_parquet_to_osl_json()
+    return module_convert_parquet_to_json(*args, **kwargs)
+
+
 def _emit_progress(progress_cb: ProgressCallback | None, message: str) -> None:
     if progress_cb:
         progress_cb(message)

{opensportslib-0.3.0.dev1 → opensportslib-0.3.0.dev3/opensportslib.egg-info}/PKG-INFO

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

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

@@ -2,7 +2,7 @@ from pathlib import Path
 
 import pytest
 
-from opensportslib.core.config import load_config, migrate_config, validate_config
+from opensportslib.core.config import load_config, migrate_config, resolve_config, validate_config
 from opensportslib.core.config.accessors import (
     get_vqa_xvars_feature_mode,
     get_xvars_feature_token_len_for_mode,
@@ -85,6 +85,20 @@ def test_localization_experiment_composes_all_layers():
     assert cfg["MODEL"]["components"]["video_encoder"]["source"]["name"] == "rny008_gsm"
 
 
+def test_resolve_config_cpu_normalizes_canonical_dali_localization_config():
+    cfg = load_config("opensportslib/configs/localization/video_dali.yaml", as_namespace=False)
+    cfg["SYSTEM"]["device"] = "cpu"
+
+    resolved = migrate_config(cfg, as_namespace=False)
+    resolved = validate_config(resolved)
+    resolved = resolve_config(resolved, 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.dev1 → opensportslib-0.3.0.dev3}/tests/test_config_split_override_sync.py

@@ -35,3 +35,11 @@ def test_resolve_config_keeps_canonical_split_sources():
     cfg = resolve_config(migrate_config(_legacy_localization_cfg(), as_namespace=False), as_namespace=False)
     assert cfg["DATA"]["common"]["splits"]["valid"]["annotation_path"].endswith("valid.json")
     assert cfg["DATA"]["common"]["splits"]["valid_data_frames"]["annotation_path"].endswith("valid.json")
+
+
+def test_resolve_config_cpu_forces_opencv_backend_and_split_types():
+    cfg = resolve_config(migrate_config(_legacy_localization_cfg(), as_namespace=False), as_namespace=False)
+    assert cfg["DATA"]["common"]["runtime"]["loader_backend"] == "opencv"
+    assert cfg["DATA"]["common"]["splits"]["train"]["type"] == "VideoGameWithOpencv"
+    assert cfg["DATA"]["common"]["splits"]["valid"]["type"] == "VideoGameWithOpencv"
+    assert cfg["DATA"]["common"]["splits"]["valid_data_frames"]["type"] == "VideoGameWithOpencvVideo"