opensportslib 0.3.1.dev9__tar.gz → 0.3.1.dev11__tar.gz

{opensportslib-0.3.1.dev9/opensportslib.egg-info → opensportslib-0.3.1.dev11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensportslib
-Version: 0.3.1.dev9
+Version: 0.3.1.dev11
 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
@@ -45,6 +45,10 @@ See the [complete inference server guide](docs/server/inference-server.md) for
 installation, registry administration, curl requests, single-video inference,
 full-test-set and per-sample remote inference, job polling, and sessions.
 
+For Docker administration, set `OSL_MODEL_ADMIN_TOKEN` in the private
+`server/.env` file, recreate the containers after changes, and use the exact
+same value as the Python client's `admin_token`. Never commit the real token.
+
 ## Configuration From Hugging Face
 
 Prepare and inspect configuration before model weights are allocated:

{opensportslib-0.3.1.dev9 → opensportslib-0.3.1.dev11}/README.md

@@ -9,6 +9,10 @@ See the [complete inference server guide](docs/server/inference-server.md) for
 installation, registry administration, curl requests, single-video inference,
 full-test-set and per-sample remote inference, job polling, and sessions.
 
+For Docker administration, set `OSL_MODEL_ADMIN_TOKEN` in the private
+`server/.env` file, recreate the containers after changes, and use the exact
+same value as the Python client's `admin_token`. Never commit the real token.
+
 ## Configuration From Hugging Face
 
 Prepare and inspect configuration before model weights are allocated:

{opensportslib-0.3.1.dev9 → opensportslib-0.3.1.dev11}/opensportslib/apis/base_task_model.py

@@ -76,6 +76,7 @@ class BaseTaskModel(ConfigurationMixin, ABC):
         self.remote_poll_interval = float(remote_poll_interval)
         self.remote_result_timeout = float(remote_result_timeout)
         self.remote_model_id = remote_model_id
+        self.remote_session_id: str | None = None
         if self.remote_timeout <= 0 or self.remote_poll_interval <= 0 or self.remote_result_timeout <= 0:
             raise ValueError("Remote timeout values must be positive.")
 
@@ -86,7 +87,14 @@ class BaseTaskModel(ConfigurationMixin, ABC):
             if self.is_remote:
                 self._config_editor.remote_overrides()
 
-        if config is None and self._config_editor is None:
+        remote_only = config is None and self._config_editor is None and self.is_remote and weights is None
+        if remote_only:
+            # Remote workers own model configuration and weights. Keep a
+            # minimal namespace so shared decorators and remote-only methods
+            # can operate without downloading or constructing a local model.
+            self.config_path = None
+            self.config = dict_to_namespace({})
+        elif config is None and self._config_editor is None:
             from huggingface_hub.utils import HFValidationError, validate_repo_id
 
             if (not isinstance(weights, str) or os.path.exists(expand(weights))
@@ -107,7 +115,7 @@ class BaseTaskModel(ConfigurationMixin, ABC):
         if self._config_editor is not None:
             self.config_path = self._config_editor.source
             self.config = dict_to_namespace(self._config_editor.get_config())
-        else:
+        elif self._config_editor is None and not remote_only:
             self.config_path = resolve_config_path(config)
             self._config_editor = Config.from_file(self.config_path)
             self.config = dict_to_namespace(self._config_editor.get_config())
@@ -203,7 +211,7 @@ class BaseTaskModel(ConfigurationMixin, ABC):
                 archive_path,
                 archive_path.stat().st_size,
             )
-            return self._post_multipart(
+            response = self._post_multipart(
                 "/predict",
                 fields={
                     "task_type": task_type,
@@ -215,6 +223,7 @@ class BaseTaskModel(ConfigurationMixin, ABC):
                     "media_archive": archive_path,
                 },
             )
+            return response
 
     def submit_per_sample_inference(
         self,
@@ -304,7 +313,44 @@ class BaseTaskModel(ConfigurationMixin, ABC):
             fields["question"] = question
         if session_id is not None:
             fields["session_id"] = session_id
-        return self._post_multipart("/predict", fields=fields, files={"upload_file": source})
+        response = self._post_multipart("/predict", fields=fields, files={"upload_file": source})
+        self._remember_remote_session(response)
+        return response
+
+    def submit_session_inference(
+        self,
+        *,
+        task_type: str,
+        session_id: str,
+        model_id: str | None = None,
+        task_options: dict[str, Any] | None = None,
+        question: str | None = None,
+    ) -> dict[str, Any]:
+        if not self.remote:
+            raise RuntimeError("Remote inference is not configured. Pass `remote=` to the model constructor.")
+        fields = {
+            "task_type": task_type,
+            "model_id": model_id or self.remote_model_id or "",
+            "session_id": session_id,
+            "task_options": json.dumps(task_options or {}),
+        }
+        if question is not None:
+            fields["question"] = question
+        response = self._post_multipart("/predict", fields=fields, files={})
+        self._remember_remote_session(response)
+        return response
+
+    def _remember_remote_session(self, response: dict[str, Any]) -> None:
+        session_id = response.get("session_id")
+        if session_id:
+            self.remote_session_id = str(session_id)
+
+    @property
+    def last_remote_session_id(self) -> str | None:
+        return self.remote_session_id
+
+    def clear_remote_session(self) -> None:
+        self.remote_session_id = None
 
     def get_remote_job(self, job_id: str) -> dict[str, Any]:
         return self._request_json(f"/jobs/{job_id}")

{opensportslib-0.3.1.dev9 → opensportslib-0.3.1.dev11}/opensportslib/apis/classification.py

@@ -261,6 +261,7 @@ class ClassificationModel(BaseTaskModel):
         use_ddp=False,
         use_wandb=True,
         video_path: str | None = None,
+        session_id: str | None = None,
         **kwargs,
     ):
         """Run model inference and return predictions in OSL JSON format."""
@@ -273,12 +274,27 @@ class ClassificationModel(BaseTaskModel):
             remote_task_options = kwargs.pop("remote_task_options", None)
             if kwargs:
                 raise TypeError(f"Unsupported remote inference options: {', '.join(kwargs)}")
+            active_session_id = (
+                session_id
+                if session_id is not None
+                else (self.remote_session_id if video_path is None else None)
+            )
             if video_path is not None:
                 if remote_mode != "full_test_set":
                     raise ValueError("`remote_mode=per_sample` requires `test_set`, not direct video input.")
                 job = self.submit_video_inference(
                     task_type="classification",
                     video_path=video_path,
+                    session_id=active_session_id,
+                    model_id=remote_model_id,
+                    task_options=remote_task_options,
+                )
+                self.last_remote_failures = []
+                return self.wait_for_remote_result(job["job_id"])["result"]["predictions"]
+            if test_set is None and active_session_id is not None:
+                job = self.submit_session_inference(
+                    task_type="classification",
+                    session_id=active_session_id,
                     model_id=remote_model_id,
                     task_options=remote_task_options,
                 )

{opensportslib-0.3.1.dev9 → opensportslib-0.3.1.dev11}/opensportslib/apis/localization.py

@@ -427,6 +427,7 @@ class LocalizationModel(BaseTaskModel):
         weights=None,
         use_wandb=True,
         video_path: str | None = None,
+        session_id: str | None = None,
         **kwargs,
     ):
         """Run model inference and return predictions in OSL JSON format."""
@@ -439,12 +440,27 @@ class LocalizationModel(BaseTaskModel):
             remote_task_options = kwargs.pop("remote_task_options", None)
             if kwargs:
                 raise TypeError(f"Unsupported remote inference options: {', '.join(kwargs)}")
+            active_session_id = (
+                session_id
+                if session_id is not None
+                else (self.remote_session_id if video_path is None else None)
+            )
             if video_path is not None:
                 if remote_mode != "full_test_set":
                     raise ValueError("`remote_mode=per_sample` requires `test_set`, not direct video input.")
                 job = self.submit_video_inference(
                     task_type="localization",
                     video_path=video_path,
+                    session_id=active_session_id,
+                    model_id=remote_model_id,
+                    task_options=remote_task_options,
+                )
+                self.last_remote_failures = []
+                return self.wait_for_remote_result(job["job_id"])["result"]["predictions"]
+            if test_set is None and active_session_id is not None:
+                job = self.submit_session_inference(
+                    task_type="localization",
+                    session_id=active_session_id,
                     model_id=remote_model_id,
                     task_options=remote_task_options,
                 )

{opensportslib-0.3.1.dev9 → opensportslib-0.3.1.dev11}/opensportslib/apis/vqa.py

@@ -274,17 +274,21 @@ class VQAModel(BaseTaskModel):
                 return self.wait_for_remote_result(job["job_id"])["result"]["predictions"]
             if remote_mode != "full_test_set":
                 raise ValueError("`remote_mode=per_sample` requires `test_set`, not direct VQA input.")
-            if session_id is not None and video_path is None and question:
-                job = self._post_multipart(
-                    "/predict",
-                    fields={
-                        "task_type": "vqa",
-                        "model_id": remote_model_id or self.remote_model_id or "",
-                        "session_id": session_id,
-                        "question": str(question),
-                        "task_options": json.dumps(remote_task_options or {}),
-                    },
-                    files={},
+            # A stored session is for question-only follow-ups. A new video
+            # must start a fresh server session; explicitly supplied session
+            # IDs remain caller-controlled and are forwarded as requested.
+            active_session_id = (
+                session_id
+                if session_id is not None
+                else (self.remote_session_id if video_path is None else None)
+            )
+            if active_session_id is not None and video_path is None and question:
+                job = self.submit_session_inference(
+                    task_type="vqa",
+                    session_id=active_session_id,
+                    model_id=remote_model_id,
+                    task_options=remote_task_options,
+                    question=str(question),
                 )
                 return self.wait_for_remote_result(job["job_id"])["result"]["predictions"]
             if not video_path or not str(question or "").strip():
@@ -293,7 +297,7 @@ class VQAModel(BaseTaskModel):
                 task_type="vqa",
                 video_path=video_path,
                 question=str(question),
-                session_id=session_id,
+                session_id=active_session_id,
                 model_id=remote_model_id,
                 task_options=remote_task_options,
             )

{opensportslib-0.3.1.dev9 → opensportslib-0.3.1.dev11/opensportslib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensportslib
-Version: 0.3.1.dev9
+Version: 0.3.1.dev11
 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
@@ -45,6 +45,10 @@ See the [complete inference server guide](docs/server/inference-server.md) for
 installation, registry administration, curl requests, single-video inference,
 full-test-set and per-sample remote inference, job polling, and sessions.
 
+For Docker administration, set `OSL_MODEL_ADMIN_TOKEN` in the private
+`server/.env` file, recreate the containers after changes, and use the exact
+same value as the Python client's `admin_token`. Never commit the real token.
+
 ## Configuration From Hugging Face
 
 Prepare and inspect configuration before model weights are allocated:

{opensportslib-0.3.1.dev9 → opensportslib-0.3.1.dev11}/pyproject.toml

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