twist-innovation-api 0.0.1__py3-none-any.whl

twist/TwistAPI.py

@@ -0,0 +1,102 @@
+# 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
+from typing import Callable
+import random
+import json
+from .TwistTypes import DeviceVariant
+from .TwistDevice import TwistModel, TwistDevice
+
+
+class TwistAPI:
+    def __init__(self, installation_id: int, model_update: Callable[[TwistModel], None]):
+        self._ext_publish = None
+        self._subscribe = None
+        self._callback = model_update
+
+        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
+
+    def add_mqtt(self, publisher, subscriber):
+        self._ext_publish = publisher
+        self._subscribe = subscriber
+
+        self._subscribe(f"v2/{self.installation_id}/rx/#", self._on_message_received)
+
+    async def search_models(self):
+        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
+
+    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}"
+
+            self._ext_publish(topic, json.dumps(payload))
+
+    def getboard(self, twist_id):
+          self._publish(twist_id, "getboard")
+
+    def activate_event(self, model: TwistModel, data: json):
+        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
+        }
+
+    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:
+                self.function_map[data["opcode"]](data["twist_id"], payload, data["model_id"])
+
+    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 = device.context_msg(model_id, payload)
+
+        self._callback(model)
+
+    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/TwistCbShutter.py

@@ -0,0 +1,30 @@
+# 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 .TwistDevice import TwistModel
+
+
+class TwistCbShutter(TwistModel):
+    def __init__(self, model_id: int, parent_device: TwistDevice):
+        super().__init__(model_id, parent_device)
+
+    def context_msg(self, payload: str):
+        self.parse_general_context(payload)
+
+    def print_context(self):
+        print(f"Cb Shutter Device: {self.parent_device.twist_id}, Model: {self.model_id},")

twist/TwistDevice.py

@@ -0,0 +1,42 @@
+# 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 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):
+        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
+
+    def context_msg(self, model_id: int, payload: str):
+        self.model_list[model_id].context_msg(payload)
+        return self.model_list[model_id]

twist/TwistLight.py

