ics_2000_python 0.1.0__py3-none-any.whl

ics_2000/command.py

@@ -0,0 +1,87 @@
+import json
+from typing import List
+import socket
+import requests
+from .config import API_URL
+from .encryption import encrypt
+from .model.entity_type import Entity_Type
+
+
+class Command:
+    def __init__(
+        self,
+        hub_mac: str,
+        device_id: int,
+        device_function: int,
+        value: int,
+        aes_key: str,
+        entity_type: Entity_Type,
+        device_functions: List[int] = [],
+    ):
+        self.hub_mac = hub_mac
+        self.device_id = device_id
+        self.device_function = device_function
+        self.value = value
+        self.aes_key = aes_key
+        self.entity_type = entity_type
+        self.device_functions = device_functions
+
+        data_object = {}
+        data_object[entity_type.value] = {
+            "id": device_id,
+            "function": device_function,
+            "value": value,
+        }
+
+        if entity_type.value == "group":
+            data_object["group"]["update_group_members"] = True
+            device_functions[device_function] = value
+            data_object["group"]["functions"] = device_functions
+
+        encrypted_data = encrypt(json.dumps(data_object), aes_key)
+        # data = bytes.fromhex(encrypted_data)
+        header = bytearray(43)
+        header[0] = 1  # set frame
+        header[9:13] = (653213).to_bytes(4, byteorder="little")  # set magic
+        header[2] = 128  # set type
+        header[41:43] = len(encrypted_data).to_bytes(
+            2, byteorder="little"
+        )  # set data length
+        header[29:33] = device_id.to_bytes(4, byteorder="little")  # set entityId
+
+        # set mac
+        mac_buffer = bytes.fromhex(hub_mac)
+        for i in range(len(mac_buffer)):
+            header[3 + i] = mac_buffer[i]
+
+        self.total_message = bytes(header) + encrypted_data
+
+    def send_to(self, host: str, port: int, send_timeout: int = 10000) -> None:
+        client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        client.settimeout(send_timeout / 1000)
+
+        try:
+            client.sendto(self.total_message, (host, port))
+            data, _ = client.recvfrom(1024)
+        except socket.timeout:
+            raise TimeoutError("Message timed out")
+        finally:
+            client.close()
+
+    def send_to_cloud(self, email: str, password: str) -> None:
+        params = {
+            "action": "add",
+            "email": email,
+            "mac": self.hub_mac,
+            "password_hash": password,
+            "device_unique_id": "",
+            "command": self.to_hex(),
+        }
+
+        response = requests.get(f"{API_URL}/command.php", params=params)
+
+        if response.status_code != 200:
+            raise Exception(f"Non 200 status returned: {response.status_code}")
+
+    def to_hex(self) -> str:
+        return self.total_message.hex()

ics_2000/config.py

