py_canoe 3.0.3__py3-none-any.whl → 26.0.0__py3-none-any.whl

py_canoe/core/measurement.py

@@ -0,0 +1,149 @@
+from typing import Union
+import win32com.client
+
+from py_canoe.core.capl import CaplFunction
+from py_canoe.helpers.common import DoEventsUntil
+from py_canoe.helpers.common import logger, wait
+
+
+class MeasurementEvents:
+    def __init__(self):
+        self.APP_COM_OBJ = object
+        self.INIT: bool = False
+        self.START: bool = False
+        self.STOP: bool = False
+        self.EXIT: bool = False
+        self.CAPL_FUNCTION_OBJECTS = dict()
+        self.CAPL_FUNCTION_NAMES = tuple()
+
+    def OnInit(self):
+        """measurement is initialized"""
+        for fun in self.CAPL_FUNCTION_NAMES:
+            self.CAPL_FUNCTION_OBJECTS[fun] = CaplFunction(self.APP_COM_OBJ.CAPL.GetFunction(fun))
+        self.INIT = True
+
+    def OnStart(self):
+        """measurement is started"""
+        self.START = True
+
+    def OnStop(self):
+        """measurement is stopped"""
+        self.STOP = True
+
+    def OnExit(self):
+        """measurement is exited"""
+        self.CAPL_FUNCTION_OBJECTS.clear()
+        self.EXIT = True
+
+
+class Measurement:
+    def __init__(self, app):
+        self.com_object = win32com.client.Dispatch(app.com_object.Measurement)
+        self.measurement_events: MeasurementEvents = win32com.client.WithEvents(self.com_object, MeasurementEvents)
+        self.measurement_events.APP_COM_OBJ = app.com_object
+
+    @property
+    def animation_delay(self) -> int:
+        return self.com_object.AnimationDelay
+
+    @animation_delay.setter
+    def animation_delay(self, delay: int):
+        self.com_object.AnimationDelay = delay
+        logger.info(f"📢 Animation Delay ⏲️ set to: {delay} ms")
+
+    @property
+    def measurement_index(self) -> int:
+        index = self.com_object.MeasurementIndex
+        logger.info(f"📢 Measurement Index value: {index}")
+        return index
+
+    @measurement_index.setter
+    def measurement_index(self, index: int):
+        self.com_object.MeasurementIndex = index
+        logger.info(f"📢 Measurement Index set to: {index}")
+
+    @property
+    def running(self) -> bool:
+        return self.com_object.Running
+
+    def start(self, timeout=30) -> bool:
+        try:
+            if self.running:
+                logger.warning("⚠️ Measurement is already running")
+                return True
+            self.measurement_events.START = False
+            self.com_object.Start()
+            status = DoEventsUntil(lambda: self.measurement_events.START, timeout, "CANoe Measurement Start")
+            if status:
+                logger.info('📢 Measurement Started 🏃‍➡️')
+            return status
+        except Exception as e:
+            logger.error(f"❌ Error starting CANoe measurement: {e}")
+            return False
+
+    def stop(self, timeout=30) -> bool:
+        return self.stop_ex(timeout)
+
+    def stop_ex(self, timeout=30) -> bool:
+        try:
+            if not self.running:
+                logger.warning("⚠️ Measurement is already stopped")
+                return True
+            self.measurement_events.STOP = False
+            self.com_object.Stop()
+            status = DoEventsUntil(lambda: self.measurement_events.STOP, timeout, "CANoe Measurement Stop")
+            if status:
+                logger.info('📢 Measurement Stopped 🧍')
+            wait(1)  # Allow 1 second buffer
+            return status
+        except Exception as e:
+            logger.error(f"❌ Error stopping CANoe measurement: {e}")
+            return False
+
+    def start_measurement_in_animation_mode(self, animation_delay=100, timeout=30) -> bool:
+        try:
+            if self.running:
+                logger.warning("⚠️ Measurement is already running, cannot animate")
+                return False
+            self.measurement_events.START = False
+            self.animation_delay = animation_delay
+            self.com_object.Animate()
+            status = DoEventsUntil(lambda: self.measurement_events.START, timeout, "CANoe Measurement Animation Initialization")
+            if status:
+                logger.info(f'📢 Measurement started 🏃‍➡️ in Animation mode with animation delay ⏲️ {animation_delay} ms')
+            else:
+                logger.error(f"❌ Measurement did not start in Animation mode within {timeout} seconds")
+            return status
+        except Exception as e:
+            logger.error(f"❌ Error starting CANoe measurement in animation mode: {e}")
+            return False
+
+    def break_measurement_in_offline_mode(self) -> bool:
+        try:
+            if not self.running:
+                logger.warning("⚠️ Measurement is not running, cannot break")
+                return False
+            self.com_object.Break()
+            logger.info('📢 Measurement break applied 🫷 in Offline mode')
+            return True
+        except Exception as e:
+            logger.error(f"❌ Error breaking CANoe measurement in offline mode: {e}")
+            return False
+
+    def reset_measurement_in_offline_mode(self) -> bool:
+        try:
+            self.com_object.Reset()
+            logger.info('📢 Measurement reset applied 🔁 in Offline mode')
+            return True
+        except Exception as e:
+            logger.error(f"❌ Error resetting CANoe measurement in offline mode: {e}")
+            return False
+
+    def process_measurement_event_in_single_step(self) -> bool:
+        try:
+            self.com_object.Step()
+            logger.info('📢 Processed a measurement event in single step 👣')
+            return True
+        except Exception as e:
+            logger.error(f"❌ Error processing CANoe measurement event in single step: {e}")
+            return False

