reachy-mini 1.2.5rc1__py3-none-any.whl → 1.2.11__py3-none-any.whl

reachy_mini/daemon/app/main.py

@@ -10,10 +10,11 @@ managing the robot's state.
 import argparse
 import asyncio
 import logging
+import types
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
 from pathlib import Path
-from typing import AsyncGenerator
+from typing import Any, AsyncGenerator
 
 import uvicorn
 from fastapi import APIRouter, FastAPI, Request
@@ -26,7 +27,9 @@ from reachy_mini.apps.manager import AppManager
 from reachy_mini.daemon.app.routers import (
     apps,
     daemon,
+    hf_auth,
     kinematics,
+    logs,
     motors,
     move,
     state,
@@ -37,9 +40,13 @@ from reachy_mini.media.audio_utils import (
     check_reachymini_asoundrc,
     write_asoundrc_to_home,
 )
+from reachy_mini.motion.recorded_move import preload_default_datasets
 from reachy_mini.utils.wireless_version.startup_check import (
+    check_and_fix_restore_venv,
     check_and_fix_venvs_ownership,
+    check_and_sync_apps_venv_sdk,
     check_and_update_bluetooth_service,
+    check_and_update_wireless_launcher,
 )
 
 
@@ -57,6 +64,7 @@ class Args:
     hardware_config_filepath: str | None = None
 
     sim: bool = False
+    mockup_sim: bool = False
     scene: str = "empty"
     headless: bool = False
     websocket_uri: str | None = None
@@ -71,6 +79,8 @@ class Args:
 
     wake_up_on_start: bool = True
     goto_sleep_on_stop: bool = True
+    preload_datasets: bool = False
+    dataset_update_interval_hours: float = 24.0  # 0 to disable periodic updates
 
     robot_name: str = "reachy_mini"
 
@@ -92,12 +102,52 @@ def create_app(args: Args, health_check_event: asyncio.Event | None = None) -> F
     async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
         """Lifespan context manager for the FastAPI application."""
         args = app.state.args  # type: Args
+        dataset_updater_task: asyncio.Task[None] | None = None
+
+        def preload_with_logging() -> None:
+            """Download datasets with logging."""
+            try:
+                preload_default_datasets()
+                logging.info("Recorded move datasets pre-loaded successfully")
+            except Exception as e:
+                logging.warning(f"Failed to pre-load some datasets: {e}")
+
+        async def dataset_updater(interval_hours: float) -> None:
+            """Background task that periodically checks for dataset updates."""
+            interval_seconds = interval_hours * 3600
+            while True:
+                try:
+                    await asyncio.sleep(interval_seconds)
+                    logging.info("Checking for dataset updates...")
+                    loop = asyncio.get_event_loop()
+                    await loop.run_in_executor(None, preload_with_logging)
+                except asyncio.CancelledError:
+                    logging.info("Dataset updater task cancelled")
+                    break
+                except Exception as e:
+                    logging.warning(f"Error in dataset updater: {e}")
+
+        # Pre-download recorded move datasets in background to avoid delays on first play
+        # This runs in asyncio's default ThreadPoolExecutor (fire and forget)
+        if args.preload_datasets:
+            loop = asyncio.get_event_loop()
+            loop.run_in_executor(None, preload_with_logging)
+
+        # Start periodic dataset updater if enabled (interval > 0)
+        if args.dataset_update_interval_hours > 0:
+            dataset_updater_task = asyncio.create_task(
+                dataset_updater(args.dataset_update_interval_hours)
+            )
+            logging.info(
+                f"Dataset updater started (interval: {args.dataset_update_interval_hours}h)"
+            )
 
         try:
             if args.autostart:
                 await app.state.daemon.start(
                     serialport=args.serialport,
                     sim=args.sim,
+                    mockup_sim=args.mockup_sim,
                     scene=args.scene,
                     headless=args.headless,
                     websocket_uri=args.websocket_uri,
@@ -109,14 +159,23 @@ def create_app(args: Args, health_check_event: asyncio.Event | None = None) -> F
                     localhost_only=localhost_only,
                     hardware_config_filepath=args.hardware_config_filepath,
                 )
+
             yield
         finally:
+            # Cancel dataset updater task if running
+            if dataset_updater_task and not dataset_updater_task.done():
+                dataset_updater_task.cancel()
+                try:
+                    await dataset_updater_task
+                except asyncio.CancelledError:
+                    pass
+
             # Ensure cleanup happens even if there's an exception
             try:
                 logging.info("Shutting down app manager...")
                 await app.state.app_manager.close()
             except Exception as e:
-                logging.error(f"Error closing app manager: {e}")
+                logging.exception(f"Error closing app manager: {e}")
 
             try:
                 logging.info("Shutting down daemon...")
@@ -124,7 +183,7 @@ def create_app(args: Args, health_check_event: asyncio.Event | None = None) -> F
                     goto_sleep_on_stop=args.goto_sleep_on_stop,
                 )
             except Exception as e:
