opensignalbox-interface 0.1.0__py3-none-any.whl

opensignalbox/interface/interfaces/bell/models.py

@@ -0,0 +1,103 @@
+"""
+Bell interface models.
+"""
+
+from enum import Enum
+from typing import List, Literal, Optional
+
+from opensignalbox.common.models import CamelModel
+from opensignalbox.common.variables import SharedVariable
+from opensignalbox.interface.models import (
+    Interface,
+    InterfaceBase,
+    InterfaceTypeEnum,
+    InterfaceUpdate,
+)
+
+
+class BellConnectionType(str, Enum):
+    """Connection types for Bell interfaces."""
+
+    MODBUS_ADAPTER = "ModbusAdapter"
+    DIRECT_TCP = "DirectTCP"
+    TEST = "Test"  # For testing purposes only
+
+
+class ForceStateEnum(str, Enum):
+    """Enum for force states."""
+
+    ON = "on"
+    OFF = "off"
+    NONE = "none"  # To remove forcing
+
+
+class BellChannelConfig(CamelModel):
+    pass
+
+
+class BellChannel(CamelModel):
+    """Model for Bell channels."""
+
+    system_name: str
+    user_name: str
+    description: str = ""
+    tags: List[str] = []
+    in_count: int = 0
+    in_code: str = ""
+    in_shared_variable: Optional[SharedVariable] = None
+    out_count: int = 0
+    last_out_count: int = 0
+    out_code: str = ""
+    out_shared_variable_name: str | None = None
+
+
+class BellInterfaceFields(CamelModel):
+    """Mixin with Bell-specific fields."""
+
+    connection_type: BellConnectionType = BellConnectionType.MODBUS_ADAPTER
+
+    channels: dict[int, BellChannel] = {}
+
+    # Fields for modbus connection
+    modbus_address: Optional[int] = None
+
+    # Fields for TCP connection
+    tcp_host: Optional[str] = None
+    tcp_port: Optional[int] = None
+
+
+class BellInterfaceBase(Interface, BellInterfaceFields):
+    """Base model with Bell-specific fields."""
+
+    pass
+
+
+class BellInterface(BellInterfaceBase):
+    """Runtime model for Bell interfaces."""
+
+    pass
+
+
+class BellInterfaceCreate(InterfaceBase, BellInterfaceFields):
+    """API model for creating Bell interfaces."""
+
+    interface_type: Literal[InterfaceTypeEnum.BELL] = InterfaceTypeEnum.BELL
+
+
+class BellInterfacePublic(BellInterfaceBase):
+    """API model for Bell interface responses."""
+
+    pass
+
+
+class BellInterfaceUpdate(InterfaceUpdate):
+    """API model for updating Bell interfaces."""
+
+    pass
+
+
+class BellForceMessage(CamelModel):
+    """Message for setting force state on Bell channels."""
+
+    channel: int
+    state: ForceStateEnum

opensignalbox/interface/interfaces/controller.py

