dexos-lite 0.0.1__py3-none-any.whl

dexos_lite/__init__.py

@@ -0,0 +1,84 @@
+from dexos_lite.inference import infer_robot
+from dexos_lite.dataset_validation import DEFAULT_DATASET_FORMAT, DatasetFormat
+from dexos_lite.utils.client import ActionType, InferenceResult, DexosClient
+from dexos_lite.utils.http import DexosResponse
+from dexos_lite.exceptions import (
+    CliError,
+    CliExit,
+    DatasetDependencyError,
+    DatasetFormatError,
+    DatasetReadError,
+    DatasetUploadError,
+    DatasetValidationError,
+    DexosAPIError,
+    DexosClientError,
+    DexosConfigError,
+    DexosHTTPError,
+    DexosRequestError,
+    InferenceInterrupted,
+    RobotActionError,
+    RobotConfigError,
+    RobotConfigImportError,
+    RobotConfigNotFoundError,
+    RobotConfigTypeError,
+    RobotDependencyError,
+    RobotError,
+    RobotNotStartedError,
+    RobotTimeoutError,
+    RobotUnsupportedOperationError,
+    SensorDataError,
+    SensorDependencyError,
+    SensorError,
+    SensorImageFormatError,
+    SensorImageRequiredError,
+    SensorImageTooLargeError,
+    SensorNotFoundError,
+    SensorNotImplementedError,
+    SensorNotStartedError,
+    SensorParamError,
+    SensorUnsupportedError,
+)
+
+__all__ = [
+    "InferenceResult",
+    "ActionType",
+    "DEFAULT_DATASET_FORMAT",
+    "CliError",
+    "CliExit",
+    "DatasetDependencyError",
+    "DatasetFormatError",
+    "DatasetReadError",
+    "DatasetUploadError",
+    "DatasetValidationError",
+    "DatasetFormat",
+    "DexosAPIError",
+    "DexosClient",
+    "DexosClientError",
+    "DexosConfigError",
+    "DexosHTTPError",
+    "DexosRequestError",
+    "DexosResponse",
+    "InferenceInterrupted",
+    "RobotActionError",
+    "RobotConfigError",
+    "RobotConfigImportError",
+    "RobotConfigNotFoundError",
+    "RobotConfigTypeError",
+    "RobotDependencyError",
+    "RobotError",
+    "RobotNotStartedError",
+    "RobotTimeoutError",
+    "RobotUnsupportedOperationError",
+    "SensorDataError",
+    "SensorDependencyError",
+    "SensorError",
+    "SensorImageFormatError",
+    "SensorImageRequiredError",
+    "SensorImageTooLargeError",
+    "SensorNotFoundError",
+    "SensorNotImplementedError",
+    "SensorNotStartedError",
+    "SensorParamError",
+    "SensorUnsupportedError",
+    "infer_robot",
+]

dexos_lite/cli.py

