opensportslib 0.1.2.dev7__tar.gz → 0.1.2.dev9__tar.gz

{opensportslib-0.1.2.dev7/opensportslib.egg-info → opensportslib-0.1.2.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensportslib
-Version: 0.1.2.dev7
+Version: 0.1.2.dev9
 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.1.2.dev7 → opensportslib-0.1.2.dev9}/opensportslib/apis/base_task_model.py

@@ -9,7 +9,7 @@ import uuid
 from abc import ABC, abstractmethod
 from typing import Any
 
-from opensportslib.core.utils.config import expand, load_config_omega
+from opensportslib.core.utils.config import expand, load_config_omega, fetch_and_merge_config_from_HF
 
 
 class BaseTaskModel(ABC):
@@ -24,6 +24,13 @@ class BaseTaskModel(ABC):
         self.config_path = expand(config)
         self.config = load_config_omega(self.config_path)
 
+        if weights is not None:
+            self.config = fetch_and_merge_config_from_HF(self.config, weights, merge_policy="compatibility")
+            self.last_loaded_weights = weights
+            self.best_checkpoint = weights
+
+        self.train_flag = False  # Flag to indicate whether we're in training mode (affects checkpoint loading behavior)
+
         data_cfg = getattr(self.config, "DATA", None)
         if data_cfg is not None and hasattr(data_cfg, "data_dir"):
             data_cfg.data_dir = expand(data_cfg.data_dir)

{opensportslib-0.1.2.dev7 → opensportslib-0.1.2.dev9}/opensportslib/apis/classification.py

@@ -8,7 +8,6 @@ import os
 from opensportslib.apis.base_task_model import BaseTaskModel
 from opensportslib.core.utils.config import expand
 
-
 class ClassificationModel(BaseTaskModel):
     """Top-level task wrapper for classification."""
 
@@ -172,8 +171,8 @@ class ClassificationModel(BaseTaskModel):
 
         train_set = self._resolve_split_path("train", train_set)
         valid_set = self._resolve_split_path("valid", valid_set)
-
-        self.config = resolve_config_omega(self.config)
+        
+        self.config = resolve_config_omega(self.config, weights=weights)
         logging.info("Configuration:")
         logging.info(self.config)
 
@@ -241,7 +240,7 @@ class ClassificationModel(BaseTaskModel):
 
         test_set = self._resolve_split_path("test", test_set)
 
-        self.config = resolve_config_omega(self.config)
+        self.config = resolve_config_omega(self.config, weights=weights)
         logging.info("Configuration:")
         logging.info(self.config)
 
@@ -304,7 +303,7 @@ class ClassificationModel(BaseTaskModel):
 
         test_set = self._resolve_split_path("test", test_set)
 
-        self.config = resolve_config_omega(self.config)
+        self.config = resolve_config_omega(self.config, weights=weights)
         logging.info("Configuration:")
         logging.info(self.config)
         if predictions is None:

{opensportslib-0.1.2.dev7 → opensportslib-0.1.2.dev9}/opensportslib/apis/localization.py

@@ -9,13 +9,13 @@ from opensportslib.core.utils.config import expand
 class LocalizationModel(BaseTaskModel):
     """Top-level task wrapper for localization / spotting."""
 
-    def __init__(self, config=None, weights=None):
-        super().__init__(config=config, weights=None)
-        if weights is not None:
-            self.last_loaded_weights = weights
-            self.best_checkpoint = weights
+    # def __init__(self, config=None, weights=None):
+    #     super().__init__(config=config, weights=None)
+    #     if weights is not None:
+    #         self.last_loaded_weights = weights
+    #         self.best_checkpoint = weights
 
-        self.train_flag = False  # Flag to indicate whether we're in training mode (affects checkpoint loading behavior)
+    #     self.train_flag = False  # Flag to indicate whether we're in training mode (affects checkpoint loading behavior)
 
     def _resolve_split_path(self, split: str, override: str | None = None) -> str:
         if override is not None:
@@ -178,8 +178,8 @@ class LocalizationModel(BaseTaskModel):
         valid_set = self._resolve_split_path("valid", valid_set)
         self._set_split_path("train", train_set)
         self._set_split_path("valid", valid_set)
