sublinear 0.0.0.1__tar.gz

sublinear-0.0.0.1/PKG-INFO

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: sublinear
+Version: 0.0.0.1
+Summary: Python SDK for Sublinear foundation reward models for robotics.
+Author: Sublinear
+License-Expression: MIT
+Project-URL: Homepage, https://sublinear.dev
+Project-URL: Documentation, https://sublinear.dev/docs
+Keywords: robotics,reinforcement-learning,reward-models,video-language-models,embodied-ai
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.24
+Requires-Dist: opencv-python-headless>=4.8
+Requires-Dist: requests>=2.31
+
+# Sublinear Python SDK
+
+The official Python client for submitting robot videos and trajectories to Sublinear foundation reward models.
+
+## Installation
+
+```bash
+pip install sublinear
+```
+
+The PyPI distribution is named `sublinear`, while the Python import package is named `sublinear`:
+
+```python
+from sublinear import Sublinear
+```
+
+## Quick start
+
+Create an API key from the Sublinear dashboard, then submit a local MP4 video:
+
+```python
+import os
+from sublinear import Sublinear
+client = Sublinear(api_key=os.environ["SUBLINEAR_API_KEY"])
+response = client.responses.create(model="sole-r1", task_description="Fold the clothing.", video_path="episode.mp4")
+print(response.rewards)
+print(response.success)
+```
+
+You can also provide RGB video frames directly as a list or NumPy array with shape `(frames, height, width, 3)`:
+
+```python
+import os
+import numpy as np
+from sublinear import Sublinear
+client = Sublinear(api_key=os.environ["SUBLINEAR_API_KEY"])
+video_frames = np.load("video_frames.npy")
+response = client.responses.create(model="robometer", task_description="Fold the clothing.", video_frames=video_frames)
+print(response.rewards)
+print(response.success)
+```
+
+## Multiple videos
+
+Pass `video_paths` to process multiple videos. The SDK submits jobs concurrently, up to `max_parallel_jobs` at a time.
+
+```python
+import os
+from sublinear import Sublinear
+client = Sublinear(api_key=os.environ["SUBLINEAR_API_KEY"], max_parallel_jobs=8)
+response = client.responses.create(model="sole-r1", task_description="Pick up the cube.", video_paths=["episode_1.mp4", "episode_2.mp4"])
+print(response.rewards)
+print(response.success)
+```
+
+## Available models
+
+- `sole-r1` — reasoning-based robot trajectory evaluation
+- `robometer` — dense task-progress reward estimation
+- `topreward` — visual reward estimation across robot tasks
+- `roboreward` — general-purpose robot reward prediction
+
+## Documentation
+
+Full documentation and additional input formats are available at [sublinear.dev/docs](https://sublinear.dev/docs).
+
+## Package layout
+
+This project uses a `src` layout:
+
+```text
+sublinear/
+├── pyproject.toml
+├── README.md
+└── src/
+    └── sublinear/
+        ├── __init__.py
+        └── core.py
+```
+
+Your `src/sublinear/__init__.py` should expose the public client:
+
+```python
+from .core import Sublinear
+__all__ = ["Sublinear"]
+```
+
+## Development
+
+Install the package locally in editable mode:
+
+```bash
+python -m pip install -e .
+```
+
+Build the source distribution and wheel:
+
+```bash
+python -m pip install --upgrade build
+python -m build
+```
+
+Before publishing, verify the package metadata and archives:
+
+```bash
+python -m pip install --upgrade twine
+python -m twine check dist/*
+```
+
+Publish to PyPI:
+
+```bash
+python -m twine upload dist/*
+```
+
+## License
+
+MIT
+

sublinear-0.0.0.1/README.md

@@ -0,0 +1,119 @@
+# Sublinear Python SDK
+
+The official Python client for submitting robot videos and trajectories to Sublinear foundation reward models.
+
+## Installation
+
+```bash
+pip install sublinear
+```
+
+The PyPI distribution is named `sublinear`, while the Python import package is named `sublinear`:
+
+```python
+from sublinear import Sublinear
+```
+
+## Quick start
+
+Create an API key from the Sublinear dashboard, then submit a local MP4 video:
+
+```python
+import os
+from sublinear import Sublinear
+client = Sublinear(api_key=os.environ["SUBLINEAR_API_KEY"])
+response = client.responses.create(model="sole-r1", task_description="Fold the clothing.", video_path="episode.mp4")
+print(response.rewards)
+print(response.success)
+```
+
+You can also provide RGB video frames directly as a list or NumPy array with shape `(frames, height, width, 3)`:
+
+```python
+import os
+import numpy as np
+from sublinear import Sublinear
+client = Sublinear(api_key=os.environ["SUBLINEAR_API_KEY"])
+video_frames = np.load("video_frames.npy")
+response = client.responses.create(model="robometer", task_description="Fold the clothing.", video_frames=video_frames)
+print(response.rewards)
+print(response.success)
+```
+
+## Multiple videos
+
+Pass `video_paths` to process multiple videos. The SDK submits jobs concurrently, up to `max_parallel_jobs` at a time.
+
+```python
+import os
+from sublinear import Sublinear
+client = Sublinear(api_key=os.environ["SUBLINEAR_API_KEY"], max_parallel_jobs=8)
+response = client.responses.create(model="sole-r1", task_description="Pick up the cube.", video_paths=["episode_1.mp4", "episode_2.mp4"])
+print(response.rewards)
+print(response.success)
+```
+
+## Available models
+
+- `sole-r1` — reasoning-based robot trajectory evaluation
+- `robometer` — dense task-progress reward estimation
+- `topreward` — visual reward estimation across robot tasks
+- `roboreward` — general-purpose robot reward prediction
+
+## Documentation
+
+Full documentation and additional input formats are available at [sublinear.dev/docs](https://sublinear.dev/docs).
+
+## Package layout
+
+This project uses a `src` layout:
+
+```text
+sublinear/
+├── pyproject.toml
+├── README.md
+└── src/
+    └── sublinear/
+        ├── __init__.py
+        └── core.py
+```
+
+Your `src/sublinear/__init__.py` should expose the public client:
+
+```python
+from .core import Sublinear
+__all__ = ["Sublinear"]
+```
+
+## Development
+
+Install the package locally in editable mode:
+
+```bash
+python -m pip install -e .
+```
+
+Build the source distribution and wheel:
+
+```bash
+python -m pip install --upgrade build
+python -m build
+```
+
+Before publishing, verify the package metadata and archives:
+
+```bash
+python -m pip install --upgrade twine
+python -m twine check dist/*
+```
+
+Publish to PyPI:
+
+```bash
+python -m twine upload dist/*
+```
+
+## License
+
+MIT
+

sublinear-0.0.0.1/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sublinear"
+version = "0.0.0.1"
+description = "Python SDK for Sublinear foundation reward models for robotics."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [
+    { name = "Sublinear" },
+]
+keywords = [
+    "robotics",
+    "reinforcement-learning",
+    "reward-models",
+    "video-language-models",
+    "embodied-ai",
+]
+dependencies = [
+    "numpy>=1.24",
+    "opencv-python-headless>=4.8",
+    "requests>=2.31",
+]
+
+[project.urls]
+Homepage = "https://sublinear.dev"
+Documentation = "https://sublinear.dev/docs"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["sublinear*"]
+

sublinear-0.0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sublinear-0.0.0.1/src/sublinear/__init__.py

@@ -0,0 +1,11 @@
+from .core import *
+
+__all__ = []
+
+try:
+    from importlib.metadata import version
+    __version__ = version("sublinear-sdk")
+except Exception:
+    __version__ = "0.1.4"
+
+

sublinear-0.0.0.1/src/sublinear/core.py

@@ -0,0 +1,402 @@
+import mimetypes
+import time
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Any, BinaryIO
+import os
+
+import requests
+import numpy as np
+
+import tempfile
+from concurrent.futures import ThreadPoolExecutor
+
+import cv2
+from itertools import repeat
+
+import threading
+from collections.abc import Callable
+
+SUPABASE_FUNCTIONS_URL = (
+    "https://qttoxuyjvehacmihvkzu.supabase.co/functions/v1"
+)
+
+VideoData = bytes | bytearray | memoryview | BinaryIO
+
+
+
+def load_video_frames(video_path):
+    import cv2
+    frames = []
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise ValueError("Error opening video file")
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)  
+        frames.append(frame)
+    cap.release()
+    return frames
+
+
+def get_video_dimensions(
+    video_path: str | Path,
+) -> tuple[int, int]:
+    capture = cv2.VideoCapture(str(video_path))
+    try:
+        if not capture.isOpened():
+            raise ValueError(f"Unable to inspect video: {video_path}")
+        width = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    finally:
+        capture.release()
+    if width < 1 or height < 1:
+        raise ValueError(f"Invalid video dimensions: {video_path}")
+    return width, height
+
+
+
+
+def get_final_video_frames(
+    model: str,
+    video_paths: list = None,
+    video_path: str = None,
+    ###### optional, in case you want to give two videos with different views instead of one video that has a single view or has combined side-by-side views
+    video_paths_external_view: list = None, 
+    video_paths_wrist_view: list = None,
+    video_path_external_view: str = None, 
+    video_path_wrist_view: str = None,
+    ######
+    ###### optional, in case you want to give frames instead of video paths
+    video_frames: list | None = None,
+    video_frames_external_view: list | None = None,
+    video_frames_wrist_view: list | None = None,
+    ###### optional
+    view_type_per_video: list = None,
+    view_type: str = None,
+    verbose: bool = True,
+): 
+    final_video_paths=None
+    final_video_paths_external_view=None
+    final_video_paths_wrist_view=None
+    videos=None
+    single_video = False
+    if video_frames is not None:
+        # if video_frames[0] is a list of frames, then we have multiple videos worth of frames. if video_frames is a single list of frames, then we have one video worth of frames.
+        if isinstance(video_frames[0], list) or (isinstance(video_frames[0], np.ndarray) and video_frames[0].ndim == 4):
+            single_video = False
+        else:
+            single_video = True
+        # 
+        if view_type_per_video is None and view_type is not None:
+            if single_video:
+                view_type_per_video = [view_type]
+            else:
+                view_type_per_video = [view_type] * len(video_frames)
+        # 
+    elif video_frames_external_view is not None or video_frames_wrist_view is not None:
+        if video_frames_external_view is not None:
+            if isinstance(video_frames_external_view[0], list) or (isinstance(video_frames_external_view[0], np.ndarray) and video_frames_external_view[0].ndim == 4):
+                single_video = False
+            else:
+                single_video = True
+        if video_frames_wrist_view is not None:
+            if isinstance(video_frames_wrist_view[0], list) or (isinstance(video_frames_wrist_view[0], np.ndarray) and video_frames_wrist_view[0].ndim == 4):
+                single_video = False
+            else:
+                single_video = True
+        # 
+        if view_type_per_video is None and view_type is not None:
+            if single_video:
+                view_type_per_video = [view_type]
+            else:
+                view_type_per_video = [view_type] * max([len(video_frames_external_view or []), len(video_frames_wrist_view or [])])
+    else:
+        if video_paths is not None:
+            final_video_paths = video_paths
+        elif video_paths is None and video_path is not None:
+            final_video_paths = [video_path]
+            single_video = True
+            # 
+            if view_type_per_video is None and view_type is not None:
+                view_type_per_video = [view_type] * len(final_video_paths)
+        # 
+        else:
+            if video_paths_external_view is None and video_path_external_view is not None:
+                final_video_paths_external_view = [video_path_external_view]
+                single_video = True
+            if video_paths_wrist_view is None and video_path_wrist_view is not None:
+                final_video_paths_wrist_view = [video_path_wrist_view]
+                single_video = True
+            # 
+            if view_type_per_video is None and view_type is not None:
+                view_type_per_video = [view_type] * max([len(final_video_paths or []), len(final_video_paths_external_view or []), len(final_video_paths_wrist_view or [])])
+    # 
+    ############ EXTRACT VIDEO FRAMES FOR ALL VIDEOS AS A LIST OF LISTS    
+    # 
+    if video_frames is not None:
+        if single_video:
+            videos = [video_frames]
+        else:
+            videos = video_frames
+    elif video_frames_external_view is not None or video_frames_wrist_view is not None:
+        if video_frames_external_view is not None and video_frames_wrist_view is not None:
+            if single_video:
+                video_frames_external_view = [video_frames_external_view]
+                video_frames_wrist_view = [video_frames_wrist_view]
+            # 
+            if len(video_frames_external_view) != len(video_frames_wrist_view):
+                raise ValueError(f"Number of videos in video_frames_external_view {len(video_frames_external_view)} does not match number of videos in video_frames_wrist_view {len(video_frames_wrist_view)}")
+            # 
+            if model in ['sole-r1']:
+                videos = []
+                for video_idx in range(len(video_frames_external_view)):
+                    frames_external = video_frames_external_view[video_idx]
+                    frames_wrist = video_frames_wrist_view[video_idx]
+                    if not len(frames_external) == len(frames_wrist):
+                        raise ValueError(f"Number of frames in external view video {len(frames_external)} does not match number of frames in wrist view video {len(frames_wrist)} for video_idx {video_idx}")
+                    frames_combined = [np.concatenate((frames_external[i], frames_wrist[i]), axis=1) for i in range(len(frames_external))]
+                    videos.append(frames_combined)
+                view_type_per_video = ['external and wrist'] * len(videos)
+            else:
+                if video_frames_external_view is not None and video_frames_wrist_view is not None:
+                    raise ValueError(f"Both video_frames_external_view and video_frames_wrist_view are provided, but model '{model}' does not support both views. Please provide only one view.")
+        else:
+            if video_frames_external_view is not None and video_frames_wrist_view is None:
+                if single_video:
+                    video_frames_external_view = [video_frames_external_view]
+                videos = video_frames_external_view
+                view_type_per_video = ['external'] * len(video_frames_external_view)
+                if verbose:
+                    print(f"Using videos from video_frames_external_view with view type 'external'")
+            elif video_frames_external_view is None and video_frames_wrist_view is not None:
+                if single_video:
+                    video_frames_wrist_view = [video_frames_wrist_view]
+                videos = video_frames_wrist_view
+                view_type_per_video = ['wrist'] * len(video_frames_wrist_view)
+                if verbose:
+                    print(f"Using videos from video_frames_wrist_view with view type 'wrist'")
+            else:
+                raise ValueError("video_frames cannot be None if video_paths is None")
+    else:
+        if final_video_paths is None and final_video_paths_external_view is not None and final_video_paths_wrist_view is not None:
+            # concatenate external and wrist view videos side by side and use that as input to the model 
+            # if False:
+            #     videos = []
+            #     for video_idx in range(len(video_paths_external_view)):
+            #         frames_external = load_video_frames(video_paths_external_view[video_idx])
+            #         frames_wrist = load_video_frames(video_paths_wrist_view[video_idx])
+            #         if not len(frames_external) == len(frames_wrist):
+            #             raise ValueError(f"Number of frames in external view video {len(frames_external)} does not match number of frames in wrist view video {len(frames_wrist)} for video_idx {video_idx}")
+            #         frames_combined = [np.concatenate((frames_external[i], frames_wrist[i]), axis=1) for i in range(len(frames_external))]
+            #         videos.append(frames_combined)
+            if model in ['sole-r1']:
+                view_type_per_video = ['external and wrist'] * len(final_video_paths_external_view)
+            else: 
+                raise ValueError(f"Both video_paths_external_view and video_paths_wrist_view are provided, but model '{model}' does not support both views. Please provide only one view.")
+        else:
+            if final_video_paths is None and final_video_paths_external_view is not None and final_video_paths_wrist_view is None:
+                final_video_paths = final_video_paths_external_view
+                final_video_paths_external_view = None
+                view_type_per_video = ['external'] * len(final_video_paths)
+                if verbose:
+                    print(f"Using videos from video_paths_external_view with view type 'external'")
+            elif final_video_paths is None and final_video_paths_external_view is None and final_video_paths_wrist_view is not None:
+                final_video_paths = final_video_paths_wrist_view
+                final_video_paths_wrist_view = None
+                view_type_per_video = ['wrist'] * len(final_video_paths)
+                if verbose:
+                    print(f"Using videos from video_paths_wrist_view with view type 'wrist'")
+            elif final_video_paths is None:
+                raise ValueError("video_paths cannot be None if video_paths_external_view and video_paths_wrist_view are both not provided")
+            # 
+            # videos = []
+            # for video_path in video_paths:
+            #     frames = load_video_frames(video_path)
+            #     videos.append(frames)
+    # 
+    if not videos and not final_video_paths and not final_video_paths_external_view and not final_video_paths_wrist_view:
+        raise ValueError("No videos were provided.")
+    elif not videos is None:
+        video_count = len(videos)
+    elif not final_video_paths is None:
+        video_count = len(final_video_paths)
+    elif not final_video_paths_external_view is None:
+        video_count = len(final_video_paths_external_view)
+    elif not final_video_paths_wrist_view is None:
+        video_count = len(final_video_paths_wrist_view)
+    # 
+    if view_type_per_video is None and not videos is None:
+        view_type_per_video = ['external'] * len(videos)
+    elif view_type_per_video is None and final_video_paths is not None:
+        view_type_per_video = ['external'] * len(final_video_paths)
+    elif view_type_per_video is None and final_video_paths_external_view is not None:
+        view_type_per_video = ['external'] * len(final_video_paths_external_view)
+    elif view_type_per_video is None and final_video_paths_wrist_view is not None:
+        view_type_per_video = ['wrist'] * len(final_video_paths_wrist_view)
+    # 
+    elif len(view_type_per_video) != video_count:
+        if len(view_type_per_video) < video_count and len(set(view_type_per_video)) == 1:
+            if verbose:
+                print(f"Extending view_type_per_video (length {len(view_type_per_video)}) to match number of videos (length {video_count})")
+            view_type_per_video = view_type_per_video * video_count
+        else:
+            raise ValueError(f"Length of view_type_per_video ({len(view_type_per_video)}) does not match number of videos ({video_count})")
+    # 
+    return videos, final_video_paths, final_video_paths_external_view, final_video_paths_wrist_view, view_type_per_video, single_video, video_count
+
+def video_plot(*args, **kwargs):
+    print('Thank you for trying out Sublinear! We are still in development and will be launching the API soon.')
+
+class Sublinear:
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = SUPABASE_FUNCTIONS_URL,
+        max_parallel_jobs: int = 8,
+    ):
+        if not api_key:
+            raise ValueError("api_key cannot be empty")
+        if max_parallel_jobs < 1:
+            raise ValueError("max_parallel_jobs must be at least 1")
+        self.base_url = base_url.rstrip("/")
+        self.max_parallel_jobs = max_parallel_jobs
+        self.session = requests.Session()
+        self.session.headers.update({
+            "Authorization": f"Bearer {api_key}",
+        })
+        self.responses = self
+    # 
+    def cancel_job(self, job_id: str) -> None:
+        response = self.session.post(
+            f"{self.base_url}/create-inference-job",
+            json={
+                "action": "cancel",
+                "job_id": job_id,
+            },
+            timeout=10,
+        )
+        # Cancellation losing a race with completion is not retriable.
+        if response.status_code != 409:
+            response.raise_for_status()
+    # 
+    def create_job(
+        self,
+        input_json: dict[str, Any],
+        *,
+        video: VideoData,
+        filename: str,
+        model: str,
+        on_job_created: Callable[[str], None] | None = None,
+    ) -> dict[str, Any]:
+        downsample_to = input_json.get("downsample_to",10)
+        if (
+            isinstance(downsample_to, bool)
+            or not isinstance(downsample_to, int)
+            or downsample_to < 1
+            or downsample_to > 100
+        ):
+            raise ValueError("downsample_to must be an integer between 1 and 100")
+        content_type = (
+            mimetypes.guess_type(filename)[0]
+            or "application/octet-stream"
+        )
+        response = self.session.post(
+            f"{self.base_url}/create-inference-job",
+            json={
+                "action": "create",
+                "filename": filename,
+                "input_json": input_json,
+                "content_type": content_type,
+                "model": model,
+            },
+            timeout=30,
+        )
+        response.raise_for_status()
+        job = response.json()
+        if on_job_created is not None:
+            on_job_created(job["job_id"])
+        # Do not use self.session for the signed upload URL.
+        # The storage host should not receive the API key.
+        upload_response = requests.put(
+            job["upload_url"],
+            data=video,
+            headers={
+                "Content-Type": content_type,
+            },
+            timeout=(30, 1800),
+        )
+        upload_response.raise_for_status()
+        start_response = self.session.post(
+            f"{self.base_url}/create-inference-job",
+            json={
+                "action": "start",
+                "job_id": job["job_id"],
+            },
+            timeout=60,
+        )
+        start_response.raise_for_status()
+        return start_response.json()
+    # 
+    def get_job(
+        self,
+        job_id: str,
+    ) -> dict[str, Any]:
+        response = self.session.get(
+            f"{self.base_url}/get-inference-job",
+            params={
+                "job_id": job_id,
+            },
+            timeout=30,
+        )
+        response.raise_for_status()
+        return response.json()
+    # 
+    def wait_for_job(
+        self,
+        job_id: str,
+        poll_interval: float = 2.0,
+        timeout: float = 6000,
+    ) -> dict[str, Any]:
+        deadline = time.monotonic() + timeout
+        while True:
+            job = self.get_job(job_id)
+            status = job["status"]
+            if status == "completed":
+                return job
+            if status == "failed":
+                raise RuntimeError(
+                    job.get("error")
+                    or "Inference job failed."
+                )
+            if status == "canceled":
+                raise RuntimeError("Inference job was canceled.")
+            if time.monotonic() >= deadline:
+                raise TimeoutError(
+                    f"Job did not finish within {timeout} seconds."
+                )
+            time.sleep(poll_interval)
+    # 
+    def create(
+        self,
+        *,
+        model: str,
+        video_paths: list | None = None,
+        video_path: str | None = None,
+        video_paths_external_view: list | None = None,
+        video_paths_wrist_view: list | None = None,
+        video_path_external_view: str | None = None,
+        video_path_wrist_view: str | None = None,
+        video_frames: list | np.ndarray | None = None,
+        video_frames_external_view: list | np.ndarray | None = None,
+        video_frames_wrist_view: list | np.ndarray | None = None,
+        view_type_per_video: list | None = None,
+        view_type: str | None = None,
+        verbose: bool = True,
+        **input_json: Any,
+    ) -> SimpleNamespace | list[SimpleNamespace]:
+        print('Thank you for trying out Sublinear! We are still in development and will be launching the API soon.')
+        return
+

