py_canoe.CANoe

def __enter__(self):
    """
    Enter context manager.
    """
    return self

def __exit__(self, exc_type, exc_val, exc_tb):
    """
    Exit context manager and cleanup resources. Explicitly release resources and uninitialize COM.
    """
    try:
        if self.application is not None:
            pythoncom.CoUninitialize()
    except Exception as e:
        logger.error(f"Error during COM uninitialization: {e}.")
    finally:
        self.application = None

def add_database(self, database_file: str, network: str | int) -> bool:
    """adds database file to a network channel

    Args:
        database_file (str): database file to attach. give full file path.
        network (str | int): network name or channel number on which you want to add database.
    """
    return self.application.configuration.add_database(database_file, network)

def add_filters_to_exporter(self, logger_index: int, full_names: 'Iterable'):
    """Add messages and symbols to exporter filter by their full names.

    Args:
        logger_index (int): indicates logger
        full_names (Iterable): full names of messages and symbols
    """
    return self.application.configuration.add_filters_to_exporter(logger_index, full_names)

def add_logging_block(self, full_name: str) -> 'Logging':
    """adds a new logging block to configuration measurement setup.

    Args:
        full_name (str): full path to log file as "C:/file.(asc|blf|mf4|...)", may have field functions like {IncMeasurement} in the file name.

    Returns:
        Logging: returns Logging object of added logging block.
    """
    return self.application.configuration.add_logging_block(full_name)

def add_netWork(self, network_name: str, network_type: BusType = BusType.CAN,
                sw_channel: int = 1) -> Bus:
    """Adds a new network to the configuration.

    Args:
        network_name: Name of the new network.
        network_type: Bus type. Defaults to BusType.CAN.
        sw_channel: Software channel index (1-based) to assign.
            Defaults to 1.

    Returns:
        The newly added :class:`Bus` object.
    """
    return self.application.configuration.add_netWork(network_name, network_type, sw_channel)

def add_netWork_with_hardware(self, network_name: str,
                               network_type: BusType = BusType.CAN,
                               sw_channel: int = 1,
                               hw_channel: ChannelInfo | None = None,
                               arb_phase_config: CanChannelConfiguration | None = None,
                               data_phase_config: CanChannelConfiguration | None = None
                               ) -> Bus:
    """Add a network and optionally assign a physical hardware channel.

    This combines :meth:`add_netWork` + :meth:`set_hardware_channel`.

    Args:
        network_name: Network name.
        network_type: Bus type.
        sw_channel: Software channel index (1-based).
        hw_channel: Physical hardware channel from
            :meth:`get_hardware_channels`.  Pass *None* to skip
            hardware assignment.

    Returns:
        The newly added :class:`Bus` object.
    """
    bus = self.add_netWork(network_name, network_type, sw_channel)
    if hw_channel is not None:
        # app-channel is 0-based; sw_channel is 1-based
        self.set_hardware_channel(sw_channel - 1, hw_channel, network_type)        

    if network_type == BusType.CAN and (arb_phase_config is not None or data_phase_config is not None):
        # a network can only be bound to one channel
        busController = bus.channels.item(1).controller
        if arb_phase_config is not None and data_phase_config is None:
            # can
            arb_phase_config.apply_to_can_set_config(busController)
        if arb_phase_config is not None and data_phase_config is not None:
            # can fd
            arb_phase_config.apply_to_can_set_fd_arb_phase_config(busController)
            data_phase_config.apply_to_can_set_fd_data_phase_config(busController)
        elif arb_phase_config is None and data_phase_config is not None:
            raise ValueError("data_phase_config cannot be set without arb_phase_config")
    return bus

def add_offline_source_log_file(self, absolute_log_file_path: str) -> bool:
    """
    Adds an offline source log file to the configuration.

    Args:
        absolute_log_file_path (str): The absolute path to the log file.

    Returns:
        bool: True if the operation was successful, False otherwise.
    """
    return self.application.configuration.add_offline_source_log_file(absolute_log_file_path)

