reachy_mini/pr_1321/en/API/daemon.md

Daemon

Core Daemon Classes[[reachy_mini.daemon.daemon.Daemon]]

reachy_mini.daemon.daemon.Daemon[[reachy_mini.daemon.daemon.Daemon]]

reachy_mini.daemon.daemon.Daemon(log_level: str = 'INFO', robot_name: str = 'reachy_mini', wireless_version: bool = False, desktop_app_daemon: bool = False, no_media: bool = False, sim_mode: SimulationMode = <SimulationMode.NONE: 'none'>)

Source

Daemon for simulated or real Reachy Mini robot.

Runs the server with the appropriate backend (Mujoco for simulation or RobotBackend for real hardware).

acquire_media[[reachy_mini.daemon.daemon.Daemon.acquire_media]]

acquire_media()

Source

Re-acquire camera and audio hardware after a release.

Restarts the GstMediaServer pipeline and central signalling relay. Idempotent: no-op if not currently released or no media server.

apply_robot_name[[reachy_mini.daemon.daemon.Daemon.apply_robot_name]]

apply_robot_name(name: str)

Source

Apply a new robot name to the live daemon without a restart.

Refreshes the in-memory name and the daemon status, then nudges the central relay so its next heartbeat advertises the new label. The persistent store (utils/robot_name) is written by the caller (the set_robot_name command handler); this only updates the live/advertised copies. mDNS re-registration is wired separately in the app lifespan, which owns the MdnsServiceRegistration.

Safe to call from the backend's command thread: it only mutates attributes and calls the relay's thread-safe name setter.

release_media[[reachy_mini.daemon.daemon.Daemon.release_media]]

release_media()

Source

Release camera and audio hardware so clients can access them directly.

Stops the GstMediaServer pipeline and central signalling relay. Idempotent: no-op if already released or no media server.

restart[[reachy_mini.daemon.daemon.Daemon.restart]]

restart(sim: typing.Optional[bool] = None, mockup_sim: typing.Optional[bool] = None, serialport: typing.Optional[str] = None, scene: typing.Optional[str] = None, headless: typing.Optional[bool] = None, use_audio: typing.Optional[bool] = None, wake_up_on_start: typing.Optional[bool] = None, goto_sleep_on_stop: typing.Optional[bool] = None)

Source

Parameters:

sim (bool) : If True, run in simulation mode using Mujoco. Defaults to None (uses the previous value).

mockup_sim (bool) : If True, run in lightweight simulation mode (no MuJoCo). Defaults to None (uses the previous value).

serialport (str) : Serial port for real motors. Defaults to None (uses the previous value).

scene (str) : Name of the scene to load in simulation mode ("empty" or "minimal"). Defaults to None (uses the previous value).

headless (bool) : If True, run Mujoco in headless mode (no GUI). Defaults to None (uses the previous value).

use_audio (bool) : If True, enable audio. Defaults to None (uses the previous value).

