opensignalbox-interface 0.1.0__py3-none-any.whl

opensignalbox/interface/interfaces/bell/handler.py

@@ -0,0 +1,802 @@
+"""
+Handler for Bell interfaces.
+"""
+
+import logging
+from typing import Any, Dict, cast
+
+from anyio import sleep
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import StreamingResponse
+from opensignalbox.common.messaging import get_messager
+from opensignalbox.common.sv_wire import decode_sv_message
+from opensignalbox.interface.adapters.base import BaseAdapter
+from opensignalbox.interface.interfaces.base import InterfaceHandler
+from opensignalbox.interface.interfaces.basicio.models import IfaceChanTuple
+from opensignalbox.interface.interfaces.bell.connections import (
+    BellConnection,
+    BellModbusConnection,
+    BellTestConnection,
+)
+from opensignalbox.interface.models import Interface
+
+from .models import (
+    BellConnectionType,
+    BellForceMessage,
+    BellInterface,
+    BellInterfaceCreate,
+    BellInterfacePublic,
+    BellInterfaceUpdate,
+)
+
+logger = logging.getLogger(__name__)
+messager = get_messager()
+
+STATUS_UPDATE_PERIOD = 0.2  # seconds
+
+
+class BellInterfaceHandler(InterfaceHandler):
+    """Handler for Bell interfaces."""
+
+    # Metadata for the API discovery
+    metadata = {
+        "supported_connection_types": ["BellModbusConnection", "BellTestConnection"],
+        "required_fields": ["system_name", "user_name", "interface_type"],
+        "optional_fields": ["description", "adapter_name", "enabled", "modbus_address"],
+    }
+
+    @classmethod
+    def get_router(cls) -> Any:
+        """Get API router for Bell interface endpoints.
+
+        Returns:
+            FastAPI router with Bell interface specific endpoints
+        """
+
+        router = APIRouter(tags=["interfaces/bell"])
+
+        @router.get("/{system_name}", response_model=BellInterfacePublic)
+        async def get_interface(system_name: str):
+            """Get a Bell interface by system name."""
+            if not cls.interface_controller:
+                raise HTTPException(
+                    status_code=500, detail="Interface controller not initialized"
+                )
+
+            try:
+                interface = cls.interface_controller.get(system_name)
+                if interface.interface_type != "Bell":
+                    raise HTTPException(
+                        status_code=404,
+                        detail=f"Bell interface '{system_name}' not found",
+                    )
+                return BellInterfacePublic(**interface.model_dump())
+            except KeyError as exc:
+                raise HTTPException(
+                    status_code=404, detail=f"Interface '{system_name}' not found"
+                ) from exc
+
+        @router.post("/")
+        async def create_interface(interface: BellInterfaceCreate):
+            """Create a new Bell interface."""
+            if not cls.interface_controller:
+                raise HTTPException(
+                    status_code=500, detail="Interface controller not initialized"
+                )
+
+            if interface.interface_type != "Bell":
+                raise HTTPException(
+                    status_code=400, detail="Interface type must be Bell"
+                )
+
+            try:
+                interface_model = BellInterface(**interface.model_dump())
+
+                # Add the interface
+                new_interface = cls.interface_controller.add(interface_model)
+                return new_interface
+            except FileExistsError as exc:
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"Interface '{interface.system_name}' already exists",
+                ) from exc
+            except TypeError as exc:
+                raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+        @router.patch("/{system_name}")
+        async def update_interface(
+            system_name: str, interface_update: BellInterfaceUpdate
+        ):
+            """Update a Bell interface."""
+            if not cls.interface_controller:
+                raise HTTPException(
+                    status_code=500, detail="Interface controller not initialized"
+                )
+
+            try:
+                # Check that the interface exists and is Bell type
+                interface = cls.interface_controller.get(system_name)
+                if interface.interface_type != "Bell":
+                    raise HTTPException(
+                        status_code=404,
+                        detail=f"Bell interface '{system_name}' not found",
+                    )
+
+                # Extract update fields
+                fields = {
+                    k: v
+                    for k, v in interface_update.model_dump().items()
+                    if v is not None
+                }
+
+                # Update the interface
+                updated_interface = cls.interface_controller.update(system_name, fields)
+                return updated_interface
+            except KeyError as exc:
+                raise HTTPException(
+                    status_code=404, detail=f"Interface '{system_name}' not found"
+                ) from exc
+
+        @router.delete("/{system_name}")
+        async def delete_interface(system_name: str):
+            """Delete a Bell interface."""
+            if not cls.interface_controller:
+                raise HTTPException(
+                    status_code=500, detail="Interface controller not initialized"
+                )
+
+            try:
+                # Check that the interface exists and is Bell type
+                interface = cls.interface_controller.get(system_name)
+                if interface.interface_type != "Bell":
+                    raise HTTPException(
+                        status_code=404,
+                        detail=f"Bell interface '{system_name}' not found",
+                    )
+
+                cls.interface_controller.remove(system_name)
+                return {"status": "success"}
+            except KeyError as exc:
+                raise HTTPException(
+                    status_code=404, detail=f"Interface '{system_name}' not found"
+                ) from exc
+
+        @router.post("/{system_name}/connect")
+        async def connect_interface(system_name: str):
+            """Connect to a Bell interface."""
+            if not cls.interface_controller:
+                raise HTTPException(
+                    status_code=500, detail="Interface controller not initialized"
+                )
+
+            try:
+                interface = cls.interface_controller.get(system_name)
+                if interface.interface_type != "Bell":
+                    raise HTTPException(
+                        status_code=404,
+                        detail=f"Bell interface '{system_name}' not found",
+                    )
+
+                # Connect to the interface
+                success = cls.connect(interface)
+                if success:
+                    return {"status": "success"}
+                else:
+                    raise HTTPException(
+                        status_code=500,
+                        detail=f"Failed to connect to interface. Detail: {interface.error}",
+                    )
+            except KeyError as exc:
+                raise HTTPException(
+                    status_code=404, detail=f"Interface '{system_name}' not found"
+                ) from exc
+
+        @router.get("/{system_name}/channel-status")
+        async def status_stream(request: Request, system_name: str):
+            """Stream the channel status of a Bell interface."""
+            if not cls.interface_controller:
+                raise HTTPException(
+                    status_code=500, detail="Interface controller not initialized"
+                )
+
+            try:
+
+                async def status_generator():
+                    if not cls.interface_controller:
+                        raise HTTPException(
+                            status_code=500,
+                            detail="Interface controller not initialized",
+                        )
+                    interface = cls.interface_controller.get(system_name)
+                    if interface.interface_type != "Bell":
+                        raise HTTPException(
+                            status_code=404,
+                            detail=f"Bell interface '{system_name}' not found",
+                        )
+                    while True:
+                        if await request.is_disconnected():
+                            break
+                        # Use controller's get_status method
+                        yield f"data: {cls.get_channel_status(interface)}\n\n"
+                        await sleep(STATUS_UPDATE_PERIOD)
+
+                return StreamingResponse(
+                    status_generator(), media_type="text/event-stream"
+                )
+
+            except KeyError as exc:
+                raise HTTPException(
+                    status_code=404, detail=f"Interface '{system_name}' not found"
+                ) from exc
+
+        @router.put("/{system_name}/forcing")
+        async def set_forcing(system_name: str, force_message: BellForceMessage):
+            """Set forcing for a channel in a Bell interface."""
+            if not cls.interface_controller:
+                raise HTTPException(
+                    status_code=500, detail="Interface controller not initialized"
+                )
+
+            try:
+                interface = cls.interface_controller.get(system_name)
+                if interface.interface_type != "Bell":
+                    raise HTTPException(
+                        status_code=404,
+                        detail=f"Bell interface '{system_name}' not found",
+                    )
+
+                cls.set_forcing(interface, force_message.channel, force_message.state)
+                return {"status": "success"}
+            except KeyError as exc:
+                raise HTTPException(
+                    status_code=404, detail=f"Interface '{system_name}' not found"
+                ) from exc
+
+        @router.put("/{system_name}/send-code")
+        async def send_code(system_name: str, request: Request):
+            """Send a code to a Bell interface."""
+            if not cls.interface_controller:
+                raise HTTPException(
+                    status_code=500, detail="Interface controller not initialized"
+                )
+
+            try:
+                interface = cls.interface_controller.get(system_name)
+                if interface.interface_type != "Bell":
+                    raise HTTPException(
+                        status_code=404,
+                        detail=f"Bell interface '{system_name}' not found",
+                    )
+
+                data = await request.json()
+                if "code" not in data or "channel" not in data:
+                    raise HTTPException(
+                        status_code=400,
+                        detail="Missing 'code' or 'channel' in request body",
+                    )
+
+                code = data["code"]
+                channel = int(data["channel"])
+
+                # Validate channel
+                if channel < 1 or channel > 4:
+                    raise HTTPException(
+                        status_code=400, detail="Channel must be between 1 and 4"
+                    )
+
+                # Send the code
+                cls.send_code(interface, code, channel)
+                return {"status": "success"}
+            except KeyError as exc:
+                raise HTTPException(
+                    status_code=404, detail=f"Interface '{system_name}' not found"
+                ) from exc
+
+        @router.put("/{system_name}/forceReceiveCode")
+        async def force_receive_code(system_name: str, request: Request):
+            """Force receiving a code on a Bell interface."""
+            if not cls.interface_controller:
+                raise HTTPException(
+                    status_code=500, detail="Interface controller not initialized"
+                )
+
+            try:
+                interface = cls.interface_controller.get(system_name)
+                if interface.interface_type != "Bell":
+                    raise HTTPException(
+                        status_code=404,
+                        detail=f"Bell interface '{system_name}' not found",
+                    )
+
+                data = await request.json()
+                if "code" not in data or "channel" not in data:
+                    raise HTTPException(
+                        status_code=400,
+                        detail="Missing 'code' or 'channel' in request body",
+                    )
+
+                code = data["code"]
+                channel = int(data["channel"])
+
+                # Validate channel
+                if channel < 1 or channel > 4:
+                    raise HTTPException(
+                        status_code=400, detail="Channel must be between 1 and 4"
+                    )
+
+                # Force receiving the code
+                cls.force_receive_code(interface, code, channel)
+                return {"status": "success"}
+            except KeyError as exc:
+                raise HTTPException(
+                    status_code=404, detail=f"Interface '{system_name}' not found"
+                ) from exc
+
+        return router
+
+    @staticmethod
+    def add(interface: Interface) -> Interface:
+        """
+        Initialize a BellInterface from an Interface.
+
+        Args:
+            interface: The interface to initialize. Must be a BellInterface or
+                      convertible to a BellInterface.
+
+        Returns:
+            The initialized BellInterface.
+
+        Raises:
+            TypeError: If the interface cannot be converted to a BellInterface.
+        """
+
+        bell_interface = cast(BellInterface, interface)
+
+        for channel_index, channel in bell_interface.channels.items():
+            channel.in_shared_variable = (
+                BellInterfaceHandler.output_variables.new_from_bellcode(
+                    system_name=channel.system_name,
+                    user_name=channel.user_name,
+                    description=channel.description,
+                    tags=channel.tags,
+                    count=channel.in_count,
+                    code=channel.in_code,
+                )
+            )
+
+            channel_var = channel.out_shared_variable_name
+            if channel_var:
+                if channel_var not in BellInterfaceHandler.input_variable_subs:
+                    BellInterfaceHandler.input_variable_subs[channel_var] = []
+                BellInterfaceHandler.input_variable_subs[channel_var].append(
+                    IfaceChanTuple(bell_interface.system_name, channel_index)
+                )
+
+                # Create a closure that captures the interface reference
+                def create_variable_callback(iface):
+                    def callback(var: str, json_data: str):
+                        # Forward to controller's callback which has access to all interfaces
+                        if BellInterfaceHandler.variable_update_callback:
+                            BellInterfaceHandler.variable_update_callback(
+                                var, json_data
+                            )
+
+                    return callback
+
+                # Subscribe with the closure
+                messager.sub(channel_var, create_variable_callback(bell_interface))
+
+        return bell_interface
+
+    @staticmethod
+    def update(interface: Interface, fields: Dict[str, Any]) -> None:
+        """
+        Update a BellInterface.
+
+        Args:
+            interface: The interface to update. Must be a BellInterface or convertible to one.
+            fields: The fields to update.
+
+        Raises:
+            TypeError: If the interface cannot be converted to a BellInterface.
+        """
+
+        bell_interface = cast(BellInterface, interface)
+
+        # Handle basic field updates
+        for field, value in fields.items():
+            if hasattr(bell_interface, field) and value is not None:
+                setattr(bell_interface, field, value)
+
+        # TODO handle variable updates
+
+    @staticmethod
+    def remove(interface: Interface) -> None:
+        """
+        Remove a BellInterface.
+
+        Args:
+            interface: The interface to remove.
+        """
+
+        # TODO remove variable subscriptions
+
+        return
+
+    @staticmethod
+    def handle_variable_update(
+        interface: Interface, variable: str, json_data: str
+    ) -> None:
+        """
+        Handle a variable update for a BellInterface.
+
+        Args:
+            interface: The interface to handle the update for.
+            variable: The name of the variable that was updated.
+            json_data: The JSON data of the updated variable.
+        """
+
+        bell_interface = cast(BellInterface, interface)
+
+        # logger.debug(f"Handling variable update for {variable} with data: {json_data}")
+
+        # Find channels subscribed to this variable
+        channels = []
+        if variable in BellInterfaceHandler.input_variable_subs:
+            for item in BellInterfaceHandler.input_variable_subs[variable]:
+                if item.interface == bell_interface.system_name:
+                    channels.append(item.channel)
+
+        # logger.debug(f"Channels subscribed to variable '{variable}': {channels}")
+
+        # No channels to update
+        if not channels:
+            return
+
+        # Parse the variable data
+        try:
+            data = decode_sv_message(json_data).data
+            code = data.get("code", "")
+
+            # Update each channel
+            for channel in channels:
+                BellInterfaceHandler.send_code(bell_interface, code, channel)
+
+        except Exception as e:
+            logger.error(f"Error parsing variable data: {e}")
+
+    @staticmethod
+    def connect(interface: Interface) -> bool:
+        """
+        Connect to a BellInterface using the specified adapter.
+
+        Args:
+            interface: The interface to connect.
+            adapter: The adapter to use for communication.
+
+        Returns:
+            True if connection was successful, False otherwise.
+        """
+
+        bell_interface = cast(BellInterface, interface)
+
+        # Check if the interface is enabled
+        if not bell_interface.enabled:
+            return False
+
+        # Get the appropriate connection strategy based on connection type
+        connected = False
+        match bell_interface.connection_type:
+            case BellConnectionType.TEST:
+                connected = BellTestConnection.connect(bell_interface)
+            case BellConnectionType.MODBUS_ADAPTER:
+                if BellInterfaceHandler.interface_controller:
+                    adapter = BellInterfaceHandler.interface_controller.get_adapter_for_interface(
+                        interface
+                    )
+                    if not adapter or not adapter.enabled:
+                        return False  # No adapter configured or adapter is disabled
+                    connected = BellModbusConnection.connect(bell_interface, adapter)
+                    # if connected:
+                    #     for channel in bell_interface.channels:
+                    #         in_data = BellModbusConnection.receive_code(bell_interface, channel, adapter)
+                    #         if in_data and len(in_data) >= 2:
+                    #             bell_interface.channels[channel].in_count = (in_data[0] << 8) | in_data[1]
+                    #         out_data = BellModbusConnection.get_sent_code(bell_interface, channel, adapter)
+                    #         if out_data and len(out_data) >= 2:
+                    #             bell_interface.channels[channel].out_count = (out_data[0] << 8) | out_data[1]
+            case _:
+                logger.error(
+                    f"Unsupported connection type: {bell_interface.connection_type}"
+                )
+                interface.error = (
+                    f"Unsupported connection type: {bell_interface.connection_type}"
+                )
+                interface.enabled = False
+                return False
+        return connected
+
+    @staticmethod
+    def disconnect(interface: Interface) -> None:
+        """
+        Disconnect from a BellInterface.
+
+        Args:
+            interface: The interface to disconnect.
+
+        Returns:
+            True if disconnection was successful, False otherwise.
+        """
+
+        bell_interface = cast(BellInterface, interface)
+
+        # Get the appropriate connection strategy based on connection type
+        match bell_interface.connection_type:
+            case BellConnectionType.TEST:
+                BellTestConnection.disconnect(bell_interface)
+            case BellConnectionType.MODBUS_ADAPTER:
+                if BellInterfaceHandler.interface_controller:
+                    adapter = BellInterfaceHandler.interface_controller.get_adapter_for_interface(
+                        interface
+                    )
+                    if not adapter:
+                        return
+                    BellModbusConnection.disconnect(bell_interface, adapter)
+            case _:
+                logger.error(
+                    f"Unsupported connection type: {bell_interface.connection_type}"
+                )
+                interface.error = (
+                    f"Unsupported connection type: {bell_interface.connection_type}"
+                )
+                interface.enabled = False
+                return
+
+    @staticmethod
+    def read_data(interface: Interface, adapter: BaseAdapter | None = None) -> None:
+        """
+        Read data from the adapter for a BellInterface.
+
+        Args:
+            interface: The interface to read data for.
+            adapter: The adapter to read from.
+        """
+
+        bell_interface = cast(BellInterface, interface)
+
+        # Get the appropriate connection strategy based on connection type
+        connection: type[BellConnection]
+        match bell_interface.connection_type:
+            case BellConnectionType.TEST:
+                connection = BellTestConnection
+            case BellConnectionType.MODBUS_ADAPTER:
+                connection = BellModbusConnection
+                if BellInterfaceHandler.interface_controller:
+                    adapter = BellInterfaceHandler.interface_controller.get_adapter_for_interface(
+                        interface
+                    )
+            case _:
+                logger.error(
+                    f"Unsupported connection type: {bell_interface.connection_type}"
+                )
+                interface.error = (
+                    f"Unsupported connection type: {bell_interface.connection_type}"
+                )
+                interface.enabled = False
+                return
+
+        # Read from the hardware
+        try:
+            counts = [0, 0, 0, 0]
+            codes = ["", "", "", ""]
+
+            # Read the words from the adapter (starting at the configured address)
+            data = connection.receive_all_codes(bell_interface, adapter=adapter)
+
+            if not data:
+                logger.error(
+                    f"No data read from adapter for interface '{bell_interface.system_name}'"
+                )
+                return
+
+            # Convert data to integer array
+            words = []
+            for i in range(0, len(data), 2):
+                if i + 1 < len(data):
+                    word = (data[i] << 8) | data[i + 1]
+                    words.append(word)
+
+            for channel in range(0, 4):
+                counts[channel] = words[channel * 9]
+                # Form code from the next four bytes as ints separated by commas
+                codes[channel] = (
+                    f"{','.join([str(words[i]) for i in range((channel * 9 + 1), (channel * 9 + 4)) if words[i] != 0])}"
+                )
+            # Update the interface fields
+            for index, channel in bell_interface.channels.items():
+                channel.in_count = counts[index - 1]
+                channel.in_code = codes[index - 1]
+                if channel.in_shared_variable is not None:
+                    channel.in_shared_variable.update(
+                        {
+                            "count": channel.in_count,
+                            "code": channel.in_code,
+                        }
+                    )
+
+        except Exception as e:
+            logger.error(
+                f"Error reading data for interface '{bell_interface.system_name}': {e}"
+            )
+            interface.error = str(e)
+
+    @staticmethod
+    def write_data(interface: Interface, adapter: BaseAdapter | None = None) -> None:
+        """
+        Write data to the adapter for a BellInterface.
+
+        Args:
+            interface: The interface to write data for.
+            adapter: The adapter to write to.
+        """
+
+        bell_interface = cast(BellInterface, interface)
+
+        # Get the appropriate connection strategy based on connection type
+        connection: type[BellConnection]
+        match bell_interface.connection_type:
+            case BellConnectionType.TEST:
+                connection = BellTestConnection
+            case BellConnectionType.MODBUS_ADAPTER:
+                connection = BellModbusConnection
+                if BellInterfaceHandler.interface_controller:
+                    adapter = BellInterfaceHandler.interface_controller.get_adapter_for_interface(
+                        interface
+                    )
+            case _:
+                logger.error(
+                    f"Unsupported connection type: {bell_interface.connection_type}"
+                )
+                interface.error = (
+                    f"Unsupported connection type: {bell_interface.connection_type}"
+                )
+                interface.enabled = False
+                return
+
+        for channel in range(1, 5):
+            # Prepare data to send
+            out_count = bell_interface.channels[channel].out_count
+            last_out_count = bell_interface.channels[channel].last_out_count
+            if out_count == last_out_count:
+                continue
+            bell_interface.channels[channel].last_out_count = out_count
+            out_code = bell_interface.channels[channel].out_code
+
+            words = [0] * 8  # 1 count + 7 codes
+            words[0] = out_count if out_count is not None else 0
+            for i in range(1, 8):
+                if i - 1 < len(out_code.split(",")):
+                    try:
+                        words[i] = int(out_code.split(",")[i - 1])
+                    except ValueError:
+                        words[i] = 0
+
+            # Convert words to byte array
+            data = bytearray()
+            for word in words:
+                data.append((word >> 8) & 0xFF)  # High byte
+                data.append(word & 0xFF)  # Low byte
+
+            # Send data to the adapter
+            try:
+                connection.send_code(bell_interface, channel, data, adapter=adapter)
+                # logger.debug(f"Sent data for interface '{bell_interface.system_name}': channel {channel} data {data.hex()}")
+            except Exception as e:
+                logger.error(
+                    f"Error writing data for interface '{bell_interface.system_name}': {e}"
+                )
+                interface.error = str(e)
+
+        return
+
+    @staticmethod
+    def get_channel_status(interface: Interface):
+        """
+        Get the channel status of a BellInterface.
+
+        Args:
+            interface: The interface to get the status of.
+
+        Returns:
+            A string describing the current status.
+        """
+
+        bell_interface = cast(BellInterface, interface)
+
+        return bell_interface.model_dump_json(
+            include={"channels"},
+            by_alias=True,
+        )
+
+    @staticmethod
+    def set_forcing(interface: Interface, channel_index: int, state: str) -> None:
+        """
+        Set forcing for a channel in a BellInterface.
+
+        Args:
+            interface: The interface to set forcing for.
+            channel: The channel number.
+            is_input: Whether the channel is an input.
+            enabled: Whether forcing is enabled.
+            value: The value to force.
+        """
+        if state not in ["on", "off", "none"]:
+            raise ValueError("Invalid state. Must be 'on', 'off', or 'none'.")
+        if channel_index is None:
+            raise ValueError("Channel must be specified.")
+
+        # Set forcing for the specified channel
+        return
+
+    @staticmethod
+    def send_code(interface: Interface, code: str, channel: int) -> None:
+        """
+        Send a code to a specific channel of a BellInterface.
+
+        Args:
+            interface: The interface to send the code to.
+            code: The code to send.
+            channel: The channel number (1-4).
+        """
+        bell_interface = cast(BellInterface, interface)
+
+        if channel in bell_interface.channels:
+            bell_interface.channels[channel].out_code = code
+            bell_interface.channels[channel].out_count = (
+                bell_interface.channels[channel].out_count or 0
+            ) + 1
+
+        return
+
+    @staticmethod
+    def force_receive_code(interface: Interface, code: str, channel: int) -> None:
+        """
+        Force receiving a code on a specific channel of a BellInterface.
+
+        Args:
+            interface: The interface to receive the code on.
+            code: The code to receive.
+            channel: The channel number (1-4).
+        """
+        bell_interface = cast(BellInterface, interface)
+
+        if channel in bell_interface.channels:
+            bell_interface.channels[channel].in_code = code
+            bell_interface.channels[channel].in_count = (
+                bell_interface.channels[channel].in_count or 0
+            ) + 2  # So we don't miss a subsequent real input
+            var = bell_interface.channels[channel].in_shared_variable
+            if var is not None:
+                var.update(
+                    {
+                        "count": bell_interface.channels[channel].in_count,
+                        "code": bell_interface.channels[channel].in_code,
+                    }
+                )
+
+    @classmethod
+    def load_from_json(cls, interface_data: Any) -> None:
+        # Convert channel keys to integers
+        interface_data["channels"] = {
+            int(k): v for k, v in interface_data["channels"].items()
+        }
+        bell_interface = BellInterface.model_validate(interface_data)
+        if cls.interface_controller is None:
+            raise ValueError(
+                "Interface controller not set. Call set_controller() first."
+            )
+        cls.interface_controller.add(bell_interface)
+
+    @staticmethod
+    def save_to_json(interface: Interface) -> str:
+        return interface.model_dump_json()