twist-innovation-api 0.0.3__tar.gz → 0.0.6__tar.gz

{twist_innovation_api-0.0.3/twist_innovation_api.egg-info → twist_innovation_api-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
-Name: twist-innovation-api
-Version: 0.0.3
+Name: twist_innovation_api
+Version: 0.0.6
 Summary: Python library to talk to the twist-innovation api
 Home-page: https://github.com/twist-innovation/twist-innovation-api
 Author: Sibrecht Goudsmedt

{twist_innovation_api-0.0.3 → twist_innovation_api-0.0.6}/setup.py

@@ -1,8 +1,8 @@
 from setuptools import setup, find_packages
 
 setup(
-    name="twist-innovation-api",
-    version="0.0.3",
+    name="twist_innovation_api",
+    version="0.0.6",
     packages=find_packages(),
     install_requires=[
         # "requests"  # For REST API
@@ -19,4 +19,4 @@ setup(
         "Operating System :: OS Independent",
     ],
     python_requires=">=3.7",
-)
+)

twist_innovation_api-0.0.6/twist/BackendAdapter.py

@@ -0,0 +1,267 @@
+# 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 .TwistShutter import TwistShutter
+from .TwistRgb import TwistRgb
+from .TwistSensor import TwistSensor
+from .TwistGarage import TwistGarage
+from .TwistRelay import TwistRelay
+from .TwistButton import TwistButton
+from .TwistBinarySensor import TwistBinarySensor
+
+
+class DeviceInfo:
+    """Container for device information from backend"""
+    def __init__(self, device_id: int, model_id: int, name: str, model_class: Type[TwistModel],
+                 device_key: str, device_allocation_model_key: Optional[str] = None):
+        self.device_id = device_id
+        self.model_id = model_id
+        self.name = name
+        self.model_class = model_class
+        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 directly to model class
+                    model_class = self._map_model_type_to_class(model_type_name)
+
+                    if model_class:
+                        device_info = DeviceInfo(
+                            device_id=twist_id,
+                            model_id=model_index,
+                            name=label,
+                            model_class=model_class,
+                            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_class(self, model_type_name: str) -> Optional[Type[TwistModel]]:
+        """
+        Map the API's modelTypeName directly to Twist model class
+
+        Args:
+            model_type_name: Model type name from the API
+
+        Returns:
+            TwistModel subclass or None if unmapped
+        """
+        mapping = {
+            "Louvres": TwistShutter,
+            "Mono Light": TwistLight,
+            "RGB": TwistRgb,
+            "Temperature": TwistSensor,
+            "CB Shutter": TwistShutter,
+            "PB Shutter": TwistShutter,
+            "Shutter": TwistShutter,
+            "Garage": TwistGarage,
+            "Relay": TwistRelay,
+            "Button": TwistButton,
+            "Binary Sensor": TwistBinarySensor,
+            "Gateway": None,  # Skip Gateway models
+            "Weather": None,  # Skip Weather models
+            "Wind": None,  # Skip Wind models
+            "Rain Sensor": None,  # Skip Rain Sensor models
+            "Pergola Protection": None,  # Skip logic models
+            "Unknown": None,  # Skip unknown models
+        }
+
+        return mapping.get(model_type_name)

twist_innovation_api-0.0.6/twist/TwistAPI.py

@@ -0,0 +1,165 @@
+# 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
+
+
+import asyncio
+import json
+import random
+from typing import Optional
+
+from .TwistDevice import TwistDevice, TwistModel
+from .BackendAdapter import BackendAdapter, DeviceInfo, ProductModelInfo
+
+
+class TwistAPI:
+    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.function_map = {
+            "context": self._context_msg,
+            "getboard": self._get_board
+        }
+
+        self.device_list: list[TwistDevice] = list()
+        self.installation_id: Optional[int] = None
+
+        # 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
+        self._subscribe = subscriber
+
+        await self._subscribe(f"v2/{self.installation_id}/rx/#", self._on_message_received)
+
+    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_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 = info.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
+
+                # 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
+
+    async def _publish(self, twist_id, opcode, payload: dict | None = None, model_id=None):
+        if self._ext_publish is not None:
+            topic = f"v2/{self.installation_id}/tx/{twist_id}/{opcode}"
+            if payload is None:
+                payload = dict()
+            payload["key"] = random.randint(1, 65535)
+            if model_id is not None:
+                topic = f"{topic}/{model_id}"
+
+            await self._ext_publish(topic, json.dumps(payload))
+
+    async def getboard(self, twist_id):
+        await self._publish(twist_id, "getboard")
+
+    async def activate_event(self, model: TwistModel, data: json):
+        await self._publish(model.parent_device.twist_id, "activate_event", data, model.model_id)
+
+    def _parse_topic(self, topic):
+        tpc_delim = topic.split('/')
+
+        model_id = None
+        if len(tpc_delim) == 6:
+            model_id = int(tpc_delim[5])
+
+        return {
+            "twist_id": int(tpc_delim[3]),
+            "opcode": tpc_delim[4],
+            "model_id": model_id
+        }
+
+    async def _on_message_received(self, topic, payload, qos=None):
+        data = self._parse_topic(topic)
+        if any(dev.twist_id == data["twist_id"] for dev in self.device_list) or data["opcode"] == "getboard":
+            if data["opcode"] in self.function_map:
+                await self.function_map[data["opcode"]](data["twist_id"], payload, data["model_id"])
+
+    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)
+        await device.context_msg(model_id, payload)
+
+    async def _get_board(self, twist_id, payload, model_id=None):
+        """Handle getboard MQTT message (legacy compatibility)"""
+        pass

twist_innovation_api-0.0.3/twist/TwistCbShutter.py → twist_innovation_api-0.0.6/twist/TwistBinarySensor.py

@@ -12,22 +12,37 @@
 # 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 TwistCbShutter(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):
-        self.parse_general_context(payload)
+        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):
-        print(f"Cb Shutter Device: {self.parent_device.twist_id}, Model: {self.model_id},")
+        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_innovation_api-0.0.6/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_innovation_api-0.0.3 → twist_innovation_api-0.0.6}/twist/TwistDevice.py