wake_up_on_start (bool) : If True, wake up Reachy Mini on start. Defaults to None (don't wake up).

goto_sleep_on_stop (bool) : If True, put Reachy Mini to sleep on stop. Defaults to None (don't go to sleep).

Returns: DaemonState

The current state of the daemon after attempting to restart it.

Restart the Reachy Mini daemon.

start[[reachy_mini.daemon.daemon.Daemon.start]]

start(sim: bool = False, mockup_sim: bool = False, serialport: str = 'auto', scene: str = 'empty', wake_up_on_start: bool = True, check_collision: bool = False, kinematics_engine: str = 'AnalyticalKinematics', headless: bool = False, use_audio: bool = True, hardware_config_filepath: str | None = None, on_wake_up_callback: collections.abc.Callable[[], None] | None = None)

Source

Parameters:

sim (bool) : If True, run in simulation mode using Mujoco. Defaults to False.

mockup_sim (bool) : If True, run in lightweight simulation mode (no MuJoCo). Defaults to False.

serialport (str) : Serial port for real motors. Defaults to "auto", which will try to find the port automatically.

scene (str) : Name of the scene to load in simulation mode ("empty" or "minimal"). Defaults to "empty".

wake_up_on_start (bool) : If True, wake up Reachy Mini on start. Defaults to True.

check_collision (bool) : If True, enable collision checking. Defaults to False.

kinematics_engine (str) : Kinematics engine to use. Defaults to "AnalyticalKinematics".

headless (bool) : If True, run Mujoco in headless mode (no GUI). Defaults to False.

use_audio (bool) : If True, enable audio. Defaults to True.

hardware_config_filepath (str | None) : Path to the hardware configuration YAML file. Defaults to None.

on_wake_up_callback (Callable[[], None] | None) : Fired once each time the robot finishes waking up. Defaults to None.

Returns: DaemonState

The current state of the daemon after attempting to start it.

Start the Reachy Mini daemon.

status[[reachy_mini.daemon.daemon.Daemon.status]]

status()

Source

Get the current status of the Reachy Mini daemon.

stop[[reachy_mini.daemon.daemon.Daemon.stop]]

stop(goto_sleep_on_stop: bool = True)

Source

Parameters:

goto_sleep_on_stop (bool) : If True, put Reachy Mini to sleep on stop. Defaults to True.

Returns: DaemonState

The current state of the daemon after attempting to stop it.

Stop the Reachy Mini daemon.

Note: The relay releases its remote hold on self.robot_app_lock via relay.stop(). A local-app hold is not force-released here because the daemon is going down; the lock object dies with the process. If restart-in-place is ever added, force-release the LOCAL_APP state here before restart.

reachy_mini.io.protocol.DaemonState[[reachy_mini.io.protocol.DaemonState]]

reachy_mini.io.protocol.DaemonState(value, names = None, module = None, qualname = None, type = None, start = 1, boundary = None)

Source

Enum representing the state of the Reachy Mini daemon.

reachy_mini.io.protocol.DaemonStatus[[reachy_mini.io.protocol.DaemonStatus]]

reachy_mini.io.protocol.DaemonStatus(type: typing.Literal['daemon_status'] = 'daemon_status', robot_name: str, state: DaemonState, wireless_version: bool, desktop_app_daemon: bool, simulation_enabled: typing.Optional[bool], mockup_sim_enabled: typing.Optional[bool], no_media: bool = False, media_released: bool = False, camera_specs_name: str = '', backend_status: typing.Union[reachy_mini.io.protocol.RobotBackendStatus, reachy_mini.io.protocol.MujocoBackendStatus, reachy_mini.io.protocol.MockupSimBackendStatus, NoneType], error: typing.Optional[str] = None, wlan_ip: typing.Optional[str] = None, version: typing.Optional[str] = None, hardware_id: typing.Optional[str] = None, face_target: FaceTarget = <factory>)

Source

Status of the Reachy Mini daemon.

Robot App Lock

The robot app lock is the daemon's single source of truth for which managed app currently holds the robot. It serializes the two managed entry points — local Python apps launched by :class:AppManager and remote WebRTC clients routed through the central signaling relay.

It does not gate every code path that can drive the robot: SDK clients talking to the daemon directly over LAN/WebSocket bypass it. The name uses "app" deliberately to reflect that narrower scope.

Concurrency model

Two managed entry points can open a session with the robot:

1. Local path — a Python app launched via POST /api/apps/start. Runs as a subprocess of the daemon, talks to the backend directly.
2. Remote path — a browser client authenticated through the HuggingFace central signaling server, routed to the robot over WebRTC. Handled by CentralSignalingRelay in its own thread.

Without coordination, both paths can grab the robot at the same time and fight over motor commands, camera, and audio. :class:RobotAppLock prevents that with three mutually exclusive states:

• free — no managed app holds the slot.
• local_app(name) — a Python app is running.
• remote_session(name) — a remote WebRTC client is connected.

Acquire rules:

• The local path uses :meth:RobotAppLock.acquire_local_evicting_remote. If a remote session is active, the lock is transitioned atomically to local_app and the relay is asked to send endSession to the remote peer and to local GStreamer so the existing WebRTC connection tears down cleanly. If another Python app already holds the lock, the acquire raises RuntimeError.
• The remote path uses :meth:RobotAppLock.try_acquire_remote. This fails fast (returns False) whenever the lock is not free — incoming remote sessions are refused with {"type": "endSession", "reason": "robot_busy_local_app"}.

Release rules:

• :meth:RobotAppLock.release_local is called from the subprocess monitor's finally block, so clean exits, crashes, SIGKILL, OOM and task cancellation all release the lock.
• :meth:RobotAppLock.release_remote is called from every endSession handler (both directions), from _close_connections on disconnect/reconnect, and from the relay's stop(). All release calls are idempotent — they no-op if the lock is not in the corresponding state.

Cross-thread considerations: the lock state is guarded by a threading.Lock. The eviction callback is registered by the relay and invoked by AppManager from the main asyncio loop, but dispatches the actual session tear-down onto the relay's own event loop via asyncio.run_coroutine_threadsafe. AppManager awaits the tear-down before spawning the Python subprocess, so the remote peer has released its media handles before the local app opens them.

API reference[[reachy_mini.daemon.robot_app_lock.RobotAppLock]]

reachy_mini.daemon.robot_app_lock.RobotAppLock[[reachy_mini.daemon.robot_app_lock.RobotAppLock]]

reachy_mini.daemon.robot_app_lock.RobotAppLock()

Source

Thread-safe lock coordinating local app and remote session access to the robot.

acquire_local_evicting_remote[[reachy_mini.daemon.robot_app_lock.RobotAppLock.acquire_local_evicting_remote]]

acquire_local_evicting_remote(app_name: str)

Source

Raises: RuntimeError

• RuntimeError -- If another local app already holds the lock. Caller should not start a second Python app concurrently.

Acquire the lock for a local Python app, evicting any remote session.

If a remote session is held, it is transitioned to local_app atomically and the registered eviction handler is invoked (after releasing the mutex) so the relay can notify the remote peer.

acquire_local_keeping_remote[[reachy_mini.daemon.robot_app_lock.RobotAppLock.acquire_local_keeping_remote]]

acquire_local_keeping_remote(app_name: str)

Source

Raises: `RuntimeError``

• RuntimeError -- If another local app already holds the lock.

Acquire the local-app slot without evicting a remote session.

Used when the local app is started by the connected remote client (e.g. the mobile app launching a conversation it will then drive): the client is a controller, not a competitor for the robot, so its WebRTC session must stay up. Transitions remote_session/``free->local_app` and does not invoke the eviction handler.

release_local[[reachy_mini.daemon.robot_app_lock.RobotAppLock.release_local]]

release_local(app_name: Optional[str] = None)

Source

Parameters:

app_name : Optional name of the app expected to hold the lock. If provided and the current holder differs, logs a warning but still releases — this protects against stale releases after a rapid stop/start cycle.

Release the lock held by a local app.

Idempotent: if the lock is free or held by a remote session, this is a no-op (with a warning). Safe to call from monitor_process regardless of how the subprocess exited.

release_remote[[reachy_mini.daemon.robot_app_lock.RobotAppLock.release_remote]]

release_remote(expect_handoff: bool = False)

Source

Parameters:

expect_handoff : True when the client ended its session on purpose (a relayed endSession) rather than vanishing. The two read very differently downstream: a deliberate release usually means another session is on its way in - the mobile app dropping its own session so an app's iframe can take the slot - whereas a drop means nobody is coming back. Passed to the FREE handler so the daemon can wait longer before reclaiming the robot.

Release a remote-session hold. Idempotent.

set_on_became_free_handler[[reachy_mini.daemon.robot_app_lock.RobotAppLock.set_on_became_free_handler]]

set_on_became_free_handler(handler: Optional[Callable[[bool], None]])

Source

Register (or clear) the callback fired when the slot becomes FREE.

Fired once per FREE transition, from either release_local or release_remote, after the internal mutex is released. The handler receives expect_handoff: True when the previous owner released the slot on purpose for someone else to pick it up (see release_remote). It must return promptly and must not call back into this lock. Pass None to clear.

set_on_remote_acquired_handler[[reachy_mini.daemon.robot_app_lock.RobotAppLock.set_on_remote_acquired_handler]]

set_on_remote_acquired_handler(handler: Optional[Callable[[], None]])

Source

Register (or clear) the callback fired when a remote session acquires the slot.

Fired from try_acquire_remote after a successful acquisition, after the internal mutex is released. It must return promptly and must not call back into this lock. Pass None to clear.

set_remote_eviction_handler[[reachy_mini.daemon.robot_app_lock.RobotAppLock.set_remote_eviction_handler]]

set_remote_eviction_handler(handler: Optional[Callable[[], Awaitable[None]]])

Source

Register (or clear) the coroutine invoked when a local acquire evicts a remote session.

The handler must be safe to call from the caller of acquire_local_evicting_remote — typically the main asyncio loop. Pass None to clear.

status[[reachy_mini.daemon.robot_app_lock.RobotAppLock.status]]

status()

Source

Return a snapshot of the current lock state.

try_acquire_local[[reachy_mini.daemon.robot_app_lock.RobotAppLock.try_acquire_local]]

try_acquire_local(app_name: str)

Source

Returns:

True if the lock was acquired. False if another local app or a remote session already holds it. Unlike acquire_local_evicting_remote, this never evicts a remote session.

Acquire the lock for a local Python app only if the slot is free.

try_acquire_remote[[reachy_mini.daemon.robot_app_lock.RobotAppLock.try_acquire_remote]]

try_acquire_remote(app_name: str)

Source

Returns:

True if the lock was acquired (state transitioned to remote_session). False if a local app or another remote session is already holding it — caller must refuse the incoming session.

Attempt to acquire the lock for a remote WebRTC session.

reachy_mini.daemon.robot_app_lock.RobotAppLockState[[reachy_mini.daemon.robot_app_lock.RobotAppLockState]]

reachy_mini.daemon.robot_app_lock.RobotAppLockState(value, names = None, module = None, qualname = None, type = None, start = 1, boundary = None)

Source

Lock state enum. Values are stable strings suitable for serialization.

reachy_mini.daemon.robot_app_lock.RobotAppLockStatus[[reachy_mini.daemon.robot_app_lock.RobotAppLockStatus]]

reachy_mini.daemon.robot_app_lock.RobotAppLockStatus(state: RobotAppLockState, holder_name: typing.Optional[str] = None)

Source

Snapshot of the lock state, suitable for JSON serialization.

Returned by RobotAppLock.status and by the GET /api/daemon/robot-app-lock-status endpoint.

Backend Classes

Abstract Backend[[reachy_mini.io.protocol.MotorControlMode]]

reachy_mini.io.protocol.MotorControlMode[[reachy_mini.io.protocol.MotorControlMode]]

reachy_mini.io.protocol.MotorControlMode(value, names = None, module = None, qualname = None, type = None, start = 1, boundary = None)

Source

Enum for motor control modes.

Robot Backend[[reachy_mini.daemon.backend.robot.RobotBackend]]

reachy_mini.daemon.backend.robot.RobotBackend[[reachy_mini.daemon.backend.robot.RobotBackend]]

reachy_mini.daemon.backend.robot.RobotBackend(serialport: str, log_level: str = 'INFO', check_collision: bool = False, kinematics_engine: str = 'AnalyticalKinematics', hardware_error_check_frequency: float = 1.0, use_audio: bool = True, wireless_version: bool = False, hardware_config_filepath: str | None = None)

Source

Real robot backend for Reachy Mini.

close[[reachy_mini.daemon.backend.robot.RobotBackend.close]]

close()

Source

Close the motor controller connection and release resources.

compensate_head_gravity[[reachy_mini.daemon.backend.robot.RobotBackend.compensate_head_gravity]]

compensate_head_gravity()

Source

Calculate the currents necessary to compensate for gravity.

disable_motors[[reachy_mini.daemon.backend.robot.RobotBackend.disable_motors]]

disable_motors()

Source

Disable the motors by turning the torque off.

enable_motors[[reachy_mini.daemon.backend.robot.RobotBackend.enable_motors]]

enable_motors()

Source

Enable motor torque; pin all targets to present pose first to avoid a snap.

get_all_joint_positions[[reachy_mini.daemon.backend.robot.RobotBackend.get_all_joint_positions]]

get_all_joint_positions()

Source

Returns: tuple

A tuple containing two lists - the first list is for the head joint positions, and the second list is for the antenna joint positions.

Get the current joint positions of the robot.

get_imu_data[[reachy_mini.daemon.backend.robot.RobotBackend.get_imu_data]]

get_imu_data()

Source

Returns:

An ImuDataMsg, or None if the IMU is missing or the cache is older than IMU_CACHE_FRESH_S.

Return the latest IMU reading cached by the control loop.

get_present_antenna_joint_positions[[reachy_mini.daemon.backend.robot.RobotBackend.get_present_antenna_joint_positions]]

get_present_antenna_joint_positions()

Source

Returns: list

A list of joint positions for the antennas.

Get the current joint positions of the antennas.

get_present_head_joint_positions[[reachy_mini.daemon.backend.robot.RobotBackend.get_present_head_joint_positions]]

get_present_head_joint_positions()

Source

Returns: list

A list of joint positions for the head, including the body rotation.

Get the current joint positions of the head.

get_status[[reachy_mini.daemon.backend.robot.RobotBackend.get_status]]

get_status()

Source

Get the current status of the robot backend.

read_hardware_errors[[reachy_mini.daemon.backend.robot.RobotBackend.read_hardware_errors]]

read_hardware_errors()

Source

Read hardware errors from the motor controller.

run[[reachy_mini.daemon.backend.robot.RobotBackend.run]]

run()

Source

Run the control loop for the robot backend.

This method continuously updates the motor controller at a specified frequency. It reads the joint positions, updates the motor controller, and publishes the joint positions. It also handles errors and retries if the motor controller is not responding.

set_antennas_operation_mode[[reachy_mini.daemon.backend.robot.RobotBackend.set_antennas_operation_mode]]

set_antennas_operation_mode(mode: int)

Source

Parameters:

mode (int) : The operation mode for the antennas motors (0: torque control, 3: position control, 5: current-based position control).

mode (int) : The operation mode for the antennas motors. This could be a specific mode like position control, velocity control, or torque control.

Change the operation mode of the antennas motors.

Important: This method does not work well with the current feetech motors, as they do not support torque control. So the method disables the antennas when in torque control mode.

set_head_operation_mode[[reachy_mini.daemon.backend.robot.RobotBackend.set_head_operation_mode]]

set_head_operation_mode(mode: int)

Source

Parameters:

mode (int) : The operation mode for the head motors.

mode (int) : The operation mode for the head motors. This could be a specific mode like position control, velocity control, or torque control.

Change the operation mode of the head motors.

The operation modes can be: 0: torque control 3: position control 5: current-based position control.

Important: This method does not work well with the current feetech motors (body rotation), as they do not support torque control. So the method disables the antennas when in torque control mode. The dynamixel motors used for the head do support torque control, so this method works as expected.

set_motor_torque_ids[[reachy_mini.daemon.backend.robot.RobotBackend.set_motor_torque_ids]]

set_motor_torque_ids(ids: list, on: bool)

Source

Parameters:

ids (list[int]) : List of motor IDs to set the torque state for.

on (bool) : True to enable torque, False to disable.

Set the torque state for specific motor names.

reachy_mini.io.protocol.RobotBackendStatus[[reachy_mini.io.protocol.RobotBackendStatus]]

reachy_mini.io.protocol.RobotBackendStatus(ready: bool, motor_control_mode: MotorControlMode, last_alive: float | None, control_loop_stats: dict, error: str | None = None)

Source

Status of the Robot Backend.

MuJoCo Backend[[reachy_mini.daemon.backend.mujoco.MujocoBackend]]

reachy_mini.daemon.backend.mujoco.MujocoBackend[[reachy_mini.daemon.backend.mujoco.MujocoBackend]]

reachy_mini.daemon.backend.mujoco.MujocoBackend(scene: str = 'empty', check_collision: bool = False, kinematics_engine: str = 'AnalyticalKinematics', headless: bool = False, use_audio: bool = False)

Source

Simulated Reachy Mini using MuJoCo.

get_mj_present_head_pose[[reachy_mini.daemon.backend.mujoco.MujocoBackend.get_mj_present_head_pose]]

get_mj_present_head_pose()

Source

Returns: np.ndarray

The current head pose as a 4x4 transformation matrix.

Get the current head pose from the Mujoco simulation.

get_present_antenna_joint_positions[[reachy_mini.daemon.backend.mujoco.MujocoBackend.get_present_antenna_joint_positions]]

get_present_antenna_joint_positions()

Source

Get the current joint positions of the antennas.

get_present_head_joint_positions[[reachy_mini.daemon.backend.mujoco.MujocoBackend.get_present_head_joint_positions]]

get_present_head_joint_positions()

Source

Get the current joint positions of the head.

get_status[[reachy_mini.daemon.backend.mujoco.MujocoBackend.get_status]]

get_status()

Source

Returns: dict

An empty dictionary as the Mujoco backend does not have a specific status to report.

Get the status of the Mujoco backend.

rendering_loop[[reachy_mini.daemon.backend.mujoco.MujocoBackend.rendering_loop]]

rendering_loop(camera_name: str, port: int)

Source

Offline Rendering loop for the Mujoco simulation.

Capture the image from the virtual camera_name and send it over UDP to the port or over WebSocket to the ws_uri.

run[[reachy_mini.daemon.backend.mujoco.MujocoBackend.run]]

run()

Source

Run the Mujoco simulation with a viewer.

This method initializes the viewer and enters the main simulation loop. It updates the joint positions at a rate and publishes the joint positions.

set_motor_torque_ids[[reachy_mini.daemon.backend.mujoco.MujocoBackend.set_motor_torque_ids]]

set_motor_torque_ids(ids: list, on: bool)

Source

Set the motor torque state for specific motor names.

reachy_mini.io.protocol.MujocoBackendStatus[[reachy_mini.io.protocol.MujocoBackendStatus]]

reachy_mini.io.protocol.MujocoBackendStatus(motor_control_mode: MotorControlMode, error: str | None = None)

Source

Status of the Mujoco backend.

Mockup Simulation Backend[[reachy_mini.daemon.backend.mockup_sim.MockupSimBackend]]

reachy_mini.daemon.backend.mockup_sim.MockupSimBackend[[reachy_mini.daemon.backend.mockup_sim.MockupSimBackend]]

reachy_mini.daemon.backend.mockup_sim.MockupSimBackend(check_collision: bool = False, kinematics_engine: str = 'AnalyticalKinematics', use_audio: bool = True)

Source

Lightweight simulated Reachy Mini without MuJoCo.

This backend provides a simple simulation where target positions are applied immediately without physics simulation.

Apps access webcam/microphone directly (not via UDP streaming).

get_present_antenna_joint_positions[[reachy_mini.daemon.backend.mockup_sim.MockupSimBackend.get_present_antenna_joint_positions]]

get_present_antenna_joint_positions()

Source

Get the current joint positions of the antennas.

get_present_head_joint_positions[[reachy_mini.daemon.backend.mockup_sim.MockupSimBackend.get_present_head_joint_positions]]

get_present_head_joint_positions()

Source

Get the current joint positions of the head.

get_status[[reachy_mini.daemon.backend.mockup_sim.MockupSimBackend.get_status]]

get_status()

Source

Get the status of the backend.

run[[reachy_mini.daemon.backend.mockup_sim.MockupSimBackend.run]]

run()

Source

Run the simulation loop.

In mockup-sim mode, target positions are applied immediately.

set_motor_torque_ids[[reachy_mini.daemon.backend.mockup_sim.MockupSimBackend.set_motor_torque_ids]]

set_motor_torque_ids(ids: list, on: bool)

Source

Set the motor torque state for specific motor names.

No-op in mockup-sim mode.

reachy_mini.io.protocol.MockupSimBackendStatus[[reachy_mini.io.protocol.MockupSimBackendStatus]]

reachy_mini.io.protocol.MockupSimBackendStatus(motor_control_mode: MotorControlMode, error: str | None = None)

Source

Status of the MockupSim backend.

Daemon Utilities[[reachy_mini.daemon.utils.find_serial_port]]

reachy_mini.daemon.utils.find_serial_port[[reachy_mini.daemon.utils.find_serial_port]]

reachy_mini.daemon.utils.find_serial_port(wireless_version: bool = False, vid: str = '1a86', pid: str = '55d3', pi_uart: str = '/dev/ttyAMA3')

Source

Parameters:

wireless_version (bool) : Whether to look for the wireless version using the Raspberry Pi UART.

vid (str) : Vendor ID of the device. (eg. "1a86").

pid (str) : Product ID of the device. (eg. "55d3").

pi_uart (str) : Path to the Raspberry Pi UART device. (eg. "/dev/ttyAMA3").

Find the serial port for Reachy Mini based on VID and PID or the Raspberry Pi UART for the wireless version.

reachy_mini.daemon.utils.get_ip_address[[reachy_mini.daemon.utils.get_ip_address]]

reachy_mini.daemon.utils.get_ip_address(ifname: str = 'wlan0')

Source

Get the IP address of a specific network interface (Linux and Windows).

App

Models[[reachy_mini.daemon.app.models.Matrix4x4Pose]]

reachy_mini.daemon.app.models.Matrix4x4Pose[[reachy_mini.daemon.app.models.Matrix4x4Pose]]

reachy_mini.daemon.app.models.Matrix4x4Pose(m: tuple)

Source

Represent a 3D pose by its 4x4 transformation matrix (translation is expressed in meters).

from_pose_array[[reachy_mini.daemon.app.models.Matrix4x4Pose.from_pose_array]]

from_pose_array(arr: ndarray)

Source

Create a Matrix4x4 pose representation from a 4x4 pose array.

to_pose_array[[reachy_mini.daemon.app.models.Matrix4x4Pose.to_pose_array]]

to_pose_array()

Source

Convert the Matrix4x4Pose to a 4x4 numpy array.

reachy_mini.daemon.app.models.XYZRPYPose[[reachy_mini.daemon.app.models.XYZRPYPose]]

reachy_mini.daemon.app.models.XYZRPYPose(x: float = 0.0, y: float = 0.0, z: float = 0.0, roll: float = 0.0, pitch: float = 0.0, yaw: float = 0.0)

Source

Represent a 3D pose using position (x, y, z) in meters and orientation (roll, pitch, yaw) angles in radians.

from_pose_array[[reachy_mini.daemon.app.models.XYZRPYPose.from_pose_array]]

from_pose_array(arr: ndarray)

Source

Create an XYZRPYPose representation from a 4x4 pose array.

to_pose_array[[reachy_mini.daemon.app.models.XYZRPYPose.to_pose_array]]

to_pose_array()

Source

Convert the XYZRPYPose to a 4x4 numpy array.

reachy_mini.daemon.app.models.FullBodyTarget[[reachy_mini.daemon.app.models.FullBodyTarget]]

reachy_mini.daemon.app.models.FullBodyTarget(target_head_pose: reachy_mini.daemon.app.models.XYZRPYPose | reachy_mini.daemon.app.models.Matrix4x4Pose | None = None, target_antennas: tuple[float, float] | None = None, target_body_yaw: float | None = None, timestamp: datetime.datetime | None = None)

Source

Represent the full body including the head pose and the joints for antennas.

reachy_mini.io.protocol.DoaSnapshot[[reachy_mini.io.protocol.DoaSnapshot]]

reachy_mini.io.protocol.DoaSnapshot(angle: float, speech_detected: bool)

Source

Sound Direction of Arrival reading (ReSpeaker mic array).

angle is in radians: 0 = left, π/2 = front, π = right.

reachy_mini.daemon.app.models.FullState[[reachy_mini.daemon.app.models.FullState]]

reachy_mini.daemon.app.models.FullState(control_mode: reachy_mini.io.protocol.MotorControlMode | None = None, head_pose: reachy_mini.daemon.app.models.XYZRPYPose | reachy_mini.daemon.app.models.Matrix4x4Pose | None = None, head_joints: list[float] | None = None, body_yaw: float | None = None, antennas_position: list[float] | None = None, timestamp: datetime.datetime | None = None, passive_joints: list[float] | None = None, doa: reachy_mini.io.protocol.DoaSnapshot | None = None)

Source

Represent the full state of the robot including all joint positions and poses.

Dependencies[[reachy_mini.daemon.app.dependencies.get_daemon]]

reachy_mini.daemon.app.dependencies.get_daemon[[reachy_mini.daemon.app.dependencies.get_daemon]]

reachy_mini.daemon.app.dependencies.get_daemon(request: Request)

Source

Get the daemon as request dependency.

reachy_mini.daemon.app.dependencies.get_backend[[reachy_mini.daemon.app.dependencies.get_backend]]

reachy_mini.daemon.app.dependencies.get_backend(request: Request)

Source

Get the backend as request dependency.

reachy_mini.daemon.app.dependencies.get_app_manager[[reachy_mini.daemon.app.dependencies.get_app_manager]]

reachy_mini.daemon.app.dependencies.get_app_manager(request: Request)

Source

Get the app manager as request dependency.

reachy_mini.daemon.app.dependencies.ws_get_backend[[reachy_mini.daemon.app.dependencies.ws_get_backend]]

reachy_mini.daemon.app.dependencies.ws_get_backend(websocket: WebSocket)

Source

Get the backend as websocket dependency.

Jobs[[reachy_mini.daemon.app.bg_job_register.JobStatus]]

reachy_mini.daemon.app.bg_job_register.JobStatus[[reachy_mini.daemon.app.bg_job_register.JobStatus]]

reachy_mini.daemon.app.bg_job_register.JobStatus(value, names = None, module = None, qualname = None, type = None, start = 1, boundary = None)

Source

Enum for job status.

reachy_mini.daemon.app.bg_job_register.JobInfo[[reachy_mini.daemon.app.bg_job_register.JobInfo]]

reachy_mini.daemon.app.bg_job_register.JobInfo(command: str, status: JobStatus, logs: list)

Source

Pydantic model for install job status.

reachy_mini.daemon.app.bg_job_register.JobHandler[[reachy_mini.daemon.app.bg_job_register.JobHandler]]

reachy_mini.daemon.app.bg_job_register.JobHandler(uuid: str, info: JobInfo, new_log_evt: dict)

Source

Handler for background jobs.

reachy_mini.daemon.app.bg_job_register.run_command[[reachy_mini.daemon.app.bg_job_register.run_command]]

reachy_mini.daemon.app.bg_job_register.run_command(command: str, coro_func: typing.Callable[..., typing.Awaitable[NoneType]], *args: Any)

Source

Start a background job, with a custom logger and return its job_id.

reachy_mini.daemon.app.bg_job_register.get_info[[reachy_mini.daemon.app.bg_job_register.get_info]]

reachy_mini.daemon.app.bg_job_register.get_info(job_id: str)

Source

Get the info of a job by its ID.

reachy_mini.daemon.app.bg_job_register.ws_poll_info[[reachy_mini.daemon.app.bg_job_register.ws_poll_info]]

reachy_mini.daemon.app.bg_job_register.ws_poll_info(websocket: WebSocket, job_uuid: str)

Source

WebSocket endpoint to stream job logs in real time.

Main Application[[reachy_mini.daemon.app.main.Args]]

reachy_mini.daemon.app.main.Args[[reachy_mini.daemon.app.main.Args]]

reachy_mini.daemon.app.main.Args(log_level: str = 'INFO', log_file: str | None = None, wireless_version: bool = False, desktop_app_daemon: bool = False, serialport: str = 'auto', hardware_config_filepath: str | None = None, sim: bool = False, mockup_sim: bool = False, scene: str = 'empty', headless: bool = False, no_media: bool = False, kinematics_engine: str = 'AnalyticalKinematics', check_collision: bool = False, autostart: bool = True, timeout_health_check: float | None = None, wake_up_on_start: bool = True, goto_sleep_on_stop: bool = True, preload_datasets: bool = False, dataset_update_interval_hours: float = 24.0, robot_name: str = 'reachy_mini', fastapi_host: str | None = None, fastapi_port: int = 8000)

Source

Arguments for configuring the Reachy Mini daemon.

reachy_mini.daemon.app.main.create_app[[reachy_mini.daemon.app.main.create_app]]

reachy_mini.daemon.app.main.create_app(args: Args, health_check_event: asyncio.locks.Event | None = None)

Source

Create and configure the FastAPI application.

reachy_mini.daemon.app.main.run_app[[reachy_mini.daemon.app.main.run_app]]

reachy_mini.daemon.app.main.run_app(args: Args)

Source

Run the FastAPI app with Uvicorn.

reachy_mini.daemon.app.main[[reachy_mini.daemon.app.main]]

reachy_mini.daemon.app.main()

Source

Run the FastAPI app with Uvicorn.

App Routers

Daemon Router[[reachy_mini.daemon.app.routers.daemon.start_daemon]]

reachy_mini.daemon.app.routers.daemon.start_daemon[[reachy_mini.daemon.app.routers.daemon.start_daemon]]

reachy_mini.daemon.app.routers.daemon.start_daemon(request: Request, wake_up: bool, daemon: Daemon = Depends(dependency=<function get_daemon at 0x7f021dd19440>, use_cache=True, scope=None))

Source

Start the daemon.

reachy_mini.daemon.app.routers.daemon.stop_daemon[[reachy_mini.daemon.app.routers.daemon.stop_daemon]]

reachy_mini.daemon.app.routers.daemon.stop_daemon(goto_sleep: bool, daemon: Daemon = Depends(dependency=<function get_daemon at 0x7f021dd19440>, use_cache=True, scope=None))

Source

Stop the daemon, optionally putting the robot to sleep.

reachy_mini.daemon.app.routers.daemon.restart_daemon[[reachy_mini.daemon.app.routers.daemon.restart_daemon]]

reachy_mini.daemon.app.routers.daemon.restart_daemon(request: Request, daemon: Daemon = Depends(dependency=<function get_daemon at 0x7f021dd19440>, use_cache=True, scope=None))

Source

Restart the daemon.

reachy_mini.daemon.app.routers.daemon.get_daemon_status[[reachy_mini.daemon.app.routers.daemon.get_daemon_status]]

reachy_mini.daemon.app.routers.daemon.get_daemon_status(daemon: Daemon = Depends(dependency=<function get_daemon at 0x7f021dd19440>, use_cache=True, scope=None))

Source

Get the current status of the daemon.

reachy_mini.daemon.app.routers.daemon.get_robot_app_lock_status[[reachy_mini.daemon.app.routers.daemon.get_robot_app_lock_status]]

reachy_mini.daemon.app.routers.daemon.get_robot_app_lock_status(daemon: Daemon = Depends(dependency=<function get_daemon at 0x7f021dd19440>, use_cache=True, scope=None))

Source

Return the current state of the robot's managed-app lock.

The daemon's single source of truth for which managed app (if any) currently holds the robot:

• free: no managed app holds the slot.
• local_app: a Python app launched via AppManager is running. holder_name is the app name.
• remote_session: a remote WebRTC client is connected via the central signaling relay. holder_name is a generic "remote" placeholder (the real consumer app name lives on the central server and is surfaced via its own /api/robot-status).

Note that SDK clients talking to the daemon directly bypass this lock; it only reflects the two managed app entry points.

Intended for UI layers (desktop app, dashboard) that want to render a busy/free indicator without trying to open a session.

State Router[[reachy_mini.daemon.app.routers.state.get_head_pose]]

reachy_mini.daemon.app.routers.state.get_head_pose[[reachy_mini.daemon.app.routers.state.get_head_pose]]

reachy_mini.daemon.app.routers.state.get_head_pose(use_pose_matrix: bool = False, backend: Backend = Depends(dependency=<function get_backend at 0x7f021dd19620>, use_cache=True, scope=None))

Source

Parameters:

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.

Get the present head pose.

reachy_mini.daemon.app.routers.state.get_body_yaw[[reachy_mini.daemon.app.routers.state.get_body_yaw]]

reachy_mini.daemon.app.routers.state.get_body_yaw(backend: Backend = Depends(dependency=<function get_backend at 0x7f021dd19620>, use_cache=True, scope=None))

Source

Get the present body yaw (in radians).

reachy_mini.daemon.app.routers.state.get_antenna_joint_positions[[reachy_mini.daemon.app.routers.state.get_antenna_joint_positions]]

reachy_mini.daemon.app.routers.state.get_antenna_joint_positions(backend: Backend = Depends(dependency=<function get_backend at 0x7f021dd19620>, use_cache=True, scope=None))

Source

Get the present antenna joint positions (in radians) - (left, right).

reachy_mini.daemon.app.routers.state.get_doa[[reachy_mini.daemon.app.routers.state.get_doa]]

reachy_mini.daemon.app.routers.state.get_doa(backend: Backend = Depends(dependency=<function get_backend at 0x7f021dd19620>, use_cache=True, scope=None))

Source

Get the Direction of Arrival from the microphone array.

Returns the angle in radians (0=left, π/2=front, π=right) and speech detection status. Returns None if the audio device is not available or no reading has landed yet (the first one lands within ~100 ms of the first request).

reachy_mini.daemon.app.routers.state.get_full_state[[reachy_mini.daemon.app.routers.state.get_full_state]]

reachy_mini.daemon.app.routers.state.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, with_doa: bool = False, use_pose_matrix: bool = False, backend: Backend = Depends(dependency=<function get_backend at 0x7f021dd19620>, use_cache=True, scope=None))

Source

Get the full robot state, with optional fields.

reachy_mini.daemon.app.routers.state.ws_full_state[[reachy_mini.daemon.app.routers.state.ws_full_state]]

reachy_mini.daemon.app.routers.state.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, with_doa: bool = False, use_pose_matrix: bool = False, backend: Backend = Depends(dependency=<function ws_get_backend at 0x7f021dd196c0>, use_cache=True, scope=None))

