reachy-mini 1.2.5rc1__py3-none-any.whl

reachy_mini/daemon/app/routers/state.py

@@ -0,0 +1,146 @@
+"""State-related API routes.
+
+This exposes:
+- basic get routes to retrieve most common fields
+- full state and streaming state updates
+"""
+
+import asyncio
+from datetime import datetime, timezone
+from typing import Any
+
+from fastapi import APIRouter, Depends, WebSocket, WebSocketDisconnect
+
+from ....daemon.backend.abstract import Backend
+from ..dependencies import get_backend, ws_get_backend
+from ..models import AnyPose, FullState, as_any_pose
+
+router = APIRouter(prefix="/state")
+
+
+@router.get("/present_head_pose")
+async def get_head_pose(
+    use_pose_matrix: bool = False,
+    backend: Backend = Depends(get_backend),
+) -> AnyPose:
+    """Get the present head pose.
+
+    Arguments:
+        use_pose_matrix (bool): Whether to use the pose matrix representation (4x4 flattened) or the translation + Euler angles representation (x, y, z, roll, pitch, yaw).
+        backend (Backend): The backend instance.
+
+    Returns:
+        AnyPose: The present head pose.
+
+    """
+    return as_any_pose(backend.get_present_head_pose(), use_pose_matrix)
+
+
+@router.get("/present_body_yaw")
+async def get_body_yaw(
+    backend: Backend = Depends(get_backend),
+) -> float:
+    """Get the present body yaw (in radians)."""
+    return backend.get_present_body_yaw()
+
+
+@router.get("/present_antenna_joint_positions")
+async def get_antenna_joint_positions(
+    backend: Backend = Depends(get_backend),
+) -> tuple[float, float]:
+    """Get the present antenna joint positions (in radians) - (left, right)."""
+    pos = backend.get_present_antenna_joint_positions()
+    assert len(pos) == 2
+    return (pos[0], pos[1])
+
+
+@router.get("/full")
+async def get_full_state(
+    with_control_mode: bool = True,
+    with_head_pose: bool = True,
+    with_target_head_pose: bool = False,
+    with_head_joints: bool = False,
+    with_target_head_joints: bool = False,
+    with_body_yaw: bool = True,
+    with_target_body_yaw: bool = False,
+    with_antenna_positions: bool = True,
+    with_target_antenna_positions: bool = False,
+    with_passive_joints: bool = False,
+    use_pose_matrix: bool = False,
+    backend: Backend = Depends(get_backend),
+) -> FullState:
+    """Get the full robot state, with optional fields."""
+    result: dict[str, Any] = {}
+
+    if with_control_mode:
+        result["control_mode"] = backend.get_motor_control_mode().value
+
+    if with_head_pose:
+        pose = backend.get_present_head_pose()
+        result["head_pose"] = as_any_pose(pose, use_pose_matrix)
+    if with_target_head_pose:
+        target_pose = backend.target_head_pose
+        assert target_pose is not None
+        result["target_head_pose"] = as_any_pose(target_pose, use_pose_matrix)
+    if with_head_joints:
+        result["head_joints"] = backend.get_present_head_joint_positions()
+    if with_target_head_joints:
+        result["target_head_joints"] = backend.target_head_joint_positions
+    if with_body_yaw:
+        result["body_yaw"] = backend.get_present_body_yaw()
+    if with_target_body_yaw:
+        result["target_body_yaw"] = backend.target_body_yaw
+    if with_antenna_positions:
+        result["antennas_position"] = backend.get_present_antenna_joint_positions()
+    if with_target_antenna_positions:
+        result["target_antennas_position"] = backend.target_antenna_joint_positions
+    if with_passive_joints:
+        joints = backend.get_present_passive_joint_positions()
+        if joints is not None:
+            result["passive_joints"] = list(joints.values())
+        else:
+            result["passive_joints"] = None
+
+    result["timestamp"] = datetime.now(timezone.utc)
+    return FullState.model_validate(result)
+
+
+@router.websocket("/ws/full")
+async def ws_full_state(
+    websocket: WebSocket,
+    frequency: float = 10.0,
+    with_head_pose: bool = True,
+    with_target_head_pose: bool = False,
+    with_head_joints: bool = False,
+    with_target_head_joints: bool = False,
+    with_body_yaw: bool = True,
+    with_target_body_yaw: bool = False,
+    with_antenna_positions: bool = True,
+    with_target_antenna_positions: bool = False,
+    with_passive_joints: bool = False,
+    use_pose_matrix: bool = False,
+    backend: Backend = Depends(ws_get_backend),
+) -> None:
+    """WebSocket endpoint to stream the full state of the robot."""
+    await websocket.accept()
+    period = 1.0 / frequency
+
+    try:
+        while True:
+            full_state = await get_full_state(
+                with_head_pose=with_head_pose,
+                with_target_head_pose=with_target_head_pose,
+                with_head_joints=with_head_joints,
+                with_target_head_joints=with_target_head_joints,
+                with_body_yaw=with_body_yaw,
+                with_target_body_yaw=with_target_body_yaw,
+                with_antenna_positions=with_antenna_positions,
+                with_target_antenna_positions=with_target_antenna_positions,
+                with_passive_joints=with_passive_joints,
+                use_pose_matrix=use_pose_matrix,
+                backend=backend,
+            )
+            await websocket.send_text(full_state.model_dump_json())
+            await asyncio.sleep(period)
+    except WebSocketDisconnect:
+        pass

