fix(config): corrected config extension form cpp base

- corrected config extension by using normal python classes and not dataclasses
- added unpack type hinting type kwargs for base classes
- added auto generated typed dict file for base config class types that come from cpp

Author: juelg

Makefile

@@ -30,9 +30,10 @@ stubgen:
 	find ./python -not -path "./python/rcs/_core/*" -name '*.pyi' -delete
 	find ./python/rcs/_core -name '*.pyi' -print | xargs sed -i 's/tuple\[typing\.Literal\[\([0-9]\+\)\], typing\.Literal\[1\]\]/tuple\[typing\.Literal[\1]\]/g'
 	find ./python/rcs/_core -name '*.pyi' -print | xargs sed -i 's/tuple\[\([M|N]\), typing\.Literal\[1\]\]/tuple\[\1\]/g'
-	ruff check --fix python/rcs/_core
-	isort python/rcs/_core
-	black python/rcs/_core
+	python scripts/generate_common_typing.py
+	ruff check --fix python/rcs/_core python/rcs/common_typing.py
+	isort python/rcs/_core python/rcs/common_typing.py
+	black python/rcs/_core python/rcs/common_typing.py
 
 # Python
 pycheckformat:

extensions/rcs_robotiq2f85/src/rcs_robotiq2f85/hw.py

@@ -1,28 +1,28 @@
-from dataclasses import dataclass
-
 from rcs._core.common import Gripper, GripperConfig, GripperState
 from Robotiq2F85Driver.Robotiq2F85Driver import GripperStatus, Robotiq2F85Driver
 
 
-@dataclass(kw_only=True)
 class RobotiQ2F85GripperConfig(GripperConfig):
-    serial_number: str
-    """Get the serial number with `udevadm info -a -n /dev/ttyUSB0 | grep serial`, make sure you have read/write permissions to the port."""
-    speed: float = 100
-    """Speed in mm/s. Must be between 20 and 150 mm/s."""
-    force: float = 50
-    """Force in N. Must be between 20 and 235 N."""
-    async_control: bool = True
-    """If True, gripper commands return immediately without waiting for the movement to complete.
-    A new command interrupts any ongoing movement."""
-
-
-@dataclass(kw_only=True)
-class RobotiQ2F85GripperState(GripperState):
-    state: GripperStatus
 
-    def __post_init__(self):
+    def __init__(self, serial_number: str, speed: float = 100, force: float = 50, async_control: bool = True) -> None:
+        """
+        Args:
+            serial_number: Get the serial number with `udevadm info -a -n /dev/ttyUSB0 | grep serial`, make sure you have read/write permissions to the port.
+            speed: Speed in mm/s. Must be between 20 and 150 mm/s.
+            force: Force in N. Must be between 20 and 235 N.
+            async_control: If True, gripper commands return immediately without waiting for the movement to complete. A new command interrupts any ongoing movement.
+        """
+        super().__init__()
+        self.serial_number = serial_number
+        self.speed = speed
+        self.force = force
+        self.async_control = async_control
+
+
+class RobotiQ2F85GripperState(GripperState):
+    def __init__(self, state: GripperStatus) -> None:
         super().__init__()
+        self.state = state
 
 
 class RobotiQ2F85Gripper(Gripper):

extensions/rcs_so101/src/rcs_so101/hw.py

@@ -1,22 +1,30 @@
 import threading
 import typing
-from dataclasses import dataclass
 from pathlib import Path
 
 import numpy as np
 from lerobot.robots import make_robot_from_config
 from lerobot.robots.so101_follower.config_so101_follower import SO101FollowerConfig
 from lerobot.robots.so101_follower.so101_follower import SO101Follower
+from rcs.common_typing import RobotConfigKwargs
 from rcs.utils import SimpleFrameRate
 
 from rcs import common
 
 
-@dataclass(kw_only=True)
 class SO101Config(common.RobotConfig):
-    id: str = "follower"
-    port: str = "/dev/ttyACM0"
-    calibration_dir: str = "."
+
+    def __init__(
+        self,
+        id: str = "follower",
+        port: str = "/dev/ttyACM0",
+        calibration_dir: str = ".",
+        **kwargs: typing.Unpack[RobotConfigKwargs],
+    ):
+        super().__init__(**kwargs)
+        self.id = id
+        self.port = port
+        self.calibration_dir = calibration_dir
 
 
 class SO101(common.Robot):

extensions/rcs_ur5e/src/rcs_ur5e/hw.py

@@ -5,38 +5,45 @@
 import multiprocessing as mp
 import time
 import typing
-from dataclasses import dataclass
 from enum import IntEnum
 from multiprocessing.shared_memory import SharedMemory
 
 import numpy as np
 import rtde_control
 import rtde_receive
+from rcs.common_typing import RobotConfigKwargs
 from rcs_ur5e import robotiq_gripper
 
-import rcs
 from rcs import common
 
 
-@dataclass(kw_only=True)
 class UR5eConfig(common.RobotConfig):
-    ip: str
 