def add_testEnvironments(self, name:str) -> TestEnvironment:
    """
    Add a new Test Environment to TestSetup.

    If you need to create a new test environment, the name field contains the name of the new test environment.
    If you need to load an existing test environment from a file, the name field contains the file path,
    which can be an absolute path or relative to the current configuration.

    Args:
        name (str): Name or path of the Test Environment
    """
    return self.application.configuration.add_testEnvironments(name)

def attach_to_active_application(self) -> bool:
    """
    Attach to a active instance of the CANoe application.

    Returns:
        bool: True if the operation was successful, False otherwise.
    """
    self._reset_application()
    self.application = Application()
    self.application.user_capl_functions = self.user_capl_functions
    return self.application.attach_to_active_application()

def break_measurement_in_offline_mode(self) -> bool:
    """
    Breaks the measurement in offline mode.

    Returns:
        bool: True if the operation was successful, False otherwise.
    """
    return self.application.measurement.break_measurement_in_offline_mode()

def call_capl_function(self, name: str, *arguments) -> bool:
    """
    Calls a CAPL function.

    Args:
        name (str): The name of the CAPL function.
        *arguments: The arguments to pass to the CAPL function.

    Returns:
        bool: True if the function call was successful, False otherwise.
    """
    return self.application.capl.call_capl_function(name, *arguments)

def check_j1939_signal_online(self, bus: BusType | str | int, channel: int, message: str, signal: str, source_addr: int, dest_addr: int) -> bool:
    """
    Checks if a J1939 signal is online.

    Args:
        bus (BusType): The bus type.
        channel (int): The channel number.
        message (str): The message name.
        signal (str): The signal name.
        source_addr (int): The source address.
        dest_addr (int): The destination address.

    Returns:
        bool: True if the signal is online, False otherwise.
    """
    try:
        bus = self._normalize_bus_type(bus)
        bus_obj = self.application.bus(bus)
        signal_obj = bus_obj.get_j1939_signal(channel, message, signal, source_addr, dest_addr)
        is_online = signal_obj.is_online
        logger.info(f'J1939 Signal({signal_obj.full_name}) is online ?: {is_online} ({bus_obj.VALUE_TABLE_SIGNAL_IS_ONLINE[is_online]})')
        return is_online
    except Exception as e:
        logger.error(f"Error checking J1939 bus signal online status: {e}")
        return False

def check_j1939_signal_state(self, bus: BusType | str | int, channel: int, message: str, signal: str, source_addr: int, dest_addr: int) -> int:
    """
    Checks the state of a J1939 signal.

    Args:
        bus (BusType): The bus type.
        channel (int): The channel number.
        message (str): The message name.
        signal (str): The signal name.
        source_addr (int): The source address.
        dest_addr (int): The destination address.

    Returns:
        int: The state of the signal.
    """
    try:
        bus = self._normalize_bus_type(bus)
        bus_obj = self.application.bus(bus)
        signal_obj = bus_obj.get_j1939_signal(channel, message, signal, source_addr, dest_addr)
        state = signal_obj.state
        logger.info(f'J1939 Signal({signal_obj.full_name}) state: {state} ({bus_obj.VALUE_TABLE_SIGNAL_STATE[state]})')
        return state
    except Exception as e:
        logger.error(f"Error checking J1939 bus signal state: {e}")
        return -1

def check_signal_online(self, bus: BusType | str | int, channel: int, message: str, signal: str) -> bool:
    """
    Checks if a signal is online.

    Args:
        bus (BusType): The bus type.
        channel (int): The channel number.
        message (str): The message name.
        signal (str): The signal name.

    Returns:
        bool: True if the signal is online, False otherwise.
    """
    try:
        bus = self._normalize_bus_type(bus)
        bus_obj = self.application.bus(bus)
        signal_obj = bus_obj.get_signal(channel, message, signal)
        is_online = signal_obj.is_online
        logger.info(f'Signal({signal_obj.full_name}) is online ?: {is_online} ({bus_obj.VALUE_TABLE_SIGNAL_IS_ONLINE[is_online]})')
        return is_online
    except Exception as e:
        logger.error(f"Error checking {bus} bus signal online status: {e}")
        return False

