PyPI - reachy-mini - Versions diffs - 1.0.0rc1__py3-none-any.whl - Mend

reachy-mini 1.0.0rc1__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of reachy-mini might be problematic. Click here for more details.

Files changed (359) hide show

reachy_mini/daemon/app/dashboard/live_robot_state.html ADDED Viewed

@@ -0,0 +1,242 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Live Robot State & Control</title>
+    <link rel="stylesheet" href="style.css">
+    <!-- Chart.js for live joint plotting -->
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+</head>
+<body>
+    <h2>Live Robot State & Control</h2>
+    <div>
+        <h3>Head Pose (x, y, z, roll, pitch, yaw)</h3>
+        <canvas id="pose-chart" width="400" height="200"></canvas>
+    </div>
+    <div>
+        <h3>Move Commands</h3>
+        <form id="goto-form">
+            <fieldset>
+                <legend>Goto</legend>
+                <label>x: <input type="number" step="any" id="goto-x"></label>
+                <label>y: <input type="number" step="any" id="goto-y"></label>
+                <label>z: <input type="number" step="any" id="goto-z"></label><br>
+                <label>roll: <input type="number" step="any" id="goto-roll"></label>
+                <label>pitch: <input type="number" step="any" id="goto-pitch"></label>
+                <label>yaw: <input type="number" step="any" id="goto-yaw"></label>
+                <span style="margin-left:10px"><input type="checkbox" id="goto-use-deg" checked> Use degrees</span><br>
+                <label>Antennas (left,right): <input type="number" step="any" id="goto-ant-l"> <input type="number"
+                        step="any" id="goto-ant-r"></label><br>
+                <label>Duration (s): <input type="number" step="any" id="goto-duration" value="2"></label>
+                <label>Interpolation:
+                    <select id="goto-interp">
+                        <option value="linear">linear</option>
+                        <option value="minjerk" selected>minjerk</option>
+                        <option value="ease">ease</option>
+                        <option value="cartoon">cartoon</option>
+                    </select>
+                </label>
+                <button type="submit">Send Goto</button>
+            </fieldset>
+        </form>
+        <button id="wake-up-btn">Wake Up</button>
+        <button id="sleep-btn">Go to Sleep</button>
+        <button id="stop-btn">Stop Move</button>
+        <div id="move-result"></div>
+    </div>
+    <script>
+        // Poll /api/move/running to update move status and button state
+        async function pollMoveStatus() {
+            try {
+                const res = await fetch('/api/move/running');
+                const runningMoves = await res.json();
+                // If any moves are running, disable buttons except stop
+                const isRunning = Array.isArray(runningMoves) && runningMoves.length > 0;
+                setMoveButtonsDisabled(isRunning);
+                document.getElementById('stop-btn').disabled = !isRunning;
+                // Optionally update lastMoveUUID to the first running move
+                lastMoveUUID = isRunning ? runningMoves[0].uuid : null;
+            } catch (err) {
+                // On error, enable all buttons
+                setMoveButtonsDisabled(false);
+                document.getElementById('stop-btn').disabled = true;
+            }
+        }
+        setInterval(pollMoveStatus, 1000);
+        // Utility to enable/disable move buttons
+        function setMoveButtonsDisabled(disabled) {
+            document.getElementById('goto-form').querySelector('button[type="submit"]').disabled = disabled;
+            document.getElementById('wake-up-btn').disabled = disabled;
+            document.getElementById('sleep-btn').disabled = disabled;
+        }
+        function updateMoveButtons() {
+            setMoveButtonsDisabled(!!lastMoveUUID);
+            document.getElementById('stop-btn').disabled = !lastMoveUUID;
+        }
+        // --- Chart.js Setup for head pose (x, y, z, roll, pitch, yaw) ---
+        const poseCtx = document.getElementById('pose-chart').getContext('2d');
+        const poseLabels = ["x", "y", "z", "roll", "pitch", "yaw"];
+        const poseData = {
+            labels: poseLabels,
+            datasets: [{
+                label: 'Head Pose',
+                data: [0, 0, 0, 0, 0, 0],
+                backgroundColor: 'rgba(255, 99, 132, 0.2)',
+                borderColor: 'rgba(255, 99, 132, 1)',
+                borderWidth: 1
+            }]
+        };
+        const poseChart = new Chart(poseCtx, {
+            type: 'bar',
+            data: poseData,
+            options: { scales: { y: { beginAtZero: true } } }
+        });
+        // --- Live robot state via WebSocket ---
+        let ws;
+        function connectWS() {
+            ws = new WebSocket(`ws://${location.host}/api/state/ws/full`);
+            ws.onopen = () => {
+                /* ...existing code... */
+            };
+            ws.onmessage = (event) => {
+                let data;
+                try {
+                    data = JSON.parse(event.data);
+                } catch {
+                    return;
+                }
+                // Update head pose chart if available
+                if (data.head_pose) {
+                    poseChart.data.datasets[0].data[0] = data.head_pose.x;
+                    poseChart.data.datasets[0].data[1] = data.head_pose.y;
+                    poseChart.data.datasets[0].data[2] = data.head_pose.z;
+                    poseChart.data.datasets[0].data[3] = data.head_pose.roll;
+                    poseChart.data.datasets[0].data[4] = data.head_pose.pitch;
+                    poseChart.data.datasets[0].data[5] = data.head_pose.yaw;
+                    poseChart.update();
+                }
+            };
+            ws.onclose = () => {
+                setTimeout(connectWS, 1000);
+            };
+        }
+        connectWS();
+        // --- Move commands ---
+        const resultDiv = document.getElementById('move-result');
+        let lastMoveUUID = null;
+        // Helper: wait for move to finish by polling /api/move/running
+        async function waitForMoveToFinish() {
+            for (let i = 0; i < 60; i++) { // max 30s
+                try {
+                    const res = await fetch('/api/move/running');
+                    const runningMoves = await res.json();
+                    const isRunning = Array.isArray(runningMoves) && runningMoves.length > 0;
+                    if (!isRunning) return;
+                } catch (e) { }
+                await new Promise(r => setTimeout(r, 500));
+            }
+        }
+        document.getElementById('goto-form').onsubmit = async function (e) {
+            e.preventDefault();
+            resultDiv.textContent = 'playing move goto';
+            setMoveButtonsDisabled(true);
+            const useDeg = document.getElementById('goto-use-deg').checked;
+            // If using degrees, convert roll/pitch/yaw to radians
+            function toRad(val) { return useDeg ? (parseFloat(val) || 0) * Math.PI / 180 : parseFloat(val) || 0; }
+            const head_pose = {
+                x: parseFloat(document.getElementById('goto-x').value) || 0,
+                y: parseFloat(document.getElementById('goto-y').value) || 0,
+                z: parseFloat(document.getElementById('goto-z').value) || 0,
+                roll: toRad(document.getElementById('goto-roll').value) || 0,
+                pitch: toRad(document.getElementById('goto-pitch').value) || 0,
+                yaw: toRad(document.getElementById('goto-yaw').value) || 0,
+            };
+            const antennas = [
+                parseFloat(document.getElementById('goto-ant-l').value) || 0,
+                parseFloat(document.getElementById('goto-ant-r').value) || 0
+            ];
+            const duration = parseFloat(document.getElementById('goto-duration').value) || 2;
+            const interpolation = document.getElementById('goto-interp').value;
+            try {
+                console.log('Sending goto:', { head_pose, antennas, duration, interpolation });
+                const res = await fetch('/api/move/goto', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ head_pose, antennas, duration, interpolation })
+                });
+                const data = await res.json();
+                lastMoveUUID = data.uuid || null;
+                await waitForMoveToFinish();
+                resultDiv.textContent = 'move goto finished';
+            } catch (err) {
+                resultDiv.textContent = 'Error sending goto.';
+            }
+            updateMoveButtons();
+        };
+        document.getElementById('wake-up-btn').onclick = async function () {
+            resultDiv.textContent = 'playing move wake_up';
+            setMoveButtonsDisabled(true);
+            try {
+                const res = await fetch('/api/move/play/wake_up', { method: 'POST' });
+                const data = await res.json();
+                lastMoveUUID = data.uuid || null;
+                await waitForMoveToFinish();
+                resultDiv.textContent = 'move wake_up finished';
+            } catch (err) {
+                resultDiv.textContent = 'Error sending wake up.';
+            }
+            updateMoveButtons();
+        };
+        document.getElementById('sleep-btn').onclick = async function () {
+            resultDiv.textContent = 'playing move goto_sleep';
+            setMoveButtonsDisabled(true);
+            try {
+                const res = await fetch('/api/move/play/goto_sleep', { method: 'POST' });
+                const data = await res.json();
+                lastMoveUUID = data.uuid || null;
+                await waitForMoveToFinish();
+                resultDiv.textContent = 'move goto_sleep finished';
+            } catch (err) {
+                resultDiv.textContent = 'Error sending go to sleep.';
+            }
+            updateMoveButtons();
+        };
+        document.getElementById('stop-btn').onclick = async function () {
+            if (!lastMoveUUID) {
+                resultDiv.textContent = 'No move UUID to stop.';
+                return;
+            }
+            resultDiv.textContent = 'playing move stop';
+            setMoveButtonsDisabled(true);
+            try {
+                const res = await fetch('/api/move/stop', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ uuid: lastMoveUUID })
+                });
+                const data = await res.json();
+                await waitForMoveToFinish();
+                resultDiv.textContent = 'move stop finished';
+                lastMoveUUID = null;
+            } catch (err) {
+                resultDiv.textContent = 'Error stopping move.';
+            }
+            updateMoveButtons();
+            // Initialize button states on page load
+            updateMoveButtons();
+        };
+    </script>
+    <!-- Removed duplicated move section -->
+</body>
+</html>

