reachy-mini 1.0.0__py3-none-any.whl

reachy_mini/daemon/app/main.py

@@ -0,0 +1,262 @@
+"""Daemon entry point for the Reachy Mini robot.
+
+This script serves as the command-line interface (CLI) entry point for the Reachy Mini daemon.
+It initializes the daemon with specified parameters such as simulation mode, serial port,
+scene to load, and logging level. The daemon runs indefinitely, handling requests and
+managing the robot's state.
+
+"""
+
+import argparse
+import logging
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from typing import AsyncGenerator
+
+import uvicorn
+from fastapi import APIRouter, FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+
+from reachy_mini.apps.manager import AppManager
+from reachy_mini.daemon.app.routers import apps, daemon, kinematics, motors, move, state
+from reachy_mini.daemon.daemon import Daemon
+
+
+@dataclass
+class Args:
+    """Arguments for configuring the Reachy Mini daemon."""
+
+    log_level: str = "INFO"
+
+    wireless_version: bool = False
+
+    serialport: str = "auto"
+
+    sim: bool = False
+    scene: str = "empty"
+    headless: bool = False
+
+    kinematics_engine: str = "AnalyticalKinematics"
+    check_collision: bool = False
+
+    autostart: bool = True
+
+    wake_up_on_start: bool = True
+    goto_sleep_on_stop: bool = True
+
+    fastapi_host: str = "0.0.0.0"
+    fastapi_port: int = 8000
+
+    localhost_only: bool | None = None
+
+
+def create_app(args: Args) -> FastAPI:
+    """Create and configure the FastAPI application."""
+    localhost_only = (
+        args.localhost_only
+        if args.localhost_only is not None
+        else (False if args.wireless_version else True)
+    )
+
+    @asynccontextmanager
+    async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+        """Lifespan context manager for the FastAPI application."""
+        args = app.state.args  # type: Args
+
+        if args.autostart:
+            await app.state.daemon.start(
+                serialport=args.serialport,
+                sim=args.sim,
+                scene=args.scene,
+                headless=args.headless,
+                kinematics_engine=args.kinematics_engine,
+                check_collision=args.check_collision,
+                wake_up_on_start=args.wake_up_on_start,
+                localhost_only=localhost_only,
+            )
+        yield
+        await app.state.app_manager.close()
+        await app.state.daemon.stop(
+            goto_sleep_on_stop=args.goto_sleep_on_stop,
+        )
+
+    app = FastAPI(
+        lifespan=lifespan,
+    )
+
+    app.state.args = args
+    app.state.daemon = Daemon(wireless_version=args.wireless_version)
+    app.state.app_manager = AppManager()
+
+    router = APIRouter(prefix="/api")
+    router.include_router(apps.router)
+    router.include_router(daemon.router)
+    router.include_router(kinematics.router)
+    router.include_router(motors.router)
+    router.include_router(move.router)
+    router.include_router(state.router)
+    app.include_router(router)
+
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],  # or restrict to your HF domain
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    STATIC_DIR = Path(__file__).parent / "dashboard" / "static"
+    TEMPLATES_DIR = Path(__file__).parent / "dashboard" / "templates"
+
+    app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
+    templates = Jinja2Templates(directory=str(TEMPLATES_DIR))
+
+    @app.get("/")
+    async def dashboard(request: Request) -> HTMLResponse:
+        """Render the dashboard."""
+        return templates.TemplateResponse("index.html", {"request": request})
+
+    return app
+
+
+def run_app(args: Args) -> None:
+    """Run the FastAPI app with Uvicorn."""
+    logging.basicConfig(level=logging.INFO)
+
+    app = create_app(args)
+    uvicorn.run(app, host=args.fastapi_host, port=args.fastapi_port)
+
+
+def main() -> None:
+    """Run the FastAPI app with Uvicorn."""
+    default_args = Args()
+
+    parser = argparse.ArgumentParser(description="Run the Reachy Mini daemon.")
+    parser.add_argument(
+        "--wireless-version",
+        action="store_true",
+        default=default_args.wireless_version,
+        help="Use the wireless version of Reachy Mini (default: False).",
+    )
+
+    # Real robot mode
+    parser.add_argument(
+        "-p",
+        "--serialport",
+        type=str,
+        default=default_args.serialport,
+        help="Serial port for real motors (default: will try to automatically find the port).",
+    )
+    # Simulation mode
+    parser.add_argument(
+        "--sim",
+        action="store_true",
+        default=default_args.sim,
+        help="Run in simulation mode using Mujoco.",
+    )
+    parser.add_argument(
+        "--scene",
+        type=str,
+        default=default_args.scene,
+        help="Name of the scene to load (default: empty)",
+    )
+    parser.add_argument(
+        "--headless",
+        action="store_true",
+        default=default_args.headless,
+        help="Run the daemon in headless mode (default: False).",
+    )
+    # Daemon options
+    parser.add_argument(
+        "--autostart",
+        action="store_true",
+        default=default_args.autostart,
+        help="Automatically start the daemon on launch (default: True).",
+    )
+    parser.add_argument(
+        "--no-autostart",
+        action="store_false",
+        dest="autostart",
+        help="Do not automatically start the daemon on launch (default: False).",
+    )
+    parser.add_argument(
+        "--wake-up-on-start",
+        action="store_true",
+        default=default_args.wake_up_on_start,
+        help="Wake up the robot on daemon start (default: True).",
+    )
+    parser.add_argument(
+        "--no-wake-up-on-start",
+        action="store_false",
+        dest="wake_up_on_start",
+        help="Do not wake up the robot on daemon start (default: False).",
+    )
+    parser.add_argument(
+        "--goto-sleep-on-stop",
+        action="store_true",
+        default=default_args.goto_sleep_on_stop,
+        help="Put the robot to sleep on daemon stop (default: True).",
+    )
+    parser.add_argument(
+        "--no-goto-sleep-on-stop",
+        action="store_false",
+        dest="goto_sleep_on_stop",
+        help="Do not put the robot to sleep on daemon stop (default: False).",
+    )
+    # Zenoh server options
+    parser.add_argument(
+        "--localhost-only",
+        action="store_true",
+        default=default_args.localhost_only,
+        help="Restrict the server to localhost only (default: True).",
+    )
+    parser.add_argument(
+        "--no-localhost-only",
+        action="store_false",
+        dest="localhost_only",
+        help="Allow the server to listen on all interfaces (default: False).",
+    )
+    # Kinematics options
+    parser.add_argument(
+        "--check-collision",
+        action="store_true",
+        default=default_args.check_collision,
+        help="Enable collision checking (default: False).",
+    )
+
+    parser.add_argument(
+        "--kinematics-engine",
+        type=str,
+        default=default_args.kinematics_engine,
+        choices=["Placo", "NN", "AnalyticalKinematics"],
+        help="Set the kinematics engine (default: AnalyticalKinematics).",
+    )
+    # FastAPI server options
+    parser.add_argument(
+        "--fastapi-host",
+        type=str,
+        default=default_args.fastapi_host,
+    )
+    parser.add_argument(
+        "--fastapi-port",
+        type=int,
+        default=default_args.fastapi_port,
+    )
+    # Logging options
+    parser.add_argument(
+        "--log-level",
+        type=str,
+        default=default_args.log_level,
+        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+        help="Set the logging level (default: INFO).",
+    )
+
+    args = parser.parse_args()
+    run_app(Args(**vars(args)))
+
+
+if __name__ == "__main__":
+    main()