@@ -0,0 +1,85 @@
+# 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 TwistLight(TwistModel):
+    class EventIndexes(Enum):
+        SET = 0
+        CLEAR = 1
+        VALUE = 2
+        TOGGLE = 3
+        VALUE_FADING = 4
+
+    def __init__(self, model_id: int, parent_device: TwistDevice):
+        super().__init__(model_id, parent_device)
+        self.operating_time = 0
+        self.current = 0
+
+    def turn_on(self):
+        self._activate_event(TwistLight.EventIndexes.SET)
+
+    def turn_off(self):
+        self._activate_event(TwistLight.EventIndexes.CLEAR)
+
+    def toggle(self):
+        self._activate_event(TwistLight.EventIndexes.TOGGLE)
+
+    def set_value(self, value: int, fading_time: int | None = None):
+        if fading_time is None:
+            self._activate_event(TwistLight.EventIndexes.VALUE, value)
+        else:
+            self._activate_event(TwistLight.EventIndexes.VALUE_FADING, value, fading_time)
+
+    def _activate_event(self, index: TwistLight.EventIndexes, value: int | None = None, fading_time: int | None = None):
+        data = {
+            "i": index.value
+        }
+
+        if value is None:
+            data["vl"] = []
+        elif fading_time is None:
+            data["vl"] = [value]
+        else:
+            data["vl"] = [value, fading_time]
+
+        self.parent_device.api.activate_event(self, data)
+
+    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 = round(value[0] / 655.35, 0)
+                elif ContextErrors(index) == ContextErrors.REQUESTED:
+                    self.requested_state = round(value[0] / 655.35, 0)
+            else:
+                if index == 6:
+                    self.operating_time = value[0]
+                elif index == 7:
+                    self.current = value[0]
+
+    def print_context(self):
+        print(
+            f"Light 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/TwistLouvre.py

@@ -0,0 +1,89 @@
+# 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 TwistLouvre(TwistModel):
+    class EventIndexes(Enum):
+        OPEN = 0
+        STOP = 1
+        CLOSE = 2
+        TOGGLE = 3
+        VALUE = 4
+
+    def __init__(self, model_id: int, parent_device: TwistDevice):
+        super().__init__(model_id, parent_device)
+        self.operating_time = 0
+        self.current = 0
+
+    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 = round(value[0] / 655.35, 0)
+                elif ContextErrors(index) == ContextErrors.REQUESTED:
+                    self.requested_state = round(value[0] / 655.35, 0)
+            else:
+                if index == 6:
+                    self.operating_time = value[0]
+                elif index == 7:
+                    self.current = value[0]
+
+    def open(self):
+        self._activate_event(TwistLouvre.EventIndexes.OPEN)
+
+    def stop(self):
+        self._activate_event(TwistLouvre.EventIndexes.STOP)
+
+    def close(self):
+        self._activate_event(TwistLouvre.EventIndexes.CLOSE)
+
+    def toggle(self):
+        self._activate_event(TwistLouvre.EventIndexes.TOGGLE)
+
+    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:
+            self._activate_event(TwistLouvre.EventIndexes.VALUE, value)
+
+    def _activate_event(self, index: TwistLouvre.EventIndexes, value: int | None = None,
+                        fading_time: int | None = None):
+        data = {
+            "i": index.value
+        }
+
+        if value is None:
+            data["vl"] = []
+        elif fading_time is None:
+            data["vl"] = [value]
+        else:
+            data["vl"] = [value, fading_time]
+
+        self.parent_device.api.activate_event(self, data)
+
+    def print_context(self):
+        print(
+            f"Louvre 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/TwistModel.py

@@ -0,0 +1,82 @@
+# 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
+
+import json
+from .TwistTypes import ContextErrors
+
+
+class TwistModel():
+    def __init__(self, model_id: int, parent_device: TwistDevice):
+        self.actual_state: int = 0
+        self.requested_state: int = 0
+        self.model_id: int = model_id
+        self.parent_device = parent_device
+        self.errors = {
+            "error": None,
+            "warning": None,
+            "info": None,
+            "prio": None
+        }
+
+    def print_context(self):
+        print("function is not supported")
+
+    def parse_general_context(self, payload: str):
+        data = json.loads(payload)
+
+        for ctx in data["cl"]:
+            index, value = self._get_value_from_context(ctx)
+            if index >= ContextErrors.MAX.value:
+                pass
+            elif ContextErrors(index) == ContextErrors.ERROR:
+                self.errors["error"] = value
+            elif ContextErrors(index) == ContextErrors.WARNING:
+                self.errors["warning"] = value
+            elif ContextErrors(index) == ContextErrors.INFO:
+                self.errors["info"] = value
+            elif ContextErrors(index) == ContextErrors.PRIO:
+                self.errors["prio"] = value
+        return data
+
+    def _get_value_from_context(self, ctx: dict):
+        return ctx["i"], ctx["vl"]
+
+    def context_msg(self, payload):
+        raise NotImplementedError("Function not supported for this model")
+
+    def turn_on(self):
+        raise NotImplementedError("Function not supported for this model")
+
+    def turn_off(self):
+        raise NotImplementedError("Function not supported for this model")
+
+    def open(self):
+        raise NotImplementedError("Function not supported for this model")
+
+    def stop(self):
+        raise NotImplementedError("Function not supported for this model")
+
+    def close(self):
+        raise NotImplementedError("Function not supported for this model")
+
+    def toggle(self):
+        raise NotImplementedError("Function not supported for this model")
+
+    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")

twist/TwistRgb.py

@@ -0,0 +1,96 @@
+# 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 TwistRgb(TwistModel):
+    class EventIndexes(Enum):
+        SET = 0
+        CLEAR = 1
+        VALUE = 2
+        TOGGLE = 3
+        VALUE_FADING = 4
+
+    def __init__(self, model_id: int, parent_device: TwistDevice):
+        super().__init__(model_id, parent_device)
+
+        self.actual_h = 0
+        self.actual_s = 0
+        self.actual_v = 0
+        self.requested_h = 0
+        self.requested_s = 0
+        self.requested_v = 0
+
+        self.operating_time = 0
+
+    def turn_on(self):
+        self._activate_event(TwistRgb.EventIndexes.SET)
+
+    def turn_off(self):
+        self._activate_event(TwistRgb.EventIndexes.CLEAR)
+
+    def toggle(self):
+        self._activate_event(TwistRgb.EventIndexes.TOGGLE)
+
+    def set_value(self, value: list[int, int, int], fading_time: int | None = None):
+        if fading_time is None:
+            self._activate_event(TwistRgb.EventIndexes.VALUE, value)
+        else:
+            self._activate_event(TwistRgb.EventIndexes.VALUE_FADING, value, fading_time)
+
+    def _activate_event(self, index: TwistRgb.EventIndexes, value: list[int, int, int] | None = None,
+                        fading_time: int | None = None):
+        data = {
+            "i": index.value
+        }
+
+        if value is None:
+            data["vl"] = []
+        elif fading_time is None:
+            data["vl"] = value
+        else:
+            value.append(fading_time)
+            data["vl"] = value
+
+        self.parent_device.api.activate_event(self, data)
+
+    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_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)
+                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)
+            else:
+                if index == 6:
+                    self.operating_time = value[0]
+
+    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

@@ -0,0 +1,31 @@
+# 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 .TwistDevice import TwistModel
+
+
+class TwistSensor(TwistModel):
+    def __init__(self, model_id: int, parent_device: TwistDevice):
+        super().__init__(model_id, parent_device)
+
+    def context_msg(self, payload: str):
+        self.parse_general_context(payload)
+
+    def print_context(self):
+        print(f"Sensor Device: {self.parent_device.twist_id}, Model: {self.model_id}")

twist/TwistTypes.py

@@ -0,0 +1,72 @@
+# 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/Variants.py

@@ -0,0 +1,29 @@
+# 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/__init__.py

@@ -0,0 +1,9 @@
+"""
+Twist Innovation API Library
+A Python library to interact with Twist Innovation devices
+"""
+from .TwistModel import TwistModel
+from .TwistAPI import TwistAPI
+
+__all__ = ["TwistAPI", "TwistModel"]
+