py_canoe/core/networks.py

@@ -0,0 +1,103 @@
+from typing import Union
+
+from py_canoe.helpers.common import logger
+from py_canoe.helpers.common import wait
+from py_canoe.core.child_elements.diagnostic import Diagnostic
+from py_canoe.core.child_elements.network import Network
+
+
+class Networks:
+    """
+    The Networks object represents the networks of CANoe.
+    """
+    def __init__(self, app):
+        self.com_object = app.com_object.Networks
+        self.diagnostic_devices: dict[str, Diagnostic] = dict()
+
+    @property
+    def count(self) -> int:
+        return self.com_object.Count
+
+    def item(self, index: int) -> Network:
+        return Network(self.com_object.Item(index))
+
+    def fetch_diagnostic_devices(self):
+        try:
+            for i in range(1, self.count + 1):
+                network = self.item(i)
+                for j in range(1, network.devices.count + 1):
+                    device = network.devices.item(j)
+                    try:
+                        diagnostic = getattr(device.com_object, 'Diagnostic', None)
+                        if diagnostic:
+                            self.diagnostic_devices[device.name] = Diagnostic(diagnostic)
+                    except Exception:
+                        pass
+        except Exception as e:
+            logger.error(f"❌ Error fetching Diagnostic Devices: {e}")
+            return None
+
+    def send_diag_request(self, diag_ecu_qualifier_name: str, request: str, request_in_bytes=True, return_sender_name=False, response_in_bytearray=False) -> Union[str, dict]:
+        try:
+            diag_device: Diagnostic = self.diagnostic_devices.get(diag_ecu_qualifier_name)
+            if diag_device:
+                if request_in_bytes:
+                    diag_req_in_bytes = bytearray()
+                    byte_stream = ''.join(request.split(' '))
+                    for i in range(0, len(byte_stream), 2):
+                        diag_req_in_bytes.append(int(byte_stream[i:i + 2], 16))
+                    diag_request = diag_device.create_request_from_stream(diag_req_in_bytes)
+                else:
+                    diag_request = diag_device.create_request(request)
+                diag_request.send()
+                logger.info(f'💉 {diag_ecu_qualifier_name}: Diagnostic Request = {request}')
+                while diag_request.pending:
+                    wait(0.01)
+                diag_responses_dict = {}
+                diag_response_including_sender_name = {}
+                for i in range(1, diag_request.responses.count + 1):
+                    diag_response = diag_request.responses.item(i)
+                    diag_response_positive = diag_response.positive
+                    response_code = diag_response.response_code
+                    response_sender = diag_response.sender
+                    response_stream = diag_response.stream
+                    response_stream_in_str = " ".join(f"{d:02X}" for d in response_stream).upper()
+                    diag_responses_dict[response_sender] = {
+                        "positive": diag_response_positive,
+                        "response_code": response_code,
+                        "stream": response_stream,
+                        "stream_in_str": response_stream_in_str
+                    }
+                    if response_in_bytearray:
+                        diag_response_including_sender_name[response_sender] = response_stream
+                    else:
+                        diag_response_including_sender_name[response_sender] = response_stream_in_str
+                    if diag_response_positive:
+                        logger.info(f'🟢 {response_sender}: Diagnostic Response = {response_stream_in_str}')
+                    else:
+                        logger.info(f'🔴 {response_sender}: Diagnostic Response = {response_stream_in_str}')
+                return diag_response_including_sender_name if return_sender_name else diag_response_including_sender_name[diag_ecu_qualifier_name]
+            else:
+                logger.warning(f'⚠️ No responses received for request: {request}')
+                return {"error": "No responses received"}
+        except Exception as e:
+            logger.error(f"❌ Error sending diagnostic request: {e}")
+            return {"error": str(e)}
+
+    def control_tester_present(self, diag_ecu_qualifier_name: str, value: bool) -> bool:
+        try:
+            diag_device: Diagnostic = self.diagnostic_devices.get(diag_ecu_qualifier_name)
+            if diag_device:
+                if value:
+                    diag_device.diag_start_tester_present()
+                    logger.info(f'✔️ {diag_ecu_qualifier_name}: Tester Present started 🏃‍➡️')
+                else:
+                    diag_device.diag_stop_tester_present()
+                    logger.info(f'⏹️ {diag_ecu_qualifier_name}: Tester Present stopped 🧍')
+                return True
+            else:
+                logger.warning(f'⚠️ No diagnostic device found for: {diag_ecu_qualifier_name}')
+                return False
+        except Exception as e:
+            logger.error(f"❌ Error controlling tester present: {e}")
+            return False