-                logging.error(f"Error stopping daemon: {e}")
+                logging.exception(f"Error stopping daemon: {e}")
 
     app = FastAPI(
         lifespan=lifespan,
@@ -145,6 +204,7 @@ def create_app(args: Args, health_check_event: asyncio.Event | None = None) -> F
     router = APIRouter(prefix="/api")
     router.include_router(apps.router)
     router.include_router(daemon.router)
+    router.include_router(hf_auth.router)
     router.include_router(kinematics.router)
     router.include_router(motors.router)
     router.include_router(move.router)
@@ -152,8 +212,10 @@ def create_app(args: Args, health_check_event: asyncio.Event | None = None) -> F
     router.include_router(volume.router)
 
     if args.wireless_version:
-        from .routers import update, wifi_config
+        from .routers import cache, update, wifi_config
 
+        app.include_router(cache.router)
+        app.include_router(logs.router)
         app.include_router(update.router)
         app.include_router(wifi_config.router)
 
@@ -194,18 +256,83 @@ def create_app(args: Args, health_check_event: asyncio.Event | None = None) -> F
             """Render the settings page."""
             return templates.TemplateResponse("settings.html", {"request": request})
 
+        @app.get("/logs")
+        async def logs_page(request: Request) -> HTMLResponse:
+            """Render the logs page."""
+            return templates.TemplateResponse("logs.html", {"request": request})
+
     return app
 
 
 def run_app(args: Args) -> None:
     """Run the FastAPI app with Uvicorn."""
-    logging.basicConfig(level=logging.INFO)
+    # Configure logging to ensure all logs go to stderr (captured by systemd)
+    import sys
+
+    root_logger = logging.getLogger()
+    root_logger.setLevel(args.log_level)
+
+    # Create handler that writes to stderr with immediate flush
+    handler = logging.StreamHandler(sys.stderr)
+    handler.setLevel(args.log_level)
+    handler.setFormatter(
+        logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+    )
+    root_logger.addHandler(handler)
+
+    # Explicitly configure the apps.manager logger to ensure propagation
+    apps_logger = logging.getLogger("reachy_mini.apps.manager")
+    apps_logger.setLevel(args.log_level)
+    apps_logger.propagate = True  # Ensure it propagates to root logger
+
+    # Install exception hook to catch uncaught exceptions
+    def exception_hook(
+        exc_type: type[BaseException],
+        exc_value: BaseException,
+        exc_traceback: types.TracebackType | None,
+    ) -> None:
+        """Log uncaught exceptions with full traceback."""
+        if issubclass(exc_type, KeyboardInterrupt):
+            # Allow KeyboardInterrupt to exit normally
+            sys.__excepthook__(exc_type, exc_value, exc_traceback)
+            return
+
+        root_logger.critical(
+            "Uncaught exception", exc_info=(exc_type, exc_value, exc_traceback)
+        )
+        sys.stderr.flush()
+
+    sys.excepthook = exception_hook
 
     async def run_server() -> None:
+        # Set up asyncio exception handler to catch unhandled task exceptions
+        loop = asyncio.get_running_loop()
+
+        def asyncio_exception_handler(
+            loop: asyncio.AbstractEventLoop, context: dict[str, Any]
+        ) -> None:
+            """Handle exceptions in asyncio tasks."""
+            exception = context.get("exception")
+            if exception:
+                root_logger.error(
+                    f"Unhandled exception in asyncio task: {context.get('message', 'No message')}",
+                    exc_info=(type(exception), exception, exception.__traceback__),
+                )
+            else:
+                root_logger.error(f"Asyncio error: {context}")
+            sys.stderr.flush()
+
+        loop.set_exception_handler(asyncio_exception_handler)
+
         health_check_event = asyncio.Event()
         app = create_app(args, health_check_event)
 
-        config = uvicorn.Config(app, host=args.fastapi_host, port=args.fastapi_port)
+        config = uvicorn.Config(
+            app,
+            host=args.fastapi_host,
+            port=args.fastapi_port,
+            log_config=None,  # Don't override Python logging configuration
+        )
         server = uvicorn.Server(config)
 
         health_check_task = None
@@ -234,6 +361,9 @@ def run_app(args: Args) -> None:
             await server.serve()
         except KeyboardInterrupt:
             logging.info("Received Ctrl-C, shutting down gracefully.")
+        except Exception as e:
+            logging.exception(f"Error during server operation: {e}")
+            raise
         finally:
             # Cancel health check task if it exists
             if health_check_task and not health_check_task.done():
@@ -248,7 +378,8 @@ def run_app(args: Args) -> None:
     except KeyboardInterrupt:
         logging.info("Shutdown complete.")
     except Exception as e:
-        logging.error(f"Error during shutdown: {e}")
+        logging.exception(f"Error during shutdown: {e}")
+        sys.stderr.flush()
         raise
 
 
@@ -306,6 +437,12 @@ def main() -> None:
         default=default_args.sim,
         help="Run in simulation mode using Mujoco.",
     )