@@ -0,0 +1,211 @@
+from .model.device_config import DeviceConfig
+
+
+API_URL = "https://trustsmartcloud2.com/ics2000_api"
+device_configs: dict[int, DeviceConfig] = {
+    1: DeviceConfig(
+        model_name="APC3-2300R KAKU 443MHz Smartplug",
+        on_off_function=0,
+    ),
+    2: DeviceConfig(  # DeviceType 2 uses 0 to 15 for dim values
+        model_name="KAKU dimmable",
+        on_off_function=0,
+        dim_function=1,
+        max_brightness=15,
+    ),
+    3: DeviceConfig(
+        disabled=True,
+        model_name="Actuator",
+    ),
+    4: DeviceConfig(
+        disabled=True,
+        model_name="Trust wireless motion detector for outdoor use",
+    ),
+    5: DeviceConfig(
+        disabled=True,
+        model_name="Contact sensor",
+    ),
+    6: DeviceConfig(
+        disabled=True,
+        model_name="ACDB 7000A doorbell",
+    ),
+    7: DeviceConfig(
+        disabled=True,
+        model_name="1 Channel wall control",
+    ),
+    8: DeviceConfig(
+        disabled=True,
+        model_name="2 Channel wall control",
+    ),
+    9: DeviceConfig(
+        disabled=True,
+        model_name="1 Channel remote control",
+    ),
+    10: DeviceConfig(
+        disabled=True,
+        model_name="2 Channel remote control",
+    ),
+    11: DeviceConfig(
+        disabled=True,
+        model_name="3 Channel remote control",
+    ),
+    12: DeviceConfig(
+        disabled=True,
+        model_name="16 Channel remote control AYCT-102",
+    ),
+    13: DeviceConfig(
+        disabled=True,
+        model_name="Wall mounted remote control AYCT_202",
+    ),
+    14: DeviceConfig(
+        disabled=True,
+        model_name="Ambient light sensor",
+    ),
+    15: DeviceConfig(
+        disabled=True,
+        model_name="Dusk sensor",
+    ),
+    16: DeviceConfig(
+        disabled=True,
+        model_name="ARC Remote",
+    ),
+    17: DeviceConfig(
+        disabled=True,
+        model_name="ARC Contact sensor",
+    ),
+    18: DeviceConfig(
+        disabled=True,
+        model_name="ARC Motion sensor",
+    ),
+    19: DeviceConfig(
+        disabled=True,
+        model_name="ARC Smoke sensor",
+    ),
+    20: DeviceConfig(
+        disabled=True,
+        model_name="ARC Siren",
+    ),
+    21: DeviceConfig(
+        disabled=True,
+        model_name="ACDB 7000B Doorbell",
+    ),
+    22: DeviceConfig(
+        disabled=True,
+        model_name="AWMT Buil-in wall switch",
+    ),
+    23: DeviceConfig(
+        disabled=True,
+        model_name="Somfy Actuator",
+    ),
+    24: DeviceConfig(
+        model_name="KAKU dimmable lightbulb",
+        on_off_function=0,
+        dim_function=1,
+        max_brightness=15,
+    ),
+    25: DeviceConfig(
+        disabled=True,
+        model_name="AGST 8800 KAKU 1 button wireless wall switch",
+    ),
+    26: DeviceConfig(
+        disabled=True,
+        model_name="AGST 8802 KAKU 2 button wireless wall switch",
+    ),
+    27: DeviceConfig(
+        disabled=True,
+        model_name="BREL Actuator",
+    ),
+    28: DeviceConfig(
+        disabled=True,
+        model_name="Contact sensor 2",
+    ),
+    29: DeviceConfig(
+        disabled=True,
+        model_name="ARC Keychain remote",
+    ),
+    30: DeviceConfig(
+        disabled=True,
+        model_name="ARC Action button",
+    ),
+    31: DeviceConfig(
+        disabled=True,
+        model_name="ARC Rotary dimmer",
+    ),
+    32: DeviceConfig(
+        disabled=True,
+        model_name="Unkown Zigbee device",
+    ),
+    33: DeviceConfig(  # 0 for onOff not working, maybe this,
+        model_name="Zigbee (ledvance) smart plug",
+        on_off_function=3,
+    ),
+    34: DeviceConfig(  # not tested
+        model_name="Dimmable",
+        on_off_function=3,
+        dim_function=4,
+    ),
+    35: DeviceConfig(
+        model_name="Zigbee RGB Light",
+    ),
+    36: DeviceConfig(
+        model_name="Zigbee (ledvance) dimmable with color temperature",
+        on_off_function=3,
+        dim_function=4,
+        color_temperature_function=9,
+    ),
+    37: DeviceConfig(
+        disabled=True,
+        model_name="Zigbee multi purpose dimmer",
+    ),
+    38: DeviceConfig(
+        disabled=True,
+        model_name="Zigbee lock",
+    ),
+    39: DeviceConfig(
+        disabled=True,
+        model_name="Zigbee light link remote",
+    ),
+    40: DeviceConfig(
+        model_name="KAKU dimmable lightbulb",
+        on_off_function=3,
+        dim_function=4,
+    ),
+    41: DeviceConfig(  # same as 33
+        model_name="Zigbee (ledvance) smart plug",
+        on_off_function=3,
+    ),
+    42: DeviceConfig(
+        disabled=True,
+        model_name="Zigbee lekkage sensor",
+    ),
+    43: DeviceConfig(
+        disabled=True,
+        model_name="KAKU wireless smoke detector ZSDR-850",
+    ),
+    44: DeviceConfig(
+        disabled=True,
+        model_name="Carbon monoxide sensor",
+    ),
+    45: DeviceConfig(
+        disabled=True,
+        model_name="Zigbee temperature and humidity sensor",
+    ),
+    46: DeviceConfig(
+        disabled=True,
+        model_name="Zigbee light group",
+    ),
+    47: DeviceConfig(
+        disabled=True,
+        model_name="Zigbee fire angel sensor",
+    ),
+    48: DeviceConfig(
+        model_name="KAKU group with dimmable lightbulb",
+        on_off_function=3,
+        dim_function=4,
+    ),
+    238: DeviceConfig(disabled=True, model_name="P1 Module"),
+    240: DeviceConfig(disabled=True, model_name="Alarm Module"),
+    241: DeviceConfig(disabled=True, model_name="IPCam Module"),
+    242: DeviceConfig(disabled=True, model_name="Geofencing Module"),
+    243: DeviceConfig(disabled=True, model_name="System Module"),
+}