py_canoe/core/performance.py

@@ -0,0 +1,21 @@
+from py_canoe.helpers.common import logger
+
+
+class Performance:
+    """
+    The Performance object allows setting or returning parameters that influence the performance on multicore processors.
+    """
+    def __init__(self, app):
+        self.app = app
+        self.com_object = self.app.com_object.Performance
+
+    @property
+    def max_num_measurement_setup_threads(self) -> int:
+        return self.com_object.MaxNumMeasurementSetupThreads
+
+    @max_num_measurement_setup_threads.setter
+    def max_num_measurement_setup_threads(self, num: int):
+        if not self.app.get_measurement_running_status():
+            self.com_object.MaxNumMeasurementSetupThreads = num
+        else:
+            logger.warning("⚠️ Cannot set MaxNumMeasurementSetupThreads while measurement is running.")

py_canoe/core/simulation.py

@@ -0,0 +1,53 @@
+import win32com.client
+from typing import Union
+
+
+class SimulationEvents:
+    EVENTS_INFORMATION = {}
+
+    @staticmethod
+    def OnIdle(timeHigh, time):
+        SimulationEvents.EVENTS_INFORMATION['timeHigh'] = timeHigh
+        SimulationEvents.EVENTS_INFORMATION['time'] = time
+
+
+class Simulation:
+    """
+    The Simulation object represents CANoe's measurement functions in the Simulation mode.
+    With the help of the Simulation object you can control the system time from an external source during the measurement.
+    CANoe automatically goes into Slave mode at the measurement start if you access the Simulation object.
+    """
+    def __init__(self, app, enable_events: bool = False):
+        self.com_object = app.com_object.Simulation
+        if enable_events:
+            win32com.client.WithEvents(self.com_object, SimulationEvents)
+
+    @property
+    def animation(self) -> Union[int, float]:
+        return self.com_object.Animation
+
+    @animation.setter
+    def animation(self, value: Union[int, float]):
+        self.com_object.Animation = value
+
+    @property
+    def current_time(self) ->int:
+        return self.com_object.CurrentTime
+
+    @property
+    def current_time_high(self) -> int:
+        return self.com_object.CurrentTimeHigh
+
+    @property
+    def notification_type(self) -> int:
+        return self.com_object.NotificationType
+
+    @notification_type.setter
+    def notification_type(self, value: int):
+        self.com_object.NotificationType = value
+
+    def increment_time(self, ticks: int):
+        self.com_object.IncrementTime(ticks)
+
+    def increment_time_and_wait(self, ticks: int):
+        self.com_object.IncrementTimeAndWait(ticks)

py_canoe/core/system.py

