From 70274452ca18eb33a0a3985974180c84dff29ec3 Mon Sep 17 00:00:00 2001 From: MrHu <1962951972@qq.com> Date: Mon, 19 Oct 2026 17:20:55 +0800 Subject: [PATCH 1/9] feat(deploy): add persistent program runtime contracts --- .../src/motrix_deploy/config/__init__.py | 18 + motrix_deploy/src/motrix_deploy/errors.py | 4 + motrix_deploy/src/motrix_deploy/operator.py | 284 +++++++++++++ motrix_deploy/src/motrix_deploy/program.py | 63 +++ .../src/motrix_deploy/robot/g1_standing.py | 102 +++++ .../src/motrix_deploy/runtime/control.py | 16 +- .../src/motrix_deploy/runtime/hot_swapping.py | 147 +++++++ .../src/motrix_deploy/runtime/preparation.py | 142 +++++++ .../motrix_deploy/runtime/state_machine.py | 383 ++++++++++++++++++ motrix_deploy/src/motrix_deploy/task.py | 6 + motrix_deploy/tests/test_hot_swapping.py | 151 +++++++ motrix_deploy/tests/test_operator_binding.py | 91 +++++ motrix_deploy/tests/test_package.py | 13 + motrix_deploy/tests/test_state_machine.py | 157 +++++++ 14 files changed, 1573 insertions(+), 4 deletions(-) create mode 100644 motrix_deploy/src/motrix_deploy/operator.py create mode 100644 motrix_deploy/src/motrix_deploy/program.py create mode 100644 motrix_deploy/src/motrix_deploy/robot/g1_standing.py create mode 100644 motrix_deploy/src/motrix_deploy/runtime/hot_swapping.py create mode 100644 motrix_deploy/src/motrix_deploy/runtime/preparation.py create mode 100644 motrix_deploy/src/motrix_deploy/runtime/state_machine.py create mode 100644 motrix_deploy/tests/test_hot_swapping.py create mode 100644 motrix_deploy/tests/test_operator_binding.py create mode 100644 motrix_deploy/tests/test_state_machine.py diff --git a/motrix_deploy/src/motrix_deploy/config/__init__.py b/motrix_deploy/src/motrix_deploy/config/__init__.py index c597c0e0..5bf867cb 100644 --- a/motrix_deploy/src/motrix_deploy/config/__init__.py +++ b/motrix_deploy/src/motrix_deploy/config/__init__.py @@ -95,6 +95,23 @@ def __post_init__(self) -> None: ) +@dataclass +class ProgramRunConfig: + """Resolved persistent multi-policy execution settings.""" + + program: Any = MISSING + runtime: Any = MISSING + + def __post_init__(self) -> None: + if self.program is MISSING or not getattr(self.program, "name", None): + raise ValueError("program must be a composed program recipe") + if not isinstance(self.runtime, (SimRuntimeCfg, HardwareRuntimeCfg)): + raise ValueError( + "runtime must be a composed SimRuntimeCfg or HardwareRuntimeCfg recipe, " + f"got {type(self.runtime).__name__}" + ) + + def _install_sim_runtime_schema() -> None: ConfigStore.instance().store(group=SIM_SCHEMA_GROUP, name="_sim_schema", node=SimRuntimeCfg) @@ -104,6 +121,7 @@ def _install_sim_runtime_schema() -> None: __all__ = [ "DeployRunConfig", "HardwareRuntimeCfg", + "ProgramRunConfig", "SIM_SCHEMA_GROUP", "SimRuntimeCfg", ] diff --git a/motrix_deploy/src/motrix_deploy/errors.py b/motrix_deploy/src/motrix_deploy/errors.py index 74e10987..9791c588 100644 --- a/motrix_deploy/src/motrix_deploy/errors.py +++ b/motrix_deploy/src/motrix_deploy/errors.py @@ -26,6 +26,10 @@ class LieDownRequestedError(RuntimeError): """A physical input requested the backend's configured lie-down shutdown.""" +class PassiveRequestedError(RuntimeError): + """A physical input requested an immediate transition to passive damping.""" + + class ControlFailure(RuntimeError): def __init__(self, reason: str, message: str) -> None: self.reason = reason diff --git a/motrix_deploy/src/motrix_deploy/operator.py b/motrix_deploy/src/motrix_deploy/operator.py new file mode 100644 index 00000000..204e7dc0 --- /dev/null +++ b/motrix_deploy/src/motrix_deploy/operator.py @@ -0,0 +1,284 @@ +# Copyright Motphys Technology Co., Ltd. 2025, 2026 +# SPDX-License-Identifier: Apache-2.0 + +"""Backend-neutral operator gestures and command-input configuration.""" + +import time +from collections.abc import Sequence +from dataclasses import dataclass, field + +import numpy as np + +from motrix_deploy.errors import ValidationError +from motrix_env_core.input import CommandBinding, GamePadDevice, InputDevice, KeyboardDevice, PlanarVelocityCommand + + +@dataclass(frozen=True) +class OperatorCommand: + """Backend-neutral operator input consumed by a persistent control program.""" + + intents: frozenset[str] = frozenset() + planar_velocity: PlanarVelocityCommand | None = None + + def __post_init__(self) -> None: + if not isinstance(self.intents, frozenset) or any( + not isinstance(intent, str) or not intent for intent in self.intents + ): + raise ValidationError("operator.intents", "a frozenset of non-empty strings", self.intents) + if self.planar_velocity is not None and not isinstance(self.planar_velocity, PlanarVelocityCommand): + raise ValidationError( + "operator.planar_velocity", "a PlanarVelocityCommand or None", type(self.planar_velocity).__name__ + ) + + +@dataclass +class ButtonGestureCfg: + """One edge-triggered button gesture with optional held modifiers.""" + + held: list[str] = field(default_factory=list) + pressed: str | None = None + released: str | None = None + held_for_s: dict[str, float] = field(default_factory=dict) + + def __post_init__(self) -> None: + names = [*self.held, *self.held_for_s] + if self.pressed is not None: + names.append(self.pressed) + if self.released is not None: + names.append(self.released) + if not names: + raise ValidationError("operator.gesture", "at least one button condition", names) + if any(not isinstance(name, str) or not name for name in names): + raise ValidationError("operator.gesture.buttons", "non-empty button names", names) + if len(set(self.held)) != len(self.held): + raise ValidationError("operator.gesture.held", "unique button names", self.held) + for button, seconds in self.held_for_s.items(): + if ( + not isinstance(seconds, (int, float)) + or isinstance(seconds, bool) + or not np.isfinite(seconds) + or seconds <= 0 + ): + raise ValidationError(f"operator.gesture.held_for_s.{button}", "a positive finite duration", seconds) + + +@dataclass +class PlanarVelocityOperatorCfg: + """Map three normalized device axes into one planar velocity command.""" + + linear_x_axis: str = "ly" + linear_y_axis: str = "lx" + yaw_axis: str = "rx" + invert_linear_x: bool = False + invert_linear_y: bool = False + invert_yaw: bool = False + deadzone: float = 0.0 + range_scale: list[float] = field(default_factory=lambda: [1.0, 1.0, 1.0]) + deadman_button: str | None = None + + def __post_init__(self) -> None: + for name in (self.linear_x_axis, self.linear_y_axis, self.yaw_axis): + if not isinstance(name, str) or not name: + raise ValidationError("operator.planar_velocity.axes", "non-empty axis names", name) + if ( + not isinstance(self.deadzone, (int, float)) + or isinstance(self.deadzone, bool) + or not np.isfinite(self.deadzone) + or not 0 <= self.deadzone < 1 + ): + raise ValidationError("operator.planar_velocity.deadzone", "a finite value in [0, 1)", self.deadzone) + scale = np.asarray(self.range_scale, dtype=np.float32) + if scale.shape != (3,) or not np.all(np.isfinite(scale)) or np.any(scale < 0) or np.any(scale > 1): + raise ValidationError( + "operator.planar_velocity.range_scale", "three finite values in [0, 1]", self.range_scale + ) + if self.deadman_button is not None and (not isinstance(self.deadman_button, str) or not self.deadman_button): + raise ValidationError( + "operator.planar_velocity.deadman_button", "null or a non-empty button name", self.deadman_button + ) + + +@dataclass +class OperatorProfileCfg: + """User-configurable gestures plus optional continuous command wiring.""" + + intents: dict[str, ButtonGestureCfg] = field(default_factory=dict) + planar_velocity: PlanarVelocityOperatorCfg | None = None + + def __post_init__(self) -> None: + if any(not isinstance(name, str) or not name for name in self.intents): + raise ValidationError("operator.intents", "non-empty intent names", tuple(self.intents)) + signatures: dict[tuple[object, ...], str] = {} + for intent, gesture in self.intents.items(): + if not isinstance(gesture, ButtonGestureCfg): + raise ValidationError(f"operator.intents.{intent}", "a ButtonGestureCfg", type(gesture).__name__) + signature = ( + tuple(sorted(gesture.held)), + gesture.pressed, + gesture.released, + tuple(sorted(gesture.held_for_s.items())), + ) + previous = signatures.get(signature) + if previous is not None: + raise ValidationError( + "operator.intents", "distinct gestures for each intent", f"{previous!r} and {intent!r}" + ) + signatures[signature] = intent + + +class OperatorIntentEvaluator: + """Evaluate configured button gestures from timestamped button snapshots.""" + + def __init__(self, gestures: dict[str, ButtonGestureCfg]) -> None: + self._gestures = dict(gestures) + self._previous: frozenset[str] | None = None + self._pressed_since_ns: dict[str, int] = {} + + def reset(self) -> None: + self._previous = None + self._pressed_since_ns.clear() + + def update(self, pressed_buttons: frozenset[str], timestamp_ns: int) -> frozenset[str]: + """Return intents whose edge/hold predicates became true in this snapshot.""" + + if not isinstance(timestamp_ns, int) or isinstance(timestamp_ns, bool) or timestamp_ns < 0: + raise ValidationError("operator.timestamp_ns", "a non-negative integer", timestamp_ns) + previous = self._previous + for button in pressed_buttons: + self._pressed_since_ns.setdefault(button, timestamp_ns) + for button in tuple(self._pressed_since_ns): + if button not in pressed_buttons: + del self._pressed_since_ns[button] + self._previous = pressed_buttons + if previous is None: + return frozenset() + + matched = [] + for intent, gesture in self._gestures.items(): + if any(button not in pressed_buttons for button in gesture.held): + continue + if gesture.pressed is not None and not ( + gesture.pressed in pressed_buttons and gesture.pressed not in previous + ): + continue + if gesture.released is not None and not ( + gesture.released not in pressed_buttons and gesture.released in previous + ): + continue + if any( + button not in pressed_buttons + or timestamp_ns - self._pressed_since_ns.get(button, timestamp_ns) < round(seconds * 1e9) + for button, seconds in gesture.held_for_s.items() + ): + continue + matched.append(intent) + return frozenset(matched) + + +class OperatorCommandBinding(CommandBinding[OperatorCommand]): + """Read one input frame and produce semantic intents plus bounded velocity.""" + + def __init__( + self, + device: InputDevice, + profile: OperatorProfileCfg, + *, + command_lower: Sequence[float], + command_upper: Sequence[float], + ) -> None: + if not isinstance(device, (KeyboardDevice, GamePadDevice)): + raise ValidationError("operator.device", "a keyboard or gamepad", type(device).__name__) + self._device = device + self._profile = profile + self._evaluator = OperatorIntentEvaluator(profile.intents) + self._buttons = frozenset( + button + for gesture in profile.intents.values() + for button in (*gesture.held, *gesture.held_for_s, gesture.pressed, gesture.released) + if button is not None + ) + self._lower = np.asarray(command_lower, dtype=np.float32) + self._upper = np.asarray(command_upper, dtype=np.float32) + if self._lower.shape != (3,) or self._upper.shape != (3,): + raise ValidationError("operator.command_bounds", "two vectors with shape (3,)", (self._lower, self._upper)) + if np.any(self._lower > 0) or np.any(self._upper < 0) or np.any(self._lower > self._upper): + raise ValidationError( + "operator.command_bounds", "ordered bounds containing zero", (self._lower, self._upper) + ) + + def _pressed_buttons(self) -> frozenset[str]: + if isinstance(self._device, KeyboardDevice): + return frozenset(button for button in self._buttons if self._device.is_pressing(button)) + return frozenset(button for button in self._buttons if self._device.is_button_pressing(button)) + + def _keyboard_velocity(self) -> np.ndarray: + assert isinstance(self._device, KeyboardDevice) + direction = np.asarray( + ( + int(self._device.is_pressing("w")) - int(self._device.is_pressing("s")), + int(self._device.is_pressing("a")) - int(self._device.is_pressing("d")), + int(self._device.is_pressing("q")) - int(self._device.is_pressing("e")), + ), + dtype=np.int8, + ) + return np.where(direction > 0, self._upper, np.where(direction < 0, self._lower, 0)).astype(np.float32) + + def _gamepad_velocity(self) -> np.ndarray: + assert isinstance(self._device, GamePadDevice) + config = self._profile.planar_velocity + if config is None: + return np.zeros(3, dtype=np.float32) + if config.deadman_button is not None and not self._device.is_button_pressing(config.deadman_button): + return np.zeros(3, dtype=np.float32) + axes = np.asarray( + ( + self._device.axis_value(config.linear_x_axis), + self._device.axis_value(config.linear_y_axis), + self._device.axis_value(config.yaw_axis), + ), + dtype=np.float32, + ) + direction = np.asarray( + ( + -1.0 if config.invert_linear_x else 1.0, + -1.0 if config.invert_linear_y else 1.0, + -1.0 if config.invert_yaw else 1.0, + ), + dtype=np.float32, + ) + axes = np.clip(axes * direction, -1.0, 1.0) + magnitude = np.maximum(np.abs(axes) - config.deadzone, 0.0) / (1.0 - config.deadzone) + normalized = np.copysign(magnitude, axes) + bounded = np.where(normalized >= 0, normalized * self._upper, (-normalized) * self._lower) + return (bounded * np.asarray(config.range_scale, dtype=np.float32)).astype(np.float32) + + def read_command(self, *, batch_size: int = 1) -> OperatorCommand: + if not isinstance(batch_size, int) or isinstance(batch_size, bool) or batch_size <= 0: + raise ValidationError("operator.batch_size", "a positive integer", batch_size) + self._device.poll() + intents = self._evaluator.update(self._pressed_buttons(), time.monotonic_ns()) + velocity = self._keyboard_velocity() if isinstance(self._device, KeyboardDevice) else self._gamepad_velocity() + return OperatorCommand( + intents=intents, + planar_velocity=PlanarVelocityCommand(np.repeat(velocity[None, :], batch_size, axis=0)), + ) + + +class ConstantOperatorCommandBinding(CommandBinding[OperatorCommand]): + """Keep a headless program passive until an external binding is supplied.""" + + def read_command(self, *, batch_size: int = 1) -> OperatorCommand: + if not isinstance(batch_size, int) or isinstance(batch_size, bool) or batch_size <= 0: + raise ValidationError("operator.batch_size", "a positive integer", batch_size) + return OperatorCommand(planar_velocity=PlanarVelocityCommand(np.zeros((batch_size, 3), dtype=np.float32))) + + +__all__ = [ + "ButtonGestureCfg", + "ConstantOperatorCommandBinding", + "OperatorCommand", + "OperatorCommandBinding", + "OperatorIntentEvaluator", + "OperatorProfileCfg", + "PlanarVelocityOperatorCfg", +] diff --git a/motrix_deploy/src/motrix_deploy/program.py b/motrix_deploy/src/motrix_deploy/program.py new file mode 100644 index 00000000..7d352999 --- /dev/null +++ b/motrix_deploy/src/motrix_deploy/program.py @@ -0,0 +1,63 @@ +# Copyright Motphys Technology Co., Ltd. 2025, 2026 +# SPDX-License-Identifier: Apache-2.0 + +"""Persistent multi-policy deployment program discovery and assembly.""" + +from collections.abc import Callable +from dataclasses import dataclass +from importlib import metadata +from typing import Any + +from motrix_deploy.artifact.schema import ControlSpec +from motrix_deploy.contracts import FloatArray, RobotSpec +from motrix_deploy.operator import ( + ConstantOperatorCommandBinding, + OperatorCommand, + OperatorCommandBinding, + OperatorProfileCfg, +) +from motrix_deploy.runtime.lifecycle import Controller +from motrix_env_core.input import CommandBinding, InputDevice + +PROGRAM_ENTRY_POINT_GROUP = "motrix_deploy.programs" + + +@dataclass(frozen=True) +class DeploymentProgram: + """Fully loaded persistent controller plus its backend-neutral contracts.""" + + robot: RobotSpec + control: ControlSpec + controller: Controller[OperatorCommand] + command_lower: FloatArray + command_upper: FloatArray + operator: OperatorProfileCfg + + def prepare(self, device: InputDevice | None) -> CommandBinding[OperatorCommand]: + if device is None: + return ConstantOperatorCommandBinding() + return OperatorCommandBinding( + device, + self.operator, + command_lower=self.command_lower, + command_upper=self.command_upper, + ) + + +def create_program(config: Any) -> DeploymentProgram: + """Load a program factory by the typed config's stable name.""" + name = getattr(config, "name", None) + if not isinstance(name, str) or not name: + raise ValueError("program config must provide a non-empty name") + matches = [entry for entry in metadata.entry_points(group=PROGRAM_ENTRY_POINT_GROUP) if entry.name == name] + if len(matches) != 1: + available = sorted(entry.name for entry in metadata.entry_points(group=PROGRAM_ENTRY_POINT_GROUP)) + raise ValueError(f"Deployment program {name!r} has {len(matches)} providers; available: {available}") + factory: Callable[[Any], DeploymentProgram] = matches[0].load() + program = factory(config) + if not isinstance(program, DeploymentProgram): + raise TypeError(f"Deployment program {name!r} returned {type(program).__name__}") + return program + + +__all__ = ["DeploymentProgram", "create_program"] diff --git a/motrix_deploy/src/motrix_deploy/robot/g1_standing.py b/motrix_deploy/src/motrix_deploy/robot/g1_standing.py new file mode 100644 index 00000000..868cabb1 --- /dev/null +++ b/motrix_deploy/src/motrix_deploy/robot/g1_standing.py @@ -0,0 +1,102 @@ +# Copyright Motphys Technology Co., Ltd. 2025, 2026 +# SPDX-License-Identifier: Apache-2.0 + +"""Fixed G1 29-DOF standing (FixStand) servo gains. + +FixStand is a posture, not a policy: it must not follow the exported policy +artifact, otherwise every new policy silently changes how the robot stands up. +The persistent program, the skill preparation and the single-artifact hardware +startup all resolve their pull-in gains here, so there is exactly one definition +to adjust by hand. + +Values are keyed by joint name so any canonical joint order resolves correctly. +They are the field-validated stand-up gains: stiffer than the policy gains so the +legs carry the body, with waist gains that hold the torso and light arm damping. +""" + +from __future__ import annotations + +from collections.abc import Mapping, Sequence + +import numpy as np + +G1_29DOF_STANDING_KP: Mapping[str, float] = { + "left_hip_pitch_joint": 350.0, + "left_hip_roll_joint": 200.0, + "left_hip_yaw_joint": 200.0, + "left_knee_joint": 300.0, + "left_ankle_pitch_joint": 300.0, + "left_ankle_roll_joint": 150.0, + "right_hip_pitch_joint": 350.0, + "right_hip_roll_joint": 200.0, + "right_hip_yaw_joint": 200.0, + "right_knee_joint": 300.0, + "right_ankle_pitch_joint": 300.0, + "right_ankle_roll_joint": 150.0, + "waist_yaw_joint": 200.0, + "waist_roll_joint": 200.0, + "waist_pitch_joint": 200.0, + "left_shoulder_pitch_joint": 40.0, + "left_shoulder_roll_joint": 40.0, + "left_shoulder_yaw_joint": 40.0, + "left_elbow_joint": 40.0, + "left_wrist_roll_joint": 40.0, + "left_wrist_pitch_joint": 40.0, + "left_wrist_yaw_joint": 40.0, + "right_shoulder_pitch_joint": 40.0, + "right_shoulder_roll_joint": 40.0, + "right_shoulder_yaw_joint": 40.0, + "right_elbow_joint": 40.0, + "right_wrist_roll_joint": 40.0, + "right_wrist_pitch_joint": 40.0, + "right_wrist_yaw_joint": 40.0, +} + +G1_29DOF_STANDING_KD: Mapping[str, float] = { + "left_hip_pitch_joint": 5.0, + "left_hip_roll_joint": 5.0, + "left_hip_yaw_joint": 5.0, + "left_knee_joint": 10.0, + "left_ankle_pitch_joint": 5.0, + "left_ankle_roll_joint": 5.0, + "right_hip_pitch_joint": 5.0, + "right_hip_roll_joint": 5.0, + "right_hip_yaw_joint": 5.0, + "right_knee_joint": 10.0, + "right_ankle_pitch_joint": 5.0, + "right_ankle_roll_joint": 5.0, + "waist_yaw_joint": 5.0, + "waist_roll_joint": 5.0, + "waist_pitch_joint": 5.0, + "left_shoulder_pitch_joint": 3.0, + "left_shoulder_roll_joint": 3.0, + "left_shoulder_yaw_joint": 3.0, + "left_elbow_joint": 3.0, + "left_wrist_roll_joint": 3.0, + "left_wrist_pitch_joint": 3.0, + "left_wrist_yaw_joint": 3.0, + "right_shoulder_pitch_joint": 3.0, + "right_shoulder_roll_joint": 3.0, + "right_shoulder_yaw_joint": 3.0, + "right_elbow_joint": 3.0, + "right_wrist_roll_joint": 3.0, + "right_wrist_pitch_joint": 3.0, + "right_wrist_yaw_joint": 3.0, +} + + +def resolve_g1_standing_gains(joint_names: Sequence[str]) -> tuple[np.ndarray, np.ndarray]: + """Return the fixed standing gains in the requested canonical joint order.""" + names = tuple(joint_names) + known = set(G1_29DOF_STANDING_KP) + if set(names) != known: + raise ValueError( + "G1 standing gains cover exactly the 29 G1 DOF joints; " + f"missing={sorted(known - set(names))}, unknown={sorted(set(names) - known)}" + ) + kp = np.asarray([G1_29DOF_STANDING_KP[name] for name in names], dtype=np.float32) + kd = np.asarray([G1_29DOF_STANDING_KD[name] for name in names], dtype=np.float32) + return kp, kd + + +__all__ = ["G1_29DOF_STANDING_KD", "G1_29DOF_STANDING_KP", "resolve_g1_standing_gains"] diff --git a/motrix_deploy/src/motrix_deploy/runtime/control.py b/motrix_deploy/src/motrix_deploy/runtime/control.py index e2148e06..724c92d3 100644 --- a/motrix_deploy/src/motrix_deploy/runtime/control.py +++ b/motrix_deploy/src/motrix_deploy/runtime/control.py @@ -8,7 +8,13 @@ from typing import Generic, TypeVar from motrix_deploy.contracts import JointServoCommand, RobotState -from motrix_deploy.errors import ControlFailure, EmergencyStopError, LieDownRequestedError, ValidationError +from motrix_deploy.errors import ( + ControlFailure, + EmergencyStopError, + LieDownRequestedError, + PassiveRequestedError, + ValidationError, +) from motrix_deploy.policy import Policy from motrix_deploy.policy.processing import PolicyProcessor from motrix_deploy.robot.interface import RobotInterface @@ -164,7 +170,7 @@ def start(self) -> bool: if self.robot.capabilities.requires_enable: try: self.robot.enable() - except (EmergencyStopError, LieDownRequestedError, ValidationError): + except (EmergencyStopError, LieDownRequestedError, PassiveRequestedError, ValidationError): raise except Exception as error: raise ControlFailure("backend_enable_error", str(error)) from error @@ -181,7 +187,7 @@ def _read_state(self, previous: int | None) -> "RobotState": state = self.robot.read_state(self.state_timeout_s) except TimeoutError as error: raise ControlFailure("state_timeout", str(error)) from error - except (EmergencyStopError, LieDownRequestedError): + except (EmergencyStopError, LieDownRequestedError, PassiveRequestedError): raise except Exception as error: raise ControlFailure("backend_read_error", str(error)) from error @@ -236,7 +242,7 @@ def tick(self, *, elapsed_time_s: float) -> bool: phase = time.monotonic_ns() try: self.robot.write_command(decision.command) - except (EmergencyStopError, LieDownRequestedError): + except (EmergencyStopError, LieDownRequestedError, PassiveRequestedError): raise except Exception as error: raise ControlFailure("backend_write_error", str(error)) from error @@ -267,6 +273,8 @@ def fail(self, error: BaseException) -> None: self._reason, self._message = "emergency_stop", str(error) elif isinstance(error, LieDownRequestedError): self._reason, self._message = "lie_down", str(error) + elif isinstance(error, PassiveRequestedError): + self._reason, self._message = "passive", str(error) elif isinstance(error, ControlFailure): self._reason, self._message = error.reason, str(error) elif isinstance(error, ValidationError): diff --git a/motrix_deploy/src/motrix_deploy/runtime/hot_swapping.py b/motrix_deploy/src/motrix_deploy/runtime/hot_swapping.py new file mode 100644 index 00000000..899b21cc --- /dev/null +++ b/motrix_deploy/src/motrix_deploy/runtime/hot_swapping.py @@ -0,0 +1,147 @@ +# Copyright Motphys Technology Co., Ltd. 2025, 2026 +# SPDX-License-Identifier: Apache-2.0 + +"""Backend-neutral orchestration for baseline states and finite skill modules.""" + +from __future__ import annotations + +from dataclasses import dataclass + +from motrix_deploy.contracts import RobotState +from motrix_deploy.errors import ValidationError +from motrix_deploy.operator import OperatorCommand +from motrix_deploy.runtime.preparation import JointServoPreparationState, SkillPreparationSpec +from motrix_deploy.runtime.state_machine import ( + ControlState, + ImmediateTransition, + StateMachineController, + TransitionFactory, + TransitionRule, +) + + +@dataclass(frozen=True) +class BaselineStates: + """Persistent passive, fixed-standing and locomotion states.""" + + passive: ControlState + fixstand: ControlState + walk: ControlState + + +@dataclass(frozen=True) +class SkillModule: + """One finite policy state and the preparation required before entering it.""" + + name: str + state: ControlState + preparation: SkillPreparationSpec + request_intent: str + + def __post_init__(self) -> None: + if self.name != self.state.name: + raise ValueError("skill module name must equal its control state name") + + +class RobotHotSwappingController(StateMachineController): + """Run P/A/B/C/D with one shared preparation state for all skills.""" + + def __init__( + self, + *, + joint_names: tuple[str, ...], + baseline: BaselineStates, + preparation: JointServoPreparationState, + skills: tuple[SkillModule, ...], + initial_state: str, + baseline_transitions: tuple[TransitionRule, ...], + passive_transition: TransitionFactory, + emergency_intents: tuple[str, ...] = ("request_passive", "request_emergency"), + ) -> None: + if not skills: + raise ValidationError("hot_swapping.skills", "at least one skill module", skills) + self._preparation = preparation + self._skills = {module.name: module for module in skills} + if len(self._skills) != len(skills): + raise ValidationError("hot_swapping.skills", "unique skill names", tuple(self._skills)) + self._skill_intents = {module.request_intent: module for module in skills} + if len(self._skill_intents) != len(skills): + raise ValidationError("hot_swapping.skills", "unique request intents", tuple(self._skill_intents)) + self._pending_skill: str | None = None + + states = ( + baseline.passive, + baseline.fixstand, + baseline.walk, + preparation, + *(module.state for module in skills), + ) + passive_name = baseline.passive.name + transitions = ( + *baseline_transitions, + TransitionRule(baseline.walk.name, preparation.name, ImmediateTransition), + *(TransitionRule(preparation.name, module.name, ImmediateTransition) for module in skills), + *(TransitionRule(module.name, baseline.walk.name, ImmediateTransition) for module in skills), + *( + TransitionRule(state.name, passive_name, passive_transition) + for state in states + if state.name != passive_name + and not any(rule.source == state.name and rule.target == passive_name for rule in baseline_transitions) + ), + ) + self._walk_name = baseline.walk.name + super().__init__( + joint_names=joint_names, + states={state.name: state for state in states}, + initial_state=initial_state, + transitions=transitions, + intent_targets={ + "request_fixstand": baseline.fixstand.name, + "request_walk": baseline.walk.name, + }, + emergency_intent=emergency_intents, + emergency_state=passive_name, + ) + + @property + def pending_skill(self) -> str | None: + return self._pending_skill + + def reset(self, state: RobotState) -> None: + self._pending_skill = None + super().reset(state) + + def _target_from_intents(self, command: OperatorCommand) -> str | None: + target = super()._target_from_intents(command) + if target == self._emergency_state: + self._pending_skill = None + return target + protected = {self._preparation.name, *self._skills} + if self._current in protected or (self._active is not None and self._active.target in protected): + return None + requested_modules = [self._skill_intents[intent] for intent in command.intents if intent in self._skill_intents] + if len(requested_modules) > 1 or (target is not None and requested_modules): + raise ValidationError("operator.intents", "at most one transition request", command.intents) + if not requested_modules: + return target + # Skills may only be armed from stable locomotion. Requests received in + # P/A/C/D or during a transition are deliberately ignored. + if self._current != self._walk_name or self._active is not None: + return None + module = requested_modules[0] + self._pending_skill = module.name + self._preparation.select(module.preparation) + return self._preparation.name + + def _completion_target(self, state_name: str) -> str | None: + if state_name == self._preparation.name: + if self._pending_skill is None: + raise RuntimeError("preparation completed without a pending skill") + return self._pending_skill + if state_name in self._skills: + self._pending_skill = None + return self._walk_name + return super()._completion_target(state_name) + + +__all__ = ["BaselineStates", "RobotHotSwappingController", "SkillModule"] diff --git a/motrix_deploy/src/motrix_deploy/runtime/preparation.py b/motrix_deploy/src/motrix_deploy/runtime/preparation.py new file mode 100644 index 00000000..dbeb9ebf --- /dev/null +++ b/motrix_deploy/src/motrix_deploy/runtime/preparation.py @@ -0,0 +1,142 @@ +# Copyright Motphys Technology Co., Ltd. 2025, 2026 +# SPDX-License-Identifier: Apache-2.0 + +"""Reusable measured-state preparation before a finite skill takes control.""" + +from __future__ import annotations + +from dataclasses import dataclass + +import numpy as np + +from motrix_deploy.contracts import FloatArray, JointServoCommand, RobotSpec, RobotState, float32_array +from motrix_deploy.operator import OperatorCommand +from motrix_deploy.runtime.context import ControlContext +from motrix_deploy.runtime.lifecycle import ControllerStep + + +@dataclass(frozen=True) +class SkillPreparationSpec: + """Servo target and measured readiness requirements for one skill module.""" + + joint_position: FloatArray + kp: FloatArray + kd: FloatArray + ramp_duration_s: float = 2.0 + settle_duration_s: float = 1.0 + timeout_s: float = 5.0 + max_joint_error_rad: float = 0.2 + max_joint_velocity_rad_s: float = 1.0 + max_base_tilt_rad: float = 0.5 + + def __post_init__(self) -> None: + nonnegative = ( + "ramp_duration_s", + "settle_duration_s", + "max_joint_error_rad", + "max_joint_velocity_rad_s", + "max_base_tilt_rad", + ) + for name in nonnegative: + value = getattr(self, name) + if not np.isfinite(value) or value < 0: + raise ValueError(f"{name} must be finite and non-negative") + if not np.isfinite(self.timeout_s) or self.timeout_s <= 0: + raise ValueError("timeout_s must be positive and finite") + + +class JointServoPreparationState: + """Prepare whichever skill is pending with one reusable top-level state.""" + + name = "skill_preparation" + + def __init__(self, robot: RobotSpec) -> None: + self.joint_names = robot.joint_names + self._robot = robot + self._spec: SkillPreparationSpec | None = None + self._target = np.empty(robot.joint_count, dtype=np.float32) + self._kp = np.empty(robot.joint_count, dtype=np.float32) + self._kd = np.empty(robot.joint_count, dtype=np.float32) + self._zeros = np.zeros(robot.joint_count, dtype=np.float32) + self._initial_position: FloatArray | None = None + self._ready_since: float | None = None + self._reached_ready = False + self._stop_requested = False + + @property + def spec(self) -> SkillPreparationSpec | None: + return self._spec + + def select(self, spec: SkillPreparationSpec) -> None: + """Select the preparation contract for the next requested skill.""" + joint_count = self._robot.joint_count + self._target = np.clip( + float32_array(spec.joint_position, path="skill.preparation.joint_position", shape=(joint_count,)), + self._robot.position_lower, + self._robot.position_upper, + ).astype(np.float32) + self._kp = float32_array(spec.kp, path="skill.preparation.kp", shape=(joint_count,)) + self._kd = float32_array(spec.kd, path="skill.preparation.kd", shape=(joint_count,)) + self._spec = spec + + def reset(self, state: RobotState) -> None: + if self._spec is None: + raise RuntimeError("a skill preparation spec must be selected before entering preparation") + self._initial_position = state.joint_position.copy() + self._ready_since = None + self._reached_ready = False + self._stop_requested = False + + def request_stop(self) -> None: + self._stop_requested = True + + def hold_command(self) -> JointServoCommand: + """Hold the selected target after readiness has been reached.""" + return JointServoCommand(self._target, self._zeros, self._zeros, self._kp, self._kd) + + def step(self, state: RobotState, context: ControlContext[OperatorCommand]) -> ControllerStep: + if self._stop_requested: + return ControllerStep(complete=True) + assert self._spec is not None and self._initial_position is not None + spec = self._spec + elapsed_time_s = context.elapsed_time_s + x, y, _, _ = state.base_orientation_xyzw + tilt = float(np.arccos(np.clip(1 - 2 * (float(x) ** 2 + float(y) ** 2), -1, 1))) + metrics = { + "max_joint_error_rad": float(np.max(np.abs(state.joint_position - self._target))), + "max_joint_velocity_rad_s": float(np.max(np.abs(state.joint_velocity))), + "base_tilt_rad": tilt, + } + if tilt > spec.max_base_tilt_rad: + return ControllerStep(metrics=metrics, error=f"unsafe base tilt during preparation: {metrics}") + ready = ( + elapsed_time_s + 1e-9 >= spec.ramp_duration_s + and metrics["max_joint_error_rad"] <= spec.max_joint_error_rad + and metrics["max_joint_velocity_rad_s"] <= spec.max_joint_velocity_rad_s + ) + if ready: + if self._ready_since is None: + self._ready_since = elapsed_time_s + else: + self._ready_since = None + if ( + self._ready_since is not None + and elapsed_time_s - self._ready_since + 1e-9 >= spec.settle_duration_s + and (self._reached_ready or elapsed_time_s <= spec.timeout_s + 1e-9) + ): + self._reached_ready = True + return ControllerStep(complete=True, metrics=metrics) + if not self._reached_ready and elapsed_time_s + 1e-9 >= spec.timeout_s: + return ControllerStep(metrics=metrics, error=f"preparation timed out: {metrics}") + fraction = ( + np.clip((elapsed_time_s + context.dt_s) / spec.ramp_duration_s, 0, 1) if spec.ramp_duration_s > 0 else 1 + ) + target = self._initial_position + np.float32(fraction) * (self._target - self._initial_position) + target = np.clip(target, self._robot.position_lower, self._robot.position_upper).astype(np.float32) + return ControllerStep( + command=JointServoCommand(target, self._zeros, self._zeros, self._kp, self._kd), + metrics=metrics, + ) + + +__all__ = ["JointServoPreparationState", "SkillPreparationSpec"] diff --git a/motrix_deploy/src/motrix_deploy/runtime/state_machine.py b/motrix_deploy/src/motrix_deploy/runtime/state_machine.py new file mode 100644 index 00000000..9464002c --- /dev/null +++ b/motrix_deploy/src/motrix_deploy/runtime/state_machine.py @@ -0,0 +1,383 @@ +# Copyright Motphys Technology Co., Ltd. 2025, 2026 +# SPDX-License-Identifier: Apache-2.0 + +"""Backend-neutral persistent control states and command transitions.""" + +from __future__ import annotations + +from collections import deque +from collections.abc import Callable, Mapping +from dataclasses import dataclass, replace +from typing import Protocol + +import numpy as np + +from motrix_deploy.contracts import JointServoCommand, JointTorqueCommand, RobotCommand, RobotState +from motrix_deploy.errors import ValidationError +from motrix_deploy.operator import OperatorCommand +from motrix_deploy.runtime.context import ControlContext +from motrix_deploy.runtime.lifecycle import ControllerStep + + +class ControlState(Protocol): + """One persistent state that produces commands in its declared joint order.""" + + name: str + joint_names: tuple[str, ...] + + def reset(self, state: RobotState) -> None: ... + + def step(self, state: RobotState, context: ControlContext[OperatorCommand]) -> ControllerStep: ... + + def request_stop(self) -> None: ... + + +class CommandTransition(Protocol): + """Stateful blend from a frozen source command to live target commands.""" + + def start(self, source: RobotCommand, target: RobotCommand) -> None: ... + + def step(self, target: RobotCommand, elapsed_time_s: float) -> tuple[RobotCommand, bool]: ... + + +TransitionFactory = Callable[[], CommandTransition] + + +@dataclass(frozen=True) +class TransitionRule: + """One legal directed state edge and the command blend used on that edge.""" + + source: str + target: str + create: TransitionFactory + + +def _quintic_smoothstep(value: float) -> np.float32: + s = np.float32(np.clip(value, 0.0, 1.0)) + return np.float32(10.0 * s**3 - 15.0 * s**4 + 6.0 * s**5) + + +def _blend_array(source: np.ndarray, target: np.ndarray, alpha: np.float32) -> np.ndarray: + return (source + alpha * (target - source)).astype(np.float32) + + +class SmoothServoTransition: + """Blend position, velocity, feed-forward torque and gains with zero endpoint slope.""" + + def __init__(self, duration_s: float) -> None: + if not np.isfinite(duration_s) or duration_s <= 0: + raise ValidationError("transition.duration_s", "a positive finite value", duration_s) + self.duration_s = float(duration_s) + self._source: JointServoCommand | None = None + + def start(self, source: RobotCommand, target: RobotCommand) -> None: + if not isinstance(source, JointServoCommand) or not isinstance(target, JointServoCommand): + raise ValidationError("transition.command", "joint-servo source and target commands", (source, target)) + if source.joint_position.shape != target.joint_position.shape: + raise ValidationError( + "transition.command.shape", str(source.joint_position.shape), target.joint_position.shape + ) + self._source = source + + def step(self, target: RobotCommand, elapsed_time_s: float) -> tuple[RobotCommand, bool]: + if self._source is None: + raise RuntimeError("transition must be started before stepping") + if not isinstance(target, JointServoCommand): + raise ValidationError("transition.target", "a joint-servo command", type(target).__name__) + alpha = _quintic_smoothstep(elapsed_time_s / self.duration_s) + source = self._source + command = JointServoCommand( + joint_position=_blend_array(source.joint_position, target.joint_position, alpha), + joint_velocity=_blend_array(source.joint_velocity, target.joint_velocity, alpha), + feedforward_torque=_blend_array(source.feedforward_torque, target.feedforward_torque, alpha), + kp=_blend_array(source.kp, target.kp, alpha), + kd=_blend_array(source.kd, target.kd, alpha), + ) + return command, elapsed_time_s + 1e-9 >= self.duration_s + + +class AdaptiveServoTransition(SmoothServoTransition): + """Choose duration from the largest commanded joint displacement.""" + + def __init__(self, min_duration_s: float, max_duration_s: float, max_joint_speed_rad_s: float) -> None: + if not 0 < min_duration_s <= max_duration_s: + raise ValidationError( + "transition.duration_range", "0 < min_duration_s <= max_duration_s", (min_duration_s, max_duration_s) + ) + if not np.isfinite(max_joint_speed_rad_s) or max_joint_speed_rad_s <= 0: + raise ValidationError("transition.max_joint_speed_rad_s", "a positive finite value", max_joint_speed_rad_s) + self.min_duration_s = float(min_duration_s) + self.max_duration_s = float(max_duration_s) + self.max_joint_speed_rad_s = float(max_joint_speed_rad_s) + super().__init__(min_duration_s) + + def start(self, source: RobotCommand, target: RobotCommand) -> None: + super().start(source, target) + assert isinstance(source, JointServoCommand) and isinstance(target, JointServoCommand) + displacement = float(np.max(np.abs(target.joint_position - source.joint_position))) + self.duration_s = float( + np.clip(displacement / self.max_joint_speed_rad_s, self.min_duration_s, self.max_duration_s) + ) + + +class ImmediateTransition: + """Select the target command without blending, for emergency paths.""" + + def start(self, source: RobotCommand, target: RobotCommand) -> None: + del source, target + + def step(self, target: RobotCommand, elapsed_time_s: float) -> tuple[RobotCommand, bool]: + del elapsed_time_s + return target, True + + +@dataclass +class _ActiveTransition: + target: str + transition: CommandTransition + origin_s: float + + +class StateMachineController: + """Run persistent states while keeping backend command order and lifecycle stable.""" + + def __init__( + self, + *, + joint_names: tuple[str, ...], + states: Mapping[str, ControlState], + initial_state: str, + transitions: tuple[TransitionRule, ...], + intent_targets: Mapping[str, str], + completion_targets: Mapping[str, str] | None = None, + emergency_intent: str | tuple[str, ...] = "request_emergency", + emergency_state: str = "emergency_damping", + ) -> None: + if not joint_names or len(joint_names) != len(set(joint_names)): + raise ValidationError("state_machine.joint_names", "unique joint names", joint_names) + self.joint_names = joint_names + self.states = dict(states) + if set(self.states) != {state.name for state in self.states.values()}: + raise ValidationError("state_machine.states", "mapping keys equal state names", tuple(self.states)) + if initial_state not in self.states: + raise ValidationError("state_machine.initial_state", "a configured state", initial_state) + for state in self.states.values(): + if set(state.joint_names) != set(joint_names): + raise ValidationError( + f"state_machine.states.{state.name}.joint_names", "the canonical joint-name set", state.joint_names + ) + self._rules = {(rule.source, rule.target): rule.create for rule in transitions} + if len(self._rules) != len(transitions): + raise ValidationError("state_machine.transitions", "unique directed edges", transitions) + for source, target in self._rules: + if source not in self.states or target not in self.states: + raise ValidationError("state_machine.transitions", "edges between configured states", (source, target)) + self._intent_targets = dict(intent_targets) + self._completion_targets = dict(completion_targets or {}) + for target in (*self._intent_targets.values(), *self._completion_targets.values(), emergency_state): + if target not in self.states: + raise ValidationError("state_machine.target", "a configured state", target) + self._initial_state = initial_state + self._current = initial_state + self._emergency_intents = ( + frozenset({emergency_intent}) if isinstance(emergency_intent, str) else frozenset(emergency_intent) + ) + self._emergency_state = emergency_state + self._active: _ActiveTransition | None = None + self._queued_targets: list[str] = [] + self._last_command: RobotCommand | None = None + self._state_origin_s = 0.0 + self._state_step = 0 + self._stop_requested = False + + @property + def current_state(self) -> str: + return self._current + + @property + def target_state(self) -> str | None: + return None if self._active is None else self._active.target + + def reset(self, state: RobotState) -> None: + self._current = self._initial_state + self._active = None + self._queued_targets.clear() + self._last_command = None + self._state_origin_s = 0.0 + self._state_step = 0 + self._stop_requested = False + self.states[self._current].reset(state) + + def request_stop(self) -> None: + self._stop_requested = True + + def _state_context( + self, context: ControlContext[OperatorCommand], command: OperatorCommand | None = None + ) -> ControlContext[OperatorCommand]: + return ControlContext( + step=self._state_step, + elapsed_time_s=max(0.0, context.elapsed_time_s - self._state_origin_s), + command=context.command if command is None else command, + dt_s=context.dt_s, + ) + + def _canonical_command(self, command: RobotCommand, state_name: str) -> RobotCommand: + source_names = self.states[state_name].joint_names + indices = np.asarray([source_names.index(name) for name in self.joint_names], dtype=np.int64) + if isinstance(command, JointServoCommand): + return JointServoCommand( + command.joint_position[indices].astype(np.float32), + command.joint_velocity[indices].astype(np.float32), + command.feedforward_torque[indices].astype(np.float32), + command.kp[indices].astype(np.float32), + command.kd[indices].astype(np.float32), + ) + if isinstance(command, JointTorqueCommand): + return JointTorqueCommand(command.torque[indices].astype(np.float32)) + raise ValidationError("state_machine.command", "a RobotCommand", type(command).__name__) + + def _target_from_intents(self, command: OperatorCommand) -> str | None: + if self._emergency_intents.intersection(command.intents): + return self._emergency_state + targets = {self._intent_targets[intent] for intent in command.intents if intent in self._intent_targets} + if len(targets) > 1: + raise ValidationError("operator.intents", "at most one state transition request", command.intents) + return next(iter(targets), None) + + def _completion_target(self, state_name: str) -> str | None: + return self._completion_targets.get(state_name) + + def _path_to(self, source: str, target: str) -> list[str]: + """Return the shortest configured route, preserving declaration order.""" + if source == target: + return [] + frontier: deque[tuple[str, list[str]]] = deque([(source, [])]) + visited = {source} + while frontier: + node, path = frontier.popleft() + for edge_source, edge_target in self._rules: + if edge_source != node or edge_target in visited: + continue + next_path = [*path, edge_target] + if edge_target == target: + return next_path + visited.add(edge_target) + frontier.append((edge_target, next_path)) + raise ValidationError("state_machine.transition", "a configured route", (source, target)) + + def _begin_routed_transition( + self, + target: str, + state: RobotState, + context: ControlContext[OperatorCommand], + source_command: RobotCommand, + ) -> ControllerStep: + path = self._path_to(self._current, target) + if not path: + return ControllerStep(command=source_command) + self._queued_targets = path[1:] + return self._begin_transition(path[0], state, context, source_command) + + def _begin_transition( + self, + target: str, + state: RobotState, + context: ControlContext[OperatorCommand], + source_command: RobotCommand, + ) -> ControllerStep: + if target == self._current: + return ControllerStep(command=source_command) + factory = self._rules.get((self._current, target)) + if factory is None: + raise ValidationError("state_machine.transition", "a configured legal edge", (self._current, target)) + target_state = self.states[target] + target_state.reset(state) + self._state_origin_s = context.elapsed_time_s + self._state_step = 0 + target_step = target_state.step(state, self._state_context(context)) + if target_step.error is not None: + return target_step + if target_step.command is None: + if not target_step.complete: + return target_step + self._current = target + completion_target = self._completion_target(target) + if completion_target is None: + return target_step + return self._begin_transition(completion_target, state, context, source_command) + target_command = self._canonical_command(target_step.command, target) + transition = factory() + transition.start(source_command, target_command) + self._active = _ActiveTransition(target=target, transition=transition, origin_s=context.elapsed_time_s) + blended, complete = transition.step(target_command, 0.0) + if complete: + self._current = target + self._active = None + self._state_step += 1 + return replace(target_step, command=blended, complete=False) + + def step(self, state: RobotState, context: ControlContext[OperatorCommand]) -> ControllerStep: + if self._stop_requested: + return ControllerStep(complete=True) + operator = context.command + if not isinstance(operator, OperatorCommand): + raise ValidationError("state_machine.command", "an OperatorCommand", type(operator).__name__) + requested = self._target_from_intents(operator) + if self._active is not None: + if requested == self._emergency_state and self._active.target != self._emergency_state: + assert self._last_command is not None + self._current = self._active.target + self._active = None + self._queued_targets.clear() + return self._begin_routed_transition(requested, state, context, self._last_command) + target = self._active.target + decision = self.states[target].step(state, self._state_context(context)) + if decision.error is not None or decision.command is None: + return decision + target_command = self._canonical_command(decision.command, target) + output, complete = self._active.transition.step( + target_command, context.elapsed_time_s - self._active.origin_s + ) + self._last_command = output + self._state_step += 1 + if complete: + self._current = target + self._active = None + return replace(decision, command=output, complete=False) + + decision = self.states[self._current].step(state, self._state_context(context)) + if decision.error is not None: + return decision + if decision.command is None: + if decision.complete: + target = requested if requested is not None else self._completion_target(self._current) + if target is None: + return decision + if self._last_command is None: + raise ValidationError("state_machine.command", "a command before state completion", None) + return self._begin_transition(target, state, context, self._last_command) + raise ValidationError("state_machine.command", "one command per active interval", None) + command = self._canonical_command(decision.command, self._current) + self._last_command = command + self._state_step += 1 + target = requested + if target == self._emergency_state: + self._queued_targets.clear() + elif target is None and self._queued_targets: + target = self._queued_targets.pop(0) + if target is None and decision.complete: + target = self._completion_target(self._current) + if target is not None: + return self._begin_routed_transition(target, state, context, command) + return replace(decision, command=command, complete=False) + + +__all__ = [ + "AdaptiveServoTransition", + "CommandTransition", + "ControlState", + "ImmediateTransition", + "SmoothServoTransition", + "StateMachineController", + "TransitionRule", +] diff --git a/motrix_deploy/src/motrix_deploy/task.py b/motrix_deploy/src/motrix_deploy/task.py index afb37ead..37cd5ed7 100644 --- a/motrix_deploy/src/motrix_deploy/task.py +++ b/motrix_deploy/src/motrix_deploy/task.py @@ -9,6 +9,7 @@ from motrix_deploy.artifact.schema import TaskSpec from motrix_deploy.contracts import FloatArray, RobotSpec, RobotState +from motrix_deploy.operator import OperatorProfileCfg from motrix_deploy.policy import Policy from motrix_deploy.runtime.context import ControlContext from motrix_deploy.runtime.lifecycle import ControllerStep @@ -62,6 +63,11 @@ def prepare( self.validate_command(None) return None + def configure_operator(self, profile: OperatorProfileCfg | None) -> None: + """Accept task-owned command wiring before ``prepare`` assembles its binding.""" + if profile is not None and profile.planar_velocity is not None: + raise ValueError(f"{type(self).__name__} does not support planar velocity operator input") + @property def operator_hint(self) -> str | None: """One-line operator key reference, or None when no operator input is attached.""" diff --git a/motrix_deploy/tests/test_hot_swapping.py b/motrix_deploy/tests/test_hot_swapping.py new file mode 100644 index 00000000..903221d1 --- /dev/null +++ b/motrix_deploy/tests/test_hot_swapping.py @@ -0,0 +1,151 @@ +# Copyright Motphys Technology Co., Ltd. 2025, 2026 +# SPDX-License-Identifier: Apache-2.0 + +from dataclasses import dataclass + +import numpy as np + +from motrix_deploy.contracts import JointServoCommand, RobotSpec, RobotState +from motrix_deploy.operator import OperatorCommand +from motrix_deploy.runtime.context import ControlContext +from motrix_deploy.runtime.hot_swapping import BaselineStates, RobotHotSwappingController, SkillModule +from motrix_deploy.runtime.lifecycle import ControllerStep +from motrix_deploy.runtime.preparation import JointServoPreparationState, SkillPreparationSpec +from motrix_deploy.runtime.state_machine import ImmediateTransition, TransitionRule + + +@dataclass +class _State: + name: str + joint_names: tuple[str, ...] + target: float + complete_after: int | None = None + + def reset(self, state: RobotState) -> None: + del state + self.steps = 0 + + def request_stop(self) -> None: + pass + + def step(self, state: RobotState, context: ControlContext[OperatorCommand]) -> ControllerStep: + del state, context + self.steps += 1 + position = np.full(2, self.target, dtype=np.float32) + zeros = np.zeros(2, dtype=np.float32) + return ControllerStep( + command=JointServoCommand(position, zeros, zeros, np.ones(2, dtype=np.float32), zeros), + complete=self.complete_after is not None and self.steps > self.complete_after, + ) + + +def _robot() -> RobotSpec: + return RobotSpec( + base_link_name="base", + joint_names=("a", "b"), + default_joint_position=np.zeros(2, dtype=np.float32), + position_lower=np.full(2, -2, dtype=np.float32), + position_upper=np.full(2, 2, dtype=np.float32), + torque_limit=np.ones(2, dtype=np.float32), + ) + + +def _state() -> RobotState: + return RobotState( + sample_time_ns=0, + receive_time_ns=0, + joint_position=np.zeros(2, dtype=np.float32), + joint_velocity=np.zeros(2, dtype=np.float32), + base_orientation_xyzw=np.asarray([0, 0, 0, 1], dtype=np.float32), + base_angular_velocity=np.zeros(3, dtype=np.float32), + base_linear_acceleration=np.zeros(3, dtype=np.float32), + ) + + +def _context(step: int, intent: str | None = None) -> ControlContext[OperatorCommand]: + intents = frozenset() if intent is None else frozenset({intent}) + return ControlContext(step, step * 0.1, OperatorCommand(intents), 0.1) + + +def _machine(initial_state: str = "walk") -> RobotHotSwappingController: + robot = _robot() + passive = _State("passive", robot.joint_names, 0.0) + fixstand = _State("fixstand", robot.joint_names, 0.1) + walk = _State("walk", robot.joint_names, 0.2) + wave = _State("wave", robot.joint_names, 0.3, complete_after=1) + bow = _State("bow", robot.joint_names, 0.4, complete_after=1) + preparation = JointServoPreparationState(robot) + preparation_spec = SkillPreparationSpec( + joint_position=np.zeros(2, dtype=np.float32), + kp=np.ones(2, dtype=np.float32), + kd=np.ones(2, dtype=np.float32), + ramp_duration_s=0.1, + settle_duration_s=0.0, + ) + return RobotHotSwappingController( + joint_names=robot.joint_names, + baseline=BaselineStates(passive, fixstand, walk), + preparation=preparation, + skills=( + SkillModule("wave", wave, preparation_spec, "request_wave"), + SkillModule("bow", bow, preparation_spec, "request_bow"), + ), + initial_state=initial_state, + baseline_transitions=( + TransitionRule("passive", "fixstand", ImmediateTransition), + TransitionRule("fixstand", "walk", ImmediateTransition), + TransitionRule("walk", "fixstand", ImmediateTransition), + ), + passive_transition=ImmediateTransition, + ) + + +def test_skill_request_uses_one_shared_preparation_state_then_returns_to_walk(): + machine = _machine() + state = _state() + machine.reset(state) + + machine.step(state, _context(0)) + machine.step(state, _context(1, "request_wave")) + assert machine.current_state == "skill_preparation" + assert machine.pending_skill == "wave" + + machine.step(state, _context(2)) + assert machine.current_state == "wave" + machine.step(state, _context(3)) + machine.step(state, _context(4)) + assert machine.current_state == "walk" + assert machine.pending_skill is None + + +def test_multiple_skills_share_preparation_and_select_the_pending_destination(): + machine = _machine() + state = _state() + machine.reset(state) + + preparation = machine.states["skill_preparation"] + machine.step(state, _context(0)) + machine.step(state, _context(1, "request_bow")) + assert machine.states["skill_preparation"] is preparation + assert machine.current_state == "skill_preparation" + assert machine.pending_skill == "bow" + + machine.step(state, _context(2)) + assert machine.current_state == "bow" + + +def test_skill_request_is_ignored_until_walk_and_passive_preempts_preparation(): + machine = _machine(initial_state="fixstand") + state = _state() + machine.reset(state) + + machine.step(state, _context(0, "request_wave")) + assert machine.current_state == "fixstand" + assert machine.pending_skill is None + + machine.step(state, _context(1, "request_walk")) + machine.step(state, _context(2, "request_wave")) + assert machine.current_state == "skill_preparation" + machine.step(state, _context(3, "request_passive")) + assert machine.current_state == "passive" + assert machine.pending_skill is None diff --git a/motrix_deploy/tests/test_operator_binding.py b/motrix_deploy/tests/test_operator_binding.py new file mode 100644 index 00000000..541bf337 --- /dev/null +++ b/motrix_deploy/tests/test_operator_binding.py @@ -0,0 +1,91 @@ +# Copyright Motphys Technology Co., Ltd. 2025, 2026 +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +from motrix_deploy.operator import ( + ButtonGestureCfg, + OperatorCommandBinding, + OperatorProfileCfg, + PlanarVelocityOperatorCfg, +) +from motrix_env_core.input import GamePadDevice, KeyboardDevice + + +class _Keyboard(KeyboardDevice): + def __init__(self, frames): + self.frames = iter(frames) + self.current = frozenset() + self.previous = frozenset() + + def poll(self): + self.previous = self.current + self.current = frozenset(next(self.frames)) + + def is_key_down(self, key): + return key in self.current and key not in self.previous + + def is_key_up(self, key): + return key not in self.current and key in self.previous + + def is_pressing(self, key): + return key in self.current + + +class _GamePad(GamePadDevice): + def __init__(self, frames): + self.frames = iter(frames) + self.current = ({}, frozenset()) + self.previous = self.current + + def poll(self): + self.previous = self.current + self.current = next(self.frames) + + def axis_value(self, axis): + return self.current[0].get(axis, 0.0) + + def is_button_down(self, button): + return button in self.current[1] and button not in self.previous[1] + + def is_button_up(self, button): + return button not in self.current[1] and button in self.previous[1] + + def is_button_pressing(self, button): + return button in self.current[1] + + +def test_keyboard_binding_produces_intent_and_velocity_from_one_polled_frame(): + device = _Keyboard([set(), {"1", "w"}]) + profile = OperatorProfileCfg(intents={"request_walk": ButtonGestureCfg(pressed="1")}) + binding = OperatorCommandBinding(device, profile, command_lower=(-1, -2, -3), command_upper=(1, 2, 3)) + assert not binding.read_command().intents + command = binding.read_command() + assert command.intents == frozenset({"request_walk"}) + np.testing.assert_array_equal(command.planar_velocity.values, [[1, 0, 0]]) + + +def test_gamepad_binding_applies_deadzone_inversion_range_and_gesture(): + device = _GamePad( + [ + ({}, frozenset()), + ({"ly": 1.0, "lx": 0.5, "rx": -1.0}, frozenset({"RB", "X"})), + ] + ) + profile = OperatorProfileCfg( + intents={"request_walk": ButtonGestureCfg(held=["RB"], pressed="X")}, + planar_velocity=PlanarVelocityOperatorCfg( + linear_x_axis="ly", + linear_y_axis="lx", + yaw_axis="rx", + invert_linear_y=True, + invert_yaw=True, + deadzone=0.0, + range_scale=[0.25, 0.5, 1.0], + ), + ) + binding = OperatorCommandBinding(device, profile, command_lower=(-1, -2, -3), command_upper=(1, 2, 3)) + binding.read_command() + command = binding.read_command() + assert command.intents == frozenset({"request_walk"}) + np.testing.assert_array_equal(command.planar_velocity.values, [[0.25, -0.5, 3.0]]) diff --git a/motrix_deploy/tests/test_package.py b/motrix_deploy/tests/test_package.py index 5005b144..13c0f403 100644 --- a/motrix_deploy/tests/test_package.py +++ b/motrix_deploy/tests/test_package.py @@ -3,11 +3,24 @@ """Package boundary and command-line smoke tests.""" +import re import subprocess import sys +from pathlib import Path import pytest +import motrix_deploy + +_PYPROJECT = Path(__file__).resolve().parents[1] / "pyproject.toml" + + +def test_package_version() -> None: + """The boundary version mirrors the release version declared in pyproject.toml.""" + declared = re.search(r'^version = "(.+)"$', _PYPROJECT.read_text(), re.MULTILINE) + assert declared is not None, f"Missing version in {_PYPROJECT}" + assert motrix_deploy.__version__ == declared.group(1) + @pytest.mark.integration def test_cli_help() -> None: diff --git a/motrix_deploy/tests/test_state_machine.py b/motrix_deploy/tests/test_state_machine.py new file mode 100644 index 00000000..c001c772 --- /dev/null +++ b/motrix_deploy/tests/test_state_machine.py @@ -0,0 +1,157 @@ +# Copyright Motphys Technology Co., Ltd. 2025, 2026 +# SPDX-License-Identifier: Apache-2.0 + +from dataclasses import dataclass + +import numpy as np + +from motrix_deploy.contracts import JointServoCommand, RobotState +from motrix_deploy.operator import OperatorCommand +from motrix_deploy.runtime.context import ControlContext +from motrix_deploy.runtime.lifecycle import ControllerStep +from motrix_deploy.runtime.state_machine import ( + ImmediateTransition, + SmoothServoTransition, + StateMachineController, + TransitionRule, +) + + +@dataclass +class _State: + name: str + joint_names: tuple[str, ...] + target: tuple[float, ...] + kp: float + complete_after: int | None = None + + def reset(self, state: RobotState) -> None: + del state + self.steps = 0 + + def request_stop(self) -> None: + pass + + def step(self, state, context): + del state, context + target = np.asarray(self.target, dtype=np.float32) + zeros = np.zeros_like(target) + self.steps += 1 + return ControllerStep( + command=JointServoCommand(target, zeros, zeros, np.full_like(target, self.kp), np.full_like(target, 1.0)), + complete=self.complete_after is not None and self.steps > self.complete_after, + policy_tick=self.name == "walk", + ) + + +def _robot_state() -> RobotState: + return RobotState( + sample_time_ns=0, + receive_time_ns=0, + joint_position=np.zeros(2, dtype=np.float32), + joint_velocity=np.zeros(2, dtype=np.float32), + base_orientation_xyzw=np.asarray([0, 0, 0, 1], dtype=np.float32), + base_angular_velocity=np.zeros(3, dtype=np.float32), + base_linear_acceleration=np.zeros(3, dtype=np.float32), + ) + + +def _context(step, elapsed, intent=None): + command = OperatorCommand(frozenset() if intent is None else frozenset({intent})) + return ControlContext(step, elapsed, command, 0.1) + + +def test_transition_blends_live_target_and_reorders_by_joint_name(): + passive = _State("passive", ("hip", "knee"), (0.0, 0.0), 0.0) + walk = _State("walk", ("knee", "hip"), (2.0, 1.0), 10.0) + machine = StateMachineController( + joint_names=("hip", "knee"), + states={state.name: state for state in (passive, walk)}, + initial_state="passive", + transitions=(TransitionRule("passive", "walk", lambda: SmoothServoTransition(0.5)),), + intent_targets={"request_walk": "walk"}, + emergency_state="passive", + ) + state = _robot_state() + machine.reset(state) + first = machine.step(state, _context(0, 0.0)) + start = machine.step(state, _context(1, 0.1, "request_walk")) + middle = machine.step(state, _context(2, 0.35)) + end = machine.step(state, _context(3, 0.6)) + np.testing.assert_array_equal(first.command.joint_position, [0, 0]) + np.testing.assert_array_equal(start.command.joint_position, [0, 0]) + np.testing.assert_allclose(middle.command.joint_position, [0.5, 1.0], atol=1e-6) + np.testing.assert_array_equal(end.command.joint_position, [1, 2]) + assert middle.policy_tick and machine.current_state == "walk" + + +def test_emergency_preempts_smooth_transition_immediately(): + states = { + "fixstand": _State("fixstand", ("a", "b"), (1.0, 1.0), 20.0), + "walk": _State("walk", ("a", "b"), (2.0, 2.0), 10.0), + "emergency": _State("emergency", ("a", "b"), (0.0, 0.0), 0.0), + } + machine = StateMachineController( + joint_names=("a", "b"), + states=states, + initial_state="fixstand", + transitions=( + TransitionRule("fixstand", "walk", lambda: SmoothServoTransition(0.5)), + TransitionRule("walk", "emergency", ImmediateTransition), + ), + intent_targets={"request_walk": "walk"}, + emergency_state="emergency", + ) + state = _robot_state() + machine.reset(state) + machine.step(state, _context(0, 0.0)) + machine.step(state, _context(1, 0.1, "request_walk")) + emergency = machine.step(state, _context(2, 0.2, "request_emergency")) + np.testing.assert_array_equal(emergency.command.kp, [0, 0]) + assert machine.current_state == "emergency" and machine.target_state is None + + +def test_completed_policy_returns_to_safe_intermediate_state(): + fixstand = _State("fixstand", ("a", "b"), (1.0, 1.0), 20.0) + motion = _State("motion", ("a", "b"), (2.0, 2.0), 10.0, complete_after=1) + machine = StateMachineController( + joint_names=("a", "b"), + states={state.name: state for state in (fixstand, motion)}, + initial_state="motion", + transitions=(TransitionRule("motion", "fixstand", lambda: SmoothServoTransition(0.5)),), + intent_targets={}, + completion_targets={"motion": "fixstand"}, + emergency_state="fixstand", + ) + state = _robot_state() + machine.reset(state) + assert not machine.step(state, _context(0, 0.0)).complete + assert machine.step(state, _context(1, 0.1)).command is not None + assert machine.target_state == "fixstand" + + +def test_policy_switch_is_routed_through_safe_intermediate_state(): + states = { + name: _State(name, ("a", "b"), target, 10.0) + for name, target in (("walk", (1.0, 1.0)), ("fixstand", (0.0, 0.0)), ("motion", (2.0, 2.0))) + } + machine = StateMachineController( + joint_names=("a", "b"), + states=states, + initial_state="walk", + transitions=( + TransitionRule("walk", "fixstand", lambda: SmoothServoTransition(0.1)), + TransitionRule("fixstand", "motion", lambda: SmoothServoTransition(0.1)), + ), + intent_targets={"request_motion": "motion"}, + emergency_state="fixstand", + ) + state = _robot_state() + machine.reset(state) + machine.step(state, _context(0, 0.0)) + machine.step(state, _context(1, 0.1, "request_motion")) + assert machine.target_state == "fixstand" + machine.step(state, _context(2, 0.2)) + assert machine.current_state == "fixstand" + machine.step(state, _context(3, 0.3)) + assert machine.target_state == "motion" From 614223d55b110706790d1989afcea139bd1dbb8b Mon Sep 17 00:00:00 2001 From: MrHu <1962951972@qq.com> Date: Mon, 19 Oct 2026 17:20:57 +0800 Subject: [PATCH 2/9] feat(deploy): add program application configs and deploy presets --- motrix_deploy/src/motrix_deploy/cli.py | 102 +++++++++++++++++- .../motrix_deploy/config/program-real.yaml | 24 +++++ .../src/motrix_deploy/config/program.yaml | 17 +++ 3 files changed, 139 insertions(+), 4 deletions(-) create mode 100644 motrix_deploy/src/motrix_deploy/config/program-real.yaml create mode 100644 motrix_deploy/src/motrix_deploy/config/program.yaml diff --git a/motrix_deploy/src/motrix_deploy/cli.py b/motrix_deploy/src/motrix_deploy/cli.py index 9dcbf153..a564d103 100644 --- a/motrix_deploy/src/motrix_deploy/cli.py +++ b/motrix_deploy/src/motrix_deploy/cli.py @@ -14,8 +14,9 @@ from omegaconf.errors import OmegaConfBaseException from motrix_deploy.artifact.io import inspect_artifact, read_artifact -from motrix_deploy.config import DeployRunConfig, SimRuntimeCfg +from motrix_deploy.config import DeployRunConfig, ProgramRunConfig, SimRuntimeCfg from motrix_deploy.errors import ArtifactError, ValidationError +from motrix_deploy.operator import OperatorCommandBinding from motrix_deploy.runtime.control import ControlSession from motrix_deploy.runtime.factory import RuntimeCreateContext, create_hardware_runtime, create_simulation_runtime from motrix_deploy.task import create_task, load_task_type @@ -52,6 +53,7 @@ def run(cfg: DeployRunConfig) -> int: device = runtime.keyboard or runtime.gamepad try: manifest.robot.validate_compatible(robot.spec) + task.configure_operator(getattr(cfg.runtime, "operator", None)) command_binding = task.prepare(simulation=simulation, device=device, spawn_pose=spawn_pose) session = ControlSession( controller=task, @@ -99,6 +101,80 @@ def _run_config(cfg: DictConfig) -> None: _hydra_main = hydra.main(version_base=None, config_path="pkg://motrix_deploy.config", config_name="deploy")(_run_config) +def run_program(cfg: ProgramRunConfig) -> int: + """Run one persistent multi-policy program on the selected backend.""" + from motrix_deploy.program import create_program + + program = create_program(cfg.program) + simulation = isinstance(cfg.runtime, SimRuntimeCfg) + if simulation: + runtime = create_simulation_runtime(cfg.runtime.backend, cfg.runtime.build_runtime_config()) + else: + runtime = create_hardware_runtime( + cfg.runtime.backend, + cfg.runtime, + RuntimeCreateContext(robot=program.robot, control=program.control), + ) + try: + program.robot.validate_compatible(runtime.robot.spec) + profile = getattr(cfg.runtime, "operator", None) or program.operator + command_binding = ( + OperatorCommandBinding( + runtime.keyboard or runtime.gamepad, + profile, + command_lower=program.command_lower, + command_upper=program.command_upper, + ) + if (runtime.keyboard or runtime.gamepad) is not None + else program.prepare(None) + ) + session = ControlSession( + controller=program.controller, + robot=runtime.robot, + command_binding=command_binding, + period_s=program.control.period_s, + state_timeout_s=program.control.state_timeout_s, + ) + runtime.bind_session(session) + except (ValidationError, ValueError): + runtime.close() + raise + with runtime: + result = runtime.run() + print(json.dumps(result.to_dict(), indent=2, sort_keys=True)) + return 0 if result.success else 1 + + +def _run_program_config(cfg: DictConfig) -> None: + try: + typed_cfg = OmegaConf.to_object(OmegaConf.merge(OmegaConf.structured(ProgramRunConfig), cfg)) + if not isinstance(typed_cfg, ProgramRunConfig): + raise TypeError(f"Expected ProgramRunConfig, got {type(typed_cfg).__name__}") + exit_code = run_program(typed_cfg) + except (ArtifactError, OmegaConfBaseException, RuntimeError, TypeError, ValidationError, ValueError) as error: + print(json.dumps({"valid": False, "error": str(error)}, sort_keys=True), file=sys.stderr) + raise SystemExit(2) from error + if exit_code: + raise SystemExit(exit_code) + + +_hydra_program_main = hydra.main(version_base=None, config_path="pkg://motrix_deploy.config", config_name="program")( + _run_program_config +) + +_hydra_program_real_main = hydra.main( + version_base=None, config_path="pkg://motrix_deploy.config", config_name="program-real" +)(_run_program_config) + +# deploy= aliases: one flag selects a whole application configuration. +# The simulation application keeps the generic program entry point, so its preset +# also selects the program group option. +_DEPLOY_PRESETS = { + "g1-sim": (_hydra_program_main, ("program=g1-hot-swapping",)), + "g1-real": (_hydra_program_real_main, ()), +} + + def inspect(cfg: DictConfig) -> None: """Validate one deployment artifact without opening a backend.""" print(json.dumps(inspect_artifact(Path(cfg.artifact)), indent=2, sort_keys=True)) @@ -115,10 +191,28 @@ def _hydra_inspect_main(cfg: DictConfig) -> None: def main() -> None: """Adapt ``mxlab deploy`` arguments to the deployment Hydra commands.""" - if sys.argv[1:2] == ["inspect"]: - sys.argv = [f"{sys.argv[0]} inspect", *sys.argv[2:]] + args = sys.argv[1:] + if args[:1] == ["inspect"]: + sys.argv = [f"{sys.argv[0]} inspect", *args[1:]] _hydra_inspect_main() return - if not sys.argv[1:]: + + preset = next((argument.split("=", 1)[1] for argument in args if argument.startswith("deploy=")), None) + if preset is not None: + if preset not in _DEPLOY_PRESETS: + raise SystemExit(f"unknown deploy preset {preset!r}; choose from {sorted(_DEPLOY_PRESETS)}") + del sys.argv[1 + args.index(f"deploy={preset}")] + entry_point, implicit_arguments = _DEPLOY_PRESETS[preset] + sys.argv.extend(implicit_arguments) + entry_point() + return + + if any(argument == "program" or argument.startswith("program=") for argument in args): + if args[:1] == ["program"]: + del sys.argv[1] + _hydra_program_main() + return + + if not args: sys.argv.append("--help") _hydra_main() diff --git a/motrix_deploy/src/motrix_deploy/config/program-real.yaml b/motrix_deploy/src/motrix_deploy/config/program-real.yaml new file mode 100644 index 00000000..415feccb --- /dev/null +++ b/motrix_deploy/src/motrix_deploy/config/program-real.yaml @@ -0,0 +1,24 @@ +# Hardware deployment application: same program and artifacts as the +# simulation application, but the Unitree SDK2 DDS runtime, starting in damping. +defaults: + - runtime: g1-unitree-state-machine + - program: g1-hot-swapping + - _self_ + - override hydra/job_logging: stdout + +hydra: + output_subdir: null + run: + dir: . + sweep: + dir: . + subdir: ${hydra.job.num} + job: + chdir: false + +program: + # Hardware always starts in damping and waits for the operator. + initial_state: passive + +runtime: + network_interface: eth0 diff --git a/motrix_deploy/src/motrix_deploy/config/program.yaml b/motrix_deploy/src/motrix_deploy/config/program.yaml new file mode 100644 index 00000000..18f5b4d1 --- /dev/null +++ b/motrix_deploy/src/motrix_deploy/config/program.yaml @@ -0,0 +1,17 @@ +defaults: + - runtime: g1-sim-state-machine + - program: null + - _self_ + - override hydra/job_logging: stdout + +hydra: + output_subdir: null + run: + dir: . + sweep: + dir: . + subdir: ${hydra.job.num} + job: + chdir: false + +program: ??? From 69d1f60ff4601955bfc0ea2ff19dd58daf91f757 Mon Sep 17 00:00:00 2001 From: MrHu <1962951972@qq.com> Date: Mon, 19 Oct 2026 17:20:57 +0800 Subject: [PATCH 3/9] feat(deploy-tasks): add G1 walk/WBT hot-swapping program and walk artifact --- artifacts/g1-flat.deploy/manifest.json | 375 ++++++++++++++++++ artifacts/g1-flat.deploy/policy/model.onnx | Bin 0 -> 890337 bytes motrix_deploy_tasks/pyproject.toml | 4 + .../motrix_deploy_tasks_searchpath.py | 3 + .../src/motrix_deploy_tasks/__init__.py | 4 +- .../config/program/g1-hot-swapping.yaml | 13 + .../config/runtime/g1-sim-state-machine.yaml | 15 + .../runtime/g1-unitree-state-machine.yaml | 54 +++ .../config/task/g1-walk-flat/hardware.yaml | 57 +++ .../config/task/g1-walk-flat/sim.yaml | 19 + .../config/task/g1-wbt-dance/hardware.yaml | 37 ++ .../motrix_deploy_tasks/programs/__init__.py | 1 + .../programs/g1_hot_swapping.py | 194 +++++++++ .../state_machines/__init__.py | 1 + .../state_machines/g1_states.py | 277 +++++++++++++ .../src/motrix_deploy_tasks/tasks/g1_walk.py | 357 +++++++++++++++++ .../src/motrix_deploy_tasks/tasks/g1_wbt.py | 161 +++----- motrix_deploy_tasks/tests/test_cli.py | 61 +++ .../tests/test_g1_hot_swapping_program.py | 63 +++ 19 files changed, 1590 insertions(+), 106 deletions(-) create mode 100644 artifacts/g1-flat.deploy/manifest.json create mode 100644 artifacts/g1-flat.deploy/policy/model.onnx create mode 100644 motrix_deploy_tasks/src/motrix_deploy_tasks/config/program/g1-hot-swapping.yaml create mode 100644 motrix_deploy_tasks/src/motrix_deploy_tasks/config/runtime/g1-sim-state-machine.yaml create mode 100644 motrix_deploy_tasks/src/motrix_deploy_tasks/config/runtime/g1-unitree-state-machine.yaml create mode 100644 motrix_deploy_tasks/src/motrix_deploy_tasks/config/task/g1-walk-flat/hardware.yaml create mode 100644 motrix_deploy_tasks/src/motrix_deploy_tasks/config/task/g1-walk-flat/sim.yaml create mode 100644 motrix_deploy_tasks/src/motrix_deploy_tasks/config/task/g1-wbt-dance/hardware.yaml create mode 100644 motrix_deploy_tasks/src/motrix_deploy_tasks/programs/__init__.py create mode 100644 motrix_deploy_tasks/src/motrix_deploy_tasks/programs/g1_hot_swapping.py create mode 100644 motrix_deploy_tasks/src/motrix_deploy_tasks/state_machines/__init__.py create mode 100644 motrix_deploy_tasks/src/motrix_deploy_tasks/state_machines/g1_states.py create mode 100644 motrix_deploy_tasks/src/motrix_deploy_tasks/tasks/g1_walk.py create mode 100644 motrix_deploy_tasks/tests/test_g1_hot_swapping_program.py diff --git a/artifacts/g1-flat.deploy/manifest.json b/artifacts/g1-flat.deploy/manifest.json new file mode 100644 index 00000000..8ee18e8a --- /dev/null +++ b/artifacts/g1-flat.deploy/manifest.json @@ -0,0 +1,375 @@ +{ + "control": { + "angular_velocity_frame": "body", + "base_orientation": "body_to_world", + "mode": "joint_servo", + "period_s": 0.02, + "quaternion_order": "xyzw", + "state_timeout_s": 0.1 + }, + "payloads": [], + "policy": { + "component_version": "onnx/v1", + "input": { + "dtype": "float32", + "name": "obs", + "shape": [ + 1, + 100 + ] + }, + "output": { + "dtype": "float32", + "name": "actions", + "shape": [ + 1, + 29 + ] + }, + "payload_path": "policy/model.onnx", + "sha256": "21d8aa4c77e5ba7ee3876974c5f28223b284da33544921a20286e0a091b2a54c" + }, + "robot": { + "base_link_name": "pelvis", + "default_joint_position": [ + -0.31200000643730164, + 0.0, + 0.0, + 0.6690000295639038, + -0.3630000054836273, + 0.0, + -0.31200000643730164, + 0.0, + 0.0, + 0.6690000295639038, + -0.3630000054836273, + 0.0, + 0.0, + 0.0, + 0.0, + 0.20000000298023224, + 0.20000000298023224, + 0.0, + 0.6000000238418579, + 0.0, + 0.0, + 0.0, + 0.20000000298023224, + -0.20000000298023224, + 0.0, + 0.6000000238418579, + 0.0, + 0.0, + 0.0 + ], + "joint_names": [ + "left_hip_pitch_joint", + "left_hip_roll_joint", + "left_hip_yaw_joint", + "left_knee_joint", + "left_ankle_pitch_joint", + "left_ankle_roll_joint", + "right_hip_pitch_joint", + "right_hip_roll_joint", + "right_hip_yaw_joint", + "right_knee_joint", + "right_ankle_pitch_joint", + "right_ankle_roll_joint", + "waist_yaw_joint", + "waist_roll_joint", + "waist_pitch_joint", + "left_shoulder_pitch_joint", + "left_shoulder_roll_joint", + "left_shoulder_yaw_joint", + "left_elbow_joint", + "left_wrist_roll_joint", + "left_wrist_pitch_joint", + "left_wrist_yaw_joint", + "right_shoulder_pitch_joint", + "right_shoulder_roll_joint", + "right_shoulder_yaw_joint", + "right_elbow_joint", + "right_wrist_roll_joint", + "right_wrist_pitch_joint", + "right_wrist_yaw_joint" + ], + "position_lower": [ + -2.5306999683380127, + -0.5235998630523682, + -2.7576000690460205, + -0.08726692199707031, + -0.87267005443573, + -0.26179999113082886, + -2.5306999683380127, + -2.967099905014038, + -2.7576000690460205, + -0.08726692199707031, + -0.87267005443573, + -0.26179999113082886, + -2.618000030517578, + -0.5199999809265137, + -0.5199999809265137, + -3.089200019836426, + -1.5881998538970947, + -2.618000030517578, + -1.0471999645233154, + -1.9722199440002441, + -1.6144299507141113, + -1.6144299507141113, + -3.089200019836426, + -2.251499891281128, + -2.618000030517578, + -1.0471999645233154, + -1.9722199440002441, + -1.6144299507141113, + -1.6144299507141113 + ], + "position_upper": [ + 2.8798000812530518, + 2.967099905014038, + 2.7576000690460205, + 2.8798000812530518, + 0.5235999822616577, + 0.26179999113082886, + 2.8798000812530518, + 0.5235998630523682, + 2.7576000690460205, + 2.8798000812530518, + 0.5235999822616577, + 0.26179999113082886, + 2.618000030517578, + 0.5199999809265137, + 0.5199999809265137, + 2.6703996658325195, + 2.251499891281128, + 2.618000030517578, + 2.094399929046631, + 1.9722199440002441, + 1.6144299507141113, + 1.6144299507141113, + 2.6703996658325195, + 1.5881998538970947, + 2.618000030517578, + 2.094399929046631, + 1.9722199440002441, + 1.6144299507141113, + 1.6144299507141113 + ], + "torque_limit": [ + 88.0, + 139.0, + 88.0, + 139.0, + 50.0, + 50.0, + 88.0, + 139.0, + 88.0, + 139.0, + 50.0, + 50.0, + 88.0, + 50.0, + 50.0, + 25.0, + 25.0, + 25.0, + 25.0, + 25.0, + 5.0, + 5.0, + 25.0, + 25.0, + 25.0, + 25.0, + 25.0, + 5.0, + 5.0 + ] + }, + "schema_version": "motrix-deploy/v1", + "source": { + "checkpoint": "checkpoints/latest.pt", + "framework": "motrix.fastsac/torch", + "run_id": "26-10-14_20-24-17-390551" + }, + "task": { + "config": { + "action_lower": [ + -12.767200469970703, + -11.868399620056152, + -11.030400276184082, + -8.84320068359375, + -3.5464000701904297, + -1.0471999645233154, + -12.767200469970703, + -11.868399620056152, + -11.030400276184082, + -8.84320068359375, + -3.5464000701904297, + -1.0471999645233154, + -10.472000122070312, + -2.0799999237060547, + -2.0799999237060547, + -13.156800270080566, + -8.205999374389648, + -10.472000122070312, + -6.588799953460693, + -7.888879776000977, + -6.457719802856445, + -6.457719802856445, + -13.156800270080566, + -8.205999374389648, + -10.472000122070312, + -6.588799953460693, + -7.888879776000977, + -6.457719802856445, + -6.457719802856445 + ], + "action_scale": [ + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25 + ], + "action_upper": [ + 12.767200469970703, + 11.868399620056152, + 11.030400276184082, + 8.84320068359375, + 3.5464000701904297, + 1.0471999645233154, + 12.767200469970703, + 11.868399620056152, + 11.030400276184082, + 8.84320068359375, + 3.5464000701904297, + 1.0471999645233154, + 10.472000122070312, + 2.0799999237060547, + 2.0799999237060547, + 13.156800270080566, + 8.205999374389648, + 10.472000122070312, + 6.588799953460693, + 7.888879776000977, + 6.457719802856445, + 6.457719802856445, + 13.156800270080566, + 8.205999374389648, + 10.472000122070312, + 6.588799953460693, + 7.888879776000977, + 6.457719802856445, + 6.457719802856445 + ], + "base_angular_velocity_scale": 0.25, + "command_lower": [ + -1.0, + -1.0, + -1.0 + ], + "command_upper": [ + 1.0, + 1.0, + 1.0 + ], + "gait_period_s": 1.0, + "gait_phase_offsets_rad": [ + 0.0, + 3.141592653589793 + ], + "joint_position_scale": 1.0, + "joint_velocity_scale": 0.05, + "kd": [ + 2.557889699935913, + 6.308801651000977, + 2.557889699935913, + 6.308801651000977, + 1.8144457340240479, + 1.8144457340240479, + 2.557889699935913, + 6.308801651000977, + 2.557889699935913, + 6.308801651000977, + 1.8144457340240479, + 1.8144457340240479, + 2.557889699935913, + 1.8144457340240479, + 1.8144457340240479, + 0.9072228670120239, + 0.9072228670120239, + 0.9072228670120239, + 0.9072228670120239, + 0.9072228670120239, + 1.0681414604187012, + 1.0681414604187012, + 0.9072228670120239, + 0.9072228670120239, + 0.9072228670120239, + 0.9072228670120239, + 0.9072228670120239, + 1.0681414604187012, + 1.0681414604187012 + ], + "kp": [ + 40.179237365722656, + 99.09842681884766, + 40.179237365722656, + 99.09842681884766, + 28.501245498657227, + 28.501245498657227, + 40.179237365722656, + 99.09842681884766, + 40.179237365722656, + 99.09842681884766, + 28.501245498657227, + 28.501245498657227, + 40.179237365722656, + 28.501245498657227, + 28.501245498657227, + 14.250622749328613, + 14.250622749328613, + 14.250622749328613, + 14.250622749328613, + 14.250622749328613, + 16.77832794189453, + 16.77832794189453, + 14.250622749328613, + 14.250622749328613, + 14.250622749328613, + 14.250622749328613, + 14.250622749328613, + 16.77832794189453, + 16.77832794189453 + ], + "standing_command_threshold": 0.01 + }, + "name": "g1_walk/v1" + } +} diff --git a/artifacts/g1-flat.deploy/policy/model.onnx b/artifacts/g1-flat.deploy/policy/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..86c67774b7ed43d3d9ff4da40261fea0e76253d9 GIT binary patch literal 890337 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�omEk>|`}W^Sq)4q4zx z%`cbGuBM6eKJLfq%$=Cr>Y7YfC3b`8vy(V%*=1^1lRE3A zqRh0JxXkbp)afxk z0=_n?Xe@mW>bqh`=7Ts~`|MFW_oM+cPu7ggio3-qNBfeL$7eViHW_bnR$+(pZ|S{YdAji3Ab$KM5(!2n(#Z=}AX{lg`rC1gE_Gi3U$b)QnvGsG zVOB9dm=T3n`8^9)hp0i-)w@Z*U~h1C?*$Qu(7H_()p=UScP}PPS-) zfqp$Ky~G2b@%@Uk3i;?jM;&e|EC!dd0D8+Y4omH& zoQ;P}QT&~E$o)b#^W8oM4V-+%{M1&XBQ6I}Y@RASn$H zdw`@k@xYbJE5uJ^Vvmq_G2HlAitQj(PLhS(;mpGX+qw7rHVkSv} z+os}*RtY=-m&n&JD@mPu#$XjO-J(V{l>N~1S5;&~a1hzrzXb-rt%RDX37~XxCXK8= z%Hnq)VS)s5j)y zVmXk|mOv*bO+j@}ogn}8TBcX{9)l{ySSxLk=~S%9J?kmUtt}J9vNP_}DY<)TYcGrL z-Y|l<-kymoOhnnWgHH6wuXN1!q8?jCBKE;2qv*)uQbr^_1{Zc8M^z)bm=Ehxi3g8K z^MN5OT6h;H7NlaSZTV=@%nsb6b(22XKaTU8)wxSgJjcyj9>A{J2NU@ZQMQ`WA^f4i z0gpf1g*VK0r5|&7X<%O%*FVS#|EONVd^wv(=USFSAXka~n_EW)H=RZLIcoHgZw2-o z&Y8Gxkj9kDI-(B)lW5!NEc|9UAbLX)oL=VAo%24xG4HErm*^}sIr1K}U+_9OKNg3N zA67$3_AkWg&_e+hc|?AIpZdQz23JHUlT|eicw@H!P5W{PZ44+xsJw;DkFj8GrwYIm zX$DF58k5Jomh`^m>sUvY4|0FAgku@Wz> zB_B4W+L&w9phFQhbUdI#jD)-_phesr5o(~PM6~`TW zTVYF257G$4Nc2}f8VLGLSR)=T&E6HFmqDQ{Pf^6p};07UU6q%RA)tFL&@EN$60k z6|-W{6D;yGiII>H*!SLLsiP~kHI_LTtAKav$~l5?vGe}0}71WlW3-ENEt>m zy0Pw49TY!l7FwsWh6dX9p`EYKQ9peN{NYtLJ-#dgUTW)t<)L`E(`|%H19d3GzeXO# z(J&}>1{A`3ajiiRp8n-3xD+W;N7Z?FX72~){4GhczqOaHaKhB9x`3v4`=X}E445IJ zOpiC*#FD=2>BsH-+#G*>_IiF9ZrA8t0jSpH7_j z6*0MGedE_$oR+?ylVN|LIF(j_I%h?rPcKxdUGY5{RGx(wz6zoz$7Zs_ zURlAbz;94|XALd*S;DN}9DK~=$Byj;yRGR|ZRQ9LTjh*TE)1v3?%YR~^9|8rhb9;cUCMqTX~DL662O&exJvdG ze53~_atAwxnyCNpDx7ew8dXGmhHAHcq~*2@ee^pIsfrl)JF}8^2oD#bv;% zISjdUX(^~~+6hg&?~w=}1e|0SrrbFi{M6zQouyBr0=$XtQ5|@Eu$a-{Z6OIN{&4G{ zGUGaSpVMS+LPkt0YW8|wV~(w=CAz}nq*^W)*RrqDnW8GVXzdT2SayuaykCuHy{Ulb zw8+}%(hiUf9LE}lHF&wR9;406M;PU^O!K7?G$pbUmM1Kx^#|jiK|`7+pqW zdri3sou=%t)r~ONDl>b2Lk0514iF$#NN+3XQm2uv_@zu4u3Bb*Zxtq z`gsY3tnjBQWHIiMTmxTM71EG*j@(rS_h{|9pJ=b10k&NHne`h)P>x$Vs;MYtrX*Fu zw{JS=c3JDhmB3qQ;nZeQR$z;7d-32kvAGlX+WZ+)aa-UO$RumF-$AVpEf{^PW9S~Q zA@k145(WJ}0dE`p&>p@9xO2IQEOEx1wQEJ@`KdXc(5EZof-Q} zuUOG}aU>`z3T^1W#nL(Mjd}_nFatk!GV%TwktGvFith}fst?h${8%S*qiY)XuFE6N zqDDTvDDDLI$=0B~YG?2pIY(-_QIu@~2Kcw*#N4|u9V`ECB&^yg+!xh3lyUlv$kJT= zA|R5681AFqXa66D&O4s!FO1_xR#phfimakxg?rAqq|#7GN=h3k($G&dgiy93MY2bw z(ok{FbG|}@A`KNKg@#Hgqltd^|9k(rulqXZInVR{yq{g9#$TDc{NfIta5#=#f3loq z-+aehvTm_6%dE-T(_@JG^gA$ATT0rmZYCcae!}n9C-I!zR}h0G@y}hyIaHv|1<(Hl zt2#58lGaUJ8+)9S%TVDOB7YH?S4Bax;c{%EaYof^7!9YkEuNJHkdPCJC~$u z`Y`E<+BAIgZfwENCLUk2!Sh!i*nCWc_?$S{DOgJ>*j9 zmQFkTp6Ba-4w~$CLH}J>UPrpni*BpO;--}y1l=u#Xqp-nM3%ab1kicp=PCK&- z2i$YuE?M`H!riy1{)6o({b@1N_S=d*Mn6E#(pj`nZwiL@UG$W?7hE++0teY@xFI?f z?UjwfKNsx70n@HSXl@ksZQe^`1j4(z?jd=n@dF5Ck}dL|nbPXt=xvS<(lrz2tqx{# zU6xO{uJ9-Lh^Q<#Dt8p#%h+=-MKn16c1Qk?*(Pl0NeNpsrxVvVPKA^mRowK2oA_Vb zfprGja=KIc$(7*CL{u6gySF)$hSY!G3prRG2*Es_3PVfHLr0VSJ- z;WxP)I3GNXZ*M$LzgH;H#f!x8@U0}CMtTOm(jH6S)~!PpEQ|X@zHgxYz zHJY7Z11BvlYzuZcqpe@^(dA`oJe?Jbcz^oO(-WB@%-ZGz={)Pl+zju*{aUBTCkM%7w^>w{T`>7AXEJ!~fJ)<7n$D8f^o#Nsx*st{ua&1fS_u z%Q%|9V+-D)`Uja#TZ~(l|A2ANVxV0XsK;z4h*e4vT#Fh*qFNu3uAil-?qeM@QK}-! zsYkK4SvNZnxsojuXW46Imj+=SKn=L*Z z&vM2~FtStu_Wd#D@7-HQ9=b{rDK|N`TH^ygAiJ79eYS?3@;Qq;e7+L*t||OGYfH$c zYooZLZ4MjQet|7IE6+6NA-3OjHM@|Z!v^tK=H?&BE=iog&)j}8Mg6U;Ct#eAN3CaO z;g+mW>M}~75&(-OVn|40GIZ`e%TLl!Cx%2JIR;Sj?Wgp@eqYS@k7A<^nLG#EAX=FJA2^S_gn!KWCNP(ifXZ9rakZ2b zJ}7CxR4-i` zz9wc;*QSr?_mW%`o2CWQ^>H-VVj9)msDrL)XH#7n4?4NojJM-~B)(8nggSP}qEGJG zcJ_JG@EWTimTNeRA7UfM*IiOb731XiZ*HAod*(hyop)ET8GD9V=)nxq=4g$hH%XK4 z4%*~DlsV^gy*57c`}Ue?uvroN%4)RelWjTF0>N z$Q0yzVi70VYrs#5T+CP1X(zk%gtMY)<6(NBA1gHvB!h$ITub#0a_PVoTyp;cev-A4 z{5)ld4=hyW%Va8YZABN@y~-rEH7A#}rCW0QqesZ!101UxxW?uyih`}9zCcOMjr|-{ zCIvQ9{OvbhL84#^d#x}CSBI-n&gfToYdwaYPH4y9{^~PJJ$aV){sI26lF#&tEMVqA zBT{p~fndK%=-@Td)P>`)ljL(MG3Al1N@6Tr>o9?BmweFf+*oj_xj_$*Q0l)bl@@YJ z@ZDhsIP95?Gn)n>dA$bc*o+6Qo+`SlX^PzmnL9l3!m+&OLz=K@`xC*m>ubP~QRVl-|@ON1?tKfwpl7}9EEMs_Jp6ry-XS+q(9+-$o^t{lI|0<>bmr(_zlNvmP% zyD=H$9U{gWXV~1fG}dUW!%DPskXhP0I(pHG9W5LnCxo2e5A&mtb889Tb;GpkTl+-p zrCVf4%fThA@Yi8{QKJ&a8*S&8yS!lspSrNAFCQ}foJhR;Rvy3F=?y>syD#@=tpfi* z`X=)BKV4R#)r@yKkB}i*F`^i;2IuYmPVc=)g@yT#=tmn@sy8zWnF#YrJ-ak;X^;p! z_?Cgnlm8QF_NigZBdgFFqXwk1Mw$(gNSr-;Aq}eZ!E=I5;YUxQ;NOK1oF^HEV?s@# z(mx99Zg}HDn_g&%suB#FKBfMBW9hDK`;qlnMVwydWLLe+jrScF3+i<}XuHO50ZR%; zBXtXK=}U7o^ynjXI?zEIm74`+$4}EYa;v~4*@A2@%S6Rn+pzKeaN=>j1XM&NVY$6C z$<3a|mUc!kzHbG*?gjj}Vm|(4=T7D|r@_=Ez4X}dKVHRl4HOq;3xjKK+1YvOfyzNK zC>fiIE8gsflxw8|v%Gx*-3{HmEFs4&mVSWtcQ>(@Q>^$wDtowX28Cp7(;vD>KNQN^ z%hC5q#+=O!Lw;V18Sz>@5vrv$iG1WuvSZ;2Zr8q_Y;F#peHC5EIR)|98nY~xx^OYr z-}np{uk_*Ic3oz{m&P@@6m8L7K>FlA;6SZIWZ|DHFl(1JUM^FFcN`LCjzT#ae6AnD z9;G6&%~~us%o>sw8T zX7~a?#f%rHeiDA9uji?Jtw#r{9AT2FIJQvzM6;z3p8Rz&N?msc`R_X*xU8iD5C3bR z6=NPz%k5vQZaLJ_Pl}1yRhftPw=y*FX$-xqRf9as<>9oa1^Cp+@TcU|kXM%!h=Idg zPM&9uvnxyyOQTF*Vn1o}iYG^=GQ2jT2$10bEAT2}zbcgQ`9mTk=jJZ_vE>qzZ1{j> zpN>NB<8q>)X2rCwWKi|I>&)NBfqQ;4k<{2)fT2V=c}eZ4uUH8An3G6G+|wW@K8u}< z!%Tkh5!kYNh}q}F5wEMYRld(`v0BkMvM8>R#e4bUel8p3-VP&&8db5>!41SeKaqX2 zl3*7Hr1-b#`);nV#RkfbRG%Ufm1$ys5%9j~k4-iIJC)_p3RZ4~2kznvld z&jY;d#1~|lDo@7e3OUB2%&I>wPs_IP);a1ZjH68X;vk*6AHG<0+;a#5nkQD9+VcgB@ z#QJs#?Cou4nYSB=k3uBe?dyUJQ#UgG+&V6?G?*3p>5wV41LUXRCE4irgj{%*O#=19 z*sO+Kq_o+U1lI)IcM1feliQ}b4HRM>`6}&Hg8dkAz zgTH?PQdz+@7u zO!J`OW>TENQd72J(1Z91*^`au*0Sw22K?XKu7LY@HFEfM8q+PB2pJz|W4-VWCQ>w& zY)VPN=d2d8*J8RvMrJRZx$%x|IiO4oDl!-v?8ouUj+6Di0OyLDp(KSzH|%-~^F&v{ zUE!?h{tr(kkXlB>GoG=N(hrzR2B45@*YL(~Q&{qxIxK4wjRVtLar=MYk-DcgF*B@RX__5M+M}|94Uf?d3J20FOiHrSUU5RFQ?2C)mNH1zJ#YFpj=FpG1G0ol6(% zisB_>%&-Lakm?AdmCj);Sc1QtDUo8*;P{!%MD{o#TaIf#GLEk`^%OaJGJ*s+EoGnY z&cKEbr!fs%F<9yoMJ|PEbDtyR+1iAc?1o62z^~^k_}aTNvpY4|R7ZpV>fHtA5WAAh zslCA-FZ;oIMe<2RLMa*dL<2tiAA?WgpYWoSJIGccW9zDQgyuXy591Y|k^5h3*=}=v zR;6f;vC*gee-D zykw)@u-2f!MB4vo{ol}VA0Zrcv5LEy62aS7No0#P0v%i#a6c~)r~XI%QzckE1pgb z&EFu8DtBb&@ri0DNz(7O7tugQGu8c1i`#BW$&rOB9fc;7c}pqx1{zR92G$ zhw0?og*?_+J%}&(UO~3E4dIz)Bes{FK(ud06C34Pw5cwiUic}@q@6OM&eyIAjvna- z(Nb}Ew|pvd-2M^A)K}7pf-u-#Ss=KR-U(fL#{}LVkJI1Q@-V&D5sjby0nUdif%5BR z_-0Ta4JvqwL(KKq;-odgtbMZJW?HJCGw}p6@fH5gKUUzyHCKc=-P^n~Hty)m!WAHh z9ToiiQX;tYSDz=>xfxYQ6eGFK#k@mvzf>v5yyIzoYDEL`zR1MlBJ;_b3a6j^fhpN> zta?fuOud?pUOG%5T?vcv_>FPo(IHuK?tu}%GB66Kxy&HSawGWEC_&oiuR{IoLLAYx zihZ5FgUJWCPg`vg3?(uvpg zbb#B@GN}B>V<&6Nu3Pdj$s5n<(lNg9PT+&$mJ6MV>Q~sx zzVRR%w}f09m&FDgT%h=-9O(awV0z_)q-Itr+^o|h#xn+Bnu`saBz&(wzG%Q!esIN( z-LmZQ&!gyLQV4#zeJS1C7>KTfAfUEy(Iz)%{JgjiW&cxv*L$|1j=Xq0J}ZlEjqtTy z8L7rLUY}Lvd;0{>o2N}JimT!84MGlz-G%`B6D0ILVmzM~h*Ow|&-q6}PC)<`yB`gw zf;Zu7XZosED4Z8q_XsmRyG`Ko+|8)fJ_{TbgR$JtL>!U6m9G70O{eXfj)gP9vE zNbNcf8cU}U87D;F**|67%Gb$v?aS=pjYO~*r^{d2xQo|o|4w)}E?`&7t3Z3ijCAOv zfy!AcvR$$U0v?r-R|^g?Q>lrNES^FBwQ3UG?s&4|pA4J(rwD5OOvnbx@MH5NRvOpJ zqR!_LSZ&MZR*CWNXeI#Xa1LzmM6nDxLnhL&hU`m>B=rgF$s;p0VhR$>Q6-zSP4vdA z4UOn)t!J#y-5I|X`c{^;AI9odh0OQz1n%bDczn9r0|xCr2o79vgnL=j*v@_Vc;_r3 zcQfq+FH%{P)wF(~!SC$x+WWI1^@IZ*u{jGa`PV>hlPTW3q7qlhXW@YdCQN2>3ysXQ zVt!FYJPn6N`oXRgX{sKAFS){=Pi_@2g^mIaDzfXHJ)eG1lPA*Ktnl{TTk(z;Q4s0y z0zu(hMC$5M$CwW=?Rq>+`Qe2B+{xy-xd#bG|2?Eryw2dL#NQ}NI~N&<)T2j}Cqk&T zIPdP{@dA@q&U}URY*~6#Fy&1QS*C;vc%VgxH>Z&O|z%;oO(G#OcL#@;6tJJ7qJCm5h&KF0X#j zH96w^v(XJ?pyLZ!*{A@CN*vo9evz!*a*28F5o59Za+I*G6W)nP@P9|2B#LDQOzcfP zcz*B1QQr;7Gp9qO;pIbo{Qhg$wR{7Ccael1slpRy-iP*-vFxMqNgOzHE<4m7#11rd z!pw_x*l@5FD%SOr{iy+LKyfLqs$9tWXSGnHH!@`M=scKiYCzl`Z=^f9XLyO!95&Bx z0v=qb%!-Bi&q%J9&RKXF$9;NDm#ncAa7QMgj1E;gu&NYaHZ26VlTOIHbuKmCErZW( z+ROWJvY1ZSdxAb*KS~Ye9iuy2_JPld%{8uI6Ksrtr zWb_7T`KvEfsnZyp``ph<{AWj#?Wc1Of+pbAwYki5l^m;nbek#S&G@~QkX=4w!(Y-p zg}hpaV86c+$=JA=G#}=14uMAGj_#kgKcdx$ZD=6*{%Jqfuen7njgJWU zR^t3y>QVeE(B}?LF2>0xRq$SK9W?Of6{#?s#mq)!$kUtm$-03WR1oXWELzSHrlrT3 zhNhCp6OX|yM3Dr@9D}+Qy>ww&9{XJ`#`H*#MR%wRYpX20 zd|My#7W#uU?2qHKudC@lVa_+#Gz?ZAn2T+`xxfMuU3{w09w}BSLF~#*)HbdNnJoLn zyB&Q9%c;kJkRQd%0v51>?=@g;(uO|Xz>u-i3I46AK{1(fb~5(SZRA0QTVuz<;`;? z4V7~t=t&nISGY*JJwccP4wzI z;IE4lHXq9)k+T*vGs!C?O~`O-Z0?4C{g zL1&UYifBl|i$Wjcv6GgwEfeL~XF)s`yK07hjem~+c>hE?bwPOBQpOXzCIWYLlhOJp zH@tJ?5UlTdEvS1AU})VYsM{_^|E0gi!@~cdv`;0S9_1p;5J=Hd)eBfg^)PDMcLZw< zi{m#W)Gj^wEYH+Y9gW;LE09!6p`mZP=xaScbTaq`O$@B!m8*GU=Uh{m5?V>dsHfwv zO_!j3hX?tk=)inbwOQpVBX0YSG{o)F<>Fl?bLG?S;rzGjnUXvoR}Id^n%>rIFshzy zbTj83ica8?`C{a`$Vz5rn9XAM%W^8)J$S*r{bbHIIc^}di%n=QXD2T2Uw0ydUmA({X<-1FXifsw~Q+5SMFJaF`G4%Q|Ih;@3@YW5pu-9!594IRVSF5AJVn!N9k1kWCqr%LmR|d@} zXh3S0EU`>qEH=J&O5hl96lNK=(dEidY51FXB(Z5Mcw1gYPmToQ)r++7nVpp=ywjcc zQ*;u%z8S?Dx0o|89Vw6#{9D8`Al(SExgtm%hty{Vc`Q2q+qMHrMd)ZuIRYxX8_|V4XPRHyFE}u61|E8@25n*; zsHmch(pSw${0~8IRm#XV=`rL}MkI-oeoof6`S5QP&mkViB+x$hV&eW#0hcRRGTD{~ zpd{=gZpruu!KXZ7k8pl0l`PN3MpR)_QTyi=3H-%W8V=p)v8#N?;GF6}VO9_u=cw zG&1tvO0ZAsW?q-~k-uSCtW?2BkXrp&*oUv;;jQw_WKaRWDCL3k_W5Yo>Nrsg-3N~E zdISz}=TY)dCPu~2QHE)aASmDsRN`OM%()PEc8@1V%T$?j`g*(Ssdd=heWKv`z(KJ2 zq0A<_mZ3u{4uR2@t>Dss1vWjtPuB%R@P^iRpacg^YT{N!NE;OJs?R?aCSQ0j^p9~-G#iFayO=Ne=6I%Gz0OY!E!NbDwxIpIyi}|~V zrCE<zedRHL-MjEqC)qw z!CaQ5{(-2!isL^`R^;QmXINs{BfNU*A2R&$G91*M%w=i_IqY^1)@{q!dczb_XC2Sa zMjqU!`FDt>o+ZC1auT;|&sp;M>Qy4`dKl&4TJoR1hPkr*xzx=uqnI@-AhTr zEh%+0;>#&;zc0dQ+IM=ntQyv5UlC~Dl_Z}Ol4wOp1Z;@@Op6MX;o$~LwCjm9i$&M$ zl6>x=ZTg82+Ac#4jz5Ow+pgi?ZfkItMmpMPv=+`r*3zYkEj*={UXfGiR`i6s@r!2~KOUjT&?O@P%n#4-%tw?RPBr(;04Zn5D z;Do&gnkjTwx76RoEtODpyIB*Ox10y>_q*Wy$x#&j>nPmp+W>YGE!eQ67i8@?hgFVP z!B{U-mOWrdcGT$O2lerI@xQ}p>To$d5@wBO4Lh@&VmWBjW+U)*tfhMuF9^!0I-ZlU zmF68XLuImgRQ+YVV29FDBxAWrkYpK#!q0hA!{Gfq**I?~sgI^1V2_7))d~Xs+r;u# zOyGwNHNo$9b)whML+g*0&i%>H9K#70!(OCZC;yjidG?$DW zoy`^d&*pcYKE(YO9n4BBhwK*YACFHuYx1wida(%`bolKWW}L^Iy9^#mqtvO%^zgA9 zvRqq1@bz5{-s=V^dT}cRbeVzE%o3P`O_N?OP%D^8Uky%W4Lm|zJH&}!>oG<~Mk(woq8Spmg?!dU(sm*b#|CPWJ?mTP zsoYc8=xP=!^R2`Dc`tGEhAr^%>^yu(>pCc>Xkn$#P6C&aGHQQ7882RP0N)K-iM&KK zaP8OyaI8fOMt@xtwCH>B-AeXwS<{?2JM|=PYrQ;oxloRYFKuPIInC@=>{pVf+`+b8 zyw8Rv>oM*BT)=ce6EWZ5&P~Xf%dEBUlEVQm*dRPmr|D#FkS;ad?*=K6mLF-Xc92 zo84N8?F22@ebzg08{9|#{8ORX+qP4Gekv8obcD$MU~F8Hi%)Gn3;z92;k!}_4vBOi znLXzr@Yqr66DzDY&TWD9i^}MSHG8OUf-F7*a<(4B3PS_-G+#M-9(SDol!$0=`OF?kFB+KFZ+Qm@6OS%opdoloqrp)vVcm92VedK5W%cDlU`7jqhK4#5YgH+g!!+O|d%{gM>ti|T2>ynH0lFW67!BE{7k9)4b$lkGR`j%OENVN@0Cm9eAqc9fc?m+|vK4_(> zBQ76PfQ?jU!pulW zE^HG$6}Zm4i3~-KBjwZj$aW+gG=AB@tgXicd)Gn0JY%Z*e!n8W|ciwp0eBGO3waO%)8_B1h+jMpkA$6SMO zMadd${LqPc#++d5rrC1(mVa68w$Eg~$soCRC4)Q{@`RB*Th3K+7P+uu3>UV=gq_iR z%6`jbgO{}!7ZMUgkW#$xjUtbGdD&>kjl-mxnh^nKkCy+L4f~|c$)#5|^l~bK+NlM! z|Ltn55dD#oD0!UIBLd+s>d}1lHnj2b7-l2(j2B;j2Di_i28uOD!7aWH-Megu1~(qX z{joMYY0U~yoYWz>s&N+m*OLq<|Evcoo;_4s5m*vyjh`J(g}cUA?4CAQBXhGr96LpV zCd@BIdS&9+yY~q-*O)+c3NcKz*M;3y$voANSY(kTOFfd#^Gb)6s*bp&;hnM@$ef3M ztXI2*{Wo}!Z9Im^8}WR$EKZ(HD_Fwmc{y^UQ!B~a2M>{W$w_9lL;*i47y;2)OPQ{} z8hd{9BR;tQ7H_QEX?FhBXH=?xg6%R6V!utU;i^x2Nbjph@agA7QvEUuu1iiK+(j$$ zbF2>6;uXalB9h22hX`hEC`H7ds_~U`<(SBb&{e6hfZdiKgYRE*B^4VR+2Wik_W1J< z(SBP`%Enz~ca!76ac~)4ARWQmp2UL*Cl`=8o)=j`@*_6&+a4lz;4yYr6D5n%*OP{S zmtnW#EoA*x7OrVu0jpQSeq^`;xmur$b+<>OXR31W$k>IadZtz2bo(r_wez5-2E1@O z=R=iuHPfcKXJO;bayYNEM(EKH#aCWGh5D@`(7kyZB%KlFDRx@ZGFcNGGbWX$1&dYf z9lsH8v5SG%d_MA?z64537SfTv^~im{392rB!21*+gK{_9;OSvn$SJf^V7Dfer}Bpr zP=y(&;EOqbONKFb&vXyoHnfcE7iKnI{ya{0ZZBfqE64K7dtbA~;Qck{CZg!a*MBkd)bog*1$g)78NG}PyQokpNvq6tYfh1^@!lY0pVw}Bakn>16sEJ zSbxq+`l+gn+6r`hRp1+y;h^H61&jYAQTsjx{4zxkzbGDt z<$O65u9QR94ln0zQ)ovgL>MgDn}qX@WTVchBJ`irEi|~>5}JLzKUDLCwRB3O6>An zyXjxo2WaodN_;$jJpQ&JiFeFKlLrAQsLWW5{%Hwd`!vpj-^Cdu!9R&xdi6Tn{oERV z{O88sQ}Gq_{qK;eYaIAG=_0Uf=4A9`dIk~wc9}S4&LBUV;^4N+IIP;+018z$?BcH% zRJ|_;oYHmJ>C;cpRrLs_Tf30QCKa)obU$b-TR4F9B`>9}b|gz)?4$kpT5Nc6W( z94;9Lb8Mx!G0z>j4?t-z&_b{2{%Wm)HbB4Gmg*P^^RwrpiY-Oh@_e#UTB#x zH>;p~9sZu5h)bux1oC(n%hP*Kwfa064;4_S!UK3+G(!vKoPmd@uj3yHhhf%wBX)L% z9%)zU!17f=RL%T8KC(iQ@wUw*5pufh;k_2v`0XN@n{7ZYuxOIp zb)SWJGdA~k4QdLEAt+*)<$Z3a&ZZb8RdwTi`(^l_zB`j-KQVCKDha5(lz8yH$YSje zX!KtVh!h@We%|gRR??rHx7&%*%ZGqpt-$sO*@^R=*(@dgA)KCbfJ$Vj!17*1k=E z;ICWofuP!$m?5VE9j=k0cz{1pneSC~IJYGjX*3n=Y^T zXewSIBZJ3oa{zm^3X=W2AF%qEukUV z*g@|Kk>t-|L%i$odGSWpIO8>(I`51ZCE2lm8e`b&G9|uJ{ws9X#0z`g?_e_4+H76@ zRTgBnAM0L}=K|Bm689sgh@4k3x%GJ*x%uKO`LKvbo(Ur$###C7+TbF->|u4LXPSgU z7CXVWo)Gw|n}>^KYp}^aRi-a_nlwiHlFw#$Ve*r5{=^%SoJocinWtGwJ|))*VrOn- zw?{-_-n9A5r)d&tY?r{7KDO|}O!%ba+beFMDTm+UkU>rb{Q&nTfuwVOAHFzOg4}Ub z#$tcd@C)4v2rn_iyO-#ZH3b6tAS3~Gg(V6ewk6_rub=4r=XA8*-5dU$um-Eh5^OQc z4q@_2SQE*yOD{JPwlD|DPyY_SQl7}z^Eev(^9G(8DUzzd|M0;D8mRrxD)@Fp1pZ4l z1G&So0-uyjI^$6nHH@u5sd7$&*3d>8s$dCPI`PyfY#thS-4@;6ycOqnmh$`)%^|Si zw%}jF6oh|%B&(NA$3Ddwgw?gMOSQ-79&27zM6VsQ@;XV4oK@M^JO9YQGZ*q@j~L!R|y_eit_(1YhaNfe4_YPo!eRNK;EAjhsQ4w=T1t@dr5^keWTAT$ zFLc}itG*q_JSGkf9)T6}dN6aLV=Q(!S(wUTe9Axg+6FD=zQCRGBiTMiObMtn- z1eJ6@rl}Fd`sVLrw__Ec_n<0iQ@VxzHD3e2SyI6NrpOjvuK6)`H#l}S9u0b1wKT3KL4Hm z8avOz%!4v!M!tLX?G$rYsyX+Yhgt_Y{&E zO9ZR+@{yKaGw-|2EHrrU0;KtErWQ+2;qck>vAKT-J@d~QnR_n7;hseh`b~yTS|UpB z{?~|~T5ks{r8f5Ul`ZBAeROUW;{>X$NhnC-Cu|QsjU*Pi;U|yYBE!RH>7}Q?=$p!u zLLZtAs<8LRH)kBebNBMF%e8xUO^sQ0_Gf1y!@gEJ9IDEfG91r;za^JRQpwyy^UXTM*f!y_Wn5p1{JK#qk0QQBIs^08%0+(cX>P*l}vCW)(cEY!x~2H=Su@a4fUw z9P*rVfmH5mBVNf#?CZM({z@n(N-#(g8y%SKYXLJ9`iezDqM`XkEN9Ls@hzlfVTQK| zH}OjsIN06fui5N@=c97G^kfHF(QzE)F6onp4;o;@!5GrK)t%t|ufVT6AO4eE4ZkZt zQS-55=(C^%D%STK^ZjI*acL(_(s9H+6Yj#WgczDHD}rT{Y!EA034J5a1eao@>~a>K z#$T5uz=ol#G- zQm+v&xHC49j_iMk?yoPT&&`z4_MTd_r)(j1^j|L+uGx>o3un{3zu|PZMzV1CWIdj9 z<2;->bbtkpAIIOd=ou2ZJ{=d#ZNSsIBf&GlnHcVMVYZ??_!h56h;Yxx&p(Ip$g>4t zAmlLAU;5#>D@>p&BNq;(M8Se4FQ{B^MBbh0LAHNZA<@s9(BoS|=g@uu6z`Ux5_eaz z)XOW#2kmF9=-q10XV(P&)b*MqVDWqGrCA4KrM0+STmpYu?R%IaD|l6P`kAf+bQn~D;HG)N^^ngW8;`)g(iWmo+f|% zd3D?zcn9CZ^SFkZ3|4plK4Yuh@k}JcSG@QcPmpRM*{9Svr}G)OcQRx7bArj*wo~ll zJsoyyN(UKlmd&CJJ9v-RzhqgH8gSKtsc`1UGgNzhIzM;OPBPl-MK%u9k;F%`XhrgD z+;by=nFwD|LW$+{QftmTP3Ys${VY3p?0!>btZK9dTgdI8|MQG-oNau@JjC&9`+RVeCk z4sH1FK3cL*3XaGKwH*U#u+H}gKJjBJdY1KpX4spfc|mpPjO}W?$=eQ_oIc1d&&b90 z=l;^3VneJDr40>sj`&`DF3s$kgx7?{qcLyq)7zS>sr0%eyZIM4f}!wTdCk=tf2(On zXzF2Jvs^V5*^2PqyYKBP9!BEsp;&VIWFb4cDw@dHY{2J)tZqHjGkoz8DbMd9#ebiI zcTqcWjhX<<_bp}tcg;xt#8md@={?fpK8SzF>2OJUrR675q8$UUv%#);vV+z0l&n4ZBTtXFO(3tM-$s7mw&wlTLo! z*b)9C2O0ZykJO;Y(uvgyJ>PTA8{02ibeo&K=`nG9wuL|G%QCjlH-|}LHGbF}e=g!m zI=TOT27hUSGiX1lhk_OrcC)mCoz4g(_VdoeCChwX!`5)B+@1jM-4kfn)@{76_G75s zCkyl_{{o&MDGE}PpF+d97uS75E1$gw||(4-~KWX zyi{nWhrZO{>uU(Sxb>Tww7sAsylGhd;tE{AH$y4&8|k0b(a3kOPmq$igqj7afl0`5 z6m7X#@Wf6ZI<<$97~g`P>$(9$mL-D8&nP;OuLqjj%FxQe81l#3m2K2@W;N9}V9D8B z-0Gb{!UuP<8t))dB=(dXJA50z*RsI{4fV7#ND;fM*P?NIL_w@a0#+31fY_NBbiQ&Y zvfsZ6I%3{X|8q)$*)vYl@7+<@?v6Q597q*JA``su`(mE;hnFO{vX6=EIm~UW$YxIs zBAKX7GuGav&6dQN@E`u}CBHnEVCgX7T=RWD8ZbM_j$37-aLaUNtR77M9W^Gw&1XRR z%1vewRLJB81KIcCNTR4?%{s^4UY&EaI6vtk^!>u!fMb0c=^ zMJo;}=ti-vMp#br5Ijh?$CASQ?G621p#DqFPRUvaLUy~u{0;NK(o76C1zZzkDK?`A z=~L*cM|~*D=(=F5>uI`moN$MP8z&fI5vamg4ky&>8aGgoi;6md1+=K%^M0&^bNJD}KncZ}NjPJOJyS}_6 zA^cP9xQGI|^6(}*aiX78UkhQ9I&G}tcR7}iGGldGjJW*FB)(&|U~Zxz5m@H2q%99g z^2kvly4{%Et$4#4%EY;I8)P`|9V@w+y=DBOu|G&mY$|zk{1sl+cMkuvp28b z#q-s!B*4`gNzQo11Q^N|;fJixX469+GV4%8hO7oi>K1KgoOzE$-knU=whyx_hhJce z-U9SZ$%Z}3)F)F=A>OST4+_hg1)Cf%3H{~k$jJG#*vC&37i7PpTdY5$AGzhYfCR8G z-g0P0;ch}>_KTY_r=u|q?SBYg3Owg6XHaLI$ zRR{~6#Uk2bSY6JA5BUq0D7 z{t~n7=zy|wzmUk-ay0bmpCGL~2%p%p1R{3XpwzgXc*P<={Cq|ePh?*uvRx(I7kefj z`~PmnidQ_DpQk&?%e^721@g$ca&bECvm8Ea%DcK0AKJF51x^=BlgDHogw1lN zb;~Re1SNyl6O4ZwufVQ{mZ2KaPlAN7Rd8@pH(I2liDUe7shD&IzLW5a8b4`59pRW> zF#JvLgxR4l2}R%@mqWf>)aIJDeJ4A*1z;bPPQ88%kwbTsIgh!8@yyrt~9+i$SyH(=L{MA@(B@>FYxf&{KYiLi*ahUde(p$t5I zQOZu`rwh1O>quoU2Xu`-_d9Ac-}&!PVpLzKPJ zPD3Vn=|WL#399muW>Wf7AXeCexO?$D9;LlYEYq6{}*4d!GD0U?!2+6Nz_?7K00cqlNDaFEF-g4f*qS z1{)Z?o}B3%zyV99(DB(u!s%OfVb!uX?9mfodi(hQ#{7J$oa{#;CdzQPCdbed>2>r_ z>?WpME6&zzl@~sKlR@N7c)#h-Xnq#Bh-j@DO@gFeMq3NxVx#=;;h3|u5Gexv6wT4P&h(Z6R8CZ9Q5oqVQ;c*`Ykh%Q5$bZ>WYW_qX zYspI?HNAPDlwU`U;_Rt@>rF~liNPSBMJbR;M03;)X^gZQ(#YThA^yqqh+Yc`eUVK5 zm5ULF!zrZspf#6ee~|dj93$*JvY8F?p1kQtY{`k1QoO+Qg5V+RW^eEMkjJs-c+Tm2 z5WS9KPYWZ7?~?$!W&U{zaZeyVS%I3G$l!MIy~t~s z1>7EaijEGvjPHl5v-)ScqL!ye@w57!I6f-^&kMK1DZO=2n`cFH7wr^fUWq|d!^N!> z`geovhCFy)w*pvG37E}xgDH!T3Fg-Unt7hUx_Ld+`4PtX-KMnffIVyiF)$C5r+e}h zAj(jdRaLknr`y|^yiPKEcfJgdUh@!3ce)EtyKhFPO_RveRZXP)f;9|Y|4mBUg30m4 z?d(~aKhYhyPJ&8S5amTz$c;lyY}ocS3#sBc?pAL}zN?n-+%*;Miu)>T=@~^v?yaD` z-9cokb1i`UL$Wuo7|)e{K`MFoz>2m#thQgoDt%nYu_ne1%q$Qp$W)Te>96qhL!Ytu zG)3~SH-$Ue_mxdwokfaYZR5N{TZ!OYi|9{aH21uqhb^v;B>_6l+)F)m?vt-99wYG< z2d1U5hi4wLpJfc2ZM%%?C%zM1oxc!gN1vf;yVuh6%h_9q!a2=e-~*rj$BPk%rK#m#n^cg`>I+ouUI-VLUhEG1Ax2LOaAk zU}?F8cYhaJWppCJ1F1YJIB3j*Z-nAwXL$ha^CO_Xcs)Cin}OxBve|;BO>Fj15&5;T zALTW8qdz($*h^h48vMSS{@W>u7tT%r=cR#yUZ0Ct`_lr@{r!S!e{I1ZO_g!-NG-PF z+ZIf|#zUFcBUscIgDu{dqlD{6Az)aJ+cxtD(HQlaJ)N)^x9yJ+gbT+ok<1EsMvb{{ zac9o@@D$E@)Ew3m(8@agO3}H}KcP~klNo{q^I7>1)=vAxe*E4C?YG^@1DOEwRx_0N zIA#)6H3qpppHZ%{73_%(Wp_ovl-L~y6P@$W-f|A<@@#06##FFBaSpCL6~m{_WbsaC zS8!;hRQh!ttmgTtK}W7&j~#LJ*FiaUYfT?gFOd;U_$NVpV{AdFDMPF8EW+JWBVdYF zDSj+_j!KPMjhFiUpjsZ&VH&POQ#?B8GA@diyLpD$+_s)^-hilRm*- zoD8O>Q+OwtxM3AjGsUY{`{4`cPO(fKaZ#?+G!mFOo%l(`GE?QpIQZ)VT<1`pH_4;NWBKSe|p{+oz*JIoV4-!WFG{`(_a(=t+MH^ZDc&CbVS zHo>e^>KutSS&Q3zzOf(I{MnFS3$n^oq%ZF#^4(7_@@_BhFnFbnhZ|nGdf$F*+AjljGK%zOps&@0#TBqVyAHXF z8^DrxCuqBF7_4l_<@+8g%wg3;vb9s0mX6kkF*8@jJf<#PGV@78!S+^|V_Z#nN}j@wE?O&5}P zGW?$Nm64!RMqJzIdkKg}Z20z%yKgYJmxj5(A8nRhR5&o$ z99xa2g>9qy&bI*#PQ+$Phj54OWRepR0&eq;pi7Afuv?=Qn?*?z`2huz895HhFHZz9 zIt#w&4A6lPAM|Zr2R$@AfakBYgIi_#I6=vQ#i2%MUdn$H(mbhxb_h&hk+5RYZ%ccg z6SOqHjk<)40S!N%eQjq;&lkU=QEGlx)r;;@|ME$A=4TI4-M&b4?cZn7hEH=uT{beD z&!K4~_`*HnyFMCQe5)cawa1XnP)+ia3)o5h0rI+KHmc!Wk76XzKM{>1NvWu1 zZ4OK+(jX1ePSk7hSf-ac3ZMF1g71z>gTo`mL2m5;QbY%TW- zPHJ|cnum6xbr&~^bmd>cld5S@axRmy2pds=SRS=;cc6dof98AUE?`vnnttf-t=g2e zmELuC7X?bzQe9|Za%(P;vtwh(CMRnmQ+$n0cl#!2noy2Hr&h8#*(rF)a+r)QwiHgd z@5aRYF5o4_H}DM^ajcVjR{;8cW%n2Q&6WDT$ofvw{fio8iauRd|+Kl<-fjCOhykkHsd6Se33WIm>r_ zhlWp(g>ti)=c&77envLub_$WfSI*>5Xc>4qU4Wu1`Na3#7@_yxP|oP`OyN7LiQHd& zn$34>!U`w5amA0@EbVQMVCzvu;_a+Jo{#6yu?K<3P@s*A8aXW1`viKT-=o(x-RM!` z2y&BOFYkxXroX;g;Jd0}aJn^*8Nat8kJMG!EZ1Zb6flm&-$;Z{tEGt^zn_s&F=VIS z-a$u?Z(tkkKSOGAJbsz5l3cdV7p?kr1OneHqLn+H1TiPK;_`w7H26#xHo57-z&!`( zSCFG;3UAZz_eOx%a&hqSEkt%E&yj+QE^GgxgY6f&(eY9*p}s(ggpE0k)D7*4jCKbZ zIq@IN`U0IC1Gi+$(b@C?HjP-eE zGXIIU*}o$PiM@!!apOZto&7qZaXF4WljHM70X-zmJA(aoyUSc-B9T;b8zn-XfpGT< z+?C;bhqe_YT`z(?yV8x9uAR+%lrE6EqhZ)tQj1*;2x4#3DX4h_(!akB!K$ym_?m7C zWZ(LL>9Ig~(r7^Dc;BRcif3rWl04|Y@*n>5DHqP|QvvE`g34xRU_JeQ^s;XcTD7bS ztcqgcva<+J3%Uw*8IS3>B`>P>6!lOuId>d5qF?mADHX}39)s6+LSW7K6@vZFtH2|C zF09<$EE>CMET+mcajMi*(ZH}P&YLZc@0~w`mJVE^a@#^k>1!?F-D!xZYA7S2mIpUU zBNo?s{$!%54y^n^C^;gmh43pE;a}kswmz>4oOc&jwPr2HZ+e9gk$j1y-n>O#cj}T! z5KWYp^g`;aN02r1ExWm#pCMUp!|%2EXLi?*^!PSIV2FV24w=t(eOkZ*|2s~KB94)q zi#%ia_BkqlI*JwU_zSLndvWX2(|E_4SMbh?pHU4~l5PE%RX_hqyw)Yc=ylK86OC9R zZP>+Tdq%>CyTEqn>cA8k6{g}*%u40m$(S=Wro@>U9)}Rqus} zWjV0wrz04z_(CJ5MuJ0*HyHNC;`NThqO%`2;iugnQ0s>P{@IOW8RgSK!+9zu-3tUy zI`i=8$&u904Si4YAeR(lF^qM8mv$_D1E?G2cq6wTzU5$bRUZ8#Qa_Ho>bucpJ8%zE$l5>yx z#=2Zi3U3W56JM1%e5zJYP68}Yo`-MHl65|IDNJ7>1J zp-B1-{OmDa6z&RLNIY68Re3(!7`D@-r;{s*K66Is=Z9GVFxTJ2Eve6>pj7#EP3PGt&db zq;lgc97w&{iW`3*cjGKBG*Oz{I$cUwJarl~-601T+~T3*_z!|oRnhnvX-w;c3}4soKr zE|VbTYzXf9cpN?n&e6RZ#%SeQL=PKnfI@nn-tVdrm`GehBORiVH1FzE44i~+x}K!F zPqYdmWlhobV`A`5U5TY)Ghyd>2|VL%J3BTcM+_AL1X<%d=>yHRP`AaEJD2E;4V2^?HwC1hposh~U~nBw#KSYym?Hb2yw)m@PwK|b^q{p+D6zD!>F27yK zw$0fnDfj~UaU%pNT^%FT8sScyUgxqiJ3Zmv-VJQLdpqPbsdBR-B!%K)XNi>>$2$5v zxY$5bA~+IEb9ypK>Hhur`=1Bs-5nLSOFTft4|zc@y8=d4%w}QFpMYvc5O(`JPgLA` zo4(C2!_RuMVRCt`NYYy!FO1HGyK{p>NzIY_A~!>3SXUt+-) zm>%U0iES1>A2k<$j9|p>j*w`$1mnK~efI8fKMQ+eK_;wjWZ%t>L(ZN~P;i<+ES67Z zYeb9jr(4B1xhsss-7_U+CLU~1Jf1nL-@!4{H9%Wej0|p^kNbW-qPaoVJX>NE82jG9 z*Gn|elJwcwI{hXMQr!>hGJx0bZcTI~KVukbUqNIyt%) zaw5xN%gs$7{qrX_=HHJQJf0+Si1 zOzw9b!DEL)Akz64vc9j2r|8VV^LX~i!T0I#V1_F;x?coJc7gb|!6p3nuOG}(-2<9y zzrpecJvd?a74$n*i)lwlX+H_r&F5R~dZkWfRFWo2U z2%$N+kI<)c{kEfLH=^lZo-=XQOwR-PUEIKt0^mmIGH>tx5T0N%Fv} z3p~ zPtjqx)g+6)9b5|%r&UF|V>k=DfrIqlX?bj)`;c-q_t55hZt!CHYnppxkO~YxRL<%2 z7j!-NM0>vTJ?NAXLL5`f-(R@H8|2Qm=PE+JOg+0P`I6Wi`_7K9wIq)7_dqDz!Oe03 zu*mNxE>4xkD~%Vxh;VB%%2*p8w#cXR!X=O!zYeq~tzr-P?xszZ0|Y83u%4mkaFZ`_ z|8~Y~=(-oXkZi`O|5rrvZ+5ca_HP24UT0Qfg|YYiBCLC5yl}JsW}#zM6`9-jk!eFA z_UJ!Gz80S&f2Rer?3Yu7(x;t;d7qW}eOfD9nv_fi2Ig^(LUTynC0F+J$v)z<`#3b8 zH$jyKaa8<3I5yE&z!Mn7qrNNQGm4>tcTQR0ec1!ete=cR-Abu zl{Q;Iw?8>ek7fEGr-2xZRxja1ZVosw#UGD5^%bXo=J$=e)7VLm0)of4;d{Hyh4Z-s zEd2gQcJr(VG^+)y=F&f{!>a72#9+!B$ zmSx_u#Q_1Dw5{(9EB)M$lX(tSje0E6?W|y7$rH&B#m!JLTb_-x<>-?sGw{)ojEa02 zo-saxH4H3gy^CHF%j!gIaIqV7LT8Lf z<($g3IP;u&?7^fJBz%)OF^VcBe_w25UZpB9LE{<=6+1vK@$)E`b&|}RzvJ?f@P0qE?mA$sN;moqXF`u?~s4e+C4%MxJ=;QHtYLFy*VY8mh;f#^mS0@~`tqV)u zcOeF8tz@0sSx#eF9_JV;Lva5_{3jh@2%7=dZfbFN>)V-Wo4C*~UZ zb2V&NbBD@>&V-krM#GBM8}R7sd$cAwo$n?bgVgdp_?o9Y79U}N{Y~evfMF*jbE*iv z_IATMMY)g`Yzesq4Y2k8b$HHB;rMrR(AU7pu)I}IN7Y6$kf{i3vQzDo&ETI>Fyr z&$nhpi$mDg7lC;6f_SpBM2@UYOot8I?n1Z;=9kt8?C477ULM1oJG{V)=U(Xy>*KQC*ATJU0Zwly#cR^*$(02wxQn_(_@|&3 zp1(B5P1^e8@f}+%QEed%(lTOt2ez_1BYs-7)zstSE{Y|2UXWE<4l|6X$EUXc$2=8= z@f(k^Y^YmDSex4ko(B2QnOI2D@0$~SZAp?I8AfJak`OkRMvyIQWLdAtQGgZ|Y&}C9 zztTDf9$jy7{f7j2rpG(lo;JWG6+TBDX^AsUY}h$LBRaNNfjnGyR?yxxNtFCo73bIR zjAN&b&`frM&BKwPFS3GLI~8zrmKuZ?hNHY10Tkw^;eUfiM7zpPQcJQJWV~;QJhBI9 zX%UEePWOxGjtXEt zHTjEiSJh|yYQ!t@D*HGouhPdVH`CbXmL25%g;Cs?f2)c2{B$OxbdDXLXN4chDhgG5 zz7kjSde*!?g)Q+EBN~qFZ0DjLY_MdbFp9sI>Ryw|bWM#(-QD%V^*Yk*UB(cTH<4r` zM{~IOZxSh-Kawe4A0^!2Dq`i*TUp9|P3|hUf+;2}f z(C1x&*z=1QsE)mCb=>-n;DUb`ouLu|MMlNAA=3fBX)z}=uMhGwkPx)<#tS^gk>{;l zR%U7CUOex`6{^>qz+o~PbofFxJ{xlf#4V5Vti~H~xnU+TjPqm=c@hYIfwJrvtaC>T*Nsk*Wt`u~|s=_aIvENmcMRb|zHZYZF}H zR?+^TPq>g%gulgaSg6E#{O#Tld8p8cng$Ltc6|Y9Nl@XU-}FLz?hDvi9u5yu64|1v z)A)n0EX`YNNm5Jip#CO5-hK2Anrj94<-95!rgICcsmijqAGhIO#i!V2*;m!8N$D9Z=>whV}(^tj&z1~7&|{Wfm?zx2~eKR zXtE!qsa0YosS_9_}cnOBO|5`qDKLsUA5^?P(V-VRdhqig6SyOlr96BCCcg?Ot zTha#ccP<5w7E@uhejL51nK;T+;Ias``vUYogHw!n8zjl-QDIUuO-f_-&+=y=YmkX?@DM)U z!JkDBEu}1Vn0k$nfS)cYu>Jf*96Y)Po=qyj;hD8~!z@jvJuw41<;0nlT@)Bdj>50c z@e0hdMNsv_0e&}N(VGcoFxb5M2gyY%F;r@+TX@yy)PYVCwQ6li{lm zL??MJdRdYwlYTNvYQx~<+DfeMZ|ff z3EsLkmz}WKN51iQ&}SAGV7=tMWQyWKwnXzLa-JKDYTjO@+q(%p?ko+R&oXgR0b-xm zq`17g)t}@?C-#38VZRLg&D#{+`{p8QoVy-$o*4_; zkM|3X+>FH1&0nxV=s_%Ps|d#jROq+0A$Y~08}#-5M62J(K;_^~bmN#KwrlMcm;~j} zE7Q)3hQs(CT;OXoJlYeFo~28}SCpXw(PVUap%gqa3Ky=Le~WxRpMchBOyW%R<;m|) zQ_1G89%fe%$!yINQ9_;yrUq-Vewq<6-@2bH$UMP}lPd7Y&U)r|B?(^=KgdS-1wq!z z3CuSsf~ovDLl*q%BkJE1Sxf$GX8q(U_K&^FWf`n`u!KsG=`EU9+yv%47QHv1=skN(x8}|ANwdT1H@w!iJJX^rl z7U!|Z;WEheJx&IaHQAVPG2~hFRle9xvsy=Q)G4 zIn@#>4yU41#+6mJTcUvMk>-7#)2LlZGM4K}L&4bv=(uArl%M&9T#y<{tO|j@o(gy% za67&+{U9oEibGc0RGInVkGSDryD0zpRQzez3_NWF&u2c^ClEV2mHE;dl>JJJj=Fb) zp7zxT#l~CoY0Cuov>=PtRG8p*pCkpJ9P`mFPepqB?_6}^@^31AYytE*w3F-y(M-E- zCYv&I6!)-u3lqf8MIV+XvbT0S*i=_jq8eICtS>I%mMJT<(YF?}7kob8#>}H2WitZb zk*);Wg6Z(m@Fn_n9rg7So+EkwksG< z^M0%cugxh~#$1&dsJG(H&td>Slw&sk5Joe!q{# zTTTD*-K|Nuls`WW%QQmSaR;!engRc^66w%aA%q7+f>HWoDt|VeF0&^%MyCop9sNOt zm#)!|yFcSZrJYZd_e-C}kUj;_oC?LE0dzho*SfO&hlyF^v3fuC!06Gd3$mts4k|A@n_h3u~L6Y!c7hJXFk zVWpKLnZk-+I50AVWGF4=)C|8cyY4vhc;Pis=WnW2o+>RvObU z2V1Y{z+r7B3V1MN^;sBeC1Ldv4K7olBh>oo7URRzuXe7eCNoMfXm=SG|C>(#1i90{ zLt!X!p9!Cj*`i&} zXhrU2SX3y%rWu!Ex%_zCe38L}=6dqP!TJ|7VZw-6*tDz`TtDx! zEZs9mh0)4zaVHbqI<12hvnQaN;pyNy$(}wE9LI;eq)GeB46HxqI8yg2p;z&F2(^Ap zWwkHD_+6a9_E#=FBW6UaS9jB#aT2g>*+Y7CML$}#yIrK>twR55O9`xUEojN(B)Zlg z1OmP5NU$JDAPJFHT^|*zU{te}{~m4X6kbPEtTcp8S%eH#y0KyHVq(9{1kZXALr!?T zX0r`kxLg@M;T7kXtY)DTN##8ZvI}|kr0*-ynoB28#K%b>bW~*OO;sRNu7%2>IHdVf znH4sxlXri6KvS`hW~bGoD{6<(6z&qXNpC_)R(MJN0!--L$^3UmQ?0BBCTWq!cm76@@Ac)NRHu!VSN+1;m2>d^wazfo z)s8-~{eUIg_^eUFNF4I`D6;r+gBI>N3@a8a!PR>MVeNqrA}{(Gz1KuIlh3D#E8Is@ zy?J++nKL*!Jw^YCrI2gwTUqIw7$_H0r(VEk*wvy@gwTc-CEA0>BV$PQGr+++-&6OR z`Dpc#vG9J=PeE<|D)_g>8s5&UsdU?^EZALLfap|Nq}eu-WG{+h2SyC@FJCFU5Sql_ zG0Bk|QhV9Vi{aeHKl+lbHaUx0fR(jot#47)W?4Obm`PG*TcgFO%8 zSe3LiYgu7Uqe}Jh&9|L6BI7sC*GwR5{Iz_P)R?=BY3>yF$ypt9ksaa+;7z zwvsZ#AEdW-FB@k(Rap1SnC+KJB>&wiBJus%c$;(qUMG7CBrPxF=8F2ds8WOnlDJhsv`j_r6M&K|xD#`U_h ziQJHr$c$&oAI#`L8sF34Xu=e-Am%8Wy(klZOjRT|=Pv}MIn%pxXI(w+pm4zKC?oyl~)HwbQ)9-~uhs_Ep&zXH{?7&s5RNa?v} zxH~A4oVxi1R{Ze5cY)f!rv$>rs3MZuwvKHWeS;*_%mX#Y zk-|%lejtTQ3LN&FLr?F_#bdg)c!y>v8Q;-Pwr(sYnO7a)jqO!X??CWAdm-)|@+TpB zX)JKm#7Z%k2G==TBJneTjH}pL{I4*cKnOoQfv}-4PhZ zEyUp$C(=i|3bC{6HOM-sNy-KUkThx~)@ngew(t~qk5>Y-h*Q|UEd|d~OhA)+pP~E} zQ$*$&Vc_s#km_qKN2qZX9FiUZ13b&%hT1#1EjZdS) z+t=W`m(r@T)t2K=KGo=$slM=U(=b_h?h_=S%gMB5szPp39orwF z#B%|X$)z&g5v1YRJDCH?Z}Z3?cc2q@w4M;-S3&WOi>o* zhU-_s%St+b5zhxGJRvfAm@UwFbOyP4tRbQMRk`WemN@&OFVDu2X3~DsgpcnmU>hQ{ z$*W1qWNd;sWRKBeYM0dbjA1riWOxpbtqEeLk}hP#5(V<&-&-`k|1g;{w}P%q{0qMmVS>6E}~UJk+9JC1DI zv1s<9bOCNy6vdq_SxnZ~358;v65Or4v!rzWL$d7f9y)QbljUjye!oDKot&x8k@GQZ zxnUC-{qH3!)Q^XD;bGQN@(!HbM;fy`tTFgmvoU#%t} zf8aPA_LU&7r|dxAt{V}Zv(9jQ>NXndYX~2v-Gbv+eqpl{3HZ)aFP^7&iT9b7AO(l% z#O`S>==wy9W`~%u=FanA+N_LTbSvQ^JsGy=#WeI{LqE1Edx*04=8CLjD@5sz>d;b| zg+kt#QQw;>xGV7@4*I$Q$0($U4(ctU1y>H>_{#??Un!0vw$s~1SNZSlq(hU1v)Zq- z$!G`9$O$AC$^sgd8xM1}8i{G!C35V0F7c>PWJZO_L@QXF9Mq{~s)mHD)H;Y0Ojm7Q!ric<0Dpb!PYDFbrLr!qCNRX5f1Y-`f|9Qy1|0xTp2ZbnqPMI4&@Sg(Ft^LZY;$T30GRr)~|ku2UQ+B(u8d;E7*OD3etTcg*}@&lY}jQOblwX zNporj+i9{Fe(B$#i%ji_dH6rL5hrB!_sxj4l^xNz9Ziz*gTTxrnf(Y+V_n)3Fd{IX zD2()CbK@I`O0hXPGAi53_`o?9Gd-5PJ$RD|Ej7u1HCMU&%TJTmsr|%MdX{J)ZV05d z)wB3S5%)ap7hCo;k=%KElX>lozyXW4uwR8roXdh5*mw0iQDLjNkj1CS&kcN*Qa_vS zel14a>hHn~b#0=f^O$axcZ1c+rC3V#1r7S~g1T7(9UESEG@}N|Xx8Aro0FzbAxQ`GpEfmKl)t($j29K>+a*#xpUs zO8hx*1sbVqOdR45F#8(@=wvbnGG20ItFkKY-Kl~d_<5Hg`#Mz|p!D#qam;yWKHhxG zh~&J@#5<}?$nEbOtbckDlXv1oU2`+3?p_3UFNQI>XO-m34go0begu}$_t^}KDct8# zn}td07Q!DP&G-==0j_p;@y{cvWP!^`Z>p~Jd7vNvq_h+xnwR# zUvv>U4b8;Kv#RNtpxNLjSA!mA^E~S^T~M>%gat}gME{^Wd_L=h?-faa#2g7cGHV4q zy6DDwQzzg!G8^!H1C;AC5kK#>!ZWuD;I>g5N}KUlWT|KjeQPyPj?`-^+P^~-y99yx z%wDAX>?E3``hqrZh^DI`Tri@O(Tu8Ca=EG=pRQ?Ru`_lN`;n={U3?=sYJ8M5#r+@$ zX&xK$SjA2Jb&8!^|C=ff%aD5|#!RNS22ZG(j%}5rSr%YY>bZ-2-)RTab?k9cx)hOe zol36mZo&Wkc7+G+OW}3q2{K=L3b9q4%VbxEkXrF^Btwuw)*4K~Ns3c&iq>lgGuOq_ z=Mz#{lPvsEe~10-{lM0}uc2e0i`=@@iMu>?869OK)O>y#?9B+9-ek$FTjR)(jUgvr zWhjgj1+ksVF*Lm72jzU4z+%~^l=y1oqG$qj*=@x^fdyaCy+ z&ac<+w3&63Ea`q^N3d42YIed6F1Sq=VdBbMZ za^h-w=SK+co?k*I{nDTZcU}@?U9G0`N+n@V&3CH#^%u|9ibIJ%NJ~|I|kv`Z?l6-Zr~GY=LA`S z{Jy(>DxNyKi~YPVWGA=m=FbD8I3Ks4^y%YVQmS$Wo!r3Zs;Lw9vr!>O_odU@Yd^xC zG-*=tb1XAHpiGX7FXmeA4Ui{Um29<%0xo>6M66~d)2_OH`uK4uIkeo2#oLsUqYjS5 z-Dw_)bqOF_(gN93Ee>l~?j@l{6W8csCHc*)pTw|4lhipvFc3d@h(FXb#3st7a7#&a zv1G!g27>-u!rCU;FvI#x+?ec0e)aXj`FG(!xBP=!uC-`&<`dj8&yh)&B!P{3tiXNg zc__|(e z@vMP%abbePK5qBcZ{$AX*=z;liFgLb3hs>KjCL;IWX_1Q#j+pZO4LX8eBcd#&l-sj zpVw!T6g|n91T|(N`3WYQ+dVK;$;BH!Nx-Au>9npO40=ZL4!J+EkeA_v#sv=I{8AhI`_N8M zb$o!#I|k_cBWIv`*%Ex|&@x=tvIEyCCE@DhzajkCD8}Vr?YqJ-5O zXz0JElQlsGS#Vx3IF6{DH4D21eiYGdzNzu`h{ z6kGh!j(HEAA`>}NHqD}uD#;WgF=01;_p}W|Qy`nMv)+BR3y^LGo^=xT1&KxQY2n*mD?h3q8hi)y8^cU)>4LtMLHKSM7ls=XG?1 z(r!o+J|$b`$ME@qBJ-U6QTV|I6B;F7MF+gJAjRq%oKG-f+Lil|_HRjc;O{>CME^Q| zbN4LG80>)7tRe8&Qds#`gVu4YaG{YH7+&_m0SXgA zwMhqp1*fRT2??}ea27qi#}zj(ldhWKtPabo4Co}M4&))XjGAqgr`Fev`SoN3-Rp1# zIS)xw|L0;@?A}q42~;reW*;JcGntqsP9S7eFK*?+AzrG71WsE+^p-X9&u9#(*PhP) zRDQur`p)9+gUO)aIiDQ5I7*GUv7f78aZxQZ>F%iWEPuU{|v=d=?Z(l>vHzk zkN=;CaSHd2LbJaQw_(_wHGGi}W>+e)Essx=sO_hTst9X3ta7|}q=Wv?=Kwdul? z4mI|CWh`{8=G}dI21MbioG_DrU%3?qSpI+%*}Yi}W(m5gcCFOJPYU%wMfJYul|Rp* z_Z-L87u-evILj_smcg8|X=*~$3XLSun=y8}F_OGd`4AJfngUujnL zGTix12h5Urp!-oHC{Z$~EIM!v?TS7EiSUb&?r>H`Hs=sY-Tws@J&mznBC!$I zrEt7tzc)}k-3ICnr$gGH8Pi=)}Js;-;Cadk^_1Ui=UT} ztq0OsorMHDwrD0xdG!KK{^w0PEewSs8G~RMF-k11AE4`RN3x9iE9~cNAkte864Tlw zX8-2`Q*uxiM)~G*cQi_Ba(P1Dk!XH-W`r2RIvJ^d)X&PbG9^V9(0r!lRx$^ zAVzEr`f=ngjBqSOfBhsu$hoKJ>6Q}orN0QCCk}w<+W@d}SOi8ggH$_01b+VhhHf`j zg6*R!y!Fl*U}6Q3vBS7-qRMK)e;(&~M&+IKws-{wfOQyS~({>JU-TJK{j|9k`Q(5COSD9Rr9FBFH~ ztROgX`wAxSud~d^m)JWd%KW*Vmu;`!g%N zJJW%GOOC>!l{{kMszwGpj==`)C9LC`5gV(V0NwEsurI3~Pi>opGkPNNw3!{a zw%rIN&N~l^Z9mzP^xH^FTO3c#(BKzb{!IQmlL3E4T3B?#Pv)p3A`JFhk3+dS+WS*l zV4<7O3T^3q<^!V0>sY9IqLq>2K9(p`9u%7%_+V!8ur8b%7vthb~1K zhj3m{6uRfROCVDlh|c{w%}!@za(=OyMC+<3f7t9HSj+nn`|2+QUJ1##k4=JYM{1as z`x2(G;5geEG7oph$&=+e`LyKRRPtY`8ZnpOOwOFtVik>)#y{PMe1nRZ_9xEYe8Gy% zRHUTxqM^|E`UlwdUXQ;mYd!JE3uVDllle0_ox>(I&im3DcdmA>8~HYfvuX z|G41JKQUu7S^7>=_%%F$jA&D#ws)K`A=iS>SIrbY*;h=a+YMs>EerWiUpKH(`O_rE zT%CWmB7+uxmxb^&hD#b<*x3a+JlT3@u5%tw4VR`OCCO6wH_G`LW|%{jyqA4zKpYrE z212n>2ewaX63A+NqNW#;;8k8Y{psz`ZtV?*Ptu-P>O%|mEj7kR{|?ft(<{+&E|zje z!vVr$mw`xxI6FN!NW-$W);)X?i_`j*sEPT0c=SjdP0cl?zni!&ZO%5@yC#|533aBo z{C3fb1N-fVZMN|??-~>+H#iEi%#smLGa1>X{lV{pXAsF#k=VIdhuzQ7VWo$)*x8%k zK+5Y8No~kry9W%}h}u>5pVbJpEvN$DmsVuw;Ud`T!tKEqA4h(rm(Z^+6-YdO0LMmX zVY^)!4*DL}yj^b-;IGLpY&|X#_7$B1eK%?15mzEudf^JGDy?NroqYc9cX{M!dLwScH);8aoMj&YMz}T>cVI?fqVC?&X!^Np%pOK*b?X3Ed|wa zhOG6iD@6Zl!cm!Pp}`=iE+G0m2>xo)ywmEut%GGWaQaHL%Qg!d*mM+*UGd8D9Ej+- zL(eZ3W7D}#l{nWqU%s`1&i;^(Q{P*{%vT!($`Y1z=R!?-GB62&5YaN-653%pL=Seo zqi_61>b|d@gUTiz#^C`tj6cUi2Fm-2CJMwLc*tbnF-?!Sm7ozj|i(3*o z9-I`{+tr|3Rb}{{+RLHgv#!uGPmRCXEt9*gTNBOCLs<2v3RyNsi$sXmkPVSn*u1(l zQlo833P%i0iJG$PLC#bjbb$K|}h9ZR8e<|EV?FiLerb8y<~_4wuU zTBzpc*}#X~{OTVGE%Q=fSZxg~+)r>%dKx@>K7dLWn4---#>m674v(0f6KFac&~f*B zc~Miw!1n#&aJ@GRb)H;{b{uq|qOavqNk5rA1|c8&F6yS z^VbgLk!5(1vmBC21xLuF79oPk$;9krqu}VfPTcuxpD_HeG~ah-73&GkM|ZlM$?_pYPnfspHdUS#`&zp$rn(qO<1?_osu(d_}?ObKh}uM=*8FIJjL6&fb9pwmUj-&_@?ei;>P z3>(YqRSAVuO(9xf9Zo&krD*iHc6#4U4);v?L{sAa)vQ&O;{N7x-uzr8Jgs#W$7DT+ zK4{C}ljmgcfmPku&PJTicOdN7ac6#41Y(6|F679c)2xfjMD;A=v+yu;X2o_w*{02; zv11Q&Z@xy(i)#_y)Jl@uBgVhgbrjBSOJF-L^O>A~9;yDONq)V3?~s_BNB5TQ$Fm-) zvjMXoc$#$%G@L3Y(3DL0FP}m{Yoze?PknsmZ6w)0C7XTDyvojOyT`iXF9_Fc9ZQz$ z9w)KYM@i;WIsU!uXkxWjkp$hh6Mp!cj_r1C0#}*!c%9=SW;wTvf0q00%nf?R8muUJ zt1z7e+dgHL)-5E{D1|)??f{uT8l-LdD?yHLHQbO)#0NStr0Etw;~@p|jrG&J%mhvH zn!ya3Yj~IEyrP~a3b0~yB5RBt!XwwmvV40(n(((5F$EdcwEH|n`XIKduNiJE{Y$5G z4UT2`uCcsJ-=8CjB1c{e|1e9iJnB zHdFk zU|$<|=dk6cQ!#=3I7zbosU5MkTZam2cL=8i6_VA{+S%Uf>BQU1naTWpA>0-(B6Rl9 zCC}g8V?CAuqvz{QiZCW;dd$FS9|T-wXP)X5p!iGjUrr zAFnBio6VM%GL3 z(ZhcuVXgBSbW(Q)^<-}FvQP=9q(tLe6HlTYPmf~NW3gms+(C9lb&0UG+n1bnm_^Pj zJc7EcOceaJl>J`j#SiYn!kr1>Ful)*S$HBMu{H~|xEz~RwhOEr-i&f2)X{f6Px9jL z9oW9W4T((J!~!#~;jI;tbj|ZU_%&RI_$qz)>t~4hx|(D(R7tpREM{izCj83mKH%k@ zW5MU8iQEwx;iq;J6!9~Q#LM&8_nq7>BXj^xONa~O+_*R77LHqn5i{VTe=IWaxEe}CLfG1R^C;t zR(H)tNHyhU(EG76xT@_qvi@cd8aZdtv>FL0j6PHs(A`F7o|h3$Z|9MaTyr47cW}~D zAakZ%V;={0vj46s@V5*l@#Q9P8`ga{n0KKFc{)dixbB-u7DWC7?N$*;csmK--S(Lz z#|rVM`xa!?sTk}`QrV4q?uM9=$c%#S;|VY8&_9_>A`)?$O(`CO*53>z?qDX|{0K9F z^I5o*R4I7B?;>0~{*f%=d=VEn93wW5hRH5IBZ?(D*g!6 zC%p&IN?$4b#Z{fG3yw-)dGg6N>V~vO&zQfQ`pJ3BTQALM$p+;$*AoK z@|itg8LqS0@pW19v#ajcYimtnO{Unb%c*_WA1yQ`qaPVBKLXGv)IGhErLkL&r@tb zN`Y_gevhr~@Dy&}7)euqMWWv&VZw-%Tm0P{@`dA5f54w@rubI;eDU`6k%bd0JZ(iA<12glS>1?|V+eu~QmiB*EMy&0*Jz|_?~55Op2U@-cU zD)p*B^ukRrVbwFiKL5ECxk-X>(SID9F9Th1nL&44`-r+PR-^Y)s{|ts^{8usB6dEh zk1OX$BmW5tSgwyWY33Nh;oAyuhMY3{b(;^i=iQmqJ_#;^dk-eMP9{3)W!OTd7(WY2 z#%mwfa^Ci_@NcCgTv=X>Ow5bn&p81t^7xGVo)vO^W>3(XD1i;PM$)f(PtX-VZpNS7 z$Mek>2X*IF_M4=lNX6qHv{AMUS3GGVH8+h}j{FuXn{ZzsCn?DnDp>I4R@M>|$98hM z%ntS4&tw*z>3r#_OCkQ(c{V5JDSi80jTP*APqw5B*tT|Yeq%T13EO^_Kl8gSKT~l4 zTD)T*`hYvLY&u8AZ|H%G+mGVW-IwS~o7w2+j{C6ujwl3W-{N)nz5t_p`SeVNHc6Rd z&D!SMqr*Aduy2WKV|jil zI>Nl->zT^^?U1jw449D?d*AZ{C3uRGat|lc^w%GslBvPtM0Fgdmn-7_$ZTjipNFNL zro-{&@32PnJp9>W4eYWt!T0iJB4d+Wn4MGt6JGUkw=N#5*7=UBCq)tOe{Tr=xt}x~ zjKQOuzcANe1Lo5&OXjVJW5&VR-1jsex{q%mwsU8K_HrSvGin2$yIbgs=Q?EPr91eq z#D8ojdk63IOo)?}1?jr63OW*0Njm3*`6E>h)hqg`%ac0rd2${!>-(@k>m~%gTh2r_ z72!_@@8bQsqhPYRA3r(y9C|cYqO|N2kQOr$dvUzBd0*?``20Dr_wIU>b4mq5kL^Na zd?qe(*^6v!3BEnX2-XZP#>=)m7EEe*i(gTFc<8@PFsIB(Q1&Pah2Drlnqh{Z>>#A4 z^Tt8b-6#jmm(!@`RUK6R?L7@nj>T3h#i+7~v~b@1o7hLHZWt z@@*#9SB%ApZ_GHCP66|ERp5V*oy7mB?MJ%zn9}E;Ul7k)WqyVDJa((%7Ux=h!Qw{C zp{U%H+1)F~BHM4HSw#|Tz-$`&cYGVG7av@*Tf+ zDuLm*bIC1dIsAI05euF$Jn*)aeoAT+u#3;p%Og_kL|`2b&hLh}S(-TgUmLSg^+}81EZtZ*!j%O1|}fA!2jr!kVa&!uLMgQbD-5Go5)@?V(-Fc zF;yc^5;WJFoV_h4Jkm{3&{K~8V6H1{8~jIebkaaCNQ@t0TSzkAsxa*rvcjL`cX8=! z4dJ;N;=<4=876C3O2z4F6`$VF$t=()8T@>X4r9o`?I{bO3A!Bd;1HUIS>}%Fin6hRSeh?Fl zr564`7vddQ%Z(E_%HRv{(Y8c%reg_Sy5t@j8}t?LR+xa5*N*2UUob+7`xDW{@-6g7 zQxesGRZAPjdqPsaGS!%!L8F2u(c_7OG~}`YRw%WmpVv(1l`3ALEzzlH-0&cZ_vxhp zxkKd8)Nq{qMV=LJ@)HI+Y4D$9*b!9+X%@21i#P>*U}rz|vzV&!%+EFv7t7qoX^W1r z(t>P`5$GlyHHc(s&*aHXvv6W_@HVNkeN2*7oRno0DSdKUDdgUE;r$ULKO zWaM!SF5h{b7?}Z?{oIZSR#EaJZ4LWc=tuj`yWnSmt@z>U-&B3qGX5^d_5AA0T|$v> zr2@r^1@LQH8_{@E%2aJF$;m4(=uG9wB*julnm<%rQvi25w?zD^B9%*TOcV zqYm4n7DFEk&356?VC zn{G$2fpr>$!r|Cz0rvB%wTxXQ6(qQ)k*f9+9$qX*PdEjGV)JI~=yau;ygh;vmgd0ifQ_*4MGz6O>;scu z22h<^g17cw!KbUH61j`%yrK&qq3P^$dVhxyecy5(e|wYyW<_=MXyNfHlBq}-c9hE z1QL@NiEHxj!L4*xc>8+|3p``WF0M&rw>SpSP*Nv58zjze@}7fVeH$cSbF`t0m61ss zZP){cVG`N*1%htgpyBa7chS@r?c=*W>{*TL-@-s{E&vj4go)s#?&t1Aq zReliWd&V=LIuUY;xM5Y@VyH0vBFMP-5~oY_q9r0$@Qlmg9&f6~Ubi}-)ATg;++~RU zx?Je#_PaF8_orZcMIg#bSqE0f*Hil);sU2bQFK}V5nM4%8x(UnH%$LIbm&AfT*_z^ z9JuyNAl+hvq_#vt4X*>cjPt<>^k8zQ4GFL0ra-@| zo+bUc4$@Or@k1BABSq5>ps>P3QuJsJD{2}?@TO<AKmG}hyC|AuNB-7dV6i^4SewsHEW4iaY?fpSZpMW$ z&D`5?Q|1GXk+vo##aYB?{3Md0x{ZIQ>@?P!4tU^mITRYn3;((@^0YgQhBi3k^Q-2N zQ;&-A=g=7>;{%5ynbC#Y=BB~ngT{Cqe;QT``~~*MUn8%N->AkxS4cCsLAxtU(K*Ru zxZ;u)%`JBWk?FUP-+yax%8Wy_YHAcxf7}QP`}Sk~@18TRSG=V0C;jPV!#O;QV-jG{ zdH}C86U9~5u{_#;9gRf(Lci}XzfzuGkM!OCqh=@E(5zSE(9d1#(fgI@$S+VJ@KPSb zcoo-ioKYT;3sh$73~Jbdc{|x1=~}MOs!pV=FGKEX5sudqOIDp;%^vxBV>g3)=yceb32-J{jq0;hdNmC3?+o5G%^pNb4OTcz> zT*<>d=6oBQF!rcs5Z(RK4r@KMnR3N-axfx;8KP3MqGJ&rAuHMZOKRvXO@Nj@byD9L z#a!NA!p~zjz}+M{mgBG&Q?)?4;@Nl_bA1|())gT=^UDRgDaYu)GH>o}VTuRq9FV!| zX?)Um9I9*+hm5LHkW>#Qe{eJmB><%H?$Ej{N9_DTl*yE4Vt1#Tv{-*0ybfGc_oH|j z{k)#b9sAqxL{_%at?#ONOE-t1rqNJn_-%zfluD?&sX6F!d}7I`DzLnDA2O2|;?*~& zAPbofR7cg3ElhZftIogTmIZdgtRJUHrl<;89y7}1-X^dqIw?fv!7O3Ut^l%d%SB?G zn?{qf-N5UmH~VyBlsc|hPX1{n;(@AA_VsEyI(bbQ3Penqy2=?|b(lA)oi0Zfe;LDC zu0${sk#3Ydu@t*I7tnH*vp7-0hW{@?oquBZI>*o{fyrM-iJg|CP_0Eo_~H68a;$SA zD^O4pYS|sdW7-ng>ZuQjZDc>Y=dB`a_KaaEs_6_*xh#zHO-03ilLhhWD}{Szcd=<| zSrD|~09mbiA1`;>1G!`xnOgT0C3~$yi&h>*zjhA6*6tl>Uu!ai&9TNJ)fecYBwH+2 zZ!geUIf%kGbBx=ENAR4Q_jvcYgU}j%1MfUF&Y@(w4KMdnGA=0z045=dZ6u28?wk^0 z)$N-ExhuQq=XeEd@lTU3$GY%rk~n1U$fjp}66l$}DV#5GEKJ`1f_{j(#j83r4*PHV zN=2U(3j{4<;Ji!$sXhCO*1fkyYXn&?m!|w2KOFY%?c^ zLn_&R{%O)5KNqB%pW%=n{$N#e8=pO%1Q*XfhdFVYL}OYNcK=<4s-sq6$uvjY*|Zva z6^-X@8aYFBhjf@~MK!N#T{UiXW)P;s2iQT`zzh-owg>_9`;yPD|7qrSxYO9r!_Am> zn~;}#uc9wT4y34y%OEz7XHFezBxh?B(Rmuf)>Zz%*NvKS?7a2(*yVh7OG=)&$ z@^IXo8-uQR*s@JRJ9zeDgyudmChxo3K{4VJnB7!hg)!D7twWMH9Ik?c!)EaAelRRd z?x%_-ad>5;7#Wn)VnO3-aVW>m-8<5c3T9mfwI`E6;<*KcT8|?QyInwj`BE@{p#cLo z`jNez2d|3rVdNdl!QV6=Qu)vE==YC<$ZkS5m8slHm9~b#issqq%;mB=r;apga!?Cq zcSOPK>#HzW4d7Kf7T_6gxz2Zr3>Nk6K*twUq8BT**shF8{Do`f_^3IR$>Vp#`urkt z1eMX1I|>CMVV~Kzo1OTa_J8=nb}BXB=NYQJq*CyRc2k-$>RWBhK@> zhY0f*lJO_|iB3Mp8VOS+Y7dkIFW>-VCaICWOAoQWI^c%9N#wI#Bb>kZQ!u1#jB|FJ zqh{UdX!YhE8tQ)m919v@?w-F$G)R<%yW}E|URwy8cZzOtK97DkXTb`cV!Rt9?*f%i{jOM0r_s4K(&vL~IDno*C8~&l&MaGb0TZyoS6?V~Y5G4N%5p>U4 z&G8ND&^DI`f}g{y=+uK9yrudnf;adU>iQ=Q?IoVPR?7*veR~-_aC19<$u|L8YxkCH zxH5*{Wnu<8t0@!QFK1R)?S*NHxynewQ7QDcN zy;s^!{v42jC~r#s^U-5I2`*gT>@o||4`rQ=yGd^LM&Xm1RV>hO1wZ(rsW3a>G5o0; z#D{I~F^3hii86TxGV>dlZJrp}A$pc62%fT8NungJXFvNHC5~+4&k;o@pkLH}!z4*Z z$Uk=y!WyrFe^&-i?$-M{dBH{06o}K}chMy~HE3 zu6Ro4OuIY??e+Y?R!h%fuVePGrBAik zgR)ApjoYc!c$8pXnK$KYpND{Pd2D;KDqCT!$MO}0SnZZJr$5PJAErNmHI4zq{cQ-* z-0i|zU&xTnvwX49!(MP(mI+snci_=*GZePR9l!gn%EoB_rdG55!Ew<%ys#&mC%@O8 zRn3`Bw_SFHZvPC>h>gN~RHLwlvK#CQoj`+(s%Xw148L;5<7xkK9KjoENIHEY-9FC; zZP2%=>y6(||GKzhgJNS`bRFo*J!7E4tsTua|HbP#<0&xVJ7e6m1kD+mg6DLr;Kf>h zkb-sxdcw_o{qE;L#)jk2UrBIiS=R-|W6yGoBd!Y=rOMaVPN60ZSue_J4o-l)zvpE&WpafLZAOJ>mrFClZsJ-{NY1<3j#bi6m?TXD=C z8^7H|Uuim@@2&zd{cf&1%D=zT<$P8ww|`c1`E3q1BkQoIOg^64eqZz zP0T+Gf=8nYt2q6Ex$k|CPaQ}ger+-EN}z(}&4#eeXdka?o(op0x{hc2ZAKSAU&6aL zay+=JBly&-6&x$|5tm251aAFfKxB^+miWDdtyRy%D~poQr{vo(r&ofxC5w=S22=5} zzjdOUzwqi0EO`#jU4_+NkSCSX)-!z%OXe3V%VKX_f>S$#;kT1LS?SmWxhi*Y-_`4|<=Z_$ z$GZC{vRa=Pe>WfIUqLLzp2ygK$IsJGppzV)utDW)wsUwMNG4elH?BNh%{j${4fY}nOH+92w?nD~drgH5(JiTZPn-tssTN zZn#c)9RDl%!ql{UNL$Ack zO9o6k;mS@eWbsvk^z2L~(=8>)&$uM;bdYD0Yv0gvbcXfTu49>Iy28kn0upr9jfu8J z;^n8#!t~Ft$o!gf+^o{c5~L5a_c{7(SE4_w7uJ!u$r)_Dp&QZUm?nJ%G3Zn0KhVMh zICo_t8CP%##G)R+f9H;}bLDwx?6EeyA?hq!Xe~<}wby{fZ3EKomjV4OhlXD{1c3`T z)HNM;gup-S1=d1SweLM2jL{A0OAw2o}H2z!nd~er zG8dtW-@$0>vRU|J`Yp8aq9XWfAA@Zxk3g$^K0bCb3F(wi#&zpmX+6hk)024)HrxHs zWs!Eg=B*~XJntpmHSh=a*VxnIk1w#>dIe(FE5LEemUOCL1U_?951GE;n3snvp`~aP zHF^CNtlp@GdjB!%ca}hQTm(w#zk)W;55ZkNTrOff4;(&Ho}+9Z&qUu8%G5UyozHQ^ zQ1(4UWK=_X(i`ku;K@|CMx$D~kr;nE!YVKSVXHr9lbuRZgc=UeS(PX0w1jKey`qwh z`U>c+g@k<(n6nklPhi^VbD(y2I=d5D%t_6rpgsj}Vyti)b^5%({r+C$b4Cuy(mTcG zss^#?e=m@GKI$awrv>S*l^`?5I$=F2Wq#eXV!ZwH0WvSy9zGvz!Gn7YS@tz8e)J_- zKJV3K==RNJGCJR|sE!&LO74e^O@X)gqHg7FNG^CIByH16KblSt3 z<#*udSyPA*af7rOYvAv-7Y@Etwm@**(HW!f`Dn_s@z^Fi0-JZ=<)w_RM?3Bv6sWFV zMVHpAu&{n^x7K)rUAF!O9b&c2`-uiQXL+2N4=OXad8bLf*jm<6D#GW5v!#YztR2IjP^O0}ivB?5 zf|U=~GCA4#M87o;mMkm7Nxd^+sau)AP$HKeh?|H@hXPUd!G2m=cnvGI%pesKFJbR~ z!Y2Mmf!A{zk@Hj`-7JTY#$kP=XL=vx`;LIt*U7Llm4f-+1aPmsNMV{G32nOtpLS1# z%LPfa!|e>DrOI%8zYwtfIumE*%hILlqM&B50xCJaf!c5dy`;MrH%rVwlMJg+6@*YM@v zY(kxi$4Uu4wIM?}jCXVMm=<%upQ8ydW(kKd->vZdtO>`8rEBUPm?tbFS1~rfj!E zKRZ)li5I>+itkHB;Nj48_O{6%Wz0zdId0}Ze##fS9c-kbmyV&e|4#C{1n=SNJ3bkF zw3l~z%nzQ#&m%~@%M899--o?y>u~qFKH6`jMAK0%w1r=T@e{-Zha7Y9j4gS*=hauy zF9jP=+>(q%_mm07pLyWGdTp@$wCS*`MSzBL!s`y6T?_{jO+hMGhfe#OMZc`jL7`)g z@m|+U;uV`u(&tPH**IA6u1sm-)1ZO+1sWoHLDh`1{gtwL95g^;bAm z;~Yz!a+7`jDkZd&EkJ##ry<_dg~&MSv&j~xiOl)yTxL>-q^(;BiOM5zY4Lg@oY_r- z46@P7rZnO+!u2;a=HtXmbxfUO!-cMrB?VFn?6GPe3Y~b2mH&OjCiHG0YpQfP4(Ap! zbFC&h|9Cmx?V3!=EGpT;lbgw^Yy0Vg;-z)#zlY&X*DTrP=SxVLMie)Xb>a^?&TQGX zGtAEhFiSxD~$7W(KTEI-P~){$O#W@}4^B{+WZqKPPdp$ogyrGnOWny_^X z3Bb4sSoJ{#tO?zT=lVO7%HmOo-RlU?hX%mc)dQ0xJ*H&LhuyL2*p8Z!R>N4B6f$41 zK`b4MFXy3gR}8MW=OTu$_TxcQJy3YF7bmIPN*kOZCN7-1?XriQ zCJ8FyUXQ|3cA*)jo_HiLAGhCK16zIX(C{>Qtmw{1ciVONWn;O#M|u)gGTMUEFD1Yr zoloeJ5h6Y10vpV9B`bc5vY=EMzQ0&3-{r;)R_S~M3wpLOpT*5gcQ6EJ3l{S8G>@=X zx|{e!tAt)Zq%9m%A}@5k_6imxO%z)FQp2~tMv{pZ9i;E^1m+~XLlo>)NT7)<--vy} zhh`3gq*prl#yPM9FWSjK`#FBfuq&&3{E%&5I*~1s*-He*KKwn4Gl~4{NBEBK39^iz z$lc*xSaJ1FcH2ln=v=A9|2R&9A7FU_3@*NbpH>!lqHP$OnO%S$uO6*iARhp+CBf+Q z#|lC4s3v=S_%Qc&b*9pWW0Bvc0o*d>BMKhiK^(6Vzf*_>?bj3Wd|o7s+)sfg{ITed z#6%p~@taPaN2x*49?<3P<mlC56vwkUp!5B$g zT_KNNxh;SONJeqHKu~uyhxRNmhVyp}PaorDxy(;T zHTx28g46A;vtl}miswz@FWtP64LRGAQFSLAsqfA<{L>S*bq14;TN=dlULh+Gy})J$ z)sdIqT4C?MSh(=j1o0;FNL$KPzS=tko-?*YVt5T47UM^T} zY6p9zK5QvHmFX3B)UB@_i{?#Qk4qQX0pt1*&H8DK?2#oO9+pFFp9!S)NZ}){TakBT zCj7M!P}MX;?0>-qO?@asy-b_vfV~7rcg4_U&oy|@Gh}e%=&w2}Ullsf*}ksfLKb@F z^_Vv7?Pcu^A?$0bC10}YDRFXkVZ6Kh*`kcyZ2YnHIC#zlXj!Zxtlni!3Kq(eRa=Je zM#GJ44dK|Jo9^Pd4>DQW-~D8>&18JbL}Oppa-6+5Vfn-wJpX4iCiXJI#>3}v`qe+2 zFQTI^)`gMrs3HZ9i63Gv)qG2{mm7M5JM^SPnBQlH{iq%;vjx9VSuh4iFiS|8UVa4Ro-vnMiH=%>tt{ zuu7;oyS+FCC)Sie&$i7h#m9&852oVX(fe5R=U#C6JOw|L4T7OT#)=wBS@tJUW-w+y z%bbx(0_EF5%1{QMnC{5sy6=;z(T*(Zy&`#eB7qgWEx}hFuVCs|D6*NH4M-w^DUP|$ z7aPBcO!m6X6dv!#vy(5A`Xd*FU%GA!CvV8)|MN@2pKr;M$dtRRF6IeI>5vmb;Vh2* z>c(YPWca+X?`ZJZaB4M9noSOSE%B9}7(pnK}VKu5pI@^_tjrtpdH7>xR2m=TOrKW3)r}0E9cA<7FE;qAC05 zP#HapCm5bV!!>0*sjzg~rjUu|+T5l~@>SU1;qSQXejBcMlfjHt2r5P4e$<4^q@FP(IAMjFxMu*inz9tZ#y;00&$IFt`@;Nv>JCoeEsH57V zxomOe6V@j8OZX)3A@M%{8hn;K0TXvKp=8K7;p&Zx`Hua|gy+(^J7Iz>yZ9vtE$H)G4#P{)1pVC^^RS6?v^0FT;5&qZzF!wat!dC7&K9) zigx(!;z>vwlJ(w(xWx3C!&QG5*vn5xvRMxJ&=*Y{e&Rc}Fy-U9jhG#i+Q?3?+KoHU zNbowp48oReJMfLoCeX7_id`KtC)>aK!K!T;f}`~*@P52HRNMFPI-f4ZCH+3U1B*SN zWZ#=B`>b5>=p}gwnD>|(d@;o16E?&4mKiWyvG*Gmj$n#p zJ#t-{#YJNzVcBhI)G~Ss%UCHgu($y?T{(~OwyWsRTN&cEdp)4&UR>F)!vAt5g#G)o zm$}HDU<1QagqM{G{3V>*Zctu0QRM>8pClukDqljZFY7R++xN(h@I_`*Q1c=&GLmOZ4Fg3Xw5pO0w>IKkoM&gSvjKURd!vjpU$o^- zFa&H{MMnPxz`ficC>?BthZ$4w(PvlDSDzX9SAPTQ$UOlUvP)p7yIZhTtCYT#{6kYx zb$M!1{?z*N4^;eYSYY@!fFAIy@31skCH{vJM{-KL7>ZTJgnG)YM7pq- zTCFI?uuwzz?#?kzy^Kj?&m=x?&oXo`DvI4&V=B~}wLzG6MU(aDm2p!>194UHCjGBv z_%+=Zk*-{*@MMKO6lb@w@tGkk?PG+{B-okIdTns7_F);zE)jLJ2iW=kb!;Iqng98V ztk7S77t#Ku$@Vy&07)wzTWZk(ZEef3Ls$%~DSUw?u5-P?g)_iNwiRk`<=_YA*7T0A z2<%uKgHB3q#HlimaH=}Tgow~(hsA!ty=5_&m-A9E`)n!PXuAm-O9=72I~O`V0bL9} zNV~^}z&E2@L8+=f-4(8d%v8JSk4c`quvaDMQD+3#lfFo|Jrl+6)$0ZOhUX&*Je`W% zb)`2ijPR~DXp^zW7SS)C-r=Zu`uvwtvq}AP2lAY#!%)QuV(Fp4d>@(Gu@Wf z1vOwX&0R!)p)UL6;l-XsU&a&HMuXF`KKuuwaqQ}EG&=&d_rQRyO4!lK3WdS!v62hZd;6Dg@eMriBZ2=>UWQ|<9Kk1Y!|*-9RPqkL zf+Dr~kfbp}E{(m&T4!x07Zg0myFC}#v0){l*!I1|BK#%$Zq5@nc^_cUKHVUnYF?A- zY;QdKfh6Db>O=NH>_0+GjoIVAXf|nv9=2?_Knnlez;b_2GtW>(;kc*JiL(KMOD zQlrAzj)~WC_r`m0Zjvc~$|Er%|2Cc&T~HP7oWS{xmk+Z94=1$Zcp08ay@Wb@7Blq| z1?+sbf$-=Y4CCyEptJD{-qF4gPOcYX*VZT4Sx25dU8RH1?6?XK(Luox&3fux+Co-^a5&Z1BiY1M-$m?;z=unUn=Dp287CO4TeS*f;D%~*%wNidQ= zO5XY3EQ8@k=W7ArQxc?4R z7qqcltw)fPkP8Ka?~rQSMhznkD%gqk*LM#3T(Lh z=(D>z-dG|53LgD*b-65+{OB#-Q)&(V{$nBK2~S%>jOpC&mH0>aX3>=31mq&OA1i;l zfTp^v#`bIV=+n*@wCcDX`fZ@Zg#|0|XA>3*J^#ym3#-Co-R+6_e0!MVE5WUoBxGt` zsW4a0$8QRrAkT&ze0#Azx9VjgD{B6ZZPdp=i=P%TakFGQbygAGzv-+(X#?Juy@m|( z8De#Z7`Dgz2%WS>o%?52Mvm=fv?NFgy#5_QPU-TjFzz&dnKlPGl*Z#d3A)Tg;0RwC zC(i=(Brx?G8Ez>5od za10Ob9Yi~iPlh>7r$suqQqkDLLlr|UbU2mTHRPhjc)oCo5i5ME%`522lL?h`$hGD7 z$?TfLq-5MsoamFp-sr3#7o-;vjoHmiO+Jb#{kMpZpLUa64tz$hZMMyOLeczrs zOq>MIkC&hVzY-+=6^^`De-y9QSA@s5V@1%=i8{Si;LW90@C$gxUM4NYuWg4CSuTS& z3>|>E3ok*jau&W8Jcg|fk>$&$Xz?CN?IINgZ?GRe0~S|{vDZ~)_VtPjZ5y6i;nZM5 zY_(H6DR9`gr*L*NfSOHsn zBGIqNQ`G%wBX-KrXDOrOQCe3L{L>&T+Gn+>#bG{Mka3g&&4ytLQzUOkO2)#x}b3+ARPtQKsPOw@Sp#Y@DGpB?F(at9>D2t_jFUT@%-5_~Pb3u#uwzRD@tY(i$`GF=YwEXg zr$<(>qVA12Fv}e2&%DeW>y@WI$=^@j-9pQ}yOu%{IwCPblCVkLZH=SlP} z?;42yBj_tuz?0QZV)eWL(KAhflXOd$?9o!dU9#tp(vL^5e_#`i*{lk?V|HWJWx3RF zcPcFRZWc{xe20z=SHy9mkJND9OZuQdk(zKa^evLY>mMdllH)?pzxydtPX38xIOIFJ$|TL-@et2RL_o0sfM3th`y(fwi8{B03**3EJU^S=Kzf z_}@<4mh^@W@3@B3XPcl|dm=?g7PUC6d0ktvZB{=uR*XR>`zE1)3w}@?U58F^rD$3} zExk~yNI$fWcG%jykGH6p%>Asf z-?3}xQ;UnZY?~$a95e+P)un7qx)gtW`9?A`{RoSDp~ylvNTBZaR6ML>BVTNz#?8Oz z$?siPEaLGOyf9%79-cEoaHQ?Sal98Qzn+XfZJ0-5CU&CVchAEr6D8vK^($R#8U<0Y z7f4WKE7mP5$NT;&6R&I4_@S&8oI5v~OR`hqzk>uhP#DI?eF{ZxGpyP1VcW>duvy$8 z!MQ2m1lZvTGugk76PfoueWEU)Z(k?FGF5fzp_WA5cAG#- zwLA`$;_-cj1>%yC`C@t17*X!maqur^A}+i;7ad*MN?OK@Af(xrHNG!rbqOz-r@a?h z+)~0eRCVGdP7!!x-3WFtU;?t(u1X@`)srJVx>SGD9riKv7Ap;MVc{B9_)h99Xw5F6 z4W~kIac~vZJyyd$*y}RI`L|g!&cY3|=CGMRkK&J(ud!Em6Kh}af*kE~Bwc$LvktZ< zUelA=buCvwJr7uQh94j3XG%PmoWK)R+8}6uG zPFvWcd!bP8bA$Ozp&T$Atbd{0_~iDaruGK{9M~Fc;zo2*q9#*YA%&{>NpLw z-R+=*RG9>%E(^u(#UV&-*g0xFBo(Vf4#gg445;n(6!d#$Dm*zp95n7F;|xtXlC;ns zv`1CZ!0oeW)^THO=<^WityzJ5(-PpK>v^zQ6MOx6DN;~FXo;^C-sKmCZGApb@~U<1(mVTY%o?l+SHF`cO7IG=Txv?zw}v; z^F@O5gx#Z$4*BYHn!U2q<7xvE$?2%^Y##kcjO(_ML}h2D=j1{Lg>TM|{-bQ!ffHnV z>2kI!YYbbX%0us-36OGsHYt5J14m`{uzkCPOtmPF6;%T~XmVq_S39G>XV0@Y1EEC! z+z;}`Oqy$*w1>UuIR@=3?%|*Foyh&ZHh~{(%_hF(aj4l2i0h}w!>bpEdCdZ^`U$K* z%$VIf)(fgaUQOomFw&M>PM$Rt!ix)j#PG&Ac6#1wV)64ScuSpTD|;rAl9hwl?z=t= zJ^Yc`LiA_V863Q#TWmF17b@nQgp_r5wD!$e zhXFOA%dBVsyX%AuyTNQawQntTU%QVw?rWotTB`VR%VP1nP1@onUwd>Z*8{!juBRWT zkK#V=?qf@ftoZT|XF*dkiY5Ktfi30qnT%QzPTZ#k)x(_lkq=jrFDn&zQ)a`ZNfqIz zqylU<*0Qb|32w@ivqU@15Decda)o0vk@CbCoSR=wjJkzRZB8m4A~lp51bt;E)J`&f zRt%?J*@TU!O=E8bhn$0sEeekfBN2~nvC)|_(W1WRr2OJZ(e~Hhm}}2bez@3^9gifu zR`Y)Ha8nnZ8~mE?o9j$E-uKc=!LOi8dNH1SypXI7OTvGCoh2(~ogzjvwMeGMMRCV} zQRHWD9Bxk4Wo_rAnZ=H$;=^wf@j<6x)PL*&y%lsE+YFC~gEQwNg=#r0arG;maOFMf z-%^c!WhX-u4#uZX%*3Lf)i|#q9?6*P2DjSnu%;ubL3ekpz(+R7;Om0-2Ax2#x_&-T~PW&_n*F3z-46N3$A{BkI{<$mDS0W@8 zH2KZ-Ls;RF4J@Ew7zx}PMgpOf9G@0}^3^WD8H=ruy~`gz8llJjt}TEtMrixnTg%-k1NlDpT_koLLpu!-w}G`oGwb4mubI3S1gmsgR% z(s;I1wiFukR+2Zf*Rc_@(d=FFdDLQ}%FkXtof-dL0D8-L@CO! zhSP`P`V$fM3@Q|>yi~{5TYd28WLxMx=T3LrPo#+sA4G|!om4?D6wFeE4pn%!D2cg= z4(>_E0i{K>LQMs^o23C)FAq|6$MB2iuh7DzJenxWsM&~4@!YLN=-e6*vGRqf@Uh95MD`~@(G?e-hD^g_v!a>KLrd-=G>`#Kg7-h9&(EH9 zmkBLAvU&Y$VmKDD)5j)3SE?U-zWoxLGqVCD$I5dmKbm2Vr&WTypz}gT?=7FpHJp>E+7TtQ^}L;CcLW0f=w6^ z#96;vNgjW9XAOThlkk_)Wc$WBWcf}jlD9KARwr1+_3>oR z+ZkZvd5uLD4R$y=EX=Bf+AH~mS9mXcF-^2RBcF>xbg#EXirfx${!R~aX8jxw);V}(8YhP1GepECDg-#9jR`DwO$=?qfwYBno(Fo zgCO^@Y{axw<`OrHc=b)>?&k-xBTnJyMwGe8`fe|g>Uu=>BnQEp$Tj4n{!jA!UnpC0 zwT+tY^1@b91*~4+X^tG&PGtKY5zx})4lm&N#=5EO@j5rA{&)xp3;D=${w4DznbQ0q zH;TKk(2l!q)`OGlzp%i&Nt|ibL}9kF5vsZi*+mCEQZ{xtpHbvNN|x)AA=cVl?C-C% zZ%HwJn3Ie9qpD!Y$Ryleu?;32b;Tbg%$Y;51-6j3fvI=Z&}LGE|9zPX!(PUrC8ZI7 z)}4o#X#@D%ypOn4)n4$_T%$|NQx)G{DQPM`X0?IzS7{n3T}yHi=?iL2nEt4zjlhIDPV zI~jSy4xf3o7kgw#uox_KLbp7F(2r%Xy}KLVag-Ckn0*t6ZJNwnN5#SY5qIvXqw5ap#dXo53b~vo< zzKfP7>T=y*Qo+qof-Nv**Hq=qTJFmZ@{deA?jK3f8 zzP0~o*=341E0$m`G#j?IzDIgF@%YfCMeO6VW7wkX2~6Gjjc(pDm#Iw7!Pi&lql965 zsmw(+yk+z`aQ4eWcW#%U$r@4UV~G>q8x)V%My*1|T8gMKb2@w(6-l?jom$rp4CT@@^_^K1N>EGy{;aVg=W*@tf@qk(1 z6nrqd$Fs412JEH4B!{`bGL|m2w&`*jqqSHzVfuejNLDSYXjOCPMa! z#jIGfyW7Zv0jEIlgBZCp!9bA{a-H67m=(%;pqjWt9WS^Y9sH!F`~2$b$Hck%g~{ zuSgvd!|n`#qA|7LRMLVwJQ_r&6O(Z8>$Bjx%@mIRHp2R=eCd*d(bRYIS$e%>B+k7g z#r{(*L=o*r=rF4>5M(?>JZoMZT_aP0qd5`RZ6w8pXj_o7))V-m?gzH`xiOhAZX|D> zCLGh}rLxttn#tb8jbi!WGIF8u0L7t+OsYhc-zB}3D9l%aehpKac{Pv}@8eiPhaM71 zG>IZDtZ9e+aIXKCDtS9ch34KohVNI!60H;i=0$qQC=FHeW7s@0d`1*8ZR*2KJ%f0K zz>DkOt;NkXy~uVtwc%g#+gQoUh>BPFDct#H3x3^PTU1-zF2rLTiA8WQMBS6-TU)pD zSx-iCcA1q6XD;92TXvrHcdGUr@EVa`-}cJoR9ubkeVc ziZ3bWk@3T!^vuIfbo9tl(eAiXq*1a^?0zf-d2E4hN#{fl4~(S3wR@$}h6bzUj7mZa}&gVjP#g?i29^*8<`xh-i-{dODkHb~{H8hF+* zdo|8~j)u+=LgqKvjno=;kPGk%w?`$y&CUe!QtJqvC6$9MCGWv}3xU&8{|$R@ zOMx$u*XjJ?V=%T+lQ^%y_*`W&Z~{$G&6*k`Ejbuhkf?TBwzhk?ndp>QYE2$`M86Xk4bt$6#zoyewp zGL1uH$lsPoTz91B+tN@|%?`oG zVZd}(Sg`f?m*HJ224Q2MA2B4qZH7Cze<)4kZIV`$*lIEasvSOsvyYC^fAHl}ck=6)}$UsaAtM z!K-lDlfyJh;Gkrjxk&Tve@~7NT5iAyTBG&#RV?yG%XIRBV zi;2htRrGaiOD|Gy*CUU68rG99|MsLO1cZX!OM4XwcRg+TPmI+oq?%{ZKWUylw*S zaOy>}LMHmKV=E2M(tx0x5EjH&V#jNiY-syL6dv#p48`LaTBtxg)=Bfh|2V=I)?f`? zCDijJ0Gdan;e5@Lct$}8#q!p$nwY|-)Vs7!?}w<_cfNStzx@?bo#{ya%_ekJ+ZB~Z z*3$R)9*N7-v$4nRQ1o|75BXxA!1MB+@5&$_ZHBSJ zm$9&G&ID$vPyiCY(^!qeA+ksEFP@sKz{Pl%K~$t6De9}o_q+bESl4Xm?K9_B-!$U` zzKd~cWiFQHc zh*})?Yd;O!tAnpj@WFOzBVb^-8@fH@2)5T~N9PugqV}FYX^>u~D9d-SVp?i4N;@XP z+B=TXESOafZ3pB1dfdjd!}yB4 zE$ot&Y~?@u)$jhY*Cl;et55~~E!-s5(3=MB{x10SgLIMT zdkq>DlSO^k)X;U0vY_HYnkX*nD9&va&;+N9KyIxt_wboZx~hh-2iwP!3tPNk!>&AZ z;K2mEGN=qMT~P@Q^6{d}%^tYqPc3ZM+ksj%v(e?(li*0VGmcf7glp^WB3Y;N=;Lhj z^3Oi1Fyu@!ZBmp4_528`8TU*);Y}In+pMNf4ydByDj6Jook2|eG5(6cs{PTT#J!ns zOnOsW;oGw1L~h?*Xd9M;KVCHB$NyQzwzc}8itJAG{_}Ux|Grif!Zzby=iZ}LwLDJw zo&%?HW!bW!GO%z(jp&-t%j-Efgy1waqSZST%69K%-d`MX&5v!!`Rqb|8eKq?jlVOm z+ag}iJVvzq^?nF@H;b%oJI8{|I)&cM4RS@`X4`oPe#(sf#Khq%B$iF##S1Q=7Y04} zbH^Z{Q_^Jr^?c%VkZ^bAoh6CUxYKXj-r(?YJ~zm#-UnMb6*Nim)Ch3L3K73Ee`qA8QSkbmMR zHZ(>R!viHmD+ceNCC^8QwVNv)e(>kum%1vRePbumIDd`Sx&)z4on+A=euQ|~$=T#{ z$$7R!<`bz|bsswQgG(LO@au6IbZZIjb_#S#v?KE?Qf4a-q@mQNPH^8;i`{p>rjB2? zpzbqUuw2JFH0X04N*n))mW){lADg#|v-2>1z3M*wSt!i1*S)4XISf@DSH~+ahl%5s zZvy*Y8Ib1Rhc>-2$Da~iM1LxUT+Pqrg12}s>R4ofKD@NXy7&v4KS={W@YFzSJoeBN zXJzq$|HcT>MV2)P*JEU+Y7V2a@rd@s_5U6raQ$;Izjsd|y6a?cN`!xB&W-0!j_Gu=2HiB^4!}yXF*d*x0nuL|&~0D%8CB5cNDf(j=9wIS(v--f9+Z-^0`g%2`2e7xB4i#|$f9fmL7= zmY&&;>d7o(`fU;vUz(09JVvwTQ#at4;Xb(L<%OLlWQcbzQm4*US8&Zr9zM9X zqPK@qaeGM*Ozn??)g#>4nD5s?+v6qvkADZHYJYI$x0|T*We%DVAciR8QamGk46B%M z4J&=Sg`Au=;~lz};b24;U4FnpTwnKGU=Iqr?X70uqw51vTYViqdu*l#!-bsDZ!!K| z)QRA*p-ASHJoakR!o#r}j`QOFE*TYI40r2 z2IlN$7mKHnjf-F5#*qiW_o@XcC`kkRD#GNIgu6~=7`wN}oL?Dh&1U_YL;`He$YKeO zI~sk4w3x-PvvH>ET+nw~`QjmNPJcwCj;0WK_kHZ2t1+2BVKfA;s)Vr%_H&)@1K^3~ zG>i`ZCdyxW;ECr**7D#oJi*ee@=A3i`Nlrfp%6<%T#a~3}pL|i~PH(!TzY^QZm5cw*o&x`+CByCs z9dL3+C#v4P3tk?Nz~^o+5|61F4waY2K=Rj6QSa@0uysHct$5i%7ukKHc3YmJ`--_} zYwB9sJm5*E^Z%jIIzLhP`8%jq?j*Xuwijs(^P&6P!-=fLX#SekFrsIo#2&4gNyLfW z*w5lG;g?}j?C}=wxVM!}e5K7t`wT)?*ixL2AJbb08*o=<0hy~3Nc48RW8c#A;ADV4 zNelfCUoX_;r@sHiW&|kl@JNz&Gz19u%0zOctB}Y}nNI2ga&TqZbM&U`B5nHc9iC=S zgaLjK*~%J0!0Q;&(mH~rZJAESo+@OzYy4nycAm}IqQj0n4`&u( zA{JvYKr$aCkmVZ2C?Kgw@CfTOr%?-W=I{=@R8EI=g=FL1IalyW9eZr^vRjlFFoI^t z$Kv$6JHaZc3_gulWNXIG#5G%m&Z~(H-7~}pt~{NGUuD07efCi})=f+=TAGXg+!@aF zLTs_Yh)!zq!K+q_2A<{C(ygxjC^u8L-m69B8%U(bbLw>O3Rxj zZe0Aitp2hQy_l9m9n%#Z{#7c|D{8@5zrh%<^%wZ@`#*?2xrB*=zlDfZ9v@^8Usof39Wl8b}zQ@pxOUj(Z%r1OR^pa`TXR@MorZhuMi4<888rNt`e6#Xd zD`(8EqfWB_NfQpg@q(p}o=j3|hVoWb*T|IByt1 zC|>3al>E*Iu!|S=+C#|iym=0V^5gLH-3YXuL-EO7{-6UPuyMr=vCSV%SYNdUM;X|n znicaw>&xYXej$6Q%Q=hjpN=lr?4|e^th_5$t3)c9Le5% z1!`80A&w>{~pUa%0JQ4MlDu7D;Y^ix1*_+ zu0odQ8fd@wz!JX7tiUlF=2a%5lqu$9jKdR{GwmLl6+8aK4b==r8Q8 zY-nKNB=FqUfF9@Nq1-J?$--16K4ZKZcQExKu@v8B))5>zV)lSFojgJMBuBC1>I0&P z=fZvz)cKWmQ!D|unpy#$f~tdVcFUyTJ-1?DUppJ`f8)N({7TS ztGv(~`7DdnU)&}N0)z2s`E#b{-3xU;q}cY!^2{Kv6Atdc?B%8;wk-B4w2atB9Zn48 zm%p>+YQ2QL{JT=HaacnRO}k50H66#UzqX*#qC;fN%SG&PWdR!uZXqKtO0k(q4e&Hr@g!+~+mw0tz@wtJD@2QdOr!LT+iD2Thl~BC$CY+aW#orSN z^q2iZ?Jdoy;XT8x&&JYtP!u1Y5l1tl55UZZg?Q6~67Ub+h7O&Kg><=6csAz*((;c& zU)|@EHMJ#hy|!22}S8b zpYIPTb-2k$qaSblB%16WzKXn!v|toOaK<5*O?~K0WV4L;iCskSp)DYl%Q}dt_&qtO zrO$uKVdA3sFWJ?V(QLM@60b=&QxciA z_Zza@*OiT~RDnC1-*Ke>45DcsODi5 z%?Nh3hNDHyX^x+!UYPA&)e(WN6CSk&sYUNIkK#NSe>0RtX{~^Ddyt zomtem-$E=|u7(t@0`k*8;*dQwOMERhOtk2kGm<>^9zQltV25A|+u}Bv#7)QGown%pCFBUW$1lC+Sx$V9lP~KU1zVJA{cgBu* zd5Ku*p~*z&$tmJ#I*iS@aDsUEttY?Jc7jPrCcT^=4#ow-ZnUkN9e(#!VD1d(^p$Rr zQ4$}>U4MbPYT&^A!FlYnZ7&|WYy)KGCbDxynL>|lfNcNl&MkK-CB433Q8Q8b_VuWHXeyF0`a$0}hvKWvg46f- z12p1~0-n}8l{B83i(^afind7AKweXk*gxeYoORra+7?WOzNzleyL}`kI(b;xD@okc zlu}VsWk(>V2k2G+`J(XGVbUSiM2bBG3C#UYB7Ho>z>T^X7KMX*{{4z?3)5o8)o5U|C_Rxb)0rb0LujsSiTF{YB zCU0#snKmwl37&oAn(A2URs8^Gjdlc`j0P|oG7iUOjYr7C1zi z>QNi}A~Gy8pTta-;NzXP@{?QMpr08M=xud9WC}fa*A+kFW6gfj6--I0^Cb!7Ru8B>u0^57wWF6}%|&#QU-|E8MbM{KE4G zUXz2sdi`U1H1-FLG?BtD?XqZZ-#fb1?HJ6{x`Iv@On@DtmtvDU_v!l!opd(mFS@); z72iE7$OKH>X+fkc4a>Vm`(BuV$EYG2>o}awTz3j>m7vHe>pfKqaHY8&%J4oQhTc#! z6sHX{g2GxwBrd%n?lVxqv9?1X>u8O5YVi#)h=La&eZ$jfo-=bcR zpNrSHd7!FJ3wkg?*hQiyRQ7xmNME^ymbkg&PxmfUMJFDn?v;h&w)yzkkV}YwTs zBvNoNLzW)Pp+%f5dj2Vd`X9+hx|a}gz0fbxZ`Z(Y_U@r3*9{=d!H>GTXNZ4a?htnd zo)@e8wu+Rju87{c|0fC$#AI}h0eRJG&mMj}$zl^2+vAl@UhUK6B4p*b60gzR^nN+s zQDFL9SQN^J9ls0?9_CEXOP3Sw`Ao9tDczuV2P;t}HveZVRJ&;M9ZuuP(6gPOmVS*$ z%x*@bIow_{n}{d_2TwGrvec3>2h!dpu}np&Sr z%=iAIgWozGijSYeOQ{)}Ub_a*a?U`J#eI~wk*LV`3c->U3LqNUBc6=&>HN4))a9cF ztUS1xF6&dB zW2JuAplw?a8q^s^3M7?T(1W9RYoI?~`+KK&cx5bhovMYWPv6F-gqgFqGz;eNp=1d@ zg-dKlkf!N!q^Dl!O4irmN5;FDlym|~dJxJjs`2M{$|d7*qdu~e1DP27OvsmiiV#*I zO`a?2@`>S3nCbrSaNJA^KR8BWcd z|3E_)=YT4@MpiC-4-a1tVL!*|lDd5rFvLLc+5MEj%7c<5V7N5V>9|6zaX9uVc!NK+ zs^QvRD{*xDHuz`1P&Cu62`_4OVb>BY*!*?F@jp!wRrxaq+uXfHt1X|QFjak8wYVAU z1m{u}^Fw&cIR|pnE+4eG6>!F*fX*hG;?}r0+BHk)zLW`WiLk$-Tdx*SXR{$C2 zD1EzN2e6k$Yx6i_9}KAy9r_N-xq1-JKq$>#d>4i!#6>s za~F%$K8u5^R$?jBbUJ+42Ygho1Dl=O03YNPm`TY@vDfu`pgFz|)IBHSEXi=Z`A;n# zFYJ5PJIX@xGKAL`AIEE5obbZ90X*tWD|O6Ft|(f|M9>l8`Y%Mm8^Y;+=m}VqgJ&Mj}}|(`f4n>KVdd= zEk6U!H-_yinpTi7ag8}n7A?48m88f?7{O_sr|`05X~;M_Ix z_>KbJH8}!(yKG5%+eDxoY|bz3n9U@7C0ORPEH-3n21!+Yhp+$nfR`G4rg(oO`_g5B z-41Ss^M{Uu_Rtyhn|}_Je$&Uk%9Y4+)II256b18oZ{jNl<-lT?K3TQHlKBjG$9?sh zSmsC>1kOpvHe;p$giMEnGSO(Uju>pcy6IPy0xGH$+|dhD>9)4Z=gX34?+E%3vFt3#D^-R;N|O`w65=l$hWbE zx=VZ}VjE0?Ow8z^aYM!iwm7xLTZu?Uro)p6^Ewf^lwj;4r!=;Lg z?<85RoeC#kb&4sBN+Ei-7Tj6&T#^%4%wo09LfMKG>NfEd$$76xJYV+1_LbYfr}`yH zGsV4E*f&c7dlH!4{|{u_FAJ&Z&)dD0v$}Zf`zDZstrTgD2HEi4#iv z+^UOYyCNZ)j~|d@Zbxy*q_Nz{i7NEM(+G0$+K7tX%?H7&t%o#bi7~rA6gND}#_l^L zc(?RM##=DBGH~1DD8wPh&uWOQFa2-NV6VNwj&`hD;hrzQzBzcw>eYr z_>c(->%&3xGoqp;c6vqU>~i$U{V8-mJSCjPi;#riO|2F(X01z|;iHQ_lx2kBJBgHz z+j$NyXSZR?oA0Q}QYrA=st?FErpxR!z zMP-P|;~@6XC5J^$-AY;u#_`6N_JUXAZHKm?4lFz282ivx0$rK@cK6TU!(q}|Wb#fW z_HSZ8bnX0)#vEJ;{QGFc*C>!39rs#P>h;CcZ{fx!OWR zthPKMax#~Q{pl(eazUEwFTBNK#^DnAiRWM>y-U9IKnyC+8Kpwx9#P4n0k3!#d#XMqQ#&luXLoTEznz>*0sd4J?&X zjGEVS`02WjSi5f`ahrwlyR0QJ=IuX>D-(qK%Oa@A`2yKa#%#jFT+n>?2YHtY?7Dwj zKxZh!^JQvj!_Bj(*Uyt&)QD%we^w*yZ|$&n*>4apEkU2xJr@TqeIR7Arb9jF2vt*+ zX}`ijv^eiK{UE=ADu~0xXQvd<0V#WN{dpVF2UCHWYZd}WAy0I=?^?yF3p^?13&<|r z55(<-66d_#i}gu|vt72X-Nd-(Y#$(B?htIEGar*|ahXLT9Aed4`b z#j4!%QgL!_y#>y>h;srn8nqL-;s+@}b74P8m*j*s6mI%9d zmr(az=EBPnK~Ptaj@{2sh9a@iMA=3cETs9Y+4TG9uSXP>Ja&S5j4BY$NmVAZe!fA6 z?km%t7-N=GcZLR>%7eGDX|o&O7NYb)Yh?6g2hEC-#70V&(FCbrI$u13N(_xeW{>5e z-%|!|hW>a`KP-hXkX4t z%&9D7zXi3-Pa=tAV?Az0@(i}_@+a7REJ}eTsC*!0s-bG5XkCrxUTcBqI$id_J&w#bx8UlPFjLgK0J3qD;Ie8N{Kf%vV>pG1 z@iEp5x@_4L87cPuq%^bJ6^MPW1z_Ei&9Js-1{@fd#osrQ1jeVUQS*9ZIPvEKTGVEV zJDSSrrw3C&S?2`S+o%jdf0NK^XhgQpHVEu@CYbvFUkFE-Hg;r8s$r}~g#PX=1@^dVjPAd*y%9nZ#Syv64CM~P%s zsf!E`-@g77`Zuf-HMGjmwmrNz_u~+4+A{@T;C_aItU;dw(PcUs~sf<9pUI zwaJp)!Ww_LC-aGHkx<0A-k;IxUXpVwfYkImiVB^>*gU>hW}C1KCq{>{YPpvn|FN1J z863@BxV41~;&W6zQPO0LxH9+q$QJ0|77kGtEzmuBlK!bF02P}sBL9KEXLZ$+9ci}& zC$r+QY?}r9ef%ABa{A7*dehjZ-8p3R344>an(Qtww=Mx zH`@&0P|y|Jb8;m4(j81&@0^9HZC{0Her9;+M2E08Mu|A_JDWGNWk^RHVJ?3XgsKKL z2n{K*zhMrOgZ<@Ya_?Z|yzw{ntzMoxxtTS!ov@`|cHTtWrR>m4FUgx#Ed4_t5Da??tt_ zz@IU#c-v#(_tfvOcfv7psaS>lj0<7H2^pkK;XS$WU4ebM6Vp3V* zf9KiL8=+(cb!7G)pV=O#g~Y^nj_CAS40pFifc|m~(S$D^#9=}LelIUe9@pLnr1;c2 zs_izdJbN8~o%H^rU2!gUH^&qr(D+ph3jcQw~(64_2sH$f& zB+O9AM23y%q17JP$i7ti6zTi(*^UF~S~`FQl& zXh0}@f{@@YU4+1YV!A(DMVML4JR$aP!LpRPnnq;bf9hS=?G zJIgKofgO}3Nab^WZ+I_-`Dosue!Yg=@@y4WEuTe7j6K-TDN@{$gmO52s7V;BwGtJ( zJS1NH9O|6cPxgJafxxTUi2KAwa`1O+g)c#?8- z14vycM#ZBe_|N24S;Rxb>i* zf}i>A!N)z6>8lB=sb{7m;{OG-=Up1hZY z>{!n_<-Y?)pHN$bBx%k5$sXvOA$KyWU?T}-zALlv-gLlIPI|Jq=4oWw0|)l)WZysI`{llIJr`;DH^dJlQp+RY=`y(yyl`T8+IIK7td^h zd7gnJ`H>PSkJRB5TMUSq!vTgrjbrA?zHEBtY@D2-K>~iMF{B5Y&`p;U}*o?fHj{QkrVY_@WgM=u+o(2Z11;oyoXtjcNmzX zOD>B^%3?>d`fwv`&kJGR0|Hq0@eVOKp@E;BRwNxZ{lMK#Vkb6uv5TMmNWzv9vc&Qz zPWU^8MLQ+IKevTgQ;hG*&1{4F&s}lkwf#il-ab$;=XbWTBWSZrhtRD+m87rOM8pg$ zU_rMmw|)b^d0e!WRUUjsp07~A5obn|Ems8i#J(XsGRB>y-<=Ok!xNPmz6LUNEcw=R zj{S6)MTQcu;V+}dkgYDGV8`-fxPFcf4bTe3ANKZPE#5(IQYwqv%k62;`Ky98eCJpc zm5nq<%tm%<@yJw{6W-I8#ZG^W;F6649*(aOBs8ByF(2*9g;%!1_8J*9DREeM^1^t? zCwk!D@s-9qoJZGR)KTSU0oY1B42z9)z-P<=DJ{Egof0|HI_&%lYIQt{KSzCtkJL@; zLZt-Q(c-`aV)~p;q&rm($tSv7i&%e=HW~Rkn}~Jki>zMWV|S`fun8@yc%It?uD1RJ znw(ilmLw{Q_RKxcaT$ME%Iv>Pa3Gjf24^uSmlOR>xW=X}+{?l$#YCqY_mb}?Z?o)n z4ZdTzme{W3`xn2H$ZYjk_S`Xu#m8?FX%`;kxS(SsvowWzxGoFi)FC zoLyl`UMpq_>_>0HnHl4Rd47wbRXYlIUHX8fQ>T-a<>%=5$>Yf4;v1Mv-AzYs-H95; z~;lkj6O z#z|%&RQ-Jkmhll6>8()|wVof(=Qb>f&|^Az9+1b1CvRb0zb>(z0;~q$4Cy>+O z6}(G97F&GvgI258)ca;Dq;$++(r?7r$vIP~*1T>y`i&BJ9T@tWjjeHB9vqOdJcs^Osyk#_PoCGvJj}8Gqq9gAnh-dIqbt1bHv5{0~euXD*oydqBB}iDa zmdG9bAQ&)bkpJK>?8=Un`Y$G@T3VdeE{kYiQ6n5`^A72kS;l zflPE4T@iBzr}SHq-BV0h`({3$rO*nIxrsZ7(3Bw*9#0iU%DPRE)O8_0jYZUbM&O2|a&51aSiv zXwz9WtTwk2U2l9RcwbYC=4@PnE)12BdD=6%mF;p|^~eA=?|=?j+9EI5Ghoaq4kfZR z^L22YjyD*~X0iH_QA|g>f!fwSgG{^6Y_NZp=!X3xFj+=fLy|J<+VO;S24SknyY5YG zXIFf7BC0g-7hI_FB9obTU+r)#RBrrf}t3D9DYIWRm51 z0-ar2WdA2Z|Jl~v)y-8*(1aW)em6xooT{p?K-$+PY_Z|51<<;qI9woD~UfAiX~N}r2j4p=Km8D9q%6{T2YkBrcZkXk)J0K z=hsGX{>Nn&6#1SUYQVVpK_k=ZUQcS`dq|&B8#7)w0VgCpL2*_$`Fq(#_RQoQQT}m- z?8%A6g3pDdSMUW~makzkMb+3`p#mi4PGV7sTbOI+A6ykYMkGv}&mJ!eAtw^%u!S8B zNVChDOC{f_J8iiSrv`Da3CB(7iYD#pg=Eb82DWoj1$i{C zoJ^0LKw^&iaV8htxT%hR*~S+|q~2hH=%qtH41qR*q*CI864~ZXMM%z^!M5-Wg@RL$ zU}0XCutZl0n>-joN%F_bcZHZU(F-5CU)^sd0`?{%oz zI7={~HVr>fW0cF}h-Qcv}yi?VKhr|Z(g1x3#akza0(K=p(m^!0`i8t`Es#5I1SUlm8;oWhm#W^@ETIXtyI`Bx><33tOjff4xr&Q2P+ zMxUG2yOpWxuVL?0{}Vhregn6gw!jO1CoanMC9#Y6dBGkt(fDNk?8p+3HBp}A-z`ci z56y)$szq=$Y6rAmu^}I}Utn7zlgZuTZr+V8i`_Oj;j3-~Y-~{th}Vy1TW}bTkh_V} zcP+pLmv}jXAK*!+a`+xvt5D=4VE#Shu z@c_)4`$~8zC8+%BI}I|s7QvHuW2k7J0ujvg#FyiO=!Pc;z}CBsPKy7B_9}+sFb{Kq z`h00t?W%?Aw%XwBhH=#6kP>8`OhuJRQ*geXk@c`t7`9ZBKz_wLk;%I~ICr$@8WmLwL=^e4jofe?L6+W9Bd+r8f-0Bm zc)a5bs(ez8(f8-s#_LPS*^NPLQqmDv;rJZ|?Y&I0#vKJ0yAl>;?np+LpJJoBU%(q{ zM{4)Tnwh_E!RzGxxx6laQKs2MQDaXTUaT>e*%=jq+{&+P#f?eiavjGBvQ)|Vm%P{N z`cm8oL*&q^1){0i(xS23Rq2r)aZwjc<9?>i!uvCVu_)0OEA0M3)^|_kqNlGF-P?w3~4RMrK?jYmZsL$tntiNtuwf zTn{v;AG`}$1zDpJo7I|$XBs#O()RDe?)MmE=Wc~}Kh6t`f2?2@U3J3o?bq0b4MSKd zu@nakJv|aY<`0-h_5V1y8rGI_22sBxU9UWP%IAe^7PqEw;ar78?c-r^pOpatQ#RmF5+Yn%qmCD?(uGEwjqKg^bo%qp4*d7X1i%C9 z@YVIP)P3Cocsh|mwBc@^esl(3f6@rKQ=Q<^1XbAVl!L+^9}wJ&Y@rQQ8h`Mc%6oF% zV9s_57c672;sxI_W!owUuli{%82Lyj-K!7J%w;&H(@Y`_t|IY!Es*Nhj{Ek`70EbP zF(+wNQPAcMLnmyc0p?G=(AbcV?1 z2eT@pukhs~&*wrEyG17wi-c#O-Bp77=UyZeM=b*S-!VKfCXW_o9l-bLb2t{TA0ME{ zV3d(E>-iwbhW6=#xug@(_~Zba%oe~!w~?f0+IEzBBpUtPv=3_xkAkN*#dxh`n2`KU zqd9jR!9JSrQwfCNImZ(W+!ny!*9*ZfJ`8Cnl?u7|rvi^GNqYINKinEA2d7L0)XhNy zUo||8YJ%Sjhc79?j8iJqe1$muLPKEhV60$9o*nA-*(Ge-D=8YS^^9a{J;99;hgpeL z6@GnFg&VN@K_ut=gtyD=MH2j(w*6ZoDV3i^G_025?LYL0_=O4VxNi@;)KW+6*HJcm zr37b8AHf(+O>)D?f_wCLDVd_0NM>&fWbKweaJkEM;=dq+mE4YDGP>uPe_#_RaS>QM z_6?cw%~4pjNsTJwBCKh-o9BZ*CPQY`ME%M!Che92E1OE#wY6KheU@d|+9na@y_4fo zO4><5vKTp&|Cn&HEzF2#IrLafCCm4X5hYz2$Ieu4A&1mTV6<{MjH5$Td1W=2c3%dA z#UJ7KvBf-#G@l;vamW5YOj-P6Mwk2WN5G_5Y_t%tn^-Q|96cL<+&158Gk1Z;)$8Jc zn)`V6Xgk>K*GsE&>}k6AL^@q&7syn!;U5DN+0bZDT4(tIb2g`8lR-L+plP_z+7)G; zFB4i9N%8Y#KPYUpg2-wua6GJulT*uZx#=U+GBX8j%Nc21Gkz4F`=?TPH}fAWZ(hsB zF0LTfA-Bo>h#MfWRu<2W|A!-%*yz?i zvQsONc|I&Ag1MhzTx%7J8hrrm?pn&;_SBIp9{k?GnJKMs9|j71oSN zLN(9&*}&O&V(Cq zW6N{bV9&L0Fu$~6z1EJ{?P~`bu$>N{KU=We!EBuUi{Sj(;aH-_48|RLOFyWnuzL3` zJd34Pn5gFfHx&NCnhikTJ(z+c^c(3v=gH+Jeuea1DaKQJ34i~;Ds10r4sYN7r3Pzm zQEhu)=#B10&O5cxOSByPn@u6`+Y`a;92_r_wXSCTrum^o=mP5H4upk zXEGpuo6knKV7cBZT)!!ml_fTjFl9qtj-x zNyC4fH{eQ>Y4}dIztF72f?9jE2tO9)2bI`xW5OmbG09G#xXYVw5<1+#dr^UN%tIJN;PPuAFI{=HH1c?t@KUCe!Yojkj2svcIj> zOp@;q#&6UkjZZJKz711wzh4wOov@7b%{>Gje(A9P-8JwNMN#g=OuF63ig_!CVFRA$ z^ZfBjPoEjC7SZV@n`8EUAJ^U=-4k_Tlj!Pi6 zN`z+~tVRY7neag46MgXY4bSciqpH)EGR>bY#O%ZhQR38O;`-w@QF@KZ`#&`}pn8Nz zFs+B@4e_k@1SN97Xc^h&I)*M-1<`B2z9Bo8ODO!!7<}k^75ZIr-Wsh~OlNF+ zLrrEEQt_HJBp6H;x+rg@7ffnVhe3|O!g4Q?-Y!n>8Ow`CHqB?+t?Su*^J(0#0#mG! zt^o1>B$!0vbGC!$O1h{xvWxYlL`>cvJj2ZJk{nJnud4|4c$#a%|ym z?<8jU!~tK^8x-nk%fXuPhuEfV6^QIKvDAxL+#lbIdZ)Hfsf@6)oVW_SX5 zTCkICMT*?nXUE{=UrQ2sy&mMoci{1#3&{7-9#Pki&0KA@F<$g%G)&zd%w+k_e}j4r zm(pY*(jB9~-E7JwCpB%5a^E(ld_;`PGp%A5C+p)I&LZ0JIh8C*lpxzqrjdt|ujw(b zk65d!95pz!!8s74>koF&16CZAy;=#UdamNtBW0lNhdRC`bhS=uut4Q26>w4IIBa5Q z2>xv;aM)gq{7fu>I8PV2xOzEiGsqRbTqcf_KJ-!5YbkJZ%5|#Uqyj7cHkYsYTtYir z#|Z!4*+Vxyk3fC*q)~&hCn!q35-7>-rj1Qubjg82p{blUijSL(=X?DY+G*#~8H*%v zopv2n=Lta?+B3=Wpa51X)y;m5slXu{cu!nU0S-Smfs0wBDY`Hrlvwosq!qVhV1mA> zaQRwUvSvt(Y%UYW6Z!7=$#=%|ng14~aY2>sdMk-1R=z-n+a!ovs|V!oO9u1*9)slz zd$i?MxNz-e5w@8l&7G}K6MgPXV`DF0VDHns+4z~_WS~2Xg}1yS6MnxSgAcJNCVUG! zlqL@7Pzcdk^9-L=BP>F8KYnlb4G#M*W_$EUGKH-@WCK``(GLS4B_fC%8?uLG-7>_u z%#8h9J&%nJb|U6V+rcOFKUDI>5*vHogxR@DAlKOnL%0fFc&M;=%_C$*$#H13R;OdN zC)3(LF*N$EA5PQx2hPz7AV~c}r`^(p4US1@_r^JR%`U**5gy3x`v+K4r4K<`Qf#Tx z7`PE8hiAQh4Kp83p7KU>mqjdTZ| z;O6DZa}y1cIGg>FESIYg9roPIJZgPgM}W@BHQJr;{zXO^9(z4D9>sF@!@z(8~xyAv?ku?7y<2SVqhqjmz+T!i7>!-5N3jCb5a87W+0;49EAZK93~uF$VVvjpzfV$n3F0HQ<;Yg)?aaa~FJ zz{DSYn4}4Il1^}AFQq#hw+beGuSAZI9}+(CL!Dl^;BU|5xm6=3Fxi1jQYYRh7#Nid z7K?n@^I!9^`=Y71{je7PRQVbAsJM{MEFFA^9fo;ih|1jlh7B(6gW*AYPe9?T*qC(fn*}q6FT?hXHvIhL4xDUt z5l`zI4+@Vfu*z5?VWImnen0GspX~@h%5!2tcW*I0 zmnyWs>q2kVC_quvbUe1QRgf4c2|Tj_y{UPDqLuQ|d-W)$|453f`6eyezV#R@9l^6* zHvfjJ$NiXcuMO9x+{$iUZ)OulyRl9Bd1(3faMm?Hk}P(v0qF(3cqnrj3zrJPYH=a3 z#mbN!CxQHT^&x~Ad9a(et=O+vNtUMg2d_0c%DklWNhls8Qv0sL z)kO5bbw6Dal*sdqDn%sAq=|?L`8%_U8CkVp9v*8ZMXF^aIH{9Uv3U0l9Ica2)*RYN zLLa<>X4S{!MXRpphSUsFtrtUHs2FmK^Zf7)w^HaTPh~cS{bb(hH(0i%5NmzsIiugt zqNyK$qBX+LP`%{?6+#~!6z0`s z&}Pn0FdUkK%BTG&2#?Z+s*q6#wwffA@wpkNoJJ(g29+r z_H9iJ9jVboeud7$b^RN0(R?XUDnGkeAj^okjxW<|dIaKHbI7jg-b7Xy%yJ!9k+L!+ zCiDF(nGrNo!BiLIQT%?2l}C%aDf zki=Il*tB>%`5Qf+=no&kk#!NIr(axTw=M`4PoE*0yGVwcXuq7H;cYM>!GO`RCt%yM z4s6%+9&2^a!XpPpU^~kYH2%#CyyMRT^2pg8+TkhQc9g-z%Haht_#(IP2o<-UPxY-_@m2VI%=#&0y`wmQ8v`7ErNXomG zcG^az024h3sODY$+x28lU9% zt3B5q5S>N#Wa+1FzGE{Br!*?uC1>iNQp6O>PvZ+in-VRrg|nsu!UDPdu@D z;ZGjs`;i5=&yqmjERn+1CEV#1E}~r*z3>{lsf3q)L)sP%WD>}`6!P~W&n2VThb=qF z1S4zMs4#^rthU9qL2X!%{YLU;H^5A1Ax+1_bal8pe$ZJ6dP=YGn>GzJXg-2fT0Xb# z4nGO@8+>r7_jx=j*$*VTZo+&O7q(3_KYA` zeCkv9OYtFn0Scc1_lh zIqRfy?l#Zx#?X3NE)zp-y46Md|5Frg+Wv*OXf&}zHOgpUF4LU%g2bu0k`u?Dv+qaj zNY+3B%PBg`9)C&4N5-tcuxlgyRcuC<$#vLa`6N8X+lLmI&!E5l@Vuc$e?W$l*{qK2 za@m!9kMCd>btxW&kLt&wGm{jBI``ZmDn6V48U|YM zzDpkpEo(Sbp=$%*2#o?ywl{HCceSY`H%R@IwB)~<7~=iqrP`jLmy z*Y)5t^`~)W=R~ybr50R^$Pn&Ik$^v6?hD<62T-BGW!$^o4xEhw1obuB!1Cw-)oD?J z9FK5%^=l1X>>7ywCHwwC*{u6Xux5S0>#3A9tTDHbbpKz%+;M%`0Z06Z1 zZ0g`w^u=>6S^R=R+i!LLO=k>?7nlNs#NbUm8BEGPUbvrk#rR;}Vy_vA4WXr6}7oNDyvt(Ztf*BY03G{EkJ$1KKjJzHpfkW9LFmMv?zN^Zua5u2xPNUxW? z2!C1yMb>BF!q6@@E%GUR44cL>j25wI*&#e=_mAA&*NHVZR$@!#Bch-qpU6usK8q4k zivGwfXG-Da%wB3Tr&sF&+a9=x2G;7)k#{uNQxz?8aN8^k6$ z=aMjU{8#+3Z8jd-pNlJ!Hd0&XANa4VF;jCj1{H^oRQI|REgi8GAMC%4trpzCv5)7n zPKS8-#pMeOmWx0-WhA?^=0Eh@dOvJ7`-Ro-j$uAYdem#)Rcp~D83ETO3kM6XB9YuQ zoN;iFo=E+Hq<_WXwU&?Q^AppdqQ@FPGc>`^JKK@=%Zk#!d|%AU?mDu(vw%tnLh!-C zWPV1iPsS`=&9t{@ z$aN%V&obuG{{aLc52?%FHrAos2+88{Z1(wAY{aNkHt|t3Y0xS|xBoWcyMZE7G$MjM z^M1ir4h7*eg9BJEwGbT5-V@{C7<}%h0?O9iNNn`uSwXKUn`T%n2>EpvOjW0oD0)+r z+3F?oNqJ1h>e`E*fBnP`ua+b)t|xH%Q*ud}&unJ;#FvV{c>;c zag`1D)kJBwO+Es(r>KzzF(0DkYYvZOT|`AoPTy@y($&4zDpN2&I0e#wh6r?3t?>HJAE5j@6Hi?j3V-X2 zq5Ds%aDVqjdff6M{$|Uw|I+uu`D#Dxs3*&8&Bl<%g85W!Lp)mjB?z5K42LPkKjErE zpnx?xLh{c{Dt6hNmi>%Hzn4qmWv@+ekZ_|=zi}@7Yr0F*=Be}V#d@LIT^YPWAcr?8 zT@c7lT2(eXrx>Y7uR-$HlIenPyG6%8hLNdD{<2>AiEM|&DUr#EqonTOJuE_ywW&mZkhhmngi z(bJ}dm@F%|4A}KlAMcp7!71n7AFh@xRafZe2rB67H;E)-QCaS(?0> z_lVe(JwuPWyV+!?2@tF|LbQ>0aLUh-<$nAdC+aKRMcO2M$t1DgfG5u)EfwcjkgPGu zl1(8^v+t7@Lv2o07=agbPbRfbOmLXdSzMT(h!t&DQ2$#zdoLk~R(mz$7dN|*82yiW zTU~(bdfHg}mnoBecSYDC5sl8wSuPN@jS@Ch^YetBZLs&90QZ)1%=(Q1zA)=BbTw8$ z+l-wwSkz9pKh1<9wN_O4vK}=wXA4$8TUOqezeVW9b7UnZOe{aQMOv61#_z}M?Ws(z z0=?84Q(h%C9`sAXgqPGOg1vqh%}8vrE)R%BZ4KNLb%sH z4{Ak$u{+yV62y{A;gP)b-c+$&sl zb~>Mloe!29CLyzSPyE%$6lTU&;O0xw^wnhtH05qH%~)C@bZ$G2?)*@L!_WTEWbK>C zaWn74y*U%keX@qY>~*x^tqd$2+a_FkWfJ7Q)+*n1Qx6)7Drmw6Mbx^XhrZo6Qe<|; zj(Nooume;@wCsxRe-$0VY{kDC;`^W%_pHp)vh5| zZO$-*Gk2(AhY2}4Cm+8|>4fRdw@C2mk@#tH2`V+wU=gel60Ps!;2ob}h@UaWWhoPT zJyll!;;%r|za5+2zD!?^ETZxr2Dnr&6J1m@-p=jF~oR@0y3 z#+E=q{@XOr{r3dbiU-h^plEB8{?Um1Q-Pzq)UfP@JlJyVALKb*#@Y%5WU?$l_TDEt z(LV|mJ8y*(hR!^5Hb+n-F+}rsJf}||dI}mw3{tx-ld(taRXW066H9joAmfB~!Orn6 zh;Pf#R`a#ocZEFAHl8Ai;pcSjI{TR7#cgYi|<^l>sQ;pb`l+$wP^KR;CIzKVQx!y(!;Q*bYBF7_AAVXE5@aSPXwv}p$Y9zafqu&kUTQZql9&SUQ#p7Yf$b==_bOFtA zs;tNmu=guXve)Dm4*e&~#@orVwtXdN{U=xULsgq~tGQG3x*D|e@X{=Qx=wDQ2Rs4+J!Ksw>+7=MAD05Ml%}J7)8URcxm`#!hV*$|0^!hZp z?X%KgW8Wf9UvD1`?$iT6hcd=Jv=Rk=*$Bt)$%vvZQ*y#74eyvcnHA2Qh3DNp$F9s; z&3=trF6uPaCep_un6#J;d^S1)E6tVglx5>_eywZyrW2*m@<9zMCiA~r)C=nOJjnDH zLBg~1=h5R|yU}tfO23c$jutwfLDkxCA+BH#zGsvV^Bnf!^3*z%@T&%`-ueSAk6DQC zEBZi&ehKNtdn<@Z^p7P6uN1I;ro*PXIbdDa*I*Z-PgE{t zBGYS{koaf`2#u;iD>fAuzT8e0zu$~A%YMVc*4-@hzeu)sK?xpLwMsO5+Cfqka|0{v zoeX0XH{;>HLM-Lw1uJ?lvFvwwWNF<2vTkMvZdJceOkDNI>KqZ?dZ3q0=ih?`k-8*q zL=-7j%_RGOFJliKYQfB74qJQaBP|OZ!asQS_J=u5P<+dR?`L(uiKmmHW$AKINM1=U z@5#k0=3K?i4m#9+vKzeL+=%w?)`c^x7vUCZbI95H6Y!%EkRzE2pZAC3mw#4cyJib; z)k#M0g^>{7#dkcS&QbgFJMiV(SDdSIo1RhbL;vpE(*O3jzyaO)_)qD3ls>VVZZ(P% zq~FvLNX#gqf$3*y^cgp_U%~(vc{d3IyW^?Eie`Gh+#8u3t}l1*2w_(DE|As{<;bS- z5ng=q9Lt#D!OX(-xwxkWT)kN?d#E{0lx*8Ta+-9BNRhf?l_D+LyurKDHfhy zd4|WI{Q@gP|G@F4G!!9!9Xodw)Ap7}FkZNtEc|3lPIfv$qM|rdz4$^m{#T5S|5*T^ z{_~?#?(YS?J6?jMzHIcaxmnmgPE6P$S%qfvUyD3ZNnjJ!OO>wJqKFNLk)UP+cq#Cl z*F|?|-4Qo#hpZ-U2puP~+Ow2NZrlVx$MT6)$3bFUF3v&}){qI4?$FRLc4XJCa#nwT z5o^-;k4$tfB28z$f&Iu1T$X zQH@1jy+SVPw=;b36boOy1HSgCuz#`_kf-x#Y8>)`?V6TA^M|cPpA~nrU^^k1HOr4} zjakD!tm+`Cvv0B~b(PGgvj$f1_x3R!Czx~JLt5;`y<~m z->k#z^V7-LElrYq3#M51&Ut*&Bn$Lh7BUIzBi!J| zOZ_WYuKhQTE1ZCr?Qx)AUIsw>pbls}D*~rCk74Gxlc=pT8y4DLz}@qr;m=JBJLD?p zmf9%j<#}vu+cxmt8HHP&#^XW1Ni@vh7k$<4iX~&`(G{O&^4>5Tn7{NET4390Z3wzJ z#w(P%hM7Zxn=zMd=tnxXJx9{2;zY_wO?1_!gxDu)i87}1eX`1QqWE}>sO7v0XYqI( zQ>BUI$lgej*l>lsALxTkm2ywCRe__OHD0%H5#{C|edJD%z4T94X}dQK9_kn~6fb z&rQO$ugj>Lfa{h{I)-A`SEIa1JMiz-l5p#e4nDYA0)lHw_`?1ny2#0q{s_E?Ov8U7 zjfBg*sEIXn?aDDYEt=HiA8>;m&T>MF;Bt^#xP{I%zl@B3=b_S}aP;-nd` zJ5YjSi>z7OCR?)5H4**U5DMvsMiT|YChW%XTstEgMf!(l;`osi{)Me)pe^iBiL+$>FO48rrW4K83PrXdyP<=~oXJCwrZr5O^70@x$~JdF)aD4ZRE-*bqE=ZLgtgY+18OT=Jjnexi!X= z-Tz=i1gp8T{YP7(*1CqgUzEZs)FJ3?>!QJe-z%|Fb_}4;YyfZ{xT8wERe(!NE~FZ-fze8G5YU;g#_tXzMa#rJ?Qg?v?|j`MLnPsokf- zlRI!YZ!Q|0C8Ed7`S2>i2l0};@rUMeblno+!lzC6NT(aBNOc3T9tCzrXF4h-YH*-# zJiTzTh4#G1bg`)w9rx`TQnyoti)X&@-ptyGY%h7*X%CfA`P-+#?!X9-|Dd79VpIiP z+OtkrS~D99{TJ~!tKTF;!Byjt^N=m*tX(OTposhQEm4e+^{T zOOZ1t;`!=|8Q?0eOp6>!=t$2Pc&E1vyWV|=HUuZr39HR8HL*bM0i)=+6Y99E&kBxI zy{0J|Qg&&c7ipm&#V*l63|(xxLkE+!1esh9gXeag6~;Uv<9@CXdFvE%KF9(5w^R>1 z*@_D~9drb{rcDz4!KHX_=NahR7RS1@^2m7YSa#0l8DkL-Nba6(jB@{h`iK3Q<*ZbQ z(i3O5xIlJ~C%&Rv#KKw{iCC4C=&fE5c|@IA z`+IdkVqzA_C|<#=<{kje24$ktz-3_kT?D7+nh+JQtIVA@fPUNUB7ygh(CvbGf>nDq zGtwN5LN6Z`ENs0%J_n_e+{L;09687TH&dSNzs>nJR^Or8KC7wX*8R|LnnT@Z2Sd)5 zrSR&(cfOvCGI|lX1TSVM>2sS&=;_m|RAGq;?3S`58e-*G=8HN$7Gch;4t3GWKXqW= zCdR&1IiXGP0Srr{iGx}(l#OzORV z+_5G0S&2mRfIpVs=?hny*j8oBA#a05+*7(pKpLjUPx55G1sj&V>3ZJLY3BOvT@!X+Q7W%l7B;V;ISL4-~ z!`^acJ?zXT=k?)Fr=>){j_HVMLOex&dS;^BmTGLeHJ_>7k{4`oRu?UFj3YDFEGH*w zBiYeyuOM$+HP2RBa4fU!;ty zw!BA*qXy`i?-8i`@@EhzH}W$cl%N{R7}B8ZP0gGi12I}oBUfETxeY$Fwtxt$;$o0d zV>ddr2I1!(&b0nPGAd1bSiS5^2x<;^iC)EN;Zd4=R9$P%?@7Ope(gWWi)`&HU=I;(;hZL5v6OK1)(#~Ii z(;th#b80bOuaFC$QYx9e?N507FOT?bO{eu{4Y*~gHJj?QiUpbE(}%OSkZqsRKuw=> zR5&HTxAi@+CHo&)mn}}_Z_^?>c;a}R>v93_BZzkJOUdE!U2NcS5jkm9N~CXivhLPz zr1{7!=A5O+#LkZ|Gq#{mqc+glBZ)6}^93{(CFD2rw0=Y5-m?}`6O)?8Dr@_Aw|>`?l~)K$O2k~J zF%?#uCz9m_F63)UGwhn4iz_YS@X-1lQ1e|ATi#RU@>xFAZu1!U*pLUg>!m^Mx)@Qi zJ%+bhIN%wPJy0~TpLCoLCmUB`mV=HmH{onH;26V>zA+TkNT`S$R=` zk1t^8pCFnqMaYw#69kJMjv%~kH|t$;l6Y>`p(sj2G^3#de%w|Q<+QmAdK+YjW7-_z zopPBd9tx-7_y4eS`#9f$iv(-qdf0x3ow)UJlyGe9AL01bT+aUKIqZ6PCPnu0* zT=SaKfW0oHbC!reLM)Zu9tnXBXI=3-TNyUI{S%sa^@UJJ_8X`lZ{qFC%C2rpT22-` z9YU+N`f?088!WI$MB#@f-=b+5aM->pr? zI~|Ua^2PNyVCOW}D((h4F3EU$_AmT&g9=Hr*D_r)Z552Nu#sEI#B~V@aQL$8`}zs-9xw;B_$EDJw)*PDY*f2nOD&SvT@4;7VRh} z7*;<<9K0p*M*~B;LgFoq7-g^!q|S2WW--Iwv3QYiHY9qEf-325ezB)AoHDDRpC>55 zBd#|c{%98}YPCZ)XMAXDq#lawHm8ys-l4SS6QCPai~A?Ffz;PbydYYF1~pv3ft-Qh z3JZaovF6oY&n%$uK>^h%6AFiTF~TZtmgjQeCtW;r1kLsPCp1x4f`or5{Mjm((Awyg zLT#D7SZum3&G7Hwm&>_R#}E5Z+|N~XHpg2y=-&a)IBs*`!V~z{NoA33&_Z%xZ*NUu z?lpSG+)4E25F%0HwIn3{2EP7N4S%#0;m3->_=Jl#F4msKKV2ol-zKiWzkki(FD(zo zD;I=9eU23S@9tlibKwFkIM^cGcJ3ieOcck@tr+&uEv0*Tae}X_gGE{c>&U6hmw4v$ zN|^5GgXjJZB1sVzoY%&Yyk2*oNuTsbVS%ACir-i_pKyTpc`Jz_(p z>*?TJ#AbadhM>eA;ckgUCj9V#xd`O&N>@!Xd7?IvU2q**^(wGO+bO&w&J>#cmm(*@ z0Ih8^gfE(5*nczUv&}`h{2Mi^EaArs3gBq97q3@+0enB$ zM{m6MWTk$9)0QvCVu;?ly}yL-G(Vef;JTWo2O6VAqup`WZwXq~ zvm3uVtVtGaoJ*2}qy+m*Y)IPfuVm;{Jv*}O7y0qT23)lbMPA`iEI{uGG5itAhQuiL zE;>O{hP}u|mjY~mr~rP4$cmDu{KGk8jWvX*4$uy_!(7)gg??J(P2=AmUc{`Vfs(g(Xr8lvv;n(!>f>ESV#!}e- zcmTJal_0Y>XVNWJ)$nh&IE2MV(>c$_@VlClfPeHovilZ}=d6pS6Fbl2Zog4@pz0M~ zwBRb*b>lHTHgt;XV%>)Gp55rN(*+v5*cVqWZ=lzj%J35z8(gv{4Np7$53V*2VYygI zsI@!K^Yn41Utd`Px%-{3JE+L*sejju+2Tl_G#2qsTKA%Rmt|qnB_;&Z$S zF;9WWZ@3QqiU~D`Izy?zZ3)(HHNpwXiFmNYkmG)@fUd2Hbo#?dxXJD$npHHJkvZLH z#jJx+(;Ny{#LnUJ^W)HK!#sNaMh(qhzmOXI*nzf8OSa365(BFaJ!;k+O2bRXVsvl` z+$lB^));-{zuz!`oUE53U-x=CYN4~;>jmqmq3$|%|FZ?OOR6A;b8+PR)vFM*O^sOn zyNU1IwiGCk_k{kJP9kQhvW~|sc+x{NtT^cfbj;Ub{yE|73p~bsPGdyG_7^LHDrs6F7WQzfWp5BHoQ26{oX7txc4`jqu;+v!PV3%5 zQ-A*uhAydv1t=U$Sqjp{ zMzgsI|B(7ZGmbA&1ns=JZ0@mq;y7B1CHR!E8#^3HhBc6qW+Qy;a1arRqR{TyR_wub zW28Pk9nX*4N@ToMiL;HiAeF2W*oy>$U$qK?eGd2V;5Q3W)jf*IY?(02+%#$)AWCYudP=h|He*arCeW5zO@b+e>j1L zj3TMa$`Ok6tzoC?aS%j%3U|-40CR;Tyh^SDE1vjH`%7d&D@_mAOm3tukH+GKhwIS9 zd>K3e`tYNlYOHS+=I@QX!a1Bj^0vifRP(wUK;@ANR(H;?nQXfpFJH41*vH+_WWN{X zd37Xw=2vpD@{L5)Fm)eu;QG}Cnq3^1HBj`a%n;?rO%tiMei1&X z83t8jBuM|VM|h9RdNk=(u_TEVY;cl{XoW%{8+l-fbq&l#TCUaPd&*moyO;on``yUk zfDHR{3&tvg-rOajDE~Hrh6nx>s*Nm(+I9 zB~+gZs@?G|h!cT5|aV?U@L2GvgSFGY*674G%CxnG5fi!`Mes~yFP@e`X(~R+p#3m&{)K~ zu^bLP^TQK1`?K*&$D*C^Ce*1;hwWZf=*3|fHtQwlyD>al{WG@#X;s{V zOL;|j&5J`gqkjZW-dllfYcgT~iy%CB@DnbO{z8l&bFQmph#lacf*mf$QR8$uq7oL! zjt!0`BllN=UUVY=S9L7sP^%VR9>0SB?1~xwP(KTP@AC(m?~3Pb8H2ums2676UIi-V zscJ`@RU*rSQvq&EIA$z0}6^!8mQoz=Z)?B{B- zl7ET}EW7|WizGxf17{$sFp#df8OIz?|0VaVv;=(tqeV}IOWDn%vE-0vJG9G%(c0G2 z5MJmcxD#L{I3u=~6>RF8ixl6r>{?B<_$153Mmpp+fK1C4%8{SPI-d zY(>UQam72!!svunHFU+(t&p*YTdK`yu>m3@zU52F49zQP(F$Z2xOD{Bk)AGZ*{w`n9`h!?d&TR(Mlr zl>dfy7Ky<`n>^kp%NE+H<42XIa2&sOZ!~s$Doyz9O-I-6W-iMYvOWuYfp7Fdl3a0- zZP6ObMDr#QmE{>svpj%Z0u#~xlU}%fTPIQ8sS0(|?OFZ?%?oJLQ ze#1hJq}hkdH=JZM@;8#h<&ETMSv@v+vVsJksA1_P)wsyI72mIPCwqsEk&p>D;DhaD zuDj<(WM%vCo{7V(s3aH9an%$_E^TA``^3l^yY+0%@;5}B3=*#eenf9)HY*E~7ig?d zhwn8CY$o?!gZp}6S*!+g_~%X93pL0{SRvQv3uV;{uT$-kD=gEc9~lPMaP!)w@W#y! z1t>m%sG$Gg^dD(_+`bxzR&$fw>41rH8s3d!p}&TZv~^DZ(^oufXYM5sM2o7EDceK|CkV6BO1= zW+OG{NPtTilh4b6$b+(Yhr1Uv5A#ULlzpO0YVHDU@3+irX&71mn)~c;j$`-NZ--4& zfAZbjQrI@q3lG+e2K&1wATV1DnzW^OwX0*$=Jj>BcW5&>Pp(7RvVU=~+AJLPOOo%U zw3S|(-2g?ws$_@aBd{vmPWQBM9)-1oc+vcR{K730&x{olJ*pkVF;y)vtYw6W`X#i( z&k(D$T}MBz^-(4JENHgwfTMB}DFSl6wT_982-o z6WeR@^MkPPnK#F}PsZ1*e^DE=5WccQ8Fng>U_(vQ@a{i>Y(sS;v8jw8A5Uar>B(|-ch?&osaCXbTWMV(vCgH8i;sSFGyaYf*|@6*AM%#pH=@g zVuqiS1<$>+h^d_?o3zq{k8|#kssb%C9Gk#Ohn`^Zh)mJTCjmI`^8{w$UPhYS2t24; z3%xy3adXZ(b}5poa~`w?sJ5I|Z_B-|`{DU6GAhV2!v;em&` zFk3B&W?db_Idpnps+AF(%w#l|FAv@d=Wv`~1n#@3L2pE?h1b6dptc~F-sx3lqx?%y zkG~{!*trSa-SZatnY^GaxAJM;?gOyX|2J)(6GBgVZ-!70Aq^;dLYpRSgENN?A?Zec z*x(*VXBpSi&iQ-!H&b)if=f%-rKYh0(Lp(p&8T6bv0a=fmi<7^Wy%6FZlyqW`Ak;e z^A9AFrm$eKdM3IEh;{2igVr`?y7@7QTyuh~*4;!bdj1M~va8uDo+a_PvYK|7)u8vW z?{Mp-U%1~6z+klkj&su^Zd;?7!#Y>eVf~M7I(?TcmTe+*v=uulFd#?P`jP226GV|Y z0#Wh|5#t}=e!Iq};6vkg{tw*;WV>o3+n2Q#7Hqo1mMjb6X7Y7JEN2&USYZnm3-^+| z{CBYO{BoAEK89=wx<{q+1?bUFLp)e<8Q8)O9I$l` zlt~*A|0$p0r#}yTXWd1WpU3jey#YO*tBaN=t$_;zowV-PH=%vHH>w<5LXqBG`dwWD z2X&>;#`T8K(r$$pE{foJu6=^`X3ht}f?8(&_7szjv=Izws|p2Q50c@E5LS~h!1>6; z1SvD)aOA-;g5D_~h?0I6Ie52^xwJReq+E4itCT#z;nYQZVAct0_w6qlPK%R8Au$9(6>~?^FwaeBZH!eT@B2bL& z_flfpWmb!F+JBNGUk`}p#UEwWw|qcgpFu`^p0j6%Pq81)bAfs8U>}ea9>=-STDz1* z&w{i?${g=&uD+tk#aRcw-&(^gGxuTL(=Xvv*gY1%IuGw@eSu^TbBrcS2{1h%&yFj+ zfK^Y!z@ZxBt%teZ^Pg^d`4L}u;bk3&+#cXfl5NQ3ku?mgu}8D|OkmI84;&c32uyFs zqKdUi{N)$qg#}-gu+NfaD)y)bJwLS>IwE(~6-g@duJ*OW>s;U}v)kqZo zqJtJLK4L*pN;ECbOt(8XI~*CW7sq~j>F9`cFj7=;M-939{A260$%iXn7!|dXm%l$l zRGuv>yr?aTo3fI{R~N#CO`Ytw=@!zw_#+t^cEY>D&#~LRJ21Urj7Cz@gf?fU5TCBE z#BtVKru;`<5IrZ9bIqL~{#Ga0+Ky9?(}!KYLZR;etqOn(B;5;zyG{WP}aM>dPBlo92=6B8tA zpJ579@`#H?6Z6ptWhp@|?4fZ7X_P)mc4V4Tte8r+e=WkHA^|>d(LmHPBbfMTb>sWo z-nYH15Gy;b!f%u3V?}!>sMT@DN#7Mn!hKzAy8ky`c|?SpR$YRWMe;NU@yY2|ra1Z3 zG>?wJyPeI{5aUtt5;=ApEF zraoG3TFzV2$_H`Y@9JXTFSKvrCWzgjgeN|Dk2HAgXhB;tKST6KC|#z5;a@ma_UR`t zv56pi(|vGVFC_{#9Ks*2Bcht1Ei#_@lC@ZxG5ZWkI>suB%3Uz?FZ1sUj?p%nskZreGr%}=9_uuQ@_b`_$Ssj(}voEIBwrQ=FMc#wjC|VWa%W~ z289;ltJ}t$2ea@wxAp9+)q2FslxEE;n_>Ae3ub(&m>6IFg_myeW2NUaaP-J{XvrzT zl};5T=9Z?wb8a8A+u1?xn6!bOi8OP%uLVbqLhq~OepW)zt5zy|`iYgUH!}p2G?3blF zmS`G=M@~M_cRC%93sP?%w z`bs2CHCy-4l~MWV=i$fvdoR6t>+YAL*5MGUKE7J$F#86IOnZ-%HFWW;6^=Ehtv6Gz zQcEmrzL77`Urp>67>e3sdhoFN6L$Qy7L&==7cAfK9PfK`i7cwRN{ViqTS_BP!wqUz|E&FN4IaIpLac_79gjHknZ(CUl03e*hDopKBVL*cteW#u9G%H|s{|!P@9Rt!*U`vSrSw>mQVlg* z5GInp)58MR4yBqc;`Pk?IgCFY_Ax z+|xiUC90ud4|g73GK1c7T#llc3Ik<|YCGlAj#|T&#o{KXY#u4q0t69xJ z7%o`Vht(>D%r$X7Y3VpkK8}b9&?rTmTr+`tFnrSp3DCtsSGpG?CZ^_8&L*oLhir_Po-oW)(63A*W{#Lhi*5gItTWB$=T{8P~m zlsPx;?w&wc7B(6l9ju|rJr)phAqtO@*#vivDZ%;1lW_OIZhZgFGninYg3TUf*C_X| z0L9P?6#p(mi$gvMoAffFA@VH#COH8+wx~kUay1nF%?1y-U8eTs$?(N*103Z|5h*vN zkg4y?Sf#HDdU4Q!MaCvV9LJ^CM%}FU^+#rAQ$W_vyaY!z7_oXk7q*-kFR1*LfPeXT zv1!%Ep^LkxY?qu44Q?8YBkc+vp9^ERMx~Gk)5Mr>ojghTzJRp`r{es*SF!Ayi)3s? z9_h~Ge4Iy{;T$(#oqf**%Y^p9ii6Ig9Y27;!bmM*x9Ji-yQUd=p?AWE zdo0mrXH8@iF%N8FW+Sh>Sp4g=Cdi(ALo2SW$I%*3L2*Jop4_boQ=XheB3;hOd3q3~ zmfOPI?Jcn9kCd>};1ufL=?@DNXX6(>H(}7M5;vdihFos`pWx3ko zcbOZI(qInVQEyMpEoOsX$$I|zJ1^-p)#b25F$nLKs6q;(uhW8u%h8q74^Z&9G@j1W zWFi~Hb;7s(f@QS|*eAN0)SIs&4clCqVV0bz`ivHi@~LL3>DJ7uB9M(TV7SU>K5OH4 zN84A%uy1u9(EnBz>pc}Qefe6jU04FQTDg2p$0Bxe=?=EK{SXV>;z@!Z_OmjTZ#cef z0r5YT!lvJkWTPj&B{^%=S?8DYWMoY|TC-XM#{HQ|wk&pK6_Zvn#g12GL$)nj_Mn#} z26Teom>3*A?hI}-`~sH4PGtY$Iyk;%J6UjKBI_=a6m9w`E|~djv`EQPQ4p*!nk9j%jns?OQI19UdnofcwkK+p(3qV674yW&$fNtc0 zP&Xuuy3blmJ?cUMj%VTdQ^pG$bR#(Q%2}b`OFh!BY)fV?lx4gD8wgSwh6#hg^tI$a ze(JNQFxyI&eN{irw|@~uXN8}m!>5*0x56>>n#*hcWQB0pnvzLdlBMy?QIgp7&@}u` z=`6~533OCc!v0MLo_Ay05AS_)-8=*B0&GOx$%Ztg!=wjO(ge8N+|Phb^30nF-41xUTf zu8IC^2WED?SfxS{doDBKO_4o|j~#b`tzP!%=PB9hWz+50a7HtoQifU4jxVsy=`x

O;iQ$G>#EQe*Q%7 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ⅆCl&4nHNt;@l%mxO|2^b5(vd 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≻L&Hh#=#S9->oiUMYk=xW>M(BQ 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ℜ0ALv}W5B&x#F*~y#%Z|<^-7|vV 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 z None: @@ -14,4 +16,5 @@ def manipulate_search_path(self, search_path: ConfigSearchPath) -> None: if any( entry.provider == "main" and entry.path == "pkg://motrix_deploy.config" for entry in search_path.get_path() ): + install_program_schema() search_path.append(provider="motrix-deploy-tasks", path="pkg://motrix_deploy_tasks.config") diff --git a/motrix_deploy_tasks/src/motrix_deploy_tasks/__init__.py b/motrix_deploy_tasks/src/motrix_deploy_tasks/__init__.py index 50ae5b38..79daea2f 100644 --- a/motrix_deploy_tasks/src/motrix_deploy_tasks/__init__.py +++ b/motrix_deploy_tasks/src/motrix_deploy_tasks/__init__.py @@ -3,4 +3,6 @@ """Concrete deployment tasks discovered through installed package entry points.""" -__version__ = "0.3.0" +from importlib import metadata + +__version__ = metadata.version("motrix-deploy-tasks") diff --git a/motrix_deploy_tasks/src/motrix_deploy_tasks/config/program/g1-hot-swapping.yaml b/motrix_deploy_tasks/src/motrix_deploy_tasks/config/program/g1-hot-swapping.yaml new file mode 100644 index 00000000..aff1424b --- /dev/null +++ b/motrix_deploy_tasks/src/motrix_deploy_tasks/config/program/g1-hot-swapping.yaml @@ -0,0 +1,13 @@ +defaults: + - _g1_hot_swapping_schema + - _self_ + +walk_artifact: artifacts/g1-flat.deploy +wbt_artifact: artifacts/g1-wbt-dance.deploy +policy_transition_duration_s: 0.5 +passive_transition_min_s: 0.5 +passive_transition_max_s: 3.0 +passive_max_joint_speed_rad_s: 0.5 +passive_gain_ramp_s: 0.5 +passive_kd: 3.0 +initial_state: fixstand diff --git a/motrix_deploy_tasks/src/motrix_deploy_tasks/config/runtime/g1-sim-state-machine.yaml b/motrix_deploy_tasks/src/motrix_deploy_tasks/config/runtime/g1-sim-state-machine.yaml new file mode 100644 index 00000000..64c467e1 --- /dev/null +++ b/motrix_deploy_tasks/src/motrix_deploy_tasks/config/runtime/g1-sim-state-machine.yaml @@ -0,0 +1,15 @@ +defaults: + - sim + - _self_ + +backend: mujoco +viewer: true +deploy_env_id: flat +robot_id: g1-29dof +sensor_bindings: + base_angular_velocity: base_gyro + base_linear_acceleration: base_accel + base_linear_velocity: null +physics: + dt: 0.002 + solver_iterations: 100 diff --git a/motrix_deploy_tasks/src/motrix_deploy_tasks/config/runtime/g1-unitree-state-machine.yaml b/motrix_deploy_tasks/src/motrix_deploy_tasks/config/runtime/g1-unitree-state-machine.yaml new file mode 100644 index 00000000..b990271c --- /dev/null +++ b/motrix_deploy_tasks/src/motrix_deploy_tasks/config/runtime/g1-unitree-state-machine.yaml @@ -0,0 +1,54 @@ +defaults: + - _unitree_schema + - /unitree_robot@robot: g1-29dof + - _self_ + +backend: unitree +transport: native_cpp +network_interface: ??? +domain_id: 0 +lowcmd_topic: rt/lowcmd +lowstate_topic: rt/lowstate +connect_timeout_s: 5.0 +subscriber_queue_depth: 10 +validate_crc: true + +operator: + intents: + request_fixstand: + held: [LT] + pressed: up + request_walk: + held: [RB] + pressed: X + request_wbt: + held: [RB] + pressed: Y + request_passive: + held: [LT] + pressed: B + request_emergency: + pressed: select + planar_velocity: + linear_x_axis: ly + linear_y_axis: lx + yaw_axis: rx + invert_linear_x: false + invert_linear_y: true + invert_yaw: true + deadzone: 0.12 + range_scale: [0.25, 0.25, 0.25] + deadman_button: null + +robot: + startup_mode: state_machine + mode_pr: 0 + expected_mode_machine: 5 + motor_mode: 1 + command_publish_period_s: 0.001 + command_timeout_s: 0.1 + damping_duration_s: 1.0 + damping_kd: 3.0 + wait_for_remote_buttons: false + allow_lie_down: false + override_policy_gains: false diff --git a/motrix_deploy_tasks/src/motrix_deploy_tasks/config/task/g1-walk-flat/hardware.yaml b/motrix_deploy_tasks/src/motrix_deploy_tasks/config/task/g1-walk-flat/hardware.yaml new file mode 100644 index 00000000..748687e2 --- /dev/null +++ b/motrix_deploy_tasks/src/motrix_deploy_tasks/config/task/g1-walk-flat/hardware.yaml @@ -0,0 +1,57 @@ +# @package _global_ +defaults: + - /runtime@runtime: _unitree_schema + - /unitree_robot@runtime.robot: g1-29dof + - _self_ + +artifact: artifacts/g1-flat.deploy +duration_s: 30.0 + +runtime: + backend: unitree + transport: native_cpp + network_interface: ??? + domain_id: 0 + lowcmd_topic: rt/lowcmd + lowstate_topic: rt/lowstate + connect_timeout_s: 5.0 + subscriber_queue_depth: 10 + validate_crc: true + + operator: + intents: + request_stand: + held: [LT] + pressed: up + enable_policy: + held: [RB] + pressed: X + enter_passive: + held: [LT] + pressed: B + emergency_stop: + pressed: select + planar_velocity: + linear_x_axis: ly + linear_y_axis: lx + yaw_axis: rx + invert_linear_x: false + invert_linear_y: true + invert_yaw: true + deadzone: 0.12 + range_scale: [0.25, 0.25, 0.25] + deadman_button: null + + robot: + mode_pr: 0 + expected_mode_machine: 5 + motor_mode: 1 + command_publish_period_s: 0.001 + command_timeout_s: 0.1 + default_transition_duration_s: 3.0 + damping_duration_s: 1.0 + damping_kd: 3.0 + wait_for_remote_buttons: true + allow_lie_down: false + override_policy_gains: false + # FixStand gains are fixed in motrix_robots.g1_standing; artifact gains own the policy phase. diff --git a/motrix_deploy_tasks/src/motrix_deploy_tasks/config/task/g1-walk-flat/sim.yaml b/motrix_deploy_tasks/src/motrix_deploy_tasks/config/task/g1-walk-flat/sim.yaml new file mode 100644 index 00000000..1fc87e80 --- /dev/null +++ b/motrix_deploy_tasks/src/motrix_deploy_tasks/config/task/g1-walk-flat/sim.yaml @@ -0,0 +1,19 @@ +# @package _global_ +# Skeleton recipe for G1 flat-ground locomotion MuJoCo sim2sim. +defaults: + - /runtime: sim + - _self_ + +artifact: artifacts/g1-flat.deploy + +runtime: + backend: mujoco + deploy_env_id: flat + robot_id: g1-29dof + sensor_bindings: + base_angular_velocity: base_gyro + base_linear_acceleration: base_accel + base_linear_velocity: null + physics: + dt: 0.002 + solver_iterations: 100 diff --git a/motrix_deploy_tasks/src/motrix_deploy_tasks/config/task/g1-wbt-dance/hardware.yaml b/motrix_deploy_tasks/src/motrix_deploy_tasks/config/task/g1-wbt-dance/hardware.yaml new file mode 100644 index 00000000..05647b28 --- /dev/null +++ b/motrix_deploy_tasks/src/motrix_deploy_tasks/config/task/g1-wbt-dance/hardware.yaml @@ -0,0 +1,37 @@ +# @package _global_ +defaults: + - /runtime@runtime: _unitree_schema + - /unitree_robot@runtime.robot: g1-29dof + - _self_ + +artifact: artifacts/g1-wbt-dance.deploy + +runtime: + backend: unitree + transport: native_cpp + network_interface: ??? + domain_id: 0 + lowcmd_topic: rt/lowcmd + lowstate_topic: rt/lowstate + connect_timeout_s: 5.0 + subscriber_queue_depth: 10 + validate_crc: true + robot: + # FixStand gains are fixed in motrix_robots.g1_standing; artifact gains own the policy phase. + override_policy_gains: false + mode_pr: 0 + expected_mode_machine: 5 + motor_mode: 1 + command_publish_period_s: 0.001 + command_timeout_s: 0.1 + default_transition_duration_s: 3.0 + damping_duration_s: 1.0 + damping_kd: 3.0 + wait_for_remote_buttons: true + start_button: start + enable_button: A + emergency_stop_button: select + allow_lie_down: false + +# Exactly the clip playback budget: 999 frames x 0.02 s. +duration_s: 19.98 diff --git a/motrix_deploy_tasks/src/motrix_deploy_tasks/programs/__init__.py b/motrix_deploy_tasks/src/motrix_deploy_tasks/programs/__init__.py new file mode 100644 index 00000000..3265750a --- /dev/null +++ b/motrix_deploy_tasks/src/motrix_deploy_tasks/programs/__init__.py @@ -0,0 +1 @@ +"""Persistent multi-policy deployment programs.""" diff --git a/motrix_deploy_tasks/src/motrix_deploy_tasks/programs/g1_hot_swapping.py b/motrix_deploy_tasks/src/motrix_deploy_tasks/programs/g1_hot_swapping.py new file mode 100644 index 00000000..fd558367 --- /dev/null +++ b/motrix_deploy_tasks/src/motrix_deploy_tasks/programs/g1_hot_swapping.py @@ -0,0 +1,194 @@ +# Copyright Motphys Technology Co., Ltd. 2025, 2026 +# SPDX-License-Identifier: Apache-2.0 + +"""Load and validate the G1 Walk/WBT hot-swapping program.""" + +from dataclasses import dataclass, field +from pathlib import Path + +import numpy as np +from hydra.core.config_store import ConfigStore + +from motrix_deploy.artifact.io import read_artifact +from motrix_deploy.contracts import RobotSpec +from motrix_deploy.errors import ValidationError +from motrix_deploy.operator import ButtonGestureCfg, OperatorProfileCfg, PlanarVelocityOperatorCfg +from motrix_deploy.policy import OnnxPolicy +from motrix_deploy.program import DeploymentProgram +from motrix_deploy.robot.g1_standing import resolve_g1_standing_gains +from motrix_deploy.runtime.preparation import SkillPreparationSpec +from motrix_deploy_tasks.state_machines.g1_states import ( + G1HotSwappingController, + G1TransitionSettings, + G1WalkState, + G1WbtState, +) +from motrix_deploy_tasks.tasks.g1_walk import G1WalkTaskSpec +from motrix_deploy_tasks.tasks.g1_wbt import G1WbtTaskSpec, load_g1_wbt_motion + + +def _default_operator() -> OperatorProfileCfg: + return OperatorProfileCfg( + intents={ + "request_fixstand": ButtonGestureCfg(pressed="1"), + "request_walk": ButtonGestureCfg(pressed="2"), + "request_wbt": ButtonGestureCfg(pressed="3"), + "request_passive": ButtonGestureCfg(pressed="0"), + "request_emergency": ButtonGestureCfg(pressed="x"), + }, + planar_velocity=PlanarVelocityOperatorCfg(), + ) + + +@dataclass +class G1HotSwappingProgramCfg: + """Artifact paths, transition timing and backend-neutral operator defaults.""" + + name: str = "g1-hot-swapping" + walk_artifact: str = "artifacts/g1-flat.deploy" + wbt_artifact: str = "artifacts/g1-wbt-dance.deploy" + policy_transition_duration_s: float = 0.5 + passive_transition_min_s: float = 0.5 + passive_transition_max_s: float = 3.0 + passive_max_joint_speed_rad_s: float = 0.5 + passive_gain_ramp_s: float = 0.5 + passive_kd: float = 3.0 + initial_state: str = "fixstand" + operator: OperatorProfileCfg = field(default_factory=_default_operator) + + def __post_init__(self) -> None: + if self.name != "g1-hot-swapping": + raise ValueError(f"unsupported program name: {self.name!r}") + if self.initial_state not in {"passive", "fixstand"}: + raise ValueError("initial_state must be passive or fixstand") + if not self.walk_artifact or not self.wbt_artifact: + raise ValueError("walk_artifact and wbt_artifact must be non-empty paths") + for name in ( + "policy_transition_duration_s", + "passive_transition_min_s", + "passive_transition_max_s", + "passive_max_joint_speed_rad_s", + "passive_gain_ramp_s", + ): + value = getattr(self, name) + if not np.isfinite(value) or value <= 0: + raise ValueError(f"{name} must be positive and finite") + if self.passive_transition_min_s > self.passive_transition_max_s: + raise ValueError("passive transition minimum must not exceed maximum") + if self.passive_kd < 0: + raise ValueError("passive damping gain must be non-negative") + + +def install_program_schema() -> None: + ConfigStore.instance().store(group="program", name="_g1_hot_swapping_schema", node=G1HotSwappingProgramCfg) + + +def _indices(source: tuple[str, ...], target: tuple[str, ...]) -> np.ndarray: + if set(source) != set(target): + raise ValidationError("program.robot.joint_names", f"joint set {sorted(target)}", sorted(source)) + return np.asarray([source.index(name) for name in target], dtype=np.int64) + + +def _validate_robot_compatibility(canonical: RobotSpec, candidate: RobotSpec) -> None: + if canonical.base_link_name != candidate.base_link_name: + raise ValidationError("program.robot.base_link_name", canonical.base_link_name, candidate.base_link_name) + order = _indices(candidate.joint_names, canonical.joint_names) + for name in ("default_joint_position", "position_lower", "position_upper", "torque_limit"): + expected = getattr(canonical, name) + actual = getattr(candidate, name)[order] + if not np.allclose(expected, actual, atol=1e-6, rtol=0): + raise ValidationError(f"program.robot.{name}", expected.tolist(), actual.tolist()) + + +def _reorder(values: object, source: tuple[str, ...], target: tuple[str, ...]) -> np.ndarray: + return np.asarray(values, dtype=np.float32)[_indices(source, target)].astype(np.float32) + + +def create_program(config: G1HotSwappingProgramCfg) -> DeploymentProgram: + """Preload both artifacts and construct one backend-neutral persistent controller.""" + if not isinstance(config, G1HotSwappingProgramCfg): + raise TypeError(f"expected G1HotSwappingProgramCfg, got {type(config).__name__}") + walk_artifact = read_artifact(Path(config.walk_artifact)) + wbt_artifact = read_artifact(Path(config.wbt_artifact)) + walk_manifest = walk_artifact.manifest + wbt_manifest = wbt_artifact.manifest + if not isinstance(walk_manifest.task, G1WalkTaskSpec): + raise ValidationError("program.walk_artifact.task", G1WalkTaskSpec.task_name, walk_manifest.task.name) + if not isinstance(wbt_manifest.task, G1WbtTaskSpec): + raise ValidationError("program.wbt_artifact.task", G1WbtTaskSpec.task_name, wbt_manifest.task.name) + if walk_manifest.control != wbt_manifest.control: + raise ValidationError("program.control", walk_manifest.control, wbt_manifest.control) + robot = walk_manifest.robot + _validate_robot_compatibility(robot, wbt_manifest.robot) + + walk_policy = OnnxPolicy(walk_artifact.policy_path, walk_manifest.policy.input, walk_manifest.policy.output) + wbt_policy = OnnxPolicy(wbt_artifact.policy_path, wbt_manifest.policy.input, wbt_manifest.policy.output) + motion = load_g1_wbt_motion(wbt_manifest.task, wbt_artifact) + walk = G1WalkState(walk_manifest.task, robot, walk_policy, robot.joint_names) + wbt = G1WbtState( + wbt_manifest.task, + wbt_manifest.robot, + motion, + wbt_policy, + robot.joint_names, + takeover_hold_steps=max(1, round(config.policy_transition_duration_s / walk_manifest.control.period_s)), + ) + wbt_spec = wbt_manifest.task + wbt_robot = wbt_manifest.robot + fixstand_position = _reorder( + wbt_robot.default_joint_position + if wbt_spec.preparation_joint_position is None + else wbt_spec.preparation_joint_position, + wbt_robot.joint_names, + robot.joint_names, + ) + # FixStand is a fixed posture owned by the deploy, not by any policy. + fixstand_kp, fixstand_kd = resolve_g1_standing_gains(robot.joint_names) + # Skill preparation stays per-artifact: every skill ships its own stand-up recipe. + wbt_preparation_kp = _reorder( + wbt_spec.kp if wbt_spec.preparation_kp is None else wbt_spec.preparation_kp, + wbt_robot.joint_names, + robot.joint_names, + ) + wbt_preparation_kd = _reorder( + wbt_spec.kd if wbt_spec.preparation_kd is None else wbt_spec.preparation_kd, + wbt_robot.joint_names, + robot.joint_names, + ) + settings = G1TransitionSettings( + policy_duration_s=config.policy_transition_duration_s, + passive_duration_min_s=config.passive_transition_min_s, + passive_duration_max_s=config.passive_transition_max_s, + passive_max_joint_speed_rad_s=config.passive_max_joint_speed_rad_s, + passive_gain_ramp_s=config.passive_gain_ramp_s, + ) + controller = G1HotSwappingController( + robot=robot, + walk=walk, + wbt=wbt, + fixstand_joint_position=fixstand_position, + fixstand_kp=fixstand_kp, + fixstand_kd=fixstand_kd, + passive_kd=np.full(robot.joint_count, config.passive_kd, dtype=np.float32), + wbt_preparation=SkillPreparationSpec( + joint_position=fixstand_position, + kp=wbt_preparation_kp, + kd=wbt_preparation_kd, + ramp_duration_s=wbt_spec.preparation_ramp_duration_s, + settle_duration_s=wbt_spec.preparation_settle_duration_s, + timeout_s=wbt_spec.preparation_timeout_s, + ), + initial_state=config.initial_state, + settings=settings, + ) + return DeploymentProgram( + robot=robot, + control=walk_manifest.control, + controller=controller, + command_lower=walk.processor.command_lower, + command_upper=walk.processor.command_upper, + operator=config.operator, + ) + + +__all__ = ["G1HotSwappingProgramCfg", "create_program", "install_program_schema"] diff --git a/motrix_deploy_tasks/src/motrix_deploy_tasks/state_machines/__init__.py b/motrix_deploy_tasks/src/motrix_deploy_tasks/state_machines/__init__.py new file mode 100644 index 00000000..8140d24f --- /dev/null +++ b/motrix_deploy_tasks/src/motrix_deploy_tasks/state_machines/__init__.py @@ -0,0 +1 @@ +"""Task-owned persistent deployment state machines.""" diff --git a/motrix_deploy_tasks/src/motrix_deploy_tasks/state_machines/g1_states.py b/motrix_deploy_tasks/src/motrix_deploy_tasks/state_machines/g1_states.py new file mode 100644 index 00000000..a15bc915 --- /dev/null +++ b/motrix_deploy_tasks/src/motrix_deploy_tasks/state_machines/g1_states.py @@ -0,0 +1,277 @@ +# Copyright Motphys Technology Co., Ltd. 2025, 2026 +# SPDX-License-Identifier: Apache-2.0 + +"""Persistent G1 deployment states (passive/fixstand/walk/wbt) and their controller.""" + +from __future__ import annotations + +from dataclasses import dataclass + +import numpy as np + +from motrix_deploy.contracts import FloatArray, JointServoCommand, RobotSpec, RobotState, float32_array +from motrix_deploy.operator import OperatorCommand +from motrix_deploy.policy import Policy +from motrix_deploy.runtime.context import ControlContext +from motrix_deploy.runtime.control import PolicyController +from motrix_deploy.runtime.hot_swapping import BaselineStates, RobotHotSwappingController, SkillModule +from motrix_deploy.runtime.lifecycle import ControllerStep +from motrix_deploy.runtime.preparation import JointServoPreparationState, SkillPreparationSpec +from motrix_deploy.runtime.state_machine import ( + AdaptiveServoTransition, + SmoothServoTransition, + TransitionRule, +) +from motrix_deploy_tasks.tasks.g1_walk import G1WalkPolicyProcessor, G1WalkTaskSpec +from motrix_deploy_tasks.tasks.g1_wbt import G1WbtMotion, G1WbtPolicyProcessor, G1WbtTaskSpec +from motrix_env_core.input import PlanarVelocityCommand + + +def _vector(value: object, *, path: str, joint_count: int) -> FloatArray: + return float32_array(np.asarray(value, dtype=np.float32), path=path, shape=(joint_count,)) + + +def _state_in_joint_order( + state: RobotState, source_names: tuple[str, ...], target_names: tuple[str, ...] +) -> RobotState: + if source_names == target_names: + return state + indices = np.asarray([source_names.index(name) for name in target_names], dtype=np.int64) + return RobotState( + sample_time_ns=state.sample_time_ns, + receive_time_ns=state.receive_time_ns, + joint_position=state.joint_position[indices].astype(np.float32), + joint_velocity=state.joint_velocity[indices].astype(np.float32), + base_orientation_xyzw=state.base_orientation_xyzw, + base_angular_velocity=state.base_angular_velocity, + base_linear_acceleration=state.base_linear_acceleration, + base_linear_velocity=state.base_linear_velocity, + ) + + +class G1PassiveState: + """Persistent zero-stiffness damping without ending the control session.""" + + name = "passive" + + def __init__( + self, + joint_names: tuple[str, ...], + kd: FloatArray, + position_lower: FloatArray, + position_upper: FloatArray, + ) -> None: + self.joint_names = joint_names + self._kd = _vector(kd, path="g1.passive.kd", joint_count=len(joint_names)) + self._position_lower = _vector(position_lower, path="g1.passive.position_lower", joint_count=len(joint_names)) + self._position_upper = _vector(position_upper, path="g1.passive.position_upper", joint_count=len(joint_names)) + self._zeros = np.zeros(len(joint_names), dtype=np.float32) + + def reset(self, state: RobotState) -> None: + del state + + def request_stop(self) -> None: + pass + + def step(self, state: RobotState, context: ControlContext[OperatorCommand]) -> ControllerStep: + del context + target = np.clip(state.joint_position, self._position_lower, self._position_upper).astype(np.float32) + return ControllerStep(command=JointServoCommand(target, self._zeros, self._zeros, self._zeros, self._kd)) + + +class G1FixStandState: + """Persistent joint-name-defined standing posture and support gains.""" + + name = "fixstand" + + def __init__( + self, + joint_names: tuple[str, ...], + joint_position: FloatArray, + kp: FloatArray, + kd: FloatArray, + ) -> None: + joint_count = len(joint_names) + self.joint_names = joint_names + self._target = _vector(joint_position, path="g1.fixstand.joint_position", joint_count=joint_count) + self._kp = _vector(kp, path="g1.fixstand.kp", joint_count=joint_count) + self._kd = _vector(kd, path="g1.fixstand.kd", joint_count=joint_count) + self._zeros = np.zeros(joint_count, dtype=np.float32) + + def reset(self, state: RobotState) -> None: + del state + + def request_stop(self) -> None: + pass + + def step(self, state: RobotState, context: ControlContext[OperatorCommand]) -> ControllerStep: + del state, context + return ControllerStep(command=JointServoCommand(self._target, self._zeros, self._zeros, self._kp, self._kd)) + + +class G1WalkState: + """Persistent locomotion backed by the exported Walk processor and ONNX policy.""" + + name = "walk" + + def __init__( + self, + spec: G1WalkTaskSpec, + robot: RobotSpec, + policy: Policy, + canonical_joint_names: tuple[str, ...], + ) -> None: + self.joint_names = robot.joint_names + self._canonical_joint_names = canonical_joint_names + self.processor = G1WalkPolicyProcessor(spec, robot) + self.controller = PolicyController(self.processor, policy) + self._zero_velocity = PlanarVelocityCommand(np.zeros((1, 3), dtype=np.float32)) + + def _state(self, state: RobotState) -> RobotState: + return _state_in_joint_order(state, self._canonical_joint_names, self.joint_names) + + def reset(self, state: RobotState) -> None: + self.controller.steps = None + self.controller.reset(self._state(state)) + + def request_stop(self) -> None: + self.controller.request_stop() + + def step(self, state: RobotState, context: ControlContext[OperatorCommand]) -> ControllerStep: + operator = context.command + velocity = ( + self._zero_velocity if operator is None or operator.planar_velocity is None else operator.planar_velocity + ) + local = ControlContext(context.step, context.elapsed_time_s, velocity, context.dt_s) + return self.controller.step(self._state(state), local) + + +class G1WbtState: + """Finite WBT playback with a frame-zero policy warm-up during takeover.""" + + name = "wbt" + + def __init__( + self, + spec: G1WbtTaskSpec, + robot: RobotSpec, + motion: G1WbtMotion, + policy: Policy, + canonical_joint_names: tuple[str, ...], + *, + takeover_hold_steps: int, + ) -> None: + if takeover_hold_steps < 1: + raise ValueError("takeover_hold_steps must be at least one policy interval") + self.joint_names = robot.joint_names + self._canonical_joint_names = canonical_joint_names + self.motion = motion + self.processor = G1WbtPolicyProcessor(spec, robot, motion) + self.controller = PolicyController(self.processor, policy) + self._takeover_hold_steps = takeover_hold_steps + self._ticks = 0 + self._playback_frame = 0 + self._playback_started = False + + def _state(self, state: RobotState) -> RobotState: + return _state_in_joint_order(state, self._canonical_joint_names, self.joint_names) + + def reset(self, state: RobotState) -> None: + self._ticks = 0 + self._playback_frame = 0 + self._playback_started = False + local = self._state(state) + self.processor.reset_reference() + # Align the clip's heading with the robot's heading at takeover. + self.processor.align_reference_to(local) + self.controller.steps = None + self.controller.reset(local) + + def request_stop(self) -> None: + self.controller.request_stop() + + def step(self, state: RobotState, context: ControlContext[OperatorCommand]) -> ControllerStep: + if not self._playback_started and self._ticks >= self._takeover_hold_steps: + self._playback_started = True + self.controller.steps = self.controller.completed_steps + len(self.motion) + frame = self._playback_frame if self._playback_started else 0 + self.processor.set_reference_frame(min(frame, len(self.motion) - 1)) + local = ControlContext(context.step, context.elapsed_time_s, None, context.dt_s) + decision = self.controller.step(self._state(state), local) + self._ticks += 1 + if self._playback_started and decision.policy_tick: + self._playback_frame += 1 + return decision + + +@dataclass(frozen=True) +class G1TransitionSettings: + """Durations for normal policy takeover and safe posture recovery.""" + + policy_duration_s: float = 0.5 + passive_duration_min_s: float = 0.5 + passive_duration_max_s: float = 3.0 + passive_max_joint_speed_rad_s: float = 0.5 + passive_gain_ramp_s: float = 0.5 + + +class G1HotSwappingController(RobotHotSwappingController): + """Bind G1 baseline states and WBT as one standard hot-swappable skill.""" + + def __init__( + self, + *, + robot: RobotSpec, + walk: G1WalkState, + wbt: G1WbtState, + fixstand_joint_position: FloatArray, + fixstand_kp: FloatArray, + fixstand_kd: FloatArray, + passive_kd: FloatArray, + wbt_preparation: SkillPreparationSpec, + initial_state: str = "fixstand", + settings: G1TransitionSettings = G1TransitionSettings(), + ) -> None: + joint_names = robot.joint_names + passive = G1PassiveState(joint_names, passive_kd, robot.position_lower, robot.position_upper) + fixstand = G1FixStandState(joint_names, fixstand_joint_position, fixstand_kp, fixstand_kd) + baseline_transitions = ( + TransitionRule( + "passive", + "fixstand", + lambda: AdaptiveServoTransition( + settings.passive_duration_min_s, + settings.passive_duration_max_s, + settings.passive_max_joint_speed_rad_s, + ), + ), + TransitionRule("fixstand", "passive", lambda: SmoothServoTransition(settings.passive_gain_ramp_s)), + TransitionRule("fixstand", "walk", lambda: SmoothServoTransition(settings.policy_duration_s)), + TransitionRule("walk", "fixstand", lambda: SmoothServoTransition(settings.policy_duration_s)), + ) + super().__init__( + joint_names=joint_names, + baseline=BaselineStates(passive=passive, fixstand=fixstand, walk=walk), + preparation=JointServoPreparationState(robot), + skills=( + SkillModule( + name="wbt", + state=wbt, + preparation=wbt_preparation, + request_intent="request_wbt", + ), + ), + initial_state=initial_state, + baseline_transitions=baseline_transitions, + passive_transition=lambda: SmoothServoTransition(settings.passive_gain_ramp_s), + ) + + +__all__ = [ + "G1FixStandState", + "G1HotSwappingController", + "G1PassiveState", + "G1TransitionSettings", + "G1WalkState", + "G1WbtState", +] diff --git a/motrix_deploy_tasks/src/motrix_deploy_tasks/tasks/g1_walk.py b/motrix_deploy_tasks/src/motrix_deploy_tasks/tasks/g1_walk.py new file mode 100644 index 00000000..495035c0 --- /dev/null +++ b/motrix_deploy_tasks/src/motrix_deploy_tasks/tasks/g1_walk.py @@ -0,0 +1,357 @@ +# Copyright Motphys Technology Co., Ltd. 2025, 2026 +# SPDX-License-Identifier: Apache-2.0 + +"""Typed artifact specification and runtime skeleton for ``g1_walk/v1``.""" + +import math +from typing import Annotated, ClassVar + +import numpy as np +from pydantic import Field, model_validator + +from motrix_deploy.artifact.schema import TaskSpec +from motrix_deploy.contracts import FloatArray, JointServoCommand, RobotSpec, RobotState, float32_array +from motrix_deploy.errors import ValidationError +from motrix_deploy.operator import OperatorProfileCfg +from motrix_deploy.policy import Policy +from motrix_deploy.policy.processing import PolicyProcessor +from motrix_deploy.runtime.context import ControlContext +from motrix_deploy.runtime.control import PolicyController +from motrix_deploy.runtime.lifecycle import ControllerStep +from motrix_deploy.task import DeployTask +from motrix_env_core.input import ( + BoundedGamePadPlanarVelocityBinding, + CommandBinding, + ConstantPlanarVelocityBinding, + GamePadDevice, + InputDevice, + KeyboardDevice, + KeyboardPlanarVelocityBinding, + PlanarVelocityCommand, +) + +FLOAT32_MAX = float(np.finfo(np.float32).max) +FiniteFloat = Annotated[float, Field(allow_inf_nan=False)] +Float32Float = Annotated[FiniteFloat, Field(ge=-FLOAT32_MAX, le=FLOAT32_MAX)] +NonNegativeFloat = Annotated[FiniteFloat, Field(ge=0)] +PositiveFloat = Annotated[FiniteFloat, Field(gt=0)] +JointVector = Annotated[list[Float32Float], Field(min_length=1)] +NonNegativeJointVector = Annotated[list[Annotated[Float32Float, Field(ge=0)]], Field(min_length=1)] +CommandVector = Annotated[list[Float32Float], Field(min_length=3, max_length=3)] +GaitPhaseOffsets = Annotated[list[Float32Float], Field(min_length=2, max_length=2)] + + +class G1WalkTaskSpec(TaskSpec): + """Self-contained G1 locomotion policy I/O and gait parameters. + + Joint vectors use the canonical order stored in the artifact's + ``RobotSpec.joint_names``. Action bounds apply to raw policy output before + multiplication by ``action_scale`` and addition of the robot default pose. + Command vectors use ``(vx, vy, wz)`` order in SI units. + """ + + task_name: ClassVar[str] = "g1_walk/v1" + + action_scale: NonNegativeJointVector + kp: NonNegativeJointVector + kd: NonNegativeJointVector + action_lower: JointVector + action_upper: JointVector + + command_lower: CommandVector + command_upper: CommandVector + + base_angular_velocity_scale: PositiveFloat + joint_position_scale: PositiveFloat + joint_velocity_scale: PositiveFloat + + gait_period_s: PositiveFloat + gait_phase_offsets_rad: GaitPhaseOffsets + standing_command_threshold: NonNegativeFloat + + @model_validator(mode="after") + def validate_vector_lengths_and_ranges(self) -> "G1WalkTaskSpec": + joint_count = len(self.action_scale) + for key in ("kp", "kd", "action_lower", "action_upper"): + if len(getattr(self, key)) != joint_count: + raise ValueError(f"{key} must have the same length as action_scale ({joint_count})") + + if any(lower > upper for lower, upper in zip(self.action_lower, self.action_upper, strict=True)): + raise ValueError("action_lower must be less than or equal to action_upper") + if any(lower > 0.0 or upper < 0.0 for lower, upper in zip(self.action_lower, self.action_upper, strict=True)): + raise ValueError("raw action range must contain zero for every joint") + + if any(lower > upper for lower, upper in zip(self.command_lower, self.command_upper, strict=True)): + raise ValueError("command_lower must be less than or equal to command_upper") + if any(lower > 0.0 or upper < 0.0 for lower, upper in zip(self.command_lower, self.command_upper, strict=True)): + raise ValueError("velocity command range must contain zero on every axis") + + left, right = self.gait_phase_offsets_rad + phase_difference = (right - left) % (2.0 * math.pi) + if not math.isclose(phase_difference, math.pi, rel_tol=0.0, abs_tol=1e-6): + raise ValueError("gait phase lanes must be separated by pi radians") + return self + + +class G1WalkPolicyProcessor(PolicyProcessor[PlanarVelocityCommand]): + """Reproduce the G1 walk policy observation and joint-servo contracts.""" + + def __init__(self, spec: G1WalkTaskSpec, robot: RobotSpec) -> None: + joint_count = robot.joint_count + if len(spec.action_scale) != joint_count: + raise ValidationError("task.config.action_scale", f"{joint_count} joint values", len(spec.action_scale)) + self.spec = spec + self.robot = robot + shape = (joint_count,) + self._action_scale = _spec_array(spec.action_scale, path="task.config.action_scale", shape=shape) + self._kp = _spec_array(spec.kp, path="task.config.kp", shape=shape) + self._kd = _spec_array(spec.kd, path="task.config.kd", shape=shape) + self._action_lower = _spec_array(spec.action_lower, path="task.config.action_lower", shape=shape) + self._action_upper = _spec_array(spec.action_upper, path="task.config.action_upper", shape=shape) + self._command_lower = _spec_array(spec.command_lower, path="task.config.command_lower", shape=(3,)) + self._command_upper = _spec_array(spec.command_upper, path="task.config.command_upper", shape=(3,)) + self._gait_phase_offsets = _spec_array( + spec.gait_phase_offsets_rad, + path="task.config.gait_phase_offsets_rad", + shape=(2,), + ) + self._base_angular_velocity_scale = np.float32(spec.base_angular_velocity_scale) + self._joint_position_scale = np.float32(spec.joint_position_scale) + self._joint_velocity_scale = np.float32(spec.joint_velocity_scale) + self._gait_period_s = np.float32(spec.gait_period_s) + self._standing_command_threshold = np.float32(spec.standing_command_threshold) + self._previous_action = np.zeros(joint_count, dtype=np.float32) + self._phase = np.float32(0.0) + self._last_step = 0 + + @property + def command_lower(self) -> FloatArray: + return self._command_lower + + @property + def command_upper(self) -> FloatArray: + return self._command_upper + + def reset(self, state: RobotState, context: ControlContext[PlanarVelocityCommand]) -> None: + """Clear raw-action history and restart the deterministic gait clock.""" + + self._validate_state_joint_count(state) + self._previous_action.fill(0.0) + self._phase = np.float32(0.0) + self._last_step = 0 + + def build_observation( + self, + state: RobotState, + context: ControlContext[PlanarVelocityCommand], + ) -> FloatArray: + """Build the exact 100-element actor input used by ``g1-walk-flat``.""" + + self._validate_state_joint_count(state) + velocity = self._validated_velocity(context.command) + self._advance_phase(context) + + linear_speed = float(np.linalg.norm(velocity[:2])) + standing = linear_speed < float(self._standing_command_threshold) and abs(float(velocity[2])) < float( + self._standing_command_threshold + ) + if standing: + phase = np.full(2, np.float32(math.pi), dtype=np.float32) + else: + phase = self._phase + self._gait_phase_offsets + sin_phase = np.sin(phase).astype(np.float32) + cos_phase = np.cos(phase).astype(np.float32) + + observation = np.concatenate( + ( + state.base_angular_velocity * self._base_angular_velocity_scale, + _projected_gravity_body(state.base_orientation_xyzw), + velocity, + (state.joint_position - self.robot.default_joint_position) * self._joint_position_scale, + state.joint_velocity * self._joint_velocity_scale, + self._previous_action, + sin_phase, + cos_phase, + ) + ).astype(np.float32) + expected_shape = (9 + 3 * self.robot.joint_count + 4,) + if observation.shape != expected_shape or not np.all(np.isfinite(observation)): + raise ValidationError("observation", f"finite float32 values with shape {expected_shape}", observation) + return observation + + def process_action(self, action: FloatArray) -> JointServoCommand: + """Clip raw policy output and convert it to canonical joint servos.""" + + shape = (self.robot.joint_count,) + raw = float32_array(action, path="action.raw", shape=shape) + executed = np.clip(raw, self._action_lower, self._action_upper).astype(np.float32) + target = self.robot.default_joint_position + self._action_scale * executed + target = np.clip(target, self.robot.position_lower, self.robot.position_upper).astype(np.float32) + self._previous_action = executed.copy() + zeros = np.zeros(self.robot.joint_count, dtype=np.float32) + return JointServoCommand( + joint_position=target, + joint_velocity=zeros, + feedforward_torque=zeros.copy(), + kp=np.array(self._kp, dtype=np.float32, copy=True), + kd=np.array(self._kd, dtype=np.float32, copy=True), + ) + + def validate_command(self, command: PlanarVelocityCommand | None) -> None: + self._validated_velocity(command) + + def _validated_velocity(self, command: PlanarVelocityCommand | None) -> FloatArray: + if not isinstance(command, PlanarVelocityCommand): + raise ValidationError("command.type", "PlanarVelocityCommand", type(command).__name__) + if command.batch_size != 1: + raise ValidationError("command.batch_size", "1", command.batch_size) + velocity = command.values[0] + if np.any(velocity < self._command_lower) or np.any(velocity > self._command_upper): + raise ValidationError( + "command.velocity", + f"inside [{self._command_lower.tolist()}, {self._command_upper.tolist()}]", + velocity.tolist(), + ) + return velocity + + def _validate_state_joint_count(self, state: RobotState) -> None: + expected = (self.robot.joint_count,) + if state.joint_position.shape != expected or state.joint_velocity.shape != expected: + raise ValidationError( + "state.joints.shape", + str(expected), + (state.joint_position.shape, state.joint_velocity.shape), + ) + + def _advance_phase(self, context: ControlContext[PlanarVelocityCommand]) -> None: + if context.step < self._last_step: + raise ValidationError("context.step", f">= {self._last_step}", context.step) + if not np.isfinite(context.dt_s) or context.dt_s <= 0.0: + raise ValidationError("context.dt_s", "a positive finite value", context.dt_s) + elapsed_steps = context.step - self._last_step + if elapsed_steps: + increment = 2.0 * math.pi * elapsed_steps * context.dt_s / float(self._gait_period_s) + self._phase = np.float32((float(self._phase) + increment) % (2.0 * math.pi)) + self._last_step = context.step + + +def _projected_gravity_body(orientation_xyzw: FloatArray) -> FloatArray: + """Rotate world ``-Z`` into body coordinates for a body-to-world quaternion.""" + + x, y, z, w = orientation_xyzw + return np.asarray( + ( + 2.0 * (y * w - x * z), + -2.0 * (x * w + y * z), + 2.0 * (x * x + y * y) - 1.0, + ), + dtype=np.float32, + ) + + +def _spec_array(value: object, *, path: str, shape: tuple[int, ...]) -> FloatArray: + """Materialize one validated Pydantic numeric vector as immutable float32.""" + + return float32_array(np.asarray(value, dtype=np.float32), path=path, shape=shape) + + +class G1WalkDeployTask(DeployTask[PlanarVelocityCommand]): + """Assemble G1 locomotion policy I/O with an operator command source.""" + + spec_type = G1WalkTaskSpec + + def __init__( + self, + spec: G1WalkTaskSpec, + robot: RobotSpec, + policy: Policy, + steps: int | None = None, + artifact: object | None = None, + ) -> None: + del artifact + self.spec = spec + self.robot = robot + self.policy_io = G1WalkPolicyProcessor(spec, robot) + self.policy_controller = PolicyController(self.policy_io, policy, steps=steps) + self._keyboard_attached = False + self._gamepad_attached = False + self._operator_profile: OperatorProfileCfg | None = None + + def configure_operator(self, profile: OperatorProfileCfg | None) -> None: + """Store task-owned gamepad command wiring from the selected recipe.""" + self._operator_profile = profile + + def prepare( + self, + *, + simulation: bool, + device: InputDevice | None = None, + spawn_pose: str | None = None, + ) -> CommandBinding[PlanarVelocityCommand]: + """Bind viewer keys to velocity commands, or stand still without a keyboard.""" + + del simulation, spawn_pose + command_lower, command_upper = self.command_bounds + if isinstance(device, KeyboardDevice): + self._keyboard_attached = True + self._gamepad_attached = False + return KeyboardPlanarVelocityBinding( + device, + command_lower=command_lower, + command_upper=command_upper, + ) + if isinstance(device, GamePadDevice) and self._operator_profile is not None: + velocity = self._operator_profile.planar_velocity + if velocity is not None: + self._keyboard_attached = False + self._gamepad_attached = True + return BoundedGamePadPlanarVelocityBinding( + device, + linear_x_axis=velocity.linear_x_axis, + linear_y_axis=velocity.linear_y_axis, + yaw_axis=velocity.yaw_axis, + command_lower=command_lower, + command_upper=command_upper, + deadzone=velocity.deadzone, + range_scale=velocity.range_scale, + invert_linear_x=velocity.invert_linear_x, + invert_linear_y=velocity.invert_linear_y, + invert_yaw=velocity.invert_yaw, + deadman_button=velocity.deadman_button, + ) + self._keyboard_attached = False + self._gamepad_attached = False + binding = ConstantPlanarVelocityBinding((0.0, 0.0, 0.0)) + self.validate_command(binding.read_command()) + return binding + + @property + def command_bounds(self) -> tuple[FloatArray, FloatArray]: + return self.policy_io.command_lower, self.policy_io.command_upper + + @property + def operator_hint(self) -> str | None: + if self._keyboard_attached: + return "w/s forward/back a/d left/right q/e turn left/right" + if self._gamepad_attached: + return "G1 remote: LT+Up stand RB+X enable policy LT+B passive select emergency stop" + return None + + def reset(self, state: RobotState) -> None: + self.policy_controller.reset(state) + + def step( + self, + state: RobotState, + context: ControlContext[PlanarVelocityCommand], + ) -> ControllerStep: + return self.policy_controller.step(state, context) + + def request_stop(self) -> None: + self.policy_controller.request_stop() + + def validate_command(self, command: PlanarVelocityCommand | None) -> None: + self.policy_io.validate_command(command) + + +__all__ = ["G1WalkDeployTask", "G1WalkPolicyProcessor", "G1WalkTaskSpec"] diff --git a/motrix_deploy_tasks/src/motrix_deploy_tasks/tasks/g1_wbt.py b/motrix_deploy_tasks/src/motrix_deploy_tasks/tasks/g1_wbt.py index af0b5092..786bb528 100644 --- a/motrix_deploy_tasks/src/motrix_deploy_tasks/tasks/g1_wbt.py +++ b/motrix_deploy_tasks/src/motrix_deploy_tasks/tasks/g1_wbt.py @@ -28,6 +28,7 @@ from motrix_deploy.runtime.context import ControlContext from motrix_deploy.runtime.control import PolicyController from motrix_deploy.runtime.lifecycle import ControllerStep +from motrix_deploy.runtime.preparation import JointServoPreparationState, SkillPreparationSpec from motrix_deploy.task import DeployTask FiniteFloat = Annotated[float, Field(allow_inf_nan=False)] @@ -84,7 +85,7 @@ def __len__(self) -> int: return int(np.asarray(self.joint_pos).shape[0]) -def _load_motion(spec: G1WbtTaskSpec, artifact: Artifact | None) -> G1WbtMotion: +def load_g1_wbt_motion(spec: G1WbtTaskSpec, artifact: Artifact | None) -> G1WbtMotion: """Load and validate the motion clip from the artifact's single NPZ payload.""" if artifact is None: raise ValidationError("task.payloads", "the deployment artifact", None) @@ -140,6 +141,9 @@ def __init__(self, spec: G1WbtTaskSpec, robot: RobotSpec, motion: G1WbtMotion) - self._motion_joint_position = np.asarray(motion.joint_pos, dtype=np.float32) self._motion_joint_velocity = np.asarray(motion.joint_vel, dtype=np.float32) self._reference_quaternion = np.asarray(motion.reference_quaternion_xyzw, dtype=np.float32) + # Yaw offset between the clip's world frame and the robot's IMU world frame. + # Identity keeps the raw reference (simulation and parity harnesses). + self._reference_alignment = np.asarray((0.0, 0.0, 0.0, 1.0), dtype=np.float32) self._default_joint_position = robot.default_joint_position.astype(np.float32, copy=True) self._action_scale = np.asarray(spec.action_scale, dtype=np.float32) self._previous_action = np.zeros(self.action_size, dtype=np.float32) @@ -153,6 +157,21 @@ def reset_reference(self) -> None: self._reference_frame = 0 self._latest_frame = 0 + def align_reference_to(self, state: RobotState) -> None: + """Rotate the clip's world frame onto the robot's measured heading. + + The IMU has no absolute heading, so feeding ``R(torso)^T @ R(reference)`` + without this leaves a constant yaw offset in the 6D block equal to the + difference between the robot's heading and the clip's frame 0. The policy + then twists to "correct" it (works at one heading, diverges at another). + Mirrors unitree_rl_lab ``State_WBT.cpp``: ``init_quat = yaw(robot) * yaw(ref0)^T``. + """ + torso = self.torso_orientation(state) + self._reference_alignment = _quat_from_yaw(_yaw_of(torso) - _yaw_of(self._reference_quaternion[0])) + + def _aligned_reference(self, frame: int) -> np.ndarray: + return _quat_multiply(self._reference_alignment, self._reference_quaternion[frame]) + def set_reference_frame(self, frame: int) -> None: """Select a reference independently of the continuously running policy.""" if not 0 <= frame < self._frames: @@ -192,9 +211,7 @@ def actor_observation( ``process_action`` input is echoed, as training observes the current raw action after stepping and thus the previous action at the next inference. """ - relative_rotation = _rotation_matrix(torso_quaternion_xyzw).T @ _rotation_matrix( - self._reference_quaternion[frame] - ) + relative_rotation = _rotation_matrix(torso_quaternion_xyzw).T @ _rotation_matrix(self._aligned_reference(frame)) raw_history = self._previous_action if previous_action is None else previous_action return np.concatenate( ( @@ -253,7 +270,7 @@ def process_action(self, action: FloatArray) -> JointServoCommand: def check_termination(self, state: RobotState) -> str | None: frame = self._latest_frame torso = self.torso_orientation(state) - reference = self._reference_quaternion[frame] + reference = self._aligned_reference(frame) gravity_error = abs(2 * (reference[0] ** 2 + reference[1] ** 2 - torso[0] ** 2 - torso[1] ** 2)) if gravity_error > self.spec.termination_ref_orientation_threshold: return "bad_ref_ori" @@ -267,6 +284,31 @@ def check_termination(self, state: RobotState) -> str | None: return None +def _quat_multiply(a: np.ndarray, b: np.ndarray) -> np.ndarray: + """Hamilton product of two xyzw quaternions.""" + ax, ay, az, aw = (float(value) for value in a) + bx, by, bz, bw = (float(value) for value in b) + return np.asarray( + ( + aw * bx + bw * ax + ay * bz - az * by, + aw * by + bw * ay + az * bx - ax * bz, + aw * bz + bw * az + ax * by - ay * bx, + aw * bw - ax * bx - ay * by - az * bz, + ), + dtype=np.float32, + ) + + +def _yaw_of(quaternion_xyzw: np.ndarray) -> float: + """ZYX yaw of a body-to-world quaternion.""" + x, y, z, w = (float(value) for value in quaternion_xyzw) + return float(np.arctan2(2.0 * (w * z + x * y), 1.0 - 2.0 * (y * y + z * z))) + + +def _quat_from_yaw(yaw: float) -> np.ndarray: + return np.asarray((0.0, 0.0, np.sin(0.5 * yaw), np.cos(0.5 * yaw)), dtype=np.float32) + + def _rotation_matrix(quaternion_xyzw: np.ndarray) -> np.ndarray: """Quaternion matrix with the same norm correction as training's encoder.""" x, y, z, w = np.asarray(quaternion_xyzw, dtype=np.float64) @@ -292,101 +334,6 @@ class StageResult: error: str | None = None -@dataclass(frozen=True) -class G1PreparationSettings: - """Measured readiness limits; preparation never injects a reference root state.""" - - ramp_duration_s: float = 2.0 - settle_duration_s: float = 1.0 - timeout_s: float = 5.0 - max_joint_error_rad: float = 0.2 - max_joint_velocity_rad_s: float = 1.0 - max_base_tilt_rad: float = 0.5 - - -class G1ReadyController: - """Ramp from measured joints, then require an uninterrupted ready interval.""" - - name = "prepare" - - def __init__( - self, - target: FloatArray, - kp: FloatArray, - kd: FloatArray, - robot: RobotSpec, - settings: G1PreparationSettings, - ) -> None: - self._initial_position: FloatArray | None = None - self._target = np.clip(target, robot.position_lower, robot.position_upper).astype(np.float32) - self._kp = kp - self._kd = kd - self._robot = robot - self._settings = settings - self._stop_requested = False - self._ready_since: float | None = None - self._reached_ready = False - self._zeros = np.zeros(robot.joint_count, dtype=np.float32) - - def reset(self, state: RobotState) -> None: - self._initial_position = state.joint_position.copy() - self._ready_since = None - self._reached_ready = False - self._stop_requested = False - - def hold_command(self) -> JointServoCommand: - """Keep the independent standing posture while waiting for a start request.""" - return JointServoCommand(self._target, self._zeros, self._zeros, self._kp, self._kd) - - def request_stop(self) -> None: - self._stop_requested = True - - def step(self, state: RobotState, context: ControlContext[None]) -> ControllerStep: - if self._stop_requested: - return ControllerStep(complete=True) - elapsed_time_s = context.elapsed_time_s - assert self._initial_position is not None - settings = self._settings - x, y, _, _ = state.base_orientation_xyzw - tilt = float(np.arccos(np.clip(1 - 2 * (float(x) ** 2 + float(y) ** 2), -1, 1))) - metrics = { - "max_joint_error_rad": float(np.max(np.abs(state.joint_position - self._target))), - "max_joint_velocity_rad_s": float(np.max(np.abs(state.joint_velocity))), - "base_tilt_rad": tilt, - } - if tilt > settings.max_base_tilt_rad: - return ControllerStep(metrics=metrics, error=f"unsafe base tilt during preparation: {metrics}") - ready = ( - elapsed_time_s + 1e-9 >= settings.ramp_duration_s - and metrics["max_joint_error_rad"] <= settings.max_joint_error_rad - and metrics["max_joint_velocity_rad_s"] <= settings.max_joint_velocity_rad_s - ) - if ready: - if self._ready_since is None: - self._ready_since = elapsed_time_s - else: - self._ready_since = None - if ( - self._ready_since is not None - and elapsed_time_s - self._ready_since + 1e-9 >= settings.settle_duration_s - and (self._reached_ready or elapsed_time_s <= settings.timeout_s + 1e-9) - ): - self._reached_ready = True - return ControllerStep(complete=True, metrics=metrics) - if not self._reached_ready and elapsed_time_s + 1e-9 >= settings.timeout_s: - return ControllerStep(metrics=metrics, error=f"preparation timed out: {metrics}") - fraction = ( - np.clip((elapsed_time_s + context.dt_s) / settings.ramp_duration_s, 0, 1) - if settings.ramp_duration_s > 0 - else 1 - ) - target = self._initial_position + np.float32(fraction) * (self._target - self._initial_position) - target = np.clip(target, self._robot.position_lower, self._robot.position_upper).astype(np.float32) - return ControllerStep( - command=JointServoCommand(target, self._zeros, self._zeros, self._kp, self._kd), metrics=metrics - ) - - class G1DampingController: """Damp measured joint velocity briefly, without holding any reference pose.""" @@ -433,7 +380,7 @@ def __init__( artifact: Artifact | None = None, ): if motion is None: - motion = _load_motion(spec, artifact) + motion = load_g1_wbt_motion(spec, artifact) budget = len(motion) if steps is None else steps if not 0 < budget <= len(motion): raise ValidationError("steps", "a positive budget inside the single motion clip", budget) @@ -449,20 +396,24 @@ def __init__( else spec.preparation_joint_position, dtype=np.float32, ).copy() + # Per-artifact stand-up recipe: the policy gains are tracking gains and + # cannot hold a static stance. self._preparation_kp = np.asarray( spec.kp if spec.preparation_kp is None else spec.preparation_kp, dtype=np.float32 ) self._preparation_kd = np.asarray( spec.kd if spec.preparation_kd is None else spec.preparation_kd, dtype=np.float32 ) - self._preparation_settings = G1PreparationSettings( + self._preparation_spec = SkillPreparationSpec( + joint_position=self._standing_position, + kp=self._preparation_kp, + kd=self._preparation_kd, ramp_duration_s=spec.preparation_ramp_duration_s, settle_duration_s=spec.preparation_settle_duration_s, timeout_s=spec.preparation_timeout_s, ) - self.ready = G1ReadyController( - self._standing_position, self._preparation_kp, self._preparation_kd, robot, self._preparation_settings - ) + self.ready = JointServoPreparationState(robot) + self.ready.select(self._preparation_spec) self.damping = G1DampingController(self.policy_io._kd, robot) self.transitions: list[StageResult] = [] self._phase = "prepare" diff --git a/motrix_deploy_tasks/tests/test_cli.py b/motrix_deploy_tasks/tests/test_cli.py index 609eb63c..8e8659ef 100644 --- a/motrix_deploy_tasks/tests/test_cli.py +++ b/motrix_deploy_tasks/tests/test_cli.py @@ -30,6 +30,7 @@ from motrix_deploy.artifact.schema import PayloadSpec from motrix_deploy.contracts import RobotSpec, TensorSpec from motrix_deploy.env import assemble_deploy_scene, create_deploy_env +from motrix_deploy.robot.g1_standing import resolve_g1_standing_gains from motrix_deploy_tasks.tasks.go2_walk import Go2WalkTaskSpec from motrix_env_core.config.scene import FlatTerrainCfg, HFieldTerrainCfg, SceneCfg @@ -95,6 +96,32 @@ def test_hardware_cli_help_selects_hardware_recipe() -> None: assert "backend: unitree" in result.stdout +def test_g1_hardware_recipe_composes_named_gains_and_operator_profile() -> None: + unitree_config = pytest.importorskip("motrix_deploy_unitree.config") + with initialize_config_module(version_base=None, config_module="motrix_deploy.config"): + cfg = compose( + config_name="deploy", + overrides=["task=g1-walk-flat/hardware", "runtime.network_interface=eth0"], + ) + runtime = OmegaConf.to_object(cfg.runtime) + + assert isinstance(runtime, unitree_config.UnitreeBackendConfig) + assert isinstance(runtime.robot, unitree_config.UnitreeG1_29DOFRobotCfg) + assert runtime.robot.mode_pr == 0 + assert runtime.robot.expected_mode_machine == 5 + assert runtime.robot.override_policy_gains is False + assert set(runtime.robot.kp) == set(runtime.robot.actuation.motors) + assert set(runtime.robot.kd) == set(runtime.robot.actuation.motors) + assert runtime.operator is not None + assert set(runtime.operator.intents) == { + "request_stand", + "enable_policy", + "enter_passive", + "emergency_stop", + } + assert runtime.operator.planar_velocity is not None + + @pytest.mark.parametrize( ("task", "runtime_kind", "backend"), [ @@ -246,6 +273,40 @@ def test_hardware_hydra_config_selects_runtime_defaults() -> None: assert cfg.runtime.robot.lie_down_button == "B" +def test_g1_29dof_hardware_recipe_selects_explicit_robot_contract() -> None: + unitree_config = pytest.importorskip("motrix_deploy_unitree.config") + unitree_hardware = pytest.importorskip("motrix_deploy_unitree.hardware") + with initialize_config_module(version_base=None, config_module="motrix_deploy.config"): + cfg = compose( + config_name="deploy", + overrides=[ + "task=g1-wbt-dance/hardware", + "runtime.network_interface=enp3s0", + ], + ) + + runtime = OmegaConf.to_object(cfg.runtime) + assert isinstance(runtime, unitree_config.UnitreeBackendConfig) + assert type(runtime.robot) is unitree_config.UnitreeG1_29DOFRobotCfg + assert runtime.robot.mode_pr == 0 + assert runtime.robot.expected_mode_machine == 5 + assert runtime.robot.motor_slot_count == 35 + assert runtime.robot.command_publish_period_s == pytest.approx(0.001) + assert cfg.artifact == "artifacts/g1-wbt-dance.deploy" + assert isinstance(runtime.robot, unitree_hardware.HardwareRobotCfg) + # FixStand gains are fixed in one place, not per recipe. + standing_kp, standing_kd = resolve_g1_standing_gains(tuple(runtime.robot.actuation.motors)) + np.testing.assert_array_equal( + np.asarray([runtime.robot.kp[name] for name in runtime.robot.actuation.motors], np.float32), standing_kp + ) + np.testing.assert_array_equal( + np.asarray([runtime.robot.kd[name] for name in runtime.robot.actuation.motors], np.float32), standing_kd + ) + assert runtime.network_interface == "enp3s0" + assert cfg.duration_s is not None and cfg.duration_s > 0 + assert "command" not in cfg + + def test_hardware_hydra_config_accepts_explicit_gain_overrides() -> None: pytest.importorskip("motrix_deploy_unitree.config") with initialize_config_module(version_base=None, config_module="motrix_deploy.config"): diff --git a/motrix_deploy_tasks/tests/test_g1_hot_swapping_program.py b/motrix_deploy_tasks/tests/test_g1_hot_swapping_program.py new file mode 100644 index 00000000..9ddaebdd --- /dev/null +++ b/motrix_deploy_tasks/tests/test_g1_hot_swapping_program.py @@ -0,0 +1,63 @@ +# Copyright Motphys Technology Co., Ltd. 2025, 2026 +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +from motrix_deploy.artifact.io import read_artifact +from motrix_deploy.robot.g1_standing import resolve_g1_standing_gains +from motrix_deploy.runtime.hot_swapping import RobotHotSwappingController +from motrix_deploy.runtime.preparation import JointServoPreparationState +from motrix_deploy.runtime.state_machine import ImmediateTransition +from motrix_deploy_tasks.programs.g1_hot_swapping import G1HotSwappingProgramCfg, create_program + + +def _config(**overrides): + return G1HotSwappingProgramCfg( + walk_artifact="artifacts/g1-flat.deploy", + wbt_artifact="artifacts/g1-wbt-dance.deploy", + **overrides, + ) + + +def test_g1_program_fixes_fixstand_gains_but_keeps_preparation_per_artifact(): + program = create_program(_config()) + order = program.robot.joint_names + + standing_kp, standing_kd = resolve_g1_standing_gains(order) + fixstand = program.controller.states["fixstand"] + np.testing.assert_array_equal(fixstand._kp, standing_kp) + np.testing.assert_array_equal(fixstand._kd, standing_kd) + + # Preparation is a per-artifact stand-up recipe, not the fixed FixStand gains. + spec = read_artifact("artifacts/g1-wbt-dance.deploy").manifest.task + preparation = program.controller._skills["wbt"].preparation + np.testing.assert_array_equal(preparation.kp, np.asarray(spec.preparation_kp, np.float32)) + np.testing.assert_array_equal(preparation.kd, np.asarray(spec.preparation_kd, np.float32)) + np.testing.assert_array_equal(preparation.joint_position, fixstand._target) + assert preparation.ramp_duration_s == spec.preparation_ramp_duration_s + + +def test_g1_program_defaults_to_supported_simulation_startup_state(): + program = create_program(_config()) + assert program.controller.current_state == "fixstand" + assert isinstance(program.controller, RobotHotSwappingController) + assert isinstance(program.controller.states["skill_preparation"], JointServoPreparationState) + + +def test_g1_program_can_explicitly_use_passive_startup_for_hardware(): + program = create_program(_config(initial_state="passive")) + assert program.controller.current_state == "passive" + + +def test_g1_program_routes_walk_through_shared_preparation_and_returns_wbt_to_walk(): + program = create_program(_config()) + + assert ("fixstand", "wbt") not in program.controller._rules + assert isinstance(program.controller._rules[("walk", "skill_preparation")](), ImmediateTransition) + assert isinstance(program.controller._rules[("skill_preparation", "wbt")](), ImmediateTransition) + transition = program.controller._rules[("wbt", "walk")]() + assert isinstance(transition, ImmediateTransition) + program.controller._pending_skill = "wbt" + assert program.controller._completion_target("skill_preparation") == "wbt" + assert program.controller._completion_target("wbt") == "walk" + assert program.controller.pending_skill is None From 892fefb506c88ef4bd53f824be40cc4457bfa212 Mon Sep 17 00:00:00 2001 From: MrHu <1962951972@qq.com> Date: Mon, 19 Oct 2026 17:20:59 +0800 Subject: [PATCH 4/9] feat(deploy-unitree): add G1 29-DOF hardware backend and native adapter --- motrix_deploy_unitree/README.md | 28 +- .../src/motrix_deploy_unitree/__init__.py | 19 +- .../src/motrix_deploy_unitree/cli.py | 8 +- .../src/motrix_deploy_unitree/config.py | 204 +++++++- .../src/motrix_deploy_unitree/hardware.py | 104 ++++ .../src/motrix_deploy_unitree/interface.py | 291 ++++++++++-- .../src/motrix_deploy_unitree/native.py | 32 ++ .../motrix_deploy_unitree/native_interface.py | 446 ++++++++++++++++++ .../src/motrix_deploy_unitree/plugin.py | 15 +- .../motrix_deploy_unitree/read_lowstate.py | 87 +++- .../src/motrix_deploy_unitree/remote.py | 24 +- .../tests/test_g1_29dof_backend.py | 319 +++++++++++++ .../tests/test_native_backend.py | 151 ++++++ .../tests/test_unitree_deploy_backend.py | 6 +- 14 files changed, 1634 insertions(+), 100 deletions(-) create mode 100644 motrix_deploy_unitree/src/motrix_deploy_unitree/native.py create mode 100644 motrix_deploy_unitree/src/motrix_deploy_unitree/native_interface.py create mode 100644 motrix_deploy_unitree/tests/test_g1_29dof_backend.py create mode 100644 motrix_deploy_unitree/tests/test_native_backend.py diff --git a/motrix_deploy_unitree/README.md b/motrix_deploy_unitree/README.md index 545b240e..26cdda8c 100644 --- a/motrix_deploy_unitree/README.md +++ b/motrix_deploy_unitree/README.md @@ -2,10 +2,16 @@ `motrix-deploy-unitree` provides the `unitree` SDK2 DDS hardware backend for `motrix-deploy`, asset-independent hardware sensor/motor configuration, and direct read/write and diagnostic tools. +G1 hardware recipes select the native C++ SDK2 transport (`transport: native_cpp`), while the +Python SDK transport remains available for compatibility diagnostics. The entry-point `create_runtime(config, context)` accepts a `UnitreeBackendConfig` with a nested -`UnitreeGo2RobotCfg` in `config.robot`, and returns a `HardwareRuntime`. Robot configurations inherit +`UnitreeGo2RobotCfg` or `UnitreeG1_29DOFRobotCfg` in `config.robot`, and returns a `HardwareRuntime`. Robot configurations inherit `HardwareRobotCfg` through `UnitreeRobotCfg`, exposing `key_pose`, `sensors`, and `actuation` directly -alongside robot-specific control settings. G1 hardware I/O is not implemented. The Unitree SDK is imported only when a hardware connection is opened. +alongside robot-specific control settings. G1 uses HG LowCmd/LowState, validates CRC plus +`mode_pr=0` and `mode_machine=5`, maps artifact joints to motors by name, and repeats the latest +policy command from a native C++ 1 kHz writer. Install the optional `native` extra to build the +`motrix-unitree-native` extension against Unitree SDK2; the extension is loaded only when a native +hardware connection is opened. ## Safety @@ -13,7 +19,8 @@ Use a suspended robot in low-level/debug mode with an operator-ready emergency s Opening a command interface may stand down the robot before the Start gate. Choose hardware-appropriate startup gains: Start transitions to the default pose, A enables control, Select triggers emergency stop, and B requests lie-down. Stop paths send damping commands. Even the single-joint helper publishes -commands for all 12 joints. The backend has fake-SDK test coverage; a real-robot smoke test remains pending. +commands for every configured joint. G1 unused HG slots remain disabled and zeroed. The backend has +fake-SDK test coverage; a suspended real-robot smoke test remains pending. ## Usage @@ -21,13 +28,28 @@ Check incoming state without creating a command publisher: ```bash motrix-deploy-unitree read-lowstate +motrix-deploy-unitree read-lowstate --robot g1-29dof ``` With `motrix-deploy-tasks` and a matching artifact installed: +Install the native transport extra before selecting a G1 hardware recipe: + +```bash +UNITREE_SDK2_ROOT=/opt/unitree_robotics uv sync --extra unitree +``` + +When installing the package outside this workspace, use the equivalent +`UNITREE_SDK2_ROOT=/opt/unitree_robotics python -m pip install +"motrix-deploy-unitree[native]"` command. The SDK2 root must contain `include/`, +`lib//`, and `thirdparty/lib//`. + ```bash mxlab deploy task=go2-walk-flat/hardware artifact=artifacts/go2-walk-flat.deploy \ runtime.network_interface= + +mxlab deploy task=g1-wbt-dance/hardware \ + runtime.network_interface= ``` Review configured startup gains and the diff --git a/motrix_deploy_unitree/src/motrix_deploy_unitree/__init__.py b/motrix_deploy_unitree/src/motrix_deploy_unitree/__init__.py index b0d96704..81fb9c2c 100644 --- a/motrix_deploy_unitree/src/motrix_deploy_unitree/__init__.py +++ b/motrix_deploy_unitree/src/motrix_deploy_unitree/__init__.py @@ -1,19 +1,26 @@ # Copyright Motphys Technology Co., Ltd. 2025, 2026 # SPDX-License-Identifier: Apache-2.0 -"""Unitree Go2 DDS hardware backend.""" +"""Unitree SDK2 DDS hardware backends.""" -__version__ = "0.3.0" +from importlib import metadata + +__version__ = metadata.version("motrix-deploy-unitree") from motrix_deploy_unitree.config import ( + G1_29DOF_JOINT_NAME_TO_MOTOR_ID, + G1_29DOF_MOTOR_COUNT, + G1_HG_MOTOR_SLOT_COUNT, GO2_JOINT_NAME_TO_MOTOR_INDEX, GO2_MOTOR_COUNT, UnitreeBackendConfig, + UnitreeG1_29DOFRobotCfg, UnitreeGo2RobotCfg, UnitreeRobotCfg, ) from motrix_deploy_unitree.direct import UnitreeGo2DirectInterface -from motrix_deploy_unitree.interface import UnitreeGo2Robot, UnitreeSdkBindings +from motrix_deploy_unitree.interface import UnitreeG1_29DOFRobot, UnitreeGo2Robot, UnitreeSdkBindings +from motrix_deploy_unitree.native_interface import UnitreeG1NativeRobot from motrix_deploy_unitree.remote import ( BUTTON_NAMES, UnitreeRemoteGamePadDevice, @@ -23,9 +30,15 @@ __all__ = [ "BUTTON_NAMES", + "G1_29DOF_JOINT_NAME_TO_MOTOR_ID", + "G1_29DOF_MOTOR_COUNT", + "G1_HG_MOTOR_SLOT_COUNT", "GO2_JOINT_NAME_TO_MOTOR_INDEX", "GO2_MOTOR_COUNT", "UnitreeBackendConfig", + "UnitreeG1_29DOFRobot", + "UnitreeG1NativeRobot", + "UnitreeG1_29DOFRobotCfg", "UnitreeGo2RobotCfg", "UnitreeRobotCfg", "UnitreeGo2DirectInterface", diff --git a/motrix_deploy_unitree/src/motrix_deploy_unitree/cli.py b/motrix_deploy_unitree/src/motrix_deploy_unitree/cli.py index 3f6aec9e..766b0733 100644 --- a/motrix_deploy_unitree/src/motrix_deploy_unitree/cli.py +++ b/motrix_deploy_unitree/src/motrix_deploy_unitree/cli.py @@ -1,7 +1,7 @@ # Copyright Motphys Technology Co., Ltd. 2025, 2026 # SPDX-License-Identifier: Apache-2.0 -"""Command-line diagnostics for the Unitree Go2 deployment backend.""" +"""Command-line diagnostics for Unitree deployment backends.""" import argparse import math @@ -48,14 +48,15 @@ def _positive_int(value: str) -> int: def _parser() -> argparse.ArgumentParser: - parser = argparse.ArgumentParser(description="Unitree Go2 hardware diagnostics") + parser = argparse.ArgumentParser(description="Unitree hardware diagnostics") commands = parser.add_subparsers(dest="command", required=True) lowstate = commands.add_parser( "read-lowstate", help="Read rt/lowstate without creating a LowCmd publisher", ) - lowstate.add_argument("network_interface", help="Ethernet interface connected to Go2, for example enp5s0") + lowstate.add_argument("network_interface", help="Ethernet interface connected to the robot, for example enp5s0") + lowstate.add_argument("--robot", choices=("go2", "g1-29dof"), default="go2") lowstate.add_argument("--domain-id", type=_non_negative_int, default=0, help="DDS domain id (default: 0)") lowstate.add_argument("--topic", default="rt/lowstate", help="LowState DDS topic (default: rt/lowstate)") lowstate.add_argument("--queue-depth", type=_positive_int, default=10, help="Subscriber queue depth (default: 10)") @@ -98,6 +99,7 @@ def main(argv: Sequence[str] | None = None) -> int: duration_s=args.duration_s, print_interval_s=args.print_interval_s, validate_crc=not args.no_validate_crc, + robot=args.robot, ) run_joint_control( diff --git a/motrix_deploy_unitree/src/motrix_deploy_unitree/config.py b/motrix_deploy_unitree/src/motrix_deploy_unitree/config.py index 4a5b9261..a08c9a62 100644 --- a/motrix_deploy_unitree/src/motrix_deploy_unitree/config.py +++ b/motrix_deploy_unitree/src/motrix_deploy_unitree/config.py @@ -14,17 +14,25 @@ from motrix_deploy.config import HardwareRuntimeCfg from motrix_deploy.errors import ValidationError +from motrix_deploy.operator import OperatorProfileCfg +from motrix_deploy.robot.g1_standing import G1_29DOF_STANDING_KD, G1_29DOF_STANDING_KP from motrix_deploy_unitree.actuation import Actuation -from motrix_deploy_unitree.hardware import HardwareRobotCfg, UnitreeGo2HardwareCfg -from motrix_deploy_unitree.remote import BUTTON_NAMES +from motrix_deploy_unitree.hardware import HardwareRobotCfg, UnitreeG1_29DOFHardwareCfg, UnitreeGo2HardwareCfg +from motrix_deploy_unitree.remote import ACCEPTED_BUTTON_NAMES, BUTTON_NAMES from motrix_deploy_unitree.sensor import HardwareSensorBindings from motrix_env_core.config.scene.base import KeyPoseCfg GO2_MOTOR_COUNT = 12 +G1_29DOF_MOTOR_COUNT = 29 +G1_HG_MOTOR_SLOT_COUNT = 35 _DEFAULT_GO2_ROBOT = UnitreeGo2HardwareCfg() +_DEFAULT_G1_29DOF_ROBOT = UnitreeG1_29DOFHardwareCfg() GO2_JOINT_NAME_TO_MOTOR_INDEX: Mapping[str, int] = MappingProxyType( {name: binding.index for name, binding in _DEFAULT_GO2_ROBOT.actuation.motors.items()} ) +G1_29DOF_JOINT_NAME_TO_MOTOR_ID: Mapping[str, int] = MappingProxyType( + {name: binding.index for name, binding in _DEFAULT_G1_29DOF_ROBOT.actuation.motors.items()} +) @dataclass @@ -41,19 +49,17 @@ class UnitreeRobotCfg(HardwareRobotCfg): @dataclass -class UnitreeGo2RobotCfg(UnitreeRobotCfg): - """Go2-specific hardware wiring, gains, and safety settings.""" - - key_pose: KeyPoseCfg = field(default_factory=lambda: UnitreeGo2HardwareCfg().key_pose) - sensors: HardwareSensorBindings = field(default_factory=lambda: UnitreeGo2HardwareCfg().sensors) - actuation: Actuation = field(default_factory=lambda: UnitreeGo2HardwareCfg().actuation) +class _UnitreeServoRobotCfg(UnitreeRobotCfg): + """Shared named-joint servo and safety configuration.""" + motor_slot_count: int = OC_MISSING joint_name_to_motor_index: dict[str, int] | None = None default_transition_duration_s: float = 2.0 damping_duration_s: float = 1.0 damping_kd: float = 8.0 kp: Any = None kd: Any = None + override_policy_gains: bool = True wait_for_remote_buttons: bool = True start_button: str = "start" enable_button: str = "A" @@ -62,8 +68,16 @@ class UnitreeGo2RobotCfg(UnitreeRobotCfg): lie_down_duration_s: float = 2.0 lie_down_joint_position: Any = None motor_mode: int | None = None + mode_pr: int | None = None + expected_mode_machine: int | None = None + command_publish_period_s: float | None = None + command_timeout_s: float = 0.1 + allow_lie_down: bool = True + startup_mode: str = "one_shot" def __post_init__(self) -> None: + if self.startup_mode not in {"one_shot", "state_machine"}: + raise ValidationError("runtime.robot.startup_mode", "one_shot or state_machine", self.startup_mode) if not isinstance(self.wait_for_remote_buttons, bool): raise ValidationError("runtime.robot.wait_for_remote_buttons", "a boolean", self.wait_for_remote_buttons) for name in ( @@ -75,6 +89,16 @@ def __post_init__(self) -> None: value = getattr(self, name) if not isinstance(value, (int, float)) or isinstance(value, bool) or not np.isfinite(value): raise ValidationError(f"runtime.robot.{name}", "a finite number", value) + if ( + not isinstance(self.motor_slot_count, int) + or isinstance(self.motor_slot_count, bool) + or self.motor_slot_count <= 0 + ): + raise ValidationError("runtime.robot.motor_slot_count", "a positive integer", self.motor_slot_count) + if not isinstance(self.allow_lie_down, bool): + raise ValidationError("runtime.robot.allow_lie_down", "a boolean", self.allow_lie_down) + if not isinstance(self.override_policy_gains, bool): + raise ValidationError("runtime.robot.override_policy_gains", "a boolean", self.override_policy_gains) if self.default_transition_duration_s <= 0: raise ValidationError( "runtime.robot.default_transition_duration_s", "a positive duration", self.default_transition_duration_s @@ -93,6 +117,30 @@ def __post_init__(self) -> None: or not 0 <= self.motor_mode <= 0xFF ): raise ValidationError("runtime.robot.motor_mode", "an integer in [0, 255]", self.motor_mode) + for name in ("mode_pr", "expected_mode_machine"): + value = getattr(self, name) + if value is not None and (not isinstance(value, int) or isinstance(value, bool) or not 0 <= value <= 0xFF): + raise ValidationError(f"runtime.robot.{name}", "an integer in [0, 255]", value) + if self.command_publish_period_s is not None and ( + not isinstance(self.command_publish_period_s, (int, float)) + or isinstance(self.command_publish_period_s, bool) + or not np.isfinite(self.command_publish_period_s) + or self.command_publish_period_s <= 0 + ): + raise ValidationError( + "runtime.robot.command_publish_period_s", + "a positive finite duration or null", + self.command_publish_period_s, + ) + if ( + not isinstance(self.command_timeout_s, (int, float)) + or isinstance(self.command_timeout_s, bool) + or not np.isfinite(self.command_timeout_s) + or self.command_timeout_s <= 0 + ): + raise ValidationError( + "runtime.robot.command_timeout_s", "a positive finite duration", self.command_timeout_s + ) for name in ("start_button", "enable_button", "emergency_stop_button", "lie_down_button"): value = getattr(self, name) if value not in BUTTON_NAMES: @@ -107,20 +155,37 @@ def __post_init__(self) -> None: type(self.joint_name_to_motor_index).__name__, ) - @staticmethod - def _validate_gain_override(name: str, value: object | None) -> None: + def _validate_gain_override(self, name: str, value: object | None) -> None: if value is None: return + if isinstance(value, Mapping): + expected = set(self.actuation.motors) + actual = set(value) + if actual != expected: + raise ValidationError( + f"runtime.robot.{name}", + f"exactly joint names {sorted(expected)}", + f"missing={sorted(expected - actual)}, unknown={sorted(actual - expected)}", + ) + if any( + not isinstance(item, (int, float)) or isinstance(item, bool) or not np.isfinite(item) or item < 0 + for item in value.values() + ): + raise ValidationError(f"runtime.robot.{name}", "finite non-negative named gains", value) + return if isinstance(value, bool): - raise ValidationError(f"runtime.robot.{name}", "a non-negative scalar or 12 values", value) + raise ValidationError(f"runtime.robot.{name}", "a non-negative scalar or joint vector", value) try: array = np.asarray(value, dtype=np.float32) except (TypeError, ValueError) as error: - raise ValidationError(f"runtime.robot.{name}", "a non-negative scalar or 12 values", value) from error - if array.shape not in ((), (GO2_MOTOR_COUNT,)) or not np.all(np.isfinite(array)) or np.any(array < 0): + raise ValidationError(f"runtime.robot.{name}", "a non-negative scalar or joint vector", value) from error + joint_count = len(self.actuation.motors) + if array.shape not in ((), (joint_count,)): raise ValidationError( - f"runtime.robot.{name}", "a non-negative scalar or 12 finite non-negative values", value + f"runtime.robot.{name}", f"a non-negative scalar or {joint_count} joint values", value ) + if not np.all(np.isfinite(array)) or np.any(array < 0): + raise ValidationError(f"runtime.robot.{name}", "finite non-negative gains", value) def lie_down_position(self) -> np.ndarray: """Return the named shutdown pose or an explicit canonical override.""" @@ -130,13 +195,13 @@ def lie_down_position(self) -> np.ndarray: except (TypeError, ValueError) as error: raise ValidationError( "runtime.robot.lie_down_joint_position", - "12 finite canonical joint positions", + f"{len(self.actuation.motors)} finite canonical joint positions", self.lie_down_joint_position, ) from error - if position.shape != (GO2_MOTOR_COUNT,) or not np.all(np.isfinite(position)): + if position.shape != (len(self.actuation.motors),) or not np.all(np.isfinite(position)): raise ValidationError( "runtime.robot.lie_down_joint_position", - "12 finite canonical joint positions", + f"{len(self.actuation.motors)} finite canonical joint positions", self.lie_down_joint_position, ) return position.copy() @@ -146,15 +211,25 @@ def lie_down_position(self) -> np.ndarray: raise ValidationError("runtime.robot.key_pose", "a named lie_down pose", "missing") from error return np.asarray(pose, dtype=np.float32).copy() - def gain_override(self, name: str, joint_count: int) -> np.ndarray | None: + def gain_override(self, name: str, joint_names: tuple[str, ...]) -> np.ndarray | None: value = getattr(self, name) if value is None: return None + if isinstance(value, Mapping): + expected = set(joint_names) + actual = set(value) + if actual != expected: + raise ValidationError( + f"runtime.robot.{name}", + f"exactly artifact joints {sorted(expected)}", + f"missing={sorted(expected - actual)}, unknown={sorted(actual - expected)}", + ) + return np.asarray([value[joint] for joint in joint_names], dtype=np.float32) array = np.asarray(value, dtype=np.float32) if array.shape == (): - return np.full(joint_count, array.item(), dtype=np.float32) - if array.shape != (joint_count,): - raise ValidationError(f"runtime.robot.{name}", f"{joint_count} canonical joint gains", value) + return np.full(len(joint_names), array.item(), dtype=np.float32) + if array.shape != (len(joint_names),): + raise ValidationError(f"runtime.robot.{name}", f"{len(joint_names)} canonical joint gains", value) return np.array(array, dtype=np.float32, copy=True) def motor_indices(self, joint_names: tuple[str, ...]) -> np.ndarray: @@ -172,16 +247,54 @@ def motor_indices(self, joint_names: tuple[str, ...]) -> np.ndarray: values = tuple(mapping[name] for name in joint_names) if any(not isinstance(index, int) or isinstance(index, bool) for index in values): raise ValidationError("runtime.robot.motor_indices", "integer motor indices", values) - if len(set(values)) != len(values) or any(not 0 <= index < GO2_MOTOR_COUNT for index in values): - raise ValidationError("runtime.robot.motor_indices", f"unique values in [0, {GO2_MOTOR_COUNT - 1}]", values) + if len(set(values)) != len(values) or any(not 0 <= index < self.motor_slot_count for index in values): + raise ValidationError( + "runtime.robot.motor_indices", f"unique values in [0, {self.motor_slot_count - 1}]", values + ) return np.asarray(values, dtype=np.int64) +@dataclass +class UnitreeGo2RobotCfg(_UnitreeServoRobotCfg): + """Go2-specific hardware wiring, gains, and safety settings.""" + + key_pose: KeyPoseCfg = field(default_factory=lambda: UnitreeGo2HardwareCfg().key_pose) + sensors: HardwareSensorBindings = field(default_factory=lambda: UnitreeGo2HardwareCfg().sensors) + actuation: Actuation = field(default_factory=lambda: UnitreeGo2HardwareCfg().actuation) + motor_slot_count: int = GO2_MOTOR_COUNT + + +@dataclass +class UnitreeG1_29DOFRobotCfg(_UnitreeServoRobotCfg): + """G1 29-DOF HG wiring, mode contract, and high-rate publisher settings.""" + + key_pose: KeyPoseCfg = field(default_factory=lambda: UnitreeG1_29DOFHardwareCfg().key_pose) + sensors: HardwareSensorBindings = field(default_factory=lambda: UnitreeG1_29DOFHardwareCfg().sensors) + actuation: Actuation = field(default_factory=lambda: UnitreeG1_29DOFHardwareCfg().actuation) + motor_slot_count: int = G1_HG_MOTOR_SLOT_COUNT + # Fixed FixStand gains, shared with the program and task deployment paths. + kp: Any = field(default_factory=lambda: dict(G1_29DOF_STANDING_KP)) + kd: Any = field(default_factory=lambda: dict(G1_29DOF_STANDING_KD)) + mode_pr: int | None = 0 + expected_mode_machine: int | None = 5 + command_publish_period_s: float | None = 0.001 + command_timeout_s: float = 0.1 + default_transition_duration_s: float = 3.0 + damping_kd: float = 3.0 + motor_mode: int | None = 1 + allow_lie_down: bool = False + override_policy_gains: bool = False + + @dataclass class UnitreeBackendConfig(HardwareRuntimeCfg): """Shared Unitree DDS transport configuration and selected robot recipe.""" backend: str = "unitree" + # Keep the Python SDK as the explicit compatibility default for existing + # injected-transport tests and diagnostics. Hardware recipes that use the + # native real-time path set ``transport: native_cpp``. + transport: str = "python_sdk" network_interface: str = OC_MISSING domain_id: int = 0 lowcmd_topic: str = "rt/lowcmd" @@ -189,9 +302,12 @@ class UnitreeBackendConfig(HardwareRuntimeCfg): connect_timeout_s: float = 5.0 validate_crc: bool = True subscriber_queue_depth: int = 10 + operator: OperatorProfileCfg | None = None robot: UnitreeRobotCfg = OC_MISSING def __post_init__(self) -> None: + if self.transport not in {"python_sdk", "native_cpp"}: + raise ValidationError("runtime.transport", "python_sdk or native_cpp", self.transport) if not isinstance(self.network_interface, str) or not self.network_interface: raise ValidationError("runtime.network_interface", "a non-empty interface name", self.network_interface) if not isinstance(self.validate_crc, bool): @@ -217,6 +333,43 @@ def __post_init__(self) -> None: raise ValidationError("runtime.subscriber_queue_depth", "a positive integer", self.subscriber_queue_depth) if not isinstance(self.robot, UnitreeRobotCfg): raise ValidationError("runtime.robot", "a UnitreeRobotCfg config", type(self.robot).__name__) + if self.operator is not None: + if not isinstance(self.operator, OperatorProfileCfg): + raise ValidationError("runtime.operator", "an OperatorProfileCfg", type(self.operator).__name__) + self._validate_operator_profile() + + def _validate_operator_profile(self) -> None: + assert self.operator is not None + for intent, gesture in self.operator.intents.items(): + buttons = [*gesture.held, *gesture.held_for_s] + buttons.extend(name for name in (gesture.pressed, gesture.released) if name is not None) + unknown = sorted(set(buttons) - set(ACCEPTED_BUTTON_NAMES)) + if unknown: + raise ValidationError( + f"runtime.operator.intents.{intent}", + f"buttons in {sorted(ACCEPTED_BUTTON_NAMES)}", + unknown, + ) + velocity = self.operator.planar_velocity + if velocity is not None: + axes = {velocity.linear_x_axis, velocity.linear_y_axis, velocity.yaw_axis} + if not axes <= {"lx", "ly", "rx", "ry"}: + raise ValidationError("runtime.operator.planar_velocity.axes", "Unitree joystick axes", sorted(axes)) + if velocity.deadman_button is not None and velocity.deadman_button not in ACCEPTED_BUTTON_NAMES: + raise ValidationError( + "runtime.operator.planar_velocity.deadman_button", + f"one of {sorted(ACCEPTED_BUTTON_NAMES)}", + velocity.deadman_button, + ) + if isinstance(self.robot, UnitreeG1_29DOFRobotCfg): + required = ( + {"request_stand", "enable_policy", "enter_passive", "emergency_stop"} + if self.robot.startup_mode == "one_shot" + else {"request_fixstand", "request_walk", "request_wbt", "request_passive", "request_emergency"} + ) + missing = sorted(required - set(self.operator.intents)) + if missing: + raise ValidationError("runtime.operator.intents", f"G1 safety intents {sorted(required)}", missing) def install_hardware_runtime_schema() -> None: @@ -224,12 +377,17 @@ def install_hardware_runtime_schema() -> None: store = ConfigStore.instance() store.store(group="runtime", name="_unitree_schema", node=UnitreeBackendConfig) store.store(group="unitree_robot", name="go2", node=UnitreeGo2RobotCfg) + store.store(group="unitree_robot", name="g1-29dof", node=UnitreeG1_29DOFRobotCfg) __all__ = [ "GO2_JOINT_NAME_TO_MOTOR_INDEX", "GO2_MOTOR_COUNT", + "G1_29DOF_MOTOR_COUNT", + "G1_29DOF_JOINT_NAME_TO_MOTOR_ID", + "G1_HG_MOTOR_SLOT_COUNT", "UnitreeBackendConfig", + "UnitreeG1_29DOFRobotCfg", "UnitreeGo2RobotCfg", "UnitreeRobotCfg", "install_hardware_runtime_schema", diff --git a/motrix_deploy_unitree/src/motrix_deploy_unitree/hardware.py b/motrix_deploy_unitree/src/motrix_deploy_unitree/hardware.py index f93d1c83..ab412d93 100644 --- a/motrix_deploy_unitree/src/motrix_deploy_unitree/hardware.py +++ b/motrix_deploy_unitree/src/motrix_deploy_unitree/hardware.py @@ -86,3 +86,107 @@ class UnitreeGo2HardwareCfg(HardwareRobotCfg): "RR_calf_joint": UnitreeMotorBinding(index=8), } ) + + +G1_29DOF_JOINT_NAMES = ( + "left_hip_pitch_joint", + "left_hip_roll_joint", + "left_hip_yaw_joint", + "left_knee_joint", + "left_ankle_pitch_joint", + "left_ankle_roll_joint", + "right_hip_pitch_joint", + "right_hip_roll_joint", + "right_hip_yaw_joint", + "right_knee_joint", + "right_ankle_pitch_joint", + "right_ankle_roll_joint", + "waist_yaw_joint", + "waist_roll_joint", + "waist_pitch_joint", + "left_shoulder_pitch_joint", + "left_shoulder_roll_joint", + "left_shoulder_yaw_joint", + "left_elbow_joint", + "left_wrist_roll_joint", + "left_wrist_pitch_joint", + "left_wrist_yaw_joint", + "right_shoulder_pitch_joint", + "right_shoulder_roll_joint", + "right_shoulder_yaw_joint", + "right_elbow_joint", + "right_wrist_roll_joint", + "right_wrist_pitch_joint", + "right_wrist_yaw_joint", +) + +_G1_29DOF_DEFAULT_POSITION = ( + -0.312, + 0.0, + 0.0, + 0.669, + -0.363, + 0.0, + -0.312, + 0.0, + 0.0, + 0.669, + -0.363, + 0.0, + 0.0, + 0.0, + 0.0, + 0.2, + 0.2, + 0.0, + 0.6, + 0.0, + 0.0, + 0.0, + 0.2, + -0.2, + 0.0, + 0.6, + 0.0, + 0.0, + 0.0, +) + + +@configclass(kw_only=True) +class UnitreeG1_29DOFHardwareCfg(HardwareRobotCfg): + """G1 29-DOF wiring for the HG DDS protocol. + + Joint names are the stable semantic contract. Motor ids deliberately live + here rather than in a policy-order permutation so exported artifacts may + use any joint ordering without changing the physical wiring. + """ + + key_pose: KeyPoseCfg = KeyPoseCfg( + joint_names=list(G1_29DOF_JOINT_NAMES), + poses={ + "default": list(_G1_29DOF_DEFAULT_POSITION), + # G1 shutdown is damping-only. This pose only satisfies the shared + # pose schema and is never selected by the G1 adapter. + "lie_down": list(_G1_29DOF_DEFAULT_POSITION), + }, + ) + sensors: HardwareSensorBindings = HardwareSensorBindings( + base_orientation_xyzw=HardwareSensorBinding(field="imu_state.quaternion", quaternion_order="wxyz"), + base_angular_velocity=HardwareSensorBinding(field="imu_state.gyroscope"), + base_linear_acceleration=HardwareSensorBinding(field="imu_state.accelerometer"), + ) + actuation: Actuation = Actuation( + motors={ + name: UnitreeMotorBinding(index=motor_id, enabled_mode=1) + for motor_id, name in enumerate(G1_29DOF_JOINT_NAMES) + } + ) + + +__all__ = [ + "G1_29DOF_JOINT_NAMES", + "HardwareRobotCfg", + "UnitreeG1_29DOFHardwareCfg", + "UnitreeGo2HardwareCfg", +] diff --git a/motrix_deploy_unitree/src/motrix_deploy_unitree/interface.py b/motrix_deploy_unitree/src/motrix_deploy_unitree/interface.py index 48388ed8..290d1b94 100644 --- a/motrix_deploy_unitree/src/motrix_deploy_unitree/interface.py +++ b/motrix_deploy_unitree/src/motrix_deploy_unitree/interface.py @@ -24,9 +24,19 @@ RobotSpec, RobotState, ) -from motrix_deploy.errors import EmergencyStopError, LieDownRequestedError, ValidationError +from motrix_deploy.errors import ( + EmergencyStopError, + LieDownRequestedError, + PassiveRequestedError, + ValidationError, +) +from motrix_deploy.operator import OperatorIntentEvaluator from motrix_deploy.robot.interface import RobotInterface -from motrix_deploy_unitree.config import GO2_MOTOR_COUNT, UnitreeBackendConfig, UnitreeGo2RobotCfg +from motrix_deploy_unitree.config import ( + UnitreeBackendConfig, + UnitreeG1_29DOFRobotCfg, + UnitreeGo2RobotCfg, +) from motrix_deploy_unitree.remote import UnitreeRemoteGamePadDevice, UnitreeRemoteState, decode_wireless_remote from motrix_env_core.input import GamePadDevice @@ -86,9 +96,37 @@ def _load_sdk_bindings() -> UnitreeSdkBindings: ) +def _load_g1_29dof_sdk_bindings() -> UnitreeSdkBindings: + """Load the HG messages used by a physical G1 29-DOF robot.""" + try: + from unitree_sdk2py.core.channel import ChannelFactoryInitialize, ChannelPublisher, ChannelSubscriber + from unitree_sdk2py.idl.default import unitree_hg_msg_dds__LowCmd_ + from unitree_sdk2py.idl.unitree_hg.msg.dds_ import LowCmd_ as LowCmdHg + from unitree_sdk2py.idl.unitree_hg.msg.dds_ import LowState_ as LowStateHg + from unitree_sdk2py.utils.crc import CRC + except ImportError as error: + raise RuntimeError( + "Unitree G1 29-DOF support requires the Motphys unitree_sdk2py package; " + "install https://github.com/motphys-developers/unitree_sdk2_python" + ) from error + return UnitreeSdkBindings( + channel_factory_initialize=ChannelFactoryInitialize, + channel_publisher=ChannelPublisher, + channel_subscriber=ChannelSubscriber, + low_cmd_message_type=LowCmdHg, + low_state_message_type=LowStateHg, + make_low_cmd=unitree_hg_msg_dds__LowCmd_, + crc_type=CRC, + ) + + class UnitreeGo2Robot(RobotInterface): """Map canonical Go2 state/commands to SDK2 LowState/LowCmd DDS messages.""" + robot_config_type = UnitreeGo2RobotCfg + disabled_position = _POSITION_STOP + disabled_velocity = _VELOCITY_STOP + def __init__( self, config: UnitreeBackendConfig, @@ -100,8 +138,8 @@ def __init__( clock_ns: Callable[[], int] = time.monotonic_ns, sleep: Callable[[float], None] = time.sleep, ) -> None: - if not isinstance(config.robot, UnitreeGo2RobotCfg): - raise TypeError("UnitreeGo2Robot requires UnitreeGo2RobotCfg") + if not isinstance(config.robot, self.robot_config_type): + raise TypeError(f"{type(self).__name__} requires {self.robot_config_type.__name__}") self.config = config for path, value in ( ("control.period_s", control_period_s), @@ -117,6 +155,9 @@ def __init__( self._sleep = sleep self._condition = threading.Condition() self._write_lock = threading.Lock() + self._writer_stop = threading.Event() + self._writer_thread: threading.Thread | None = None + self._latest_command_update_ns = 0 self._publisher: Any = None self._subscriber: Any = None self._low_cmd: Any = None @@ -136,8 +177,11 @@ def __init__( self._last_read_sequence = 0 self._remote = UnitreeRemoteState() self._gamepad = UnitreeRemoteGamePadDevice(lambda: self.remote) + self._intent_evaluator = None if config.operator is None else OperatorIntentEvaluator(config.operator.intents) + self._latched_intents: set[str] = set() self._callback_error: Exception | None = None self._emergency_stop = False + self._passive_requested = False self._lie_down_requested = False self._last_position_kp = np.empty(0, dtype=np.float32) self._last_position_kd = np.empty(0, dtype=np.float32) @@ -148,6 +192,9 @@ def __init__( self._stopped = False self._closed = False + def _load_sdk_bindings(self) -> UnitreeSdkBindings: + return _load_sdk_bindings() + @property def spec(self) -> RobotSpec: return self._spec @@ -204,9 +251,9 @@ def open(self) -> None: if self._opened and not self._closed: raise RuntimeError("Unitree backend is already open") self._resolve_hardware_bindings(self._spec) - self._kp_override = self.config.robot.gain_override("kp", self._spec.joint_count) - self._kd_override = self.config.robot.gain_override("kd", self._spec.joint_count) - sdk = self._sdk or _load_sdk_bindings() + self._kp_override = self.config.robot.gain_override("kp", self._spec.joint_names) + self._kd_override = self.config.robot.gain_override("kd", self._spec.joint_names) + sdk = self._sdk or self._load_sdk_bindings() self._sdk = sdk try: sdk.channel_factory_initialize(self.config.domain_id, self.config.network_interface) @@ -226,24 +273,27 @@ def open(self) -> None: self._low_cmd = sdk.make_low_cmd() self._initialize_low_cmd() - self._publisher = sdk.channel_publisher(self.config.lowcmd_topic, sdk.low_cmd_message_type) - self._publisher.Init() self._subscriber = sdk.channel_subscriber(self.config.lowstate_topic, sdk.low_state_message_type) self._subscriber.Init(self._low_state_handler, self.config.subscriber_queue_depth) self._wait_for_first_state() assert self._latest_low_state is not None - if len(self._latest_low_state.motor_state) < GO2_MOTOR_COUNT: + motor_slot_count = self.config.robot.motor_slot_count + if len(self._latest_low_state.motor_state) < motor_slot_count: raise ValidationError( "backend.lowstate.motor_state", - f"at least {GO2_MOTOR_COUNT} motors", + f"at least {motor_slot_count} motors", len(self._latest_low_state.motor_state), ) - if len(self._low_cmd.motor_cmd) < GO2_MOTOR_COUNT: + if len(self._low_cmd.motor_cmd) < motor_slot_count: raise ValidationError( "backend.lowcmd.motor_cmd", - f"at least {GO2_MOTOR_COUNT} motors", + f"at least {motor_slot_count} motors", len(self._low_cmd.motor_cmd), ) + # A LowCmd publisher is created only after a CRC-valid LowState has + # passed the robot-specific mode and motor-slot contract. + self._publisher = sdk.channel_publisher(self.config.lowcmd_topic, sdk.low_cmd_message_type) + self._publisher.Init() self._capabilities = RobotCapabilities( control_modes=(JointControlMode.SERVO, JointControlMode.TORQUE), state_fields=frozenset( @@ -266,6 +316,10 @@ def open(self) -> None: self._closed = False self._health_reason = "" self._last_communication_ns = self._latest_receive_time_ns + if self.config.robot.command_publish_period_s is not None: + # Queue the robot-specific passive frame before the periodic writer starts. + self._publish_pre_enable_command() + self._start_command_writer() def _resolve_hardware_bindings(self, spec: RobotSpec) -> None: robot = self.config.robot @@ -299,6 +353,11 @@ def enable(self) -> None: self._require_open() if self._enabled: return + if self.config.robot.startup_mode == "state_machine": + # The periodic writer already owns a robot-specific passive frame. + # The persistent controller performs every posture/policy transition. + self._enabled = True + return if self._kp_override is None or self._kd_override is None: raise ValidationError( "backend.enable", @@ -318,7 +377,10 @@ def enable(self) -> None: self._last_position_kp = np.array(kp, dtype=np.float32, copy=True) self._last_position_kd = np.array(kd, dtype=np.float32, copy=True) if self.config.robot.wait_for_remote_buttons: - self._wait_for_button(self.config.robot.start_button, self._publish_zero_torque) + if self._intent_evaluator is None: + self._wait_for_button(self.config.robot.start_button, self._publish_pre_enable_command) + else: + self._wait_for_intent("request_stand", self._publish_pre_enable_command) start = self._latest_robot_state().joint_position steps = max(1, math.ceil(self.config.robot.default_transition_duration_s / self._control_period_s)) for step in range(1, steps + 1): @@ -335,10 +397,14 @@ def enable(self) -> None: self._wait_control_period() if self.config.robot.wait_for_remote_buttons: - self._wait_for_button( - self.config.robot.enable_button, - lambda: self._publish_robot_command(initial_command), - ) + + def publish_stand() -> None: + self._publish_robot_command(initial_command) + + if self._intent_evaluator is None: + self._wait_for_button(self.config.robot.enable_button, publish_stand) + else: + self._wait_for_intent("enable_policy", publish_stand) self._raise_if_remote_stop_requested() self._enabled = True @@ -372,10 +438,13 @@ def write_command(self, command: RobotCommand) -> None: def health(self) -> HealthStatus: with self._condition: emergency = self._emergency_stop + passive = self._passive_requested lie_down = self._lie_down_requested reason = self._health_reason if emergency: reason = f"remote {self.config.robot.emergency_stop_button!r} emergency stop is active" + elif passive: + reason = "operator requested passive damping" elif lie_down and not reason: reason = f"remote {self.config.robot.lie_down_button!r} lie-down shutdown is active" elif self._closed: @@ -395,7 +464,7 @@ def stop(self) -> None: return self._enabled = False with self._condition: - run_lie_down = self._lie_down_requested and not self._emergency_stop + run_lie_down = self.config.robot.allow_lie_down and self._lie_down_requested and not self._emergency_stop if run_lie_down: try: self._publish_lie_down_trajectory() @@ -421,6 +490,10 @@ def close(self) -> None: self.stop() except Exception as error: errors.append(error) + try: + self._stop_command_writer() + except Exception as error: + errors.append(error) for channel in (self._subscriber, self._publisher): if channel is None: continue @@ -452,9 +525,20 @@ def _low_state_handler(self, message: Any) -> None: self._latest_receive_time_ns = receive_time_ns self._state_sequence += 1 self._remote = remote - if remote.pressed(self.config.robot.emergency_stop_button): + if self._intent_evaluator is not None: + intents = self._intent_evaluator.update(remote.pressed_buttons(), receive_time_ns) + self._latched_intents.update(intents) + if "emergency_stop" in intents or "request_emergency" in intents: + self._emergency_stop = True + if "enter_passive" in intents and self.config.robot.startup_mode == "one_shot": + self._passive_requested = True + # Keep select/back as an unconditional, non-configurable fallback + # emergency stop in addition to the configured semantic gesture. + if remote.pressed("select") or ( + self._intent_evaluator is None and remote.pressed(self.config.robot.emergency_stop_button) + ): self._emergency_stop = True - if remote.pressed(self.config.robot.lie_down_button): + if self.config.robot.allow_lie_down and remote.pressed(self.config.robot.lie_down_button): self._lie_down_requested = True self._condition.notify_all() @@ -478,6 +562,16 @@ def _wait_for_button(self, button: str, publish: Callable[[], None]) -> None: publish() self._wait_control_period() + def _wait_for_intent(self, intent: str, publish: Callable[[], None]) -> None: + while True: + with self._condition: + if intent in self._latched_intents: + self._latched_intents.remove(intent) + return + self._raise_if_remote_stop_requested() + publish() + self._wait_control_period() + def _wait_control_period(self) -> None: self._sleep(self._control_period_s) with self._condition: @@ -517,12 +611,23 @@ def _state_from_message(self, message: Any, receive_time_ns: int) -> RobotState: ) def _validate_message_fields(self, message: Any) -> None: - if len(message.motor_state) < GO2_MOTOR_COUNT: + motor_slot_count = self.config.robot.motor_slot_count + if len(message.motor_state) < motor_slot_count: raise ValidationError( "state.motor_state", - f"at least {GO2_MOTOR_COUNT} motor states", + f"at least {motor_slot_count} motor states", len(message.motor_state), ) + expected_mode_pr = self.config.robot.mode_pr + if expected_mode_pr is not None: + actual_mode_pr = getattr(message, "mode_pr", None) + if actual_mode_pr != expected_mode_pr: + raise ValidationError("state.mode_pr", expected_mode_pr, actual_mode_pr) + expected_mode_machine = self.config.robot.expected_mode_machine + if expected_mode_machine is not None: + actual_mode_machine = getattr(message, "mode_machine", None) + if actual_mode_machine != expected_mode_machine: + raise ValidationError("state.mode_machine", expected_mode_machine, actual_mode_machine) for role, expected in ( ("base_orientation_xyzw", 4), ("base_angular_velocity", 3), @@ -565,14 +670,19 @@ def _validate_command(self, command: RobotCommand) -> None: ) def _initialize_low_cmd(self) -> None: - self._low_cmd.head[0] = 0xFE - self._low_cmd.head[1] = 0xEF - self._low_cmd.level_flag = 0xFF - self._low_cmd.gpio = 0 + if hasattr(self._low_cmd, "head"): + self._low_cmd.head[0] = 0xFE + self._low_cmd.head[1] = 0xEF + self._low_cmd.level_flag = 0xFF + self._low_cmd.gpio = 0 + if self.config.robot.mode_pr is not None: + self._low_cmd.mode_pr = self.config.robot.mode_pr + if self.config.robot.expected_mode_machine is not None: + self._low_cmd.mode_machine = self.config.robot.expected_mode_machine for motor in self._low_cmd.motor_cmd: motor.mode = 0 - motor.q = _POSITION_STOP - motor.qd = _VELOCITY_STOP + motor.q = self.disabled_position + motor.dq = self.disabled_velocity motor.kp = 0.0 motor.kd = 0.0 motor.tau = 0.0 @@ -587,7 +697,7 @@ def _publish_robot_command(self, command: RobotCommand) -> None: motor = self._low_cmd.motor_cmd[int(motor_index)] motor.mode = self._motor_modes[canonical_index] motor.q = 0.0 - motor.qd = 0.0 + motor.dq = 0.0 motor.kp = 0.0 motor.kd = 0.0 motor.tau = float(command.torque[canonical_index]) @@ -603,6 +713,8 @@ def _publish_robot_command(self, command: RobotCommand) -> None: ) def _effective_gains(self, command: JointServoCommand) -> tuple[np.ndarray, np.ndarray]: + if self._enabled and not self.config.robot.override_policy_gains: + return command.kp, command.kd kp = command.kp if self._kp_override is None else self._kp_override kd = command.kd if self._kd_override is None else self._kd_override return kp, kd @@ -622,7 +734,7 @@ def _publish_joint_fields( motor = self._low_cmd.motor_cmd[int(motor_index)] motor.mode = self._motor_modes[canonical_index] motor.q = float(position[canonical_index]) - motor.qd = float(velocity[canonical_index]) + motor.dq = float(velocity[canonical_index]) motor.kp = float(kp[canonical_index]) motor.kd = float(kd[canonical_index]) motor.tau = float(torque[canonical_index]) @@ -634,18 +746,22 @@ def _publish_zero_torque(self) -> None: motor = self._low_cmd.motor_cmd[int(motor_index)] motor.mode = self._motor_modes[canonical_index] motor.q = 0.0 - motor.qd = 0.0 + motor.dq = 0.0 motor.kp = 0.0 motor.kd = 0.0 motor.tau = 0.0 self._write_low_cmd_locked() + def _publish_pre_enable_command(self) -> None: + self._publish_zero_torque() + def _publish_lie_down_trajectory(self) -> None: - if self._last_position_kp.shape != (GO2_MOTOR_COUNT,) or self._last_position_kd.shape != (GO2_MOTOR_COUNT,): + joint_count = self._spec.joint_count + if self._last_position_kp.shape != (joint_count,) or self._last_position_kd.shape != (joint_count,): raise RuntimeError("position gains are unavailable for lie-down shutdown") start = self._latest_robot_state().joint_position target = self._lie_down_position - zeros = np.zeros(GO2_MOTOR_COUNT, dtype=np.float32) + zeros = np.zeros(joint_count, dtype=np.float32) steps = max(1, math.ceil(self.config.robot.lie_down_duration_s / self._control_period_s)) for step in range(1, steps + 1): with self._condition: @@ -668,21 +784,87 @@ def _publish_lie_down_trajectory(self) -> None: def _publish_damping(self) -> None: with self._write_lock: - for canonical_index, motor_index in enumerate(self._motor_indices): - motor = self._low_cmd.motor_cmd[int(motor_index)] - motor.mode = self._motor_modes[canonical_index] - motor.q = 0.0 - motor.qd = 0.0 - motor.kp = 0.0 - motor.kd = self.config.robot.damping_kd - motor.tau = 0.0 + self._set_damping_fields_locked() self._write_low_cmd_locked() + def _set_damping_fields_locked(self) -> None: + state = self._latest_low_state + for canonical_index, motor_index in enumerate(self._motor_indices): + motor = self._low_cmd.motor_cmd[int(motor_index)] + motor.mode = self._motor_modes[canonical_index] + motor.q = 0.0 if state is None else float(state.motor_state[int(motor_index)].q) + motor.dq = 0.0 + motor.kp = 0.0 + motor.kd = self.config.robot.damping_kd + motor.tau = 0.0 + def _write_low_cmd_locked(self) -> None: + self._latest_command_update_ns = self._clock_ns() + if self.config.robot.command_publish_period_s is not None: + return + self._publish_low_cmd_locked() + + def _publish_low_cmd_locked(self) -> None: self._low_cmd.crc = self._command_crc.Crc(self._low_cmd) self._publisher.Write(self._low_cmd) self._last_communication_ns = self._clock_ns() + def _start_command_writer(self) -> None: + if self._writer_thread is not None: + raise RuntimeError("Unitree command writer is already running") + self._writer_stop.clear() + self._writer_thread = threading.Thread( + target=self._command_writer_loop, + name=f"{type(self).__name__}-lowcmd", + daemon=True, + ) + self._writer_thread.start() + + def _stop_command_writer(self) -> None: + thread = self._writer_thread + if thread is None: + return + if self._publisher is not None and self._low_cmd is not None and self._command_crc is not None: + # stop() has already replaced the buffer with damping. Publish it + # synchronously once so shutdown does not depend on thread timing. + with self._write_lock: + self._publish_low_cmd_locked() + self._writer_stop.set() + thread.join(timeout=1.0) + if thread.is_alive(): + raise RuntimeError("Unitree command writer did not stop") + self._writer_thread = None + + def _command_writer_loop(self) -> None: + period_s = self.config.robot.command_publish_period_s + assert period_s is not None + period_ns = max(1, round(period_s * 1e9)) + command_timeout_ns = round(self.config.robot.command_timeout_s * 1e9) + state_timeout_ns = round(self._state_timeout_s * 1e9) + next_deadline_ns = self._clock_ns() + try: + while not self._writer_stop.is_set(): + now_ns = self._clock_ns() + with self._write_lock: + state_stale = now_ns - self._latest_receive_time_ns > state_timeout_ns + command_stale = now_ns - self._latest_command_update_ns > command_timeout_ns + if state_stale or command_stale: + self._set_damping_fields_locked() + stale = "LowState" if state_stale else "policy command" + self._health_reason = f"{stale} is stale; publishing damping" + self._publish_low_cmd_locked() + next_deadline_ns += period_ns + remaining_s = (next_deadline_ns - self._clock_ns()) / 1e9 + if remaining_s <= 0: + next_deadline_ns = self._clock_ns() + continue + self._writer_stop.wait(remaining_s) + except Exception as error: + with self._condition: + self._callback_error = error + self._health_reason = f"LowCmd writer failed: {error}" + self._condition.notify_all() + def _raise_if_remote_stop_requested(self) -> None: with self._condition: self._raise_if_remote_stop_requested_locked() @@ -690,6 +872,8 @@ def _raise_if_remote_stop_requested(self) -> None: def _raise_if_remote_stop_requested_locked(self) -> None: if self._emergency_stop: raise EmergencyStopError(f"remote {self.config.robot.emergency_stop_button!r} requested damping stop") + if self._passive_requested: + raise PassiveRequestedError("operator requested passive damping") if self._lie_down_requested: raise LieDownRequestedError(f"remote {self.config.robot.lie_down_button!r} requested lie-down shutdown") @@ -698,4 +882,25 @@ def _require_open(self) -> None: raise RuntimeError("Unitree backend is not open") -__all__ = ["UnitreeGo2Robot", "UnitreeSdkBindings"] +class UnitreeG1_29DOFRobot(UnitreeGo2Robot): + """Map canonical G1 29-DOF state and commands to HG DDS messages.""" + + robot_config_type = UnitreeG1_29DOFRobotCfg + disabled_position = 0.0 + disabled_velocity = 0.0 + + def _load_sdk_bindings(self) -> UnitreeSdkBindings: + return _load_g1_29dof_sdk_bindings() + + def _disable_high_level_motion_services(self, sdk: UnitreeSdkBindings) -> None: + # The validated G1 deployment enters low-level mode outside this process. + # HG mode_pr/mode_machine are then verified from LowState before output. + del sdk + + def _publish_pre_enable_command(self) -> None: + # Match the validated G1 Passive state: mode 1, measured q, kp 0, + # kd 3, zero desired velocity and feed-forward torque. + self._publish_damping() + + +__all__ = ["UnitreeG1_29DOFRobot", "UnitreeGo2Robot", "UnitreeSdkBindings"] diff --git a/motrix_deploy_unitree/src/motrix_deploy_unitree/native.py b/motrix_deploy_unitree/src/motrix_deploy_unitree/native.py new file mode 100644 index 00000000..12019b8f --- /dev/null +++ b/motrix_deploy_unitree/src/motrix_deploy_unitree/native.py @@ -0,0 +1,32 @@ +"""Optional C++ Unitree backend bridge. + +This module is intentionally small: the native extension owns DDS and the +1 kHz command writer, while this adapter preserves the Motrix RobotInterface +contract. The extension is imported lazily so simulation and Python-SDK +diagnostic paths do not require a C++ SDK installation. +""" + +from __future__ import annotations + +from importlib import import_module +from typing import Any, Protocol + + +class NativeBackend(Protocol): + def open(self) -> None: ... + + def close(self) -> None: ... + + +def load_native_module() -> Any: + """Load the separately built C++ extension only when hardware is selected.""" + try: + return import_module("motrix_unitree_native") + except ImportError as error: + raise RuntimeError( + "The native Unitree backend requires the motrix_unitree_native extension. " + "Build it against Unitree SDK2 or select transport=python_sdk for diagnostics." + ) from error + + +__all__ = ["NativeBackend", "load_native_module"] diff --git a/motrix_deploy_unitree/src/motrix_deploy_unitree/native_interface.py b/motrix_deploy_unitree/src/motrix_deploy_unitree/native_interface.py new file mode 100644 index 00000000..750012da --- /dev/null +++ b/motrix_deploy_unitree/src/motrix_deploy_unitree/native_interface.py @@ -0,0 +1,446 @@ +"""G1 hardware adapter backed by the native Unitree SDK2 extension. + +The extension owns DDS callbacks and the 1 kHz LowCmd writer. This module +only translates the native state snapshot into the existing Motrix contracts +at policy-loop frequency. +""" + +from __future__ import annotations + +import math +import time +from collections.abc import Callable +from dataclasses import dataclass +from typing import Any + +import numpy as np + +from motrix_deploy.contracts import ( + HealthStatus, + JointControlMode, + JointServoCommand, + JointTorqueCommand, + RobotCapabilities, + RobotCommand, + RobotSpec, + RobotState, +) +from motrix_deploy.errors import ( + EmergencyStopError, + LieDownRequestedError, + PassiveRequestedError, + ValidationError, +) +from motrix_deploy.operator import OperatorIntentEvaluator +from motrix_deploy.robot.interface import RobotInterface +from motrix_deploy_unitree.config import UnitreeBackendConfig, UnitreeG1_29DOFRobotCfg +from motrix_deploy_unitree.native import load_native_module +from motrix_deploy_unitree.remote import UnitreeRemoteGamePadDevice, UnitreeRemoteState, decode_wireless_remote +from motrix_env_core.input import GamePadDevice + +# Latched operator intents are only meaningful for the next few frames. +_LATCHED_INTENT_TTL_NS = 5_000_000_000 + + +@dataclass(frozen=True) +class NativeBackendHealth: + healthy: bool + reason: str + last_successful_communication_ns: int + + +def _snapshot_field(snapshot: object, name: str) -> object: + if isinstance(snapshot, dict): + return snapshot[name] + return getattr(snapshot, name) + + +class UnitreeG1NativeRobot(RobotInterface): + """Map the native C++ G1 transport to the Motrix RobotInterface contract.""" + + robot_config_type = UnitreeG1_29DOFRobotCfg + + def __init__( + self, + config: UnitreeBackendConfig, + control_period_s: float, + state_timeout_s: float, + *, + spec: RobotSpec, + native_backend: Any | None = None, + native_factory: Callable[..., Any] | None = None, + sleep: Callable[[float], None] = time.sleep, + ) -> None: + if not isinstance(config.robot, self.robot_config_type): + raise TypeError(f"{type(self).__name__} requires {self.robot_config_type.__name__}") + if spec.joint_count != 29: + raise ValidationError("robot.joint_count", 29, spec.joint_count) + for path, value in (("control.period_s", control_period_s), ("control.state_timeout_s", state_timeout_s)): + if not isinstance(value, (int, float)) or isinstance(value, bool) or not np.isfinite(value) or value <= 0: + raise ValidationError(path, "a positive finite number", value) + + self.config = config + self._spec = spec + self._control_period_s = float(control_period_s) + self._state_timeout_s = float(state_timeout_s) + self._native_backend = native_backend + self._native_factory = native_factory + self._sleep = sleep + self._motor_indices = np.empty(0, dtype=np.int64) + self._kp_override: np.ndarray | None = None + self._kd_override: np.ndarray | None = None + self._native: Any | None = None + self._latest_state: RobotState | None = None + self._last_read_sequence = -1 + self._remote = UnitreeRemoteState() + self._gamepad = UnitreeRemoteGamePadDevice(lambda: self.remote) + self._intent_evaluator = None if config.operator is None else OperatorIntentEvaluator(config.operator.intents) + # intent -> receive_time_ns; consumed by _wait_for_intent in one_shot mode + # and pruned by age, so state_machine mode cannot accumulate forever. + self._latched_intents: dict[str, int] = {} + self._emergency_stop = False + self._passive_requested = False + self._lie_down_requested = False + self._opened = False + self._enabled = False + self._stopped = False + self._closed = False + self._capabilities: RobotCapabilities | None = None + self._health_reason = "backend is not open" + + @property + def spec(self) -> RobotSpec: + return self._spec + + @property + def capabilities(self) -> RobotCapabilities: + if self._capabilities is None: + raise RuntimeError("Unitree capabilities are available after open()") + return self._capabilities + + @property + def remote(self) -> UnitreeRemoteState: + return self._remote + + def get_gamepad_device(self) -> GamePadDevice: + return self._gamepad + + def _make_native_backend(self) -> Any: + if self._native_backend is not None: + return self._native_backend + factory = self._native_factory + if factory is None: + factory = load_native_module().G1Backend + robot = self.config.robot + period = robot.command_publish_period_s or 0.001 + return factory( + network_interface=self.config.network_interface, + domain_id=self.config.domain_id, + lowcmd_topic=self.config.lowcmd_topic, + lowstate_topic=self.config.lowstate_topic, + motor_indices=self._motor_indices.tolist(), + mode_pr=-1 if robot.mode_pr is None else robot.mode_pr, + expected_mode_machine=-1 if robot.expected_mode_machine is None else robot.expected_mode_machine, + motor_mode=1 if robot.motor_mode is None else robot.motor_mode, + damping_kd=robot.damping_kd, + command_period_s=period, + command_timeout_s=robot.command_timeout_s, + state_timeout_s=self._state_timeout_s, + validate_crc=self.config.validate_crc, + subscriber_queue_depth=self.config.subscriber_queue_depth, + ) + + def open(self) -> None: + if self._opened and not self._closed: + raise RuntimeError("native Unitree backend is already open") + robot = self.config.robot + self._motor_indices = self.config.robot.motor_indices(self._spec.joint_names) + self._kp_override = robot.gain_override("kp", self._spec.joint_names) + self._kd_override = robot.gain_override("kd", self._spec.joint_names) + # A native backend starts its sequence at zero after a close/reopen. + # Reset the adapter-side cursor as well so the first sample cannot be + # rejected as older than the previous session. + self._last_read_sequence = -1 + self._latest_state = None + self._remote = UnitreeRemoteState() + self._latched_intents.clear() + self._emergency_stop = False + self._passive_requested = False + self._lie_down_requested = False + self._native = self._make_native_backend() + try: + self._native.open(self.config.connect_timeout_s) + except Exception: + try: + self._native.close() + finally: + self._closed = True + raise + self._opened = True + self._closed = False + self._enabled = False + self._stopped = False + self._health_reason = "" + self._capabilities = RobotCapabilities( + control_modes=(JointControlMode.SERVO, JointControlMode.TORQUE), + state_fields=frozenset( + { + "joint_position", + "joint_velocity", + "base_orientation_xyzw", + "base_angular_velocity", + "base_linear_acceleration", + } + ), + supports_rendering=False, + max_command_rate_hz=1.0 / self._control_period_s, + requires_enable=True, + stop_semantics="damping", + ) + + def read_state(self, timeout_s: float) -> RobotState: + self._require_open() + if timeout_s <= 0: + raise TimeoutError(f"Unitree state timeout must be positive, got {timeout_s}") + assert self._native is not None + try: + snapshot = self._native.read_state(timeout_s, self._last_read_sequence) + except TimeoutError: + raise + except Exception as error: + message = str(error) + if "timeout" in message.lower() or "no fresh" in message.lower(): + raise TimeoutError(message) from error + raise RuntimeError(message) from error + + sequence = int(_snapshot_field(snapshot, "sequence")) + self._last_read_sequence = sequence + state = self._state_from_snapshot(snapshot) + self._latest_state = state + self._update_remote(snapshot, state.receive_time_ns) + self._raise_if_remote_stop_requested() + return state + + def _state_from_snapshot(self, snapshot: object) -> RobotState: + def vector(name: str, shape: tuple[int, ...]) -> np.ndarray: + value = np.asarray(_snapshot_field(snapshot, name), dtype=np.float32) + if value.shape != shape or not np.all(np.isfinite(value)): + raise ValidationError(f"state.{name}", f"finite float32 values with shape {shape}", value) + return value + + quaternion = vector("quaternion_xyzw", (4,)) + norm = float(np.linalg.norm(quaternion)) + if norm <= 1.0e-8: + raise ValidationError("state.base_orientation_xyzw", "a non-zero quaternion", norm) + quaternion = (quaternion / np.float32(norm)).astype(np.float32, copy=False) + receive_time_ns = int(_snapshot_field(snapshot, "receive_time_ns")) + return RobotState( + sample_time_ns=receive_time_ns, + receive_time_ns=receive_time_ns, + joint_position=vector("joint_position", (29,)), + joint_velocity=vector("joint_velocity", (29,)), + base_orientation_xyzw=quaternion, + base_angular_velocity=vector("gyro", (3,)), + base_linear_acceleration=vector("accelerometer", (3,)), + ) + + def _update_remote(self, snapshot: object, receive_time_ns: int) -> None: + payload = _snapshot_field(snapshot, "wireless_remote") + self._remote = decode_wireless_remote(payload) + if self._intent_evaluator is not None: + intents = self._intent_evaluator.update(self._remote.pressed_buttons(), receive_time_ns) + for intent in intents: + self._latched_intents[intent] = receive_time_ns + cutoff_ns = receive_time_ns - _LATCHED_INTENT_TTL_NS + for intent, stamp in tuple(self._latched_intents.items()): + if stamp < cutoff_ns: + del self._latched_intents[intent] + if "emergency_stop" in intents or "request_emergency" in intents: + self._emergency_stop = True + if "enter_passive" in intents and self.config.robot.startup_mode == "one_shot": + self._passive_requested = True + if self._remote.pressed("select") or ( + self._intent_evaluator is None and self._remote.pressed(self.config.robot.emergency_stop_button) + ): + self._emergency_stop = True + if self.config.robot.allow_lie_down and self._remote.pressed(self.config.robot.lie_down_button): + self._lie_down_requested = True + + def enable(self) -> None: + self._require_open() + if self._enabled: + return + assert self._native is not None + if self.config.robot.startup_mode == "state_machine": + self._native.set_enabled(True) + self._enabled = True + return + if self._kp_override is None or self._kd_override is None: + raise ValidationError("backend.enable", "explicit backend kp and kd safety gains", "missing") + if self.config.robot.wait_for_remote_buttons: + if self._intent_evaluator is None: + self._wait_for_button(self.config.robot.start_button, self._publish_zero_torque) + else: + self._wait_for_intent("request_stand", self._publish_zero_torque) + state = self._latest_state if self._latest_state is not None else self.read_state(self._state_timeout_s) + zeros = np.zeros(29, dtype=np.float32) + self._native.set_enabled(True) + self._enabled = True + steps = max(1, math.ceil(self.config.robot.default_transition_duration_s / self._control_period_s)) + for step in range(1, steps + 1): + self._raise_if_remote_stop_requested() + alpha = np.float32(step / steps) + position = ( + (np.float32(1.0) - alpha) * state.joint_position + alpha * self._spec.default_joint_position + ).astype(np.float32) + self._write_servo(position, zeros, zeros, self._kp_override, self._kd_override) + self._wait_control_period() + if self.config.robot.wait_for_remote_buttons: + if self._intent_evaluator is None: + self._wait_for_button( + self.config.robot.enable_button, + lambda: self._write_servo( + self._spec.default_joint_position, zeros, zeros, self._kp_override, self._kd_override + ), + ) + else: + self._wait_for_intent( + "enable_policy", + lambda: self._write_servo( + self._spec.default_joint_position, zeros, zeros, self._kp_override, self._kd_override + ), + ) + self._raise_if_remote_stop_requested() + + def write_command(self, command: RobotCommand) -> None: + self._require_open() + if not self._enabled: + raise RuntimeError("Unitree command output is not enabled") + self._raise_if_remote_stop_requested() + assert self._native is not None + self._validate_command(command) + if isinstance(command, JointTorqueCommand): + self._native.write_torque(command.torque) + elif isinstance(command, JointServoCommand): + self._write_servo( + command.joint_position, + command.joint_velocity, + command.feedforward_torque, + command.kp, + command.kd, + ) + else: + raise ValidationError("command.type", "JointServoCommand or JointTorqueCommand", type(command).__name__) + + def _write_servo( + self, + position: np.ndarray, + velocity: np.ndarray, + torque: np.ndarray, + kp: np.ndarray, + kd: np.ndarray, + ) -> None: + assert self._native is not None + self._native.write_command(position, velocity, torque, kp, kd) + + def _validate_command(self, command: RobotCommand) -> None: + """Enforce the same canonical limits as the Python DDS backend.""" + shape = (self._spec.joint_count,) + if isinstance(command, JointTorqueCommand): + if command.torque.shape != shape or command.torque.dtype != np.float32: + raise ValidationError("command.torque", f"finite float32 shape {shape}", command.torque) + if not np.all(np.isfinite(command.torque)) or np.any(np.abs(command.torque) > self._spec.torque_limit): + raise ValidationError("command.torque", "inside RobotSpec torque limits", command.torque.tolist()) + return + if not isinstance(command, JointServoCommand): + raise ValidationError("command.type", "JointServoCommand or JointTorqueCommand", type(command).__name__) + for name in ("joint_position", "joint_velocity", "feedforward_torque", "kp", "kd"): + value = getattr(command, name) + if value.shape != shape or value.dtype != np.float32 or not np.all(np.isfinite(value)): + raise ValidationError(f"command.{name}", f"finite float32 shape {shape}", value) + if np.any(command.kp < 0) or np.any(command.kd < 0): + raise ValidationError("command.gains", "non-negative values", "negative gain") + if np.any(command.joint_position < self._spec.position_lower) or np.any( + command.joint_position > self._spec.position_upper + ): + raise ValidationError( + "command.joint_position", + "inside RobotSpec position range", + command.joint_position.tolist(), + ) + if np.any(np.abs(command.feedforward_torque) > self._spec.torque_limit): + raise ValidationError( + "command.feedforward_torque", + "inside RobotSpec torque limits", + command.feedforward_torque.tolist(), + ) + + def _publish_zero_torque(self) -> None: + assert self._native is not None + self._native.write_torque(np.zeros(29, dtype=np.float32)) + + def health(self) -> HealthStatus: + if self._native is None: + return HealthStatus(False, self._health_reason, 0) + value = self._native.health() + if isinstance(value, dict): + return HealthStatus( + healthy=bool(value["healthy"]), + reason=str(value["reason"]), + last_successful_communication_ns=int(value["last_successful_communication_ns"]), + ) + return NativeBackendHealth(**value) + + def stop(self) -> None: + if self._stopped: + return + self._enabled = False + if self._native is not None: + self._native.stop() + self._stopped = True + + def close(self) -> None: + if self._closed: + return + try: + self.stop() + finally: + if self._native is not None: + self._native.close() + self._closed = True + + def _wait_for_button(self, button: str, publish: Callable[[], None]) -> None: + while True: + self.read_state(self._state_timeout_s) + if self.remote.pressed(button): + return + self._raise_if_remote_stop_requested() + publish() + + def _wait_for_intent(self, intent: str, publish: Callable[[], None]) -> None: + while True: + self.read_state(self._state_timeout_s) + if intent in self._latched_intents: + del self._latched_intents[intent] + return + self._raise_if_remote_stop_requested() + publish() + + def _wait_control_period(self) -> None: + self._sleep(self._control_period_s) + self.read_state(self._state_timeout_s) + + def _raise_if_remote_stop_requested(self) -> None: + if self._emergency_stop: + raise EmergencyStopError(f"remote {self.config.robot.emergency_stop_button!r} requested damping stop") + if self._passive_requested: + raise PassiveRequestedError("operator requested passive damping") + if self._lie_down_requested: + raise LieDownRequestedError(f"remote {self.config.robot.lie_down_button!r} requested lie-down shutdown") + + def _require_open(self) -> None: + if not self._opened or self._closed: + raise RuntimeError("native Unitree backend is not open") + + +__all__ = ["NativeBackendHealth", "UnitreeG1NativeRobot"] diff --git a/motrix_deploy_unitree/src/motrix_deploy_unitree/plugin.py b/motrix_deploy_unitree/src/motrix_deploy_unitree/plugin.py index 6472a657..e9f5ded7 100644 --- a/motrix_deploy_unitree/src/motrix_deploy_unitree/plugin.py +++ b/motrix_deploy_unitree/src/motrix_deploy_unitree/plugin.py @@ -5,8 +5,9 @@ from motrix_deploy.runtime.factory import RuntimeCreateContext from motrix_deploy.runtime.hardware import HardwareRuntime -from motrix_deploy_unitree.config import UnitreeBackendConfig, UnitreeGo2RobotCfg -from motrix_deploy_unitree.interface import UnitreeGo2Robot +from motrix_deploy_unitree.config import UnitreeBackendConfig, UnitreeG1_29DOFRobotCfg, UnitreeGo2RobotCfg +from motrix_deploy_unitree.interface import UnitreeG1_29DOFRobot, UnitreeGo2Robot +from motrix_deploy_unitree.native_interface import UnitreeG1NativeRobot def create_runtime( @@ -17,9 +18,15 @@ def create_runtime( if not isinstance(config, UnitreeBackendConfig): raise TypeError(f"Unitree runtime requires UnitreeBackendConfig, got {type(config).__name__}") - if not isinstance(config.robot, UnitreeGo2RobotCfg): + if isinstance(config.robot, UnitreeG1_29DOFRobotCfg): + robot_type = UnitreeG1NativeRobot if config.transport == "native_cpp" else UnitreeG1_29DOFRobot + elif isinstance(config.robot, UnitreeGo2RobotCfg): + if config.transport == "native_cpp": + raise ValueError("transport=native_cpp currently supports only the G1 29-DOF backend") + robot_type = UnitreeGo2Robot + else: raise TypeError(f"Unsupported Unitree robot config: {type(config.robot).__name__}") - robot = UnitreeGo2Robot( + robot = robot_type( config, control_period_s=context.control.period_s, state_timeout_s=context.control.state_timeout_s, diff --git a/motrix_deploy_unitree/src/motrix_deploy_unitree/read_lowstate.py b/motrix_deploy_unitree/src/motrix_deploy_unitree/read_lowstate.py index 6c0954af..3b1c844f 100644 --- a/motrix_deploy_unitree/src/motrix_deploy_unitree/read_lowstate.py +++ b/motrix_deploy_unitree/src/motrix_deploy_unitree/read_lowstate.py @@ -1,18 +1,18 @@ # Copyright Motphys Technology Co., Ltd. 2025, 2026 # SPDX-License-Identifier: Apache-2.0 -"""Read Unitree Go2 LowState without creating a LowCmd publisher.""" +"""Read Unitree LowState without creating a LowCmd publisher.""" import sys import time from dataclasses import dataclass from typing import Any -from motrix_deploy_unitree.config import GO2_JOINT_NAME_TO_MOTOR_INDEX +from motrix_deploy_unitree.config import G1_29DOF_JOINT_NAME_TO_MOTOR_ID, GO2_JOINT_NAME_TO_MOTOR_INDEX from motrix_deploy_unitree.remote import BUTTON_NAMES, decode_wireless_remote -JOINT_NAMES = tuple(GO2_JOINT_NAME_TO_MOTOR_INDEX) -MOTOR_INDICES = tuple(GO2_JOINT_NAME_TO_MOTOR_INDEX.values()) +GO2_JOINT_NAMES = tuple(GO2_JOINT_NAME_TO_MOTOR_INDEX) +GO2_MOTOR_INDICES = tuple(GO2_JOINT_NAME_TO_MOTOR_INDEX.values()) @dataclass @@ -26,10 +26,28 @@ class ReadStatistics: class LowStatePrinter: - """Validate, throttle, and print canonical Go2 state samples.""" - - def __init__(self, crc: Any, *, print_interval_s: float, validate_crc: bool) -> None: + """Validate, throttle, and print canonical Unitree state samples.""" + + def __init__( + self, + crc: Any, + *, + robot: str, + joint_names: tuple[str, ...], + motor_indices: tuple[int, ...], + motor_slot_count: int, + expected_mode_pr: int | None, + expected_mode_machine: int | None, + print_interval_s: float, + validate_crc: bool, + ) -> None: self.crc = crc + self.robot = robot + self.joint_names = joint_names + self.motor_indices = motor_indices + self.motor_slot_count = motor_slot_count + self.expected_mode_pr = expected_mode_pr + self.expected_mode_machine = expected_mode_machine self.print_interval_ns = round(print_interval_s * 1e9) self.validate_crc = validate_crc self.statistics = ReadStatistics() @@ -41,10 +59,16 @@ def __call__(self, message: Any) -> None: if self.validate_crc and self.crc.Crc(message) != message.crc: self.statistics.crc_errors += 1 return - if len(message.motor_state) < 12: - raise ValueError(f"expected at least 12 motor states, got {len(message.motor_state)}") - position = [float(message.motor_state[index].q) for index in MOTOR_INDICES] - velocity = [float(message.motor_state[index].dq) for index in MOTOR_INDICES] + if len(message.motor_state) < self.motor_slot_count: + raise ValueError( + f"expected at least {self.motor_slot_count} motor states, got {len(message.motor_state)}" + ) + if self.expected_mode_pr is not None and message.mode_pr != self.expected_mode_pr: + raise ValueError(f"mode_pr={message.mode_pr}, expected {self.expected_mode_pr}") + if self.expected_mode_machine is not None and message.mode_machine != self.expected_mode_machine: + raise ValueError(f"mode_machine={message.mode_machine}, expected {self.expected_mode_machine}") + position = [float(message.motor_state[index].q) for index in self.motor_indices] + velocity = [float(message.motor_state[index].dq) for index in self.motor_indices] quaternion_wxyz = [float(value) for value in message.imu_state.quaternion] gyroscope = [float(value) for value in message.imu_state.gyroscope] accelerometer = [float(value) for value in message.imu_state.accelerometer] @@ -72,12 +96,14 @@ def __call__(self, message: Any) -> None: except Exception as error: remote_text = f"unavailable ({error})" - print("\n--- Unitree Go2 LowState ---") + print(f"\n--- Unitree {self.robot} LowState ---") print( f"frames received={self.statistics.received} valid={self.statistics.valid} " f"crc_errors={self.statistics.crc_errors} decode_errors={self.statistics.decode_errors}" ) - for name, joint_position, joint_velocity in zip(JOINT_NAMES, position, velocity, strict=True): + if self.expected_mode_pr is not None: + print(f"mode_pr={message.mode_pr} mode_machine={message.mode_machine}") + for name, joint_position, joint_velocity in zip(self.joint_names, position, velocity, strict=True): print(f"{name:16s} q={joint_position: 9.5f} rad dq={joint_velocity: 9.5f} rad/s") print("imu quaternion wxyz:", quaternion_wxyz) print("imu quaternion xyzw:", quaternion_wxyz[1:] + quaternion_wxyz[:1]) @@ -86,11 +112,15 @@ def __call__(self, message: Any) -> None: print("remote:", remote_text, flush=True) -def _load_sdk() -> tuple[Any, Any, Any, Any]: +def _load_sdk(robot: str) -> tuple[Any, Any, Any, Any]: try: from unitree_sdk2py.core.channel import ChannelFactoryInitialize, ChannelSubscriber - from unitree_sdk2py.idl.unitree_go.msg.dds_ import LowState_ from unitree_sdk2py.utils.crc import CRC + + if robot == "g1-29dof": + from unitree_sdk2py.idl.unitree_hg.msg.dds_ import LowState_ + else: + from unitree_sdk2py.idl.unitree_go.msg.dds_ import LowState_ except ImportError as error: raise RuntimeError( "LowState reading requires the official unitree_sdk2py package; install " @@ -108,16 +138,39 @@ def run_read_lowstate( duration_s: float, print_interval_s: float, validate_crc: bool, + robot: str = "go2", ) -> int: """Run a bounded read-only LowState DDS diagnostic.""" try: - channel_factory_initialize, channel_subscriber, low_state_type, crc_type = _load_sdk() + channel_factory_initialize, channel_subscriber, low_state_type, crc_type = _load_sdk(robot) except RuntimeError as error: print(error, file=sys.stderr) return 2 channel_factory_initialize(domain_id, network_interface) - printer = LowStatePrinter(crc_type(), print_interval_s=print_interval_s, validate_crc=validate_crc) + if robot == "g1-29dof": + joint_names = tuple(G1_29DOF_JOINT_NAME_TO_MOTOR_ID) + motor_indices = tuple(G1_29DOF_JOINT_NAME_TO_MOTOR_ID.values()) + motor_slot_count = 35 + expected_mode_pr = 0 + expected_mode_machine = 5 + else: + joint_names = GO2_JOINT_NAMES + motor_indices = GO2_MOTOR_INDICES + motor_slot_count = 12 + expected_mode_pr = None + expected_mode_machine = None + printer = LowStatePrinter( + crc_type(), + robot=robot, + joint_names=joint_names, + motor_indices=motor_indices, + motor_slot_count=motor_slot_count, + expected_mode_pr=expected_mode_pr, + expected_mode_machine=expected_mode_machine, + print_interval_s=print_interval_s, + validate_crc=validate_crc, + ) subscriber = channel_subscriber(topic, low_state_type) subscriber.Init(printer, queue_depth) duration = "unlimited time" if duration_s == 0 else f"{duration_s:g} seconds" diff --git a/motrix_deploy_unitree/src/motrix_deploy_unitree/remote.py b/motrix_deploy_unitree/src/motrix_deploy_unitree/remote.py index 2ca76e0e..8e2410eb 100644 --- a/motrix_deploy_unitree/src/motrix_deploy_unitree/remote.py +++ b/motrix_deploy_unitree/src/motrix_deploy_unitree/remote.py @@ -30,6 +30,13 @@ "down", "left", ) +BUTTON_ALIASES = {"RB": "R1", "LB": "L1", "RT": "R2", "LT": "L2", "back": "select"} +ACCEPTED_BUTTON_NAMES = BUTTON_NAMES + tuple(BUTTON_ALIASES) + + +def canonical_button_name(name: str) -> str: + """Resolve SDK-wrapper aliases without changing the stable wire bit names.""" + return BUTTON_ALIASES.get(name, name) @dataclass(frozen=True) @@ -43,12 +50,19 @@ class UnitreeRemoteState: ry: float = 0.0 def pressed(self, name: str) -> bool: + name = canonical_button_name(name) try: index = BUTTON_NAMES.index(name) except ValueError as error: raise ValidationError("remote.button", f"one of {list(BUTTON_NAMES)}", name) from error return bool(self.keys & (1 << index)) + def pressed_buttons(self) -> frozenset[str]: + """Return active canonical names plus their accepted SDK aliases.""" + active = {name for name in BUTTON_NAMES if self.pressed(name)} + active.update(alias for alias, canonical in BUTTON_ALIASES.items() if canonical in active) + return frozenset(active) + class UnitreeRemoteGamePadDevice(GamePadDevice): """Expose the latest Unitree remote sample through the common gamepad API.""" @@ -98,4 +112,12 @@ def decode_wireless_remote(data: object) -> UnitreeRemoteState: return UnitreeRemoteState(keys=keys, lx=float(lx), ly=float(ly), rx=float(rx), ry=float(ry)) -__all__ = ["BUTTON_NAMES", "UnitreeRemoteGamePadDevice", "UnitreeRemoteState", "decode_wireless_remote"] +__all__ = [ + "ACCEPTED_BUTTON_NAMES", + "BUTTON_ALIASES", + "BUTTON_NAMES", + "UnitreeRemoteGamePadDevice", + "UnitreeRemoteState", + "canonical_button_name", + "decode_wireless_remote", +] diff --git a/motrix_deploy_unitree/tests/test_g1_29dof_backend.py b/motrix_deploy_unitree/tests/test_g1_29dof_backend.py new file mode 100644 index 00000000..6c740691 --- /dev/null +++ b/motrix_deploy_unitree/tests/test_g1_29dof_backend.py @@ -0,0 +1,319 @@ +# Copyright Motphys Technology Co., Ltd. 2025, 2026 +# SPDX-License-Identifier: Apache-2.0 + +"""G1 29-DOF HG message, mode, and named-joint mapping contracts.""" + +import copy +import time +from types import SimpleNamespace + +import numpy as np +import pytest + +from motrix_deploy.contracts import JointServoCommand, RobotSpec +from motrix_deploy.errors import EmergencyStopError, PassiveRequestedError +from motrix_deploy.operator import ButtonGestureCfg, OperatorProfileCfg +from motrix_deploy.runtime.factory import RuntimeCreateContext +from motrix_deploy.runtime.hardware import HardwareRuntime +from motrix_deploy_unitree.config import UnitreeBackendConfig, UnitreeG1_29DOFRobotCfg +from motrix_deploy_unitree.hardware import G1_29DOF_JOINT_NAMES, UnitreeG1_29DOFHardwareCfg +from motrix_deploy_unitree.interface import UnitreeG1_29DOFRobot, UnitreeSdkBindings +from motrix_deploy_unitree.plugin import create_runtime + + +class _Motor: + def __init__(self, index: int = 0) -> None: + self.mode = 0 + self.q = float(index) + self.dq = float(-index) + self.kp = 0.0 + self.kd = 0.0 + self.tau = 0.0 + + +class _LowCmd: + def __init__(self) -> None: + self.mode_pr = 0 + self.mode_machine = 0 + self.motor_cmd = [_Motor() for _ in range(35)] + self.crc = 0 + + +class _LowState: + def __init__(self, *, mode_pr: int = 0, mode_machine: int = 5) -> None: + self.mode_pr = mode_pr + self.mode_machine = mode_machine + self.motor_state = [_Motor(index) for index in range(35)] + self.imu_state = SimpleNamespace( + quaternion=[1.0, 0.0, 0.0, 0.0], + gyroscope=[0.1, 0.2, 0.3], + accelerometer=[0.0, 0.0, 9.81], + ) + self.wireless_remote = bytes(40) + self.crc = 123 + + +class _CRC: + def Crc(self, message: object) -> int: + del message + return 123 + + +class _Publisher: + def __init__(self, bus: "_Bus", topic: str, message_type: type) -> None: + self.bus = bus + self.topic = topic + self.message_type = message_type + + def Init(self) -> None: + pass + + def Write(self, message: _LowCmd) -> None: + self.bus.commands.append(copy.deepcopy(message)) + if self.bus.callback is not None: + self.bus.callback(copy.deepcopy(self.bus.state)) + + def Close(self) -> None: + pass + + +class _Subscriber: + def __init__(self, bus: "_Bus", topic: str, message_type: type) -> None: + self.bus = bus + self.topic = topic + self.message_type = message_type + + def Init(self, callback, queue_depth: int) -> None: + self.bus.callback = callback + self.bus.queue_depth = queue_depth + callback(copy.deepcopy(self.bus.state)) + + def Close(self) -> None: + pass + + +class _Bus: + def __init__(self, *, mode_pr: int = 0, mode_machine: int = 5) -> None: + self.state = _LowState(mode_pr=mode_pr, mode_machine=mode_machine) + self.commands: list[_LowCmd] = [] + self.callback = None + self.queue_depth = 0 + + def sdk(self) -> UnitreeSdkBindings: + return UnitreeSdkBindings( + channel_factory_initialize=lambda domain, interface: None, + channel_publisher=lambda topic, message_type: _Publisher(self, topic, message_type), + channel_subscriber=lambda topic, message_type: _Subscriber(self, topic, message_type), + low_cmd_message_type=_LowCmd, + low_state_message_type=_LowState, + make_low_cmd=_LowCmd, + crc_type=_CRC, + ) + + +def _spec(joint_names: tuple[str, ...] = G1_29DOF_JOINT_NAMES) -> RobotSpec: + count = len(joint_names) + return RobotSpec( + base_link_name="torso_link", + joint_names=joint_names, + default_joint_position=np.zeros(count, dtype=np.float32), + position_lower=np.full(count, -10.0, dtype=np.float32), + position_upper=np.full(count, 10.0, dtype=np.float32), + torque_limit=np.full(count, 100.0, dtype=np.float32), + ) + + +def _config(**overrides) -> UnitreeBackendConfig: + robot_values = { + "wait_for_remote_buttons": False, + "default_transition_duration_s": 0.02, + "damping_duration_s": 0.0, + "kp": 20.0, + "kd": 1.0, + "command_publish_period_s": None, + } + robot_values.update(overrides) + return UnitreeBackendConfig( + network_interface="eth0", + robot=UnitreeG1_29DOFRobotCfg(**robot_values), + ) + + +def _remote_payload(*buttons: str) -> bytes: + from motrix_deploy_unitree.remote import BUTTON_NAMES, canonical_button_name + + keys = sum(1 << BUTTON_NAMES.index(canonical_button_name(button)) for button in buttons) + payload = bytearray(40) + payload[2:4] = keys.to_bytes(2, "little") + return bytes(payload) + + +def _backend(config: UnitreeBackendConfig, bus: _Bus, *, spec: RobotSpec | None = None) -> UnitreeG1_29DOFRobot: + return UnitreeG1_29DOFRobot( + config, + control_period_s=0.02, + state_timeout_s=0.1, + spec=_spec() if spec is None else spec, + sdk=bus.sdk(), + sleep=lambda _: None, + ) + + +def test_g1_hardware_uses_explicit_joint_name_to_motor_id_mapping() -> None: + hardware = UnitreeG1_29DOFHardwareCfg() + hardware.validate() + assert tuple(hardware.key_pose.joint_names) == G1_29DOF_JOINT_NAMES + assert {name: binding.index for name, binding in hardware.actuation.motors.items()} == { + name: motor_id for motor_id, name in enumerate(G1_29DOF_JOINT_NAMES) + } + assert all(binding.enabled_mode == 1 for binding in hardware.actuation.motors.values()) + + +def test_g1_state_and_command_follow_artifact_joint_names_not_policy_indices() -> None: + joint_names = G1_29DOF_JOINT_NAMES[7:] + G1_29DOF_JOINT_NAMES[:7] + bus = _Bus() + backend = _backend(_config(), bus, spec=_spec(joint_names)) + backend.open() + state = backend.read_state(0.1) + expected_motor_ids = [G1_29DOF_JOINT_NAMES.index(name) for name in joint_names] + assert state.joint_position.tolist() == pytest.approx(expected_motor_ids) + + backend.enable() + target = np.arange(29, dtype=np.float32) / 100.0 + zeros = np.zeros(29, dtype=np.float32) + policy_kp = np.full(29, 17.0, dtype=np.float32) + policy_kd = np.full(29, 0.7, dtype=np.float32) + backend.write_command( + JointServoCommand( + joint_position=target, + joint_velocity=zeros, + feedforward_torque=zeros, + kp=policy_kp, + kd=policy_kd, + ) + ) + command = bus.commands[-1] + assert command.mode_pr == 0 + assert command.mode_machine == 5 + for policy_index, motor_id in enumerate(expected_motor_ids): + assert command.motor_cmd[motor_id].q == pytest.approx(target[policy_index]) + assert command.motor_cmd[motor_id].kp == pytest.approx(policy_kp[policy_index]) + assert command.motor_cmd[motor_id].kd == pytest.approx(policy_kd[policy_index]) + for motor in command.motor_cmd[29:]: + assert (motor.mode, motor.q, motor.dq, motor.kp, motor.kd, motor.tau) == (0, 0.0, 0.0, 0.0, 0.0, 0.0) + backend.close() + + +def test_named_startup_gains_follow_artifact_joint_order() -> None: + joint_names = G1_29DOF_JOINT_NAMES[7:] + G1_29DOF_JOINT_NAMES[:7] + kp = {name: float(index + 1) for index, name in enumerate(G1_29DOF_JOINT_NAMES)} + kd = {name: float(index + 1) / 10.0 for index, name in enumerate(G1_29DOF_JOINT_NAMES)} + bus = _Bus() + backend = _backend(_config(kp=kp, kd=kd), bus, spec=_spec(joint_names)) + backend.open() + backend.enable() + + command = bus.commands[-1] + for name in joint_names: + motor_id = G1_29DOF_JOINT_NAMES.index(name) + assert command.motor_cmd[motor_id].kp == pytest.approx(kp[name]) + assert command.motor_cmd[motor_id].kd == pytest.approx(kd[name]) + backend.close() + + +def test_state_machine_startup_enables_command_stream_without_legacy_pose_ramp() -> None: + bus = _Bus() + backend = _backend(_config(startup_mode="state_machine", kp=None, kd=None), bus) + backend.open() + backend.enable() + + zeros = np.zeros(29, dtype=np.float32) + backend.write_command(JointServoCommand(zeros, zeros, zeros, zeros, np.full(29, 3.0, dtype=np.float32))) + + assert len(bus.commands) == 1 + assert all(motor.kp == 0.0 and motor.kd == pytest.approx(3.0) for motor in bus.commands[-1].motor_cmd[:29]) + backend.close() + + +def test_operator_alias_gesture_requests_passive_damping() -> None: + profile = OperatorProfileCfg( + intents={ + "request_stand": ButtonGestureCfg(held=["LT"], pressed="up"), + "enable_policy": ButtonGestureCfg(held=["RB"], pressed="X"), + "enter_passive": ButtonGestureCfg(held=["LT"], pressed="B"), + "emergency_stop": ButtonGestureCfg(pressed="select"), + } + ) + config = _config() + config.operator = profile + config.__post_init__() + bus = _Bus() + backend = _backend(config, bus) + backend.open() + bus.state.wireless_remote = _remote_payload("LT") + bus.callback(copy.deepcopy(bus.state)) + bus.state.wireless_remote = _remote_payload("LT", "B") + bus.callback(copy.deepcopy(bus.state)) + + with pytest.raises(PassiveRequestedError): + backend.read_state(0.1) + backend.close() + + +def test_select_remains_an_unconditional_emergency_stop() -> None: + profile = OperatorProfileCfg( + intents={ + "request_stand": ButtonGestureCfg(held=["LT"], pressed="up"), + "enable_policy": ButtonGestureCfg(held=["RB"], pressed="X"), + "enter_passive": ButtonGestureCfg(held=["LT"], pressed="B"), + "emergency_stop": ButtonGestureCfg(pressed="A"), + } + ) + config = _config() + config.operator = profile + config.__post_init__() + bus = _Bus() + backend = _backend(config, bus) + backend.open() + bus.state.wireless_remote = _remote_payload("select") + bus.callback(copy.deepcopy(bus.state)) + + with pytest.raises(EmergencyStopError): + backend.read_state(0.1) + backend.close() + + +@pytest.mark.parametrize(("mode_pr", "mode_machine"), [(1, 5), (0, 4)]) +def test_g1_rejects_lowstate_mode_mismatch_before_enable(mode_pr: int, mode_machine: int) -> None: + backend = _backend(_config(), _Bus(mode_pr=mode_pr, mode_machine=mode_machine)) + with pytest.raises(RuntimeError, match="mode_pr|mode_machine"): + backend.open() + backend.close() + + +def test_g1_plugin_constructs_explicit_robot_type() -> None: + context = RuntimeCreateContext(robot=_spec(), control=SimpleNamespace(period_s=0.02, state_timeout_s=0.1)) + runtime = create_runtime(_config(), context) + assert isinstance(runtime, HardwareRuntime) + assert type(runtime.robot) is UnitreeG1_29DOFRobot + + +def test_g1_periodic_writer_repeats_latest_command() -> None: + bus = _Bus() + backend = _backend( + _config(command_publish_period_s=0.001, command_timeout_s=0.1), + bus, + ) + backend.open() + deadline = time.monotonic() + 0.05 + while len(bus.commands) < 3 and time.monotonic() < deadline: + time.sleep(0.001) + passive = bus.commands[0] + for motor_id in range(29): + assert passive.motor_cmd[motor_id].mode == 1 + assert passive.motor_cmd[motor_id].q == pytest.approx(bus.state.motor_state[motor_id].q) + assert passive.motor_cmd[motor_id].kp == 0.0 + assert passive.motor_cmd[motor_id].kd == 3.0 + backend.close() + assert len(bus.commands) >= 3 + assert all(command.crc == 123 for command in bus.commands) diff --git a/motrix_deploy_unitree/tests/test_native_backend.py b/motrix_deploy_unitree/tests/test_native_backend.py new file mode 100644 index 00000000..2b888577 --- /dev/null +++ b/motrix_deploy_unitree/tests/test_native_backend.py @@ -0,0 +1,151 @@ +"""Contract tests for the Python adapter around the native G1 transport.""" + +from __future__ import annotations + +import numpy as np +import pytest + +from motrix_deploy.artifact.schema import ControlSpec +from motrix_deploy.contracts import JointServoCommand, RobotSpec +from motrix_deploy.errors import ValidationError +from motrix_deploy.runtime.factory import RuntimeCreateContext +from motrix_deploy_unitree.config import UnitreeBackendConfig, UnitreeG1_29DOFRobotCfg +from motrix_deploy_unitree.hardware import G1_29DOF_JOINT_NAMES +from motrix_deploy_unitree.native_interface import UnitreeG1NativeRobot +from motrix_deploy_unitree.plugin import create_runtime + + +class _NativeFake: + def __init__(self) -> None: + self.sequence = 0 + self.enabled = False + self.commands: list[tuple[str, tuple[np.ndarray, ...]]] = [] + self.closed = False + + def open(self, timeout_s: float) -> None: + assert timeout_s > 0 + + def read_state(self, timeout_s: float, after_sequence: int) -> dict[str, object]: + assert timeout_s > 0 + self.sequence = max(self.sequence + 1, after_sequence + 1) + return { + "sequence": self.sequence, + "receive_time_ns": 1_000_000 + self.sequence, + "joint_position": np.arange(29, dtype=np.float32), + "joint_velocity": -np.arange(29, dtype=np.float32), + "quaternion_xyzw": np.asarray([0.0, 0.0, 0.0, 2.0], dtype=np.float32), + "gyro": np.asarray([0.1, 0.2, 0.3], dtype=np.float32), + "accelerometer": np.asarray([0.0, 0.0, 9.81], dtype=np.float32), + "wireless_remote": bytes(40), + } + + def write_command(self, *values: np.ndarray) -> None: + self.commands.append(("servo", tuple(np.asarray(value) for value in values))) + + def write_torque(self, torque: np.ndarray) -> None: + self.commands.append(("torque", (np.asarray(torque),))) + + def set_enabled(self, enabled: bool) -> None: + self.enabled = enabled + + def stop(self) -> None: + self.enabled = False + + def close(self) -> None: + self.closed = True + + def health(self) -> dict[str, object]: + return { + "healthy": not self.closed, + "reason": "" if not self.closed else "backend is closed", + "last_successful_communication_ns": 1_000_001, + } + + +def _spec() -> RobotSpec: + return RobotSpec( + base_link_name="pelvis", + joint_names=G1_29DOF_JOINT_NAMES, + default_joint_position=np.zeros(29, dtype=np.float32), + position_lower=np.full(29, -10.0, dtype=np.float32), + position_upper=np.full(29, 10.0, dtype=np.float32), + torque_limit=np.full(29, 100.0, dtype=np.float32), + ) + + +def _config() -> UnitreeBackendConfig: + return UnitreeBackendConfig( + transport="native_cpp", + network_interface="eth0", + robot=UnitreeG1_29DOFRobotCfg( + wait_for_remote_buttons=False, + startup_mode="state_machine", + kp=20.0, + kd=1.0, + ), + ) + + +def test_native_adapter_normalizes_snapshot_and_forwards_command() -> None: + native = _NativeFake() + robot = UnitreeG1NativeRobot(_config(), 0.02, 0.1, spec=_spec(), native_backend=native, sleep=lambda _: None) + robot.open() + state = robot.read_state(0.1) + assert state.joint_position.shape == (29,) + np.testing.assert_array_equal(state.joint_position[:3], np.asarray([0.0, 1.0, 2.0], dtype=np.float32)) + np.testing.assert_allclose(state.base_orientation_xyzw, [0.0, 0.0, 0.0, 1.0]) + + robot.enable() + zeros = np.zeros(29, dtype=np.float32) + robot.write_command(JointServoCommand(zeros, zeros, zeros, np.ones(29, np.float32), np.ones(29, np.float32))) + assert native.enabled + assert native.commands[-1][0] == "servo" + robot.close() + assert native.closed + + +def test_native_factory_receives_configured_damping_gain() -> None: + """The damping kd must come from the runtime config, not a hardcoded value.""" + + recorded: dict[str, object] = {} + + class _Recorder(_NativeFake): + def __init__(self, **kwargs: object) -> None: + super().__init__() + recorded.update(kwargs) + + config = _config() + robot = UnitreeG1NativeRobot(config, 0.02, 0.1, spec=_spec(), native_factory=_Recorder, sleep=lambda _: None) + robot.open() + robot.close() + assert recorded["damping_kd"] == config.robot.damping_kd + assert recorded["command_period_s"] == config.robot.command_publish_period_s + assert recorded["command_timeout_s"] == config.robot.command_timeout_s + + +def test_native_transport_selects_g1_native_robot() -> None: + context = RuntimeCreateContext( + control=ControlSpec(period_s=0.02, state_timeout_s=0.1), + robot=_spec(), + ) + runtime = create_runtime(_config(), context) + assert isinstance(runtime.robot, UnitreeG1NativeRobot) + + +def test_native_adapter_enforces_robot_command_limits() -> None: + native = _NativeFake() + robot = UnitreeG1NativeRobot(_config(), 0.02, 0.1, spec=_spec(), native_backend=native, sleep=lambda _: None) + robot.open() + robot.enable() + zeros = np.zeros(29, dtype=np.float32) + with pytest.raises(ValidationError): + robot.write_command( + JointServoCommand( + joint_position=np.full(29, 11.0, dtype=np.float32), + joint_velocity=zeros, + feedforward_torque=zeros, + kp=np.ones(29, dtype=np.float32), + kd=np.ones(29, dtype=np.float32), + ) + ) + robot.close() diff --git a/motrix_deploy_unitree/tests/test_unitree_deploy_backend.py b/motrix_deploy_unitree/tests/test_unitree_deploy_backend.py index 6113a8e3..2be8f10c 100644 --- a/motrix_deploy_unitree/tests/test_unitree_deploy_backend.py +++ b/motrix_deploy_unitree/tests/test_unitree_deploy_backend.py @@ -167,7 +167,7 @@ def Write(self, message: _LowCmd) -> None: for motor_index, motor in enumerate(snapshot.motor_cmd): if motor.kp > 0: self.bus.state.motor_state[motor_index].q = motor.q - self.bus.state.motor_state[motor_index].dq = motor.qd + self.bus.state.motor_state[motor_index].dq = motor.dq self.bus.emit() def Close(self) -> None: @@ -382,7 +382,7 @@ def test_lowstate_and_lowcmd_are_mapped_by_canonical_joint_name() -> None: for canonical_index, name in enumerate(JOINT_NAMES): motor = published.motor_cmd[MOTOR_MAPPING[name]] assert motor.q == pytest.approx(command.joint_position[canonical_index]) - assert motor.qd == pytest.approx(0.0) + assert motor.dq == pytest.approx(0.0) assert motor.kp == pytest.approx(35.0) assert motor.kd == pytest.approx(0.5) assert published.crc == 123 @@ -430,7 +430,7 @@ def test_torque_enable_uses_servo_transition_then_maps_pure_torque_and_preserves backend.write_command(torque) for index, name in enumerate(JOINT_NAMES): motor = bus.commands[-1].motor_cmd[MOTOR_MAPPING[name]] - assert (motor.q, motor.qd, motor.kp, motor.kd) == (0.0, 0.0, 0.0, 0.0) + assert (motor.q, motor.dq, motor.kp, motor.kd) == (0.0, 0.0, 0.0, 0.0) assert motor.tau == pytest.approx(torque.torque[index]) assert motor.mode == transition.motor_cmd[MOTOR_MAPPING[name]].mode count = len(bus.commands) From aa6a2799eed788d7b120be6a4637918f3b56481a Mon Sep 17 00:00:00 2001 From: MrHu <1962951972@qq.com> Date: Mon, 19 Oct 2026 17:20:59 +0800 Subject: [PATCH 5/9] feat(unitree-native): add C++ DDS transport extension for G1 low-level control --- motrix_deploy_unitree/pyproject.toml | 3 + motrix_unitree_native/CMakeLists.txt | 84 ++++ motrix_unitree_native/README.md | 38 ++ motrix_unitree_native/pyproject.toml | 15 + .../python/motrix_unitree_native/__init__.py | 5 + motrix_unitree_native/src/backend.cpp | 416 ++++++++++++++++++ motrix_unitree_native/src/backend.hpp | 124 ++++++ motrix_unitree_native/src/bindings.cpp | 116 +++++ pyproject.toml | 4 +- tests/test_workspace_versions.py | 71 ++- uv.lock | 23 +- 11 files changed, 892 insertions(+), 7 deletions(-) create mode 100644 motrix_unitree_native/CMakeLists.txt create mode 100644 motrix_unitree_native/README.md create mode 100644 motrix_unitree_native/pyproject.toml create mode 100644 motrix_unitree_native/python/motrix_unitree_native/__init__.py create mode 100644 motrix_unitree_native/src/backend.cpp create mode 100644 motrix_unitree_native/src/backend.hpp create mode 100644 motrix_unitree_native/src/bindings.cpp diff --git a/motrix_deploy_unitree/pyproject.toml b/motrix_deploy_unitree/pyproject.toml index 914db245..0dd869e2 100644 --- a/motrix_deploy_unitree/pyproject.toml +++ b/motrix_deploy_unitree/pyproject.toml @@ -20,6 +20,9 @@ dependencies = [ "unitree-sdk2py", ] +[project.optional-dependencies] +native = ["motrix-unitree-native==0.4.0"] + [project.scripts] motrix-deploy-unitree = "motrix_deploy_unitree.cli:main" diff --git a/motrix_unitree_native/CMakeLists.txt b/motrix_unitree_native/CMakeLists.txt new file mode 100644 index 00000000..8d607367 --- /dev/null +++ b/motrix_unitree_native/CMakeLists.txt @@ -0,0 +1,84 @@ +cmake_minimum_required(VERSION 3.18) +project(motrix_unitree_native LANGUAGES CXX) + +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED ON) +set(CMAKE_CXX_EXTENSIONS OFF) + +find_package(Python REQUIRED COMPONENTS Interpreter Development.Module) +find_package(pybind11 CONFIG REQUIRED) +find_package(Threads REQUIRED) + +set(UNITREE_SDK2_ROOT "" CACHE PATH "Unitree SDK2 source or installation root") +find_package(unitree_sdk2 CONFIG QUIET) + +if(NOT unitree_sdk2_FOUND) + if(NOT UNITREE_SDK2_ROOT) + if(DEFINED ENV{UNITREE_SDK2_ROOT}) + set(UNITREE_SDK2_ROOT "$ENV{UNITREE_SDK2_ROOT}") + else() + set(UNITREE_SDK2_ROOT "/opt/unitree_robotics") + endif() + endif() + + if(NOT EXISTS "${UNITREE_SDK2_ROOT}/include/unitree/robot/channel/channel_factory.hpp") + # CI and simulation-only installs must still resolve `--extra unitree`; the + # adapter imports the extension lazily and reports the missing backend. + message(WARNING + "Unitree SDK2 headers were not found under ${UNITREE_SDK2_ROOT}; building " + "motrix_unitree_native without the native DDS backend. Set UNITREE_SDK2_ROOT " + "and reinstall to enable hardware transport.") + return() + endif() + + if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|amd64|AMD64") + set(UNITREE_ARCH "x86_64") + elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64") + set(UNITREE_ARCH "aarch64") + else() + message(FATAL_ERROR "Unsupported architecture: ${CMAKE_SYSTEM_PROCESSOR}") + endif() + + set(UNITREE_SDK2_LIBRARY "${UNITREE_SDK2_ROOT}/lib/${UNITREE_ARCH}/libunitree_sdk2.a") + set(UNITREE_DDS_LIBRARY "${UNITREE_SDK2_ROOT}/thirdparty/lib/${UNITREE_ARCH}/libddsc.so") + set(UNITREE_DDSXX_LIBRARY "${UNITREE_SDK2_ROOT}/thirdparty/lib/${UNITREE_ARCH}/libddscxx.so") + if(NOT EXISTS "${UNITREE_SDK2_LIBRARY}" OR NOT EXISTS "${UNITREE_DDS_LIBRARY}" OR + NOT EXISTS "${UNITREE_DDSXX_LIBRARY}") + message(FATAL_ERROR + "Unitree SDK2 libraries were not found for ${UNITREE_ARCH} under ${UNITREE_SDK2_ROOT}") + endif() + + # CycloneDDS C++ headers live under thirdparty/include/ddscxx (e.g. + # ddscxx/dds/topic/TopicTraits.hpp), the C headers under thirdparty/include. + add_library(motrix_unitree_sdk2 STATIC IMPORTED GLOBAL) + set_target_properties(motrix_unitree_sdk2 PROPERTIES + IMPORTED_LOCATION "${UNITREE_SDK2_LIBRARY}" + INTERFACE_INCLUDE_DIRECTORIES + "${UNITREE_SDK2_ROOT}/include;${UNITREE_SDK2_ROOT}/thirdparty/include;${UNITREE_SDK2_ROOT}/thirdparty/include/ddscxx") + target_link_directories(motrix_unitree_sdk2 INTERFACE + "${UNITREE_SDK2_ROOT}/thirdparty/lib/${UNITREE_ARCH}") + target_link_libraries(motrix_unitree_sdk2 INTERFACE ddscxx ddsc Threads::Threads dl) + set(UNITREE_TARGET motrix_unitree_sdk2) + set(UNITREE_RUNTIME_LIB_DIR "${UNITREE_SDK2_ROOT}/thirdparty/lib/${UNITREE_ARCH}") +else() + set(UNITREE_TARGET unitree_sdk2) +endif() + +pybind11_add_module(_native src/backend.cpp src/bindings.cpp) +target_link_libraries(_native PRIVATE ${UNITREE_TARGET}) +# DT_RPATH, not DT_RUNPATH: the robot shells source /opt/ros/foxy, whose +# LD_LIBRARY_PATH contains CycloneDDS 0.7.0. RUNPATH is searched after +# LD_LIBRARY_PATH, so the extension would bind to 0.7.0 and fail with +# "undefined symbol: ddsi_sertype_v0". RPATH is searched first. +target_link_options(_native PRIVATE "LINKER:--disable-new-dtags") + +if(DEFINED UNITREE_RUNTIME_LIB_DIR) + set_target_properties(_native PROPERTIES + BUILD_RPATH "${UNITREE_RUNTIME_LIB_DIR}" + INSTALL_RPATH "$ORIGIN;${UNITREE_RUNTIME_LIB_DIR}") +else() + # Installed SDK2 packages expose imported DDS targets. Ask CMake to carry + # their link directories into the extension's runtime search path. + set_target_properties(_native PROPERTIES INSTALL_RPATH_USE_LINK_PATH TRUE) +endif() +install(TARGETS _native LIBRARY DESTINATION motrix_unitree_native) diff --git a/motrix_unitree_native/README.md b/motrix_unitree_native/README.md new file mode 100644 index 00000000..133cca2c --- /dev/null +++ b/motrix_unitree_native/README.md @@ -0,0 +1,38 @@ +# Motrix Unitree Native + +This package builds the pybind11 extension used by the G1 `native_cpp` hardware +transport. It owns Unitree SDK2 DDS subscription/publication, LowState CRC and +mode validation, and the 1 kHz LowCmd watchdog writer. Python receives normalized +state snapshots and sends the latest policy command at policy-loop frequency. + +Build on a machine with CMake, pybind11, and Unitree SDK2 installed: + +```bash +UNITREE_SDK2_ROOT=/opt/unitree_robotics \ + python -m pip install ./motrix_unitree_native +``` + +The build embeds the SDK2 third-party library directory as a `DT_RPATH` entry, +which the dynamic loader searches **before** `LD_LIBRARY_PATH`. That matters on +robots whose shell sources ROS: `/opt/ros/foxy/lib/*/libddsc.so.0` is CycloneDDS +0.7 and does not export the 0.10 `ddsi_sertype_v0` API, so a `DT_RUNPATH` build +would bind to 0.7 and fail with `undefined symbol: ddsi_sertype_v0`. + +If the SDK is moved after installation, export its architecture-specific +library directory before starting deployment, for example: + +```bash +export LD_LIBRARY_PATH=/opt/unitree_robotics/thirdparty/lib/x86_64:$LD_LIBRARY_PATH +``` + +`G1Backend` owns the whole low-level contract: it converts the IMU quaternion to +xyzw and normalizes it, maps canonical joints to motor slots, validates the +LowState CRC and the `mode_pr`/`mode_machine` contract, publishes at +`command_period_s` with the CRC computed outside the writer lock, and damps +(kp=0, kd=`damping_kd`) whenever the state, the command or the mode contract is +stale. Mode/CRC problems are recoverable: the backend damps and reports +unhealthy, then resumes once valid frames return. + +For a source checkout of SDK2, set `UNITREE_SDK2_ROOT` to that checkout instead. +The native transport is G1 29-DOF specific; Go2 continues to use the existing +Python SDK transport. diff --git a/motrix_unitree_native/pyproject.toml b/motrix_unitree_native/pyproject.toml new file mode 100644 index 00000000..3d6f6fee --- /dev/null +++ b/motrix_unitree_native/pyproject.toml @@ -0,0 +1,15 @@ +[build-system] +requires = ["scikit-build-core>=0.10", "pybind11>=2.13", "numpy>=1.26"] +build-backend = "scikit_build_core.build" + +[project] +name = "motrix-unitree-native" +version = "0.4.0" +description = "Native Unitree SDK2 DDS transport for Motrix deployment" +requires-python = ">=3.10,<3.14" +dependencies = ["numpy>=1.26"] + +[tool.scikit-build] +wheel.packages = ["python/motrix_unitree_native"] +build-dir = "build/{wheel_tag}" +cmake.build-type = "Release" diff --git a/motrix_unitree_native/python/motrix_unitree_native/__init__.py b/motrix_unitree_native/python/motrix_unitree_native/__init__.py new file mode 100644 index 00000000..568a1f4b --- /dev/null +++ b/motrix_unitree_native/python/motrix_unitree_native/__init__.py @@ -0,0 +1,5 @@ +"""Python package for the optional Unitree SDK2 native extension.""" + +from ._native import G1Backend + +__all__ = ["G1Backend"] diff --git a/motrix_unitree_native/src/backend.cpp b/motrix_unitree_native/src/backend.cpp new file mode 100644 index 00000000..7c382719 --- /dev/null +++ b/motrix_unitree_native/src/backend.cpp @@ -0,0 +1,416 @@ +#include "backend.hpp" + +#include +#include +#include +#include + +#include + +namespace motrix_unitree_native { + +namespace { +constexpr int kMotorCount = 29; +constexpr int kMotorSlotCount = 35; +constexpr float kPositionStop = 0.0F; +constexpr float kVelocityStop = 0.0F; +// One dropped DDS sample is a hiccup, not a failure: only a sustained run of +// failed publishes makes the backend unhealthy. +constexpr int kPublishFailureLimit = 20; +} // namespace + +G1Backend::G1Backend( + std::string network_interface, int domain_id, std::string lowcmd_topic, + std::string lowstate_topic, std::vector motor_indices, int mode_pr, + int expected_mode_machine, int motor_mode, double damping_kd, + double command_period_s, double command_timeout_s, double state_timeout_s, + bool validate_crc, int subscriber_queue_depth) + : network_interface_(std::move(network_interface)), + domain_id_(domain_id), + lowcmd_topic_(std::move(lowcmd_topic)), + lowstate_topic_(std::move(lowstate_topic)), + mode_pr_(mode_pr), + expected_mode_machine_(expected_mode_machine), + motor_mode_(motor_mode), + damping_kd_(static_cast(damping_kd)), + command_period_(std::chrono::duration_cast( + std::chrono::duration(command_period_s))), + command_timeout_(std::chrono::duration_cast( + std::chrono::duration(command_timeout_s))), + state_timeout_(std::chrono::duration_cast( + std::chrono::duration(state_timeout_s))), + validate_crc_(validate_crc), + subscriber_queue_depth_(subscriber_queue_depth) { + if (motor_indices.size() != kMotorCount) { + throw std::invalid_argument("G1 native backend requires exactly 29 motor indices"); + } + std::copy(motor_indices.begin(), motor_indices.end(), motor_indices_.begin()); + std::array seen{}; + for (const int index : motor_indices_) { + if (index < 0 || index >= kMotorSlotCount || seen[static_cast(index)]) { + throw std::invalid_argument("G1 motor indices must be unique values in [0, 34]"); + } + seen[static_cast(index)] = true; + } + if (command_period_ <= std::chrono::nanoseconds::zero() || + command_timeout_ <= std::chrono::nanoseconds::zero() || + state_timeout_ <= std::chrono::nanoseconds::zero()) { + throw std::invalid_argument("native backend timing values must be positive"); + } + if (!std::isfinite(damping_kd) || damping_kd_ <= 0.0F) { + throw std::invalid_argument("native backend damping_kd must be positive and finite"); + } +} + +G1Backend::~G1Backend() { close(); } + +std::int64_t G1Backend::now_ns() { + return std::chrono::duration_cast( + std::chrono::steady_clock::now().time_since_epoch()) + .count(); +} + +std::uint32_t G1Backend::crc32_core(std::uint32_t* ptr, std::uint32_t length) { + // Unitree wire CRC: polynomial 0x04c11db7, init 0xFFFFFFFF, over + // (sizeof(message) >> 2) - 1 little-endian words (the trailing crc word is + // excluded). Implemented here so the build does not depend on an optional + // SDK header. + std::uint32_t crc = 0xFFFFFFFFU; + constexpr std::uint32_t kPolynomial = 0x04c11db7U; + for (std::uint32_t i = 0; i < length; ++i) { + std::uint32_t data = ptr[i]; + std::uint32_t mask = 1U << 31; + for (int bit = 0; bit < 32; ++bit) { + if ((crc & 0x80000000U) != 0U) { + crc = (crc << 1) ^ kPolynomial; + } else { + crc <<= 1; + } + if ((data & mask) != 0U) { + crc ^= kPolynomial; + } + mask >>= 1; + } + } + return crc; +} + +void G1Backend::open(double connect_timeout_s) { + if (connect_timeout_s <= 0.0 || !std::isfinite(connect_timeout_s)) { + throw std::invalid_argument("connect_timeout_s must be positive and finite"); + } + { + std::lock_guard lock(mutex_); + if (opened_ && !closed_) { + throw std::runtime_error("native Unitree backend is already open"); + } + unitree::robot::ChannelFactory::Instance()->Init(domain_id_, network_interface_); + subscriber_ = std::make_shared(lowstate_topic_); + subscriber_->InitChannel( + [this](const void* message) { lowstate_handler(message); }, subscriber_queue_depth_); + publisher_ = std::make_shared(lowcmd_topic_); + publisher_->InitChannel(); + initialize_command_locked(); + opened_ = true; + closed_ = false; + stopped_ = false; + enabled_ = false; + state_error_.clear(); + publish_error_.clear(); + publish_failures_ = 0; + have_state_ = false; + mode_ok_ = false; + invalid_mode_at_connect_ = false; + sequence_ = 0; + last_command_update_ns_ = now_ns(); + } + + std::unique_lock lock(mutex_); + const auto deadline = std::chrono::steady_clock::now() + + std::chrono::duration_cast( + std::chrono::duration(connect_timeout_s)); + while (!have_state_ && !invalid_mode_at_connect_) { + if (state_condition_.wait_until(lock, deadline) == std::cv_status::timeout) { + lock.unlock(); + close(); + throw NativeTimeoutError("no valid G1 LowState received before connect timeout"); + } + } + if (invalid_mode_at_connect_) { + lock.unlock(); + close(); + throw std::runtime_error("G1 LowState mode_pr/mode_machine does not match the configured contract"); + } + lock.unlock(); + + writer_stop_.store(false); + writer_thread_ = std::thread(&G1Backend::command_writer_loop, this); +} + +void G1Backend::lowstate_handler(const void* message) { + const auto* incoming = static_cast(message); + if (incoming == nullptr) return; + LowState state = *incoming; + if (validate_crc_ && !valid_crc(state)) return; + if (!valid_mode(state)) { + // Recoverable: the robot may return to low-level mode. Keep publishing + // damping while unhealthy and clear this on the next contract-valid frame. + std::lock_guard lock(mutex_); + mode_ok_ = false; + if (!have_state_) invalid_mode_at_connect_ = true; + state_error_ = "G1 LowState mode_pr/mode_machine does not match the configured contract"; + state_condition_.notify_all(); + return; + } + + StateSnapshot snapshot; + snapshot.receive_time_ns = now_ns(); + for (int i = 0; i < kMotorCount; ++i) { + const auto motor_index = static_cast(motor_indices_[static_cast(i)]); + snapshot.joint_position[static_cast(i)] = state.motor_state()[motor_index].q(); + snapshot.joint_velocity[static_cast(i)] = state.motor_state()[motor_index].dq(); + } + const auto& q = state.imu_state().quaternion(); + const float w = q[0]; + const float x = q[1]; + const float y = q[2]; + const float z = q[3]; + const float norm = std::sqrt(w * w + x * x + y * y + z * z); + if (!std::isfinite(norm) || norm <= 1.0e-8F) { + // Drop the sample instead of latching an error: one corrupt IMU frame must + // not end the session. + std::lock_guard lock(mutex_); + state_error_ = "G1 LowState contains an invalid IMU quaternion"; + state_condition_.notify_all(); + return; + } + snapshot.quaternion_xyzw = {x / norm, y / norm, z / norm, w / norm}; + for (int i = 0; i < 3; ++i) { + snapshot.gyro[static_cast(i)] = state.imu_state().gyroscope()[i]; + snapshot.accelerometer[static_cast(i)] = state.imu_state().accelerometer()[i]; + } + const auto& remote = state.wireless_remote(); + const auto remote_count = std::min(snapshot.wireless_remote.size(), remote.size()); + for (std::size_t i = 0; i < remote_count; ++i) snapshot.wireless_remote[i] = remote[i]; + + { + std::lock_guard lock(mutex_); + snapshot.sequence = ++sequence_; + latest_state_ = snapshot; + have_state_ = true; + mode_ok_ = true; + state_error_.clear(); + last_state_receive_ns_ = snapshot.receive_time_ns; + last_communication_ns_ = snapshot.receive_time_ns; + } + state_condition_.notify_all(); +} + +bool G1Backend::valid_crc(const LowState& state) const { + auto copy = state; + return state.crc() == crc32_core(reinterpret_cast(©), + (sizeof(LowState) >> 2U) - 1U); +} + +bool G1Backend::valid_mode(const LowState& state) const { + if (mode_pr_ >= 0 && state.mode_pr() != mode_pr_) return false; + return expected_mode_machine_ < 0 || state.mode_machine() == expected_mode_machine_; +} + +StateSnapshot G1Backend::read_state(double timeout_s, std::int64_t after_sequence) { + if (timeout_s <= 0.0 || !std::isfinite(timeout_s)) { + throw std::invalid_argument("state timeout must be positive and finite"); + } + std::unique_lock lock(mutex_); + const auto deadline = std::chrono::steady_clock::now() + + std::chrono::duration_cast( + std::chrono::duration(timeout_s)); + const auto fresh = [this, after_sequence] { + return have_state_ && + (after_sequence < 0 || static_cast(latest_state_.sequence) > after_sequence); + }; + while (!fresh()) { + if (state_condition_.wait_until(lock, deadline) == std::cv_status::timeout) { + std::string message = "no fresh G1 LowState received before timeout"; + const std::string& reason = !state_error_.empty() ? state_error_ : publish_error_; + if (!reason.empty()) message += ": " + reason; + throw NativeTimeoutError(message); + } + } + return latest_state_; +} + +void G1Backend::write_command(const std::array& position, + const std::array& velocity, + const std::array& torque, + const std::array& kp, + const std::array& kd) { + std::lock_guard lock(mutex_); + if (!opened_ || closed_) throw std::runtime_error("native Unitree backend is not open"); + for (int i = 0; i < kMotorCount; ++i) { + auto& motor = command_.motor_cmd()[static_cast(motor_indices_[static_cast(i)])]; + motor.mode() = motor_mode_; + motor.q() = position[static_cast(i)]; + motor.dq() = velocity[static_cast(i)]; + motor.kp() = kp[static_cast(i)]; + motor.kd() = kd[static_cast(i)]; + motor.tau() = torque[static_cast(i)]; + } + enabled_ = true; + stopped_ = false; + last_command_update_ns_ = now_ns(); +} + +void G1Backend::write_torque(const std::array& torque) { + std::array zeros{}; + write_command(zeros, zeros, torque, zeros, zeros); +} + +void G1Backend::set_enabled(bool enabled) { + std::lock_guard lock(mutex_); + enabled_ = enabled; + stopped_ = false; + if (enabled) { + // Never publish a kp=0/kd=0 frame between enabling and the first command. + set_damping_locked(); + } + last_command_update_ns_ = now_ns(); +} + +void G1Backend::stop() { + LowCmd outgoing; + { + std::lock_guard lock(mutex_); + enabled_ = false; + stopped_ = true; + set_damping_locked(); + last_command_update_ns_ = now_ns(); + outgoing = command_; + } + // Publish the first damping frame synchronously. The periodic writer keeps + // repeating it afterwards, but shutdown should not depend on its next tick. + publish(outgoing); +} + +void G1Backend::close() { + LowCmd outgoing; + bool publish_damping = false; + { + std::lock_guard lock(mutex_); + if (closed_) return; + if (opened_) { + enabled_ = false; + stopped_ = true; + set_damping_locked(); + outgoing = command_; + publish_damping = true; + } + writer_stop_.store(true); + } + if (publish_damping) publish(outgoing); + if (writer_thread_.joinable()) writer_thread_.join(); + std::lock_guard lock(mutex_); + publisher_.reset(); + subscriber_.reset(); + opened_ = false; + closed_ = true; +} + +bool G1Backend::healthy() const { + std::lock_guard lock(mutex_); + if (!opened_ || closed_ || stopped_) return false; + if (!state_error_.empty() || !publish_error_.empty()) return false; + return have_state_ && mode_ok_ && now_ns() - last_state_receive_ns_ <= state_timeout_.count(); +} + +std::string G1Backend::health_reason() const { + std::lock_guard lock(mutex_); + if (!publish_error_.empty()) return publish_error_; + if (!state_error_.empty()) return state_error_; + if (closed_) return "backend is closed"; + if (!opened_) return "backend is not open"; + if (stopped_) return "backend is stopped"; + if (!have_state_ || now_ns() - last_state_receive_ns_ > state_timeout_.count()) return "LowState is stale"; + return ""; +} + +std::int64_t G1Backend::last_communication_ns() const { + std::lock_guard lock(mutex_); + return last_communication_ns_; +} + +void G1Backend::initialize_command_locked() { + if (mode_pr_ >= 0) command_.mode_pr() = mode_pr_; + if (expected_mode_machine_ >= 0) command_.mode_machine() = expected_mode_machine_; + for (std::size_t i = 0; i < command_.motor_cmd().size(); ++i) { + auto& motor = command_.motor_cmd()[i]; + motor.mode() = 0; + motor.q() = kPositionStop; + motor.dq() = kVelocityStop; + motor.kp() = 0.0F; + motor.kd() = 0.0F; + motor.tau() = 0.0F; + } + for (const int index : motor_indices_) { + auto& motor = command_.motor_cmd()[static_cast(index)]; + motor.mode() = motor_mode_; + // The first frame published after open()/enable() must already damp. + motor.kd() = damping_kd_; + } +} + +void G1Backend::set_damping_locked() { + for (int i = 0; i < kMotorCount; ++i) { + const auto index = static_cast(motor_indices_[static_cast(i)]); + auto& motor = command_.motor_cmd()[index]; + motor.mode() = motor_mode_; + motor.q() = have_state_ ? latest_state_.joint_position[static_cast(i)] : 0.0F; + motor.dq() = 0.0F; + motor.kp() = 0.0F; + motor.kd() = damping_kd_; + motor.tau() = 0.0F; + } +} + +bool G1Backend::publish(const LowCmd& command) { + const std::shared_ptr publisher = publisher_; + if (!publisher) return false; + LowCmd message = command; + message.crc() = crc32_core(reinterpret_cast(&message), + (sizeof(LowCmd) >> 2U) - 1U); + const bool ok = publisher->Write(message, 0); + std::lock_guard lock(mutex_); + if (ok) { + last_communication_ns_ = now_ns(); + publish_failures_ = 0; + publish_error_.clear(); + } else if (++publish_failures_ >= kPublishFailureLimit) { + publish_error_ = "G1 LowCmd DDS publish failed"; + } + return ok; +} + +void G1Backend::command_writer_loop() { + auto next = std::chrono::steady_clock::now(); + while (!writer_stop_.load()) { + next += command_period_; + LowCmd outgoing; + { + std::lock_guard lock(mutex_); + const auto now = now_ns(); + const bool state_stale = !have_state_ || now - last_state_receive_ns_ > state_timeout_.count(); + const bool command_stale = now - last_command_update_ns_ > command_timeout_.count(); + if (!enabled_ || stopped_ || !mode_ok_ || state_stale || command_stale) { + set_damping_locked(); + } + outgoing = command_; + } + // CRC and the DDS write happen outside the lock: the policy loop and + // read_state() must never wait on transport I/O. + publish(outgoing); + std::this_thread::sleep_until(next); + if (std::chrono::steady_clock::now() > next + command_period_) next = std::chrono::steady_clock::now(); + } +} + +} // namespace motrix_unitree_native diff --git a/motrix_unitree_native/src/backend.hpp b/motrix_unitree_native/src/backend.hpp new file mode 100644 index 00000000..56282fb2 --- /dev/null +++ b/motrix_unitree_native/src/backend.hpp @@ -0,0 +1,124 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +namespace motrix_unitree_native { + +/// Raised when no fresh LowState (or no first LowState) arrives in time. +/// Registered as a subclass of Python ``TimeoutError``. +class NativeTimeoutError : public std::runtime_error { + public: + explicit NativeTimeoutError(const std::string& message) : std::runtime_error(message) {} +}; + +struct StateSnapshot { + std::uint64_t sequence = 0; + std::int64_t receive_time_ns = 0; + std::array joint_position{}; + std::array joint_velocity{}; + std::array quaternion_xyzw{}; + std::array gyro{}; + std::array accelerometer{}; + std::array wireless_remote{}; +}; + +class G1Backend { + public: + G1Backend( + std::string network_interface, int domain_id, std::string lowcmd_topic, + std::string lowstate_topic, std::vector motor_indices, int mode_pr, + int expected_mode_machine, int motor_mode, double damping_kd, + double command_period_s, double command_timeout_s, double state_timeout_s, + bool validate_crc, int subscriber_queue_depth); + ~G1Backend(); + + void open(double connect_timeout_s); + StateSnapshot read_state(double timeout_s, std::int64_t after_sequence); + void write_command(const std::array& position, + const std::array& velocity, + const std::array& torque, + const std::array& kp, + const std::array& kd); + void write_torque(const std::array& torque); + void set_enabled(bool enabled); + void stop(); + void close(); + + bool healthy() const; + std::string health_reason() const; + std::int64_t last_communication_ns() const; + + private: + using LowCmd = unitree_hg::msg::dds_::LowCmd_; + using LowState = unitree_hg::msg::dds_::LowState_; + using Publisher = unitree::robot::ChannelPublisher; + using Subscriber = unitree::robot::ChannelSubscriber; + + static std::int64_t now_ns(); + static std::uint32_t crc32_core(std::uint32_t* ptr, std::uint32_t length); + void lowstate_handler(const void* message); + void command_writer_loop(); + void initialize_command_locked(); + void set_damping_locked(); + /// CRC and publish one command without holding mutex_. + bool publish(const LowCmd& command); + bool valid_crc(const LowState& state) const; + bool valid_mode(const LowState& state) const; + + std::string network_interface_; + int domain_id_; + std::string lowcmd_topic_; + std::string lowstate_topic_; + std::array motor_indices_{}; + int mode_pr_; + int expected_mode_machine_; + int motor_mode_; + float damping_kd_; + std::chrono::nanoseconds command_period_; + std::chrono::nanoseconds command_timeout_; + std::chrono::nanoseconds state_timeout_; + bool validate_crc_; + int subscriber_queue_depth_; + + std::shared_ptr publisher_; + std::shared_ptr subscriber_; + LowCmd command_{}; + + mutable std::mutex mutex_; + std::condition_variable state_condition_; + StateSnapshot latest_state_{}; + bool have_state_ = false; + bool mode_ok_ = false; + bool invalid_mode_at_connect_ = false; + std::uint64_t sequence_ = 0; + std::int64_t last_state_receive_ns_ = 0; + std::int64_t last_command_update_ns_ = 0; + std::int64_t last_communication_ns_ = 0; + std::string state_error_; + std::string publish_error_; + int publish_failures_ = 0; + bool enabled_ = false; + bool stopped_ = false; + bool opened_ = false; + bool closed_ = false; + + std::atomic writer_stop_{false}; + std::thread writer_thread_; +}; + +} // namespace motrix_unitree_native diff --git a/motrix_unitree_native/src/bindings.cpp b/motrix_unitree_native/src/bindings.cpp new file mode 100644 index 00000000..8fb9c225 --- /dev/null +++ b/motrix_unitree_native/src/bindings.cpp @@ -0,0 +1,116 @@ +#include "backend.hpp" + +#include +#include +#include + +#include +#include +#include + +namespace py = pybind11; +using motrix_unitree_native::G1Backend; +using motrix_unitree_native::NativeTimeoutError; +using motrix_unitree_native::StateSnapshot; + +namespace { + +template +std::array array_from_numpy( + const py::array_t& value, + const char* name) { + if (value.ndim() != 1 || static_cast(value.shape(0)) != N) { + throw std::invalid_argument(std::string(name) + " has an unexpected shape"); + } + std::array result{}; + std::memcpy(result.data(), value.data(), sizeof(float) * N); + for (const float item : result) { + if (!std::isfinite(item)) throw std::invalid_argument(std::string(name) + " contains a non-finite value"); + } + return result; +} + +py::array_t array_to_numpy(const float* data, std::size_t count) { + py::array_t result(count); + std::memcpy(result.mutable_data(), data, sizeof(float) * count); + return result; +} + +py::dict snapshot_to_dict(const StateSnapshot& snapshot) { + py::dict result; + result["sequence"] = snapshot.sequence; + result["receive_time_ns"] = snapshot.receive_time_ns; + result["joint_position"] = array_to_numpy(snapshot.joint_position.data(), snapshot.joint_position.size()); + result["joint_velocity"] = array_to_numpy(snapshot.joint_velocity.data(), snapshot.joint_velocity.size()); + result["quaternion_xyzw"] = array_to_numpy(snapshot.quaternion_xyzw.data(), snapshot.quaternion_xyzw.size()); + result["gyro"] = array_to_numpy(snapshot.gyro.data(), snapshot.gyro.size()); + result["accelerometer"] = array_to_numpy(snapshot.accelerometer.data(), snapshot.accelerometer.size()); + result["wireless_remote"] = py::bytes( + reinterpret_cast(snapshot.wireless_remote.data()), snapshot.wireless_remote.size()); + return result; +} + +} // namespace + +PYBIND11_MODULE(_native, module) { + module.doc() = "Native Unitree SDK2 transport for Motrix deployment"; + + // Keep the Python contract explicit: callers can catch builtins.TimeoutError. + py::register_exception(module, "TimeoutError", PyExc_TimeoutError); + + py::class_(module, "G1Backend") + .def( + py::init, int, int, int, double, double, + double, double, bool, int>(), + py::arg("network_interface"), py::arg("domain_id"), py::arg("lowcmd_topic"), + py::arg("lowstate_topic"), py::arg("motor_indices"), py::arg("mode_pr") = -1, + py::arg("expected_mode_machine") = -1, py::arg("motor_mode") = 1, + py::arg("damping_kd") = 3.0, py::arg("command_period_s") = 0.001, + py::arg("command_timeout_s") = 0.1, py::arg("state_timeout_s") = 0.1, + py::arg("validate_crc") = true, py::arg("subscriber_queue_depth") = 10) + .def("open", [](G1Backend& backend, double connect_timeout_s) { + py::gil_scoped_release release; + backend.open(connect_timeout_s); + }, py::arg("connect_timeout_s") = 5.0) + .def("read_state", [](G1Backend& backend, double timeout_s, std::int64_t after_sequence) { + StateSnapshot snapshot; + { + py::gil_scoped_release release; + snapshot = backend.read_state(timeout_s, after_sequence); + } + return snapshot_to_dict(snapshot); + }, py::arg("timeout_s") = 0.1, py::arg("after_sequence") = -1) + .def("write_command", []( + G1Backend& backend, + const py::array_t& position, + const py::array_t& velocity, + const py::array_t& torque, + const py::array_t& kp, + const py::array_t& kd) { + backend.write_command( + array_from_numpy<29>(position, "joint_position"), array_from_numpy<29>(velocity, "joint_velocity"), + array_from_numpy<29>(torque, "feedforward_torque"), array_from_numpy<29>(kp, "kp"), + array_from_numpy<29>(kd, "kd")); + }, py::arg("joint_position"), py::arg("joint_velocity"), py::arg("feedforward_torque"), py::arg("kp"), + py::arg("kd")) + .def("write_torque", [](G1Backend& backend, + const py::array_t& torque) { + backend.write_torque(array_from_numpy<29>(torque, "torque")); + }) + .def("set_enabled", &G1Backend::set_enabled, py::arg("enabled")) + .def("stop", [](G1Backend& backend) { + py::gil_scoped_release release; + backend.stop(); + }) + .def("close", [](G1Backend& backend) { + py::gil_scoped_release release; + backend.close(); + }) + .def("health", [](const G1Backend& backend) { + py::dict result; + result["healthy"] = backend.healthy(); + result["reason"] = backend.health_reason(); + result["last_successful_communication_ns"] = backend.last_communication_ns(); + return result; + }); +} diff --git a/pyproject.toml b/pyproject.toml index 89367e5d..4187605a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -22,7 +22,7 @@ dependencies = [ rslrl = ["motrix-rl-rslrl==0.4.0"] skrl-jax = ["motrix-rl-skrl[jax]==0.4.0"] unitree = [ - "motrix-deploy-unitree==0.4.0", + "motrix-deploy-unitree[native]==0.4.0", ] docs = [ "sphinx", @@ -70,6 +70,7 @@ members = [ "motrix_deploy_mujoco", "motrix_deploy_motrixsim", "motrix_deploy_unitree", + "motrix_unitree_native", "motrix_deploy_tasks", "motrix_env_core", "motrix_env_motrixsim", @@ -102,6 +103,7 @@ motrix-deploy = { workspace = true } motrix-deploy-mujoco = { workspace = true } motrix-deploy-motrixsim = { workspace = true } motrix-deploy-unitree = { workspace = true } +motrix-unitree-native = { workspace = true } motrix-deploy-tasks = { workspace = true } motrix-env-motrixsim = { workspace = true } motrix-env-mujoco = { workspace = true } diff --git a/tests/test_workspace_versions.py b/tests/test_workspace_versions.py index 627601bd..b2624bf2 100644 --- a/tests/test_workspace_versions.py +++ b/tests/test_workspace_versions.py @@ -3,7 +3,9 @@ """Workspace release version contracts.""" +import ast import re +from importlib import metadata from pathlib import Path from packaging.requirements import Requirement @@ -18,7 +20,7 @@ def _project_field(path: Path, field: str) -> str: return match.group(1) -def _workspace_pyprojects() -> list[tuple[Path, str, str]]: +def _workspace_member_dirs() -> list[Path]: root_pyproject = ROOT / "pyproject.toml" members_match = re.search( r"\[tool\.uv\.workspace\]\s*members\s*=\s*\[(.*?)\]", @@ -26,7 +28,11 @@ def _workspace_pyprojects() -> list[tuple[Path, str, str]]: re.DOTALL, ) assert members_match is not None, "Missing [tool.uv.workspace] members in root pyproject.toml" - members = re.findall(r'"([^"]+)"', members_match.group(1)) + return [ROOT / member for member in re.findall(r'"([^"]+)"', members_match.group(1))] + + +def _workspace_pyprojects() -> list[tuple[Path, str, str]]: + root_pyproject = ROOT / "pyproject.toml" projects = [ ( root_pyproject, @@ -34,8 +40,8 @@ def _workspace_pyprojects() -> list[tuple[Path, str, str]]: _project_field(root_pyproject, "version"), ) ] - for member in members: - pyproject = ROOT / member / "pyproject.toml" + for member in _workspace_member_dirs(): + pyproject = member / "pyproject.toml" projects.append((pyproject, _project_field(pyproject, "name"), _project_field(pyproject, "version"))) return projects @@ -99,3 +105,60 @@ def test_workspace_member_dependencies_are_pinned_to_workspace_version(): f"{pyproject} must pin {requirement.name} to the workspace version " f"{version}; got {requirement.specifier}" ) + + +def _declared_source_versions() -> list[tuple[Path, str, ast.expr]]: + """(initializer, distribution name, assigned value) for every package declaring ``__version__``.""" + declared = [] + for member in _workspace_member_dirs(): + distribution = _project_field(member / "pyproject.toml", "name") + for initializer in sorted(member.glob("src/*/__init__.py")): + for node in ast.parse(initializer.read_text()).body: + if not isinstance(node, ast.Assign): + continue + if any(isinstance(target, ast.Name) and target.id == "__version__" for target in node.targets): + declared.append((initializer, distribution, node.value)) + return declared + + +def _installed_version(distribution: str) -> str | None: + try: + return metadata.version(distribution) + except metadata.PackageNotFoundError: + return None + + +def test_source_versions_track_the_installed_distribution(): + """``__version__`` must come from installed metadata, never a copied literal. + + ``cz bump`` only rewrites files matched by the root ``version_files`` + patterns, which do not cover package initializers, so a hardcoded literal + drifts silently from the release version. + """ + projects = _workspace_projects() + declared = _declared_source_versions() + assert declared, "Expected at least one workspace package to declare __version__" + + for initializer, distribution, value in declared: + assert isinstance(value, ast.Call), ( + f"{initializer} must derive __version__ from installed metadata, got {ast.unparse(value)}" + ) + # Accept both `version(...)` after `from importlib.metadata import version` + # and the module-qualified `metadata.version(...)`; upstream uses the former. + reader = value.func.id if isinstance(value.func, ast.Name) else getattr(value.func, "attr", None) + assert reader == "version", f"{initializer} must read the metadata version function, got {ast.unparse(value)}" + assert len(value.args) == 1, ( + f"{initializer} must read metadata.version(), got {ast.unparse(value)}" + ) + assert isinstance(value.args[0], ast.Constant), ( + f"{initializer} must pass a literal distribution name, got {ast.unparse(value)}" + ) + assert value.args[0].value == distribution, ( + f"{initializer} reads the metadata version of {value.args[0].value!r}, " + f"but its distribution is {distribution!r}" + ) + installed = _installed_version(distribution) + assert installed == projects[distribution], ( + f"{distribution} is installed as {installed!r}, expected the workspace version " + f"{projects[distribution]!r}; reinstall it with the matching install command" + ) diff --git a/uv.lock b/uv.lock index 50dd5a1a..4573fb56 100644 --- a/uv.lock +++ b/uv.lock @@ -116,6 +116,7 @@ members = [ "motrix-rl-rslrl", "motrix-rl-skrl", "motrix-robots", + "motrix-unitree-native", "motrixlab", ] @@ -1439,14 +1440,21 @@ dependencies = [ { name = "unitree-sdk2py" }, ] +[package.optional-dependencies] +native = [ + { name = "motrix-unitree-native" }, +] + [package.metadata] requires-dist = [ { name = "hydra-core", specifier = ">=1.3,<1.4" }, { name = "motrix-deploy", editable = "motrix_deploy" }, { name = "motrix-env-core", editable = "motrix_env_core" }, + { name = "motrix-unitree-native", marker = "extra == 'native'", editable = "motrix_unitree_native" }, { name = "numpy", specifier = ">=1.26" }, { name = "unitree-sdk2py", git = "https://github.com/motphys-developers/unitree_sdk2_python?rev=ff87e731174f7258e0d09980897c55116634939a" }, ] +provides-extras = ["native"] [[package]] name = "motrix-env-core" @@ -1608,7 +1616,7 @@ tbb = [ { name = "motrix-env-core", extra = ["tbb"] }, ] unitree = [ - { name = "motrix-deploy-unitree" }, + { name = "motrix-deploy-unitree", extra = ["native"] }, ] [package.dev-dependencies] @@ -1636,7 +1644,7 @@ requires-dist = [ { name = "motrix-deploy-motrixsim", editable = "motrix_deploy_motrixsim" }, { name = "motrix-deploy-mujoco", editable = "motrix_deploy_mujoco" }, { name = "motrix-deploy-tasks", editable = "motrix_deploy_tasks" }, - { name = "motrix-deploy-unitree", marker = "extra == 'unitree'", editable = "motrix_deploy_unitree" }, + { name = "motrix-deploy-unitree", extras = ["native"], marker = "extra == 'unitree'", editable = "motrix_deploy_unitree" }, { name = "motrix-env-core", extras = ["tbb"], marker = "extra == 'tbb'", editable = "motrix_env_core" }, { name = "motrix-env-motrixsim", editable = "motrix_env_motrixsim" }, { name = "motrix-env-mujoco", editable = "motrix_env_mujoco" }, @@ -1814,6 +1822,17 @@ dependencies = [ [package.metadata] requires-dist = [{ name = "motrix-env-core", editable = "motrix_env_core" }] +[[package]] +name = "motrix-unitree-native" +version = "0.4.0" +source = { editable = "motrix_unitree_native" } +dependencies = [ + { name = "numpy" }, +] + +[package.metadata] +requires-dist = [{ name = "numpy", specifier = ">=1.26" }] + [[package]] name = "motrixlab" version = "0.4.0" From 7b61623ad9bbb9cdcc9964c85bd43e9982f70dd0 Mon Sep 17 00:00:00 2001 From: MrHu <1962951972@qq.com> Date: Mon, 19 Oct 2026 17:21:01 +0800 Subject: [PATCH 6/9] feat(envs): export G1 walk deployment profile --- .../src/motrix_envs/deploy/__init__.py | 2 + motrix_envs/src/motrix_envs/deploy/g1_walk.py | 176 ++++++++++++++++++ 2 files changed, 178 insertions(+) create mode 100644 motrix_envs/src/motrix_envs/deploy/g1_walk.py diff --git a/motrix_envs/src/motrix_envs/deploy/__init__.py b/motrix_envs/src/motrix_envs/deploy/__init__.py index f891b098..507eefca 100644 --- a/motrix_envs/src/motrix_envs/deploy/__init__.py +++ b/motrix_envs/src/motrix_envs/deploy/__init__.py @@ -7,9 +7,11 @@ def register() -> None: """Register the built-in environment-to-profile compiler mappings.""" from motrix_deploy.profile import register_profile_compiler + from motrix_envs.deploy.g1_walk import build_g1_walk_profile from motrix_envs.deploy.g1_wbt import build_g1_wbt_profile from motrix_envs.deploy.go2_walk import build_go2_walk_profile register_profile_compiler("go2-walk-flat", build_go2_walk_profile) register_profile_compiler("go2-walk-rough", build_go2_walk_profile) register_profile_compiler("g1-wbt-dance", build_g1_wbt_profile) + register_profile_compiler("g1-walk-flat", build_g1_walk_profile) diff --git a/motrix_envs/src/motrix_envs/deploy/g1_walk.py b/motrix_envs/src/motrix_envs/deploy/g1_walk.py new file mode 100644 index 00000000..48c6f540 --- /dev/null +++ b/motrix_envs/src/motrix_envs/deploy/g1_walk.py @@ -0,0 +1,176 @@ +# Copyright Motphys Technology Co., Ltd. 2025, 2026 +# SPDX-License-Identifier: Apache-2.0 + +"""Compile the G1 flat-ground walking environment into its deploy contract.""" + +import math + +import numpy as np +from motrix_robots.unitree import UnitreeG129Dof + +from motrix_deploy.artifact import ControlSpec +from motrix_deploy.profile import DeploymentProfile +from motrix_deploy_tasks.tasks.g1_walk import G1WalkTaskSpec +from motrix_env_core import registry +from motrix_env_core.mdp.action import JointPositionActionTerm +from motrix_envs.deploy.robot import build_robot_model, build_robot_spec, read_position_servo_gains +from motrix_envs.locomotion.humanoid.cfg import HumanoidVelocityTrackingManagerEnvCfg + +_ACTION_TERM_NAME = "joint_position" +_COMMAND_TERM_NAME = "walk" + +# ``WalkCommand._lane_phase`` uses this threshold to pin both phase lanes +# while the planar velocity command is effectively zero. Keep it explicit in +# the exported contract rather than making the deployment task guess it. +_STANDING_COMMAND_THRESHOLD = 0.01 + +# Deployment uses one deterministic pair of antiphase clocks. Training adds a +# random common phase at reset, but that reset-only augmentation is not an +# operator/runtime input and therefore is not exported. +_GAIT_PHASE_OFFSETS_RAD = (0.0, math.pi) + + +def build_g1_walk_profile(env_name: str) -> DeploymentProfile: + """Compile the registered G1 walk task into canonical artifact data. + + The environment is constructed once so the compiler reads the exact + manager-generated action space, observation size, actuator order, and + per-joint action scales used by training. Values written to the artifact + are always reordered/validated against ``RobotSpec.joint_names``. + + ``G1WalkTaskSpec`` is deliberately implemented in the deployment package, + not here. Until that schema declares the fields assembled below this + function fails before emitting an incomplete artifact. + """ + + if env_name != "g1-walk-flat": + raise ValueError(f"G1 walk profile supports only 'g1-walk-flat', got {env_name!r}") + + env = registry.make(env_name, num_envs=1, mode="train") + cfg = env.cfg + if not isinstance(cfg, HumanoidVelocityTrackingManagerEnvCfg): + raise TypeError(f"Expected HumanoidVelocityTrackingManagerEnvCfg, got {type(cfg).__name__}") + + robot_cfg = cfg.scene.objs.robot + if not isinstance(robot_cfg, UnitreeG129Dof): + raise TypeError(f"Expected UnitreeG129Dof, got {type(robot_cfg).__name__}") + + model = build_robot_model(robot_cfg) + robot = build_robot_spec(robot_cfg, key_pose_name="default", model=model) + if robot.joint_count != 29: + raise ValueError(f"G1 29-DOF deployment requires 29 canonical joints, got {robot.joint_count}") + kp, kd = read_position_servo_gains(model, robot.joint_names) + + action_term = _single_joint_position_action_term(env) + action_joint_names = tuple(actuator.target_name for actuator in env.model.actuators) + if action_joint_names != robot.joint_names: + raise ValueError( + "G1 walk policy actuator targets must exactly match canonical robot joint order: " + f"policy={action_joint_names}, robot={robot.joint_names}" + ) + + action_shape = env.action_space.shape + observation_shape = env.policy_observation_space.shape + expected_action_shape = (robot.joint_count,) + if action_shape != expected_action_shape: + raise ValueError(f"G1 walk action space must have shape {expected_action_shape}, got {action_shape}") + if len(observation_shape) != 1 or observation_shape[0] <= 0: + raise ValueError(f"G1 walk policy observation space must be one non-empty vector, got {observation_shape}") + + action_state = action_term.state + _assert_vector("action default angles", action_state.default_angles, robot.joint_count) + _assert_vector("action scales", action_state.action_scales, robot.joint_count, non_negative=True) + _assert_vector("action lower bounds", env.action_space.low, robot.joint_count) + _assert_vector("action upper bounds", env.action_space.high, robot.joint_count) + if not np.allclose(action_state.default_angles, robot.default_joint_position, atol=1e-6, rtol=0.0): + raise ValueError("G1 walk action default angles do not match RobotSpec.default_joint_position") + if not np.allclose(action_state.joint_lower, robot.position_lower, atol=1e-6, rtol=0.0): + raise ValueError("G1 walk action lower joint limits do not match RobotSpec.position_lower") + if not np.allclose(action_state.joint_upper, robot.position_upper, atol=1e-6, rtol=0.0): + raise ValueError("G1 walk action upper joint limits do not match RobotSpec.position_upper") + + command_cfg = cfg.commands.walk + command_bounds = np.asarray(command_cfg.vel_limit, dtype=np.float32) + if command_bounds.shape != (2, 3) or not np.all(np.isfinite(command_bounds)): + raise ValueError(f"G1 walk velocity limits must contain finite lower/upper (vx, vy, wz), got {command_bounds}") + if np.any(command_bounds[0] > 0.0) or np.any(command_bounds[1] < 0.0): + raise ValueError("G1 walk velocity command range must contain zero on every axis") + if np.any(command_bounds[0] > command_bounds[1]): + raise ValueError("G1 walk velocity command lower bounds must not exceed upper bounds") + if not np.isfinite(command_cfg.gait_period) or command_cfg.gait_period <= 0.0: + raise ValueError(f"G1 walk gait period must be positive and finite, got {command_cfg.gait_period}") + + policy_obs = cfg.observations.policy + if policy_obs.command.command_name != _COMMAND_TERM_NAME: + raise ValueError( + f"G1 walk policy command observation must read {_COMMAND_TERM_NAME!r}, " + f"got {policy_obs.command.command_name!r}" + ) + if policy_obs.actions.action_name != _ACTION_TERM_NAME: + raise ValueError( + f"G1 walk previous-action observation must read {_ACTION_TERM_NAME!r}, " + f"got {policy_obs.actions.action_name!r}" + ) + if (policy_obs.sin_phase.offset, policy_obs.sin_phase.size) != (0, 2): + raise ValueError("G1 walk sine-phase observation must select offset=0, size=2") + if (policy_obs.cos_phase.offset, policy_obs.cos_phase.size) != (2, 2): + raise ValueError("G1 walk cosine-phase observation must select offset=2, size=2") + + task_values = { + "action_scale": np.asarray(action_state.action_scales, dtype=np.float32).tolist(), + "kp": kp.tolist(), + "kd": kd.tolist(), + "action_lower": np.asarray(env.action_space.low, dtype=np.float32).tolist(), + "action_upper": np.asarray(env.action_space.high, dtype=np.float32).tolist(), + "command_lower": command_bounds[0].tolist(), + "command_upper": command_bounds[1].tolist(), + "base_angular_velocity_scale": float(policy_obs.base_ang_vel.scale), + "joint_position_scale": float(policy_obs.joint_pos.scale), + "joint_velocity_scale": float(policy_obs.joint_vel.scale), + "gait_period_s": float(command_cfg.gait_period), + "gait_phase_offsets_rad": list(_GAIT_PHASE_OFFSETS_RAD), + "standing_command_threshold": _STANDING_COMMAND_THRESHOLD, + } + _require_task_schema_fields(task_values) + task = G1WalkTaskSpec(**task_values) + + return DeploymentProfile( + robot=robot, + task=task, + control=ControlSpec(period_s=cfg.ctrl_dt, state_timeout_s=0.1), + observation_size=observation_shape[0], + action_size=action_shape[0], + ) + + +def _single_joint_position_action_term(env: object) -> JointPositionActionTerm: + action_terms = getattr(env, "action_terms", None) + if not isinstance(action_terms, dict) or set(action_terms) != {_ACTION_TERM_NAME}: + names = tuple(action_terms) if isinstance(action_terms, dict) else action_terms + raise ValueError(f"G1 walk deployment requires exactly one {_ACTION_TERM_NAME!r} action term, got {names}") + action_term = action_terms[_ACTION_TERM_NAME] + if not isinstance(action_term, JointPositionActionTerm): + raise TypeError(f"Expected JointPositionActionTerm, got {type(action_term).__name__}") + return action_term + + +def _assert_vector(name: str, value: object, size: int, *, non_negative: bool = False) -> None: + vector = np.asarray(value) + if vector.shape != (size,) or not np.all(np.isfinite(vector)): + raise ValueError(f"{name} must contain {size} finite values, got shape {vector.shape}") + if non_negative and np.any(vector < 0.0): + raise ValueError(f"{name} must contain only non-negative values") + + +def _require_task_schema_fields(values: dict[str, object]) -> None: + """Stop before artifact creation while the reviewed TaskSpec is a shell.""" + + available = set(G1WalkTaskSpec.model_fields) + missing = set(values).difference(available) + if missing: + raise NotImplementedError( + "G1WalkTaskSpec must declare the profile fields before export can continue: " + ", ".join(sorted(missing)) + ) + + +__all__ = ["build_g1_walk_profile"] From d97317061b0d785f29db062826ed7ba27bca961d Mon Sep 17 00:00:00 2001 From: MrHu <1962951972@qq.com> Date: Mon, 19 Oct 2026 17:21:01 +0800 Subject: [PATCH 7/9] chore: ignore native build artifacts --- .gitignore | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.gitignore b/.gitignore index 9df32a80..f3e78aee 100644 --- a/.gitignore +++ b/.gitignore @@ -15,3 +15,7 @@ docs/source/index.md .worktrees .obsidian /unitree_sdk2_python/ +build/ +dist/ +*.so +*.egg-info/ From 010f0163d6643145b9cb4272423440e59e93c12b Mon Sep 17 00:00:00 2001 From: MrHu <1962951972@qq.com> Date: Mon, 19 Oct 2026 19:59:16 +0800 Subject: [PATCH 8/9] chore: add missing license headers --- .../src/motrix_deploy_tasks/programs/__init__.py | 3 +++ .../src/motrix_deploy_tasks/state_machines/__init__.py | 3 +++ motrix_deploy_unitree/src/motrix_deploy_unitree/native.py | 3 +++ .../src/motrix_deploy_unitree/native_interface.py | 3 +++ motrix_deploy_unitree/tests/test_native_backend.py | 3 +++ motrix_unitree_native/CMakeLists.txt | 3 +++ motrix_unitree_native/python/motrix_unitree_native/__init__.py | 3 +++ motrix_unitree_native/src/backend.cpp | 3 +++ motrix_unitree_native/src/backend.hpp | 3 +++ motrix_unitree_native/src/bindings.cpp | 3 +++ 10 files changed, 30 insertions(+) diff --git a/motrix_deploy_tasks/src/motrix_deploy_tasks/programs/__init__.py b/motrix_deploy_tasks/src/motrix_deploy_tasks/programs/__init__.py index 3265750a..3c9b7aed 100644 --- a/motrix_deploy_tasks/src/motrix_deploy_tasks/programs/__init__.py +++ b/motrix_deploy_tasks/src/motrix_deploy_tasks/programs/__init__.py @@ -1 +1,4 @@ +# Copyright Motphys Technology Co., Ltd. 2025, 2026 +# SPDX-License-Identifier: Apache-2.0 + """Persistent multi-policy deployment programs.""" diff --git a/motrix_deploy_tasks/src/motrix_deploy_tasks/state_machines/__init__.py b/motrix_deploy_tasks/src/motrix_deploy_tasks/state_machines/__init__.py index 8140d24f..3494df42 100644 --- a/motrix_deploy_tasks/src/motrix_deploy_tasks/state_machines/__init__.py +++ b/motrix_deploy_tasks/src/motrix_deploy_tasks/state_machines/__init__.py @@ -1 +1,4 @@ +# Copyright Motphys Technology Co., Ltd. 2025, 2026 +# SPDX-License-Identifier: Apache-2.0 + """Task-owned persistent deployment state machines.""" diff --git a/motrix_deploy_unitree/src/motrix_deploy_unitree/native.py b/motrix_deploy_unitree/src/motrix_deploy_unitree/native.py index 12019b8f..401a9684 100644 --- a/motrix_deploy_unitree/src/motrix_deploy_unitree/native.py +++ b/motrix_deploy_unitree/src/motrix_deploy_unitree/native.py @@ -1,3 +1,6 @@ +# Copyright Motphys Technology Co., Ltd. 2025, 2026 +# SPDX-License-Identifier: Apache-2.0 + """Optional C++ Unitree backend bridge. This module is intentionally small: the native extension owns DDS and the diff --git a/motrix_deploy_unitree/src/motrix_deploy_unitree/native_interface.py b/motrix_deploy_unitree/src/motrix_deploy_unitree/native_interface.py index 750012da..e496fe3d 100644 --- a/motrix_deploy_unitree/src/motrix_deploy_unitree/native_interface.py +++ b/motrix_deploy_unitree/src/motrix_deploy_unitree/native_interface.py @@ -1,3 +1,6 @@ +# Copyright Motphys Technology Co., Ltd. 2025, 2026 +# SPDX-License-Identifier: Apache-2.0 + """G1 hardware adapter backed by the native Unitree SDK2 extension. The extension owns DDS callbacks and the 1 kHz LowCmd writer. This module diff --git a/motrix_deploy_unitree/tests/test_native_backend.py b/motrix_deploy_unitree/tests/test_native_backend.py index 2b888577..ec11a591 100644 --- a/motrix_deploy_unitree/tests/test_native_backend.py +++ b/motrix_deploy_unitree/tests/test_native_backend.py @@ -1,3 +1,6 @@ +# Copyright Motphys Technology Co., Ltd. 2025, 2026 +# SPDX-License-Identifier: Apache-2.0 + """Contract tests for the Python adapter around the native G1 transport.""" from __future__ import annotations diff --git a/motrix_unitree_native/CMakeLists.txt b/motrix_unitree_native/CMakeLists.txt index 8d607367..5790865f 100644 --- a/motrix_unitree_native/CMakeLists.txt +++ b/motrix_unitree_native/CMakeLists.txt @@ -1,3 +1,6 @@ +# Copyright Motphys Technology Co., Ltd. 2025, 2026 +# SPDX-License-Identifier: Apache-2.0 + cmake_minimum_required(VERSION 3.18) project(motrix_unitree_native LANGUAGES CXX) diff --git a/motrix_unitree_native/python/motrix_unitree_native/__init__.py b/motrix_unitree_native/python/motrix_unitree_native/__init__.py index 568a1f4b..48d133de 100644 --- a/motrix_unitree_native/python/motrix_unitree_native/__init__.py +++ b/motrix_unitree_native/python/motrix_unitree_native/__init__.py @@ -1,3 +1,6 @@ +# Copyright Motphys Technology Co., Ltd. 2025, 2026 +# SPDX-License-Identifier: Apache-2.0 + """Python package for the optional Unitree SDK2 native extension.""" from ._native import G1Backend diff --git a/motrix_unitree_native/src/backend.cpp b/motrix_unitree_native/src/backend.cpp index 7c382719..5d45311c 100644 --- a/motrix_unitree_native/src/backend.cpp +++ b/motrix_unitree_native/src/backend.cpp @@ -1,3 +1,6 @@ +// Copyright Motphys Technology Co., Ltd. 2025, 2026 +// SPDX-License-Identifier: Apache-2.0 + #include "backend.hpp" #include diff --git a/motrix_unitree_native/src/backend.hpp b/motrix_unitree_native/src/backend.hpp index 56282fb2..ed7c4e78 100644 --- a/motrix_unitree_native/src/backend.hpp +++ b/motrix_unitree_native/src/backend.hpp @@ -1,3 +1,6 @@ +// Copyright Motphys Technology Co., Ltd. 2025, 2026 +// SPDX-License-Identifier: Apache-2.0 + #pragma once #include diff --git a/motrix_unitree_native/src/bindings.cpp b/motrix_unitree_native/src/bindings.cpp index 8fb9c225..1321a2bd 100644 --- a/motrix_unitree_native/src/bindings.cpp +++ b/motrix_unitree_native/src/bindings.cpp @@ -1,3 +1,6 @@ +// Copyright Motphys Technology Co., Ltd. 2025, 2026 +// SPDX-License-Identifier: Apache-2.0 + #include "backend.hpp" #include From 9cf11a9a23d84bbecfbc0bd2d3e4f7512eee94f3 Mon Sep 17 00:00:00 2001 From: MrH-creater <1962951972@qq.com> Date: Tue, 20 Oct 2026 12:07:25 +0800 Subject: [PATCH 9/9] Potential fix for pull request finding Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> --- tests/test_workspace_versions.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/tests/test_workspace_versions.py b/tests/test_workspace_versions.py index b2624bf2..9e82c464 100644 --- a/tests/test_workspace_versions.py +++ b/tests/test_workspace_versions.py @@ -158,6 +158,11 @@ def test_source_versions_track_the_installed_distribution(): f"but its distribution is {distribution!r}" ) installed = _installed_version(distribution) + if installed is None: + # Not every workspace package is installed in every environment + # (e.g. the Unitree plugin is Python 3.10 only), so the installed + # version can only be checked where the distribution is present. + continue assert installed == projects[distribution], ( f"{distribution} is installed as {installed!r}, expected the workspace version " f"{projects[distribution]!r}; reinstall it with the matching install command"