opensportslib 0.3.1.dev27__tar.gz → 0.3.2__tar.gz

{opensportslib-0.3.1.dev27/opensportslib.egg-info → opensportslib-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensportslib
-Version: 0.3.1.dev27
+Version: 0.3.2
 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
@@ -67,7 +67,7 @@ OpenSportsLib is designed for **researchers, ML engineers, and sports analytics
 
 - **Documentation:** https://opensportslab.github.io/opensportslib/
 - **OSL JSON format:** https://opensportslab.github.io/opensportslib/data/osl-json-format/
-- **Inference server:** [server/README.md](server/README.md), including checkpoint and config-only rule-model registration
+- **Inference server:** [server/README.md](server/README.md)
 - **PyPI:** https://pypi.org/project/opensportslib/
 - **Issues:** https://github.com/OpenSportsLab/opensportslib/issues
 
@@ -324,9 +324,3 @@ video understanding. Core contributors affiliated with KAUST include:
 - [Jeet Vora](https://jeetv.github.io/) — Remote Research Engineer
 - [Dr. Merey Ramazanova](https://meryusha.github.io/) — Post-Doc
 - [Dr. Silvio Giancola](https://www.silviogiancola.com/) — Research Scientist
-
-For synchronized native-FPS GAR action clips and optional exact frame reproduction, see the
-[spotting-to-classification converter](docs/tools/spotting-to-classification.md).
-
-For full-rate tracking clips with the same classification sample IDs, see the
-[tracking conversion script](docs/tools/spotting-tracking-to-classification.md).

{opensportslib-0.3.1.dev27 → opensportslib-0.3.2}/README.md

@@ -28,7 +28,7 @@ OpenSportsLib is designed for **researchers, ML engineers, and sports analytics
 
 - **Documentation:** https://opensportslab.github.io/opensportslib/
 - **OSL JSON format:** https://opensportslab.github.io/opensportslib/data/osl-json-format/
-- **Inference server:** [server/README.md](server/README.md), including checkpoint and config-only rule-model registration
+- **Inference server:** [server/README.md](server/README.md)
 - **PyPI:** https://pypi.org/project/opensportslib/
 - **Issues:** https://github.com/OpenSportsLab/opensportslib/issues
 
@@ -285,9 +285,3 @@ video understanding. Core contributors affiliated with KAUST include:
 - [Jeet Vora](https://jeetv.github.io/) — Remote Research Engineer
 - [Dr. Merey Ramazanova](https://meryusha.github.io/) — Post-Doc
 - [Dr. Silvio Giancola](https://www.silviogiancola.com/) — Research Scientist
-
-For synchronized native-FPS GAR action clips and optional exact frame reproduction, see the
-[spotting-to-classification converter](docs/tools/spotting-to-classification.md).
-
-For full-rate tracking clips with the same classification sample IDs, see the
-[tracking conversion script](docs/tools/spotting-tracking-to-classification.md).

{opensportslib-0.3.1.dev27 → opensportslib-0.3.2/opensportslib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensportslib
-Version: 0.3.1.dev27
+Version: 0.3.2
 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
@@ -67,7 +67,7 @@ OpenSportsLib is designed for **researchers, ML engineers, and sports analytics
 
 - **Documentation:** https://opensportslab.github.io/opensportslib/
 - **OSL JSON format:** https://opensportslab.github.io/opensportslib/data/osl-json-format/
-- **Inference server:** [server/README.md](server/README.md), including checkpoint and config-only rule-model registration
+- **Inference server:** [server/README.md](server/README.md)
 - **PyPI:** https://pypi.org/project/opensportslib/
 - **Issues:** https://github.com/OpenSportsLab/opensportslib/issues
 
@@ -324,9 +324,3 @@ video understanding. Core contributors affiliated with KAUST include:
 - [Jeet Vora](https://jeetv.github.io/) — Remote Research Engineer
 - [Dr. Merey Ramazanova](https://meryusha.github.io/) — Post-Doc
 - [Dr. Silvio Giancola](https://www.silviogiancola.com/) — Research Scientist
-
-For synchronized native-FPS GAR action clips and optional exact frame reproduction, see the
-[spotting-to-classification converter](docs/tools/spotting-to-classification.md).
-
-For full-rate tracking clips with the same classification sample IDs, see the
-[tracking conversion script](docs/tools/spotting-tracking-to-classification.md).

{opensportslib-0.3.1.dev27 → opensportslib-0.3.2}/opensportslib.egg-info/SOURCES.txt

@@ -154,7 +154,6 @@ scripts/write_release_manifest.py
 tests/__init__.py
 tests/conftest.py
 tests/helpers/__init__.py
-tests/helpers/causal_lm.py
 tests/helpers/configs.py
 tests/helpers/pipeline_stubs.py
 tests/integration/classification/test_pipeline.py
@@ -190,7 +189,6 @@ tests/unit/contracts/test_package.py
 tests/unit/contracts/test_release_versions.py
 tests/unit/contracts/test_runner_contract.py
 tests/unit/core/test_classification_trainer.py
-tests/unit/core/test_hf_runtime.py
 tests/unit/core/test_localization_hf_backend.py
 tests/unit/core/test_training_components.py
 tests/unit/core/test_video_processing.py
@@ -217,7 +215,6 @@ tests/unit/tools/test_hf_transfer.py
 tests/unit/tools/test_release_manifest.py
 tests/unit/tools/test_report_summary.py
 tests/unit/tools/test_setup.py
-tests/unit/tools/test_spotting_classification.py
 tools/convert/build_sn_vqa_2026_vqa.py
 tools/convert/build_sngar_spotting.py
 tools/convert/build_soccernet_gar.py
@@ -229,8 +226,6 @@ tools/convert/osl_json_to_parquet_webdataset.py
 tools/convert/parquet_webdataset_to_osl_json.py
 tools/convert/sngar_dataset_card.py
 tools/convert/sngar_events.py
-tools/convert/spotting_to_classification.py
-tools/convert/spotting_tracking_to_classification.py
 tools/convert/verify_sngar_spotting.py
 tools/download/download_hf_repo.py
 tools/download/download_osl_hf.py
@@ -240,6 +235,4 @@ tools/train/train_config.py
 tools/training/classification.py
 tools/training/localization.py
 tools/training/vqa.py
-tools/upload/upload_model_hf.py
-tools/upload/upload_sngar_tracking_full.py
-tools/upload/upload_sngar_videos.py
+tools/upload/upload_model_hf.py

{opensportslib-0.3.1.dev27 → opensportslib-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opensportslib"
-version = "0.3.1.dev27"
+version = "0.3.2"
 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"
@@ -22,7 +22,7 @@ opensportslib = "opensportslib.cli:main"
 opensportslib = [ "legacy_config/*.yaml", "configs/**/*.yaml",]
 
 [tool.coverage.run]
-source = [ "opensportslib", "server",]
+source = [ "opensportslib",]
 branch = true
 omit = [ "*/.ipynb_checkpoints/*",]
 

opensportslib-0.3.2/tests/unit/api/test_server_jobs.py

@@ -0,0 +1,63 @@
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+
+SERVER_ROOT = Path(__file__).resolve().parents[3] / "server"
+sys.path.insert(0, str(SERVER_ROOT))
+
+from app.schemas import JobStatus, PredictRequest  # noqa: E402
+from storage.jobs import JobStore  # noqa: E402
+
+
+def store(tmp_path):
+    runtime = tmp_path / "runtime"
+    settings = SimpleNamespace(
+        runtime_dir=runtime,
+        tmp_dir=runtime / "tmp",
+        jobs_dir=runtime / "jobs",
+        results_dir=runtime / "results",
+    )
+    settings.jobs_dir.mkdir(parents=True)
+    settings.tmp_dir.mkdir(parents=True)
+    settings.results_dir.mkdir(parents=True)
+    return JobStore(settings)
+
+
+def request():
+    return PredictRequest(task_type="classification", video_path="/tmp/clip.mp4")
+
+
+def test_metadata_is_valid_json_after_create(tmp_path):
+    jobs = store(tmp_path)
+    metadata = jobs.create_job(request(), "model")
+
+    loaded = jobs.load_metadata(metadata.job_id)
+    assert loaded is not None
+    assert loaded.status is JobStatus.QUEUED
+    assert jobs.metadata_path(metadata.job_id).read_text(encoding="utf-8").strip()
+
+
+def test_metadata_replacement_never_leaves_partial_file(tmp_path):
+    jobs = store(tmp_path)
+    metadata = jobs.create_job(request(), "model")
+
+    for status in (JobStatus.RUNNING, JobStatus.SUCCEEDED, JobStatus.FAILED):
+        metadata.status = status
+        jobs.save_metadata(metadata)
+        loaded = jobs.load_metadata(metadata.job_id)
+        assert loaded is not None
+        assert loaded.status is status
+        assert not list(jobs.settings.jobs_dir.glob(f".{metadata.job_id}.*.tmp"))
+
+
+def test_invalid_metadata_is_treated_as_missing(tmp_path):
+    jobs = store(tmp_path)
+    path = jobs.metadata_path("broken")
+    path.write_text("", encoding="utf-8")
+
+    assert jobs.load_metadata("broken") is None
+    with pytest.raises(FileNotFoundError, match="broken"):
+        jobs.mark_running("broken")

opensportslib-0.3.2/tests/unit/api/test_server_registry.py

@@ -0,0 +1,131 @@
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+
+SERVER_ROOT = Path(__file__).parents[3] / "server"
+sys.path.insert(0, str(SERVER_ROOT))
+
+from config.model_registry import (  # noqa: E402
+    ModelRegistry,
+    generated_local_model_id,
+    public_record,
+    resolve_local_source,
+    infer_source_mode,
+    validate_local_model_id,
+)
+
+
+class FakeRedis:
+    def __init__(self):
+        self.hashes = {}
+
+    def hget(self, key, field):
+        return self.hashes.get(key, {}).get(field)
+
+    def hvals(self, key):
+        return list(self.hashes.get(key, {}).values())
+
+    def hset(self, key, field, value):
+        self.hashes.setdefault(key, {})[field] = value
+
+    def hsetnx(self, key, field, value):
+        values = self.hashes.setdefault(key, {})
+        if field in values:
+            return 0
+        values[field] = value
+        return 1
+
+    def hdel(self, key, field):
+        self.hashes.get(key, {}).pop(field, None)
+
+    def hgetall(self, key):
+        return dict(self.hashes.get(key, {}))
+
+    def setex(self, key, ttl, value):
+        self.hashes.setdefault("strings", {})[key] = value
+
+    def getdel(self, key):
+        return self.hashes.setdefault("strings", {}).pop(key, None)
+
+    def delete(self, key):
+        self.hashes.setdefault("strings", {}).pop(key, None)
+
+
+def record(model_id="model", source="org/model"):
+    return {
+        "model_id": model_id,
+        "task_type": "classification",
+        "source_type": "huggingface",
+        "source": source,
+        "config_path": None,
+        "status": "ready",
+        "generation": 1,
+        "created_at": "now",
+        "updated_at": "now",
+        "error": None,
+    }
+
+
+def test_registry_reserves_idempotently_and_rejects_conflicts():
+    registry = ModelRegistry(SimpleNamespace(redis_url="redis://unused"), FakeRedis())
+    _, created = registry.reserve(record())
+    assert created
+    existing, created = registry.reserve(record())
+    assert not created
+    assert existing["source"] == "org/model"
+    with pytest.raises(FileExistsError):
+        registry.reserve(record(source="other/model"))
+
+
+def test_local_source_stays_inside_model_root(tmp_path):
+    root = tmp_path / "models"
+    folder = root / "custom"
+    folder.mkdir(parents=True)
+    (folder / "config.yaml").write_text("MODEL: {}")
+    settings = SimpleNamespace(model_root=root)
+
+    weights, config = resolve_local_source(settings, str(folder), None)
+    assert weights == folder
+    assert config == folder / "config.yaml"
+    assert generated_local_model_id(folder).startswith("local:custom-")
+
+    outside = tmp_path / "outside"
+    outside.mkdir()
+    with pytest.raises(ValueError, match="OSL_MODEL_ROOT"):
+        resolve_local_source(settings, str(outside), None)
+
+
+def test_custom_id_and_public_local_record_validation():
+    assert validate_local_model_id("football-model:v2") == "football-model:v2"
+    with pytest.raises(ValueError):
+        validate_local_model_id("folder/model")
+    local = record()
+    local.update({"source_type": "local", "source": "/secret/model", "config_path": "/secret/config", "error": "at /secret/model"})
+    visible = public_record(local)
+    assert "source" not in visible
+    assert "config_path" not in visible
+    assert "/secret" not in visible["error"]
+
+
+def test_config_driven_runner_is_weightless(tmp_path):
+    config = tmp_path / "config.yaml"
+    config.write_text("TRAIN:\n  runner:\n    type: runner_h5_header_rule\n")
+    assert infer_source_mode(str(config), "org/config-only") == "config_only"
+
+
+def test_ordinary_config_requires_checkpoint(tmp_path):
+    config = tmp_path / "config.yaml"
+    config.write_text("TRAIN:\n  runner:\n    type: default\n")
+    assert infer_source_mode(str(config), "org/model") == "checkpoint"
+
+
+def test_operation_secret_is_consumed_and_not_part_of_records():
+    settings = SimpleNamespace(redis_url="redis://unused", model_operation_timeout_seconds=60)
+    registry = ModelRegistry(settings, FakeRedis())
+    registry.store_operation_secret("operation", "hf_secret")
+    assert registry.consume_operation_secret("operation") == "hf_secret"
+    assert registry.consume_operation_secret("operation") is None
+    assert registry.list() == []

{opensportslib-0.3.1.dev27 → opensportslib-0.3.2}/tests/unit/contracts/test_package.py

@@ -47,9 +47,8 @@ def test_packaging_includes_all_yaml_presets():
     assert experiment_config_paths(), f"No task presets found under {CONFIG_ROOT}"
 
 
-@pytest.mark.parametrize("filename", ["coverage-baseline.txt", "server-coverage-baseline.txt"])
-def test_coverage_baseline_is_a_valid_committed_percentage(filename):
-    raw = (REPOSITORY_ROOT / "scripts" / filename).read_text(encoding="utf-8").strip()
+def test_coverage_baseline_is_a_valid_committed_percentage():
+    raw = (REPOSITORY_ROOT / "scripts" / "coverage-baseline.txt").read_text(encoding="utf-8").strip()
     assert raw.isdigit(), "coverage-baseline.txt must contain one integer percentage"
     assert 1 <= int(raw) <= 100
 

{opensportslib-0.3.1.dev27 → opensportslib-0.3.2}/tests/unit/core/test_classification_trainer.py

@@ -1,6 +1,5 @@
 from types import SimpleNamespace
 
-import pytest
 import torch
 from omegaconf import OmegaConf
 
@@ -162,92 +161,3 @@ def test_video_train_loader_respects_explicit_context(monkeypatch):
     assert len(dataloader_calls) == 2
     assert (dataloader_calls[0]["multiprocessing_context"].get_start_method() == "forkserver")
     assert (dataloader_calls[1]["multiprocessing_context"].get_start_method() == "forkserver")
-
-
-@pytest.fixture
-def cpu_trainer(tmp_path, monkeypatch):
-    from opensportslib.core.loss.builder import build_criterion
-    from torch.utils.data import DataLoader
-
-    monkeypatch.setattr(classification_trainer.wandb, "watch", lambda *args, **kwargs: None)
-    monkeypatch.setattr(classification_trainer.wandb, "run", None)
-    monkeypatch.setattr(classification_trainer, "log_confusion_matrix_wandb", lambda **kwargs: None)
-    data = [{"id": f"clip-{i}", "pixel_values": torch.eye(3)[i % 3], "labels": i % 3} for i in range(6)]
-    loader = DataLoader(data, batch_size=3, shuffle=False)
-    model = torch.nn.Linear(3, 3)
-    with torch.no_grad():
-        model.weight.copy_(torch.eye(3))
-        model.bias.zero_()
-    optimizer = torch.optim.SGD(model.parameters(), lr=.1, momentum=.9)
-    scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=.5)
-    return classification_trainer.MVTrainerClassification(
-        train_loader=loader, val_loader=loader, test_loader=loader,
-        model=model, optimizer=optimizer, scheduler=scheduler,
-        criterion=build_criterion({"type": "CrossEntropyLoss"}),
-        class_weights=None, class_names={0: "PASS", 1: "SHOT", 2: "HEADER"},
-        save_dir=str(tmp_path), model_name="tiny", max_epochs=2, device="cpu",
-        monitor="loss", mode="min",
-    )
-
-
-@pytest.mark.parametrize("weighted", [False, True])
-def test_cpu_training_checkpoint_resumes_identical_next_update(cpu_trainer, weighted):
-    from opensportslib.core.utils.checkpoint import load_checkpoint
-
-    trainer = cpu_trainer
-    if weighted:
-        trainer.class_weights = torch.tensor([1., 2., 3.])
-    before = trainer.model.weight.detach().clone()
-    trainer.train()
-    assert not torch.equal(before, trainer.model.weight)
-    assert trainer.best_checkpoint_path is not None
-    restored = torch.nn.Linear(3, 3)
-    optimizer = torch.optim.SGD(restored.parameters(), lr=.9, momentum=.9)
-    scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=.5)
-    _, _, _, _, epoch, checkpoint = load_checkpoint(
-        restored, trainer.best_checkpoint_path, optimizer=optimizer,
-        scheduler=scheduler, device=torch.device("cpu"),
-    )
-    assert epoch == 2
-    assert checkpoint["best_metric"] == pytest.approx(trainer.best_metric)
-    assert optimizer.param_groups[0]["lr"] == pytest.approx(.025)
-    assert scheduler.state_dict() == trainer.scheduler.state_dict()
-    assert optimizer.state  # Momentum must be populated, not an empty-state round trip.
-    batch = next(iter(trainer.train_loader))
-    expected_before = trainer.model(batch["pixel_values"]).detach()
-    torch.testing.assert_close(restored(batch["pixel_values"]), expected_before)
-    trainer._process_batch(batch, train=True)
-    optimizer.zero_grad()
-    loss = trainer.criterion(output=restored(batch["pixel_values"]), labels=batch["labels"], weight=trainer.class_weights)
-    loss.backward()
-    torch.nn.utils.clip_grad_norm_(restored.parameters(), 1.)
-    optimizer.step()
-    for actual, expected in zip(restored.parameters(), trainer.model.parameters()):
-        torch.testing.assert_close(actual, expected)
-    test_loss, scores = trainer.test()
-    assert test_loss > 0 and scores["accuracy"] == 1.
-
-
-@pytest.mark.parametrize("labelled", [False, True])
-def test_evaluation_keeps_weights_and_exports_sample_predictions(cpu_trainer, labelled):
-    trainer = cpu_trainer
-    batch = next(iter(trainer.test_loader))
-    if not labelled:
-        batch.pop("labels")
-    original = {name: value.clone() for name, value in trainer.model.state_dict().items()}
-    logits, labels, loss, scores = trainer._run_epoch([batch], epoch="check", set_name="test")
-    assert logits.shape == (3, 3)
-    assert len(labels) == (3 if labelled else 0)
-    assert loss > 0 if labelled else loss == 0
-    assert scores["accuracy"] == 1. if labelled else scores == {}
-    assert [item["id"] for item in trainer.predictions_payload["data"]] == batch["id"]
-    assert [item["labels"]["action"]["label"] for item in trainer.predictions_payload["data"]] == ["PASS", "SHOT", "HEADER"]
-    for name, value in trainer.model.state_dict().items():
-        torch.testing.assert_close(value, original[name])
-
-
-def test_empty_evaluation_returns_empty_predictions(cpu_trainer):
-    logits, labels, loss, scores = cpu_trainer._run_epoch([], epoch="empty", set_name="test")
-    assert len(logits) == len(labels) == 0
-    assert loss == 0 and scores == {}
-    assert cpu_trainer.predictions_payload["data"] == []

{opensportslib-0.3.1.dev27 → opensportslib-0.3.2}/tests/unit/data/test_localization_intervals.py

@@ -154,7 +154,6 @@ class _FrameCapture:
 
     def __init__(self, *_):
         self.position = 0
-        self.released = False
         self.seek_positions = []
         self.read_positions = []
         self.grab_positions = []
@@ -187,7 +186,7 @@ class _FrameCapture:
         return True
 
     def release(self):
-        self.released = True
+        pass
 
 
 def test_frame_reader_seeks_and_stops_inside_interval(monkeypatch):
@@ -405,46 +404,3 @@ def test_v2_evaluator_counts_missing_verified_interval_as_empty(tmp_path):
 
     assert "Average mAP" in result
     assert "Average mAP  54.55" in result
-
-
-@pytest.fixture
-def boundary_reader(monkeypatch):
-    class BrightCapture(_FrameCapture):
-        def read(self):
-            ok, frame = super().read()
-            if ok:
-                frame.fill(127)
-            return ok, frame
-
-    _FrameCapture.instances.clear()
-    monkeypatch.setattr(cv2, "VideoCapture", BrightCapture)
-    return FrameReader("rgb", crop_transform=None, img_transform=lambda frame: frame,
-                       same_transform=False, sample_fps=2, TARGET_HEIGHT=2, TARGET_WIDTH=2)
-
-
-@pytest.mark.parametrize("start,end,bounds,message", [
-    (2, 2, {}, "Invalid requested frame range"),
-    (3, 2, {}, "Invalid requested frame range"),
-    (0, 2, {"source_start_frame": 0}, "Both source"),
-    (0, 2, {"source_end_frame": 10}, "Both source"),
-    (0, 2, {"source_start_frame": -1, "source_end_frame": 10}, "Invalid source interval"),
-    (0, 2, {"source_start_frame": 10, "source_end_frame": 10}, "Invalid source interval"),
-    (0, 2, {"source_start_frame": 0, "source_end_frame": 101}, "Invalid source interval"),
-    (25, 27, {}, "No frames read"),
-])
-def test_frame_reader_rejects_invalid_or_empty_ranges_and_releases_capture(boundary_reader, start, end, bounds, message):
-    with pytest.raises(ValueError, match=message):
-        boundary_reader.load_frames_ocv("unused.mp4", start, end, **bounds)
-    assert _FrameCapture.instances[-1].released
-    assert not _FrameCapture.instances[-1].read_positions
-
-
-@pytest.mark.parametrize("pad", [False, True])
-def test_frame_reader_end_padding_preserves_real_samples(boundary_reader, pad):
-    frames = boundary_reader.load_frames_ocv("unused.mp4", 18, 23, pad=pad)
-    assert frames.shape == ((5 if pad else 2), 3, 2, 2)
-    assert frames[:2].count_nonzero() > 0
-    if pad:
-        assert frames[2:].count_nonzero() == 0
-    assert _FrameCapture.instances[-1].read_positions == [90, 95]
-    assert _FrameCapture.instances[-1].released

opensportslib-0.3.2/tests/unit/models/test_localization_metrics.py

@@ -0,0 +1,25 @@
+"""Prediction-format contracts for localization metrics."""
+
+from __future__ import annotations
+
+from opensportslib.metrics.localization_metric import build_snpro_prediction_json
+
+
+def test_localization_prediction_builder_emits_osl_v2_shape():
+    payload = build_snpro_prediction_json([
+        {
+            "video": "clips/match.mp4",
+            "fps": 25,
+            "events": [{
+                "label": "GOAL",
+                "gameTime": "1 - 00:10",
+                "frame": 250,
+                "position": 10_000,
+                "confidence": 0.9,
+            }],
+        }
+    ], split="test", created_by="test")
+    assert payload["version"] == "2.0"
+    assert payload["task"] == "localization"
+    assert payload["metadata"] == {"type": "predictions", "created_by": "test", "split": "test"}
+    assert payload["data"][0]["events"][0]["position_ms"] == 10_000

{opensportslib-0.3.1.dev27 → opensportslib-0.3.2}/tests/unit/models/test_vqa_qwen_xvars.py

@@ -6,7 +6,109 @@ from opensportslib.models.base.qwen_xvars import QWEN_MM_PROJECTOR_FILE, QwenXVa
 from opensportslib.models.builder import build_model
 
 
-from tests.helpers.causal_lm import TinyGenerateLM, TinyTokenizer
+class TinyTokenizer:
+    pad_token_id = 0
+    eos_token_id = 1
+    pad_token = "<pad>"
+    eos_token = "</s>"
+
+    def __init__(self):
+        self.vocab = {"<pad>": 0, "</s>": 1, "<vid_patch>": 2, "<vid_start>": 3, "<vid_end>": 4}
+
+    def get_vocab(self):
+        return dict(self.vocab)
+
+    def add_special_tokens(self, payload):
+        added = 0
+        for token in payload.get("additional_special_tokens", []):
+            if token not in self.vocab:
+                self.vocab[token] = len(self.vocab)
+                added += 1
+        return added
+
+    def convert_tokens_to_ids(self, token):
+        return self.vocab[token]
+
+    def __len__(self):
+        return len(self.vocab)
+
+    def __call__(self, text, return_tensors=None, **kwargs):
+        del kwargs
+        if isinstance(text, list):
+            text = text[0]
+        tokens = []
+        i = 0
+        while i < len(text):
+            matched = False
+            for token in ("<vid_start>", "<vid_patch>", "<vid_end>", "</s>"):
+                if text.startswith(token, i):
+                    tokens.append(token)
+                    i += len(token)
+                    matched = True
+                    break
+            if matched:
+                continue
+            if text[i].isspace():
+                i += 1
+                continue
+            j = i
+            while j < len(text) and not text[j].isspace() and not any(
+                text.startswith(token, j) for token in ("<vid_start>", "<vid_patch>", "<vid_end>", "</s>")
+            ):
+                j += 1
+            tokens.append(text[i:j])
+            i = j
+        ids = []
+        for token in tokens:
+            if token not in self.vocab:
+                self.vocab[token] = len(self.vocab)
+            ids.append(self.vocab[token])
+        attn = [1] * len(ids)
+        if return_tensors == "pt":
+            return {"input_ids": torch.tensor([ids]), "attention_mask": torch.tensor([attn])}
+        return SimpleNamespace(input_ids=ids, attention_mask=attn)
+
+    def batch_decode(self, sequences, skip_special_tokens=True):
+        del sequences, skip_special_tokens
+        return ["qwen answer </s>"]
+
+
+class TinyGenerateLM(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.config = SimpleNamespace(hidden_size=4, vocab_size=64, use_cache=True)
+        self.generation_config = SimpleNamespace(use_cache=False)
+        self.emb = torch.nn.Embedding(128, 4)
+        self.lm = torch.nn.Linear(4, 64)
+        self.seen_inputs_embeds = None
+        self.generate_kwargs = None
+
+    def get_input_embeddings(self):
+        return self.emb
+
+    def resize_token_embeddings(self, size):
+        return self.emb
+
+    def save_pretrained(self, output_dir):
+        del output_dir
+
+    def forward(self, input_ids=None, inputs_embeds=None, attention_mask=None, labels=None, **kwargs):
+        del input_ids, attention_mask, kwargs
+        self.seen_inputs_embeds = inputs_embeds.detach().clone()
+        logits = self.lm(inputs_embeds)
+        loss = logits.sum() * 0
+        if labels is not None:
+            loss = loss + 0.123
+        return SimpleNamespace(loss=loss, logits=logits)
+
+    def generate(self, input_ids=None, inputs_embeds=None, attention_mask=None, **kwargs):
+        del attention_mask
+        self.generate_kwargs = {"input_ids": input_ids, "inputs_embeds": inputs_embeds, **kwargs}
+        extra = torch.tensor([[9, 1]], device=input_ids.device if input_ids is not None else inputs_embeds.device)
+        if input_ids is None:
+            prefix = torch.zeros((1, inputs_embeds.shape[1]), dtype=torch.long, device=extra.device)
+            return torch.cat((prefix, extra), dim=1)
+        return torch.cat((input_ids, extra), dim=1)
 
 
 def _cfg(tmp_path):