@@ -0,0 +1,164 @@
+from typing import Union
+
+from py_canoe.helpers.common import logger
+from py_canoe.core.child_elements.namespaces import Namespaces
+from py_canoe.core.child_elements.variables_files import VariablesFiles
+from py_canoe.core.child_elements.variable import Variable
+
+
+class System:
+    """
+    The System object represents the system of the CANoe application.
+    The System object offers access to the namespaces for data exchange with external applications.
+    """
+    def __init__(self, app):
+        self.com_object = app.com_object.System
+
+    @property
+    def namespaces(self) -> Namespaces:
+        return Namespaces(self.com_object.Namespaces)
+
+    @property
+    def variables_files(self) -> VariablesFiles:
+        return VariablesFiles(self.com_object.VariablesFiles)
+
+
+    def add_variable(self, sys_var_name: str, value: Union[int, float, str], read_only: bool = False) -> Union[object, None]:
+        new_var_com_obj = None
+        try:
+            parts = sys_var_name.split('::')
+            if len(parts) < 2:
+                logger.error(f"❌ Invalid system variable name '{sys_var_name}'. Must be in 'namespace::variable' format.")
+                return None
+            namespace = '::'.join(parts[:-1])
+            variable_name = parts[-1]
+            try:
+                namespace_obj = self.com_object.Namespaces(namespace)
+            except Exception:
+                logger.info(f"namespace '{namespace}' not present. Creating namespace...")
+                namespaces_obj = self.com_object.Namespaces
+                namespace_obj = namespaces_obj.Add(namespace)
+                logger.info(f"Created new namespace: {namespace}")
+            variables_obj = namespace_obj.Variables
+            if read_only:
+                new_var_com_obj = variables_obj.Add(variable_name, value)
+            else:
+                new_var_com_obj = variables_obj.AddWriteable(variable_name, value)
+            logger.info(f"System Variable '{sys_var_name}' defined successfully with value: {value}")
+            return new_var_com_obj
+        except Exception as e:
+            logger.error(f"❌ Error defining System Variable '{sys_var_name}': {e}")
+            return None
+
+    def remove_variable(self, sys_var_name: str) -> bool:
+        try:
+            parts = sys_var_name.split('::')
+            if len(parts) < 2:
+                logger.error(f"❌ Invalid system variable name '{sys_var_name}'. Must be in 'namespace::variable' format.")
+                return None
+            namespace = '::'.join(parts[:-1])
+            variable_name = parts[-1]
+            namespace_obj = self.com_object.Namespaces(namespace)
+            variables_obj = namespace_obj.Variables
+            for i in range(1, variables_obj.Count + 1):
+                variable_obj = variables_obj.Item(i)
+                if variable_obj.Name == variable_name:
+                    variables_obj.Remove(i)
+                    logger.info(f"System Variable '{sys_var_name}' removed successfully.")
+                    return True
+            logger.info(f"System Variable '{sys_var_name}' not found.")
+            return False
+        except Exception as e:
+            logger.error(f"❌ Error removing System Variable '{sys_var_name}': {e}")
+            return False
+
+    def get_variable_value(self, sys_var_name: str, return_symbolic_name=False) -> Union[int, float, str, None]:
+        try:
+            parts = sys_var_name.split('::')
+            if len(parts) < 2:
+                logger.error(f"❌ Invalid system variable name '{sys_var_name}'. Must be in 'namespace::variable' format.")
+                return None
+            namespace = '::'.join(parts[:-1])
+            variable_name = parts[-1]
+            namespace_obj = self.com_object.Namespaces(namespace)
+            variable_obj = Variable(namespace_obj.Variables(variable_name))
+            value = variable_obj.get_value()
+            if return_symbolic_name:
+                symbolic_value = variable_obj.get_symbolic_value_name(value)
+                logger.info(f"System Variable '{sys_var_name}' symbolic value: {symbolic_value}")
+                return symbolic_value
+            logger.info(f"System Variable '{sys_var_name}' value: {value}")
+            return value
+        except Exception as e:
+            logger.error(f"❌ Error retrieving System Variable '{sys_var_name}': {e}")
+            return None
+
+    def set_variable_value(self, sys_var_name: str, value: Union[int, float, str], timeout: Union[int, float] = 1) -> bool:
+        try:
+            parts = sys_var_name.split('::')
+            if len(parts) < 2:
+                logger.error(f"❌ Invalid system variable name '{sys_var_name}'. Must be in 'namespace::variable' format.")
+                return False
+            namespace = '::'.join(parts[:-1])
+            variable_name = parts[-1]
+            namespace_obj = self.com_object.Namespaces(namespace)
+            variable_obj = Variable(namespace_obj.Variables(variable_name))
+            var_type = type(variable_obj.get_value())
+            try:
+                converted_value = var_type(value)
+            except Exception:
+                logger.error(f"❌ Could not convert value '{value}' to type {var_type.__name__} for '{sys_var_name}'")
+                return False
+            status = variable_obj.set_value(converted_value, timeout)
+            return status
+        except Exception as e:
+            logger.error(f"❌ Error setting System Variable '{sys_var_name}': {e}")
+            return False
+
+    def set_variable_array_values(self, sys_var_name: str, value: tuple, index: int = 0, timeout: Union[int, float] = 1) -> bool:
+        try:
+            parts = sys_var_name.split('::')
+            if len(parts) < 2:
+                logger.error(f"❌ Invalid system variable name '{sys_var_name}'. Must be in 'namespace::variable' format.")
+                return False
+            namespace = '::'.join(parts[:-1])
+            variable_name = parts[-1]
+            namespace_obj = self.com_object.Namespaces(namespace)
+            variable_obj = Variable(namespace_obj.Variables(variable_name))
+            arr = list(variable_obj.get_value())
+            if index < 0 or index + len(value) > len(arr):
+                logger.error(f"❌ Not enough space in System Variable Array '{sys_var_name}' to set values.")
+                return False
+            value_type = type(arr[0]) if arr else type(value[0])
+            arr[index:index + len(value)] = [value_type(v) for v in value]
+            status = variable_obj.set_value(tuple(arr), timeout)
+            return status
+        except Exception as e:
+            logger.error(f"❌ Error setting System Variable Array '{sys_var_name}': {e}")
+            return False
+
+    def get_namespaces(self) -> Union[dict['str': 'Namespace'], None]:
+        try:
+            namespaces_dict = {}
+            namespaces = self.namespaces
+            for index in range(1, namespaces.count + 1):
+                namespace = namespaces.item(index)
+                namespaces_dict[namespace.name] = namespace
+            logger.info(f"📢 total {namespaces.count} system root namespaces found.")
+            return namespaces_dict
+        except Exception as e:
+            logger.error(f"❌ Error getting system namespaces: {e}")
+            return None
+
+    def get_variables_files(self) -> Union[dict['str': 'VariablesFile'], None]:
+        try:
+            variables_files_dict = {}
+            variables_files = self.variables_files
+            for index in range(1, variables_files.count + 1):
+                variables_file = variables_files.item(index)
+                variables_files_dict[variables_file.full_name] = variables_file
+            logger.info(f"📢 total {variables_files.count} system variables files found.")
+            return variables_files_dict
+        except Exception as e:
+            logger.error(f"❌ Error getting system variables files: {e}")
+            return None

