twist-innovation-api 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

twist/BackendAdapter.py

@@ -0,0 +1,295 @@
+# Copyright (C) 2025 Twist Innovation
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+# See the GNU General Public License for more details:
+# https://www.gnu.org/licenses/gpl-3.0.html
+
+"""
+Backend Adapter for Twist Device Discovery
+
+This module handles communication with the backend server to fetch device information.
+It's designed to be easily replaceable if the server API changes.
+
+The adapter maps backend device types to Twist model classes dynamically.
+"""
+
+import aiohttp
+from typing import Optional, Type, Dict
+from .TwistModel import TwistModel
+from .TwistLight import TwistLight
+from .TwistLouvre import TwistLouvre
+from .TwistRgb import TwistRgb
+from .TwistSensor import TwistSensor
+from .TwistCbShutter import TwistCbShutter
+from .TwistGarage import TwistGarage
+from .TwistRelay import TwistRelay
+from .TwistButton import TwistButton
+from .TwistBinarySensor import TwistBinarySensor
+
+
+# Type mapping: maps backend type strings to Twist model classes
+# Add new mappings here when new device types are added
+TYPE_TO_MODEL_MAP: Dict[str, Type[TwistModel]] = {
+    "Mono_Light": TwistLight,
+    "TB_Shutter": TwistLouvre,
+    "Louvre": TwistLouvre,
+    "RGB": TwistRgb,
+    "Sensor": TwistSensor,
+    "CB_Shutter": TwistCbShutter,
+    "PB_Shutter": TwistCbShutter,
+    "Garage": TwistGarage,
+    "Relay": TwistRelay,
+    "Button": TwistButton,
+    "Binary_Sensor": TwistBinarySensor,
+}
+
+
+class DeviceInfo:
+    """Container for device information from backend"""
+    def __init__(self, device_id: int, model_id: int, name: str, device_type: str,
+                 device_key: str, device_allocation_model_key: Optional[str] = None):
+        self.device_id = device_id
+        self.model_id = model_id
+        self.name = name
+        self.device_type = device_type
+        self.device_key = device_key
+        self.device_allocation_model_key = device_allocation_model_key
+
+
+class ProductModelInfo:
+    """Container for product model information"""
+    def __init__(self, device_key: str, device_model_index: int, product_name: str,
+                 product_model_label: str, product_model_alias: str):
+        self.device_key = device_key
+        self.device_model_index = device_model_index
+        self.product_name = product_name
+        self.product_model_label = product_model_label
+        self.product_model_alias = product_model_alias
+
+
+class BackendAdapter:
+    """
+    Adapter for fetching device information from backend server.
+
+    If the backend API changes, only this class needs to be updated.
+    """
+
+    def __init__(self, base_url: str, api_key: str, installation_uuid: str):
+        """
+        Initialize backend adapter
+
+        Args:
+            base_url: Base URL of the backend server (e.g., "https://backbone-dev.twist-innovation.com")
+            api_key: API key for authentication (X-Api-Key header)
+            installation_uuid: Installation UUID for the API endpoint
+        """
+        self.base_url = base_url.rstrip('/')
+        self.api_key = api_key
+        self.installation_uuid = installation_uuid
+
+    async def fetch_products(self) -> dict[str, ProductModelInfo]:
+        """
+        Fetch product information from backend server
+
+        Returns:
+            Dictionary mapping deviceAllocationModelKey -> ProductModelInfo
+
+        Raises:
+            aiohttp.ClientError: If request fails
+        """
+        url = f"{self.base_url}/installations/V1/installations/{self.installation_uuid}/products"
+        headers = {
+            "accept": "text/plain",
+            "X-Api-Key": self.api_key
+        }
+
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url, headers=headers) as response:
+                response.raise_for_status()
+                data = await response.json()
+
+        return self._parse_products(data)
+
+    def _parse_products(self, data: dict) -> dict[str, ProductModelInfo]:
+        """
+        Parse products response into dictionary for easy lookup by model key
+
+        Returns:
+            Dictionary mapping deviceAllocationModelKey -> ProductModelInfo
+        """
+        result = {}
+
+        for product in data.get("results", []):
+            product_name = product.get("name", "")
+
+            for model in product.get("models", []):
+                model_key = model.get("key")
+                device_key = model.get("deviceKey")
+                device_model_index = model.get("deviceModelIndex")
+                product_model_label = model.get("productModelLabel", "")
+                product_model_alias = model.get("productModelAlias", "")
+
+                if model_key:
+                    result[model_key] = ProductModelInfo(
+                        device_key=device_key,
+                        device_model_index=device_model_index,
+                        product_name=product_name,
+                        product_model_label=product_model_label,
+                        product_model_alias=product_model_alias
+                    )
+
+        return result
+
+    async def fetch_installation_id(self) -> int:
+        """
+        Fetch installation ID from backend server
+
+        Returns:
+            Installation ID
+
+        Raises:
+            aiohttp.ClientError: If request fails
+            ValueError: If response format is invalid
+        """
+        url = f"{self.base_url}/installations/V1/installations/{self.installation_uuid}"
+        headers = {
+            "accept": "text/plain",
+            "X-Api-Key": self.api_key
+        }
+
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url, headers=headers) as response:
+                response.raise_for_status()
+                data = await response.json()
+
+        installation_id = data.get("installation", {}).get("installationId")
+        if installation_id is None:
+            raise ValueError("Missing 'installationId' in installation response")
+
+        return installation_id
+
+    async def fetch_config(self) -> list[DeviceInfo]:
+        """
+        Fetch device configuration from backend server
+
+        Returns:
+            List of DeviceInfo objects
+
+        Raises:
+            aiohttp.ClientError: If request fails
+            ValueError: If response format is invalid
+        """
+        url = f"{self.base_url}/installations/V1/installations/{self.installation_uuid}/devices"
+        headers = {
+            "accept": "text/plain",
+            "X-Api-Key": self.api_key
+        }
+
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url, headers=headers) as response:
+                response.raise_for_status()
+                data = await response.json()
+
+        return self._parse_response(data)
+
+    def _parse_response(self, data: dict) -> list[DeviceInfo]:
+        """
+        Parse backend response into device info list
+
+        This method contains the mapping logic for the current API format.
+        Update this method if the backend response format changes.
+
+        Args:
+            data: JSON response from backend (new format with results array)
+
+        Returns:
+            List of DeviceInfo objects
+        """
+
+        # Parse devices from new API format
+        results = data.get("results", [])
+        device_list = []
+
+        for device in results:
+            try:
+                twist_id = device.get("twistId")
+                device_key = device.get("key")
+                models = device.get("models", [])
+
+                # Process each model in the device
+                for model in models:
+                    model_index = model.get("deviceModelIndex")
+                    model_type_name = model.get("modelTypeName", "")
+                    label = model.get("label", f"Model {model_index}")
+                    device_allocation_model_key = model.get("deviceAllocationModelKey")
+
+                    # Map model type name to device type string
+                    device_type = self._map_model_type_to_device_type(model_type_name)
+
+                    if device_type:
+                        device_info = DeviceInfo(
+                            device_id=twist_id,
+                            model_id=model_index,
+                            name=label,
+                            device_type=device_type,
+                            device_key=device_key,
+                            device_allocation_model_key=device_allocation_model_key
+                        )
+                        device_list.append(device_info)
+                    else:
+                        print(f"Unknown model type '{model_type_name}' for device {twist_id}, model {model_index}")
+
+            except (KeyError, TypeError) as e:
+                print(f"Skipping device due to error: {e}")
+                continue
+
+        return device_list
+
+    def _map_model_type_to_device_type(self, model_type_name: str) -> Optional[str]:
+        """
+        Map the new API's modelTypeName to the device type string used internally
+
+        Args:
+            model_type_name: Model type name from the new API
+
+        Returns:
+            Device type string or None if unmapped
+        """
+        # Mapping from new API model type names to internal device type strings
+        mapping = {
+            "Louvres": "Louvre",
+            "Mono Light": "Mono_Light",
+            "RGB": "RGB",
+            "Temperature": "Sensor",
+            "CB Shutter": "CB_Shutter",
+            "PB Shutter": "PB_Shutter",
+            "Garage": "Garage",
+            "Relay": "Relay",
+            "Button": "Button",
+            "Binary Sensor": "Binary_Sensor",
+        }
+
+        return mapping.get(model_type_name)
+
+    @staticmethod
+    def get_model_class(device_type: str) -> Type[TwistModel]:
+        """
+        Get the appropriate model class for a device type.
+
+        This method maps backend device types to Twist model classes.
+        If a type is not recognized, it returns the base TwistModel class.
+
+        Args:
+            device_type: Device type string from backend
+
+        Returns:
+            Appropriate TwistModel subclass
+        """
+        return TYPE_TO_MODEL_MAP.get(device_type, TwistModel)