ics_2000/encryption.py

@@ -0,0 +1,25 @@
+import base64
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import unpad
+from Crypto.Random import get_random_bytes
+
+encoding = "utf-8"
+block_size = 16
+pad = lambda s: s + (block_size - len(s) % block_size) * chr(
+    block_size - len(s) % block_size
+)
+
+
+def decrypt(string: str, aes: str) -> str:
+    base = base64.b64decode(string)
+    iv = base[:16]
+    inp = base[16:]
+    cipher = AES.new(bytes.fromhex(aes), AES.MODE_CBC, iv)
+    return unpad(cipher.decrypt(inp), 16).decode(encoding)
+
+
+def encrypt(string: str, aes: str) -> bytearray:
+    base = pad(string).encode()
+    iv = bytearray(16)
+    cipher = AES.new(bytes.fromhex(aes), AES.MODE_CBC, iv)
+    return iv + cipher.encrypt(base)

ics_2000/entities/color_temperature_device.py

@@ -0,0 +1,28 @@
+from ..model.device_data import DeviceData
+from .dim_device import DimDevice
+from ..model.device_config import DeviceConfig
+
+
+class ColorTemperatureDevice(DimDevice):
+    def __init__(self, hub, device_data: DeviceData, device_config: DeviceConfig):
+        super().__init__(hub, device_data, device_config)
+
+        if device_config.color_temperature_function is None:
+            raise ValueError(
+                f"Color temperature function not defined for '{self.device_data.name}'"
+            )
+
+    def change_color_temperature(
+        self, color_temperature: float, send_local: bool = True
+    ) -> None:
+        return self.get_hub().change_color_temperature(
+            self.entity_id,
+            self.device_config.color_temperature_function,
+            color_temperature,
+            self.is_group,
+            send_local,
+        )
+
+    def get_color_temperature(self) -> float:
+        status = self.get_hub().get_device_status(self.entity_id)
+        return status[self.device_config.color_temperature_function]

ics_2000/entities/device.py

@@ -0,0 +1,14 @@
+from .entity import Entity
+from ..model.device_data import DeviceData
+from ..model.device_config import DeviceConfig
+
+
+class Device(Entity):
+    def __init__(self, hub, device_data: DeviceData, device_config: DeviceConfig):
+        super().__init__(
+            hub, device_data, "group" in device_data.data and "group" or "module"
+        )
+        self.device_config = device_config
+        self.disabled = (
+            device_config.disabled if device_config.disabled is not None else False
+        )

ics_2000/entities/dim_device.py