reachy_mini/daemon/app/models.py

@@ -0,0 +1,147 @@
+"""Common pydantic models definitions."""
+
+from datetime import datetime
+
+import numpy as np
+from numpy.typing import NDArray
+from pydantic import BaseModel
+from scipy.spatial.transform import Rotation as R
+
+from reachy_mini.daemon.backend.abstract import MotorControlMode
+
+
+class Matrix4x4Pose(BaseModel):
+    """Represent a 3D pose by its 4x4 transformation matrix (translation is expressed in meters)."""
+
+    m: tuple[
+        float,
+        float,
+        float,
+        float,
+        float,
+        float,
+        float,
+        float,
+        float,
+        float,
+        float,
+        float,
+        float,
+        float,
+        float,
+        float,
+    ]
+
+    @classmethod
+    def from_pose_array(cls, arr: NDArray[np.float64]) -> "Matrix4x4Pose":
+        """Create a Matrix4x4 pose representation from a 4x4 pose array."""
+        assert arr.shape == (4, 4), "Array must be of shape (4, 4)"
+        m: tuple[
+            float,
+            float,
+            float,
+            float,
+            float,
+            float,
+            float,
+            float,
+            float,
+            float,
+            float,
+            float,
+            float,
+            float,
+            float,
+            float,
+        ] = tuple(arr.flatten().tolist())  # type: ignore [assignment]
+        return cls(m=m)
+
+    def to_pose_array(self) -> NDArray[np.float64]:
+        """Convert the Matrix4x4Pose to a 4x4 numpy array."""
+        return np.array(self.m).reshape((4, 4))
+
+
+class XYZRPYPose(BaseModel):
+    """Represent a 3D pose using position (x, y, z) in meters and orientation (roll, pitch, yaw) angles in radians."""
+
+    x: float = 0.0
+    y: float = 0.0
+    z: float = 0.0
+    roll: float = 0.0
+    pitch: float = 0.0
+    yaw: float = 0.0
+
+    @classmethod
+    def from_pose_array(cls, arr: NDArray[np.float64]) -> "XYZRPYPose":
+        """Create an XYZRPYPose representation from a 4x4 pose array."""
+        assert arr.shape == (4, 4), "Array must be of shape (4, 4)"
+
+        x, y, z = arr[0, 3], arr[1, 3], arr[2, 3]
+        roll, pitch, yaw = R.from_matrix(arr[:3, :3]).as_euler("xyz")
+
+        return cls(
+            x=x,
+            y=y,
+            z=z,
+            roll=roll,
+            pitch=pitch,
+            yaw=yaw,
+        )
+
+    def to_pose_array(self) -> NDArray[np.float64]:
+        """Convert the XYZRPYPose to a 4x4 numpy array."""
+        rotation = R.from_euler("xyz", [self.roll, self.pitch, self.yaw])
+        pose_matrix = np.eye(4)
+        pose_matrix[:3, 3] = [self.x, self.y, self.z]
+        pose_matrix[:3, :3] = rotation.as_matrix()
+        return pose_matrix
+
+
+AnyPose = XYZRPYPose | Matrix4x4Pose
+
+
+def as_any_pose(pose: NDArray[np.float64], use_matrix: bool) -> AnyPose:
+    """Convert a numpy array to an AnyPose representation."""
+    return (
+        Matrix4x4Pose.from_pose_array(pose)
+        if use_matrix
+        else XYZRPYPose.from_pose_array(pose)
+    )
+
+
+class FullBodyTarget(BaseModel):
+    """Represent the full body including the head pose and the joints for antennas."""
+
+    target_head_pose: AnyPose | None = None
+    target_antennas: tuple[float, float] | None = None
+    timestamp: datetime | None = None
+
+    model_config = {
+        "json_schema_extra": {
+            "examples": [
+                {
+                    "target_head_pose": {
+                        "x": 0.0,
+                        "y": 0.0,
+                        "z": 0.0,
+                        "roll": 0.0,
+                        "pitch": 0.0,
+                        "yaw": 0.0,
+                    },
+                    "target_antennas": [0.0, 0.0],
+                }
+            ]
+        }
+    }
+
+
+class FullState(BaseModel):
+    """Represent the full state of the robot including all joint positions and poses."""
+
+    control_mode: MotorControlMode | None = None
+    head_pose: AnyPose | None = None
+    head_joints: list[float] | None = None
+    body_yaw: float | None = None
+    antennas_position: list[float] | None = None
+    timestamp: datetime | None = None
+    passive_joints: list[float] | None = None

