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

py_canoe/core/application.py

@@ -0,0 +1,170 @@
+from pathlib import Path
+
+import win32com.client
+import win32com.client.gencache
+
+from py_canoe.core.bus import Bus
+from py_canoe.core.capl import Capl
+from py_canoe.core.configuration import Configuration
+from py_canoe.core.environment import Environment
+from py_canoe.core.measurement import Measurement
+from py_canoe.core.networks import Networks
+from py_canoe.core.system import System
+from py_canoe.core.ui import Ui
+from py_canoe.core.version import Version
+from py_canoe.helpers.common import DoEventsUntil, logger
+
+
+class ApplicationEvents:
+    def __init__(self) -> None:
+        self.OPENED: bool = False
+        self.QUIT: bool = False
+        self.CANOE_CFG_FULLNAME: str = ""
+
+    def OnOpen(self, fullname: str) -> None:
+        self.CANOE_CFG_FULLNAME = fullname
+        self.OPENED = True
+
+    def OnQuit(self) -> None:
+        self.QUIT = True
+
+
+class Application:
+    def __init__(self) -> None:
+        self.bus_types = {'CAN': 1, 'J1939': 2, 'TTP': 4, 'LIN': 5, 'MOST': 6, 'Kline': 14}
+        self.com_object = None
+        self.application_events = None
+        self.bus: Bus = None
+        self.capl: Capl = None
+        self.configuration: Configuration = None
+        self.environment: Environment = None
+        self.measurement: Measurement = None
+        self.system: System = None
+        self.ui: Ui = None
+        self.version: Version = None
+        self.capl_function_objects = object()
+        self.user_capl_functions = tuple()
+
+    @property
+    def full_name(self) -> str:
+        return self.com_object.FullName
+
+    @property
+    def name(self) -> str:
+        return self.com_object.Name
+
+    @property
+    def path(self) -> str:
+        return self.com_object.Path
+
+    @property
+    def visible(self) -> bool:
+        return self.com_object.Visible
+
+    @visible.setter
+    def visible(self, visible: bool) -> None:
+        self.com_object.Visible = visible
+
+    def _common_between_pre_and_post_cfg_open(self) -> None:
+        self.bus = Bus(self)
+        self.capl = Capl(self)
+        self.configuration = Configuration(self)
+        self.environment = Environment(self)
+        self.networks = Networks(self)
+        self.system = System(self)
+        self.ui = Ui(self)
+        self.version = Version(self)
+
+    def _launch_application(self) -> None:
+        try:
+            # We use gencache.EnsureDispatch to connect to the CANoe COM object.
+            # This is preferred over Dispatch or DispatchEx for a few reasons:
+            # 1. It connects to a running instance of CANoe if one exists, and
+            #    starts a new instance if one is not running. This is the desired
+            #    behavior for both attaching to an existing session and starting a new one.
+            # 2. It enables early binding by generating a static proxy in the gencache,
+            #    which can improve performance.
+            # DispatchEx is not used because it would always start a new instance,
+            # which is not what we want for the 'attach' functionality.
+            self.com_object = win32com.client.gencache.EnsureDispatch("CANoe.Application")
+            self.application_events = win32com.client.WithEvents(self.com_object, ApplicationEvents)
+            self.measurement = Measurement(self)
+            self.capl_function_objects = lambda: self.measurement.measurement_events.CAPL_FUNCTION_OBJECTS
+            self.measurement.measurement_events.CAPL_FUNCTION_NAMES = self.user_capl_functions
+            self._common_between_pre_and_post_cfg_open()
+        except Exception as e:
+            logger.error(f"❌ Failed to launch CANoe application: {e}")
+            raise
+
+    def _setup_post_configuration_loading(self) -> None:
+        try:
+            self._common_between_pre_and_post_cfg_open()
+            self.networks.fetch_diagnostic_devices()
+            self.configuration.fetch_test_modules()
+        except Exception as e:
+            logger.error(f"❌ Error initializing objects after loading configuration: {e}")
+
+    def new(self, auto_save: bool = False, prompt_user: bool = False, timeout: int = 5) -> bool:
+        """Create a new empty CANoe configuration."""
+        self._launch_application()
+        status = False
+        try:
+            logger.info("📢 Opening new empty CANoe configuration...")
+            self.com_object.New(auto_save, prompt_user)
+            status = DoEventsUntil(lambda: self.application_events.OPENED, timeout, "New CANoe configuration")
+            if status:
+                logger.info("📢 New empty CANoe configuration Opened 🎉")
+                self._setup_post_configuration_loading()
+        except Exception as e:
+            logger.error(f"❌ Error creating new configuration: {e}")
+            status = False
+        finally:
+            return status
+
+    def open(self, canoe_cfg: str | Path, visible: bool = True, auto_save: bool = True, prompt_user: bool = False, timeout: int = 5) -> bool:
+        """Open an existing CANoe configuration."""
+        self._launch_application()
+        status = False
+        try:
+            self.visible = visible
+            logger.info("📢 Opening CANoe configuration ...")
+            self.com_object.Open(canoe_cfg, auto_save, prompt_user)
+            status = DoEventsUntil(lambda: self.application_events.OPENED, timeout, "Open CANoe configuration")
+            if status:
+                logger.info(f"📢 CANoe Configuration {canoe_cfg} Opened 🎉")
+                self._setup_post_configuration_loading()
+        except Exception as e:
+            logger.error(f"❌ Error opening configuration: {e}")
+            status = False
+        finally:
+            return status
+
+    def quit(self, timeout: int = 5) -> bool:
+        """Quit CANoe and clean up COM references."""
+        status = False
+        try:
+            self.configuration.modified = False
+            self.com_object.Quit()
+            status = DoEventsUntil(lambda: self.application_events.QUIT, timeout, "Quit CANoe application")
+            if status:
+                logger.info("📢 CANoe Application Quit Successfully 🎉")
+        except Exception as e:
+            logger.error(f"❌ Error during CANoe quit: {e}")
+            status = False
+        finally:
+            return status
+
+    def attach_to_active_application(self) -> bool:
+        """Attach to a active instance of the CANoe application."""
+        try:
+            self._launch_application()
+            if self.com_object:
+                logger.info("📢 Successfully attached to active CANoe application 🎉")
+                self._setup_post_configuration_loading()
+                return True
+            else:
+                logger.error("❌ Failed to attach to active CANoe application")
+                return False
+        except Exception as e:
+            logger.error(f"❌ Error attaching to active CANoe application: {e}")
+            return False