@@ -0,0 +1,24 @@
+from ..model.device_data import DeviceData
+from .switch_device import SwitchDevice
+from ..model.device_config import DeviceConfig
+
+
+class DimDevice(SwitchDevice):
+    def __init__(self, hub, device_data: DeviceData, device_config: DeviceConfig):
+        super().__init__(hub, device_data, device_config)
+
+        if device_config.dim_function is None:
+            raise ValueError(f"Dim function not defined for '{self.device_data.name}'")
+
+    def dim(self, dim_level: int, send_local: bool = True) -> None:
+        return self.get_hub().dim_device(
+            self.entity_id,
+            self.device_config.dim_function,
+            dim_level,
+            self.is_group,
+            send_local,
+        )
+
+    def get_dim_level(self) -> int:
+        status = self.get_hub().get_device_status(self.entity_id)
+        return status[self.device_config.dim_function]

ics_2000/entities/entity.py

@@ -0,0 +1,28 @@
+from typing import List
+from ..model.device_data import DeviceData
+from ..model.entity_type import EntityType
+
+
+class Entity:
+    def __init__(self, hub, device_data: DeviceData, entity_type: EntityType):
+        self._hub = hub
+        self.entity_id = int(device_data.id)
+        self.name = device_data.data[entity_type].get("name", "")
+        self.device_type = (
+            device_data.data[entity_type].get("device", "")
+            if "device" in device_data.data[entity_type]
+            else entity_type
+        )
+        self.device_data = device_data
+        self.is_group = entity_type == "group"
+
+    def get_status(self) -> List[int]:
+        return self._hub.get_device_status(self.entity_id)
+
+    def get_hub(self):
+        return self._hub
+
+    def change_status(self, device_function: int, value: int, send_local: bool) -> None:
+        self._hub.change_status(
+            self.entity_id, device_function, value, self.is_group, send_local
+        )

ics_2000/entities/switch_device.py

@@ -0,0 +1,44 @@
+from ..model.device_data import DeviceData
+from ..model.device_config import DeviceConfig
+from .device import Device
+
+
+class SwitchDevice(Device):
+    def __init__(self, hub, device_data: DeviceData, device_config: DeviceConfig):
+        super().__init__(hub, device_data, device_config)
+
+        if device_config.on_off_function is None:
+            raise ValueError(
+                f"On/off function not defined for '{self.device_data.name}'"
+            )
+
+    def turn_on_off(self, on: bool, send_local: bool = True) -> None:
+        self.get_hub().turn_device_on_off(
+            self.entity_id,
+            on,
+            self.device_config.on_off_function,
+            self.is_group,
+            send_local,
+        )
+
+    def turn_on(self, send_local: bool = True) -> None:
+        self.get_hub().turn_device_on_off(
+            self.entity_id,
+            True,
+            self.device_config.on_off_function,
+            self.is_group,
+            send_local,
+        )
+
+    def turn_off(self, send_local: bool = True) -> None:
+        self.get_hub().turn_device_on_off(
+            self.entity_id,
+            False,
+            self.device_config.on_off_function,
+            self.is_group,
+            send_local,
+        )
+
+    def get_on_status(self) -> bool:
+        status = self.get_status()
+        return status[self.device_config.on_off_function] == 1

ics_2000/hub.py

