reachy-mini 1.2.5rc1__py3-none-any.whl

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,85 @@
+"""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,
+                serialport=request.app.state.args.serialport,
+                scene=request.app.state.args.scene,
+                localhost_only=request.app.state.args.localhost_only,
+                wake_up_on_start=wake_up,
+                check_collision=request.app.state.args.check_collision,
+                kinematics_engine=request.app.state.args.kinematics_engine,
+                headless=request.app.state.args.headless,
+                websocket_uri=request.app.state.args.websocket_uri,
+                stream_media=request.app.state.args.stream_media,
+                use_audio=request.app.state.args.use_audio,
+                hardware_config_filepath=request.app.state.args.hardware_config_filepath,
+            )
+
+    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()
+
+    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"}

reachy_mini/daemon/app/routers/move.py

@@ -0,0 +1,265 @@
+"""Movement-related API routes.
+
+This exposes:
+- goto
+- play (wake_up, goto_sleep)
+- stop running moves
+- set_target and streaming set_target
+"""
+
+import asyncio
+import json
+from enum import Enum
+from typing import Any, Coroutine
+from uuid import UUID, uuid4
+
+import numpy as np
+from fastapi import APIRouter, Depends, HTTPException, WebSocket, WebSocketDisconnect
+from huggingface_hub.errors import RepositoryNotFoundError
+from pydantic import BaseModel
+
+from reachy_mini.motion.recorded_move import RecordedMoves
+
+from ....daemon.backend.abstract import Backend
+from ..dependencies import get_backend, ws_get_backend
+from ..models import AnyPose, FullBodyTarget
+
+move_tasks: dict[UUID, asyncio.Task[None]] = {}
+move_listeners: list[WebSocket] = []
+
+
+router = APIRouter(prefix="/move")
+
+
+class InterpolationMode(str, Enum):
+    """Interpolation modes for movement."""
+
+    # TODO: This should be the same as for the backend
+
+    LINEAR = "linear"
+    MINJERK = "minjerk"
+    EASE = "ease"
+    CARTOON = "cartoon"
+
+
+class GotoModelRequest(BaseModel):
+    """Request model for the goto endpoint."""
+
+    head_pose: AnyPose | None = None
+    antennas: tuple[float, float] | None = None
+    body_yaw: float | None = None
+    duration: float
+    interpolation: InterpolationMode = InterpolationMode.MINJERK
+
+    model_config = {
+        "json_schema_extra": {
+            "examples": [
+                {
+                    "head_pose": {
+                        "x": 0.0,
+                        "y": 0.0,
+                        "z": 0.0,
+                        "roll": 0.0,
+                        "pitch": 0.0,
+                        "yaw": 0.0,
+                    },
+                    "antennas": [0.0, 0.0],
+                    "body_yaw": 0.0,
+                    "duration": 2.0,
+                    "interpolation": "minjerk",
+                },
+                {
+                    "antennas": [0.0, 0.0],
+                    "duration": 1.0,
+                    "interpolation": "linear",
+                },
+            ],
+        }
+    }
+
+
+class MoveUUID(BaseModel):
+    """Model representing a unique identifier for a move task."""
+
+    uuid: UUID
+
+
+def create_move_task(coro: Coroutine[Any, Any, None]) -> MoveUUID:
+    """Create a new move task using async task coroutine."""
+    uuid = uuid4()
+
+    async def notify_listeners(message: str, details: str = "") -> None:
+        for ws in move_listeners:
+            try:
+                await ws.send_json(
+                    {
+                        "type": message,
+                        "uuid": str(uuid),
+                        "details": details,
+                    }
+                )
+            except (RuntimeError, WebSocketDisconnect):
+                move_listeners.remove(ws)
+
+    async def wrap_coro() -> None:
+        try:
+            await notify_listeners("move_started")
+            await coro
+            await notify_listeners("move_completed")
+        except Exception as e:
+            await notify_listeners("move_failed", details=str(e))
+        except asyncio.CancelledError:
+            await notify_listeners("move_cancelled")
+        finally:
+            move_tasks.pop(uuid, None)
+
+    task = asyncio.create_task(wrap_coro())
+    move_tasks[uuid] = task
+
+    return MoveUUID(uuid=uuid)
+
+
+async def stop_move_task(uuid: UUID) -> dict[str, str]:
+    """Stop a running move task by cancelling it."""
+    if uuid not in move_tasks:
+        raise KeyError(f"Running move with UUID {uuid} not found")
+
+    task = move_tasks.pop(uuid, None)
+    assert task is not None
+
+    if task:
+        if task.cancel():
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
+
+    return {
+        "message": f"Stopped move with UUID: {uuid}",
+    }
+
+
+@router.get("/running")
+async def get_running_moves() -> list[MoveUUID]:
+    """Get a list of currently running move tasks."""
+    return [MoveUUID(uuid=uuid) for uuid in move_tasks.keys()]
+
+
+@router.post("/goto")
+async def goto(
+    goto_req: GotoModelRequest, backend: Backend = Depends(get_backend)
+) -> MoveUUID:
+    """Request a movement to a specific target."""
+    return create_move_task(
+        backend.goto_target(
+            head=goto_req.head_pose.to_pose_array() if goto_req.head_pose else None,
+            antennas=np.array(goto_req.antennas) if goto_req.antennas else None,
+            body_yaw=goto_req.body_yaw,
+            duration=goto_req.duration,
+        )
+    )
+
+
+@router.post("/play/wake_up")
+async def play_wake_up(backend: Backend = Depends(get_backend)) -> MoveUUID:
+    """Request the robot to wake up."""
+    return create_move_task(backend.wake_up())
+
+
+@router.post("/play/goto_sleep")
+async def play_goto_sleep(backend: Backend = Depends(get_backend)) -> MoveUUID:
+    """Request the robot to go to sleep."""
+    return create_move_task(backend.goto_sleep())
+
+
+@router.get("/recorded-move-datasets/list/{dataset_name:path}")
+async def list_recorded_move_dataset(
+    dataset_name: str,
+) -> list[str]:
+    """List available recorded moves in a dataset."""
+    try:
+        moves = RecordedMoves(dataset_name)
+    except RepositoryNotFoundError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+    return moves.list_moves()
+
+
+@router.post("/play/recorded-move-dataset/{dataset_name:path}/{move_name}")
+async def play_recorded_move_dataset(
+    dataset_name: str,
+    move_name: str,
+    backend: Backend = Depends(get_backend),
+) -> MoveUUID:
+    """Request the robot to play a predefined recorded move from a dataset."""
+    try:
+        recorded_moves = RecordedMoves(dataset_name)
+    except RepositoryNotFoundError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    try:
+        move = recorded_moves.get(move_name)
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    return create_move_task(backend.play_move(move))
+
+
+@router.post("/stop")
+async def stop_move(uuid: MoveUUID) -> dict[str, str]:
+    """Stop a running move task."""
+    return await stop_move_task(uuid.uuid)
+
+
+@router.websocket("/ws/updates")
+async def ws_move_updates(
+    websocket: WebSocket,
+) -> None:
+    """WebSocket route to stream move updates."""
+    await websocket.accept()
+    try:
+        move_listeners.append(websocket)
+        while True:
+            _ = await websocket.receive_text()
+    except WebSocketDisconnect:
+        move_listeners.remove(websocket)
+
+
+# --- FullBodyTarget streaming and single set_target ---
+@router.post("/set_target")
+async def set_target(
+    target: FullBodyTarget,
+    backend: Backend = Depends(get_backend),
+) -> dict[str, str]:
+    """POST route to set a single FullBodyTarget."""
+    if backend.is_move_running:
+        # Avoid fighting with the daemon while a trajectory is running
+        backend.logger.warning("Ignoring set_target request: move already running.")
+        return {"status": "ignored", "reason": "move_running"}
+    backend.set_target(
+        head=target.target_head_pose.to_pose_array()
+        if target.target_head_pose
+        else None,
+        antennas=np.array(target.target_antennas) if target.target_antennas else None,
+        body_yaw=target.target_body_yaw,
+    )
+    return {"status": "ok"}
+
+
+@router.websocket("/ws/set_target")
+async def ws_set_target(
+    websocket: WebSocket, backend: Backend = Depends(ws_get_backend)
+) -> None:
+    """WebSocket route to stream FullBodyTarget set_target calls."""
+    await websocket.accept()
+    try:
+        while True:
+            data = await websocket.receive_text()
+            try:
+                target = FullBodyTarget.model_validate_json(data)
+                await set_target(target, backend)
+
+            except Exception as e:
+                await websocket.send_text(
+                    json.dumps({"status": "error", "detail": str(e)})
+                )
+    except WebSocketDisconnect:
+        pass