reachy_mini/daemon/app/routers/update.py

@@ -0,0 +1,86 @@
+"""Update router for Reachy Mini Daemon API.
+
+This module provides endpoints to check for updates, start updates, and monitor update status.
+"""
+
+import logging
+import threading
+
+import requests
+from fastapi import APIRouter, HTTPException, WebSocket
+
+from reachy_mini.daemon.app import bg_job_register
+from reachy_mini.daemon.app.bg_job_register import JobInfo
+from reachy_mini.utils.wireless_version.update import update_reachy_mini
+from reachy_mini.utils.wireless_version.update_available import (
+    get_local_version,
+    get_pypi_version,
+    is_update_available,
+)
+
+router = APIRouter(prefix="/update")
+busy_lock = threading.Lock()
+
+
+@router.get("/available")
+def available(pre_release: bool = False) -> dict[str, dict[str, dict[str, bool | str]]]:
+    """Check if an update is available for Reachy Mini Wireless."""
+    if busy_lock.locked():
+        raise HTTPException(status_code=400, detail="Update is in progress")
+
+    current_version = str(get_local_version("reachy_mini"))
+
+    try:
+        is_available = is_update_available("reachy_mini", pre_release)
+        available = str(get_pypi_version("reachy_mini", pre_release))
+    except (ConnectionError, requests.exceptions.ConnectionError):
+        is_available = False
+        available = "unknown"
+
+    return {
+        "update": {
+            "reachy_mini": {
+                "is_available": is_available,
+                "current_version": current_version,
+                "available_version": available,
+            }
+        }
+    }
+
+
+@router.post("/start")
+def start_update(pre_release: bool = False) -> dict[str, str]:
+    """Start the update process for Reachy Mini Wireless version."""
+    if busy_lock.locked():
+        raise HTTPException(status_code=400, detail="Update already in progress")
+
+    if not is_update_available("reachy_mini", pre_release):
+        raise HTTPException(status_code=400, detail="No update available")
+
+    async def update_wrapper(logger: logging.Logger) -> None:
+        with busy_lock:
+            await update_reachy_mini(pre_release, logger)
+
+    job_uuid = bg_job_register.run_command(
+        "update_reachy_mini",
+        update_wrapper,
+    )
+
+    return {"job_id": job_uuid}
+
+
+@router.get("/info")
+def get_update_info(job_id: str) -> JobInfo:
+    """Get the info of an update job."""
+    try:
+        return bg_job_register.get_info(job_id)
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+
+@router.websocket("/ws/logs")
+async def websocket_logs(websocket: WebSocket, job_id: str) -> None:
+    """WebSocket endpoint to stream update logs in real time."""
+    await websocket.accept()
+    await bg_job_register.ws_poll_info(websocket, job_id)
+    await websocket.close()

reachy_mini/daemon/app/routers/volume.py