Source

WebSocket endpoint to stream the full state of the robot.

Motors Router[[reachy_mini.daemon.app.routers.motors.get_motor_status]]

reachy_mini.daemon.app.routers.motors.get_motor_status[[reachy_mini.daemon.app.routers.motors.get_motor_status]]

reachy_mini.daemon.app.routers.motors.get_motor_status(backend: Backend = Depends(dependency=<function get_backend at 0x7f021dd19620>, use_cache=True, scope=None))

Source

Get the current status of the motors.

reachy_mini.daemon.app.routers.motors.set_motor_mode[[reachy_mini.daemon.app.routers.motors.set_motor_mode]]

reachy_mini.daemon.app.routers.motors.set_motor_mode(mode: MotorControlMode, backend: Backend = Depends(dependency=<function get_backend at 0x7f021dd19620>, use_cache=True, scope=None))

Source

Set the motor control mode.

Move Router[[reachy_mini.daemon.app.routers.move.get_running_moves]]

reachy_mini.daemon.app.routers.move.get_running_moves[[reachy_mini.daemon.app.routers.move.get_running_moves]]

reachy_mini.daemon.app.routers.move.get_running_moves()

Source

Get a list of currently running move tasks.

reachy_mini.daemon.app.routers.move.goto[[reachy_mini.daemon.app.routers.move.goto]]

