fix: issues from rebase

Author: d-perl

bec_lib/bec_lib/config_helper.py

@@ -29,13 +29,17 @@
 from bec_lib.endpoints import MessageEndpoints
 from bec_lib.file_utils import DeviceConfigWriter
 from bec_lib.logger import bec_logger
-from bec_lib.messages import ConfigAction
+from bec_lib.messages import ConfigAction, sanitize_one_way_encodable
 from bec_lib.utils.import_utils import lazy_import_from
 from bec_lib.utils.json_extended import ExtendedEncoder
 
 if TYPE_CHECKING:  # pragma: no cover
     from bec_lib.devicemanager import DeviceManagerBase
-    from bec_lib.messages import DeviceConfigMessage, RequestResponseMessage, ServiceResponseMessage
+    from bec_lib.messages import (
+        DeviceConfigMessage,
+        RequestResponseMessage,
+        ServiceResponseMessage,
+    )
     from bec_lib.redis_connector import RedisConnector
 
 else:
@@ -74,7 +78,11 @@ def __init__(self, device_manager: DeviceManagerBase) -> None:
         self._config_helper = device_manager.config_helper
 
     def update_session_with_file(
-        self, file_path: str, save_recovery: bool = True, force: bool = False, validate: bool = True
+        self,
+        file_path: str,
+        save_recovery: bool = True,
+        force: bool = False,
+        validate: bool = True,
     ) -> None:
         """Update the current session with a yaml file from disk.
 
@@ -96,15 +104,19 @@ def save_current_session(self, file_path: str):
         """
         self._config_helper.save_current_session(file_path)
 
-    def reset_config(self, wait_for_response: bool = True, timeout_s: float | None = None) -> None:
+    def reset_config(
+        self, wait_for_response: bool = True, timeout_s: float | None = None
+    ) -> None:
         """
         Send a request to reset config to default
         Args:
             wait_for_response (bool): whether to wait for the response, default True
             timeout_s (float, optional): how long to wait for a response. Ignored if not waiting. Defaults to best effort calculated value based on message length.
         Returns: None
         """
-        self._config_helper.reset_config(wait_for_response=wait_for_response, timeout_s=timeout_s)
+        self._config_helper.reset_config(
+            wait_for_response=wait_for_response, timeout_s=timeout_s
+        )
 
     def load_demo_config(self, force: bool = False) -> None:
         """
@@ -139,7 +151,11 @@ def __init__(
         self._device_manager = device_manager
 
     def update_session_with_file(
-        self, file_path: str, save_recovery: bool = True, force: bool = False, validate: bool = True
+        self,
+        file_path: str,
+        save_recovery: bool = True,
+        force: bool = False,
+        validate: bool = True,
     ) -> None:
         """Update the current session with a yaml file from disk.
 