twist/TwistAPI.py

@@ -15,17 +15,24 @@
 import asyncio
 import json
 import random
-from typing import Callable, Awaitable
+from typing import Optional
 
 from .TwistDevice import TwistDevice, TwistModel
-from .TwistTypes import DeviceVariant
+from .BackendAdapter import BackendAdapter, DeviceInfo, ProductModelInfo
 
 
 class TwistAPI:
-    def __init__(self, installation_id: int, model_update: Callable[[TwistModel], Awaitable[None]]):
+    def __init__(self, backend_url: str, api_key: str, installation_uuid: str):
+        """
+        Initialize TwistAPI
+
+        Args:
+            backend_url: Backend server URL (e.g., "https://backbone-dev.twist-innovation.com")
+            api_key: API key for backend authentication
+            installation_uuid: Installation UUID for the backend API
+        """
         self._ext_publish = None
         self._subscribe = None
-        self._callback: Callable[[TwistModel], Awaitable[None]] = model_update
 
         self.function_map = {
             "context": self._context_msg,
@@ -33,9 +40,10 @@ class TwistAPI:
         }
 
         self.device_list: list[TwistDevice] = list()
+        self.installation_id: Optional[int] = None
 
-        # TODO: this should come from the API
-        self.installation_id = installation_id
+        # Backend adapter for fetching device info
+        self._backend_adapter = BackendAdapter(backend_url, api_key, installation_uuid)
 
     async def add_mqtt(self, publisher, subscriber):
         self._ext_publish = publisher