py_canoe/core/ui.py

@@ -0,0 +1,53 @@
+from py_canoe.helpers.common import logger
+
+from py_canoe.core.child_elements.write import Write
+
+
+class Ui:
+    """
+    The UI object represents the user interface in CANoe.
+    """
+    def __init__(self, app):
+        self.app = app
+        self.com_object = self.app.com_object.UI
+
+    def get_command_enabled(self, command: str) -> bool:
+        return self.com_object.GetCommandEnabled(command)
+
+    def set_command_enabled(self, command: str, enabled: bool) -> None:
+        self.com_object.SetCommandEnabled(command, enabled)
+
+    @property
+    def write(self) -> Write:
+        return Write(self.com_object.Write)
+
+    def activate_desktop(self, desktop_name: str) -> bool:
+        try:
+            self.com_object.ActivateDesktop(desktop_name)
+            logger.info(f"📢 UI Desktop '{desktop_name}' activated successfully")
+            return True
+        except Exception as e:
+            logger.error(f"❌ Error activating UI Desktop '{desktop_name}': {e}")
+            return False
+
+    def create_desktop(self, desktop_name: str) -> bool:
+        try:
+            if float(f"{self.app.version.major}.{self.app.version.minor}") >= 15.3:
+                self.com_object.CreateDesktop(desktop_name)
+                logger.info(f"📢 UI Desktop '{desktop_name}' created successfully")
+                return True
+            else:
+                logger.warning(f"❌ Cannot create desktop '{desktop_name}': Requires CANoe version 15.3 or higher.")
+                return False
+        except Exception as e:
+            logger.error(f"❌ Error creating UI Desktop '{desktop_name}': {e}")
+            return False
+
+    def open_baudrate_dialog(self) -> bool:
+        try:
+            self.com_object.OpenBaudrateDialog()
+            logger.info("📢 UI Baudrate Dialog opened successfully")
+            return True
+        except Exception as e:
+            logger.error(f"❌ Error opening UI Baudrate Dialog: {e}")
+            return False

py_canoe/core/version.py