@@ -167,7 +183,9 @@ def update_session_with_file(
 
             if not os.path.exists(self._base_path_recovery):
                 self._writer_mixin.create_directory(self._base_path_recovery)
-            fname = os.path.join(self._base_path_recovery, f"recovery_config_{time_stamp}.yaml")
+            fname = os.path.join(
+                self._base_path_recovery, f"recovery_config_{time_stamp}.yaml"
+            )
             success = self._save_config_to_file(fname, raise_on_error=False)
             if success:
                 print(f"A recovery config was written to {fname}.")
@@ -259,7 +277,9 @@ def _get_config_conflicts(self, new_config: dict, validate: bool = True) -> dict
                     for sub_element in all_config_keys:
                         sub_value = value.get(sub_element, None)
                         current_sub_value = (
-                            current_value.get(sub_element, None) if current_value else None
+                            current_value.get(sub_element, None)
+                            if current_value
+                            else None
                         )
                         if sub_value != current_sub_value:
                             nested_conflicts[sub_element] = {
@@ -414,12 +434,16 @@ def _resolve_single_conflict(
 
         if choice.lower() == "a":
             # Accept new value
-            self._apply_config_value(config, device_name, element, sub_element, new_value)
+            self._apply_config_value(
+                config, device_name, element, sub_element, new_value
+            )
             console.print("  [green]→ Accepted new value[/green]")
         elif choice.lower() == "k":
             # Keep current value - do nothing to config since we're loading from file
             # We need to update config dict to keep current value
-            self._apply_config_value(config, device_name, element, sub_element, current_value)
+            self._apply_config_value(
+                config, device_name, element, sub_element, current_value
+            )
             console.print("  [yellow]→ Kept current value[/yellow]")
         elif choice.lower() == "m":
             # Manual merge - prompt for custom value
@@ -434,7 +458,9 @@ def _resolve_single_conflict(
             except (ValueError, SyntaxError):
                 # If evaluation fails, treat as string
                 custom_value = custom_input
-            self._apply_config_value(config, device_name, element, sub_element, custom_value)
+            self._apply_config_value(
+                config, device_name, element, sub_element, custom_value
+            )
             console.print(f"  [blue]→ Applied custom value: {custom_value}[/blue]")
 
     def _format_value_for_display(self, value) -> str:
@@ -458,7 +484,12 @@ def _format_value_for_display(self, value) -> str:
         return str(value)
 
     def _apply_config_value(
-        self, config: dict, device_name: str, element: str, sub_element: str | None, value
+        self,
+        config: dict,
+        device_name: str,
+        element: str,
+        sub_element: str | None,
+        value,
     ) -> None:
         """
         Apply a resolved value to the config dict.
@@ -501,7 +532,11 @@ def _apply_all_current_values(self, config: dict, conflicts: dict) -> None:
                 # This is a nested conflict (like deviceConfig)
                 for sub_element, sub_conflict in conflict_data.items():
                     self._apply_config_value(
-                        config, device_name, element, sub_element, sub_conflict["current"]
+                        config,
+                        device_name,
+                        element,
+                        sub_element,
+                        sub_conflict["current"],
                     )
 
     def _is_nested_conflict(self, conflict_data: dict) -> bool:
@@ -515,7 +550,8 @@ def _is_nested_conflict(self, conflict_data: dict) -> bool:
             bool: True if nested conflict, False otherwise.
         """
         return isinstance(conflict_data, dict) and all(
-            isinstance(v, dict) and "new" in v and "current" in v for v in conflict_data.values()
+            isinstance(v, dict) and "new" in v and "current" in v
+            for v in conflict_data.values()
         )
 
     def _save_config_to_file(self, file_path: str, raise_on_error: bool = True) -> bool:
@@ -617,14 +653,22 @@ def send_config_request(
         request_id = str(uuid.uuid4())
         self._connector.send(
             MessageEndpoints.device_config_request(),
-            DeviceConfigMessage(action=action, config=config, metadata={"RID": request_id}),
+            DeviceConfigMessage(
+                action=action,
+                config=sanitize_one_way_encodable(config),
+                metadata={"RID": request_id},
+            ),
         )
 
         if wait_for_response:
-            timeout = timeout_s if timeout_s is not None else self.suggested_timeout_s(config)
+            timeout = (
+                timeout_s if timeout_s is not None else self.suggested_timeout_s(config)
+            )
             logger.info(f"Waiting for reply with timeout {timeout} s")
             reply = self.wait_for_config_reply(
-                request_id, timeout=timeout, send_cancel_on_interrupt=(action != "cancel")
+                request_id,
+                timeout=timeout,
+                send_cancel_on_interrupt=(action != "cancel"),
             )
             if action == "cancel":
                 raise DeviceConfigError(
@@ -633,7 +677,9 @@ def send_config_request(
             self.handle_update_reply(reply, request_id, timeout)
         return request_id
 
-    def reset_config(self, wait_for_response: bool = True, timeout_s: float | None = None) -> None:
+    def reset_config(
+        self, wait_for_response: bool = True, timeout_s: float | None = None
+    ) -> None:
         """
         Send a request to reset config to default
         Args:
@@ -657,7 +703,9 @@ def reset_config(self, wait_for_response: bool = True, timeout_s: float | None =
     def suggested_timeout_s(config: dict):
         return min(300, len(config) * 30) + 2
 
-    def handle_update_reply(self, reply: RequestResponseMessage, RID: str, timeout: float):
+    def handle_update_reply(
+        self, reply: RequestResponseMessage, RID: str, timeout: float
+    ):
         if not reply.content["accepted"] and not reply.metadata.get("updated_config"):
             raise DeviceConfigError(
                 f"Failed to update the config: {reply.content['message']}. No devices were updated."
@@ -695,7 +743,9 @@ def wait_for_service_response(self, RID: str, timeout: float = 60) -> None:
         start_time = time.monotonic()
         while True:
             elapsed_time = time.monotonic() - start_time
-            service_messages = self._connector.lrange(MessageEndpoints.service_response(RID), 0, -1)
+            service_messages = self._connector.lrange(
+                MessageEndpoints.service_response(RID), 0, -1
+            )
             if not service_messages:
                 time.sleep(0.005)
             else:
@@ -738,11 +788,15 @@ def wait_for_config_reply(
             start = time.monotonic()
             while True:
                 elapsed_time = time.monotonic() - start
-                msg = self._connector.get(MessageEndpoints.device_config_request_response(RID))
+                msg = self._connector.get(
+                    MessageEndpoints.device_config_request_response(RID)
+                )
                 if msg is None:
                     time.sleep(0.01)
                     if elapsed_time > timeout:
-                        raise DeviceConfigError("Timeout reached whilst waiting for config reply.")
+                        raise DeviceConfigError(
+                            "Timeout reached whilst waiting for config reply."
+                        )
                     continue
                 return msg
         except KeyboardInterrupt:
@@ -759,6 +813,8 @@ def load_demo_config(self, force: bool = False) -> None:
             force (bool, optional): Force update even if there are conflicts. Defaults to False.
         Returns: None
         """
-        dir_path = os.path.abspath(os.path.join(os.path.dirname(bec_lib.__file__), "./configs/"))
+        dir_path = os.path.abspath(
+            os.path.join(os.path.dirname(bec_lib.__file__), "./configs/")
+        )
         fpath = os.path.join(dir_path, "demo_config.yaml")
         self.update_session_with_file(fpath, force=force)