opensignalbox-interface 0.1.0__py3-none-any.whl

opensignalbox/interface/main.py

@@ -0,0 +1,187 @@
+"""
+Main module for opensignalbox-interface.
+"""
+
+import logging
+
+from anyio import run, sleep
+from opensignalbox.common.messaging import get_messager
+from opensignalbox.common.modules import (
+    BaseModule,
+    ModuleInfo,
+    ModuleStatusEnum,
+    UIEntry,
+    module_argparser,
+)
+from opensignalbox.interface.adapters.controller import AdapterController
+from opensignalbox.interface.interfaces.controller import InterfaceController
+
+from .routes import adapter_router, interface_router
+from .version import __version__
+
+logger = logging.getLogger(__name__)
+
+
+messager = get_messager()
+
+
+class Module(BaseModule):
+    """OSB Interface Module."""
+
+    module_name = "opensignalbox-interface"
+    module_file = __file__
+
+    def __init__(
+        self,
+        module_info: ModuleInfo,
+        ui_entries: list[UIEntry] | None = None,
+    ) -> None:
+        if ui_entries is None:
+            ui_entries = []
+        super().__init__(
+            module_info=module_info,
+            ui_entries=ui_entries,
+        )
+
+        # Initialize controllers
+        self.adapter_controller = AdapterController(self.module_info.config_path)
+        self.fastapi_app.state.adapter_controller = self.adapter_controller
+        self.interface_controller = InterfaceController(self.module_info.config_path, self.shared_variables, self.adapter_controller)
+        self.fastapi_app.state.interface_controller = self.interface_controller
+
+        # Include API routers
+        self.fastapi_app.include_router(
+            adapter_router, prefix="/api/adapters",
+            tags=["Adapters"]
+        )
+        self.fastapi_app.include_router(
+            interface_router, prefix="/api/interfaces",
+            tags=["Interfaces"]
+        )
+
+    def setup(self) -> None:
+        """
+        Module startup code.
+        """
+        # Register any interface handlers and adapter factories
+        self._register_handlers()
+
+        # Register interface-specific routers
+        self._register_interface_routers()
+
+        # Register adapter-specific routers
+        self._register_adapter_routers()
+
+        # Load configurations
+        self.adapter_controller.load_from_json()
+        self.interface_controller.load_from_json()
+
+        # Connect interfaces
+        if self.interface_controller.module_config.connect_on_startup:
+            self.interface_controller.connect_all()
+
+        return super().setup()
+
+    def _register_interface_routers(self) -> None:
+        """Register interface-specific routers."""
+        # Get all interface routers and include them in FastAPI app
+        for interface_type, router in self.interface_controller.get_interface_routers().items():
+            # Convert enum to lowercase string for URL path
+            interface_path = interface_type.value.lower()
+            self.fastapi_app.include_router(
+                router, prefix=f"/api/interfaces/{interface_path}"
+            )
+
+    def _register_adapter_routers(self) -> None:
+        """Register adapter-specific routers."""
+        # Get all adapter routers and include them in FastAPI app
+        for adapter_type, router in self.adapter_controller.get_adapter_routers().items():
+            # Convert enum to lowercase string for URL path
+            adapter_path = adapter_type.value.lower()
+            self.fastapi_app.include_router(
+                router, prefix=f"/api/adapters/{adapter_path}"
+            )
+
+    def _register_handlers(self) -> None:
+        """Register interface handlers and adapter factories."""
+        self.interface_controller.register_interface_handlers()
+        self.adapter_controller.register_adapter_factories()
+
+    def systick_update(self, tick_json: str) -> None:
+        """
+        Module update logic executed once per clock tick.
+        """
+        super().systick_update(tick_json)
+        if self.interface_controller.module_config.sync_on_systick:
+            self.interface_controller.sync_interfaces()
+
+    async def user_task(self) -> None:
+        """Background task for periodic interface updates."""
+        while True:
+            if (
+                not self.interface_controller.module_config.sync_on_systick
+                and self.module_info.status == ModuleStatusEnum.READY
+            ):
+                await self.interface_controller.tick()
+            else:
+                await sleep(1)
+
+    def teardown(self) -> None:
+        """
+        Module teardown code.
+        """
+        # Disconnect interfaces and adapters
+        self.interface_controller.disconnect_all()
+        self.adapter_controller.disconnect_all()
+
+        # Save configurations
+        self.adapter_controller.save_to_json()
+        self.interface_controller.save_to_json()
+
+    def load_state(self) -> None:
+        """
+        Load module state.
+        """
+        return super().load_state()
+
+    def save_state(self) -> None:
+        """
+        Save module state.
+        """
+        return super().save_state()
+
+
+args = module_argparser()
+instance_name: str = args.name
+
+ui_entries = [
+    UIEntry(
+        category="operations", subcategory="Interfaces", name="Interface List", path="/"
+    ),
+    UIEntry(
+        category="configuration",
+        subcategory="Interfaces",
+        name="Interface Settings",
+        path="/settings",
+    ),
+]
+module_info = ModuleInfo(
+    instance_name=args.name,
+    module_name=Module.module_name,
+    version=__version__,
+    address=args.address,
+    port=args.port,
+    session_id=args.session_id,
+    framework_address=args.framework_address,
+    config_path=args.configdir,
+)
+module = Module(module_info=module_info, ui_entries=ui_entries)
+module.setup()
+
+
+def entry_point():
+    run(module.run, backend="trio")  # type: ignore
+
+
+if __name__ == "__main__":
+    entry_point()