@@ -0,0 +1,343 @@
+from datetime import datetime
+import json
+import requests
+from .command import Command
+from .encryption import decrypt
+from .config import API_URL, device_configs
+from .entities.color_temperature_device import ColorTemperatureDevice
+from .entities.device import Device
+from .entities.dim_device import DimDevice
+from .entities.switch_device import SwitchDevice
+from .model.device_config import DeviceConfig
+from .model.device_data import DeviceData
+from .model.entity_type import Entity_Type
+
+
+class Hub:
+    def __init__(self, email: str, password: str):
+        self.devices: list[
+            Device | DimDevice | SwitchDevice | ColorTemperatureDevice
+        ] = []
+        self.aes_key: str | None = None
+        self.mac: str | None = None
+        self.home_name: str | None = None
+        self.home_id: str | None = None
+        self.email = email
+        self.password = password
+        self.local_address = ""
+        self.device_statuses: dict[int, list[int]] = {}
+        self.update_date = datetime.min
+
+    def login(self):
+        test = requests.post(
+            f"{API_URL}/account.php",
+            {
+                "action": "login",
+                "email": self.email,
+                "password_hash": self.password,
+                "device_unique_id": "android",
+                "platform": "",
+                "mac": "",
+            },
+        )
+
+        if test.status_code != 200:
+            if test.status_code == 401:
+                raise Exception("Incorrect username or password")
+            raise Exception(test.content)
+
+        response = test.json()
+        if len(response.get("homes", [])) > 0:
+            home: dict = response["homes"][0]
+            self.aes_key = home.get("aes_key", "")
+            self.mac = home.get("mac", "")
+            self.home_id = home.get("home_id")
+            self.home_name = home.get("home_name")
+        else:
+            raise Exception("No homes")
+
+    def get_raw_devices_data(self, decrypt_data, decrypt_status) -> list:
+        if self.aes_key is None or self.mac is None:
+            raise Exception("no mac or auth key")
+
+        device_info = requests.post(
+            f"{API_URL}/gateway.php",
+            {
+                "action": "sync",
+                "email": self.email,
+                "mac": self.mac,
+                "password_hash": self.password,
+                "home_id": "",
+            },
+        )
+        data = []
+        for device in device_info.json():
+            current_device = self.format_device_data(
+                device, decrypt_data, decrypt_status
+            )
+            current_device["isGroup"] = "group" in current_device.keys()
+
+            if (
+                "module" in current_device["data"].keys()
+                and "info" in current_device["data"]["module"].keys()
+                and any(i > 0 for i in current_device["data"]["module"]["info"])
+            ):
+                data.append(current_device)
+
+            if "group" in current_device["data"].keys():
+                current_device["data"]["module"] = current_device["data"]["group"]
+                del current_device["data"]["group"]
+                data.append(current_device)
+
+        return data
+
+    def get_devices(self):
+        if self.home_id is None:
+            raise Exception("no home")
+
+        entities = self.get_raw_devices_data(True, False)
+        for device in entities:
+            device_data = DeviceData(
+                home_id=self.home_id,
+                name=device["data"]["module"]["name"],
+                id=device["data"]["module"]["id"],
+                device=device["data"]["module"]["device"],
+                isGroup=device.get("isGroup", False),
+                status=device.get("status", {}),
+                data=device.get("data", {}),
+            )
+            device_config = device_configs[device_data.device]
+            if device_config is None:
+                self.devices.append(
+                    SwitchDevice(
+                        self,
+                        device_data,
+                        DeviceConfig(
+                            model_name="Unknown device type", on_off_function=0
+                        ),
+                    )
+                )
+            elif device_config.color_temperature_function is not None:
+                self.devices.append(
+                    ColorTemperatureDevice(self, device_data, device_config)
+                )
+
+            elif device_config.dim_function is not None:
+                self.devices.append(DimDevice(self, device_data, device_config))
+
+            elif device_config.on_off_function is not None:
+                self.devices.append(SwitchDevice(self, device_data, device_config))
+            else:
+                self.devices.append(Device(self, device_data, device_config))
+
+    def create_command(
+        self, device_id: int, device_function: int, value: int, entity_type: Entity_Type
+    ) -> Command:
+        if self.aes_key is None or self.mac is None:
+            raise Exception("no mac or auth key")
+
+        device_functions: list[int] = []
+
+        # if entity_type == Entity_Type.Group:
+        #     device_functions = self.device_statuses.get(device_id, [])
+
+        return Command(
+            self.mac,
+            device_id,
+            device_function,
+            value,
+            self.aes_key,
+            entity_type,
+            device_functions,
+        )
+
+    def turn_device_on_off(
+        self,
+        device_id: int,
+        on: bool,
+        on_function: int,
+        is_group: bool,
+        send_local: bool,
+    ) -> None:
+        command = self.create_command(
+            device_id,
+            on_function,
+            1 if on else 0,
+            Entity_Type.Group if is_group else Entity_Type.Module,
+        )
+        return self.send_command(command, send_local)
+
+    def send_command(self, command: Command, send_local):
+        if send_local:
+            return self.send_command_to_hub(command, 2012)
+        else:
+            return self.send_command_to_cloud(command)
+
+    def send_command_to_hub(self, command: Command, port):
+        if self.local_address is None:
+            raise ValueError("Local address is undefined")
+
+        if not isinstance(port, int):
+            raise ValueError("Port needs to be an integer")
+
+        command.send_to(self.local_address, port)
+
+    def send_command_to_cloud(self, command: Command):
+        command.send_to_cloud(self.email, self.password)
+
+    def get_device_status(self, device_id: int) -> list[int]:
+        current_date = datetime.now()
+        update_date = self.update_date
+        self.update_date = datetime.now()
+
+        date_difference = (current_date - update_date).total_seconds() * 1000
+
+        if date_difference >= 2000 or len(self.device_statuses) == 0:
+            self.updating = True
+            self.get_all_device_statuses()
+            self.updating = False
+
+        # # Wait till the new data is fetched
+        # while self.updating:
+        #     await asyncio.sleep(0.1)
+
+        return self.device_statuses.get(device_id, [])
+
+    def get_raw_device_statuses(
+        self, decrypt_data: bool, decrypt_status: bool
+    ) -> list[dict]:
+        device_ids = [int(device.entity_id) for device in self.devices]
+        ids_string = json.dumps(device_ids)
+
+        params = {
+            "action": "get-multiple",
+            "email": self.email,
+            "mac": self.mac,
+            "password_hash": self.password,
+            "home_id": "",
+            "entity_id": ids_string,
+        }
+        status_list = requests.post(
+            f"{API_URL}/entity.php",
+            params,
+        ).json()
+
+        if len(status_list) == 0:
+            print(params)
+            raise Exception(
+                f"Unknown error while fetching device statuses, response json: {status_list}"
+            )
+        return [
+            self.format_device_data(d, decrypt_data, decrypt_status)
+            for d in status_list
+        ]
+
+    def format_device_data(
+        self, data: dict, decrypt_data: bool, decrypt_status: bool
+    ) -> dict:
+        if self.aes_key is None or self.mac is None:
+            raise Exception("no mac or auth key")
+
+        if decrypt_data:
+            data["data"] = json.loads(decrypt(data.get("data", ""), self.aes_key))
+        if decrypt_status and data.get("status", None) is not None:
+            data["status"] = json.loads(decrypt(data.get("status", ""), self.aes_key))
+        return data
+
+    def get_all_device_statuses(self):
+        status_list = self.get_raw_device_statuses(False, True)
+        for device in status_list:
+            json_status = device["status"]
+            if "module" in json_status.keys():
+                self.device_statuses[device["id"]] = json_status["module"]["functions"]
+            elif "group" in json_status.keys():
+                self.device_statuses[device["id"]] = json_status["group"]["functions"]
+            else:
+                Exception("Module or group data not found")
+
+    def change_status(
+        self,
+        device_id: int,
+        device_function: int,
+        value: int,
+        is_group: bool,
+        send_local: bool,
+    ):
+        command = self.create_command(
+            device_id,
+            device_function,
+            value,
+            Entity_Type.Group if is_group else Entity_Type.Module,
+        )
+        return self.send_command(command, send_local)
+
+    def dim_device(
+        self,
+        device_id: int,
+        dim_function: int,
+        dim_level: int,
+        is_group: bool,
+        send_local: bool,
+    ):
+        if dim_level < 0 or dim_level > 255:
+            raise ValueError(f"Dim level {dim_level} is negative or greater than 255")
+
+        command = self.create_command(
+            device_id,
+            dim_function,
+            dim_level,
+            Entity_Type.Group if is_group else Entity_Type.Module,
+        )
+        return self.send_command(command, send_local)
+
+    def change_color_temperature(
+        self,
+        device_id: int,
+        color_temp_function: int,
+        color_temperature: int,
+        is_group: bool,
+        send_local: bool,
+    ):
+        if color_temperature < 0 or color_temperature > 600:
+            raise ValueError(
+                f"Color temperature {color_temperature} is negative or greater than 600"
+            )
+
+        command = self.create_command(
+            device_id,
+            color_temp_function,
+            color_temperature,
+            Entity_Type.Group if is_group else Entity_Type.Module,
+        )
+        return self.send_command(command, send_local)
+
+    def generate_devices_json(self, decrypt_data: bool, decrypt_status: bool):
+        if not self.aes_key or not self.mac:
+            # print('MAC or AES key is null, so logging in!')
+            self.login()
+
+        devices = self.get_raw_devices_data(decrypt_data, decrypt_status)
+        with open("devices.json", "w") as f:
+            json.dump(devices, f, indent=2)
+
+    def generate_device_statuses_json(self, decrypt_data: bool, decrypt_status: bool):
+        if not self.aes_key or not self.mac:
+            # print('MAC or AES key is null, so logging in!')
+            self.login()
+            self.get_devices()
+
+        devices = self.get_raw_device_statuses(decrypt_data, decrypt_status)
+        with open("statuses.json", "w") as f:
+            json.dump(devices, f, indent=2)
+
+    def get_p1_entity_id(self):
+        raw_devices_data = self.get_raw_devices_data(True, False)
+        p1_entity = next(
+            (
+                d
+                for d in raw_devices_data
+                if d.get("data", {}).get("module", {}).get("name") == "P1 Module"
+            ),
+            None,
+        )
+        return p1_entity.get("id") if p1_entity else None

