opensportslib 0.3.1.dev26__tar.gz → 0.3.1.dev27__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensportslib
-Version: 0.3.1.dev26
+Version: 0.3.1.dev27
 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)
+- **Inference server:** [server/README.md](server/README.md), including checkpoint and config-only rule-model registration
 - **PyPI:** https://pypi.org/project/opensportslib/
 - **Issues:** https://github.com/OpenSportsLab/opensportslib/issues
 

{opensportslib-0.3.1.dev26 → opensportslib-0.3.1.dev27}/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)
+- **Inference server:** [server/README.md](server/README.md), including checkpoint and config-only rule-model registration
 - **PyPI:** https://pypi.org/project/opensportslib/
 - **Issues:** https://github.com/OpenSportsLab/opensportslib/issues
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensportslib
-Version: 0.3.1.dev26
+Version: 0.3.1.dev27
 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)
+- **Inference server:** [server/README.md](server/README.md), including checkpoint and config-only rule-model registration
 - **PyPI:** https://pypi.org/project/opensportslib/
 - **Issues:** https://github.com/OpenSportsLab/opensportslib/issues
 

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

@@ -154,6 +154,7 @@ 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
@@ -189,6 +190,7 @@ 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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opensportslib"
-version = "0.3.1.dev26"
+version = "0.3.1.dev27"
 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",]
+source = [ "opensportslib", "server",]
 branch = true
 omit = [ "*/.ipynb_checkpoints/*",]
 

opensportslib-0.3.1.dev27/tests/helpers/causal_lm.py

@@ -0,0 +1,110 @@
+"""Small tokenizer and causal model doubles for offline generation tests."""
+
+from types import SimpleNamespace
+
+import torch
+
+
+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)

opensportslib-0.3.1.dev27/tests/unit/api/test_server_jobs.py

@@ -0,0 +1,121 @@
+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")
+
+
+def test_job_lifecycle_persists_request_result_and_clears_failure(tmp_path):
+    import json
+
+    jobs = store(tmp_path)
+    metadata = jobs.create_job(request(), "model", session_id="session", input_source="uploaded.mp4")
+    job_id = metadata.job_id
+    assert jobs.load_result(job_id) is None
+    assert jobs.mark_running(job_id).status is JobStatus.RUNNING
+    assert jobs.mark_failed(job_id, "temporary failure").error == "temporary failure"
+    assert jobs.load_metadata(job_id).status is JobStatus.FAILED
+    payload = {"predictions": [{"label": "PASS", "confidence": .9}]}
+    succeeded = jobs.mark_succeeded(job_id, payload)
+    assert succeeded.status is JobStatus.SUCCEEDED and succeeded.error is None
+    assert jobs.load_result(job_id) == payload
+    assert jobs.load_metadata(job_id).session_id == "session"
+    assert jobs.load_metadata(job_id).input_source == "uploaded.mp4"
+    saved = json.loads((jobs.settings.tmp_dir / job_id / "request.json").read_text())
+    assert saved["video_path"] == "/tmp/clip.mp4"
+
+
+@pytest.mark.parametrize("source", ["video_path", "media_url", "test_set_path"])
+def test_updating_request_updates_persisted_input_source(tmp_path, source):
+    import json
+
+    jobs = store(tmp_path)
+    metadata = jobs.create_job(request(), "model")
+    replacement = PredictRequest(task_type="classification", **{source: "new-input"})
+    jobs.update_request_payload(metadata.job_id, replacement)
+    assert jobs.load_metadata(metadata.job_id).input_source == "new-input"
+    saved = json.loads((jobs.settings.tmp_dir / metadata.job_id / "request.json").read_text())
+    assert saved[source] == "new-input"
+
+
+def test_atomic_metadata_failure_preserves_last_valid_record(tmp_path, monkeypatch):
+    import storage.jobs as module
+
+    jobs = store(tmp_path)
+    metadata = jobs.create_job(request(), "model")
+    previous = jobs.metadata_path(metadata.job_id).read_bytes()
+    def fail_replace(*args):
+        raise OSError("disk replacement failed")
+    monkeypatch.setattr(module.os, "replace", fail_replace)
+    with pytest.raises(OSError, match="replacement failed"):
+        jobs.mark_running(metadata.job_id)
+    assert jobs.metadata_path(metadata.job_id).read_bytes() == previous
+    assert not list(jobs.settings.jobs_dir.glob("*.tmp"))
+    assert jobs.load_metadata(metadata.job_id).status is JobStatus.QUEUED
+
+
+@pytest.mark.parametrize("operation", ["mark_running", "mark_failed", "mark_succeeded"])
+def test_updates_to_missing_job_fail_without_creating_results(tmp_path, operation):
+    jobs = store(tmp_path)
+    args = {"mark_running": (), "mark_failed": ("failure",), "mark_succeeded": ({},)}[operation]
+    with pytest.raises(FileNotFoundError, match="metadata missing"):
+        getattr(jobs, operation)("missing", *args)
+    assert jobs.load_result("missing") is None