def check_signal_state(self, bus: BusType | str | int, channel: int, message: str, signal: str) -> int:
    """
    Checks the state of a signal.

    Args:
        bus (BusType): The bus type.
        channel (int): The channel number.
        message (str): The message name.
        signal (str): The signal name.

    Returns:
        int: The state of the signal.
    """
    try:
        bus = self._normalize_bus_type(bus)
        bus_obj = self.application.bus(bus)
        signal_obj = bus_obj.get_signal(channel, message, signal)
        state = signal_obj.state
        logger.info(f'Signal({signal_obj.full_name}) state: {state} ({bus_obj.VALUE_TABLE_SIGNAL_STATE[state]})')
        return state
    except Exception as e:
        logger.error(f"Error checking {bus} bus signal state: {e}")
        return -1

def clear_hardware_channels(self) -> None:
    """Remove all hardware channel mappings for CANoe."""
    with VxlDriver() as drv:
        drv.unset_all_appl_config("CANoe")

def clear_write_window_content(self) -> bool:
    """
    Clears the content of the write window.

    Returns:
        bool: True if the operation was successful, False otherwise.
    """
    return self.application.ui.write.clear()

def compile_all_capl_nodes(self, wait_time: Union[int, float] = 5) -> Union[CompileResult, None]:
    """
    Compiles all CAPL nodes in the application.

    Args:
        wait_time (Union[int, float]): The time to wait for the compilation to complete.

    Returns:
        The compilation result or None if an error occurred.
    """
    return self.application.capl.compile(wait_time)

def control_replay_block(self, block_name: str, start_stop: bool) -> bool:
    """
    Controls the replay block.

    Args:
        block_name (str): The name of the replay block.
        start_stop (bool): True to start the replay block, False to stop it.

    Returns:
        bool: True if the operation was successful, False otherwise.
    """
    return self.application.configuration.control_replay_block(block_name, start_stop)

def control_tester_present(self, diag_ecu_qualifier_name: str, value: bool) -> bool:
    """
    Controls the tester present signal.

    Args:
        diag_ecu_qualifier_name (str): The diagnostic ECU qualifier name.
        value (bool): The value to set for the tester present signal.

    Returns:
        bool: True if the operation was successful, False otherwise.
    """
    return self.application.networks.control_tester_present(diag_ecu_qualifier_name, value)

def copy_write_window_content(self) -> bool:
    """
    Copies the content of the write window.

    Returns:
        bool: True if the operation was successful, False otherwise.
    """
    return self.application.ui.write.copy()

def define_system_variable(self, sys_var_name: str, value: Union[int, float, str], read_only: bool = False) -> object:
    """
    Defines a system variable.

    Args:
        sys_var_name (str): The name of the system variable.
        value (Union[int, float, str]): The value of the system variable.
        read_only (bool): Whether the system variable is read-only.

    Returns:
        object: The created system variable object.
    """
    return self.application.system.add_variable(sys_var_name, value, read_only)

def disable_write_window_output_file(self, tab_index=None) -> bool:
    """
    Disables the write window output file.

    Args:
        tab_index (Optional[int]): The tab index to disable the output file for.

    Returns:
        bool: True if the operation was successful, False otherwise.
    """
    return self.application.ui.write.disable_output_file(tab_index)

def enable_disable_replay_block(self, block_name: str, enable_disable: bool) -> bool:
    """
    Enables or disables a replay block.

    Args:
        block_name (str): The name of the replay block.
        enable_disable (bool): True to enable the replay block, False to disable it.

    Returns:
        bool: True if the operation was successful, False otherwise.
    """
    return self.application.configuration.enable_disable_replay_block(block_name, enable_disable)