reachy_mini.daemon.app.routers.move.goto(goto_req: GotoModelRequest, backend: Backend = Depends(dependency=<function get_backend at 0x7f021dd19620>, use_cache=True, scope=None))

Source

Request a movement to a specific target.

reachy_mini.daemon.app.routers.move.play_wake_up[[reachy_mini.daemon.app.routers.move.play_wake_up]]

reachy_mini.daemon.app.routers.move.play_wake_up(backend: Backend = Depends(dependency=<function get_backend at 0x7f021dd19620>, use_cache=True, scope=None))

Source

Request the robot to wake up.

reachy_mini.daemon.app.routers.move.play_goto_sleep[[reachy_mini.daemon.app.routers.move.play_goto_sleep]]

reachy_mini.daemon.app.routers.move.play_goto_sleep(backend: Backend = Depends(dependency=<function get_backend at 0x7f021dd19620>, use_cache=True, scope=None))

Source

Request the robot to go to sleep.

reachy_mini.daemon.app.routers.move.list_recorded_move_dataset[[reachy_mini.daemon.app.routers.move.list_recorded_move_dataset]]

reachy_mini.daemon.app.routers.move.list_recorded_move_dataset(dataset_name: str)

Source

List available recorded moves in a dataset.

reachy_mini.daemon.app.routers.move.play_recorded_move_dataset[[reachy_mini.daemon.app.routers.move.play_recorded_move_dataset]]