@@ -43,13 +51,79 @@ class TwistAPI:
 
         await self._subscribe(f"v2/{self.installation_id}/rx/#", self._on_message_received)
 
-    async def search_models(self):
-        await self.getboard(0xffffffff)
-        await asyncio.sleep(3)
+    async def get_models(self):
+        """
+        Get models from backend
 
+        Returns:
+            List of TwistModel objects
+        """
+        return await self._get_models_from_backend()
+
+    async def _get_models_from_backend(self):
+        """
+        Fetch devices from backend and create model list
+
+        Returns:
+            List of TwistModel objects
+        """
+        # Fetch installation_id from API
+        self.installation_id = await self._backend_adapter.fetch_installation_id()
+
+        # Fetch product info for naming
+        products = await self._backend_adapter.fetch_products()
+
+        # Fetch device info from API
+        device_infos = await self._backend_adapter.fetch_config()
+
+        # Group devices by device_id
+        devices_dict = {}
+        for device_info in device_infos:
+            if device_info.device_id not in devices_dict:
+                devices_dict[device_info.device_id] = []
+            devices_dict[device_info.device_id].append(device_info)
+
+        # Create TwistDevice objects with models
         model_list: list[TwistModel] = list()
-        for device in self.device_list:
-            for model in device.model_list:
+        for device_id, infos in devices_dict.items():
+            # Sort by model_id to ensure correct order
+            infos.sort(key=lambda x: x.model_id)
+
+            # Create device if it doesn't exist
+            device = next((d for d in self.device_list if d.twist_id == device_id), None)
+            if device is None:
+                device = TwistDevice(device_id, 0, self)
+                self.device_list.append(device)
+
+            # Create models for this device
+            for info in infos:
+                model_class = BackendAdapter.get_model_class(info.device_type)
+
+                if model_class == TwistModel:
+                    print(f"Skipping unknown device type '{info.device_type}' for '{info.name}' (device {info.device_id}, model {info.model_id})")
+                    continue
+
+                model = model_class(info.model_id, device)
+
+                # Get product info if available using deviceAllocationModelKey
+                product_info = None
+                if info.device_allocation_model_key:
+                    product_info = products.get(info.device_allocation_model_key)
+
+                if product_info:
+                    model.product_name = product_info.product_name
+                    model.name = product_info.product_model_label or product_info.product_model_alias or info.name
+                else:
+                    model.product_name = None
+                    model.name = info.name
+
+                model.device_type = info.device_type
+
+                # Add model at correct position in model_list
+                while len(device.model_list) <= info.model_id:
+                    device.model_list.append(None)
+                device.model_list[info.model_id] = model
+
                 model_list.append(model)
 
         return model_list
@@ -92,12 +166,8 @@ class TwistAPI:
 
     async def _context_msg(self, twist_id, payload, model_id):
         device = next((d for d in self.device_list if d.twist_id == twist_id), None)
-        model = await device.context_msg(model_id, payload)
-
-        await self._callback(model)
+        await device.context_msg(model_id, payload)
 
     async def _get_board(self, twist_id, payload, model_id=None):
-        data = json.loads(payload)
-        if not any(dev.twist_id == twist_id for dev in self.device_list):
-            self.device_list.append(TwistDevice(twist_id, data["h"], DeviceVariant(data["v"]), self))
-            print(f"New device with id: {twist_id}")
+        """Handle getboard MQTT message (legacy compatibility)"""
+        pass

twist/TwistBinarySensor.py

@@ -0,0 +1,48 @@
+# Copyright (C) 2025 Twist Innovation
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+# See the GNU General Public License for more details:
+# https://www.gnu.org/licenses/gpl-3.0.html
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from TwistDevice import TwistDevice
+from .TwistTypes import ContextErrors
+from .TwistDevice import TwistModel
+
+
+class TwistBinarySensor(TwistModel):
+    def __init__(self, model_id: int, parent_device: TwistDevice):
+        super().__init__(model_id, parent_device)
+
+    async def context_msg(self, payload: str):
+        data = self.parse_general_context(payload)
+
+        for ctx in data["cl"]:
+            index, value = self._get_value_from_context(ctx)
+            if index < ContextErrors.MAX.value:
+                if ContextErrors(index) == ContextErrors.ACTUAL:
+                    self.actual_state = value[0]
+
+        if self._update_callback is not None:
+            await self._update_callback(self)
+
+    @property
+    def is_active(self) -> bool:
+        """Check if binary sensor is active (1) or inactive (0)"""
+        return bool(self.actual_state)
+
+    def print_context(self):
+        state = "ACTIVE" if self.is_active else "INACTIVE"
+        print(
+            f"Binary Sensor Device: {self.parent_device.twist_id}, Model: {self.model_id}, State: {state}")