def enable_write_window_output_file(self, output_file: str, tab_index=None) -> bool:
    """
    Enables the write window output file.

    Args:
        output_file (str): The output file path.
        tab_index (Optional[int]): The tab index to enable the output file for.

    Returns:
        bool: True if the operation was successful, False otherwise.
    """
    return self.application.ui.write.enable_output_file(output_file, tab_index)

def execute_all_test_configurations(self, enable_test_cases: Sequence[str] = (),
                                   disable_test_cases: Sequence[str] = (),
                                   match_by: str = "name",
                                   wait_for_completion: bool = True) -> bool:
    """executes all test configurations available in test setup.

    Args:
        enable_test_cases (Sequence[str]): Patterns of test cases to enable before execution.
        disable_test_cases (Sequence[str]): Patterns of test cases to disable before execution.
        match_by (str): Matching mode for patterns. One of "name", "group", or "fixture". Defaults to "name".
        wait_for_completion (bool): whether to wait for test configuration execution to complete before returning. defaults to True.

    Returns:
        bool: True if the operation was successful, False otherwise.
    """
    return self.application.configuration.execute_all_test_configurations(enable_test_cases,
                                                                        disable_test_cases,
                                                                        match_by,
                                                                        wait_for_completion)

def execute_all_test_environments(self):
    """executes all test environments available in test setup."""
    return self.application.configuration.execute_all_test_environments()

def execute_all_test_modules_in_test_env(self, env_name: str, enable_test_cases: Sequence[str] = (), disable_test_cases: Sequence[str] = (), match_by: str = "name"):
    """executes all test modules available in test environment.

    Args:
        env_name (str): test environment name. avoid duplicate test environment names in CANoe configuration.
        enable_test_cases (Sequence[str]): Patterns of test cases to enable before
            execution. Forwarded to every test module. Supports wildcard and regex.
            If empty (default), no test cases are explicitly enabled.
        disable_test_cases (Sequence[str]): Patterns of test cases to disable before
            execution. Forwarded to every test module. Takes precedence over
            enable_test_cases. If empty (default), no test cases are disabled.
        match_by (str): Which test case attribute the patterns are matched against.
            Either "name" (default) or "title".
    """
    return self.application.configuration.execute_all_test_modules_in_test_env(
        env_name, enable_test_cases, disable_test_cases, match_by=match_by)

def execute_test_configuration(self, test_configuration_name: str,
                               enable_test_cases: Sequence[str] = (),
                               disable_test_cases: Sequence[str] = (),
                               match_by: str = "name",
                               wait_for_completion: bool = True) -> bool:
    """executes a specific test configuration.

    Args:
        test_configuration_name (str): The name of the test configuration to execute.
        enable_test_cases (Sequence[str]): Patterns of test cases to enable before execution.
        disable_test_cases (Sequence[str]): Patterns of test cases to disable before execution.
        match_by (str): Matching mode for patterns. One of "name", "group", or "fixture". Defaults to "name".
        wait_for_completion (bool): Whether to wait for the test configuration execution to complete before returning. Defaults to True.

    Returns:
        bool: True if the operation was successful, False otherwise.
    """
    return self.application.configuration.execute_test_configuration(test_configuration_name,
                                                                     enable_test_cases,
                                                                     disable_test_cases,
                                                                     match_by,
                                                                     wait_for_completion)