ics_2000/model/device_config.py

@@ -0,0 +1,21 @@
+from typing import Optional
+
+
+class DeviceConfig:
+    def __init__(
+        self,
+        model_name: str,
+        disabled: Optional[bool] = None,
+        on_off_function: Optional[int] = None,
+        dim_function: Optional[int] = None,
+        color_temperature_function: Optional[int] = None,
+        max_brightness: Optional[int] = None,
+        max_color_temperature: Optional[int] = None,
+    ):
+        self.disabled = disabled
+        self.model_name = model_name
+        self.on_off_function = on_off_function
+        self.dim_function = dim_function
+        self.color_temperature_function = color_temperature_function
+        self.max_brightness = max_brightness
+        self.max_color_temperature = max_color_temperature

ics_2000/model/device_data.py

@@ -0,0 +1,21 @@
+from typing import Dict
+
+
+class DeviceData:
+    def __init__(
+        self,
+        home_id: str,
+        id: str,
+        name: str,
+        device: int,
+        isGroup: bool,
+        status: Dict[str, Dict[str, int]],
+        data: Dict[str, Dict[str, int]],
+    ):
+        self.home_id = home_id
+        self.id = id
+        self.name = name
+        self.device = device
+        self.isGroup = isGroup
+        self.status = status
+        self.data = data