@@ -0,0 +1,54 @@
+from py_canoe.helpers.common import logger
+
+
+class Version:
+    """
+    The Version object represents the version of the CANoe application.
+    """
+    def __init__(self, app):
+        self.com_object = app.com_object.Version
+
+    def __str__(self):
+        return f"{self.full_name}"
+
+    @property
+    def build(self):
+        return self.com_object.Build
+
+    @property
+    def full_name(self):
+        return self.com_object.FullName
+
+    @property
+    def major(self):
+        return self.com_object.major
+
+    @property
+    def minor(self):
+        return self.com_object.minor
+
+    @property
+    def name(self):
+        return self.com_object.Name
+
+    @property
+    def patch(self):
+        return self.com_object.Patch
+
+    def get_canoe_version_info(self) -> dict[str, str | int]:
+            try:
+                version_info = {
+                    'full_name': self.full_name,
+                    'name': self.name,
+                    'major': self.major,
+                    'minor': self.minor,
+                    'build': self.build,
+                    'patch': self.patch
+                }
+                logger.info('📜 CANoe Version Information:')
+                for key, value in version_info.items():
+                    logger.info(f"    {key}: {value}")
+                return version_info
+            except Exception as e:
+                logger.error(f"❌ Error retrieving CANoe version information: {e}")
+                return {}

py_canoe/helpers/common.py

@@ -0,0 +1,78 @@
+import os
+import sys
+import time
+import logging
+import pythoncom
+from datetime import datetime
+from pathlib import Path
+
+def check_if_path_exists(path: str, create_if_not_exist: bool=False) -> bool:
+    """Check if a given path exists. Optionally create it if it doesn't."""
+    if os.path.exists(path):
+        return True
+    else:
+        if create_if_not_exist:
+            try:
+                os.makedirs(path, exist_ok=True)
+                return True
+            except Exception as e:
+                logger.error(f"❌ Error creating directory {path}: {e}")
+                return False
+        else:
+            return False
+
+def setup_logger(name='py_canoe', filename='py_canoe.log'):
+    """Set up and return a logger with console and file handlers."""
+    # os.makedirs(os.path.dirname(filename), exist_ok=True)
+    logger = logging.getLogger(name)
+    logger.setLevel(logging.INFO)
+    fmt = "%(asctime)s [PY_CANOE] [%(levelname)-4.8s] %(message)s"
+    # Add console handler if not already present
+    if not any(isinstance(h, logging.StreamHandler) for h in logger.handlers):
+        console_handler = logging.StreamHandler(sys.stdout)
+        console_handler.setLevel(logging.INFO)
+        console_handler.setFormatter(logging.Formatter(fmt))
+        logger.addHandler(console_handler)
+    logger.propagate = False
+    return logger
+
+def update_logger_file_path(logger: logging.Logger, log_dir_path: str | Path) -> None:
+    """Update the file handler of an existing logger to a new file path."""
+    new_filename = os.path.join(log_dir_path, 'py_canoe.log')
+    if check_if_path_exists(os.path.dirname(new_filename), create_if_not_exist=True):
+        # Remove existing FileHandlers
+        for handler in logger.handlers[:]:
+            if isinstance(handler, logging.FileHandler):
+                logger.removeHandler(handler)
+                handler.close()
+        # Add new FileHandler
+        fmt = "%(asctime)s [PY_CANOE] [%(levelname)-4.8s] %(message)s"
+        file_handler = logging.FileHandler(new_filename, mode='w', encoding='utf-8')
+        file_handler.setLevel(logging.INFO)
+        file_handler.setFormatter(logging.Formatter(fmt))
+        logger.addHandler(file_handler)
+    else:
+        logger.error(f"❌ Cannot update logger file path. Directory does not exist and could not be created: {os.path.dirname(new_filename)}")
+
+
+logger = setup_logger()
+
+def wait(timeout_seconds=0.1):
+    """Pump waiting COM messages and sleep for the given timeout."""
+    pythoncom.PumpWaitingMessages()
+    time.sleep(timeout_seconds)
+
+def DoEvents() -> None:
+    wait(0.01)
+
+def DoEventsUntil(cond, timeout, title) -> bool:
+    base_time = datetime.now()
+    while not cond():
+        DoEvents()
+        now = datetime.now()
+        difference = now - base_time
+        seconds = difference.seconds
+        if seconds > timeout:
+            logger.warning(f'⚠️ {title} timeout({timeout} s)')
+            return False
+    return True