def execute_test_module(self, test_module_name: str, enable_test_cases: Sequence[str] = (), disable_test_cases: Sequence[str] = (), match_by: str = "name") -> int:
    """use this method to execute test module.

    Args:
        test_module_name (str): test module name. avoid duplicate test module names in CANoe configuration.
        enable_test_cases (Sequence[str]): Patterns of test cases to enable before execution.
            Only matching test cases will be checked. Supports wildcard and regex:
            - Wildcard: ``"*pass*"``, ``"TC_00?"``, ``"TC_[0-3]*"``
            - Regex: ``"(?i)tc_001"``, ``"^SmokeTest_.*"``
            If empty (default), no test cases are explicitly enabled.
        disable_test_cases (Sequence[str]): Patterns of test cases to disable before execution.
            Matching test cases will be unchecked. Takes precedence over enable_test_cases.
            Supports the same wildcard and regex patterns as enable_test_cases.
            If empty (default), no test cases are explicitly disabled.
        match_by (str): Which test case attribute the patterns are matched against.
            Either "name" (default) or "title". Use "title" when your patterns
            describe the test case title rather than its internal name.

    Returns:
        int: test module execution verdict. 0 ='VerdictNotAvailable', 1 = 'VerdictPassed', 2 = 'VerdictFailed',

    Examples:
        >>> # Enable only smoke test cases (matched by name)
        >>> canoe.execute_test_module("MyModule", enable_test_cases=["SmokeTest_*"])

        >>> # Disable slow test cases, enable everything else
        >>> canoe.execute_test_module("MyModule", enable_test_cases=["*"], disable_test_cases=["*slow*", "*stress*"])

        >>> # Use regex to match
        >>> canoe.execute_test_module("MyModule", enable_test_cases=["(?i)^tc_(001|002|003)$"])

        >>> # Match patterns against the test case title instead of name
        >>> canoe.execute_test_module("MyModule", enable_test_cases=["*BLE*"], match_by="title")
    """
    return self.application.configuration.execute_test_module(test_module_name, enable_test_cases, disable_test_cases, match_by=match_by)

def get_all_namespace_names(self) -> list[str]:
    """Returns all namespace names from the current application."""
    return self.application.system.get_all_namespace_names()

def get_all_network_names(self) -> list[str]:
    """Returns all network names in the current application."""
    return self.application.networks.get_all_network_names()

def get_all_variables_in_namespace(self, namespace_name: str) -> list[dict]:
    """Returns all variables in the specified namespace."""
    return self.application.system.get_all_variables_in_namespace(namespace_name)

def get_bus_databases_info(self, bus: BusType | str | int = BusType.CAN, log_info: bool = False) -> dict:
    """
    Gets the bus databases information.

    Args:
        bus (BusType | str | int): The bus type. Defaults to BusType.CAN.
        log_info (bool): Whether to log the databases information. Defaults to False.

    Returns:
        dict: The bus databases information.
    """
    try:
        bus = self._normalize_bus_type(bus)
        bus_obj = self.application.bus(bus)
        databases_info = {}
        for db_obj in bus_obj.com_object.Databases:
            db_file = getattr(db_obj, 'FullName', '')
            fetched_db_info = fetch_database_info(db_file)
            ecus = list(fetched_db_info.get('ecus', {}).keys())
            frames = list(fetched_db_info.get('frames', {}).keys())
            frames_signals = list(fetched_db_info.get('frames_signals', {}).keys())
            pdus = list(fetched_db_info.get('pdus', {}).keys())
            pdus_signals = list(fetched_db_info.get('pdus_signals', {}).keys())
            info = {
                'full_name': getattr(db_obj, 'FullName', ''),
                'path': getattr(db_obj, 'Path', ''),
                'name': getattr(db_obj, 'Name', ''),
                'channel': getattr(db_obj, 'Channel', ''),
                'com_obj': db_obj,
                'ecus': ecus,
                'frames': frames,
                'frames_signals': frames_signals,
                'pdus': pdus,
                'pdus_signals': pdus_signals,
            }
            databases_info[info['name']] = info
        if log_info:
            logger.info(f'{bus.name} bus databases information:')
            for db_name, db_info in databases_info.items():
                logger.info(f"    {db_name}:")
                for key, value in db_info.items():
                    logger.info(f"        {key}: {value}")
        return databases_info
    except Exception as e:
        logger.exception(f"Error retrieving {bus} bus databases information: {e}")
        return {}