@@ -17,25 +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)
+        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_innovation_api-0.0.6/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_innovation_api-0.0.3 → twist_innovation_api-0.0.6}/twist/TwistModel.py

@@ -39,6 +39,21 @@ class TwistModel():
 
         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")

twist_innovation_api-0.0.6/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_innovation_api-0.0.3 → twist_innovation_api-0.0.6}/twist/TwistRgb.py

@@ -53,10 +53,25 @@ class TwistRgb(TwistModel):
         await self._activate_event(TwistRgb.EventIndexes.TOGGLE)
 
     async def set_value(self, value: list[int, int, int], fading_time: int | None = None):
+        """Set HSV values.
+
+        Args:
+            value: [H, S, V] where H is 0-360 degrees, S is 0-100%, V is 0-100%
+            fading_time: Optional transition time in milliseconds
+        """
+        # Convert from standard ranges to device range (0-65535)
+        # H: 0-360 -> 0-65535 (multiply by 182.04)
+        # S: 0-100 -> 0-65535 (multiply by 655.35)
+        # V: 0-100 -> 0-65535 (multiply by 655.35)
+        h_value = round(value[0] * 182.04)
+        s_value = round(value[1] * 655.35)
+        v_value = round(value[2] * 655.35)
+        converted_value = [h_value, s_value, v_value]
+
         if fading_time is None:
-            await self._activate_event(TwistRgb.EventIndexes.VALUE, value)
+            await self._activate_event(TwistRgb.EventIndexes.VALUE, converted_value)
         else:
-            await self._activate_event(TwistRgb.EventIndexes.VALUE_FADING, value, fading_time)
+            await self._activate_event(TwistRgb.EventIndexes.VALUE_FADING, converted_value, fading_time)
 
     async def _activate_event(self, index: TwistRgb.EventIndexes, value: tuple[int, int, int] | None = None,
                               fading_time: int | None = None):
@@ -67,28 +82,33 @@ class TwistRgb(TwistModel):
         if value is None:
             data["vl"] = []
         elif fading_time is None:
-            data["vl"] = [int(v / 655.35) for v in value]
+            data["vl"] = list(value)
         else:
-            value = list(value)
-            value.append(fading_time)
-            data["vl"] = value
+            data["vl"] = list(value) + [fading_time]
 
         await self.parent_device.api.activate_event(self, data)
 
     async def context_msg(self, payload: str):
+        """Parse context message from device.
+
+        Device sends HSV in 0-65535 range, convert to standard ranges:
+        H: 0-65535 -> 0-360 degrees (divide by 182.04)
+        S: 0-65535 -> 0-100% (divide by 655.35)
+        V: 0-65535 -> 0-100% (divide by 655.35)
+        """
         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_h = round(value[0] / 655.35, 0)
-                    self.actual_s = round(value[1] / 655.35, 0)
-                    self.actual_v = round(value[2] / 655.35, 0)
+                    self.actual_h = round(value[0] / 182.04, 1)
+                    self.actual_s = round(value[1] / 655.35, 1)
+                    self.actual_v = round(value[2] / 655.35, 1)
                 elif ContextErrors(index) == ContextErrors.REQUESTED:
-                    self.requested_h = round(value[0] / 655.35, 0)
-                    self.requested_s = round(value[0] / 655.35, 0)
-                    self.requested_v = round(value[0] / 655.35, 0)
+                    self.requested_h = round(value[0] / 182.04, 1)
+                    self.requested_s = round(value[1] / 655.35, 1)
+                    self.requested_v = round(value[2] / 655.35, 1)
             else:
                 if index == 6:
                     self.operating_time = value[0]

twist_innovation_api-0.0.3/twist/TwistLouvre.py → twist_innovation_api-0.0.6/twist/TwistShutter.py

@@ -22,7 +22,7 @@ from .TwistDevice import TwistModel
 from enum import Enum
 
 
-class TwistLouvre(TwistModel):
+class TwistShutter(TwistModel):
     class EventIndexes(Enum):
         OPEN = 0
         STOP = 1
@@ -55,24 +55,24 @@ class TwistLouvre(TwistModel):
             await self._update_callback(self)
 
     async def open(self):
-        await self._activate_event(TwistLouvre.EventIndexes.OPEN)
+        await self._activate_event(TwistShutter.EventIndexes.OPEN)
 
     async def stop(self):
-        await self._activate_event(TwistLouvre.EventIndexes.STOP)
+        await self._activate_event(TwistShutter.EventIndexes.STOP)
 
     async def close(self):
-        await self._activate_event(TwistLouvre.EventIndexes.CLOSE)
+        await self._activate_event(TwistShutter.EventIndexes.CLOSE)
 
     async def toggle(self):
-        await self._activate_event(TwistLouvre.EventIndexes.TOGGLE)
+        await self._activate_event(TwistShutter.EventIndexes.TOGGLE)
 
     async def set_value(self, value: int, fading_time: int | None = None):
         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, int(value * 655.35))
+            await self._activate_event(TwistShutter.EventIndexes.VALUE, int(value * 655.35))
 
