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) -> 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)
    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) -> list[dict]:
    """returns all available 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.
    """
    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_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

def get_symbols(self, logger_index: int) -> list['ExporterSymbol']:
    """Return all exporter symbols from given logger."""
    return self.application.configuration.get_symbols(logger_index)

def get_system_variable_value(self, sys_var_name: str, return_symbolic_name: bool = False, return_timestamp: bool = False, enable_events: bool = True) -> Union[int, float, str, None, tuple]:
    """
    Gets the value of a system variable.

    Args:
        sys_var_name (str): The name of the system variable.
        return_symbolic_name (bool): Whether to return the symbolic name.
        return_timestamp (bool): Whether to return the timestamp in timezone utc along with the signal value. Defaults to False.
        enable_events (bool): This argument is deprecated and will be removed in a future version.

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