def get_bus_nodes_info(self, bus: BusType | str | int = BusType.CAN, log_info: bool = False) -> dict:
    """
    Gets the bus nodes information.

    Args:
        bus (BusType | str | int): The bus type. Defaults to BusType.CAN.
        log_info (bool): Whether to log the nodes information. Defaults to False.

    Returns:
        dict: The bus nodes information.
    """
    try:
        bus = self._normalize_bus_type(bus)
        bus_obj = self.application.bus(bus)
        nodes_info = {}
        for node_obj in bus_obj.com_object.Nodes:
            info = {
                'full_name': getattr(node_obj, 'FullName', ''),
                'path': getattr(node_obj, 'Path', ''),
                'name': getattr(node_obj, 'Name', ''),
                'active': getattr(node_obj, 'Active', ''),
                'com_obj': node_obj,
            }
            nodes_info[info['name']] = info
        if log_info:
            logger.info(f'{bus.name} bus nodes information:')
            for node_name, node_info in nodes_info.items():
                logger.info(f"    {node_name}:")
                for key, value in node_info.items():
                    logger.info(f"        {key}: {value}")
        return nodes_info
    except Exception as e:
        logger.error(f"Error retrieving {bus} bus nodes information: {e}")
        return {}

def get_can_bus_statistics(self, channel: int) -> dict:
    """
    Gets the CAN bus statistics.

    Args:
        channel (int): The channel number.

    Returns:
        dict: The CAN bus statistics.
    """
    return self.application.configuration.get_can_bus_statistics(channel)

def get_canoe_version_info(self) -> dict[str, str | int]:
    """
    Gets the version information of the CANoe application.

    Returns:
        dict: The version information.
    """
    return self.application.version.get_canoe_version_info()

def get_capl_compilation_result(self) -> dict[str, object]:
    """Returns the current configuration compilation result."""
    return self.application.configuration.get_compilation_result()

def get_channelUsage(self, channel_type:BusType = BusType.CAN) -> int:
    """returns the number of channels of a specific type.

    Args:
        channel_type (BusType): type of the channel (BusType.CAN for CAN, BusType.LIN for LIN, BusType.MOST for MOST, BusType.FlexRay for FlexRay, BusType.J1708 for J1708, BusType.Ethernet for Ethernet, BusType.WLAN for WLAN). Defaults to BusType.CAN.

    Returns:
        int: The number of channels of the specified type.
    """
    return self.application.configuration.general_setup.get_channels_count(channel_type)

def get_environment_variable_value(self, env_var_name: str, return_timestamp: bool = False) -> Union[int, float, str, tuple, None]:
    """
    returns a environment variable value.

    Args:
        env_var_name (str): The name of the environment variable. Ex- "float_var"
        return_timestamp (bool): Whether to return the timestamp in timezone utc along with the variable value. Defaults to False.

    Returns:
        Union[int, float, str, tuple, None]: The environment variable value or None if not found. If return_timestamp is True, returns a tuple of (variable_value, timestamp).
    """
    variable_value = self.application.environment.get_environment_variable_value(env_var_name)
    if return_timestamp:
        return variable_value, datetime.now(timezone.utc).timestamp()
    return variable_value

def get_hardware_channels(self, bus_type: BusType = BusType.CAN) -> list[ChannelInfo]:
    """Return available hardware channels for *bus_type*.

    Args:
        bus_type: CANoe bus type (BusType.CAN, BusType.LIN, etc.).

    Returns:
        List of :class:`ChannelInfo` objects from the XL Driver.
    """
    with VxlDriver() as drv:
        return drv.get_channels(self._to_xl_bus(bus_type))