sublinear-0.0.0.1/src/sublinear.egg-info/PKG-INFO

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: sublinear
+Version: 0.0.0.1
+Summary: Python SDK for Sublinear foundation reward models for robotics.
+Author: Sublinear
+License-Expression: MIT
+Project-URL: Homepage, https://sublinear.dev
+Project-URL: Documentation, https://sublinear.dev/docs
+Keywords: robotics,reinforcement-learning,reward-models,video-language-models,embodied-ai
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.24
+Requires-Dist: opencv-python-headless>=4.8
+Requires-Dist: requests>=2.31
+
+# Sublinear Python SDK
+
+The official Python client for submitting robot videos and trajectories to Sublinear foundation reward models.
+
+## Installation
+
+```bash
+pip install sublinear
+```
+
+The PyPI distribution is named `sublinear`, while the Python import package is named `sublinear`:
+
+```python
+from sublinear import Sublinear
+```
+
+## Quick start
+
+Create an API key from the Sublinear dashboard, then submit a local MP4 video:
+
+```python
+import os
+from sublinear import Sublinear
+client = Sublinear(api_key=os.environ["SUBLINEAR_API_KEY"])
+response = client.responses.create(model="sole-r1", task_description="Fold the clothing.", video_path="episode.mp4")
+print(response.rewards)
+print(response.success)
+```
+
+You can also provide RGB video frames directly as a list or NumPy array with shape `(frames, height, width, 3)`:
+
+```python
+import os
+import numpy as np
+from sublinear import Sublinear
+client = Sublinear(api_key=os.environ["SUBLINEAR_API_KEY"])
+video_frames = np.load("video_frames.npy")
+response = client.responses.create(model="robometer", task_description="Fold the clothing.", video_frames=video_frames)
+print(response.rewards)
+print(response.success)
+```
+
+## Multiple videos
+
+Pass `video_paths` to process multiple videos. The SDK submits jobs concurrently, up to `max_parallel_jobs` at a time.
+
+```python
+import os
+from sublinear import Sublinear
+client = Sublinear(api_key=os.environ["SUBLINEAR_API_KEY"], max_parallel_jobs=8)
+response = client.responses.create(model="sole-r1", task_description="Pick up the cube.", video_paths=["episode_1.mp4", "episode_2.mp4"])
+print(response.rewards)
+print(response.success)
+```
+
+## Available models
+
+- `sole-r1` — reasoning-based robot trajectory evaluation
+- `robometer` — dense task-progress reward estimation
+- `topreward` — visual reward estimation across robot tasks
+- `roboreward` — general-purpose robot reward prediction
+
+## Documentation
+
+Full documentation and additional input formats are available at [sublinear.dev/docs](https://sublinear.dev/docs).
+
+## Package layout
+
+This project uses a `src` layout:
+
+```text
+sublinear/
+├── pyproject.toml
+├── README.md
+└── src/
+    └── sublinear/
+        ├── __init__.py
+        └── core.py
+```
+
+Your `src/sublinear/__init__.py` should expose the public client:
+
+```python
+from .core import Sublinear
+__all__ = ["Sublinear"]
+```
+
+## Development
+
+Install the package locally in editable mode:
+
+```bash
+python -m pip install -e .
+```
+
+Build the source distribution and wheel:
+
+```bash
+python -m pip install --upgrade build
+python -m build
+```
+
+Before publishing, verify the package metadata and archives:
+
+```bash
+python -m pip install --upgrade twine
+python -m twine check dist/*
+```
+
+Publish to PyPI:
+
+```bash
+python -m twine upload dist/*
+```
+
+## License
+
+MIT
+

sublinear-0.0.0.1/src/sublinear.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+src/sublinear/__init__.py
+src/sublinear/core.py
+src/sublinear.egg-info/PKG-INFO
+src/sublinear.egg-info/SOURCES.txt
+src/sublinear.egg-info/dependency_links.txt
+src/sublinear.egg-info/requires.txt
+src/sublinear.egg-info/top_level.txt

sublinear-0.0.0.1/src/sublinear.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sublinear-0.0.0.1/src/sublinear.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy>=1.24
+opencv-python-headless>=4.8
+requests>=2.31

sublinear-0.0.0.1/src/sublinear.egg-info/top_level.txt

@@ -0,0 +1 @@
+sublinear