twist/TwistButton.py

@@ -0,0 +1,60 @@
+# Copyright (C) 2025 Twist Innovation
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+# See the GNU General Public License for more details:
+# https://www.gnu.org/licenses/gpl-3.0.html
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from TwistDevice import TwistDevice
+from .TwistTypes import ContextErrors
+from .TwistDevice import TwistModel
+from enum import Enum
+
+
+class TwistButton(TwistModel):
+    class ButtonEvent(Enum):
+        PUSH = 0x00
+        RELEASE = 0x01
+        LONG_PUSH = 0x02
+        LONG_RELEASE = 0x03
+        DOUBLE_PUSH = 0x04
+        DOUBLE_RELEASE = 0x05
+        DOUBLE_LONG_PUSH = 0x06
+        DOUBLE_LONG_RELEASE = 0x07
+
+    def __init__(self, model_id: int, parent_device: TwistDevice):
+        super().__init__(model_id, parent_device)
+        self.last_event: TwistButton.ButtonEvent | None = None
+
+    async def context_msg(self, payload: str):
+        data = self.parse_general_context(payload)
+
+        for ctx in data["cl"]:
+            index, value = self._get_value_from_context(ctx)
+            if index < ContextErrors.MAX.value:
+                if ContextErrors(index) == ContextErrors.ACTUAL:
+                    self.actual_state = value[0]
+                    # Store the event type
+                    try:
+                        self.last_event = TwistButton.ButtonEvent(value[0])
+                    except ValueError:
+                        self.last_event = None
+
+        if self._update_callback is not None:
+            await self._update_callback(self)
+
+    def print_context(self):
+        event_name = self.last_event.name if self.last_event else "UNKNOWN"
+        print(
+            f"Button Device: {self.parent_device.twist_id}, Model: {self.model_id}, Last Event: {event_name}")

twist/TwistCbShutter.py

@@ -26,5 +26,8 @@ class TwistCbShutter(TwistModel):
     async def context_msg(self, payload: str):
         self.parse_general_context(payload)
 
+        if self._update_callback is not None:
+            await self._update_callback(self)
+
     def print_context(self):
         print(f"Cb Shutter Device: {self.parent_device.twist_id}, Model: {self.model_id},")

twist/TwistDevice.py

@@ -17,26 +17,16 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from TwistAPI import TwistAPI
 
-from .TwistTypes import DeviceVariant
 from .TwistModel import TwistModel
 
-from .Variants import model_dict
-
 class TwistDevice:
-    def __init__(self, twist_id: int, hw: int, var: DeviceVariant, api: TwistAPI):
+    def __init__(self, twist_id: int, hw: int, api: TwistAPI):
         self.twist_id = twist_id
         self.hw = hw
-        self.var = var
         self.api = api
 
         self.model_list: list[TwistModel] = list()
 
-        model_id = 0
-        if self.var in model_dict:
-            for model in model_dict[self.var]:
-                self.model_list.append(model(model_id, self))
-                model_id += 1
-
     async def context_msg(self, model_id: int, payload: str):
-        await self.model_list[model_id].context_msg(payload)
-        return self.model_list[model_id]
+        if model_id < len(self.model_list) and self.model_list[model_id] is not None:
+            await self.model_list[model_id].context_msg(payload)

twist/TwistGarage.py

@@ -0,0 +1,65 @@
+# Copyright (C) 2025 Twist Innovation
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+# See the GNU General Public License for more details:
+# https://www.gnu.org/licenses/gpl-3.0.html
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from TwistDevice import TwistDevice
+from .TwistTypes import ContextErrors
+from .TwistDevice import TwistModel
+from enum import Enum
+
+
+class TwistGarage(TwistModel):
+    class EventIndexes(Enum):
+        OPEN = 0x00
+        CLOSE = 0x01
+        TOGGLE = 0x02
+
+    def __init__(self, model_id: int, parent_device: TwistDevice):
+        super().__init__(model_id, parent_device)
+
+    async def context_msg(self, payload: str):
+        data = self.parse_general_context(payload)
+
+        for ctx in data["cl"]:
+            index, value = self._get_value_from_context(ctx)
+            if index < ContextErrors.MAX.value:
+                if ContextErrors(index) == ContextErrors.ACTUAL:
+                    self.actual_state = value[0]
+
+        if self._update_callback is not None:
+            await self._update_callback(self)
+
+    async def open(self):
+        await self._activate_event(TwistGarage.EventIndexes.OPEN)
+
+    async def close(self):
+        await self._activate_event(TwistGarage.EventIndexes.CLOSE)
+
+    async def toggle(self):
+        await self._activate_event(TwistGarage.EventIndexes.TOGGLE)
+
+    async def _activate_event(self, index: TwistGarage.EventIndexes):
+        data = {
+            "i": index.value,
+            "vl": []
+        }
+
+        await self.parent_device.api.activate_event(self, data)
+
+    def print_context(self):
+        print(
+            f"Garage Device: {self.parent_device.twist_id}, Model: {self.model_id}, Actual: {self.actual_state}")