def get_hardware_config(self, app_channel: int,
                        bus_type: BusType = BusType.CAN) -> ChannelInfo | None:
    """Return the hardware channel mapped to CANoe logical *app_channel*,
    or *None* if not configured."""
    with VxlDriver() as drv:
        return drv.get_appl_config("CANoe", app_channel, self._to_xl_bus(bus_type))

def get_j1939_signal_full_name(self, bus: BusType | str | int, channel: int, message: str, signal: str, source_addr: int, dest_addr: int) -> Union[str, None]:
    """
    Gets the full name of a J1939 signal.

    Args:
        bus (BusType): The bus type.
        channel (int): The channel number.
        message (str): The message name.
        signal (str): The signal name.
        source_addr (int): The source address.
        dest_addr (int): The destination address.

    Returns:
        Union[str, None]: The full name of the signal or None if not found.
    """
    try:
        bus = self._normalize_bus_type(bus)
        signal_obj = self.application.bus(bus).get_j1939_signal(channel, message, signal, source_addr, dest_addr)
        full_name = signal_obj.full_name
        logger.info(f'J1939 Signal full name = {full_name}')
        return full_name
    except Exception as e:
        logger.error(f"Error retrieving J1939 bus signal full name: {e}")
        return None

def get_j1939_signal_value(self, bus: BusType | str | int, channel: int, message: str, signal: str, source_addr: int, dest_addr: int, raw_value=False, return_timestamp=False) -> Union[float, int, None, tuple]:
    """
    Gets the value of a J1939 signal.

    Args:
        bus (BusType): The bus type.
        channel (int): The channel number.
        message (str): The message name.
        signal (str): The signal name.
        source_addr (int): The source address.
        dest_addr (int): The destination address.
        raw_value (bool): Whether to get the raw value. Defaults to False.
        return_timestamp (bool): Whether to return the timestamp in timezone utc along with the signal value. Defaults to False.

    Returns:
        Union[float, int, None, tuple]: The signal value or None if not found. If return_timestamp is True, returns a tuple of (signal_value, timestamp).
    """
    signal_value = None
    try:
        bus = self._normalize_bus_type(bus)
        signal_obj = self.application.bus(bus).get_j1939_signal(channel, message, signal, source_addr, dest_addr)
        signal_value = signal_obj.raw_value if raw_value else signal_obj.value
        logger.info(f'J1939 Signal({signal_obj.full_name}) value = {signal_value}')
    except Exception as e:
        logger.error(f"Error retrieving J1939 bus signal value: {e}")
    if return_timestamp:
        return signal_value, datetime.now(timezone.utc).timestamp()
    return signal_value

def get_logging_blocks(self) -> list['Logging']:
    """Return all available logging blocks."""
    return self.application.configuration.get_logging_blocks()

def get_measurement_index(self) -> int:
    """
    Gets the measurement index.

    Returns:
        int: The measurement index.
    """
    return self.application.measurement.measurement_index

def get_measurement_running_status(self) -> bool:
    """
    Gets the running status of the measurement.

    Returns:
        bool: True if the measurement is running, False otherwise.
    """
    return self.application.measurement.running

def get_messages(self, logger_index: int) -> list['Message']:
    """Return all messages from given logger."""
    return self.application.configuration.get_messages(logger_index)

def get_network(self,network_name: str = None) -> Bus:
    """Return a specific network by name, or *None* if not found.

    Args:
        network_name: name of the network to retrieve.  If None,
            returns the first network found.
    """
    for bus in self.application.configuration.simulation_setup.buses.item():
        if bus.name == network_name:
            return bus
    return None

def get_rt_kernel_architecture(self) -> int:
    """Returns the current RT Kernel architecture (0=32-bit, 1=64-bit, ...)."""
    return self.application.configuration.execution_environment