@@ -0,0 +1,423 @@
+"""Volume control API routes.
+
+This exposes:
+- get current volume
+- set volume
+- same for microphone
+- play test sound (optional)
+"""
+
+import logging
+import platform
+import subprocess
+from typing import Optional
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel, Field
+
+from reachy_mini.daemon.app.dependencies import get_backend
+from reachy_mini.daemon.backend.abstract import Backend
+
+router = APIRouter(prefix="/volume")
+logger = logging.getLogger(__name__)
+
+# Constants
+AUDIO_COMMAND_TIMEOUT = 2  # Timeout in seconds for audio commands
+
+# Device-specific card names for amixer
+DEVICE_CARD_NAMES = {
+    "reachy_mini_audio": "Audio",  # Reachy Mini Audio device
+    "respeaker": "Array",  # Legacy ReSpeaker device
+    "default": "Audio",  # Default to Reachy Mini Audio
+}
+
+
+class VolumeRequest(BaseModel):
+    """Request model for setting volume."""
+
+    volume: int = Field(..., ge=0, le=100, description="Volume level (0-100)")
+
+
+class VolumeResponse(BaseModel):
+    """Response model for volume operations."""
+
+    volume: int
+    device: str
+    platform: str
+
+
+class TestSoundResponse(BaseModel):
+    """Response model for test sound operations."""
+
+    status: str
+    message: str
+
+
+def get_current_platform() -> str:
+    """Get the current platform."""
+    system = platform.system()
+    if system == "Darwin":
+        return "macOS"
+    elif system == "Linux":
+        return "Linux"
+    else:
+        return system
+
+
+def detect_audio_device() -> str:
+    """Detect the current audio output device."""
+    system = platform.system()
+
+    if system == "Linux":
+        # Try to detect if Reachy Mini Audio or legacy Respeaker is available
+        try:
+            result = subprocess.run(
+                ["aplay", "-l"],
+                capture_output=True,
+                text=True,
+                timeout=AUDIO_COMMAND_TIMEOUT,
+            )
+            output_lower = result.stdout.lower()
+            if "reachy mini audio" in output_lower:
+                return "reachy_mini_audio"
+            elif "respeaker" in output_lower:
+                return "respeaker"
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            pass
+        return "default"
+    elif system == "Darwin":
+        return "system"
+    else:
+        return "unknown"
+
+
+def get_linux_card_name() -> str:
+    """Get the appropriate card name for Linux amixer commands based on detected device."""
+    device = detect_audio_device()
+    return DEVICE_CARD_NAMES.get(device, DEVICE_CARD_NAMES["default"])
+
+
+# macOS Volume Control
+
+
+def get_volume_macos() -> Optional[int]:
+    """Get current system volume on macOS."""
+    try:
+        result = subprocess.run(
+            ["osascript", "-e", "output volume of (get volume settings)"],
+            capture_output=True,
+            text=True,
+            timeout=AUDIO_COMMAND_TIMEOUT,
+        )
+        if result.returncode == 0:
+            return int(result.stdout.strip())
+    except (subprocess.TimeoutExpired, FileNotFoundError, ValueError) as e:
+        logger.error(f"Failed to get macOS volume: {e}")
+    return None
+
+
+def set_volume_macos(volume: int) -> bool:
+    """Set system volume on macOS using osascript."""
+    try:
+        subprocess.run(
+            ["osascript", "-e", f"set volume output volume {volume}"],
+            capture_output=True,
+            timeout=AUDIO_COMMAND_TIMEOUT,
+            check=True,
+        )
+        return True
+    except (
+        subprocess.TimeoutExpired,
+        FileNotFoundError,
+        subprocess.CalledProcessError,
+    ) as e:
+        logger.error(f"Failed to set macOS volume: {e}")
+        return False
+
+
+# Linux Volume Control
+
+
+def get_volume_linux() -> Optional[int]:
+    """Get current volume on Linux using amixer."""
+    card_name = get_linux_card_name()
+    try:
+        result = subprocess.run(
+            ["amixer", "-c", card_name, "sget", "PCM"],
+            capture_output=True,
+            text=True,
+            timeout=AUDIO_COMMAND_TIMEOUT,
+        )
+        if result.returncode == 0:
+            # Parse output to extract volume percentage
+            for line in result.stdout.splitlines():
+                if "Left:" in line and "[" in line:
+                    # Extract percentage between brackets
+                    parts = line.split("[")
+                    for part in parts:
+                        if "%" in part:
+                            volume_str = part.split("%")[0]
+                            return int(volume_str)
+    except (subprocess.TimeoutExpired, FileNotFoundError, ValueError) as e:
+        logger.error(f"Failed to get Linux volume: {e}")
+    return None
+
+
+def set_volume_linux(volume: int) -> bool:
+    """Set current volume on Linux using amixer."""
+    card_name = get_linux_card_name()
+    try:
+        subprocess.run(
+            ["amixer", "-c", card_name, "sset", "PCM", f"{volume}%"],
+            capture_output=True,
+            text=True,
+            timeout=AUDIO_COMMAND_TIMEOUT,
+            check=True,
+        )
+        subprocess.run(
+            ["amixer", "-c", card_name, "sset", "PCM,1", "100%"],
+            capture_output=True,
+            text=True,
+            timeout=AUDIO_COMMAND_TIMEOUT,
+            check=True,
+        )
+        return True
+    except (
+        subprocess.TimeoutExpired,
+        FileNotFoundError,
+        subprocess.CalledProcessError,
+        ValueError,
+    ) as e:
+        logger.error(f"Failed to set Linux volume: {e}")
+        return False
+
+
+# API Endpoints - Speaker Volume
+
+
+@router.get("/current")
+async def get_volume() -> VolumeResponse:
+    """Get the current volume level."""
+    system = get_current_platform()
+    device = detect_audio_device()
+
+    volume = None
+    if system == "macOS":
+        volume = get_volume_macos()
+    elif system == "Linux":
+        volume = get_volume_linux()
+
+    if volume is None:
+        raise HTTPException(status_code=500, detail="Failed to get volume")
+
+    return VolumeResponse(volume=volume, device=device, platform=system)
+
+
+@router.post("/set")
+async def set_volume(
+    volume_req: VolumeRequest,
+    backend: Backend = Depends(get_backend),
+) -> VolumeResponse:
+    """Set the volume level and play a test sound."""
+    system = get_current_platform()
+    device = detect_audio_device()
+
+    success = False
+    if system == "macOS":
+        success = set_volume_macos(volume_req.volume)
+    elif system == "Linux":
+        success = set_volume_linux(volume_req.volume)
+    else:
+        raise HTTPException(
+            status_code=501,
+            detail=f"Volume control not supported on {system}",
+        )
+
+    if not success:
+        raise HTTPException(status_code=500, detail="Failed to set volume")
+
+    # Play test sound
+    test_sound = "impatient1.wav"
+    if backend.audio:
+        try:
+            backend.audio.play_sound(test_sound)
+        except Exception as e:
+            msg = str(e).lower()
+            if "device unavailable" in msg or "-9985" in msg:
+                logger.warning(
+                    "Test sound not played: audio device busy (likely GStreamer): %s",
+                    e,
+                )
+            else:
+                logger.warning("Failed to play test sound: %s", e)
+    else:
+        logger.warning("No audio backend available, skipping test sound.")
+
+    return VolumeResponse(volume=volume_req.volume, device=device, platform=system)
+
+
+@router.post("/test-sound")
+async def play_test_sound(backend: Backend = Depends(get_backend)) -> TestSoundResponse:
+    """Play a test sound."""
+    test_sound = "impatient1.wav"
+
+    if not backend.audio:
+        raise HTTPException(status_code=503, detail="Audio device not available")
+
+    try:
+        backend.audio.play_sound(test_sound)
+        return TestSoundResponse(status="ok", message="Test sound played")
+    except Exception as e:
+        msg = str(e).lower()
+
+        # Special-case ALSA / PortAudio device-busy situation
+        if "device unavailable" in msg or "-9985" in msg:
+            logger.warning(
+                "Test sound request while audio device is busy (likely GStreamer): %s",
+                e,
+            )
+            # Still 200, but tell the caller it was skipped
+            return TestSoundResponse(
+                status="busy",
+                message="Audio device is currently in use, test sound was skipped.",
+            )
+
+        # Any other error is treated as a real failure
+        logger.error("Failed to play test sound: %s", e, exc_info=True)
+        raise HTTPException(
+            status_code=500,
+            detail="Failed to play test sound (see logs for details)",
+        )
+
+
+# macOS Microphone Control
+
+
+def get_microphone_volume_macos() -> Optional[int]:
+    """Get current microphone input volume on macOS."""
+    try:
+        result = subprocess.run(
+            ["osascript", "-e", "input volume of (get volume settings)"],
+            capture_output=True,
+            text=True,
+            timeout=AUDIO_COMMAND_TIMEOUT,
+        )
+        if result.returncode == 0:
+            return int(result.stdout.strip())
+    except (subprocess.TimeoutExpired, FileNotFoundError, ValueError) as e:
+        logger.error(f"Failed to get macOS microphone volume: {e}")
+    return None
+
+
+def set_microphone_volume_macos(volume: int) -> bool:
+    """Set microphone input volume on macOS using osascript."""
+    try:
+        subprocess.run(
+            ["osascript", "-e", f"set volume input volume {volume}"],
+            capture_output=True,
+            timeout=AUDIO_COMMAND_TIMEOUT,
+            check=True,
+        )
+        return True
+    except (
+        subprocess.TimeoutExpired,
+        FileNotFoundError,
+        subprocess.CalledProcessError,
+    ) as e:
+        logger.error(f"Failed to set macOS microphone volume: {e}")
+        return False
+
+
+# Linux Microphone Control
+
+
+def get_microphone_volume_linux() -> Optional[int]:
+    """Get current microphone input volume on Linux using amixer."""
+    card_name = get_linux_card_name()
+    try:
+        result = subprocess.run(
+            ["amixer", "-c", card_name, "sget", "Headset"],
+            capture_output=True,
+            text=True,
+            timeout=AUDIO_COMMAND_TIMEOUT,
+        )
+        if result.returncode == 0:
+            # Parse output to extract volume percentage
+            for line in result.stdout.splitlines():
+                if "Left:" in line and "[" in line:
+                    parts = line.split("[")
+                    for part in parts:
+                        if "%" in part:
+                            volume_str = part.split("%")[0]
+                            return int(volume_str)
+    except (subprocess.TimeoutExpired, FileNotFoundError, ValueError) as e:
+        logger.error(f"Failed to get Linux microphone volume: {e}")
+    return None
+
+
+def set_microphone_volume_linux(volume: int) -> bool:
+    """Set microphone input volume on Linux using amixer."""
+    card_name = get_linux_card_name()
+    try:
+        subprocess.run(
+            ["amixer", "-c", card_name, "sset", "Headset", f"{volume}%"],
+            capture_output=True,
+            text=True,
+            timeout=AUDIO_COMMAND_TIMEOUT,
+            check=True,
+        )
+        return True
+    except (
+        subprocess.TimeoutExpired,
+        FileNotFoundError,
+        subprocess.CalledProcessError,
+        ValueError,
+    ) as e:
+        logger.error(f"Failed to set Linux microphone volume: {e}")
+        return False
+
+
+# API Endpoints - Microphone Volume
+
+
+@router.get("/microphone/current")
+async def get_microphone_volume() -> VolumeResponse:
+    """Get the current microphone input volume level."""
+    system = get_current_platform()
+    device = detect_audio_device()
+
+    volume = None
+    if system == "macOS":
+        volume = get_microphone_volume_macos()
+    elif system == "Linux":
+        volume = get_microphone_volume_linux()
+
+    if volume is None:
+        raise HTTPException(status_code=500, detail="Failed to get microphone volume")
+
+    return VolumeResponse(volume=volume, device=device, platform=system)
+
+
+@router.post("/microphone/set")
+async def set_microphone_volume(
+    volume_req: VolumeRequest,
+) -> VolumeResponse:
+    """Set the microphone input volume level."""
+    system = get_current_platform()
+    device = detect_audio_device()
+
+    success = False
+    if system == "macOS":
+        success = set_microphone_volume_macos(volume_req.volume)
+    elif system == "Linux":
+        success = set_microphone_volume_linux(volume_req.volume)
+    else:
+        raise HTTPException(
+            status_code=501,
+            detail=f"Microphone volume control not supported on {system}",
+        )
+
+    if not success:
+        raise HTTPException(status_code=500, detail="Failed to set microphone volume")
+
+    return VolumeResponse(volume=volume_req.volume, device=device, platform=system)