liquid_handler default use chatterbox instead of rviz backend

unilabos/devices/liquid_handling/liquid_handler_abstract.py

@@ -31,15 +31,17 @@ from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
 
 
 class LiquidHandlerMiddleware(LiquidHandler):
-    def __init__(self, backend: LiquidHandlerBackend, deck: Deck, simulator: bool = False, channel_num: int = 8, total_height: float = 310, **kwargs):
+    def __init__(self, backend: LiquidHandlerBackend, deck: Deck, simulator: bool = False, channel_num: int = 8, **kwargs):
         self._simulator = simulator
         self.channel_num = channel_num
         joint_config = kwargs.get("joint_config", None)
         if simulator:
-            self._simulate_backend = UniLiquidHandlerRvizBackend(channel_num,total_height, joint_config=joint_config, lh_device_id = deck.name)
+            if joint_config:
+                self._simulate_backend = UniLiquidHandlerRvizBackend(channel_num, kwargs["total_height"],
+                                                                     joint_config=joint_config, lh_device_id=deck.name)
+            else:
+                self._simulate_backend = LiquidHandlerChatterboxBackend(channel_num)
             self._simulate_handler = LiquidHandlerAbstract(self._simulate_backend, deck, False)
-        if hasattr(backend, "total_height"):
-            backend.total_height = total_height
         super().__init__(backend, deck)
 
     async def setup(self, **backend_kwargs):
@@ -544,51 +546,16 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
     support_touch_tip = True
     _ros_node: BaseROS2DeviceNode
 
-    def __init__(self, backend: LiquidHandlerBackend, deck: Deck, simulator: bool=False, channel_num:int = 8,total_height: float = 310,**backend_kwargs):
+    def __init__(self, backend: LiquidHandlerBackend, deck: Deck, simulator: bool=False, channel_num:int = 8):
         """Initialize a LiquidHandler.
 
         Args:
           backend: Backend to use.
           deck: Deck to use.
         """
-        backend_type = None
-        if isinstance(backend, dict) and "type" in backend:
-            backend_dict = backend.copy()
-            type_str = backend_dict.pop("type")
-            try:
-                # Try to get class from string using globals (current module), or fallback to pylabrobot or unilabos namespaces
-                backend_cls = None
-                if type_str in globals():
-                    backend_cls = globals()[type_str]
-                else:
-                    # Try resolving dotted notation, e.g. "xxx.yyy.ClassName"
-                    components = type_str.split(".")
-                    mod = None
-                    if len(components) > 1:
-                        module_name = ".".join(components[:-1])
-                        try:
-                            import importlib
-                            mod = importlib.import_module(module_name)
-                        except ImportError:
-                            mod = None
-                        if mod is not None:
-                            backend_cls = getattr(mod, components[-1], None)
-                    if backend_cls is None:
-                        # Try pylabrobot style import (if available)
-                        try:
-                            import pylabrobot
-                            backend_cls = getattr(pylabrobot, type_str, None)
-                        except Exception:
-                            backend_cls = None
-                if backend_cls is not None and isinstance(backend_cls, type):
-                    backend_type = backend_cls(**backend_dict)  # pass the rest of dict as kwargs
-            except Exception as exc:
-                raise RuntimeError(f"Failed to convert backend type '{type_str}' to class: {exc}")
-        else:
-            backend_type = backend
         self._simulator = simulator
         self.group_info = dict()
-        super().__init__(backend_type, deck, simulator, channel_num,total_height,**backend_kwargs)
+        super().__init__(backend, deck, simulator, channel_num)
 
     def post_init(self, ros_node: BaseROS2DeviceNode):
         self._ros_node = ros_node