-    async def _activate_event(self, index: TwistLouvre.EventIndexes, value: int | None = None,
+    async def _activate_event(self, index: TwistShutter.EventIndexes, value: int | None = None,
                               fading_time: int | None = None):
         data = {
             "i": index.value
@@ -89,5 +89,5 @@ class TwistLouvre(TwistModel):
 
     def print_context(self):
         print(
-            f"Louvre Device: {self.parent_device.twist_id}, Model: {self.model_id},  Actual: {self.actual_state}, "
+            f"Shutter Device: {self.parent_device.twist_id}, Model: {self.model_id},  Actual: {self.actual_state}, "
             f"Requested: {self.requested_state}, Operating: {self.operating_time}, Current: {self.current}")

twist_innovation_api-0.0.6/twist/TwistTypes.py

@@ -0,0 +1,23 @@
+# 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 enum import Enum
+
+class ContextErrors(Enum):
+    ERROR = 0
+    WARNING = 1
+    INFO = 2
+    PRIO = 3
+    ACTUAL = 4
+    REQUESTED = 5
+    MAX = 6

{twist_innovation_api-0.0.3 → twist_innovation_api-0.0.6/twist_innovation_api.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
-Name: twist-innovation-api
-Version: 0.0.3
+Name: twist_innovation_api
+Version: 0.0.6
 Summary: Python library to talk to the twist-innovation api
 Home-page: https://github.com/twist-innovation/twist-innovation-api
 Author: Sibrecht Goudsmedt

{twist_innovation_api-0.0.3 → twist_innovation_api-0.0.6}/twist_innovation_api.egg-info/SOURCES.txt

@@ -2,16 +2,19 @@ LICENSE
 README.md
 pyproject.toml
 setup.py
+twist/BackendAdapter.py
 twist/TwistAPI.py
-twist/TwistCbShutter.py
+twist/TwistBinarySensor.py
+twist/TwistButton.py
 twist/TwistDevice.py
+twist/TwistGarage.py
 twist/TwistLight.py
-twist/TwistLouvre.py
 twist/TwistModel.py
+twist/TwistRelay.py
 twist/TwistRgb.py
 twist/TwistSensor.py
+twist/TwistShutter.py
 twist/TwistTypes.py
-twist/Variants.py
 twist/__init__.py
 twist_innovation_api.egg-info/PKG-INFO
 twist_innovation_api.egg-info/SOURCES.txt

twist_innovation_api-0.0.3/twist/TwistAPI.py

@@ -1,99 +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
-
-
-import asyncio
-import json
-import random
-
-from .TwistDevice import TwistDevice, TwistModel
-from .TwistTypes import DeviceVariant
-
-
-class TwistAPI:
-    def __init__(self, installation_id: int):
-        self._ext_publish = None
-        self._subscribe = None
-
-        self.function_map = {
-            "context": self._context_msg,
-            "getboard": self._get_board
-        }
-
-        self.device_list: list[TwistDevice] = list()
-
-        # TODO: this should come from the API
-        self.installation_id = installation_id
-
-    async def add_mqtt(self, publisher, subscriber):
-        self._ext_publish = publisher
-        self._subscribe = subscriber
-
-        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)
-
-        model_list: list[TwistModel] = list()
-        for device in self.device_list:
-            for model in device.model_list:
-                model_list.append(model)
-
-        return model_list
-
-    async def _publish(self, twist_id, opcode, payload: dict | None = None, model_id=None):
-        if self._ext_publish is not None:
-            topic = f"v2/{self.installation_id}/tx/{twist_id}/{opcode}"
-            if payload is None:
-                payload = dict()
-            payload["key"] = random.randint(1, 65535)
-            if model_id is not None:
-                topic = f"{topic}/{model_id}"
-
-            await self._ext_publish(topic, json.dumps(payload))
-
-    async def getboard(self, twist_id):
-        await self._publish(twist_id, "getboard")
-
-    async def activate_event(self, model: TwistModel, data: json):
-        await self._publish(model.parent_device.twist_id, "activate_event", data, model.model_id)
-
-    def _parse_topic(self, topic):
-        tpc_delim = topic.split('/')
-
-        model_id = None
-        if len(tpc_delim) == 6:
-            model_id = int(tpc_delim[5])
-
-        return {
-            "twist_id": int(tpc_delim[3]),
-            "opcode": tpc_delim[4],
-            "model_id": model_id
-        }
-
-    async def _on_message_received(self, topic, payload, qos=None):
-        data = self._parse_topic(topic)
-        if any(dev.twist_id == data["twist_id"] for dev in self.device_list) or data["opcode"] == "getboard":
-            if data["opcode"] in self.function_map:
-                await self.function_map[data["opcode"]](data["twist_id"], payload, data["model_id"])
-
-    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)
-        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}")

twist_innovation_api-0.0.3/twist/TwistTypes.py

@@ -1,72 +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 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
-    INFO = 2
-    PRIO = 3
-    ACTUAL = 4
-    REQUESTED = 5
-    MAX = 6

twist_innovation_api-0.0.3/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],
-}