opensignalbox-interface 0.1.0__py3-none-any.whl

opensignalbox/interface/__init__.py

@@ -0,0 +1,42 @@
+"""
+opensignalbox-interface - Generic interface module for Open Signal Box
+"""
+
+# Public exports
+from .adapters.base import BaseAdapter as BaseAdapter
+from .adapters.controller import AdapterController as AdapterController
+from .interfaces.base import InterfaceHandler as InterfaceHandler
+from .interfaces.controller import InterfaceController as InterfaceController
+
+# Module classes
+from .main import Module as Module
+from .models import (
+    AdapterBase,
+    AdapterCreate,
+    AdapterModel,
+    AdapterPublic,
+    AdapterTypeEnum,
+    AdapterUpdate,
+    Interface,
+    InterfaceBase,
+    InterfacePublic,
+    InterfaceTypeEnum,
+    InterfaceUpdate,
+)
+
+__all__ = [
+    "AdapterBase",
+    "AdapterController",
+    "AdapterCreate",
+    "AdapterModel",
+    "AdapterPublic",
+    "AdapterTypeEnum",
+    "AdapterUpdate",
+    "Interface",
+    "InterfaceBase",
+    "InterfaceController",
+    "InterfaceHandler",
+    "InterfacePublic",
+    "InterfaceTypeEnum",
+    "InterfaceUpdate",
+]

opensignalbox/interface/adapters/__init__.py

@@ -0,0 +1,3 @@
+"""
+Adapters for opensignalbox-interface.
+"""

opensignalbox/interface/adapters/base.py

@@ -0,0 +1,148 @@
+"""
+Base adapter class and types for opensignalbox-interface module.
+"""
+
+import logging
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+CONNECT_RETRIES = 3
+COMMAND_RETRIES = 3
+
+
+class BaseAdapter(ABC):
+    """Base abstract class for all adapters."""
+
+    # Adapter controller reference for API routes
+    adapter_controller = None
+
+    @classmethod
+    def set_controller(cls, controller):
+        """Set the adapter controller reference for API routes.
+
+        Args:
+            controller: The adapter controller instance
+        """
+        cls.adapter_controller = controller
+
+    @classmethod
+    def get_router(cls) -> Optional[Any]:
+        """Get API router for this adapter type.
+
+        Returns:
+            Optional FastAPI router to be included in the API
+            Returns None if no custom routes are needed
+
+        Example:
+            ```python
+            @classmethod
+            def get_router(cls):
+                from fastapi import APIRouter
+
+                router = APIRouter()
+
+                @router.get("/my-adapter/status")
+                async def get_status():
+                    # Access adapters via the controller reference
+                    adapters = cls.adapter_controller.get_all()
+                    return {"status": "ok", "adapter_count": len(adapters)}
+
+                return router
+            ```
+        """
+        return None
+
+    def __init__(
+        self, system_name: str, user_name: str, description: str = "", **kwargs: Any
+    ) -> None:
+        self.system_name = system_name
+        self.user_name = user_name
+        self.description = description
+        self.adapter_type: str = "BaseAdapter"
+        self.is_connected: bool = False
+        self.error: Optional[str] = None
+        self.enabled: bool = True
+
+    def connect(self) -> bool:
+        """Connect to the adapter with retry logic."""
+        if self.is_connected:
+            self.disconnect()
+        if not self.enabled:
+            return False
+        try:
+            self.attempt_connect()
+            self.error = None
+            self.is_connected = True
+            return True
+        except Exception as error:
+            logger.error(f"Connection to adapter '{self.user_name}' failed: {error}")
+            self.error = str(error)
+            self.disconnect()
+            self.enabled = False
+            return False
+
+    def clear_error_and_connect(self) -> None:
+        """Clear any errors and attempt to connect again."""
+        self.error = None
+        self.connect()
+
+    @abstractmethod
+    def attempt_connect(self) -> None:
+        """Concrete implementation of the connection logic."""
+        pass
+
+    def disconnect(self) -> None:
+        """Disconnect from the adapter."""
+        if self.is_connected:
+            self.attempt_disconnect()
+            self.is_connected = False
+
+    @abstractmethod
+    def attempt_disconnect(self) -> None:
+        """Concrete implementation of the disconnection logic."""
+        pass
+
+    def write(self, data: Any) -> None:
+        """Write data to the adapter with retry logic."""
+        write_try = 1
+        while write_try <= COMMAND_RETRIES:
+            try:
+                self.attempt_write(data)
+                return
+            except Exception as error:
+                logger.error(f"Write to adapter '{self.user_name}' failed: {error}")
+                self.error = str(error)
+                write_try += 1
+                if write_try <= COMMAND_RETRIES:
+                    logger.error(
+                        f"Retrying write {write_try} out of {COMMAND_RETRIES} attempts..."
+                    )
+
+    @abstractmethod
+    def attempt_write(self, data: Any) -> None:
+        """Concrete implementation of the write logic."""
+        pass
+
+    def read(self) -> Any:
+        """Read data from the adapter with retry logic."""
+        read_try = 1
+        while read_try <= COMMAND_RETRIES:
+            try:
+                result = self.attempt_read()
+                return result
+            except Exception as error:
+                logger.error(f"Read from adapter '{self.user_name}' failed: {error}")
+                self.error = str(error)
+                read_try += 1
+                if read_try <= COMMAND_RETRIES:
+                    logger.error(
+                        f"Retrying read {read_try} out of {COMMAND_RETRIES} attempts..."
+                    )
+        return None
+
+    @abstractmethod
+    def attempt_read(self) -> Any:
+        """Concrete implementation of the read logic."""
+        pass