def get_signal_full_name(self, bus: BusType | str | int, channel: int, message: str, signal: str) -> Union[str, None]:
    """
    Gets the full name of a signal.

    Args:
        bus (BusType): The bus type.
        channel (int): The channel number.
        message (str): The message name.
        signal (str): The signal name.

    Returns:
        Union[str, None]: The full name of the signal or None if not found.
    """
    try:
        bus = self._normalize_bus_type(bus)
        signal_obj = self.application.bus(bus).get_signal(channel, message, signal)
        full_name = signal_obj.full_name
        logger.info(f'Signal full name = {full_name}')
        return full_name
    except Exception as e:
        logger.error(f"Error retrieving {bus} bus signal full name: {e}")
        return None

def get_signal_value(self, bus: BusType | str | int, channel: int, message: str, signal: str, raw_value: bool = False, return_timestamp: bool = False) -> Union[int, float, None, tuple]:
    """
    Gets the value of a signal.

    Args:
        bus (BusType | str | int): The bus type.
        channel (int): The channel number.
        message (str): The message name.
        signal (str): The signal name.
        raw_value (bool): Whether to get the raw value. Defaults to False.
        return_timestamp (bool): Whether to return the timestamp in timezone utc along with the signal value. Defaults to False.

    Returns:
        Union[int, float, None, tuple]: The signal value or None if not found. If return_timestamp is True, returns a tuple of (signal_value, timestamp).
    """
    signal_value = None
    try:
        bus = self._normalize_bus_type(bus)
        signal_obj = self.application.bus(bus).get_signal(channel, message, signal)
        signal_value = signal_obj.raw_value if raw_value else signal_obj.value
        logger.info(f"Signal({signal_obj.full_name}) value = {signal_value}")
    except Exception as e:
        logger.error(f"Error retrieving {bus} bus signal value: {e}")
    if return_timestamp:
        return signal_value, datetime.now(timezone.utc).timestamp()
    return signal_value

def get_simulation_bus_names(self) -> list[str]:
    """Returns all simulation bus names from the current application."""
    try:
        sim_buses = self.application.configuration.simulation_setup.buses
        bus_names: list[str] = []
        for i in range(1, sim_buses.count + 1):
            sim_bus = sim_buses.item(i)
            bus_name = getattr(sim_bus, 'name', None)
            if bus_name is not None:
                bus_names.append(bus_name)

        if bus_names:
            logger.info(f'simulation buses: {bus_names}')
            return bus_names

        fallback_network_names = self.application.networks.get_all_network_names()
        if isinstance(fallback_network_names, list):
            logger.info(f'simulation buses: {fallback_network_names}')
            return fallback_network_names

        logger.info('simulation buses: []')
        return []
    except Exception as e:
        raise ConfigurationNotLoadedError(f"Cannot access simulation buses: {e}") from e

def get_simulation_database_paths(self) -> list[str]:
    """Returns all simulation database paths from the current application."""
    try:
        sim_buses = self.application.configuration.simulation_setup.buses
        paths: list[str] = []
        for i in range(1, sim_buses.count + 1):
            sim_bus = sim_buses.item(i)
            dbs = getattr(sim_bus, 'databases', None)
            if dbs is None:
                continue
            for j in range(1, dbs.count + 1):
                db = dbs.item(j)
                if db.full_name is not None:
                    paths.append(db.full_name)

        if paths:
            logger.info(f'simulation database paths: {paths}')
            return paths

        cfg_db_collection = getattr(self.application.configuration.com_object.GeneralSetup.DatabaseSetup, 'Databases', None)
        if cfg_db_collection is None:
            logger.info('simulation database paths: []')
            return []

        from py_canoe.core.child_elements.databases import Databases
        cfg_dbs = Databases(cfg_db_collection)
        for j in range(1, cfg_dbs.count + 1):
            db = cfg_dbs.item(j)
            if db.full_name is not None:
                paths.append(db.full_name)

        logger.info(f'simulation database paths: {paths}')
        return paths
    except Exception as e:
        raise ConfigurationNotLoadedError(f"Cannot access simulation databases: {e}") from e