twist/TwistLight.py

@@ -44,6 +44,7 @@ class TwistLight(TwistModel):
         await self._activate_event(TwistLight.EventIndexes.TOGGLE)
 
     async def set_value(self, value: int, fading_time: int | None = None):
+        value = value * 655.35
         if fading_time is None:
             await self._activate_event(TwistLight.EventIndexes.VALUE, value)
         else:
@@ -79,6 +80,9 @@ class TwistLight(TwistModel):
                 elif index == 7:
                     self.current = value[0]
 
+        if self._update_callback is not None:
+            await self._update_callback(self)
+
     def print_context(self):
         print(
             f"Light Device: {self.parent_device.twist_id}, Model: {self.model_id},  Actual: {self.actual_state}, "

twist/TwistLouvre.py

@@ -12,6 +12,7 @@
 # https://www.gnu.org/licenses/gpl-3.0.html
 
 from __future__ import annotations
+
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -50,6 +51,9 @@ class TwistLouvre(TwistModel):
                 elif index == 7:
                     self.current = value[0]
 
+        if self._update_callback is not None:
+            await self._update_callback(self)
+
     async def open(self):
         await self._activate_event(TwistLouvre.EventIndexes.OPEN)
 
@@ -66,10 +70,10 @@ class TwistLouvre(TwistModel):
         if fading_time is not None:
             raise NotImplementedError("Fading time can't be used in this model")
         else:
-            await self._activate_event(TwistLouvre.EventIndexes.VALUE, value)
+            await self._activate_event(TwistLouvre.EventIndexes.VALUE, int(value * 655.35))
 
     async def _activate_event(self, index: TwistLouvre.EventIndexes, value: int | None = None,
-                        fading_time: int | None = None):
+                              fading_time: int | None = None):
         data = {
             "i": index.value
         }

twist/TwistModel.py

@@ -12,12 +12,15 @@
 # https://www.gnu.org/licenses/gpl-3.0.html
 
 from __future__ import annotations
+
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from TwistDevice import TwistDevice
 
 import json
+
+from typing import Callable, Awaitable
 from .TwistTypes import ContextErrors
 
 
@@ -34,9 +37,28 @@ class TwistModel():
             "prio": None
         }
 
+        self._update_callback: Callable[[TwistModel], Awaitable[None]] | None = None
+
+    @property
+    def friendly_name(self) -> str:
+        """
+        Convert name attribute to friendly format.
+        Example: "light_living_lamp_1" -> "Light living lamp 1"
+
+        Returns:
+            Friendly formatted name, or "Unknown" if name is not set
+        """
+        if not hasattr(self, 'name') or not self.name:
+            return "Unknown"
+
+        # Replace underscores with spaces and capitalize first letter
+        return self.name.replace('_', ' ').capitalize()
+
+
     def print_context(self):
         print("function is not supported")
 
+
     def parse_general_context(self, payload: str):
         data = json.loads(payload)
 
@@ -54,29 +76,42 @@ class TwistModel():
                 self.errors["prio"] = value
         return data
 
+
     def _get_value_from_context(self, ctx: dict):
         return ctx["i"], ctx["vl"]
 
+
     async def context_msg(self, payload):
         raise NotImplementedError("Function not supported for this model")
 
+
     async def turn_on(self):
         raise NotImplementedError("Function not supported for this model")
 
+
     async def turn_off(self):
         raise NotImplementedError("Function not supported for this model")
 
+
     async def open(self):
         raise NotImplementedError("Function not supported for this model")
 
+
     async def stop(self):
         raise NotImplementedError("Function not supported for this model")
 
+
     async def close(self):
         raise NotImplementedError("Function not supported for this model")
 
+
     async def toggle(self):
         raise NotImplementedError("Function not supported for this model")
 
+
     async def set_value(self, value: int | list[int, int] | list[int, int, int], fading_time: int | None = None):
         raise NotImplementedError("Function not supported for this model")
+
+
+    def register_update_cb(self, cb: Callable[[TwistModel], Awaitable[None]]):
+        self._update_callback = cb

twist/TwistRelay.py