+    parser.add_argument(
+        "--mockup-sim",
+        action="store_true",
+        default=default_args.mockup_sim,
+        help="Run in mockup simulation mode (no MuJoCo required).",
+    )
     parser.add_argument(
         "--scene",
         type=str,
@@ -380,6 +517,25 @@ def main() -> None:
         dest="goto_sleep_on_stop",
         help="Do not put the robot to sleep on daemon stop (default: False).",
     )
+    parser.add_argument(
+        "--preload-datasets",
+        action="store_true",
+        default=default_args.preload_datasets,
+        help="Pre-download recorded move datasets (emotions, dances) at startup (default: False).",
+    )
+    parser.add_argument(
+        "--no-preload-datasets",
+        action="store_false",
+        dest="preload_datasets",
+        help="Do not pre-download datasets at startup (default: False).",
+    )
+    parser.add_argument(
+        "--dataset-update-interval",
+        type=float,
+        default=default_args.dataset_update_interval_hours,
+        dest="dataset_update_interval_hours",
+        help="Interval in hours for background dataset update checks (default: 24.0, 0 to disable).",
+    )
     # Zenoh server options
     parser.add_argument(
         "--localhost-only",
@@ -451,6 +607,15 @@ def main() -> None:
         # Check and update bluetooth service if needed
         check_and_update_bluetooth_service()
 
+        # Check and update wireless launcher if needed
+        check_and_update_wireless_launcher()
+
+        # Check and sync apps_venv SDK version with daemon
+        check_and_sync_apps_venv_sdk()
+
+        # Check and fix restore venv if it has legacy editable install
+        check_and_fix_restore_venv()
+
         if check_reachymini_asoundrc():
             logging.getLogger().info(
                 "~/.asoundrc correctly configured for Reachy Mini Audio."

reachy_mini/daemon/app/models.py

@@ -137,6 +137,13 @@ class FullBodyTarget(BaseModel):
     }
 
 
+class DoAInfo(BaseModel):
+    """Direction of Arrival info from the microphone array."""
+
+    angle: float  # Angle in radians (0=left, π/2=front, π=right)
+    speech_detected: bool
+
+
 class FullState(BaseModel):
     """Represent the full state of the robot including all joint positions and poses."""
 
@@ -147,3 +154,4 @@ class FullState(BaseModel):
     antennas_position: list[float] | None = None
     timestamp: datetime | None = None
     passive_joints: list[float] | None = None
+    doa: DoAInfo | None = None

reachy_mini/daemon/app/routers/apps.py

@@ -6,6 +6,7 @@ from fastapi import (
     HTTPException,
     WebSocket,
 )
+from pydantic import BaseModel
 
 from reachy_mini.apps import AppInfo, SourceKind
 from reachy_mini.apps.manager import AppManager, AppStatus
@@ -112,3 +113,58 @@ async def current_app_status(
 ) -> AppStatus | None:
     """Get the status of the currently running app, if any."""
     return await app_manager.current_app_status()
+
+
+class PrivateSpaceInstallRequest(BaseModel):
+    """Request model for installing a private HuggingFace space."""
+
+    space_id: str
+
+
+@router.post("/install-private-space")
+async def install_private_space(
+    request: PrivateSpaceInstallRequest,
+    app_manager: "AppManager" = Depends(get_app_manager),
+) -> dict[str, str]:
+    """Install a private HuggingFace space.
+
+    Only available on wireless version.
+    Requires HF token to be stored via /api/hf-auth/save-token first.
+    """
+    if not app_manager.wireless_version:
+        raise HTTPException(
+            status_code=403,
+            detail="Private space installation only available on wireless version",
+        )
+
+    from reachy_mini.apps.sources import hf_auth
+
+    # Check if token is available
+    token = hf_auth.get_hf_token()
+    if not token:
+        raise HTTPException(
+            status_code=401,
+            detail="No HuggingFace token found. Please authenticate first.",
+        )
+
+    # Create AppInfo for the private space
+    space_name = request.space_id.split("/")[-1]
+    app_info = AppInfo(
+        name=space_name,
+        description=f"Private space: {request.space_id}",
+        url=f"https://huggingface.co/spaces/{request.space_id}",
+        source_kind=SourceKind.HF_SPACE,
+        extra={
+            "id": request.space_id,
+            "private": True,
+            "cardData": {
+                "title": space_name,
+                "short_description": f"Private space: {request.space_id}",
+            },
+        },
+    )
+
+    job_id = bg_job_register.run_command(
+        "install", app_manager.install_new_app, app_info
+    )
+    return {"job_id": job_id}

reachy_mini/daemon/app/routers/cache.py

@@ -0,0 +1,58 @@
+"""Cache management router for Reachy Mini Daemon API."""
+
+import logging
+import shutil
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException
+
+router = APIRouter(prefix="/cache")
+logger = logging.getLogger(__name__)
+
+
+@router.post("/clear-hf")
+def clear_huggingface_cache() -> dict[str, str]:
+    """Clear HuggingFace cache directory."""
+    try:
+        cache_path = Path("/home/pollen/.cache/huggingface")
+
+        if cache_path.exists():
+            shutil.rmtree(cache_path)
+            logger.info(f"Cleared HuggingFace cache at {cache_path}")
+            return {"status": "success", "message": "HuggingFace cache cleared"}
+        else:
+            logger.info(f"HuggingFace cache directory does not exist: {cache_path}")
+            return {"status": "success", "message": "Cache directory already empty"}
+
+    except Exception as e:
+        logger.error(f"Failed to clear HuggingFace cache: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to clear cache: {str(e)}")
+
+
+@router.post("/reset-apps")
+def reset_apps() -> dict[str, str]:
+    """Remove applications virtual environment directory."""
+    try:
+        venv_path = Path("/venvs/apps_venv/")
+
+        if venv_path.exists():
+            shutil.rmtree(venv_path)
+            logger.info(f"Removed applications virtual environment at {venv_path}")
+            return {
+                "status": "success",
+                "message": "Applications virtual environment removed",
+            }
+        else:
+            logger.info(
+                f"Applications virtual environment directory does not exist: {venv_path}"
+            )
+            return {
+                "status": "success",
+                "message": "Virtual environment directory already empty",
+            }
+
+    except Exception as e:
+        logger.error(f"Failed to clear applications virtual environment: {e}")
+        raise HTTPException(
+            status_code=500, detail=f"Failed to clear virtual environment: {str(e)}"
+        )

reachy_mini/daemon/app/routers/hf_auth.py

@@ -0,0 +1,57 @@
+"""HuggingFace authentication API routes."""
+
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from reachy_mini.apps.sources import hf_auth
+
+router = APIRouter(prefix="/hf-auth")
+
+
+class TokenRequest(BaseModel):
+    """Request model for saving a HuggingFace token."""
+
+    token: str
+
+
+class TokenResponse(BaseModel):
+    """Response model for token operations."""
+
+    status: str
+    username: str | None = None
+    message: str | None = None
+
+
+@router.post("/save-token")
+async def save_token(request: TokenRequest) -> TokenResponse:
+    """Save HuggingFace token after validation."""
+    result = hf_auth.save_hf_token(request.token)
+
+    if result["status"] == "error":
+        raise HTTPException(
+            status_code=400, detail=result.get("message", "Invalid token")
+        )
+
+    return TokenResponse(
+        status="success",
+        username=result.get("username"),
+    )
+
+
+@router.get("/status")
+async def get_auth_status() -> dict[str, Any]:
+    """Check if user is authenticated with HuggingFace."""
+    return hf_auth.check_token_status()
+
+
+@router.delete("/token")
+async def delete_token() -> dict[str, str]:
+    """Delete stored HuggingFace token."""
+    success = hf_auth.delete_hf_token()
+
+    if not success:
+        raise HTTPException(status_code=500, detail="Failed to delete token")
+
+    return {"status": "success"}

reachy_mini/daemon/app/routers/logs.py

@@ -0,0 +1,124 @@
+"""Logs router for Reachy Mini Daemon API.
+
+This module provides a WebSocket endpoint to stream journalctl logs for the daemon service.
+"""
+
+import asyncio
+import logging
+
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect
+
+router = APIRouter(prefix="/logs")
+logger = logging.getLogger(__name__)
+
+
+@router.websocket("/ws/daemon")
+async def websocket_daemon_logs(websocket: WebSocket) -> None:
+    """WebSocket endpoint to stream journalctl logs for reachy-mini-daemon service in real time."""
+    await websocket.accept()
+
+    process = None
+    stderr_task = None
+
+    try:
+        # Start journalctl subprocess to stream daemon logs
+        process = await asyncio.create_subprocess_exec(
+            "journalctl",
+            "-u",
+            "reachy-mini-daemon",
+            "-b",  # current boot only
+            "-f",  # follow mode (tail)
+            "-n",
+            "100",  # start with last 100 lines
+            "--output",
+            "short-iso",  # ISO timestamp format
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+
+        logger.info("journalctl process started")
+
+        # Task to read and log stderr
+        async def log_stderr() -> None:
+            try:
+                while True:
+                    err_line = await process.stderr.readline()  # type: ignore
+                    if not err_line:
+                        break
+                    logger.error(f"journalctl stderr: {err_line.decode().strip()}")
+            except Exception as e:
+                logger.error(f"Error reading stderr: {e}")
+
+        stderr_task = asyncio.create_task(log_stderr())
+
+        # Stream lines to WebSocket
+        while True:
+            try:
+                line = await asyncio.wait_for(process.stdout.readline(), timeout=1.0)  # type: ignore
+            except asyncio.TimeoutError:
+                # No data available, check if process is still running
+                if process.returncode is not None:
+                    logger.error(
+                        f"journalctl process exited with code {process.returncode}"
+                    )
+                    break
+                # Check if WebSocket is still connected
+                try:
+                    await websocket.send_text("")  # Keepalive ping
+                except Exception:
+                    break
+                continue
+
+            if not line:
+                # EOF reached
+                logger.info("journalctl process stdout closed")
+                break
+
+            # Send line to client
+            decoded_line = line.decode().strip()
+            if decoded_line:  # Only send non-empty lines
+                await websocket.send_text(decoded_line)
+
+    except WebSocketDisconnect:
+        logger.info("WebSocket disconnected")
+    except FileNotFoundError:
+        # journalctl not available
+        error_msg = (
+            "ERROR: journalctl command not found. This feature requires systemd."
+        )
+        logger.error(error_msg)
+        try:
+            await websocket.send_text(error_msg)
+        except Exception:
+            pass
+    except Exception as e:
+        error_msg = f"ERROR: Failed to stream logs: {str(e)}"
+        logger.error(error_msg)
+        try:
+            await websocket.send_text(error_msg)
+        except Exception:
+            pass
+    finally:
+        # Cancel stderr task if running
+        if stderr_task and not stderr_task.done():
+            stderr_task.cancel()
+            try:
+                await stderr_task
+            except asyncio.CancelledError:
+                pass
+
+        # Terminate journalctl process if still running
+        if process and process.returncode is None:
+            try:
+                process.terminate()
+                await asyncio.wait_for(process.wait(), timeout=2.0)
+            except asyncio.TimeoutError:
+                process.kill()
+            except Exception as e:
+                logger.error(f"Error terminating journalctl process: {e}")
+
+        # Close WebSocket connection
+        try:
+            await websocket.close()
+        except Exception:
+            pass