reachy_mini.daemon.app.routers.move.play_recorded_move_dataset(dataset_name: str, move_name: str, backend: Backend = Depends(dependency=<function get_backend at 0x7f021dd19620>, use_cache=True, scope=None))

Source

Request the robot to play a predefined recorded move from a dataset.

reachy_mini.daemon.app.routers.move.stop_move[[reachy_mini.daemon.app.routers.move.stop_move]]

reachy_mini.daemon.app.routers.move.stop_move(uuid: MoveUUID)

Source

Stop a running move task.

reachy_mini.daemon.app.routers.move.set_target[[reachy_mini.daemon.app.routers.move.set_target]]

reachy_mini.daemon.app.routers.move.set_target(target: FullBodyTarget, backend: Backend = Depends(dependency=<function get_backend at 0x7f021dd19620>, use_cache=True, scope=None))

Source

POST route to set a single FullBodyTarget.

reachy_mini.daemon.app.routers.move.ws_move_updates[[reachy_mini.daemon.app.routers.move.ws_move_updates]]

reachy_mini.daemon.app.routers.move.ws_move_updates(websocket: WebSocket)

Source

WebSocket route to stream move updates.

Apps Router[[reachy_mini.daemon.app.routers.apps.list_available_apps]]

reachy_mini.daemon.app.routers.apps.list_available_apps[[reachy_mini.daemon.app.routers.apps.list_available_apps]]