opensignalbox/interface/models.py

@@ -0,0 +1,155 @@
+"""
+Base models for the opensignalbox-interface module.
+"""
+
+from enum import Enum
+from typing import List, Optional
+
+from opensignalbox.common.models import CamelModel
+
+
+class InterfaceTypeEnum(str, Enum):
+    """Enum for interface types"""
+
+    BASICIO = "BasicIO"
+    BELL = "Bell"
+    # Add more interface types here as needed
+
+
+class AdapterTypeEnum(str, Enum):
+    """Enum for adapter types"""
+
+    MODBUS = "Modbus"
+    # Add more adapter types here as needed
+
+
+class ModuleConfig(CamelModel):
+    input_update_period: float = 0.1
+    output_update_period: float = 1
+    sync_on_systick: bool = False
+    connect_on_startup: bool = True
+
+
+class AdapterBase(CamelModel):
+    """Base model for all adapters"""
+
+    system_name: str
+    user_name: str
+    description: str = ""
+    adapter_type: AdapterTypeEnum
+    enabled: bool = True
+    error: Optional[str] = None
+    # Dynamic fields for different adapter types
+    is_network: Optional[bool] = None
+    serial_port: Optional[str] = None
+    baud: Optional[int] = None
+    address: Optional[str] = None
+    network_port: Optional[int] = None
+
+
+class AdapterModel(AdapterBase):
+    """Runtime model for adapters with additional operational fields"""
+
+    is_connected: bool = False
+
+
+class AdapterCreate(CamelModel):
+    """API model for creating adapters. Omits adapter type."""
+
+    system_name: str
+    user_name: str
+    description: str = ""
+    enabled: bool = True
+    error: Optional[str] = None
+    # Dynamic fields for different adapter types
+    is_network: Optional[bool] = None
+    serial_port: Optional[str] = None
+    baud: Optional[int] = None
+    address: Optional[str] = None
+    network_port: Optional[int] = None
+
+
+class AdapterPublic(AdapterBase):
+    """API model for adapter responses"""
+
+    is_connected: bool = False
+
+
+class AdapterUpdate(CamelModel):
+    """API model for adapter updates"""
+
+    system_name: Optional[str] = None
+    user_name: Optional[str] = None
+    description: Optional[str] = None
+    enabled: Optional[bool] = None
+    is_network: Optional[bool] = None
+    serial_port: Optional[str] = None
+    baud: Optional[int] = None
+    address: Optional[str] = None
+    network_port: Optional[int] = None
+
+
+class InterfaceBase(CamelModel):
+    """Base model for all interfaces with common fields"""
+
+    system_name: str
+    user_name: str
+    description: str = ""
+    adapter_name: Optional[str] = None
+    error: Optional[str] = None
+    enabled: bool = True
+
+
+class Interface(InterfaceBase):
+    """Runtime model for all interfaces"""
+
+    interface_type: InterfaceTypeEnum
+    is_connected: bool = False
+
+
+class InterfacePublic(Interface):
+    """API model for interface responses"""
+
+    is_connected: bool = False
+
+
+class InterfaceUpdate(CamelModel):
+    """API model for interface updates"""
+
+    system_name: Optional[str] = None
+    user_name: Optional[str] = None
+    description: Optional[str] = None
+    adapter_name: Optional[str] = None
+    enabled: Optional[bool] = None
+
+
+class ConnectionTypeInfo(CamelModel):
+    """Information about a connection type"""
+
+    interface_type: InterfaceTypeEnum
+    adapter_type: AdapterTypeEnum
+    connection_class: str
+    name: str
+    description: str
+
+
+class AdapterTypeInfo(CamelModel):
+    """Information about an adapter type"""
+
+    adapter_type: AdapterTypeEnum
+    name: str
+    description: str
+    supported_connection_types: List[str]
+    required_fields: List[str]
+    optional_fields: List[str]
+
+
+class InterfaceTypeInfo(CamelModel):
+    """Information about an interface type"""
+
+    interface_type: InterfaceTypeEnum
+    name: str
+    description: str
+    supported_connection_types: List[str]
+    required_fields: List[str]
+    optional_fields: List[str]