reachy_mini/daemon/app/dashboard/style.css ADDED Viewed

@@ -0,0 +1,37 @@
+body {
+    font-family: Arial, sans-serif;
+    background: #f7f7f7;
+    margin: 0;
+    padding: 0;
+}
+h1 {
+    background: #2d3e50;
+    color: #fff;
+    padding: 1em;
+    margin: 0 0 1em 0;
+}
+ul#examples-list {
+    list-style: none;
+    padding: 0;
+    margin: 2em;
+}
+ul#examples-list li {
+    background: #fff;
+    margin-bottom: 1em;
+    padding: 1em;
+    border-radius: 6px;
+    box-shadow: 0 2px 6px rgba(0, 0, 0, 0.07);
+}
+ul#examples-list li a {
+    color: #2d3e50;
+    text-decoration: none;
+    font-weight: bold;
+}
+ul#examples-list li a:hover {
+    text-decoration: underline;
+}

reachy_mini/daemon/app/dependencies.py ADDED Viewed

@@ -0,0 +1,36 @@
+"""FastAPI common request dependencies."""
+from fastapi import HTTPException, Request, WebSocket
+from ...apps.manager import AppManager
+from ..backend.abstract import Backend
+from ..daemon import Daemon
+def get_daemon(request: Request) -> Daemon:
+    """Get the daemon as request dependency."""
+    assert isinstance(request.app.state.daemon, Daemon)
+    return request.app.state.daemon
+def get_backend(request: Request) -> Backend:
+    """Get the backend as request dependency."""
+    backend = request.app.state.daemon.backend
+    assert isinstance(backend, Backend)
+    if not backend.ready.is_set():
+        raise HTTPException(status_code=503, detail="Backend not running")
+    return backend
+def get_app_manager(request: Request) -> "AppManager":
+    """Get the app manager as request dependency."""
+    assert isinstance(request.app.state.app_manager, AppManager)
+    return request.app.state.app_manager
+def ws_get_backend(websocket: WebSocket) -> Backend:
+    """Get the backend as websocket dependency."""
+    assert isinstance(websocket.app.state.daemon.backend, Backend)
+    return websocket.app.state.daemon.backend

reachy_mini/daemon/app/main.py ADDED Viewed

@@ -0,0 +1,271 @@
+"""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
+import os
+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
+DASHBOARD_PAGES = Path(__file__).parent / "dashboard"
+TEMPLATES_DIR = Path(__file__).parent / "templates"
+templates = Jinja2Templates(directory=str(TEMPLATES_DIR))
+@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()
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],  # or restrict to your HF domain
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+    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)
+    # Route to list available HTML/JS/CSS examples with links using Jinja2 template
+    @app.get("/")
+    async def list_examples(request: Request) -> HTMLResponse:
+        """Render the dashboard."""
+        files = [f for f in os.listdir(DASHBOARD_PAGES) if f.endswith(".html")]
+        return templates.TemplateResponse(
+            "dashboard.html", {"request": request, "files": files}
+        )
+    app.mount(
+        "/dashboard",
+        StaticFiles(directory=str(DASHBOARD_PAGES), html=True),
+        name="dashboard",
+    )
+    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()