ics_2000/model/entity_type.py

@@ -0,0 +1,11 @@
+import enum
+from typing import Literal, Union
+
+
+class Entity_Type(enum.Enum):
+    Module = "module"
+    Group = "group"
+    Scene = "scene"
+
+
+EntityType = Union[Literal["module"], Literal["group"], Literal["scene"]]

ics_2000/model/smart_meter_data.py

@@ -0,0 +1,24 @@
+from typing import Union
+from datetime import datetime
+
+Precision = str
+
+
+class SmartMeterData:
+    def __init__(
+        self,
+        date: Union[datetime, str, int],
+        power_consumed_low_tariff: float,
+        power_consumed: float,
+        power_produced_low_tariff: float,
+        power_produced: float,
+        gas: float,
+        water: float,
+    ):
+        self.date = date
+        self.power_consumed_low_tariff = power_consumed_low_tariff
+        self.power_consumed = power_consumed
+        self.power_produced_low_tariff = power_produced_low_tariff
+        self.power_produced = power_produced
+        self.gas = gas
+        self.water = water

ics_2000/model/smart_meter_data_current.py

@@ -0,0 +1,23 @@
+from typing import List
+
+
+class SmartMeterDataCurrent:
+    def __init__(
+        self,
+        power_consumed_low_tariff: float,
+        power_consumed: float,
+        power_produced_low_tariff: float,
+        power_produced: float,
+        current_consumption: float,
+        current_production: float,
+        gas: float,
+        raw_data_array: List[float],
+    ):
+        self.power_consumed_low_tariff = power_consumed_low_tariff
+        self.power_consumed = power_consumed
+        self.power_produced_low_tariff = power_produced_low_tariff
+        self.power_produced = power_produced
+        self.current_consumption = current_consumption
+        self.current_production = current_production
+        self.gas = gas
+        self.raw_data_array = raw_data_array