reachy_mini.daemon.app.routers.apps.list_available_apps(source_kind: SourceKind, app_manager: AppManager = Depends(dependency=<function get_app_manager at 0x7f021dd194e0>, use_cache=True, scope=None))

Source

List available apps (including not installed).

reachy_mini.daemon.app.routers.apps.list_all_available_apps[[reachy_mini.daemon.app.routers.apps.list_all_available_apps]]

reachy_mini.daemon.app.routers.apps.list_all_available_apps(app_manager: AppManager = Depends(dependency=<function get_app_manager at 0x7f021dd194e0>, use_cache=True, scope=None))

Source

List all available apps (including not installed).

reachy_mini.daemon.app.routers.apps.install_app[[reachy_mini.daemon.app.routers.apps.install_app]]

reachy_mini.daemon.app.routers.apps.install_app(app_info: AppInfo, app_manager: AppManager = Depends(dependency=<function get_app_manager at 0x7f021dd194e0>, use_cache=True, scope=None))

Source

Install a new app by its info (background, returns job_id).

reachy_mini.daemon.app.routers.apps.remove_app[[reachy_mini.daemon.app.routers.apps.remove_app]]

reachy_mini.daemon.app.routers.apps.remove_app(app_name: str, request: Request, app_manager: AppManager = Depends(dependency=<function get_app_manager at 0x7f021dd194e0>, use_cache=True, scope=None))