reachy_mini/daemon/app/routers/apps.py

@@ -0,0 +1,114 @@
+"""Apps router for apps management."""
+
+from fastapi import (
+    APIRouter,
+    Depends,
+    HTTPException,
+    WebSocket,
+)
+
+from reachy_mini.apps import AppInfo, SourceKind
+from reachy_mini.apps.manager import AppManager, AppStatus
+from reachy_mini.daemon.app import bg_job_register
+from reachy_mini.daemon.app.dependencies import get_app_manager
+
+router = APIRouter(prefix="/apps")
+
+
+@router.get("/list-available/{source_kind}")
+async def list_available_apps(
+    source_kind: SourceKind,
+    app_manager: "AppManager" = Depends(get_app_manager),
+) -> list[AppInfo]:
+    """List available apps (including not installed)."""
+    return await app_manager.list_available_apps(source_kind)
+
+
+@router.get("/list-available")
+async def list_all_available_apps(
+    app_manager: "AppManager" = Depends(get_app_manager),
+) -> list[AppInfo]:
+    """List all available apps (including not installed)."""
+    return await app_manager.list_all_available_apps()
+
+
+@router.post("/install")
+async def install_app(
+    app_info: AppInfo,
+    app_manager: "AppManager" = Depends(get_app_manager),
+) -> dict[str, str]:
+    """Install a new app by its info (background, returns job_id)."""
+    job_id = bg_job_register.run_command(
+        "install", app_manager.install_new_app, app_info
+    )
+    return {"job_id": job_id}
+
+
+@router.post("/remove/{app_name}")
+async def remove_app(
+    app_name: str,
+    app_manager: "AppManager" = Depends(get_app_manager),
+) -> dict[str, str]:
+    """Remove an installed app by its name (background, returns job_id)."""
+    job_id = bg_job_register.run_command("remove", app_manager.remove_app, app_name)
+    return {"job_id": job_id}
+
+
+@router.get("/job-status/{job_id}")
+async def job_status(job_id: str) -> bg_job_register.JobInfo:
+    """Get status/logs for a job."""
+    try:
+        return bg_job_register.get_info(job_id)
+    except Exception as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+
+# WebSocket route for live job status/logs
+@router.websocket("/ws/apps-manager/{job_id}")
+async def ws_apps_manager(websocket: WebSocket, job_id: str) -> None:
+    """WebSocket route to stream live job status/logs for a job, sending updates as soon as new logs are available."""
+    await websocket.accept()
+    await bg_job_register.ws_poll_info(websocket, job_id)
+    await websocket.close()
+
+
+@router.post("/start-app/{app_name}")
+async def start_app(
+    app_name: str,
+    app_manager: "AppManager" = Depends(get_app_manager),
+) -> AppStatus:
+    """Start an app by its name."""
+    try:
+        return await app_manager.start_app(app_name)
+    except RuntimeError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.post("/restart-current-app")
+async def restart_app(
+    app_manager: "AppManager" = Depends(get_app_manager),
+) -> AppStatus:
+    """Restart the currently running app."""
+    try:
+        return await app_manager.restart_current_app()
+    except RuntimeError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.post("/stop-current-app")
+async def stop_app(
+    app_manager: "AppManager" = Depends(get_app_manager),
+) -> None:
+    """Stop the currently running app."""
+    try:
+        return await app_manager.stop_current_app()
+    except RuntimeError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.get("/current-app-status")
+async def current_app_status(
+    app_manager: "AppManager" = Depends(get_app_manager),
+) -> AppStatus | None:
+    """Get the status of the currently running app, if any."""
+    return await app_manager.current_app_status()