ics_2000_python-0.1.0.dist-info/LICENSE

@@ -0,0 +1,176 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

ics_2000_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,14 @@
+Metadata-Version: 2.1
+Name: ics_2000_python
+Version: 0.1.0
+Summary: 
+Author: iiTzArcur
+Author-email: zefanjaj@gmail.com
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: pycryptodome (>=3.21.0,<4.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Description-Content-Type: text/markdown
+
+

ics_2000_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+ics_2000/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ics_2000/command.py,sha256=_REpHEvxsviYgHdughucwaSprQZhYo5tUSgifHhNrgo,2781
+ics_2000/config.py,sha256=kgiWnse06SQ9qhoUMaGOeaVqZ10To-775iEyq_X8_Wo,5524
+ics_2000/encryption.py,sha256=sI-ptiih1B7okP24yyven8jACAhKDvlEv2UDoUi6nbU,702
+ics_2000/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ics_2000/entities/color_temperature_device.py,sha256=gPsEjkRLDtMe9GY2_ZXH_R1XXHnOkka7eR1eJL_rLgU,1033
+ics_2000/entities/device.py,sha256=ysbB7sXckx3jNGXLUAQ53rmblsXyh4-B1Dd1dpw7D4I,505
+ics_2000/entities/dim_device.py,sha256=kEm0N4d99dT1SLJWwqEKkZZf6DxpSuQGiNbEnZ0PPX4,866
+ics_2000/entities/entity.py,sha256=bXuGH8RrA1qp0pwVZIrQPekPp3wH5fzOCe2CuWLPU1s,970
+ics_2000/entities/switch_device.py,sha256=ctjzn3B7qfUmVdwekJO9x9zWAalswqYu4wQUzO9GNFg,1375
+ics_2000/hub.py,sha256=IWg6hdlg8mNx6m8Wt_xrvBEmXTS8v2tI_JawTI9EuEU,11784
+ics_2000/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ics_2000/model/device_config.py,sha256=IK8hsixCxM_4xcwveRMIplGyUCsAo8kSze4ki2H7Y8c,734
+ics_2000/model/device_data.py,sha256=p5XeuU-88No7YxsSbrMnt-xYVhDrZIk9-N3I2DvY3w4,460
+ics_2000/model/entity_type.py,sha256=TVtes0QcFYeYMgMcAQ5ZZkEriynozNUYGE8nr8Yku_g,216
+ics_2000/model/smart_meter_data.py,sha256=frpdosAA69G-sAksXZk1RTMMGGN2aw0VeWEo5qV55Kw,663
+ics_2000/model/smart_meter_data_current.py,sha256=SwuBc-6e7jgjE2zAj-kop_JusErfNmNgkLCwtyO4vLQ,768
+ics_2000_python-0.1.0.dist-info/LICENSE,sha256=WYmcYJG1QFgu1hfo7qrEkZ3Jhcz8NUWe6XUraZvlIFs,10172
+ics_2000_python-0.1.0.dist-info/METADATA,sha256=80Y-1r3mkgQv5r_DhSy1a92nQjnhQUcOm94b45y0ZZ8,378
+ics_2000_python-0.1.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+ics_2000_python-0.1.0.dist-info/RECORD,,

ics_2000_python-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any