@@ -0,0 +1,68 @@
+# Copyright (C) 2025 Twist Innovation
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+# See the GNU General Public License for more details:
+# https://www.gnu.org/licenses/gpl-3.0.html
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from TwistDevice import TwistDevice
+from .TwistTypes import ContextErrors
+from .TwistDevice import TwistModel
+from enum import Enum
+
+
+class TwistRelay(TwistModel):
+    class EventIndexes(Enum):
+        SET = 0x00
+        CLEAR = 0x01
+        TOGGLE = 0x03
+
+    def __init__(self, model_id: int, parent_device: TwistDevice):
+        super().__init__(model_id, parent_device)
+
+    async def context_msg(self, payload: str):
+        data = self.parse_general_context(payload)
+
+        for ctx in data["cl"]:
+            index, value = self._get_value_from_context(ctx)
+            if index < ContextErrors.MAX.value:
+                if ContextErrors(index) == ContextErrors.ACTUAL:
+                    self.actual_state = value[0]
+                elif ContextErrors(index) == ContextErrors.REQUESTED:
+                    self.requested_state = value[0]
+
+        if self._update_callback is not None:
+            await self._update_callback(self)
+
+    async def turn_on(self):
+        await self._activate_event(TwistRelay.EventIndexes.SET)
+
+    async def turn_off(self):
+        await self._activate_event(TwistRelay.EventIndexes.CLEAR)
+
+    async def toggle(self):
+        await self._activate_event(TwistRelay.EventIndexes.TOGGLE)
+
+    async def _activate_event(self, index: TwistRelay.EventIndexes):
+        data = {
+            "i": index.value,
+            "vl": []
+        }
+
+        await self.parent_device.api.activate_event(self, data)
+
+    def print_context(self):
+        state = "ON" if self.actual_state else "OFF"
+        print(
+            f"Relay Device: {self.parent_device.twist_id}, Model: {self.model_id}, State: {state}")

twist/TwistRgb.py

@@ -12,6 +12,7 @@
 # https://www.gnu.org/licenses/gpl-3.0.html
 
 from __future__ import annotations
+
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -57,8 +58,8 @@ class TwistRgb(TwistModel):
         else:
             await self._activate_event(TwistRgb.EventIndexes.VALUE_FADING, value, fading_time)
 
-    async def _activate_event(self, index: TwistRgb.EventIndexes, value: list[int, int, int] | None = None,
-                        fading_time: int | None = None):
+    async def _activate_event(self, index: TwistRgb.EventIndexes, value: tuple[int, int, int] | None = None,
+                              fading_time: int | None = None):
         data = {
             "i": index.value
         }
@@ -66,8 +67,9 @@ class TwistRgb(TwistModel):
         if value is None:
             data["vl"] = []
         elif fading_time is None:
-            data["vl"] = value
+            data["vl"] = [int(v / 655.35) for v in value]
         else:
+            value = list(value)
             value.append(fading_time)
             data["vl"] = value
 
@@ -91,6 +93,9 @@ class TwistRgb(TwistModel):
                 if index == 6:
                     self.operating_time = value[0]
 
+        if self._update_callback is not None:
+            await self._update_callback(self)
+
     def print_context(self):
         print(f"Rgb Device: {self.parent_device.twist_id}, Model: {self.model_id}, "
               f"Actual: h{self.actual_h} s{self.actual_s} v{self.actual_v}")

twist/TwistSensor.py

@@ -27,5 +27,8 @@ class TwistSensor(TwistModel):
     async def context_msg(self, payload: str):
         self.parse_general_context(payload)
 
+        if self._update_callback is not None:
+            await self._update_callback(self)
+
     def print_context(self):
         print(f"Sensor Device: {self.parent_device.twist_id}, Model: {self.model_id}")

twist/TwistTypes.py

@@ -13,55 +13,6 @@
 
 from enum import Enum
 