-
-        self.config = resolve_config_omega(self.config)
+        
+        self.config = resolve_config_omega(self.config, weights=weights)
         check_config(self.config, split="train")
         init_wandb(
             self.config_path,
@@ -292,7 +292,7 @@ class LocalizationModel(BaseTaskModel):
         self._set_split_path("test", test_set)
 
         self.config.MODEL.multi_gpu = False
-        self.config = resolve_config_omega(self.config)
+        self.config = resolve_config_omega(self.config, weights=weights)
         check_config(self.config, split="test")
         self.config.infer_split = whether_infer_split(self.config.DATA.test)
 
@@ -361,9 +361,8 @@ class LocalizationModel(BaseTaskModel):
 
         test_set = self._resolve_split_path("test", test_set)
         self._set_split_path("test", test_set)
-
         self.config.MODEL.multi_gpu = False
-        self.config = resolve_config_omega(self.config)
+        self.config = resolve_config_omega(self.config, weights=weights)
         check_config(self.config, split="test")
         self.config.infer_split = whether_infer_split(self.config.DATA.test)
 

{opensportslib-0.1.2.dev7 → opensportslib-0.1.2.dev9}/opensportslib/core/trainer/classification_trainer.py

@@ -550,6 +550,13 @@ class BaseTrainerClassification:
         path_aux = os.path.join(epoch_dir, name)
         torch.save(state, path_aux)
         logging.info(f"Saved checkpoint: {path_aux}")
+
+        if self.config is not None:
+            from opensportslib.core.utils.config import save_config
+            config_path = os.path.join(epoch_dir, "config.yaml")
+            save_config(self.config, config_path)
+            logging.info(f"Saved config: {config_path}")
+            
         return path_aux
 
 

{opensportslib-0.1.2.dev7 → opensportslib-0.1.2.dev9}/opensportslib/core/trainer/localization_trainer.py

@@ -155,6 +155,7 @@ class Trainer_pl(Trainer):
             num_sanity_val_steps=0,
         )
         self.best_checkpoint_path = None
+        self.config = cfg
 
     def train(self, **kwargs):
         self.trainer.fit(**kwargs)
@@ -179,6 +180,13 @@ class Trainer_pl(Trainer):
             logging.info("Done training")
             logging.info(f"Best model saved at: {self.best_checkpoint_path}")
 
+            # Save the config file uniformly inside the work_dir
+            if hasattr(self, 'config') and self.config is not None:
+                from opensportslib.core.utils.config import save_config
+                config_path = os.path.join(self.work_dir, "config.yaml")
+                save_config(self.config, config_path)
+                logging.info(f"Saved config: {config_path}")
+
         log()
 
 
@@ -297,6 +305,12 @@ class Trainer_e2e(Trainer):
             self.best_checkpoint_path = best_path
             torch.save(checkpoint, best_path)
             logging.info(f"Best checkpoint saved: {best_path}")
+        
+        if self.config is not None:
+            from opensportslib.core.utils.config import save_config
+            config_path = os.path.join(self.save_dir, "config.yaml")
+            save_config(self.config, config_path)
+            logging.info(f"Saved config: {config_path}")
             
     def train(self, train_loader, valid_loader, classes):
         """Training loop with checkpoint management."""

opensportslib-0.1.2.dev9/opensportslib/core/utils/config.py