Source

Remove an installed app by its name (background, returns job_id).

reachy_mini.daemon.app.routers.apps.job_status[[reachy_mini.daemon.app.routers.apps.job_status]]

reachy_mini.daemon.app.routers.apps.job_status(job_id: str)

Source

Get status/logs for a job.

reachy_mini.daemon.app.routers.apps.ws_apps_manager[[reachy_mini.daemon.app.routers.apps.ws_apps_manager]]

reachy_mini.daemon.app.routers.apps.ws_apps_manager(websocket: WebSocket, job_id: str)

Source

WebSocket route to stream live job status/logs for a job, sending updates as soon as new logs are available.

reachy_mini.daemon.app.routers.apps.start_app[[reachy_mini.daemon.app.routers.apps.start_app]]

reachy_mini.daemon.app.routers.apps.start_app(app_name: str, app_manager: AppManager = Depends(dependency=<function get_app_manager at 0x7f021dd194e0>, use_cache=True, scope=None))

Source

Start an app by its name.

reachy_mini.daemon.app.routers.apps.restart_app[[reachy_mini.daemon.app.routers.apps.restart_app]]

reachy_mini.daemon.app.routers.apps.restart_app(app_manager: AppManager = Depends(dependency=<function get_app_manager at 0x7f021dd194e0>, use_cache=True, scope=None))

Source

Restart the currently running app.

reachy_mini.daemon.app.routers.apps.stop_app[[reachy_mini.daemon.app.routers.apps.stop_app]]

reachy_mini.daemon.app.routers.apps.stop_app(app_manager: AppManager = Depends(dependency=<function get_app_manager at 0x7f021dd194e0>, use_cache=True, scope=None))

Source