-class DeviceVariant(Enum):
-    NO_VARIANT = 0xFFFF
-    NONE = 0x0000
-    LED_4_BUTTON_4 = 0x0001
-    LED_1_BUTTON_1 = 0x0002
-    MONO_LIGHT_4 = 0x0003
-    MONO_LIGHT_2 = 0x0004
-    TEMP_1_HUM_1_PIR_1_LUX_1_VOC_1 = 0x0005
-    MONO_LIGHT_1_BUTTON_1 = 0x0006
-    RGB_1_TUNABLE_WHITE_1 = 0x0007
-    BUTTON_8 = 0x0008
-    MONO_LIGHT_2_LUX2BRIGHTNESS_1 = 0x0009
-    RGB_1_MONO_LIGHT_2 = 0x000A
-    LUX_1_UV_1_TEMP_1_HUM_1_WINDSPEED_1_GUSTSPEED_1_WINDDIR_1_RAINFALL_1_PRES_1 = 0x000B
-    RGB_1 = 0x000C
-    BUTTON_6_LUX_6 = 0x00D2  # Corrected 0x000D2 to 0x00D2
-    BUTTON_4 = 0x000E
-    TUNABLE_WHITE_2 = 0x000F
-    WIND_1_LUX_1_RAIN_1 = 0x0010
-    BUTTON_1 = 0x0011
-    PULSE_CONTACT_2 = 0x0012
-    TBSHUTTER_1 = 0x0013
-    MONO_LIGHT_32 = 0x0142
-    REPEATER_1 = 0x0015
-    REPEATER_1_LED_1 = 0x0016
-    LED_12 = 0x0172
-    BUTTON_12 = 0x0182
-    CBSHUTTER_1_VOLTAGE_1_CURRENT_1 = 0x0019
-    TBSHUTTER_6 = 0x001A
-    CBSHUTTER_1_MONO_LIGHT_1 = 0x001B
-    CBSHUTTER_1 = 0x001C
-    MONO_LIGHT_1 = 0x001D
-    HEATER_1 = 0x001E
-    PBSHUTTER_1 = 0x001F
-    CBSHUTTER_2_MONO_LIGHT_4_TEMPERATURE_1 = 0x0020
-    GATEWAY_1_WEATHER_1_TEMPERATURE_1_WIND_1_RAIN_1 = 0x0021
-    CBSHUTTER_3 = 0x0022
-    BUTTON_10 = 0x0023
-    MATRIX_1 = 0x0024
-    RAIN_1 = 0x0025
-    RAIN_1_TEMPERATURE_1_WIND_1_WEATHER_1 = 0x0026
-    LOUVRE_2_MONO_LIGHT_4_TEMPERATURE_1 = 0x0027
-    LOUVRE_2_MONO_LIGHT_4 = 0x0028
-
-
-class Models(Enum):
-    LOUVRE = 0
-    MONO_LIGHT = 1
-
 class ContextErrors(Enum):
     ERROR = 0
     WARNING = 1

