reachy-mini 1.2.5rc1__py3-none-any.whl

reachy_mini/apps/manager.py

@@ -0,0 +1,312 @@
+"""App management for Reachy Mini."""
+
+import asyncio
+import logging
+import os
+import signal
+from dataclasses import dataclass
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Optional
+
+import numpy as np
+import psutil
+from pydantic import BaseModel
+
+from . import AppInfo, SourceKind
+from .sources import hf_space, local_common_venv
+
+if TYPE_CHECKING:
+    from reachy_mini.daemon.daemon import Daemon
+
+
+class AppState(str, Enum):
+    """Status of a running app."""
+
+    STARTING = "starting"
+    RUNNING = "running"
+    DONE = "done"
+    STOPPING = "stopping"
+    ERROR = "error"
+
+
+class AppStatus(BaseModel):
+    """Status of an app."""
+
+    info: AppInfo
+    state: AppState
+    error: str | None = None
+
+
+@dataclass
+class RunningApp:
+    """Information about a running app."""
+
+    process: asyncio.subprocess.Process
+    monitor_task: asyncio.Task[None]
+    status: AppStatus
+
+
+class AppManager:
+    """Manager for Reachy Mini apps."""
+
+    def __init__(
+        self,
+        wireless_version: bool = False,
+        desktop_app_daemon: bool = False,
+        daemon: Optional["Daemon"] = None,
+    ) -> None:
+        """Initialize the AppManager."""
+        self.current_app = None  # type: RunningApp | None
+        self.logger = logging.getLogger("reachy_mini.apps.manager")
+        self.wireless_version = wireless_version
+        self.desktop_app_daemon = desktop_app_daemon
+        self.running_on_wireless = wireless_version
+        self.daemon = daemon
+
+    async def close(self) -> None:
+        """Clean up the AppManager, stopping any running app."""
+        if self.is_app_running():
+            await self.stop_current_app()
+
+    def _kill_process_tree(self, pid: int) -> None:
+        """Kill a process and all its children recursively."""
+        try:
+            parent = psutil.Process(pid)
+            children = parent.children(recursive=True)
+            for child in children:
+                try:
+                    child.kill()
+                except psutil.NoSuchProcess:
+                    pass
+        except psutil.NoSuchProcess:
+            pass
+
+    # App lifecycle management
+    # Only one app can be started at a time for now
+    def is_app_running(self) -> bool:
+        """Check if an app is currently running or stopping."""
+        return self.current_app is not None and self.current_app.status.state in (
+            AppState.STARTING,
+            AppState.RUNNING,
+            AppState.ERROR,
+            AppState.STOPPING,
+        )
+
+    async def start_app(self, app_name: str, *args: Any, **kwargs: Any) -> AppStatus:
+        """Start the app as a subprocess, raises RuntimeError if an app is already running."""
+        if self.is_app_running():
+            raise RuntimeError("An app is already running")
+
+        # Get module name and Python path for subprocess execution
+        module_name = local_common_venv.get_app_module(
+            app_name, self.wireless_version, self.desktop_app_daemon
+        )
+        python_path = local_common_venv.get_app_python(
+            app_name, self.wireless_version, self.desktop_app_daemon
+        )
+
+        # Launch app as subprocess with unbuffered output
+        self.logger.getChild("runner").info(f"Starting app {app_name}")
+        process = await asyncio.create_subprocess_exec(
+            str(python_path),
+            "-u",  # Unbuffered stdout/stderr for real-time logging
+            "-m",
+            module_name,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+
+        # Create status and monitor task
+        status = AppStatus(
+            info=AppInfo(name=app_name, source_kind=SourceKind.INSTALLED),
+            state=AppState.STARTING,
+            error=None,
+        )
+
+        async def monitor_process() -> None:
+            """Monitor the subprocess and update status."""
+            assert self.current_app is not None
+            assert process.stdout is not None
+            assert process.stderr is not None
+
+            # Update to RUNNING once process starts
+            self.current_app.status.state = AppState.RUNNING
+            self.logger.getChild("runner").info(f"App {app_name} is running")
+
+            # Stream stdout
+            async def log_stdout() -> None:
+                assert process.stdout is not None
+                async for line in process.stdout:
+                    self.logger.getChild("runner").info(line.decode().rstrip())
+
+            # Stream stderr (many libraries write INFO/WARNING to stderr)
+            stderr_lines: list[str] = []
+
+            async def log_stderr() -> None:
+                assert process.stderr is not None
+                async for line in process.stderr:
+                    decoded = line.decode().rstrip()
+                    stderr_lines.append(decoded)
+                    self.logger.getChild("runner").info(decoded)
+
+            # Run both streams concurrently
+            await asyncio.gather(log_stdout(), log_stderr())
+
+            # Wait for process to complete
+            returncode = await process.wait()
+
+            # Update status based on exit code
+            if self.current_app is not None:
+                if returncode == 0:
+                    self.current_app.status.state = AppState.DONE
+                    self.logger.getChild("runner").info(f"App {app_name} finished")
+                else:
+                    self.current_app.status.state = AppState.ERROR
+                    error_msg = "\n".join(stderr_lines[-10:])  # Last 10 lines
+                    self.current_app.status.error = (
+                        f"Process exited with code {returncode}\n{error_msg}"
+                    )
+                    self.logger.getChild("runner").error(
+                        f"App {app_name} exited with code {returncode}"
+                    )
+
+        monitor_task = asyncio.create_task(monitor_process())
+
+        self.current_app = RunningApp(
+            process=process,
+            monitor_task=monitor_task,
+            status=status,
+        )
+
+        return self.current_app.status
+
+    async def stop_current_app(self, timeout: float | None = 20.0) -> None:
+        """Stop the current app subprocess."""
+        if self.current_app is None or self.current_app.status.state in (
+            AppState.DONE,
+            AppState.STOPPING,
+        ):
+            raise RuntimeError("No app is currently running")
+
+        assert self.current_app is not None
+
+        self.current_app.status.state = AppState.STOPPING
+        self.logger.getChild("runner").info(
+            f"Stopping app {self.current_app.status.info.name}"
+        )
+
+        # Terminate subprocess
+        process = self.current_app.process
+        if process.returncode is None:
+            # Send SIGINT to trigger KeyboardInterrupt (cross-platform, handled by template)
+            try:
+                if os.name == "posix":
+                    # Unix/Linux/Mac: send SIGINT signal
+                    os.kill(process.pid, signal.SIGINT)
+                else:
+                    # Windows: use CTRL_C_EVENT or fallback to terminate
+                    process.terminate()
+
+                # Wait for graceful shutdown
+                await asyncio.wait_for(process.wait(), timeout=timeout)
+                self.logger.getChild("runner").info("App stopped successfully")
+            except asyncio.TimeoutError:
+                # Force kill if timeout expires - also kill child processes
+                self.logger.getChild("runner").warning(
+                    "App did not stop within timeout, forcing termination"
+                )
+                self._kill_process_tree(process.pid)
+                process.kill()
+                await process.wait()
+
+        # Cancel and wait for monitor task
+        if not self.current_app.monitor_task.done():
+            self.current_app.monitor_task.cancel()
+            try:
+                await self.current_app.monitor_task
+            except asyncio.CancelledError:
+                pass
+
+        # Return robot to zero position after app stops
+        if self.daemon is not None and self.daemon.backend is not None:
+            try:
+                from reachy_mini.reachy_mini import INIT_HEAD_POSE
+
+                self.logger.getChild("runner").info("Returning robot to zero position")
+                await self.daemon.backend.goto_target(
+                    head=INIT_HEAD_POSE,
+                    antennas=np.array([0.0, 0.0]),
+                    duration=1.0,
+                )
+            except Exception as e:
+                self.logger.getChild("runner").warning(
+                    f"Could not return to zero position: {e}"
+                )
+
+        self.current_app = None
+
+    async def restart_current_app(self) -> AppStatus:
+        """Restart the current app."""
+        if not self.is_app_running():
+            raise RuntimeError("No app is currently running")
+
+        assert self.current_app is not None
+
+        app_info = self.current_app.status.info
+
+        await self.stop_current_app()
+        await self.start_app(app_info.name)
+
+        return self.current_app.status
+
+    async def current_app_status(self) -> Optional[AppStatus]:
+        """Get the current status of the app."""
+        if self.current_app is not None:
+            return self.current_app.status
+        return None
+
+    # Apps management interface
+    async def list_all_available_apps(self) -> list[AppInfo]:
+        """List available apps (parallel async)."""
+        results = await asyncio.gather(
+            *[self.list_available_apps(kind) for kind in SourceKind]
+        )
+        return sum(results, [])
+
+    async def list_available_apps(self, source: SourceKind) -> list[AppInfo]:
+        """List available apps for given source kind."""
+        if source == SourceKind.HF_SPACE:
+            return await hf_space.list_all_apps()
+        elif source == SourceKind.DASHBOARD_SELECTION:
+            return await hf_space.list_available_apps()
+        elif source == SourceKind.INSTALLED:
+            return await local_common_venv.list_available_apps(
+                wireless_version=self.wireless_version,
+                desktop_app_daemon=self.desktop_app_daemon,
+            )
+        elif source == SourceKind.LOCAL:
+            return []
+        else:
+            raise NotImplementedError(f"Unknown source kind: {source}")
+
+    async def install_new_app(self, app: AppInfo, logger: logging.Logger) -> None:
+        """Install a new app by name."""
+        success = await local_common_venv.install_package(
+            app,
+            logger,
+            wireless_version=self.wireless_version,
+            desktop_app_daemon=self.desktop_app_daemon,
+        )
+        if success != 0:
+            raise RuntimeError(f"Failed to install app '{app.name}'")
+
+    async def remove_app(self, app_name: str, logger: logging.Logger) -> None:
+        """Remove an installed app by name."""
+        success = await local_common_venv.uninstall_package(
+            app_name,
+            logger,
+            wireless_version=self.wireless_version,
+            desktop_app_daemon=self.desktop_app_daemon,
+        )
+        if success != 0:
+            raise RuntimeError(f"Failed to uninstall app '{app_name}'")

reachy_mini/apps/sources/__init__.py

@@ -0,0 +1,4 @@
+"""Specific app sources.
+
+For the moment, only huggingface spaces is implemented.
+"""

reachy_mini/apps/sources/hf_space.py

@@ -0,0 +1,106 @@
+"""Hugging Face Spaces app source."""
+
+import asyncio
+import json
+from typing import Any, Dict
+
+import aiohttp
+
+from .. import AppInfo, SourceKind
+
+# Constants
+AUTHORIZED_APP_LIST_URL = "https://huggingface.co/datasets/pollen-robotics/reachy-mini-official-app-store/raw/main/app-list.json"
+HF_SPACES_API_URL = "https://huggingface.co/api/spaces"
+# TODO look for js apps too (reachy_mini_js_app)
+HF_SPACES_FILTER_URL = "https://huggingface.co/api/spaces?filter=reachy_mini_python_app&sort=likes&direction=-1&limit=50&full=true"
+REQUEST_TIMEOUT = aiohttp.ClientTimeout(total=30)
+
+
+async def _fetch_space_data(
+    session: aiohttp.ClientSession, space_id: str
+) -> Dict[str, Any] | None:
+    """Fetch data for a single space from Hugging Face API."""
+    url = f"{HF_SPACES_API_URL}/{space_id}"
+    try:
+        async with session.get(url, timeout=REQUEST_TIMEOUT) as response:
+            if response.status == 200:
+                data: Dict[str, Any] = await response.json()
+                return data
+            else:
+                return None
+    except (aiohttp.ClientError, asyncio.TimeoutError):
+        return None
+
+
+async def list_available_apps() -> list[AppInfo]:
+    """List apps available on Hugging Face Spaces."""
+    async with aiohttp.ClientSession(timeout=REQUEST_TIMEOUT) as session:
+        # Fetch the list of authorized app IDs
+        try:
+            async with session.get(AUTHORIZED_APP_LIST_URL) as response:
+                response.raise_for_status()
+                text = await response.text()
+                authorized_ids = json.loads(text)
+        except (aiohttp.ClientError, json.JSONDecodeError):
+            return []
+
+        if not isinstance(authorized_ids, list):
+            return []
+
+        # Filter to only string elements
+        authorized_ids = [
+            space_id for space_id in authorized_ids if isinstance(space_id, str)
+        ]
+
+        # Fetch data for each space in parallel
+        tasks = [_fetch_space_data(session, space_id) for space_id in authorized_ids]
+        spaces_data = await asyncio.gather(*tasks)
+
+        # Build AppInfo list from fetched data
+        apps = []
+        for item in spaces_data:
+            if item is None or "id" not in item:
+                continue
+
+            apps.append(
+                AppInfo(
+                    name=item["id"].split("/")[-1],
+                    description=item.get("cardData", {}).get("short_description", ""),
+                    url=f"https://huggingface.co/spaces/{item['id']}",
+                    source_kind=SourceKind.HF_SPACE,
+                    extra=item,
+                )
+            )
+
+        return apps
+
+
+async def list_all_apps() -> list[AppInfo]:
+    """List all apps available on Hugging Face Spaces (including unofficial ones)."""
+    async with aiohttp.ClientSession(timeout=REQUEST_TIMEOUT) as session:
+        try:
+            async with session.get(HF_SPACES_FILTER_URL) as response:
+                response.raise_for_status()
+                data: list[Dict[str, Any]] = await response.json()
+        except (aiohttp.ClientError, json.JSONDecodeError, asyncio.TimeoutError):
+            return []
+
+        if not isinstance(data, list):
+            return []
+
+        apps = []
+        for item in data:
+            if item is None or "id" not in item:
+                continue
+
+            apps.append(
+                AppInfo(
+                    name=item["id"].split("/")[-1],
+                    description=item.get("cardData", {}).get("short_description", ""),
+                    url=f"https://huggingface.co/spaces/{item['id']}",
+                    source_kind=SourceKind.HF_SPACE,
+                    extra=item,
+                )
+            )
+
+        return apps