opensignalbox/interface/adapters/controller.py

@@ -0,0 +1,286 @@
+"""
+Adapter controller for managing all adapters in the opensignalbox-interface module.
+"""
+
+import json
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Type
+
+from opensignalbox.interface.adapters.base import BaseAdapter
+from opensignalbox.interface.adapters.modbus.adapter import ModbusAdapter
+from opensignalbox.interface.models import (
+    AdapterBase,
+    AdapterTypeEnum,
+    AdapterTypeInfo,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class AdapterController:
+    """Controller for managing all adapters."""
+
+    def __init__(self, config_path: Path) -> None:
+        self.adapters: Dict[str, BaseAdapter] = {}
+        self.config_filepath = config_path / "adapters.json"
+        self.adapter_factories: Dict[AdapterTypeEnum, Type[BaseAdapter]] = {}
+
+        # Dictionary to store adapter-specific routers
+        self.adapter_routers: Dict[AdapterTypeEnum, Any] = {}
+
+    def register_adapter_factory(
+        self, adapter_type: AdapterTypeEnum, factory: Type[BaseAdapter]
+    ) -> None:
+        """Register a factory for creating adapters of a specific type.
+
+        Args:
+            adapter_type: The type of adapter this factory creates
+            factory: The adapter class that will be instantiated
+        """
+        # Set the controller reference for API routes
+        factory.set_controller(self)
+
+        # Register the factory
+        self.adapter_factories[adapter_type] = factory
+
+        # Check if the factory provides a router
+        router = factory.get_router()
+        if router:
+            self.adapter_routers[adapter_type] = router
+
+    def register_adapter_factories(self) -> None:
+        """Register all adapter factories."""
+        self.register_adapter_factory(AdapterTypeEnum.MODBUS, ModbusAdapter)
+
+    def add(self, adapter_base: AdapterBase, **kwargs) -> BaseAdapter:
+        """Add an adapter to the controller.
+
+        Args:
+            adapter_base: The base adapter model with common fields
+            **kwargs: Additional arguments specific to the adapter type
+
+        Returns:
+            The instantiated adapter
+
+        Raises:
+            FileExistsError: If an adapter with the same system name already exists
+            TypeError: If the adapter type is unknown
+        """
+        if adapter_base.system_name in self.adapters:
+            raise FileExistsError(
+                f"Adapter '{adapter_base.system_name}' already exists"
+            )
+
+        # Get the factory for this adapter type
+        factory = self.adapter_factories.get(adapter_base.adapter_type)
+        if not factory:
+            raise TypeError(f"Unknown adapter type: {adapter_base.adapter_type}")
+
+        # Create the adapter
+        try:
+            adapter = factory(**kwargs)
+            self.adapters[adapter_base.system_name] = adapter
+            return adapter
+        except Exception as e:
+            logger.error(f"Failed to create adapter: {e}")
+            raise
+
+    def get_all(self) -> Dict[str, BaseAdapter]:
+        """Get all adapters.
+
+        Returns:
+            Dictionary of adapters keyed by system name
+        """
+        return self.adapters
+
+    def get(self, system_name: str) -> BaseAdapter:
+        """Get an adapter by system name.
+
+        Args:
+            system_name: The system name of the adapter
+
+        Returns:
+            The adapter
+
+        Raises:
+            KeyError: If no adapter with the given system name exists
+        """
+        try:
+            return self.adapters[system_name]
+        except KeyError as exc:
+            raise KeyError(f"Cannot find adapter '{system_name}'") from exc
+
+    def update(self, system_name: str, **kwargs) -> BaseAdapter:
+        """Update an adapter.
+
+        Args:
+            system_name: The system name of the adapter to update
+            **kwargs: The fields to update
+
+        Returns:
+            The updated adapter
+
+        Raises:
+            KeyError: If no adapter with the given system name exists
+        """
+        try:
+            adapter = self.adapters[system_name]
+
+            # Update fields
+            for key, value in kwargs.items():
+                if hasattr(adapter, key) and value is not None:
+                    setattr(adapter, key, value)
+
+            return adapter
+        except KeyError as exc:
+            raise KeyError(f"Cannot find adapter '{system_name}'") from exc
+
+    def remove(self, system_name: str) -> None:
+        """Remove an adapter.
+
+        Args:
+            system_name: The system name of the adapter to remove
+
+        Raises:
+            KeyError: If no adapter with the given system name exists
+        """
+        try:
+            adapter = self.adapters[system_name]
+            if adapter.is_connected:
+                adapter.disconnect()
+            del self.adapters[system_name]
+        except KeyError as exc:
+            raise KeyError(f"Cannot find adapter '{system_name}'") from exc
+
+    def load_from_json(self) -> None:
+        """Load adapters from a JSON file."""
+        if not self.config_filepath.exists():
+            logger.warning(f"Adapter config file not found: {self.config_filepath}")
+            return
+
+        try:
+            with open(self.config_filepath, "r") as f:
+                adapters_data = json.load(f)
+
+            for adapter_data in adapters_data.get("adapters", []):
+                try:
+                    # Extract common fields
+                    adapter_type = adapter_data.get("adapter_type", None)
+                    if not adapter_type:
+                        logger.error(f"Adapter missing type: {adapter_data}")
+                        continue
+
+                    # Create adapter base model
+                    adapter_base = AdapterBase(**adapter_data)
+
+                    # Add the adapter with specific fields
+                    self.add(adapter_base, **adapter_data)
+                except Exception as e:
+                    logger.error(f"Error loading adapter: {e}")
+
+        except Exception as e:
+            logger.error(f"Error loading adapters from {self.config_filepath}: {e}")
+
+    def save_to_json(self) -> None:
+        """Save adapters to a JSON file."""
+        try:
+            adapters_data = []
+            for adapter in self.adapters.values():
+                # Create a dictionary with all adapter fields
+                adapter_dict = {
+                    "system_name": adapter.system_name,
+                    "user_name": adapter.user_name,
+                    "description": adapter.description,
+                    "adapter_type": adapter.adapter_type,
+                    "enabled": adapter.enabled,
+                }
+
+                # Add adapter-specific fields
+                for key, value in adapter.__dict__.items():
+                    if (
+                        key not in adapter_dict
+                        and not key.startswith("_")
+                        and not callable(value)
+                    ):
+                        adapter_dict[key] = value
+
+                adapters_data.append(adapter_dict)
+
+            with open(self.config_filepath, "w") as f:
+                json.dump(adapters_data, f, indent=2)
+
+        except Exception as e:
+            logger.error(f"Error saving adapters to {self.config_filepath}: {e}")
+
+    def get_adapter_routers(self) -> Dict[AdapterTypeEnum, Any]:
+        """Get all registered adapter routers.
+
+        Returns:
+            Dictionary of FastAPI routers keyed by adapter type
+        """
+        return self.adapter_routers
+
+    def get_adapter_class(
+        self, adapter_type: AdapterTypeEnum
+    ) -> Optional[Type[BaseAdapter]]:
+        """Get the adapter class for a given adapter type.
+
+        Args:
+            adapter_type: The adapter type to get the class for
+
+        Returns:
+            The adapter class, or None if not found
+        """
+        return self.adapter_factories.get(adapter_type)
+
+    def get_adapter_types(self) -> List[AdapterTypeEnum]:
+        """Get all available adapter types.
+
+        Returns:
+            List of available adapter types
+        """
+        return list(self.adapter_factories.keys())
+
+    def get_adapter_type_infos(self) -> List["AdapterTypeInfo"]:
+        """Get all available adapter types with their metadata.
+
+        Returns:
+            List of adapter type info objects
+        """
+        from opensignalbox.interface.models import AdapterTypeInfo
+
+        type_infos = []
+        for adapter_type in self.adapter_factories.keys():
+            adapter_factory = self.adapter_factories[adapter_type]
+
+            # Get metadata from the adapter class (class-level attributes)
+            adapter_class = adapter_factory
+            metadata = getattr(adapter_class, "metadata", {})
+
+            type_info = AdapterTypeInfo(
+                adapter_type=adapter_type,
+                name=metadata.get("name", adapter_type.value),
+                description=metadata.get(
+                    "description", f"{adapter_type.value} adapter"
+                ),
+                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 disconnect_all(self) -> None:
+        """Disconnect all adapters."""
+        for adapter in self.adapters.values():
+            if adapter.is_connected:
+                try:
+                    adapter.disconnect()
+                except Exception as e:
+                    logger.error(
+                        f"Error disconnecting adapter {adapter.system_name}: {e}"
+                    )

opensignalbox/interface/adapters/modbus/__init__.py

@@ -0,0 +1,3 @@
+"""
+Init file for Modbus adapter.
+"""