@@ -0,0 +1,467 @@
+"""
+Interface controller for managing all interfaces in the opensignalbox-interface module.
+"""
+
+import json
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Type
+
+from anyio import sleep
+from opensignalbox.common.messaging import get_messager
+from opensignalbox.common.variables import SharedVariableCollection
+from opensignalbox.interface.adapters.controller import AdapterController
+from opensignalbox.interface.interfaces.base import InterfaceHandler
+from opensignalbox.interface.interfaces.basicio.handler import BasicIOInterfaceHandler
+from opensignalbox.interface.interfaces.bell.handler import BellInterfaceHandler
+from opensignalbox.interface.models import (
+    Interface,
+    InterfaceTypeEnum,
+    InterfaceTypeInfo,
+    ModuleConfig,
+)
+
+logger = logging.getLogger(__name__)
+messager = get_messager()
+
+MAX_RETRIES = 3
+
+
+class InterfaceController:
+    """Controller for managing all interfaces."""
+
+    def __init__(
+        self,
+        config_path: Path,
+        output_variables: SharedVariableCollection,
+        adapters: AdapterController,
+    ) -> None:
+        self.interfaces: Dict[str, Interface] = {}
+        self.config_path = config_path
+        self.output_variables = output_variables
+        self.input_variable_subs: Dict[str, List[Any]] = {}
+        self.adapters = adapters
+        self.module_config = ModuleConfig()
+        self.output_sync_countdown: int = 0
+
+        # Initialize interface handlers dictionary (will be populated by register_handler)
+        self.interface_handlers: Dict[InterfaceTypeEnum, Type[InterfaceHandler]] = {}
+
+        # Dictionary to store interface-specific routers
+        self.interface_routers: Dict[InterfaceTypeEnum, Any] = {}
+
+    def register_handler(
+        self, interface_type: InterfaceTypeEnum, handler: Type[InterfaceHandler]
+    ) -> None:
+        """Register a handler for an interface type.
+
+        Args:
+            interface_type: The type of interface this handler handles
+            handler: The handler class for this interface type
+        """
+        # Initialize the handler with controller references
+        handler.init(
+            output_variables=self.output_variables,
+            input_variable_subs=self.input_variable_subs,
+            variable_update_callback=self.variable_update_callback,
+        )
+
+        # Set the controllers for the handler
+        handler.set_controllers(self, self.adapters)
+
+        # Register the handler
+        self.interface_handlers[interface_type] = handler
+
+        # Check if the handler provides a router
+        router = handler.get_router()
+        if router:
+            self.interface_routers[interface_type] = router
+
+    def register_interface_handlers(self) -> None:
+        """Register all interface handlers."""
+        self.register_handler(InterfaceTypeEnum.BASICIO, BasicIOInterfaceHandler)
+        self.register_handler(InterfaceTypeEnum.BELL, BellInterfaceHandler)
+
+    def add(self, interface: Interface) -> Interface:
+        """Add an interface to the controller.
+
+        Args:
+            interface: The interface to add
+
+        Returns:
+            The initialized interface
+
+        Raises:
+            FileExistsError: If an interface with the same system name already exists
+            TypeError: If the interface type is unknown
+        """
+        if interface.system_name in self.interfaces:
+            raise FileExistsError(
+                f"Interface with system name '{interface.system_name}' already exists"
+            )
+
+        try:
+            # Use the handler based on interface type
+            handler = self.interface_handlers.get(interface.interface_type)
+            if not handler:
+                raise TypeError(f"Unknown interface type: {interface.interface_type}")
+
+            # Handler.add already does type conversion if needed
+            specialized_interface = handler.add(interface)
+            self.interfaces[interface.system_name] = specialized_interface
+            return specialized_interface
+        except Exception as e:
+            logger.error(f"Failed to add interface: {e}")
+            raise
+
+    def get_all(self) -> Dict[str, Interface]:
+        """Get all interfaces.
+
+        Returns:
+            Dictionary of interfaces keyed by system name
+        """
+        return self.interfaces
+
+    def get_interface_type_infos(self) -> List["InterfaceTypeInfo"]:
+        """Get all available interface types with their metadata.
+
+        Returns:
+            List of interface type info objects
+        """
+        from opensignalbox.interface.models import InterfaceTypeInfo
+
+        type_infos = []
+        for interface_type, handler_class in self.interface_handlers.items():
+            # Get metadata from the handler class
+            metadata = getattr(handler_class, "metadata", {})
+
+            type_info = InterfaceTypeInfo(
+                interface_type=interface_type,
+                name=metadata.get("name", interface_type.value),
+                description=metadata.get(
+                    "description", f"{interface_type.value} interface"
+                ),
+                supported_connection_types=metadata.get(
+                    "supported_connection_types", []
+                ),
+                required_fields=metadata.get("required_fields", []),
+                optional_fields=metadata.get("optional_fields", []),
+            )
+            type_infos.append(type_info)
+
+        return type_infos
+
+    def get(self, system_name: str) -> Interface:
+        """Get an interface by system name.
+
+        Args:
+            system_name: The system name of the interface
+
+        Returns:
+            The interface
+
+        Raises:
+            KeyError: If no interface with the given system name exists
+        """
+        try:
+            return self.interfaces[system_name]
+        except KeyError as exc:
+            raise KeyError(f"Cannot find interface '{system_name}'") from exc
+
+    def update(self, system_name: str, fields: Dict[str, Any]) -> Interface:
+        """Update an interface.
+
+        Args:
+            system_name: The system name of the interface to update
+            fields: The fields to update
+
+        Returns:
+            The updated interface
+
+        Raises:
+            KeyError: If no interface with the given system name exists
+            TypeError: If the interface type is unknown
+        """
+        try:
+            interface = self.interfaces[system_name]
+            # Use the handler based on interface type
+            handler = self.interface_handlers.get(interface.interface_type)
+            if not handler:
+                raise TypeError(f"Unknown interface type: {interface.interface_type}")
+            # Update the interface using the handler
+            handler.update(interface, fields)
+            return self.interfaces[system_name]
+        except KeyError as exc:
+            raise KeyError(f"Cannot find interface '{system_name}'") from exc
+
+    def remove(self, system_name: str) -> None:
+        """Remove an interface.
+
+        Args:
+            system_name: The system name of the interface to remove
+
+        Raises:
+            KeyError: If no interface with the given system name exists
+            TypeError: If the interface type is unknown
+        """
+        try:
+            interface = self.interfaces[system_name]
+            # Use the handler based on interface type
+            handler = self.interface_handlers.get(interface.interface_type)
+            if not handler:
+                raise TypeError(f"Unknown interface type: {interface.interface_type}")
+            # Remove the interface using the handler
+            handler.remove(interface)
+            del self.interfaces[system_name]
+        except KeyError as exc:
+            raise KeyError(f"Cannot find interface '{system_name}'") from exc
+
+    def variable_update_callback(self, variable: str, json_data: str) -> None:
+        """Callback for variable updates.
+
+        Args:
+            variable: The name of the variable that was updated
+            json_data: The serialized JSON data of the variable update
+        """
+        # Check if we have any interfaces subscribed to this variable
+        if variable in self.input_variable_subs:
+            for iface_tuple in self.input_variable_subs[variable]:
+                interface_name = iface_tuple[0]  # Assuming the tuple structure
+
+                # Get the interface and its handler
+                try:
+                    interface = self.interfaces[interface_name]
+                    handler = self.interface_handlers.get(interface.interface_type)
+                    if handler:
+                        # Let the handler process the variable update
+                        handler.handle_variable_update(interface, variable, json_data)
+                except (KeyError, TypeError) as e:
+                    logger.error(f"Error handling variable update: {e}")
+
+    def sync_interfaces(self) -> None:
+        """Synchronize all interfaces with their adapters."""
+        for interface_name, interface in self.interfaces.items():
+            # logger.debug(f"Syncing interface '{interface_name}', with enabled={interface.enabled}, connected={interface.is_connected}")
+            if not interface.enabled or not interface.is_connected:
+                continue
+
+            handler = self.interface_handlers.get(interface.interface_type)
+            if not handler:
+                logger.error(
+                    f"Unknown interface type for '{interface_name}': {interface.interface_type}"
+                )
+                continue
+
+            retries = 0
+            while retries < MAX_RETRIES:
+                try:
+                    # Attempt to sync the interface
+                    # Read from hardware
+                    handler.read_data(interface)
+                    # Write to hardware
+                    handler.write_data(interface)
+                    interface.error = None  # Clear any previous error
+                    break
+                except Exception as e:
+                    logger.error(f"Error syncing interface '{interface_name}': {e}")
+                    logger.info(
+                        f"Retrying sync for interface '{interface_name}' ({retries + 1}/{MAX_RETRIES})"
+                    )
+                    retries += 1
+                    if retries >= MAX_RETRIES:
+                        interface.error = str(e)
+                        logger.error(
+                            f"Max retries reached for interface '{interface_name}', disabling it."
+                        )
+                        interface.enabled = False
+                        handler.disconnect(interface)  # Ensure we disconnect on failure
+                        handler.connect(interface)  # Attempt to reconnect
+
+    async def tick(self) -> None:
+        """Perform a tick update for interfaces not synchronized on systick."""
+        self.sync_interfaces()
+        await sleep(self.module_config.input_update_period)
+
+    def load_from_json(self) -> None:
+        """Load configuration from a JSON file."""
+
+        # First the module config
+        self.config_filepath = self.config_path / "module_config.json"
+        if not self.config_filepath.exists():
+            logger.warning(f"Module config file not found: {self.config_filepath}")
+            logger.info("Creating default module config")
+            # Create default config if it doesn't exist
+            self.module_config = ModuleConfig()
+            self.save_module_config()
+
+        try:
+            with open(self.config_filepath, "r") as f:
+                config_data = json.load(f)
+                self.module_config.input_update_period = config_data.get(
+                    "input_update_period", 0.1
+                )
+                self.module_config.output_update_period = config_data.get(
+                    "output_update_period", 1
+                )
+                self.module_config.sync_on_systick = config_data.get(
+                    "sync_on_systick", False
+                )
+        except Exception as e:
+            logger.error(
+                f"Error loading module config from {self.config_filepath}, using defaults: {e}"
+            )
+
+        # Now load each interface in the interfaces directory
+        interfaces_config_dir = self.config_path / "interfaces"
+        if not interfaces_config_dir.exists():
+            logger.warning(
+                f"Interfaces config directory not found: {interfaces_config_dir}"
+            )
+            return
+
+        # Clear existing interfaces
+        for interface in self.interfaces.values():
+            try:
+                handler = self.interface_handlers.get(interface.interface_type)
+                if handler:
+                    handler.remove(interface)
+            except Exception as e:
+                logger.error(f"Error removing interface '{interface.system_name}': {e}")
+
+        for interface_file in interfaces_config_dir.glob("*.json"):
+            try:
+                with open(interface_file, "r") as f:
+                    interface_data = json.load(f)
+                    # Use the handler based on interface type
+                    interface_name = interface_data.get("system_name")
+                    interface_type = interface_data.get("interface_type")
+                    adapter_name = interface_data.get("adapter_name")
+
+                    if adapter_name:
+                        adapter = self.adapters.get(adapter_name)
+                        if not adapter:
+                            logger.error(
+                                f"Adapter '{adapter_name}' not found for interface '{interface_name}'"
+                            )
+                            raise KeyError(f"Adapter '{adapter_name}' not found")
+
+                    handler = self.interface_handlers.get(interface_type)
+                    if not handler:
+                        logger.error(
+                            f"Unknown interface type for '{interface_name}': {interface_type}"
+                        )
+                        raise TypeError(f"Unknown interface type: {interface_type}")
+                    handler.load_from_json(interface_data)
+            except Exception as e:
+                logger.error(f"Error loading interface from {interface_file}: {e}")
+
+    def save_module_config(self) -> None:
+        """Save the module configuration to a JSON file."""
+        try:
+            with open(self.config_filepath, "w") as f:
+                json.dump(self.module_config.model_dump(), f, indent=2)
+        except Exception as e:
+            logger.error(f"Error saving module config to {self.config_filepath}: {e}")
+
+    def save_to_json(self, suffix: str | None = None) -> None:
+        """Save configuration to a JSON file.
+        Args:
+            suffix: Optional suffix to append to the interface filenames
+        """
+
+        # Save the module config first
+        self.save_module_config()
+
+        # Save each interface
+        interfaces_config_dir = self.config_path / "interfaces"
+        interfaces_config_dir.mkdir(parents=True, exist_ok=True)
+
+        for interface in self.interfaces.values():
+            interface_file = (
+                interfaces_config_dir / f"{interface.system_name}{suffix or ''}.json"
+            )
+            try:
+                with open(interface_file, "w") as f:
+                    # Use the handler based on interface type
+                    handler = self.interface_handlers.get(interface.interface_type)
+                    if handler:
+                        json.dump(handler.save_to_json(interface), f, indent=2)
+                    else:
+                        logger.error(
+                            f"Unknown interface type for '{interface.system_name}': {interface.interface_type}"
+                        )
+            except Exception as e:
+                logger.error(
+                    f"Error saving interface '{interface.system_name}' to {interface_file}: {e}"
+                )
+
+    def get_interface_routers(self) -> Dict[InterfaceTypeEnum, Any]:
+        """Get all registered interface routers.
+
+        Returns:
+            Dictionary of FastAPI routers keyed by interface type
+        """
+        return self.interface_routers
+
+    def connect_all(self) -> None:
+        """Connect all interfaces."""
+        for interface in self.interfaces.values():
+            if not interface.enabled:
+                continue
+            handler = self.interface_handlers.get(interface.interface_type)
+            if handler:
+                retries = 0
+                while retries < MAX_RETRIES and not interface.is_connected:
+                    retries += 1
+                    logger.info(
+                        f"Connecting interface '{interface.system_name}' (attempt {retries}/{MAX_RETRIES})"
+                    )
+                    handler.connect(interface)
+                    if interface.is_connected:
+                        logger.info(
+                            f"Interface '{interface.system_name}' connected successfully"
+                        )
+                        interface.error = None
+                        break
+                else:
+                    logger.error(
+                        f"Failed to connect interface '{interface.system_name}'"
+                    )
+                    interface.error = "Connection failed"
+                    interface.enabled = False
+            else:
+                logger.error(
+                    f"Unknown interface type for '{interface.system_name}': {interface.interface_type}"
+                )
+
+    def disconnect_all(self) -> None:
+        """Disconnect all interfaces."""
+        for interface in self.interfaces.values():
+            handler = self.interface_handlers.get(interface.interface_type)
+            if handler:
+                handler.disconnect(interface)
+            else:
+                logger.error(
+                    f"Unknown interface type for '{interface.system_name}': {interface.interface_type}"
+                )
+
+    def get_adapter_for_interface(self, interface: Interface) -> Optional[Any]:
+        """Get the adapter instance for a given interface.
+
+        Args:
+            interface: The interface to get the adapter for
+
+        Returns:
+            The adapter instance, or None if no adapter is assigned
+
+        Raises:
+            KeyError: If the adapter name is not found
+        """
+        if not hasattr(interface, "adapter_name") or not interface.adapter_name:
+            return None
+
+        adapter = self.adapters.get(interface.adapter_name)
+        if not adapter:
+            raise KeyError(f"Adapter '{interface.adapter_name}' not found")
+
+        return adapter