{twist_innovation_api-0.0.2.dist-info → twist_innovation_api-0.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: twist-innovation-api
-Version: 0.0.2
+Version: 0.0.4
 Summary: Python library to talk to the twist-innovation api
 Home-page: https://github.com/twist-innovation/twist-innovation-api
 Author: Sibrecht Goudsmedt
@@ -11,15 +11,6 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license-file
-Dynamic: requires-python
-Dynamic: summary
 
 # Twist Innovation API
 
@@ -133,12 +124,13 @@ async def main():
             asyncio.create_task(listen())
 
         # Initialize Twist API with async methods
-        twist_api = TwistAPI(8, on_model_update)
+        twist_api = TwistAPI(8)
         await twist_api.add_mqtt(mqtt_publish, mqtt_subscribe)
 
         twist_model_list: list[TwistModel] = await twist_api.search_models()
 
         for model in twist_model_list:
+            model.register_update_cb(on_model_update)
             print(f"{type(model)} has Model id: {model.model_id}, Device id: {model.parent_device.twist_id}")
             
         while True:

twist_innovation_api-0.0.4.dist-info/RECORD

@@ -0,0 +1,20 @@
+twist/BackendAdapter.py,sha256=vvFomOgBiyKOZJ_n565AdHzdCgB-hNEU9UVDRONdhZc,10509
+twist/TwistAPI.py,sha256=0wwIiJRwV92tVoLdSJ6NYnZHu-UAPAVYZ7jaGsLpQq0,6477
+twist/TwistBinarySensor.py,sha256=k9gsF1dTR3E_kiB60R1SUuUc9oUGGRGs592fQqy2VPM,1747
+twist/TwistButton.py,sha256=p5svcsU6maGwyWa06NnlKCGUXHoFzuwFPEQI0UqoGB4,2172
+twist/TwistCbShutter.py,sha256=mWQa4ro30uI8qm0J1rkR8M0KP7IwxlCRfWt0wSyCOLA,1199
+twist/TwistDevice.py,sha256=-ttj9LrZhR3BwLK4ADSe2TrTtY5Z3GMkz3BruUP_jCU,1159
+twist/TwistGarage.py,sha256=RaE0Pi-1dE9FwHEIANf--Uig9tFt6EAZBt_lxjZgk18,2149
+twist/TwistLight.py,sha256=6f-gPfP6v7BgaRJUFt7Q3r990y2L0812d76K_33KSTw,3230
+twist/TwistLouvre.py,sha256=f2ocRjLkf3qC45hbcHdEOboA2mbkaxLaOa15tvkHOHY,3320
+twist/TwistModel.py,sha256=HKDDm-vaRiNEF-a67N-cjWw2UZDiSPSRMkEmlAIUPTg,3667
+twist/TwistRelay.py,sha256=VL9eKXSOoZ_9GHT8TGZKDU1hGH-cgoogoMmJWLfjOqc,2309
+twist/TwistRgb.py,sha256=V7YuaqJaLTH3cL8CsQ3xIztfVKfqdMMJ7uyh9UZQDwA,3572
+twist/TwistSensor.py,sha256=6eYrwtZFFFOHmoHS68JHmsyi6FVVzoQy19KooGU0vMI,1192
+twist/TwistTypes.py,sha256=k1CdLqjhJi8MyrFZsHkDsEoL9gEXF-HQv6I-r3G7ngA,726
+twist/__init__.py,sha256=gf8GHc9utiG0vD8GP3IfzLFHAG-ev1TXBIm0XUHxy38,201
+twist_innovation_api-0.0.4.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+twist_innovation_api-0.0.4.dist-info/METADATA,sha256=c5eSo06IcHRdW1vTHfXxQdyEYcrUtUctP98MaL8Lx8c,4139
+twist_innovation_api-0.0.4.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+twist_innovation_api-0.0.4.dist-info/top_level.txt,sha256=mkoeBkRPFodjnd-3UDf9YndjTQ6Sriz-EKSI4nQ7brs,6
+twist_innovation_api-0.0.4.dist-info/RECORD,,

{twist_innovation_api-0.0.2.dist-info → twist_innovation_api-0.0.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: bdist_wheel (0.42.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

twist/Variants.py

@@ -1,29 +0,0 @@
-# Copyright (C) 2025 Twist Innovation
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-#
-# See the GNU General Public License for more details:
-# https://www.gnu.org/licenses/gpl-3.0.html
-
-from .TwistLight import TwistLight
-from .TwistLouvre import TwistLouvre
-from .TwistRgb import TwistRgb
-from .TwistSensor import TwistSensor
-from .TwistCbShutter import TwistCbShutter
-from .TwistTypes import DeviceVariant
-
-model_dict = {
-    DeviceVariant.LOUVRE_2_MONO_LIGHT_4: [TwistLouvre, TwistLouvre, TwistLight, TwistLight, TwistLight,
-                                          TwistLight],
-    DeviceVariant.RGB_1: [TwistRgb],
-    DeviceVariant.MONO_LIGHT_4: [TwistLight, TwistLight, TwistLight, TwistLight],
-    DeviceVariant.GATEWAY_1_WEATHER_1_TEMPERATURE_1_WIND_1_RAIN_1: [TwistSensor, TwistSensor, TwistSensor,
-                                                                    TwistSensor, TwistSensor],
-    DeviceVariant.CBSHUTTER_1_MONO_LIGHT_1: [TwistCbShutter, TwistLight],
-}

twist_innovation_api-0.0.2.dist-info/RECORD

@@ -1,16 +0,0 @@
-twist/TwistAPI.py,sha256=hXkkxkUM9W9oDczRKwioDJ1SZA0s1K8Ed612YkvtUmk,3797
-twist/TwistCbShutter.py,sha256=Ps_Yvr7pl71wvt0h3BU12MyccUitA6qJMyBP-Yq9qks,1106
-twist/TwistDevice.py,sha256=1wfLNB0BgJHDSUrBYD4gv_Txak7SS4mmHrJ0jcMxfI8,1421
-twist/TwistLight.py,sha256=TrlZ03Aztc8-Qvybv96RYA_21zAke6GLBGHFpk-RznU,3106
-twist/TwistLouvre.py,sha256=wFl8MOMMslKDzSr2FkqArXXoJ5CWvBqMde7-UTlEpgU,3206
-twist/TwistModel.py,sha256=pyaGiw2vpaCsZkp0xC6XDB7HABGZM_2X7aZCqAxhmE0,2925
-twist/TwistRgb.py,sha256=MxAshwe4fczGD-pEgMAXG5847kKR0KFm7WemWKeDKHs,3412
-twist/TwistSensor.py,sha256=C1uHxdVvixnJeijeWAhArSAu5e7Dag7yt-dqqt407lg,1099
-twist/TwistTypes.py,sha256=wsp-lnkaU70wNdoKWOWcnsq89vBheBYmM31ZXW3FMRw,2166
-twist/Variants.py,sha256=SFAZ7bSmTRomPspOfU1qNWEW-htRuyhTKuyGKK9Qh54,1369
-twist/__init__.py,sha256=gf8GHc9utiG0vD8GP3IfzLFHAG-ev1TXBIm0XUHxy38,201
-twist_innovation_api-0.0.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-twist_innovation_api-0.0.2.dist-info/METADATA,sha256=g7LK4ufC35S-4xD1w8me6pb95jbmURlhALaRs7p3yp0,4298
-twist_innovation_api-0.0.2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-twist_innovation_api-0.0.2.dist-info/top_level.txt,sha256=mkoeBkRPFodjnd-3UDf9YndjTQ6Sriz-EKSI4nQ7brs,6
-twist_innovation_api-0.0.2.dist-info/RECORD,,