opensignalbox-interface 0.1.0__py3-none-any.whl

opensignalbox/interface/routes.py

@@ -0,0 +1,204 @@
+"""
+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.interfaces.controller import InterfaceController
+from opensignalbox.interface.models import (
+    AdapterPublic,
+    AdapterTypeInfo,
+    InterfacePublic,
+    InterfaceTypeInfo,
+)
+
+logger = logging.getLogger(__name__)
+
+def get_adapter_controller(request: Request) -> AdapterController:
+    return request.app.state.adapters
+
+AdapterControllerDependency = Annotated[AdapterController, Depends(get_adapter_controller)]
+
+def get_interface_controller(request: Request) -> InterfaceController:
+    return request.app.state.interfaces
+
+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()
+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
+
+@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
+
+@adapter_router.put("/adapters/{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(
+    "/adapters/{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(
+    "/adapters/{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(
+    "/adapters/{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
+
+@interface_router.put(
+    "/interfaces/{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(
+    "/interfaces/{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(
+    "/interfaces/{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(
+    "/interfaces/{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"
+        )
+
+@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()
+
+@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()

opensignalbox/interface/utils.py

@@ -0,0 +1,29 @@
+"""
+Utility functions for the opensignalbox-interface module.
+"""
+
+
+def swap_bytes(data: int) -> int:
+    """
+    Swap the bytes in a 16-bit word.
+
+    Args:
+        data: The 16-bit word to swap
+
+    Returns:
+        The bytes-swapped word
+    """
+    return ((data & 0xFF) << 8) | ((data >> 8) & 0xFF)
+
+
+def swap_words(data: int) -> int:
+    """
+    Swap the words in a 32-bit double word.
+
+    Args:
+        data: The 32-bit double word to swap
+
+    Returns:
+        The words-swapped double word
+    """
+    return ((data & 0xFFFF) << 16) | ((data >> 16) & 0xFFFF)

opensignalbox/interface/version.py

@@ -0,0 +1,5 @@
+"""
+Version information.
+"""
+
+__version__ = "0.1.0"

opensignalbox/interface/web_ui/.gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+#dist
+#dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

opensignalbox/interface/web_ui/README.md

@@ -0,0 +1,5 @@
+# Vue 3 + TypeScript + Vite
+
+This template should help get you started developing with Vue 3 and TypeScript in Vite. The template uses Vue 3 `<script setup>` SFCs, check out the [script setup docs](https://v3.vuejs.org/api/sfc-script-setup.html#sfc-script-setup) to learn more.
+
+Learn more about the recommended Project Setup and IDE Support in the [Vue Docs TypeScript Guide](https://vuejs.org/guide/typescript/overview.html#project-setup).

opensignalbox/interface/web_ui/WEB_UI_REFACTORING.md

@@ -0,0 +1,136 @@
+# Web UI Architecture Refactoring
+
+This document describes the refactored web UI structure for adapters and interfaces.
+
+## Directory Structure
+
+```
+src/
+├── components/
+│   ├── ui/                    # shadcn components (unchanged)
+│   ├── adapters/             # Adapter-related components
+│   │   ├── AdapterList.vue   # Main adapter list component  
+│   │   ├── BaseAdapterEdit.vue # Reusable adapter edit component
+│   │   ├── BaseAdapterView.vue # Reusable adapter view component
+│   │   └── types.ts          # Shared adapter types
+│   ├── interfaces/           # Interface-related components
+│   │   └── InterfaceList.vue # Main interface list component
+│   └── SharedVariablePicker.vue
+├── views/
+│   ├── adapters/             # Adapter-specific views
+│   │   ├── AdapterCreate.vue     # Adapter type selection
+│   │   ├── ModbusAdapterEdit.vue # Modbus-specific edit form
+│   │   └── ModbusAdapterView.vue # Modbus-specific view
+│   ├── interfaces/           # Interface-specific views
+│   │   ├── InterfaceCreate.vue       # Interface type selection
+│   │   ├── SimpleInterfaceEdit.vue   # Simple interface edit
+│   │   ├── SimpleInterfaceView.vue   # Simple interface view
+│   │   ├── BellInterfaceEdit.vue     # Bell interface edit
+│   │   └── BellInterfaceView.vue     # Bell interface view
+│   ├── Overview.vue          # Main dashboard
+│   └── Settings.vue          # Settings page
+└── main.ts                   # Router configuration
+```
+
+## Key Improvements
+
+### 1. Separation of Concerns
+- **Components**: Reusable UI components organized by feature
+- **Views**: Page-level components for specific routes
+- **Types**: Shared TypeScript interfaces
+
+### 2. Adapter Type System
+- **Base Components**: `BaseAdapterEdit.vue` and `BaseAdapterView.vue` provide common functionality
+- **Type-Specific Views**: Each adapter type (e.g., Modbus) has its own edit/view components
+- **Extensible**: Easy to add new adapter types by extending base components
+
+### 3. Routing Structure
+```
+/adapters/create                    # Select adapter type
+/adapters/create/modbus            # Create Modbus adapter
+/adapters/edit/modbus/:name        # Edit Modbus adapter
+/adapters/view/modbus/:name        # View Modbus adapter
+
+/interfaces/create                  # Select interface type
+/interfaces/create/simple          # Create simple interface
+/interfaces/edit/simple/:name      # Edit simple interface
+/interfaces/view/simple/:name      # View simple interface
+```
+
+## Adding New Adapter Types
+
+To add a new adapter type (e.g., "Serial"):
+
+### 1. Create Type-Specific Components
+
+**views/adapters/SerialAdapterEdit.vue**:
+```vue
+<script setup lang="ts">
+import BaseAdapterEdit from '@/components/adapters/BaseAdapterEdit.vue'
+// Import additional components as needed
+</script>
+
+<template>
+    <BaseAdapterEdit
+        adapter-type="Serial"
+        adapter-type-name="Serial"
+        adapter-description="Configure your Serial adapter settings"
+        :show-network-config="false"
+        :show-baud-config="true"
+    >
+        <template #additional-cards="{ adapterIsNetworkState }">
+            <!-- Serial-specific configuration cards -->
+        </template>
+    </BaseAdapterEdit>
+</template>
+```
+
+**views/adapters/SerialAdapterView.vue**:
+```vue
+<script setup lang="ts">
+import BaseAdapterView from '@/components/adapters/BaseAdapterView.vue'
+</script>
+
+<template>
+    <BaseAdapterView
+        adapter-type="Serial"
+        adapter-type-name="Serial"
+        edit-route="/adapters/edit/serial"
+    >
+        <template #adapter-specific="{ adapter }">
+            <!-- Serial-specific information cards -->
+        </template>
+    </BaseAdapterView>
+</template>
+```
+
+### 2. Update Router Configuration
+
+Add routes to `main.ts`:
+```typescript
+// In the routes array
+{ path: '/adapters/create/serial', name: 'Create Serial Adapter', component: SerialAdapterEdit },
+{ path: '/adapters/edit/serial/:name', name: 'Edit Serial Adapter', component: SerialAdapterEdit },
+{ path: '/adapters/view/serial/:name', name: 'View Serial Adapter', component: SerialAdapterView },
+```
+
+### 3. Backend Support
+
+Ensure the backend API returns the new adapter type in:
+- `/api/types/adapters` - Include the new adapter type metadata
+- Adapter CRUD operations support the new type
+
+## Benefits
+
+1. **Maintainability**: Clear separation between reusable components and specific implementations
+2. **Scalability**: Easy to add new adapter and interface types
+3. **Consistency**: Base components ensure consistent UI/UX across all types
+4. **Type Safety**: TypeScript interfaces provide compile-time checking
+5. **Developer Experience**: Clear structure makes it easy for developers to understand and extend
+
+## Migration Notes
+
+- Old `AdapterEdit.vue` has been replaced with type-specific components
+- `AdapterList.vue` now works similarly to `InterfaceList.vue` with dropdown navigation
+- Routes have been restructured to include type information
+- All existing functionality is preserved with improved organization

opensignalbox/interface/web_ui/components.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "https://shadcn-vue.com/schema.json",
+  "style": "default",
+  "typescript": true,
+  "tsConfigPath": "./tsconfig.json",
+  "tailwind": {
+    "config": "tailwind.config.js",
+    "css": "src/assets/index.css",
+    "baseColor": "slate",
+    "cssVariables": true
+  },
+  "framework": "vite",
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/libs/utils"
+  }
+}