reachy_mini/daemon/app/routers/daemon.py

@@ -0,0 +1,80 @@
+"""Daemon-related API routes."""
+
+import logging
+import threading
+
+from fastapi import APIRouter, Depends, HTTPException, Request
+
+from reachy_mini.daemon.app import bg_job_register
+
+from ...daemon import Daemon, DaemonStatus
+from ..dependencies import get_daemon
+
+router = APIRouter(
+    prefix="/daemon",
+)
+busy_lock = threading.Lock()
+
+
+@router.post("/start")
+async def start_daemon(
+    request: Request,
+    wake_up: bool,
+    daemon: Daemon = Depends(get_daemon),
+) -> dict[str, str]:
+    """Start the daemon."""
+    if busy_lock.locked():
+        raise HTTPException(status_code=409, detail="Daemon is busy.")
+
+    async def start(logger: logging.Logger) -> None:
+        with busy_lock:
+            await daemon.start(
+                sim=request.app.state.args.sim,
+                scene=request.app.state.args.scene,
+                headless=request.app.state.args.headless,
+                wake_up_on_start=wake_up,
+            )
+
+    job_id = bg_job_register.run_command("daemon-start", start)
+    return {"job_id": job_id}
+
+
+@router.post("/stop")
+async def stop_daemon(
+    goto_sleep: bool, daemon: Daemon = Depends(get_daemon)
+) -> dict[str, str]:
+    """Stop the daemon, optionally putting the robot to sleep."""
+    if busy_lock.locked():
+        raise HTTPException(status_code=409, detail="Daemon is busy.")
+
+    async def stop(logger: logging.Logger) -> None:
+        with busy_lock:
+            await daemon.stop(goto_sleep_on_stop=goto_sleep)
+
+    job_id = bg_job_register.run_command("daemon-stop", stop)
+    return {"job_id": job_id}
+
+
+@router.post("/restart")
+async def restart_daemon(
+    request: Request, daemon: Daemon = Depends(get_daemon)
+) -> dict[str, str]:
+    """Restart the daemon."""
+    if busy_lock.locked():
+        raise HTTPException(status_code=409, detail="Daemon is busy.")
+
+    async def restart(logger: logging.Logger) -> None:
+        with busy_lock:
+            await daemon.restart(
+                sim=request.app.state.args.sim,
+                scene=request.app.state.args.scene,
+            )
+
+    job_id = bg_job_register.run_command("daemon-restart", restart)
+    return {"job_id": job_id}
+
+
+@router.get("/status")
+async def get_daemon_status(daemon: Daemon = Depends(get_daemon)) -> DaemonStatus:
+    """Get the current status of the daemon."""
+    return daemon.status()

