opensportslib 0.3.0.dev20__tar.gz → 0.3.0.dev21__tar.gz

{opensportslib-0.3.0.dev20/opensportslib.egg-info → opensportslib-0.3.0.dev21}/PKG-INFO

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

{opensportslib-0.3.0.dev20 → opensportslib-0.3.0.dev21}/opensportslib/tools/hf_transfer.py

@@ -117,9 +117,13 @@ def extract_repo_paths_from_json(
                 if not isinstance(inp, dict):
                     continue
                 path = inp.get("path")
-                if not path:
-                    continue
-                repo_paths.append(str(path).lstrip("/"))
+                if path:
+                    repo_paths.append(str(path).lstrip("/"))
+                # player_joints_h5 / player_centroids_h5 inputs may carry a
+                # sidecar ball_path; download it alongside the primary input.
+                ball_path = inp.get("ball_path")
+                if ball_path:
+                    repo_paths.append(str(ball_path).lstrip("/"))
 
     if not repo_paths:
         raise ValueError("No file paths found in the provided JSON (no inputs with 'path').")
@@ -637,28 +641,37 @@ def extract_local_input_upload_entries_from_json(dataset_json_path: str) -> list
         for inp in inputs:
             if not isinstance(inp, dict):
                 continue
-            raw_path = str(inp.get("path") or "").strip()
-            if not raw_path:
-                continue
 
-            local_path = raw_path if os.path.isabs(raw_path) else os.path.join(base_dir, raw_path)
-            local_path = os.path.abspath(local_path)
-            if not os.path.isfile(local_path):
-                raise FileNotFoundError(
-                    f"Input file from dataset JSON not found on disk: {raw_path} (resolved: {local_path})"
+            raw_paths = []
+            path = str(inp.get("path") or "").strip()
+            if path:
+                raw_paths.append(path)
+            # player_joints_h5 / player_centroids_h5 inputs may carry a sidecar
+            # ball_path pointing at a separate ball-tracking h5 file; include it
+            # alongside the primary input when present.
+            ball_path = str(inp.get("ball_path") or "").strip()
+            if ball_path:
+                raw_paths.append(ball_path)
+
+            for raw_path in raw_paths:
+                local_path = raw_path if os.path.isabs(raw_path) else os.path.join(base_dir, raw_path)
+                local_path = os.path.abspath(local_path)
+                if not os.path.isfile(local_path):
+                    raise FileNotFoundError(
+                        f"Input file from dataset JSON not found on disk: {raw_path} (resolved: {local_path})"
+                    )
+
+                path_in_repo = _normalize_repo_path(raw_path)
+                if not path_in_repo:
+                    raise ValueError(f"Invalid input path in dataset JSON: {raw_path}")
+
+                entries.append(
+                    {
+                        "local_path": local_path,
+                        "path_in_repo": path_in_repo,
+                    }
                 )
 
-            path_in_repo = _normalize_repo_path(raw_path)
-            if not path_in_repo:
-                raise ValueError(f"Invalid input path in dataset JSON: {raw_path}")
-
-            entries.append(
-                {
-                    "local_path": local_path,
-                    "path_in_repo": path_in_repo,
-                }
-            )
-
     if not entries:
         raise ValueError("No valid data[].inputs[].path entries found in the provided dataset JSON.")
     return entries

{opensportslib-0.3.0.dev20 → opensportslib-0.3.0.dev21}/opensportslib/tools/osl_json_to_parquet.py

@@ -149,9 +149,14 @@ def _estimate_sample_tar_size(
     for input_item in _extract_inputs_with_path(sample):
         rel_path = str(input_item["path"])
         resolved = _resolve_media_path(media_root, rel_path, missing_policy=missing_policy)
-        if resolved is None:
-            continue
-        total += _tar_member_size(resolved.stat().st_size)
+        if resolved is not None:
+            total += _tar_member_size(resolved.stat().st_size)
+
+        ball_rel_path = str(input_item.get("ball_path") or "").strip()
+        if ball_rel_path:
+            ball_resolved = _resolve_media_path(media_root, ball_rel_path, missing_policy=missing_policy)
+            if ball_resolved is not None:
+                total += _tar_member_size(ball_resolved.stat().st_size)
     return total
 
 
@@ -312,6 +317,7 @@ def convert_json_to_parquet(
                 for input_idx, input_item in enumerate(_extract_inputs_with_path(sample)):
                     rel_path = str(input_item["path"])
                     resolved = _resolve_media_path(media_root, rel_path, missing_policy=missing_policy)
+                    input_type = str(input_item.get("type", "")).strip()
 
                     if resolved is None:
                         total_missing_input_files += 1
@@ -319,25 +325,65 @@ def convert_json_to_parquet(
                             "sample_id": sample_id,
                             "shard_name": shard_name,
                             "input_index": input_idx,
-                            "input_type": str(input_item.get("type", "")).strip(),
+                            "file_role": "primary",
+                            "input_type": input_type,
                             "relative_path": rel_path,
                             "resolved_path": None,
                             "status": "missing",
                         })
+                    else:
+                        ext = resolved.suffix.lstrip(".").lower() or "bin"
+                        arcname = f"{key}.{input_idx}.{ext}"
+                        _add_file_to_tar(tar, resolved, arcname)
+                        shard_manifest.append({
+                            "sample_id": sample_id,
+                            "shard_name": shard_name,
+                            "input_index": input_idx,
+                            "file_role": "primary",
+                            "input_type": input_type,
+                            "relative_path": rel_path,
+                            "resolved_path": str(resolved if not keep_relative_paths_in_parquet else rel_path),
+                            "status": "ok",
+                            "wds_member": arcname,
+                        })
+                        total_input_files_added += 1
+
+                    # player_joints_h5 / player_centroids_h5 inputs may carry a
+                    # sidecar ball_path pointing at a separate ball-tracking h5
+                    # file; bundle it into the same shard, tagged with a distinct
+                    # arcname (".ball.") so it doesn't collide with the primary
+                    # input's tar member.
+                    ball_rel_path = str(input_item.get("ball_path") or "").strip()
+                    if not ball_rel_path:
+                        continue
+                    ball_resolved = _resolve_media_path(media_root, ball_rel_path, missing_policy=missing_policy)
+                    if ball_resolved is None:
+                        total_missing_input_files += 1
+                        shard_manifest.append({
+                            "sample_id": sample_id,
+                            "shard_name": shard_name,
+                            "input_index": input_idx,
+                            "file_role": "ball",
+                            "input_type": input_type,
+                            "relative_path": ball_rel_path,
+                            "resolved_path": None,
+                            "status": "missing",
+                        })
                         continue
 
-                    ext = resolved.suffix.lstrip(".").lower() or "bin"
-                    arcname = f"{key}.{input_idx}.{ext}"
-                    _add_file_to_tar(tar, resolved, arcname)
+                    ball_ext = ball_resolved.suffix.lstrip(".").lower() or "bin"
+                    ball_arcname = f"{key}.{input_idx}.ball.{ball_ext}"
+                    _add_file_to_tar(tar, ball_resolved, ball_arcname)
                     shard_manifest.append({
                         "sample_id": sample_id,
                         "shard_name": shard_name,
                         "input_index": input_idx,
-                        "input_type": str(input_item.get("type", "")).strip(),
-                        "relative_path": rel_path,
-                        "resolved_path": str(resolved if not keep_relative_paths_in_parquet else rel_path),
+                        "file_role": "ball",
+                        "input_type": input_type,
+                        "relative_path": ball_rel_path,
+                        "resolved_path": str(ball_resolved if not keep_relative_paths_in_parquet else ball_rel_path),
                         "status": "ok",
-                        "wds_member": arcname,
+                        "wds_member": ball_arcname,
                     })
                     total_input_files_added += 1
 
@@ -349,14 +395,25 @@ def convert_json_to_parquet(
             ok_manifest = manifest_df[manifest_df["status"] == "ok"].copy()
             if not ok_manifest.empty:
                 ok_manifest["input_index"] = ok_manifest["input_index"].astype(int)
+                primary_manifest = ok_manifest[ok_manifest["file_role"] == "primary"]
+                ball_manifest = ok_manifest[ok_manifest["file_role"] == "ball"]
+
                 by_sample_input_paths: Dict[str, Dict[int, str]] = {}
-                for sample_id, sample_manifest in ok_manifest.groupby("sample_id", sort=False):
+                for sample_id, sample_manifest in primary_manifest.groupby("sample_id", sort=False):
                     sample_manifest = sample_manifest.sort_values("input_index")
                     by_sample_input_paths[str(sample_id)] = {
                         int(rec["input_index"]): str(rec["resolved_path"])
                         for _, rec in sample_manifest.iterrows()
                     }
 
+                by_sample_ball_paths: Dict[str, Dict[int, str]] = {}
+                for sample_id, sample_manifest in ball_manifest.groupby("sample_id", sort=False):
+                    sample_manifest = sample_manifest.sort_values("input_index")
+                    by_sample_ball_paths[str(sample_id)] = {
+                        int(rec["input_index"]): str(rec["resolved_path"])
+                        for _, rec in sample_manifest.iterrows()
+                    }
+
                 def _resolved_payload_for_row(row: pd.Series) -> str:
                     payload = maybe_json_loads(row.get("sample_payload"), {})
                     if not isinstance(payload, dict):
@@ -368,6 +425,7 @@ def convert_json_to_parquet(
                         return json_dumps_compact(payload_copy)
 
                     resolved_by_index = by_sample_input_paths.get(str(row.get("sample_id")), {})
+                    resolved_ball_by_index = by_sample_ball_paths.get(str(row.get("sample_id")), {})
                     with_path_idx = 0
                     rewritten: List[Any] = []
                     for inp in inputs_value:
@@ -379,6 +437,10 @@ def convert_json_to_parquet(
                             resolved = resolved_by_index.get(with_path_idx)
                             if resolved is not None:
                                 inp_copy["path"] = resolved
+                            if inp_copy.get("ball_path"):
+                                resolved_ball = resolved_ball_by_index.get(with_path_idx)
+                                if resolved_ball is not None:
+                                    inp_copy["ball_path"] = resolved_ball
                             with_path_idx += 1
                         rewritten.append(inp_copy)
                     payload_copy["inputs"] = rewritten

{opensportslib-0.3.0.dev20 → opensportslib-0.3.0.dev21}/opensportslib/tools/parquet_to_osl_json.py

@@ -52,18 +52,23 @@ def _extract_sample_media_from_tar(
     sample_index: int,
     output_media_root: Path,
     original_paths: List[str],
+    original_ball_paths: Optional[List[Optional[str]]] = None,
     overwrite: bool = False,
 ) -> int:
     """
-    Extract all input files for *sample_index* from the shard.
+    Extract all input files for *sample_index* from the shard, including any
+    sidecar ball-tracking files (tar members named ``<key>.<idx>.ball.<ext>``).
 
-    Files are written to ``output_media_root / original_path``, preserving the
-    original relative path structure so that ``inputs[].path`` values stay valid.
+    Files are written to ``output_media_root / original_path`` (or
+    ``output_media_root / original_ball_path`` for ball members), preserving
+    the original relative path structure so that ``inputs[].path`` /
+    ``inputs[].ball_path`` values stay valid.
 
     Returns the number of files extracted.
     """
     key_prefix = f"{sample_index:09d}."
     extracted = 0
+    ball_paths = original_ball_paths or []
 
     with tarfile.open(tar_path, "r") as tar:
         members = [
@@ -72,20 +77,27 @@ def _extract_sample_media_from_tar(
             if m.isfile() and m.name.startswith(key_prefix) and not m.name.endswith(".json")
         ]
 
-        def _input_idx(m: tarfile.TarInfo) -> int:
-            part = m.name[len(key_prefix) :].split(".", 1)[0]
+        def _member_info(m: tarfile.TarInfo) -> tuple[int, bool]:
+            parts = m.name[len(key_prefix) :].split(".")
             try:
-                return int(part)
+                idx = int(parts[0])
             except ValueError:
-                return 0
+                idx = 0
+            is_ball = len(parts) >= 3 and parts[1] == "ball"
+            return idx, is_ball
 
-        members.sort(key=_input_idx)
+        members.sort(key=_member_info)
 
         for member in members:
-            input_idx = _input_idx(member)
-            if input_idx >= len(original_paths):
-                continue
-            out_path = output_media_root / original_paths[input_idx]
+            input_idx, is_ball = _member_info(member)
+            if is_ball:
+                if input_idx >= len(ball_paths) or not ball_paths[input_idx]:
+                    continue
+                out_path = output_media_root / ball_paths[input_idx]
+            else:
+                if input_idx >= len(original_paths):
+                    continue
+                out_path = output_media_root / original_paths[input_idx]
             if out_path.exists() and not overwrite:
                 extracted += 1
                 continue
@@ -230,16 +242,20 @@ def convert_parquet_to_json(
 
         if extract_media:
             inputs = sample.get("inputs", []) if isinstance(sample, dict) else []
-            original_input_paths = [
-                str(inp["path"])
-                for inp in inputs
-                if isinstance(inp, dict) and inp.get("path")
-            ]
+            original_input_paths: List[str] = []
+            original_ball_paths: List[Optional[str]] = []
+            for inp in inputs:
+                if not isinstance(inp, dict) or not inp.get("path"):
+                    continue
+                original_input_paths.append(str(inp["path"]))
+                ball_path = inp.get("ball_path")
+                original_ball_paths.append(str(ball_path) if ball_path else None)
             extracted_media_count += _extract_sample_media_from_tar(
                 tar_path=tar_path,
                 sample_index=sample_index,
                 output_media_root=output_media_root_path,
                 original_paths=original_input_paths,
+                original_ball_paths=original_ball_paths,
                 overwrite=overwrite_media,
             )
 

{opensportslib-0.3.0.dev20 → opensportslib-0.3.0.dev21/opensportslib.egg-info}/PKG-INFO

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

{opensportslib-0.3.0.dev20 → opensportslib-0.3.0.dev21}/pyproject.toml

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