py_canoe/core/bus.py

@@ -0,0 +1,301 @@
+from typing import Union
+
+from py_canoe.core.child_elements.channels import Channels
+from py_canoe.core.child_elements.database_setup import Databases
+from py_canoe.core.child_elements.nodes import Nodes
+from py_canoe.core.child_elements.ports import Ports
+from py_canoe.core.child_elements.replay_collection import ReplayCollection
+from py_canoe.core.child_elements.security_configuration import SecurityConfiguration
+from py_canoe.core.child_elements.signals import Signal
+from py_canoe.helpers.common import logger
+
+
+class Bus:
+    """
+    The Bus object represents a bus of the CANoe application.
+    """
+    def __init__(self, app):
+        self.app = app
+        self.com_object = self.set_bus('CAN')
+        self.VALUE_TABLE_SIGNAL_IS_ONLINE = {
+            True: "measurement is running and the signal has been received.",
+            False: "The signal is not online."
+        }
+        self.VALUE_TABLE_SIGNAL_STATE = {
+            0: "The default value of the signal is returned.",
+            1: "The measurement is not running. The value set by the application is returned.",
+            2: "The measurement is not running. The value of the last measurement is returned.",
+            3: "The signal has been received in the current measurement. The current value is returned."
+        }
+
+    def set_bus(self, bus_type: str = 'CAN'):
+        try:
+            self.com_object = self.app.com_object.GetBus(bus_type)
+        except Exception as e:
+            logger.error(f"❌ Error retrieving {bus_type} bus: {e}")
+        finally:
+            return self.com_object
+
+    @property
+    def active(self) -> bool:
+        return self.com_object.Active
+
+    @property
+    def baudrate(self) -> int:
+        return self.com_object.Baudrate()
+
+    @baudrate.setter
+    def baudrate(self, value: int):
+        self.com_object.SetBaudrate(value)
+
+    @property
+    def channels(self) -> 'Channels':
+        return Channels(self.com_object.Channels)
+
+    @property
+    def databases(self) -> 'Databases':
+        return Databases(self.com_object.Databases)
+
+    @property
+    def name(self) -> str:
+        return self.com_object.Name
+
+    @name.setter
+    def name(self, name: str):
+        self.com_object.Name = name
+
+    @property
+    def nodes(self) -> 'Nodes':
+        return Nodes(self.com_object.Nodes)
+
+    @property
+    def ports(self) -> 'Ports':
+        return Ports(self.com_object.Port)
+
+    @property
+    def ports_of_channel(self) -> 'Ports':
+        return Ports(self.com_object.PortsOfChannel)
+
+    @property
+    def replay_collection(self) -> 'ReplayCollection':
+        return ReplayCollection(self.com_object.ReplayCollection)
+
+    @property
+    def security_configuration(self) -> 'SecurityConfiguration':
+        return SecurityConfiguration(self.com_object.SecurityConfiguration)
+
+    def get_signal(self, channel: int, message: str, signal: str) -> Signal:
+        return Signal(self.com_object.GetSignal(channel, message, signal))
+
+    def get_j1939_signal(self, channel: int, message: str, signal: str, source_address: int, destination_address: int) -> Signal:
+        return Signal(self.com_object.GetJ1939Signal(channel, message, signal, source_address, destination_address))
+
+    def get_bus_databases_info(self, bus: str = 'CAN') -> dict:
+        try:
+            bus_type = bus.upper()
+            if bus_type not in self.app.bus_types:
+                logger.error(f"❌ Invalid bus type '{bus_type}'. Supported types: {', '.join(self.app.bus_types)}")
+                return {}
+            databases_info = {}
+            self.set_bus(bus_type)
+            for db_obj in self.com_object.Databases:
+                info = {
+                    'full_name': getattr(db_obj, 'FullName', None),
+                    'path': getattr(db_obj, 'Path', None),
+                    'name': getattr(db_obj, 'Name', None),
+                    'channel': getattr(db_obj, 'Channel', None),
+                    'com_obj': db_obj,
+                }
+                databases_info[info['name']] = info
+            logger.info(f'📜 {bus_type} 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.error(f"❌ Error retrieving {bus} bus databases information: {e}")
+            return {}
+
+    def get_bus_nodes_info(self, bus: str = 'CAN') -> dict:
+        try:
+            bus_type = bus.upper()
+            if bus_type not in self.app.bus_types:
+                logger.error(f"❌ Invalid bus type '{bus_type}'. Supported types: {', '.join(self.app.bus_types)}")
+                return {}
+            nodes_info = {}
+            self.set_bus(bus_type)
+            for node_obj in self.com_object.Nodes:
+                info = {
+                    'full_name': getattr(node_obj, 'FullName', None),
+                    'path': getattr(node_obj, 'Path', None),
+                    'name': getattr(node_obj, 'Name', None),
+                    'active': getattr(node_obj, 'Active', None),
+                    'com_obj': node_obj,
+                }
+                nodes_info[info['name']] = info
+            logger.info(f'📜 {bus_type} 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_signal_value(self, bus: str, channel: int, message: str, signal: str, raw_value: bool = False) -> Union[int, float, None]:
+        try:
+            bus_type = bus.upper()
+            if bus_type not in self.app.bus_types:
+                logger.error(f"❌ Invalid bus type '{bus_type}'. Supported types: {', '.join(self.app.bus_types)}")
+                return None
+            self.set_bus(bus_type)
+            signal_obj = self.get_signal(channel, message, signal)
+            value = signal_obj.raw_value if raw_value else signal_obj.value
+            logger.info(f"🚦Signal({signal_obj.full_name}) value = {value}")
+            return value
+        except Exception as e:
+            logger.error(f"❌ Error retrieving {bus} bus signal value: {e}")
+            return None
+
+    def set_signal_value(self, bus: str, channel: int, message: str, signal: str, value: Union[int, float], raw_value: bool = False) -> bool:
+        try:
+            bus_type = bus.upper()
+            if bus_type not in self.app.bus_types:
+                logger.error(f"❌ Invalid bus type '{bus_type}'. Supported types: {', '.join(self.app.bus_types)}")
+                return False
+            self.set_bus(bus_type)
+            signal_obj = self.get_signal(channel, message, signal)
+            if raw_value:
+                signal_obj.raw_value = int(value)
+            else:
+                signal_obj.value = value
+            logger.info(f"🚦Signal({signal_obj.full_name}) value set to {value}")
+            return True
+        except Exception as e:
+            logger.error(f"❌ Error setting {bus} bus signal value: {e}")
+            return False
+
+    def get_signal_full_name(self, bus: str, channel: int, message: str, signal: str) -> Union[str, None]:
+        try:
+            bus_type = bus.upper()
+            if bus_type not in self.app.bus_types:
+                logger.error(f"❌ Invalid bus type '{bus_type}'. Supported types: {', '.join(self.app.bus_types)}")
+                return None
+            self.set_bus(bus_type)
+            signal_obj = self.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 check_signal_online(self, bus: str, channel: int, message: str, signal: str) -> bool:
+        try:
+            bus_type = bus.upper()
+            if bus_type not in self.app.bus_types:
+                logger.error(f"❌ Invalid bus type '{bus_type}'. Supported types: {', '.join(self.app.bus_types)}")
+                return False
+            self.set_bus(bus_type)
+            signal_obj = self.get_signal(channel, message, signal)
+            is_online = signal_obj.is_online
+            logger.info(f'🚦Signal({signal_obj.full_name}) is online ?: {is_online} ({self.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: str, channel: int, message: str, signal: str) -> int:
+        try:
+            bus_type = bus.upper()
+            if bus_type not in self.app.bus_types:
+                logger.error(f"❌ Invalid bus type '{bus_type}'. Supported types: {', '.join(self.app.bus_types)}")
+                return -1
+            self.set_bus(bus_type)
+            signal_obj = self.get_signal(channel, message, signal)
+            state = signal_obj.state
+            logger.info(f'🚦Signal({signal_obj.full_name}) state: {state} ({self.VALUE_TABLE_SIGNAL_STATE[state]})')
+            return state
+        except Exception as e:
+            logger.error(f"❌ Error checking {bus} bus signal state: {e}")
+            return -1
+
+    def get_j1939_signal_value(self, bus: str, channel: int, message: str, signal: str, source_addr: int, dest_addr: int, raw_value=False) -> Union[float, int, None]:
+        try:
+            bus_type = bus.upper()
+            if bus_type not in self.app.bus_types:
+                logger.error(f"❌ Invalid bus type '{bus_type}'. Supported types: {', '.join(self.app.bus_types)}")
+                return None
+            self.set_bus(bus_type)
+            signal_obj = self.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}')
+            return signal_value
+        except Exception as e:
+            logger.error(f"❌ Error retrieving J1939 bus signal value: {e}")
+            return None
+
+    def set_j1939_signal_value(self, bus: str, channel: int, message: str, signal: str, source_addr: int, dest_addr: int, value: Union[float, int], raw_value: bool = False) -> bool:
+        try:
+            bus_type = bus.upper()
+            if bus_type not in self.app.bus_types:
+                logger.error(f"❌ Invalid bus type '{bus_type}'. Supported types: {', '.join(self.app.bus_types)}")
+                return False
+            self.set_bus(bus_type)
+            signal_obj = self.get_j1939_signal(channel, message, signal, source_addr, dest_addr)
+            if raw_value:
+                signal_obj.raw_value = int(value)
+            else:
+                signal_obj.value = value
+            logger.info(f'🚦J1939 Signal({signal_obj.full_name}) value set to {value}')
+            return True
+        except Exception as e:
+            logger.error(f"❌ Error setting J1939 bus signal value: {e}")
+            return False
+
+    def get_j1939_signal_full_name(self, bus: str, channel: int, message: str, signal: str, source_addr: int, dest_addr: int) -> Union[str, None]:
+        try:
+            bus_type = bus.upper()
+            if bus_type not in self.app.bus_types:
+                logger.error(f"❌ Invalid bus type '{bus_type}'. Supported types: {', '.join(self.app.bus_types)}")
+                return None
+            self.set_bus(bus_type)
+            signal_obj = self.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 check_j1939_signal_online(self, bus: str, channel: int, message: str, signal: str, source_addr: int, dest_addr: int) -> bool:
+        try:
+            bus_type = bus.upper()
+            if bus_type not in self.app.bus_types:
+                logger.error(f"❌ Invalid bus type '{bus_type}'. Supported types: {', '.join(self.app.bus_types)}")
+                return False
+            self.set_bus(bus_type)
+            signal_obj = self.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} ({self.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: str, channel: int, message: str, signal: str, source_addr: int, dest_addr: int) -> int:
+        try:
+            bus_type = bus.upper()
+            if bus_type not in self.app.bus_types:
+                logger.error(f"❌ Invalid bus type '{bus_type}'. Supported types: {', '.join(self.app.bus_types)}")
+                return -1
+            self.set_bus(bus_type)
+            signal_obj = self.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} ({self.VALUE_TABLE_SIGNAL_STATE[state]})')
+            return state
+        except Exception as e:
+            logger.error(f"❌ Error checking J1939 bus signal state: {e}")
+            return -1

py_canoe/core/capl.py

@@ -0,0 +1,59 @@
+from typing import Union
+
+from py_canoe.helpers.common import logger
+from py_canoe.helpers.common import wait
+
+from py_canoe.core.child_elements.capl_function import CaplFunction
+from py_canoe.core.child_elements.compile_result import CompileResult
+
+
+class Capl:
+    """
+    The CAPL object allows to compile all nodes (CAPL, .NET, XML) in the configuration. Additionally it represents the CAPL functions available in the CAPL programs.
+    Please note that only user-defined CAPL functions can be accessed.
+    """
+    def __init__(self, app):
+        self.com_object = app.com_object.CAPL
+        self.capl_function_objects = lambda: app.measurement.measurement_events.CAPL_FUNCTION_OBJECTS
+
+    @property
+    def compile_result(self) -> 'CompileResult':
+        return CompileResult(self.com_object.CompileResult)
+
+    def compile(self, wait_time: Union[int, float] = 5) -> Union['CompileResult', None]:
+        try:
+            self.com_object.Compile()
+            wait(wait_time)
+            compile_result = self.compile_result
+            logger.info(f'🧑‍💻 compiled all CAPL nodes. result={compile_result.result}')
+            return compile_result
+        except Exception as e:
+            logger.error(f"❌ Error compiling CAPL nodes: {e}")
+            return None
+
+    def get_function(self, name: str) -> Union['CaplFunction', None]:
+        if name in self.capl_function_objects():
+            return self.capl_function_objects()[name]
+        else:
+            logger.warning(f'⚠️ CAPL function "{name}" not found/registered.')
+            return None
+
+    def call_capl_function(self, name: str, *arguments) -> bool:
+        try:
+            capl_function = self.get_function(name)
+            if capl_function:
+                if len(arguments) != capl_function.parameter_count:
+                    logger.warning(f"⚠️ Not enough arguments provided for CAPL function '{name}'.")
+                    return False
+                else:
+                    if len(arguments) > 0:
+                        capl_function.call(*arguments)
+                    else:
+                        capl_function.call()
+                    return True
+            else:
+                logger.warning(f"⚠️ CAPL function '{name}' not found.")
+                return False
+        except Exception as e:
+            logger.error(f"❌ Error calling CAPL function '{name}': {e}")
+            return False

py_canoe/core/child_elements/application_model.py

@@ -0,0 +1,24 @@
+import win32com.client
+
+from py_canoe.core.child_elements.application_model_files import ApplicationModelFiles
+from py_canoe.core.child_elements.participants import Participants
+
+
+class ApplicationModel:
+    """
+    Represents a single application model.
+    """
+    def __init__(self, com_object) -> None:
+        self.com_object = win32com.client.Dispatch(com_object)
+
+    @property
+    def application_model_files(self) -> 'ApplicationModelFiles':
+        return ApplicationModelFiles(self.com_object.ApplicationModelFiles)
+
+    @property
+    def is_active(self) -> bool:
+        return self.com_object.IsActive
+
+    @property
+    def participants(self) -> 'Participants':
+        return Participants(self.com_object.Participants)

py_canoe/core/child_elements/application_model_file.py

@@ -0,0 +1,21 @@
+import win32com.client
+
+
+class ApplicationModelFile:
+    """
+    Represents a file associated with an application model.
+    """
+    def __init__(self, com_object) -> None:
+        self.com_object = win32com.client.Dispatch(com_object)
+
+    @property
+    def full_name(self) -> str:
+        return self.com_object.FullName
+
+    @property
+    def name(self) -> str:
+        return self.com_object.Name
+
+    @property
+    def path(self) -> str:
+        return self.com_object.Path

py_canoe/core/child_elements/application_model_files.py

@@ -0,0 +1,22 @@
+from py_canoe.core.child_elements.application_model_file import ApplicationModelFile
+
+
+class ApplicationModelFiles:
+    """
+    Collection of ApplicationModelFile objects (immutable).
+    """
+    def __init__(self, com_object) -> None:
+        self.com_object = com_object
+
+    @property
+    def count(self) -> int:
+        return self.com_object.Count
+
+    def item(self, index: int) -> 'ApplicationModelFile':
+        return ApplicationModelFile(self.com_object.Item(index))
+
+    def add(self, application_model_file_path: str) -> 'ApplicationModelFile':
+       self.com_object.Add(application_model_file_path)
+
+    def remove(self, index: int):
+        self.com_object.Remove(index)

py_canoe/core/child_elements/application_model_setup.py

@@ -0,0 +1,15 @@
+import win32com.client
+
+from py_canoe.core.child_elements.application_models import ApplicationModels
+
+
+class ApplicationModelSetup:
+    """
+    Provides access to the application model management API.
+    """
+    def __init__(self, com_object) -> None:
+        self.com_object = com_object
+
+    @property
+    def application_models(self) -> 'ApplicationModels':
+        return ApplicationModels(self.com_object.ApplicationModels)

py_canoe/core/child_elements/application_models.py

@@ -0,0 +1,22 @@
+from py_canoe.core.child_elements.application_model import ApplicationModel
+
+
+class ApplicationModels:
+    """
+    Collection of ApplicationModel objects.
+    """
+    def __init__(self, com_object) -> None:
+        self.com_object = com_object
+
+    @property
+    def count(self) -> int:
+        return self.com_object.Count
+
+    def item(self, index: int) -> 'ApplicationModel':
+        return ApplicationModel(self.com_object.Item(index))
+
+    def add(self, file_path: str) -> 'ApplicationModel':
+        return ApplicationModel(self.com_object.Add(file_path))
+
+    def remove(self, index: int):
+        self.com_object.Remove(index)

py_canoe/core/child_elements/application_socket.py

@@ -0,0 +1,11 @@
+class ApplicationSocket:
+    def __init__(self, com_object):
+        self.com_object = com_object
+
+    @property
+    def bus_registry(self) -> bytearray:
+        return self.com_object.BusRegistry
+
+    @property
+    def fb_lock_list(self) -> bytearray:
+        return self.com_object.FBlockList

py_canoe/core/child_elements/application_specific_module.py

@@ -0,0 +1,24 @@
+import win32com.client
+
+
+class ApplicationSpecificModule:
+    """
+    Represents an application specific VT System module (e.g., VT7900 with application board or UserFPGA).
+    """
+    def __init__(self, app_specific_module_com_obj):
+        self.com_object = win32com.client.Dispatch(app_specific_module_com_obj)
+
+    @property
+    def name(self) -> str:
+        """The name of the module. For User FPGA, includes project name."""
+        return self.com_object.Name
+
+    @property
+    def base_type(self) -> int:
+        """The basic module type (e.g. 1004)."""
+        return self.com_object.BaseType
+
+    @property
+    def id(self) -> int:
+        """The unique ID of this application specific module."""
+        return self.com_object.ID