opensignalbox/interface/routes/__init__.py

@@ -0,0 +1,4 @@
+from .adapters import adapter_router
+from .interfaces import interface_router
+
+__all__ = ["interface_router", "adapter_router"]

opensignalbox/interface/routes/adapters.py

@@ -0,0 +1,119 @@
+"""
+API routes for the opensignalbox.interface module.
+"""
+
+import logging
+from typing import Annotated, List, Optional
+
+from fastapi import APIRouter, Depends, HTTPException, Query, Request
+from opensignalbox.common.variables import SharedVariableCollection
+from opensignalbox.interface.adapters.controller import AdapterController
+from opensignalbox.interface.models import (
+    AdapterPublic,
+    AdapterTypeInfo,
+)
+
+logger = logging.getLogger(__name__)
+
+def get_adapter_controller(request: Request) -> AdapterController:
+    return request.app.state.adapter_controller
+
+AdapterControllerDependency = Annotated[AdapterController, Depends(get_adapter_controller)]
+
+def get_shared_variables(request: Request) -> SharedVariableCollection:
+    return request.app.state.shared_variables
+
+SharedVariablesDependency = Annotated[SharedVariableCollection, Depends(get_shared_variables)]
+
+adapter_router = APIRouter()
+
+@adapter_router.get("/", response_model=List[AdapterPublic])
+async def get_adapters(
+    adapters: AdapterControllerDependency,
+    adapter_type: Optional[str] = Query(
+        None, description="Filter by adapter type"
+    ),
+):
+    """Get all adapters, optionally filtered by type."""
+    adapters_list = []
+    for adapter in adapters.get_all().values():
+        # Filter by type if specified
+        if adapter_type and adapter.adapter_type != adapter_type:
+            continue
+
+        # Convert BaseAdapter to AdapterPublic
+        adapter_dict = {
+            "system_name": adapter.system_name,
+            "user_name": adapter.user_name,
+            "description": adapter.description,
+            "adapter_type": adapter.adapter_type,
+            "enabled": adapter.enabled,
+            "is_connected": adapter.is_connected,
+        }
+        adapters_list.append(AdapterPublic(**adapter_dict))
+    return adapters_list
+
+@adapter_router.put("/{system_name}/enable", response_model=AdapterPublic)
+async def enable_adapter(system_name: str, adapters: AdapterControllerDependency):
+    """Enable a specific adapter."""
+    adapter = adapters.get(system_name)
+    if not adapter:
+        raise HTTPException(status_code=404, detail="Adapter not found")
+    adapter.enabled = True
+    adapter_dict = {
+        "system_name": adapter.system_name,
+        "user_name": adapter.user_name,
+        "description": adapter.description,
+        "adapter_type": adapter.adapter_type,
+        "enabled": adapter.enabled,
+        "is_connected": adapter.is_connected,
+    }
+    return AdapterPublic(**adapter_dict)
+
+@adapter_router.put(
+    "/{system_name}/disable", response_model=AdapterPublic
+)
+async def disable_adapter(system_name: str, adapters: AdapterControllerDependency):
+    """Disable a specific adapter."""
+    adapter = adapters.get(system_name)
+    if not adapter:
+        raise HTTPException(status_code=404, detail="Adapter not found")
+    adapter.enabled = False
+    adapter_dict = {
+        "system_name": adapter.system_name,
+        "user_name": adapter.user_name,
+        "description": adapter.description,
+        "adapter_type": adapter.adapter_type,
+        "enabled": adapter.enabled,
+        "is_connected": adapter.is_connected,
+    }
+    return AdapterPublic(**adapter_dict)
+
+@adapter_router.put(
+    "/{system_name}/connect", response_model=AdapterPublic
+)
+async def connect_adapter(system_name: str, adapters: AdapterControllerDependency):
+    """Connect a specific adapter."""
+    adapter = adapters.get(system_name)
+    if not adapter:
+        raise HTTPException(status_code=404, detail="Adapter not found")
+    if adapter.connect():
+        return adapter
+    else:
+        raise HTTPException(status_code=500, detail="Failed to connect adapter")
+
+@adapter_router.put(
+    "/{system_name}/disconnect", response_model=AdapterPublic
+)
+async def disconnect_adapter(system_name: str, adapters: AdapterControllerDependency):
+    """Disconnect a specific adapter."""
+    adapter = adapters.get(system_name)
+    if not adapter:
+        raise HTTPException(status_code=404, detail="Adapter not found")
+    adapter.disconnect()
+    return adapter
+
+@adapter_router.get("/types/adapters", response_model=List[AdapterTypeInfo])
+async def get_adapter_types(adapters: AdapterControllerDependency):
+    """Get all available adapter types with their metadata."""
+    return adapters.get_adapter_type_infos()