reachy_mini/daemon/app/routers/kinematics.py

@@ -0,0 +1,57 @@
+"""Kinematics router for handling kinematics-related requests.
+
+This module defines the API endpoints for interacting with the kinematics
+subsystem of the robot. It provides endpoints for retrieving URDF representation,
+and other kinematics-related information.
+"""
+
+from pathlib import Path
+from typing import Any
+
+from fastapi import APIRouter, Depends, HTTPException, Response
+
+from ....daemon.backend.abstract import Backend
+from ..dependencies import get_backend
+
+router = APIRouter(
+    prefix="/kinematics",
+)
+
+STL_ASSETS_DIR = (
+    Path(__file__).parent.parent.parent.parent
+    / "descriptions"
+    / "reachy_mini"
+    / "urdf"
+    / "assets"
+)
+
+
+@router.get("/info")
+async def get_kinematics_info(
+    backend: Backend = Depends(get_backend),
+) -> dict[str, Any]:
+    """Get the current information of the kinematics."""
+    return {
+        "info": {
+            "engine": backend.kinematics_engine,
+            "collision check": backend.check_collision,
+        }
+    }
+
+
+@router.get("/urdf")
+async def get_urdf(backend: Backend = Depends(get_backend)) -> dict[str, str]:
+    """Get the URDF representation of the robot."""
+    return {"urdf": backend.get_urdf()}
+
+
+@router.get("/stl/{filename}")
+async def get_stl_file(filename: Path) -> Response:
+    """Get the path to an STL asset file."""
+    file_path = STL_ASSETS_DIR / filename
+    try:
+        with open(file_path, "rb") as file:
+            content = file.read()
+            return Response(content, media_type="model/stl")
+    except FileNotFoundError:
+        raise HTTPException(status_code=404, detail=f"STL file not found {file_path}")

reachy_mini/daemon/app/routers/motors.py

@@ -0,0 +1,41 @@
+"""Motors router.
+
+Provides endpoints to get and set the motor control mode.
+"""
+
+from fastapi import APIRouter, Depends
+from pydantic import BaseModel
+
+from ....daemon.backend.abstract import Backend, MotorControlMode
+from ..dependencies import get_backend
+
+router = APIRouter(
+    prefix="/motors",
+)
+
+
+class MotorStatus(BaseModel):
+    """Represents the status of the motors.
+
+    Exposes
+    - mode: The current motor control mode (enabled, disabled, gravity_compensation).
+    """
+
+    mode: MotorControlMode
+
+
+@router.get("/status")
+async def get_motor_status(backend: Backend = Depends(get_backend)) -> MotorStatus:
+    """Get the current status of the motors."""
+    return MotorStatus(mode=backend.get_motor_control_mode())
+
+
+@router.post("/set_mode/{mode}")
+async def set_motor_mode(
+    mode: MotorControlMode,
+    backend: Backend = Depends(get_backend),
+) -> dict[str, str]:
+    """Set the motor control mode."""
+    backend.set_motor_control_mode(mode)
+
+    return {"status": f"motors changed to {mode} mode"}