@@ -0,0 +1,367 @@
+from __future__ import annotations
+
+import logging
+import signal
+import sys
+import threading
+import time
+from pathlib import Path
+from types import FrameType, TracebackType
+from typing import Any, Dict, Optional
+
+import click
+
+from dexos_lite.dataset import upload_dataset
+from dexos_lite.dataset_validation import DEFAULT_DATASET_FORMAT, DatasetFormat
+from dexos_lite.exceptions import CliError, CliExit, InferenceInterrupted
+from dexos_lite.inference import infer_robot
+from dexos_lite.robot import AlohaRobot, MirrorRobot, load_robot_config
+from dexos_lite.utils.client import DexosClient
+
+
+logger = logging.getLogger(__name__)
+
+
+_options = {}
+ROBOT_TYPES = {
+    "aloha": AlohaRobot,
+    "mirror": MirrorRobot,
+}
+
+
+class _InferenceInterruptHandler:
+    """Translate ``Ctrl+C`` into a controlled inference-loop stop."""
+
+    def __init__(self) -> None:
+        """Create a temporary SIGINT handler for the active inference loop."""
+
+        self.stop_requested = False
+        self._installed = False
+        self._previous_handler: Any = None
+
+    def __enter__(self) -> "_InferenceInterruptHandler":
+        """Install the SIGINT handler.
+
+        :return: The active handler instance.
+        """
+
+        if threading.current_thread() is not threading.main_thread():
+            return self
+        self._previous_handler = signal.getsignal(signal.SIGINT)
+        signal.signal(signal.SIGINT, self._handle_signal)
+        self._installed = True
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[type[BaseException]],
+        exc: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> None:
+        """Restore the previous SIGINT handler.
+
+        :param exc_type: Exception type leaving the context.
+        :param exc: Exception leaving the context.
+        :param traceback: Traceback leaving the context.
+        """
+
+        if self._installed:
+            signal.signal(signal.SIGINT, self._previous_handler)
+
+    def _handle_signal(self, signum: int, frame: Optional[FrameType]) -> None:
+        """Stop the current inference loop immediately.
+
+        :param signum: Received signal number.
+        :param frame: Current interpreter frame.
+        :raises _InferenceInterrupted: Always raised to interrupt the active call.
+        """
+
+        self.stop_requested = True
+        raise InferenceInterrupted
+
+
+class _UploadProgress:
+    def __init__(self) -> None:
+        self._context: Any = None
+        self._bar: Any = None
+        self._last_uploaded = 0
+
+    def update(self, uploaded: int, total: int) -> None:
+        if self._bar is None:
+            self._context = click.progressbar(
+                length=total,
+                label="Uploading dataset",
+                show_eta=True,
+                show_percent=True,
+                show_pos=True,
+                file=click.get_text_stream("stderr"),
+            )
+            self._bar = self._context.__enter__()
+            self._last_uploaded = 0
+
+        delta = uploaded - self._last_uploaded
+        if delta > 0:
+            self._bar.update(delta)
+            self._last_uploaded = uploaded
+
+    def retry(self, completed_attempt: int, total_attempts: int, reason: str) -> None:
+        self.close()
+        next_attempt = completed_attempt + 1
+        click.echo(
+            (
+                f"Upload attempt {completed_attempt}/{total_attempts} failed; "
+                f"retrying attempt {next_attempt}/{total_attempts}: {reason}"
+            ),
+            err=True,
+        )
+
+    def close(self) -> None:
+        if self._context is None:
+            return
+        self._context.__exit__(None, None, None)
+        self._context = None
+        self._bar = None
+        self._last_uploaded = 0
+
+
+def _upload_success_message(result: Dict[str, Any]) -> str:
+    details = []
+    dataset_id = result.get("dataset_id")
+    status = result.get("status")
+    if dataset_id:
+        details.append(f"dataset_id={dataset_id}")
+    if status:
+        details.append(f"status={status}")
+    suffix = f" ({', '.join(details)})" if details else ""
+    return f"Dataset upload succeeded{suffix}."
+
+
+def _upload_failure_message(exc: Exception) -> str:
+    message = str(exc).strip() or exc.__class__.__name__
+    return f"Dataset upload failed: {message}"
+
+
+def _prompt_inference_feedback() -> Optional[Dict[str, Any]]:
+    try:
+        score = click.prompt(
+            "Please evaluate this task on a scale of 0 to 10",
+            type=click.IntRange(0, 10),
+        )
+        message = click.prompt(
+            "Feedback message",
+            default="",
+            show_default=False,
+        )
+    except (click.Abort, EOFError, KeyboardInterrupt):
+        click.echo("feedback skipped", err=True)
+        return None
+    return {"score": score, "message": message}
+
+
+def _submit_inference_feedback(client: DexosClient) -> None:
+    feedback = _prompt_inference_feedback()
+    if feedback is None:
+        return
+    try:
+        client.feedback(
+            score=feedback["score"],
+            message=feedback["message"],
+        )
+    except Exception as exc:
+        click.echo(f"feedback failed: {exc}", err=True)
+        return
+    click.echo("feedback submitted")
+
+
+def _reset_robot_to_home(robot: Any, *, raise_errors: bool = True) -> None:
+    try:
+        click.echo("resetting robot to home pose...")
+        robot.reset_to_home()
+        click.echo("robot reset to home pose")
+    except Exception as exc:
+        if raise_errors:
+            raise
+        click.echo(f"reset_to_home failed: {exc}", err=True)
+
+
+@click.group()
+@click.option("--debug", is_flag=True, help="Enable debug mode.")
+def cli(debug) -> None:
+    global _options
+    _options["debug"] = debug
+    if debug:
+        logging.basicConfig(
+            level=logging.ERROR,
+            format=(
+                "%(asctime)s | %(levelname)-8s | "
+                "%(name)s:%(funcName)s:%(lineno)d - %(message)s"
+            ),
+        )
+        logging.getLogger("dexos_lite").setLevel(logging.INFO)
+
+
+def safe_cli():  # pragma: no cover
+    try:
+        cli()
+    except Exception as e:
+        if _options.get("debug", False):
+            raise
+        else:
+            click.echo(f"\n[{type(e).__name__}] {e}", err=True)
+            sys.exit(1)
+
+
+@cli.group()
+def dataset() -> None:
+    pass
+
+
+@cli.group("robot")
+def robot_cli() -> None:
+    pass
+
+
+@dataset.command("upload")
+@click.argument("path", type=click.Path(exists=True, path_type=str))
+@click.option("--api-key", envvar=DexosClient.api_key_env)
+@click.option("--dataset-name")
+@click.option(
+    "--dataset-format",
+    default=DEFAULT_DATASET_FORMAT.value,
+    show_default=True,
+    type=click.Choice([item.value for item in DatasetFormat]),
+)
+@click.option("--description", default="", show_default=True)
+def upload_dataset_command(
+    path: str,
+    api_key: Optional[str],
+    dataset_name: Optional[str],
+    dataset_format: str,
+    description: str,
+) -> None:
+    """Upload a dataset using the configured CLI endpoint.
+
+    :param path: Dataset file or directory path.
+    :param api_key: API key from ``--api-key`` or ``DEXOS_API_KEY``.
+    :param dataset_name: Remote dataset name.
+    :param dataset_format: Dataset format name.
+    :param description: Optional dataset description.
+    """
+
+    progress = _UploadProgress()
+    try:
+        result = upload_dataset(
+            path,
+            api_key=api_key,
+            dataset_name=dataset_name,
+            dataset_format=dataset_format,
+            description=description,
+            direct_upload_max_retries=3,
+            progress_callback=progress.update,
+            retry_callback=progress.retry,
+        )
+    except Exception as exc:
+        progress.close()
+        click.echo(_upload_failure_message(exc), err=True)
+        raise CliExit(1) from None
+    finally:
+        progress.close()
+
+    click.echo(_upload_success_message(result))
+
+
+@robot_cli.command("config")
+@click.option(
+    "--robot-id",
+    required=True,
+    type=click.Choice(sorted(ROBOT_TYPES)),
+    help="Robot ID to generate config for.",
+)
+@click.option(
+    "--path",
+    "config_path",
+    default="config.py",
+    show_default=True,
+    type=click.Path(dir_okay=False, path_type=str),
+    help="Path for the generated config.",
+)
+@click.option("--force", is_flag=True, help="Overwrite an existing config file.")
+def robot_config_command(robot_id: str, config_path: str, force: bool) -> None:
+    path = Path(config_path).expanduser()
+    if path.exists() and not force:
+        raise CliError(
+            f"config already exists: {path}. Use --force to overwrite it."
+        )
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(ROBOT_TYPES[robot_id].config_template, encoding="utf-8")
+    click.echo(f"Robot config written to {path}")
+
+
+@robot_cli.command("infer")
+@click.option("--api-key", envvar=DexosClient.api_key_env)
+@click.option("--model-id", required=False, default="dm05", help="Model ID to use for inference.")
+@click.option(
+    "--robot-config",
+    required=True,
+    help="Python config path, optionally path.py:robot.",
+)
+@click.option("--prompt", required=True, help="Text prompt sent to the inference API.")
+@click.option(
+    "--time-limit",
+    default=600.0,
+    show_default="600 seconds",
+    type=click.FloatRange(min=0.0, min_open=True),
+    help="Maximum inference runtime in seconds.",
+)
+def infer_command(
+    api_key: Optional[str],
+    model_id: str,
+    robot_config: str,
+    prompt: Optional[str],
+    time_limit: float,
+) -> None:
+    """Run robot inference with the configured CLI endpoint.
+
+    :param api_key: API key from ``--api-key`` or ``DEXOS_API_KEY``.
+    :param model_id: Model ID to use for inference.
+    :param robot_config: Python config path, optionally ``path.py:robot``.
+    :param prompt: Text prompt sent to the inference API.
+    :param time_limit: Maximum inference runtime in seconds.
+    """
+
+    client = DexosClient(api_key=api_key)
+    robot = load_robot_config(robot_config)
+    should_collect_feedback = False
+    interrupted = False
+    try:
+        robot.start()
+        _reset_robot_to_home(robot)
+        deadline = time.monotonic() + time_limit
+        with _InferenceInterruptHandler() as interrupt_handler:
+            while not interrupt_handler.stop_requested:
+                if time.monotonic() >= deadline:
+                    click.echo("time limit reached")
+                    should_collect_feedback = True
+                    break
+                infer_robot(
+                    robot,
+                    client,
+                    model_id=model_id,
+                    prompt=prompt,
+                )
+                time.sleep(1)
+                click.echo("working...")
+    except KeyboardInterrupt:
+        click.echo("interrupted", err=True)
+        should_collect_feedback = True
+        interrupted = True
+    finally:
+        if interrupted:
+            _reset_robot_to_home(robot, raise_errors=False)
+        robot.close()
+    if should_collect_feedback:
+        _submit_inference_feedback(client)
+
+
+if __name__ == "__main__":
+    safe_cli()