Stop the currently running app.

reachy_mini.daemon.app.routers.apps.current_app_status[[reachy_mini.daemon.app.routers.apps.current_app_status]]

reachy_mini.daemon.app.routers.apps.current_app_status(app_manager: AppManager = Depends(dependency=<function get_app_manager at 0x7f021dd194e0>, use_cache=True, scope=None))

Source

Get the status of the currently running app, if any.

reachy_mini.daemon.app.routers.apps.install_private_space[[reachy_mini.daemon.app.routers.apps.install_private_space]]

reachy_mini.daemon.app.routers.apps.install_private_space(request: PrivateSpaceInstallRequest, app_manager: AppManager = Depends(dependency=<function get_app_manager at 0x7f021dd194e0>, use_cache=True, scope=None))

Source

Install a private HuggingFace space.

Requires HF token to be stored via /api/hf-auth/save-token first.

Update Router[[reachy_mini.daemon.app.routers.update.available]]

reachy_mini.daemon.app.routers.update.available[[reachy_mini.daemon.app.routers.update.available]]

reachy_mini.daemon.app.routers.update.available(pre_release: bool = False)

Source

Check if an update is available for Reachy Mini Wireless.

reachy_mini.daemon.app.routers.update.start_update[[reachy_mini.daemon.app.routers.update.start_update]]

reachy_mini.daemon.app.routers.update.start_update(pre_release: bool = False)

Source

Start the update process for Reachy Mini Wireless version.

reachy_mini.daemon.app.routers.update.get_update_info[[reachy_mini.daemon.app.routers.update.get_update_info]]

reachy_mini.daemon.app.routers.update.get_update_info(job_id: str)

Source

Get the info of an update job.

reachy_mini.daemon.app.routers.update.websocket_logs[[reachy_mini.daemon.app.routers.update.websocket_logs]]

reachy_mini.daemon.app.routers.update.websocket_logs(websocket: WebSocket, job_id: str)

Source

WebSocket endpoint to stream update logs in real time.

Cache Router[[reachy_mini.daemon.app.routers.cache.clear_huggingface_cache]]

reachy_mini.daemon.app.routers.cache.clear_huggingface_cache[[reachy_mini.daemon.app.routers.cache.clear_huggingface_cache]]

reachy_mini.daemon.app.routers.cache.clear_huggingface_cache()

Source

Clear HuggingFace cache directory.

reachy_mini.daemon.app.routers.cache.reset_apps[[reachy_mini.daemon.app.routers.cache.reset_apps]]

reachy_mini.daemon.app.routers.cache.reset_apps()

Source

Remove applications virtual environment directory.

Kinematics Router[[reachy_mini.daemon.app.routers.kinematics.get_kinematics_info]]

reachy_mini.daemon.app.routers.kinematics.get_kinematics_info[[reachy_mini.daemon.app.routers.kinematics.get_kinematics_info]]

reachy_mini.daemon.app.routers.kinematics.get_kinematics_info(backend: Backend = Depends(dependency=<function get_backend at 0x7f021dd19620>, use_cache=True, scope=None))

Source

Get the current information of the kinematics.

reachy_mini.daemon.app.routers.kinematics.get_urdf[[reachy_mini.daemon.app.routers.kinematics.get_urdf]]

reachy_mini.daemon.app.routers.kinematics.get_urdf(backend: Backend = Depends(dependency=<function get_backend at 0x7f021dd19620>, use_cache=True, scope=None))

Source

Get the URDF representation of the robot.

reachy_mini.daemon.app.routers.kinematics.get_stl_file[[reachy_mini.daemon.app.routers.kinematics.get_stl_file]]

reachy_mini.daemon.app.routers.kinematics.get_stl_file(filename: Path)

Source

Get the path to an STL asset file.

Volume Router[[reachy_mini.daemon.app.routers.volume.get_volume]]

reachy_mini.daemon.app.routers.volume.get_volume[[reachy_mini.daemon.app.routers.volume.get_volume]]

reachy_mini.daemon.app.routers.volume.get_volume()

Source

Get the current output volume level.

reachy_mini.daemon.app.routers.volume.set_volume[[reachy_mini.daemon.app.routers.volume.set_volume]]

reachy_mini.daemon.app.routers.volume.set_volume(volume_req: VolumeRequest, request: Request)

Source

Set the output volume level and play a test sound.

reachy_mini.daemon.app.routers.volume.play_test_sound[[reachy_mini.daemon.app.routers.volume.play_test_sound]]

reachy_mini.daemon.app.routers.volume.play_test_sound(backend: Backend = Depends(dependency=<function get_backend at 0x7f021dd19620>, use_cache=True, scope=None))

Source

Play a test sound.

reachy_mini.daemon.app.routers.volume.get_microphone_volume[[reachy_mini.daemon.app.routers.volume.get_microphone_volume]]

reachy_mini.daemon.app.routers.volume.get_microphone_volume()

Source

Get the current microphone input volume level.

reachy_mini.daemon.app.routers.volume.set_microphone_volume[[reachy_mini.daemon.app.routers.volume.set_microphone_volume]]

reachy_mini.daemon.app.routers.volume.set_microphone_volume(volume_req: VolumeRequest)

Source

Set the microphone input volume level.

Logs Router[[reachy_mini.daemon.app.routers.logs.websocket_daemon_logs]]

reachy_mini.daemon.app.routers.logs.websocket_daemon_logs[[reachy_mini.daemon.app.routers.logs.websocket_daemon_logs]]

reachy_mini.daemon.app.routers.logs.websocket_daemon_logs(websocket: WebSocket)

Source

WebSocket endpoint to stream journalctl logs for reachy-mini-daemon service in real time.

HF Auth Router[[reachy_mini.daemon.app.routers.hf_auth.save_token]]

reachy_mini.daemon.app.routers.hf_auth.save_token[[reachy_mini.daemon.app.routers.hf_auth.save_token]]

reachy_mini.daemon.app.routers.hf_auth.save_token(request: TokenRequest)

Source

Save HuggingFace token after validation.

reachy_mini.daemon.app.routers.hf_auth.get_auth_status[[reachy_mini.daemon.app.routers.hf_auth.get_auth_status]]

reachy_mini.daemon.app.routers.hf_auth.get_auth_status()

Source

Check if user is authenticated with HuggingFace.

reachy_mini.daemon.app.routers.hf_auth.delete_token[[reachy_mini.daemon.app.routers.hf_auth.delete_token]]

reachy_mini.daemon.app.routers.hf_auth.delete_token()

Source

Delete stored HuggingFace token.