opensportslib-0.3.1.dev27/tests/unit/api/test_server_registry.py

@@ -0,0 +1,314 @@
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import Mock
+
+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,
+    resolve_huggingface_source,
+    infer_source_mode,
+    require_api_key,
+    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"]
+
+
+@pytest.mark.parametrize("runner_section", ["MODEL", "TRAIN"])
+def test_config_driven_runner_is_weightless(tmp_path, runner_section):
+    config = tmp_path / "config.yaml"
+    config.write_text(f"{runner_section}:\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() == []
+
+
+def _mock_hub(monkeypatch, config_path, files):
+    import huggingface_hub
+
+    download = Mock(return_value=str(config_path))
+    listing = Mock(return_value=files)
+    monkeypatch.setattr(huggingface_hub, "hf_hub_download", download)
+    monkeypatch.setattr(huggingface_hub, "list_repo_files", listing)
+    return download, listing
+
+
+@pytest.mark.parametrize("variant", [
+    "h5_header_skeleton", "h5_header_skeleton_recall", "h5_header_skeleton_max_recall",
+])
+def test_hf_rule_source_loads_localization_service_without_weights(tmp_path, monkeypatch, variant):
+    from opensportslib.core.config import load_config
+    from opensportslib.core.config.loader import save_config
+    from services.localization_service import LocalizationService
+
+    canonical = load_config(
+        SERVER_ROOT.parent / "opensportslib/configs/localization/h5_header_skeleton.yaml",
+        as_namespace=False,
+    )
+    canonical["MODEL"]["components"]["rule"]["source"]["name"] = variant
+    canonical["SYSTEM"]["paths"]["save_dir"] = str(tmp_path / "outputs")
+    canonical["DATA"]["common"]["data_root"] = str(tmp_path)
+    canonical["DATA"]["common"]["splits"]["test"]["source_path"] = str(tmp_path)
+    config_path = tmp_path / "config.yaml"
+    save_config(canonical, config_path)
+    download, listing = _mock_hub(monkeypatch, config_path, ["config.yaml"])
+    model_id = "example/skeleton"
+
+    resolved_path, source_mode, weights = resolve_huggingface_source(model_id, token="test-token")
+    assert (resolved_path, source_mode, weights) == (str(config_path), "config_only", None)
+    download.assert_called_once_with(repo_id=model_id, filename="config.yaml", token="test-token")
+    listing.assert_called_once_with(model_id, token="test-token")
+
+    registry = ModelRegistry(SimpleNamespace(redis_url="redis://unused"), FakeRedis())
+    registered = record(model_id=model_id, source=model_id)
+    registered.update(task_type="localization", config_path=resolved_path, source_mode=source_mode)
+    settings = registry.model_settings(registered)
+    assert settings.weights is None
+    service = LocalizationService(settings)
+    service.preload()
+    assert service.model.last_loaded_weights is None
+    assert service.model.config.MODEL.components.rule.source.name == variant
+    assert service.label_schema["action"]["labels"] == ["header"]
+    # Older persisted records without source_mode must infer the same behavior.
+    registered.pop("source_mode")
+    assert registry.model_settings(registered).weights is None
+    assert download.call_count == 1
+
+
+@pytest.mark.parametrize("checkpoint", ["model.pt", "model.pth.tar", "adapter_model.safetensors"])
+def test_hf_checkpoint_source_keeps_weights(tmp_path, monkeypatch, checkpoint):
+    config_path = tmp_path / "config.yaml"
+    config_path.write_text("MODEL:\n  runner:\n    type: runner_e2e\n")
+    _mock_hub(monkeypatch, config_path, ["config.yaml", checkpoint])
+    model_id = "example/checkpoint"
+
+    path, mode, weights = resolve_huggingface_source(model_id)
+    assert (path, mode, weights) == (str(config_path), "checkpoint", model_id)
+    registry = ModelRegistry(SimpleNamespace(redis_url="redis://unused"), FakeRedis())
+    registered = record(model_id=model_id, source=model_id)
+    registered.update(config_path=path, source_mode=mode)
+    assert registry.model_settings(registered).weights == model_id
+
+
+@pytest.mark.parametrize("content", [
+    "MODEL:\n  runner:\n    type: runner_e2e\n",
+    "{}",
+    "[]",
+    "MODEL: [",
+])
+def test_hf_weightless_source_without_supported_runner_is_rejected(tmp_path, monkeypatch, content):
+    config_path = tmp_path / "config.yaml"
+    config_path.write_text(content)
+    _mock_hub(monkeypatch, config_path, ["config.yaml"])
+
+    with pytest.raises(ValueError, match="no supported checkpoint"):
+        resolve_huggingface_source("example/unsupported")
+
+
+def test_hf_repository_access_failure_is_reported(tmp_path, monkeypatch):
+    config_path = tmp_path / "config.yaml"
+    config_path.write_text("MODEL: {}")
+    _, listing = _mock_hub(monkeypatch, config_path, [])
+    listing.side_effect = RuntimeError("repository access denied")
+    with pytest.raises(ValueError, match="Could not access Hugging Face repository"):
+        resolve_huggingface_source("example/gated", token="test-token")
+
+
+def test_default_selection_and_deletion_preserve_other_tasks():
+    registry = ModelRegistry(SimpleNamespace(redis_url="redis://unused"), FakeRedis())
+    registry.put(record("classifier"))
+    localizer = record("localizer")
+    localizer["task_type"] = "localization"
+    registry.put(localizer)
+    registry.set_default("classification", "classifier")
+    registry.set_default("localization", "localizer")
+    assert registry.resolve("classification", None)["model_id"] == "classifier"
+    assert registry.resolve("localization", None)["model_id"] == "localizer"
+    assert [item["model_id"] for item in registry.list()] == ["classifier", "localizer"]
+    registry.delete("classifier")
+    assert registry.resolve("classification", None) is None
+    assert registry.resolve("localization", None)["model_id"] == "localizer"
+    assert registry.get("classifier") is None
+
+
+@pytest.mark.parametrize("status", ["registering", "failed", "unregistering"])
+def test_only_ready_models_can_be_defaults(status):
+    registry = ModelRegistry(SimpleNamespace(redis_url="redis://unused"), FakeRedis())
+    candidate = record()
+    candidate["status"] = status
+    registry.put(candidate)
+    with pytest.raises(ValueError, match="READY"):
+        registry.set_default("classification", "model")
+    assert registry.resolve("classification", None) is None
+
+
+def test_unknown_and_wrong_task_models_cannot_be_selected_as_defaults():
+    registry = ModelRegistry(SimpleNamespace(redis_url="redis://unused"), FakeRedis())
+    with pytest.raises(KeyError):
+        registry.set_default("classification", "missing")
+    registry.put(record())
+    with pytest.raises(ValueError, match="requested task"):
+        registry.set_default("localization", "model")
+    with pytest.raises(TypeError, match="not `localization`"):
+        registry.resolve("localization", "model")
+    assert registry.resolve("classification", "missing") is None
+
+
+def test_operations_round_trip_and_secrets_can_be_removed():
+    registry = ModelRegistry(SimpleNamespace(redis_url="redis://unused", model_operation_timeout_seconds=60), FakeRedis())
+    assert registry.get_operation("missing") is None
+    operation = registry.create_operation("register", "model")
+    assert operation["status"] == "queued"
+    operation.update(status="failed", error="missing config")
+    registry.save_operation(operation)
+    assert registry.get_operation(operation["operation_id"])["error"] == "missing config"
+    registry.store_operation_secret(operation["operation_id"], "temporary")
+    registry.delete_operation_secret(operation["operation_id"])
+    assert registry.consume_operation_secret(operation["operation_id"]) is None
+
+
+@pytest.mark.parametrize("authorization", [None, "Bearer wrong", "Bearer"])
+def test_api_key_rejects_missing_or_wrong_credentials(authorization):
+    with pytest.raises(PermissionError, match="Invalid API key"):
+        require_api_key(SimpleNamespace(api_key="expected"), authorization)
+
+
+def test_api_key_accepts_valid_bearer_and_disables_unconfigured_admin():
+    require_api_key(SimpleNamespace(api_key="expected"), "Bearer expected")
+    with pytest.raises(RuntimeError, match="disabled"):
+        require_api_key(SimpleNamespace(api_key=""), "Bearer expected")
+
+
+def test_local_source_rejects_symlink_escape_and_requires_file_config(tmp_path):
+    root = tmp_path / "models"
+    root.mkdir()
+    outside = tmp_path / "outside.pt"
+    outside.write_bytes(b"checkpoint")
+    escaped = root / "escape.pt"
+    escaped.symlink_to(outside)
+    settings = SimpleNamespace(model_root=root)
+    with pytest.raises(ValueError, match="OSL_MODEL_ROOT"):
+        resolve_local_source(settings, str(escaped), None)
+    checkpoint = root / "model.pt"
+    checkpoint.write_bytes(b"checkpoint")
+    with pytest.raises(ValueError, match="config_path is required"):
+        resolve_local_source(settings, str(checkpoint), None)
+    with pytest.raises(ValueError, match="config does not exist"):
+        resolve_local_source(settings, str(checkpoint), str(root / "missing.yaml"))
+    with pytest.raises(ValueError, match="weights do not exist"):
+        resolve_local_source(settings, str(root / "missing.pt"), None)
+    config = root / "config.yaml"
+    config.write_text("MODEL: {}")
+    assert resolve_local_source(settings, str(checkpoint), str(config)) == (checkpoint, config)

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

@@ -47,8 +47,9 @@ def test_packaging_includes_all_yaml_presets():
     assert experiment_config_paths(), f"No task presets found under {CONFIG_ROOT}"
 
 
-def test_coverage_baseline_is_a_valid_committed_percentage():
-    raw = (REPOSITORY_ROOT / "scripts" / "coverage-baseline.txt").read_text(encoding="utf-8").strip()
+@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()
     assert raw.isdigit(), "coverage-baseline.txt must contain one integer percentage"
     assert 1 <= int(raw) <= 100