opensignalbox/interface/routes/interfaces.py

@@ -0,0 +1,104 @@
+"""
+API routes for the opensignalbox-interface module.
+"""
+
+import logging
+from typing import Annotated, List, Optional
+
+from fastapi import APIRouter, Depends, HTTPException, Query, Request
+from opensignalbox.common.variables import SharedVariableCollection
+from opensignalbox.interface.interfaces.controller import InterfaceController
+from opensignalbox.interface.models import (
+    InterfacePublic,
+    InterfaceTypeInfo,
+)
+
+logger = logging.getLogger(__name__)
+
+def get_interface_controller(request: Request) -> InterfaceController:
+    return request.app.state.interface_controller
+
+InterfaceControllerDependency = Annotated[InterfaceController, Depends(get_interface_controller)]
+
+def get_shared_variables(request: Request) -> SharedVariableCollection:
+    return request.app.state.shared_variables
+
+SharedVariablesDependency = Annotated[SharedVariableCollection, Depends(get_shared_variables)]
+
+interface_router = APIRouter()
+
+@interface_router.get("/", response_model=List[InterfacePublic])
+async def get_interfaces(
+    interfaces: InterfaceControllerDependency,
+    interface_type: Optional[str] = Query(
+        None, description="Filter by interface type"
+    ),
+):
+    """Get all interfaces, optionally filtered by type."""
+    interfaces_list = []
+    for interface in interfaces.get_all().values():
+        # Filter by type if specified
+        if interface_type and interface.interface_type != interface_type:
+            continue
+
+        interfaces_list.append(interface)
+    return interfaces_list
+
+@interface_router.put(
+    "/{system_name}/disable", response_model=InterfacePublic
+)
+async def disable_interface(system_name: str, interfaces: InterfaceControllerDependency):
+    """Disable a specific interface."""
+    interface = interfaces.get(system_name)
+    if not interface:
+        raise HTTPException(status_code=404, detail="Interface not found")
+    interface.enabled = False
+    return interface
+
+@interface_router.put(
+    "/{system_name}/enable", response_model=InterfacePublic
+)
+async def enable_interface(system_name: str, interfaces: InterfaceControllerDependency):
+    """Enable a specific interface."""
+    interface = interfaces.get(system_name)
+    if not interface:
+        raise HTTPException(status_code=404, detail="Interface not found")
+    interface.enabled = True
+    return interface
+
+@interface_router.put(
+    "/{system_name}/connect", response_model=InterfacePublic
+)
+async def connect_interface(system_name: str, interfaces: InterfaceControllerDependency):
+    """Connect a specific interface."""
+    interface = interfaces.get(system_name)
+    if not interface:
+        raise HTTPException(status_code=404, detail="Interface not found")
+    handler = interfaces.interface_handlers.get(interface.interface_type)
+    if handler and handler.connect(interface):
+        return interface
+    else:
+        raise HTTPException(
+            status_code=500, detail="Failed to connect interface"
+        )
+
+@interface_router.put(
+    "/{system_name}/disconnect", response_model=InterfacePublic
+)
+async def disconnect_interface(system_name: str, interfaces: InterfaceControllerDependency):
+    """Disconnect a specific interface."""
+    interface = interfaces.get(system_name)
+    if not interface:
+        raise HTTPException(status_code=404, detail="Interface not found")
+    handler = interfaces.interface_handlers.get(interface.interface_type)
+    if handler and handler.disconnect(interface):
+        return interface
+    else:
+        raise HTTPException(
+            status_code=500, detail="Failed to disconnect interface"
+        )
+
+@interface_router.get("/types/interfaces", response_model=List[InterfaceTypeInfo])
+async def get_interface_types(interfaces: InterfaceControllerDependency):
+    """Get all available interface types with their metadata."""
+    return interfaces.get_interface_type_infos()