@@ -0,0 +1,358 @@
+
+import os
+import re
+import json
+import gzip
+import yaml
+
+def dict_to_namespace(d, skip_keys=("classes",)):
+    """
+    Recursively convert dict to namespace for easy access,
+    but keep certain keys (like 'classes') as raw dict/list.
+    """
+    from types import SimpleNamespace
+
+    if isinstance(d, dict):
+        out = {}
+        for k, v in d.items():
+            if k in skip_keys:
+                out[k] = v  # leave as-is
+            else:
+                out[k] = dict_to_namespace(v, skip_keys)
+        return SimpleNamespace(**out)
+    elif isinstance(d, list):
+        return [dict_to_namespace(v, skip_keys) for v in d]
+    else:
+        return d
+
+def namespace_to_dict(ns):
+    """
+    Recursively convert namespace/dict/list containers into plain Python types.
+    """
+    if ns is None or isinstance(ns, (str, int, float, bool)):
+        return ns
+
+    try:
+        from omegaconf import DictConfig, ListConfig, OmegaConf
+        if isinstance(ns, (DictConfig, ListConfig)):
+            ns = OmegaConf.to_container(ns, resolve=True)
+    except ImportError:
+        pass
+
+    if isinstance(ns, dict):
+        return {str(k): namespace_to_dict(v) for k, v in ns.items()}
+
+    if isinstance(ns, (list, tuple, set)):
+        return [namespace_to_dict(v) for v in ns]
+
+    if hasattr(ns, "__dict__"):
+        return {str(k): namespace_to_dict(v) for k, v in vars(ns).items()}
+
+    return ns
+
+def namespace_to_omegaconf(ns):
+    """
+    Recursively convert SimpleNamespace (or dict/list) back to OmegaConf
+    """
+    from omegaconf import OmegaConf
+    from types import SimpleNamespace
+
+    def to_dict(obj):
+        if isinstance(obj, SimpleNamespace):
+            return {k: to_dict(v) for k, v in vars(obj).items()}
+        elif isinstance(obj, dict):
+            return {k: to_dict(v) for k, v in obj.items()}
+        elif isinstance(obj, list):
+            return [to_dict(v) for v in obj]
+        else:
+            return obj
+
+    return OmegaConf.create(to_dict(ns))
+    
+def load_config(config_path):
+    """
+    Loading configurations
+    """
+    print(config_path)
+    if config_path.endswith(".yaml") or config_path.endswith(".yml"):
+        with open(config_path, "r") as f:
+            cfg_dict = yaml.safe_load(f)
+    elif config_path.endswith(".json"):
+        with open(config_path, "r") as f:
+            cfg_dict = json.load(f)
+    else:
+        raise ValueError("Unsupported config format. Use YAML or JSON.")
+    return dict_to_namespace(cfg_dict)
+
+
+
+def load_config_omega(path):
+    
+    from omegaconf import OmegaConf
+    cfg = OmegaConf.load(path)
+    # OmegaConf.resolve(cfg)
+    # cfg = OmegaConf.to_container(cfg, resolve=True)
+    return dict_to_namespace(cfg)
+
+def resolve_config_omega(cfg, weights=None):
+    from omegaconf import OmegaConf, DictConfig
+    #cfg = namespace_to_omegaconf(cfg)
+    #cfg = namespace_to_dict(cfg)
+    #print(type(cfg))
+    #cfg = OmegaConf.create(cfg)
+    if weights is not None:
+        cfg = fetch_and_merge_config_from_HF(cfg, weights, merge_policy="compatibility")
+
+    if not isinstance(cfg, DictConfig):
+        return cfg 
+    OmegaConf.resolve(cfg)
+    cfg = dict_to_namespace(OmegaConf.to_container(cfg, resolve=True))
+    return cfg
+
+
+def expand(path):
+    return os.path.abspath(os.path.expanduser(path))
+
+
+def load_json(fpath):
+    with open(fpath, encoding="utf-8") as fp:
+        return json.load(fp)
+
+def load_gz_json(fpath):
+    with gzip.open(fpath, "rt", encoding="utf-8") as fp:
+        return json.load(fp)
+
+
+def store_json(fpath, obj, pretty=False):
+    kwargs = {}
+    if pretty:
+        kwargs["indent"] = 4
+        kwargs["sort_keys"] = False
+    with open(fpath, "w", encoding="utf-8") as fp:
+        json.dump(obj, fp, **kwargs)
+
+
+def store_gz_json(fpath, obj):
+    with gzip.open(fpath, "wt", encoding="utf-8") as fp:
+        json.dump(obj, fp)
+
+
+def load_text(fpath):
+    """Load text from a given file.
+
+    Args:
+        fpath (string): The path of the file.
+
+    Returns:
+        lines (List): List in which element is a line of the file.
+
+    """
+    lines = []
+    with open(fpath, "r") as fp:
+        for l in fp:
+            l = l.strip()
+            if l:
+                lines.append(l)
+    return lines
+
+def load_classes(input):
+    """Load classes from either list or txt file.
+
+    Args:
+        input (string): Path of the file that contains one class per line or list of classes.
+
+    Returns:
+        Dictionnary with classes associated to indexes.
+    """
+    from omegaconf import ListConfig
+    if isinstance(input, (list, ListConfig)):
+        return {x: i + 1 for i, x in enumerate(input)}
+    return {x: i + 1 for i, x in enumerate(load_text(input))}
+
+def clear_files(dir_name, re_str, exclude=[]):
+    for file_name in os.listdir(dir_name):
+        if re.match(re_str, file_name):
+            if file_name not in exclude:
+                file_path = os.path.join(dir_name, file_name)
+                os.remove(file_path)
+
+
+def _print_info_helper(src_file, labels):
+    """Print informations about videos contained in a json file.
+
+    Args:
+        src_file (string): The source file.
+        labels (list(dict)): List containing a dict fro each video.
+    """
+    num_frames = sum([x["num_frames"] for x in labels])
+    num_events = sum([len(x["events"]) for x in labels])
+    print(
+        "{} : {} videos, {} frames, {:0.5f}% non-bg".format(
+            src_file, len(labels), num_frames, num_events / num_frames * 100
+        )
+    )
+
+def select_device(config):
+    import torch
+    mode = config.device.lower()
+
+    if mode == "auto":
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    elif mode == "cuda":
+        assert torch.cuda.is_available(), "CUDA requested but not available"
+        gpu_id = getattr(config, "gpu_id", 0)
+        torch.cuda.set_device(gpu_id)
+        device = torch.device(f"cuda:{gpu_id}")
+
+    elif mode == "cpu":
+        device = torch.device("cpu")
+
+    else:
+        raise ValueError(f"Unknown device mode: {mode}")
+
+    print(f"Using device: {device}")
+    if device.type == "cuda" or device.type == "auto":
+        print(f"GPU: {torch.cuda.get_device_name(device)}")
+
+    return device
+
+def is_local_path(p):
+    return p and (
+        os.path.exists(p) or
+        p.endswith((".pt", ".pth", ".tar"))
+    )
+
+
+def fetch_and_merge_config_from_HF(
+    target_config, weights, hf_token=None, merge_policy="full"
+):
+    """
+    Fetch config from a local path or HF repo and merge it with the local config.
+
+    merge_policy:
+      - "full": legacy behavior; local config overrides loaded config for
+        TASK/MODEL/SYSTEM/TRAIN/DATA.
+      - "compatibility": used for inference; only TASK/MODEL are updated from
+        pretrained config while runtime/system/data settings remain local.
+    """
+    import os
+    import logging
+    from omegaconf import OmegaConf
+    
+    loaded_cfg = None
+
+    if is_local_path(weights):
+        dir_name = os.path.dirname(os.path.abspath(weights))
+        yaml_path = os.path.join(dir_name, "config.yaml")
+        json_path = os.path.join(dir_name, "config.json")
+        if os.path.exists(yaml_path):
+            loaded_cfg = load_config_omega(yaml_path)
+            logging.info(f"Loaded config from {yaml_path}")
+        elif os.path.exists(json_path):
+            loaded_cfg = load_config_omega(json_path)
+            logging.info(f"Loaded config from {json_path}")
+    else:
+        try:
+            from huggingface_hub import hf_hub_download
+            try:
+                config_path = hf_hub_download(repo_id=weights, filename="config.yaml", token=hf_token)
+                loaded_cfg = load_config_omega(config_path)
+                logging.info(f"Loaded config.yaml from HF repo {weights}")
+            except Exception:
+                config_path = hf_hub_download(repo_id=weights, filename="config.json", token=hf_token)
+                loaded_cfg = load_config_omega(config_path)
+                logging.info(f"Loaded config.json from HF repo {weights}")
+        except Exception as e:
+            logging.warning(f"Could not load config from HF repo {weights}: {e}")
+
+    if loaded_cfg is not None:
+        logging.info(f"Merging pretrained config from {weights}")
+        
+        target_dict = namespace_to_dict(target_config)
+        loaded_dict = namespace_to_dict(loaded_cfg)
+
+        _warn_critical_config_conflicts(target_dict, loaded_dict)
+
+        if merge_policy == "compatibility":
+            # Keep local runtime config as source of truth. Pull only compatibility-
+            # critical sections from the pretrained config.
+            for section in ["TASK", "MODEL"]:
+                if section in loaded_dict:
+                    if isinstance(loaded_dict[section], dict):
+                        target_oc = OmegaConf.create(target_dict.get(section, {}))
+                        loaded_oc = OmegaConf.create(loaded_dict[section])
+                        merged_oc = OmegaConf.merge(target_oc, loaded_oc)
+                        target_dict[section] = OmegaConf.to_container(merged_oc, resolve=False)
+                    else:
+                        target_dict[section] = loaded_dict[section]
+        elif merge_policy == "full":
+            for section in ["TASK", "MODEL", "SYSTEM", "TRAIN", "DATA"]:
+                if section in loaded_dict:
+                    # Sanitize the DATA block to strip out remote machine-specific paths
+                    if section == "DATA" and isinstance(loaded_dict[section], dict):
+                        keys_to_remove = ["data_dir", "train", "valid", "test"]
+                        for k in keys_to_remove:
+                            loaded_dict[section].pop(k, None)
+
+                    # Legacy merge logic: pretrained config as base, local config overrides it.
+                    if isinstance(loaded_dict[section], dict):
+                        loaded_oc = OmegaConf.create(loaded_dict[section])
+                        target_oc = OmegaConf.create(target_dict.get(section, {}))
+                        merged_oc = OmegaConf.merge(loaded_oc, target_oc)
+                        target_dict[section] = OmegaConf.to_container(merged_oc, resolve=False)
+                    else:
+                        target_dict[section] = target_dict.get(section, loaded_dict[section])
+        else:
+            raise ValueError(f"Unknown merge_policy: {merge_policy}")
+
+        # Convert back using DictConfig or SimpleNamespace
+        return dict_to_namespace(target_dict)
+    
+    return target_config
+
+
+def _warn_critical_config_conflicts(target_dict, loaded_dict):
+    import logging
+
+    local_data = target_dict.get("DATA", {}) if isinstance(target_dict, dict) else {}
+    hf_data = loaded_dict.get("DATA", {}) if isinstance(loaded_dict, dict) else {}
+
+    local_num_classes = local_data.get("num_classes")
+    hf_num_classes = hf_data.get("num_classes")
+    if (
+        local_num_classes is not None
+        and hf_num_classes is not None
+        and local_num_classes != hf_num_classes
+    ):
+        logging.warning(
+            "Config mismatch: DATA.num_classes local=%s hf=%s. "
+            "Keeping local runtime config values.",
+            local_num_classes,
+            hf_num_classes,
+        )
+
+    local_classes = local_data.get("classes")
+    hf_classes = hf_data.get("classes")
+    if (
+        local_classes is not None
+        and hf_classes is not None
+        and local_classes != hf_classes
+    ):
+        logging.warning(
+            "Config mismatch: DATA.classes differs between local and HF config. "
+            "Keeping local runtime config values.",
+        )
+
+def save_config(config_obj, path):
+    """Save the configuration object to a YAML file."""
+    from omegaconf import OmegaConf, DictConfig
+    import yaml
+    
+    if isinstance(config_obj, DictConfig):
+        cfg_dict = OmegaConf.to_container(config_obj, resolve=True)
+    else:
+        cfg_dict = namespace_to_dict(config_obj)
+
+    with open(path, "w", encoding="utf-8") as f:
+        yaml.dump(cfg_dict, f, default_flow_style=False)

{opensportslib-0.1.2.dev7 → opensportslib-0.1.2.dev9/opensportslib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensportslib
-Version: 0.1.2.dev7
+Version: 0.1.2.dev9
 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.1.2.dev7 → opensportslib-0.1.2.dev9}/opensportslib.egg-info/SOURCES.txt

@@ -94,6 +94,8 @@ tests/test_package_smoke.py
 tests/test_public_apis_smoke.py
 tests/test_subset_train_infer_integration.py
 tests/test_task_model_api_contract.py
+tools/convert/build_soccernet_gar.py
+tools/convert/build_soccernet_gar_action_spotting.py
 tools/convert/osl_json_to_parquet_webdataset.py
 tools/convert/parquet_webdataset_to_osl_json.py
 tools/download/download_hf_repo.py

{opensportslib-0.1.2.dev7 → opensportslib-0.1.2.dev9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opensportslib"
-version = "0.1.2.dev7"
+version = "0.1.2.dev9"
 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"