-    # Kinematics Setup
-    robot_type: common.RobotType = common.RobotType.UR5e
-    kinematic_model_path = rcs.scenes["ur5e_empty_world"].mjcf_robot
-    attachment_site = "attachment_site"
-
-    # Robot movement parameters
-    max_velocity: float = 1.0
-    max_acceleration: float = 1.0
-    async_control: bool = True
-    max_servo_joint_step: float = 0.15
-    max_servo_cartesian_step: float = 0.01
-
-    # UR Controller parameters, change with caution
-    lookahead_time: float = 0.05
-    gain: float = 500.0
+    def __init__(
+        self,
+        ip: str,
+        max_velocity: float = 1.0,
+        max_acceleration: float = 1.0,
+        async_control: bool = True,
+        max_servo_joint_step: float = 0.15,
+        max_servo_cartesian_step: float = 0.01,
+        lookahead_time: float = 0.05,
+        gain: float = 500.0,
+        **kwargs: typing.Unpack[RobotConfigKwargs],
+    ):
+        super().__init__(**kwargs)
+        self.robot_platform = common.RobotPlatform.HARDWARE
+        self.robot_type = common.RobotType.UR5e
+        self.ip = ip
+        # Robot movement parameters
+        self.max_velocity = max_velocity
+        self.max_acceleration = max_acceleration
+        self.async_control = async_control
+        self.max_servo_joint_step = max_servo_joint_step
+        self.max_servo_cartesian_step = max_servo_cartesian_step
+        # UR Controller parameters, change with caution
+        self.lookahead_time = lookahead_time
+        self.gain = gain
 
     def to_dict(self) -> dict[str, typing.Any]:
         return {
@@ -55,13 +62,11 @@ def from_dict(self, data: dict[str, typing.Any]) -> None:
         for key, value in data.items():
             setattr(self, key, value)
 
-    def __post_init__(self):
-        super().__init__()
 
-
-@dataclass(kw_only=True)
 class RobotiQGripperConfig(common.GripperConfig):
-    ip: str
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
 
 
 # Define the shared memory

extensions/rcs_xarm7/src/rcs_xarm7/hw.py

@@ -1,23 +1,30 @@
 import typing
-from dataclasses import dataclass, field
 from typing import List
 
 import numpy as np
+from rcs.common_typing import RobotConfigKwargs
 from xarm.wrapper import XArmAPI
 
 from rcs import common
 
 
-@dataclass(kw_only=True)
 class XArm7Config(common.RobotConfig):
-    ip: str
-    payload_weight: float = 0.624
-    payload_tcp: List[float] = field(default_factory=lambda: [-4.15, 5.24, 76.38])
-    async_control: bool = False
-    use_internal_ik: bool = True
 
-    def __post_init__(self):
-        super().__init__()
+    def __init__(
+        self,
+        ip: str,
+        payload_weight: float = 0.624,
+        payload_tcp: List[float] | None = None,
+        async_control: bool = False,
+        use_internal_ik: bool = True,
+        **kwargs: typing.Unpack[RobotConfigKwargs],
+    ):
+        super().__init__(**kwargs)
+        self.ip = ip
+        self.payload_weight = payload_weight
+        self.payload_tcp = payload_tcp if payload_tcp is not None else [-4.15, 5.24, 76.38]
+        self.async_control = async_control
+        self.use_internal_ik = use_internal_ik
 
 
 class XArm7(common.Robot):

python/rcs/common_typing.py

@@ -0,0 +1,24 @@
+# ATTENTION: auto generated from C++ stub files, use `make stubgen` to update!
+"""TypedDict helpers generated from `python/rcs/_core/common.pyi`."""
+from __future__ import annotations
+
+from typing import TypedDict
+
+from rcs._core import common
+
+__all__ = ["BaseCameraConfigKwargs", "RobotConfigKwargs"]
+
+
+class BaseCameraConfigKwargs(TypedDict, total=False):
+    identifier: str
+    frame_rate: int
+    resolution_width: int
+    resolution_height: int
+
+
+class RobotConfigKwargs(TypedDict, total=False):
+    robot_type: common.RobotType
+    robot_platform: common.RobotPlatform
+    tcp_offset: common.Pose
+    attachment_site: str
+    kinematic_model_path: str

python/rcs/hand/tilburg_hand.py

@@ -1,7 +1,6 @@
 import copy
 import logging
 import typing
-from dataclasses import dataclass
 from time import sleep
 
 import numpy as np
@@ -15,27 +14,30 @@
 logger.disabled = False
 
 
-@dataclass(kw_only=True)
 class THConfig(common.HandConfig):
     """Config for the Tilburg hand"""
 
-    calibration_file: str | None = None
-    grasp_percentage: float = 1.0
-    control_unit: Unit = Unit.NORMALIZED
-    hand_orientation: str = "right"
-    grasp_type: common.GraspType = common.GraspType.POWER_GRASP
-
-    def __post_init__(self):
-        # 👇 satisfy pybind11 by actually calling the C++ constructor
+    def __init__(
+        self,
+        calibration_file: str | None = None,
+        grasp_percentage: float = 1.0,
+        control_unit: Unit = Unit.NORMALIZED,
+        hand_orientation: str = "right",
+        grasp_type: common.GraspType = common.GraspType.POWER_GRASP,
+    ) -> None:
         super().__init__()
+        self.calibration_file = calibration_file
+        self.grasp_percentage = grasp_percentage
+        self.control_unit = control_unit
+        self.hand_orientation = hand_orientation
+        self.grasp_type = grasp_type
 
 
-@dataclass
 class TilburgHandState(common.HandState):
-    joint_positions: Vec18Type
 
-    def __post_init__(self):
+    def __init__(self, joint_positions: Vec18Type) -> None:
         super().__init__()
+        self.joint_positions = joint_positions
 
 
 class TilburgHand(common.Hand):