Make 'code' attribute really optional

Oven overwrite

pyhon/__main__.py

@@ -78,12 +78,7 @@ async def main():
                     )
                 )
             else:
-                print(helper.pretty_print({"data": device.data}))
-                print(
-                    helper.pretty_print(
-                        {"settings": helper.create_command(device.commands)}
-                    )
-                )
+                print(device.diagnose("  "))
 
 
 def start():

pyhon/appliance.py

@@ -1,17 +1,26 @@
 import importlib
+import json
+import logging
 from contextlib import suppress
+from datetime import datetime, timedelta
+from pathlib import Path
 from typing import Optional, Dict, Any
 from typing import TYPE_CHECKING
 
 from pyhon import helper
 from pyhon.commands import HonCommand
+from pyhon.parameter.base import HonParameter
 from pyhon.parameter.fixed import HonParameterFixed
 
 if TYPE_CHECKING:
     from pyhon import HonAPI
 
+_LOGGER = logging.getLogger(__name__)
+
 
 class HonAppliance:
+    _MINIMAL_UPDATE_INTERVAL = 5  # seconds
+
     def __init__(
         self, api: Optional["HonAPI"], info: Dict[str, Any], zone: int = 0
     ) -> None:
@@ -25,11 +34,14 @@ class HonAppliance:
         self._statistics: Dict = {}
         self._attributes: Dict = {}
         self._zone: int = zone
+        self._additional_data: Dict[str, Any] = {}
+        self._last_update = None
+        self._default_setting = HonParameter("", {}, "")
 
         try:
             self._extra = importlib.import_module(
                 f"pyhon.appliances.{self.appliance_type.lower()}"
-            ).Appliance()
+            ).Appliance(self)
         except ModuleNotFoundError:
             self._extra = None
 
@@ -106,13 +118,21 @@ class HonAppliance:
     def info(self):
         return self._info
 
+    @property
+    def additional_data(self):
+        return self._additional_data
+
     @property
     def zone(self) -> int:
         return self._zone
 
-    async def _recover_last_command_states(self, commands):
-        command_history = await self._api.command_history(self)
-        for name, command in commands.items():
+    @property
+    def api(self) -> Optional["HonAPI"]:
+        return self._api
+
+    async def _recover_last_command_states(self):
+        command_history = await self.api.command_history(self)
+        for name, command in self._commands.items():
             last = next(
                 (
                     index
@@ -124,8 +144,13 @@ class HonAppliance:
             if last is None:
                 continue
             parameters = command_history[last].get("command", {}).get("parameters", {})
-            if command.programs and parameters.get("program"):
-                command.program = parameters.pop("program").split(".")[-1].lower()
+            if command.categories and (
+                parameters.get("program") or parameters.get("category")
+            ):
+                if parameters.get("program"):
+                    command.category = parameters.pop("program").split(".")[-1].lower()
+                else:
+                    command.category = parameters.pop("category")
                 command = self.commands[name]
             for key, data in command.settings.items():
                 if (
@@ -135,83 +160,158 @@ class HonAppliance:
                     with suppress(ValueError):
                         data.value = parameters.get(key)
 
-    async def load_commands(self):
-        raw = await self._api.load_commands(self)
-        self._appliance_model = raw.pop("applianceModel")
-        for item in ["settings", "options", "dictionaryId"]:
-            raw.pop(item)
-        commands = {}
-        for command, attr in raw.items():
-            if "parameters" in attr:
-                commands[command] = HonCommand(command, attr, self._api, self)
-            elif "parameters" in attr[list(attr)[0]]:
-                multi = {}
-                for program, attr2 in attr.items():
-                    program = program.split(".")[-1].lower()
-                    cmd = HonCommand(
+    def _get_categories(self, command, data):
+        categories = {}
+        for category, value in data.items():
+            result = self._get_command(value, command, category, categories)
+            if result:
+                if "PROGRAM" in category:
+                    category = category.split(".")[-1].lower()
+                categories[category] = result[0]
+        if categories:
+            if "setParameters" in categories:
+                return [categories["setParameters"]]
+            return [list(categories.values())[0]]
+        return []
+
+    def _get_commands(self, data):
+        commands = []
+        for command, value in data.items():
+            commands += self._get_command(value, command, "")
+        return {c.name: c for c in commands}
+
+    def _get_command(self, data, command="", category="", categories=None):
+        commands = []
+        if isinstance(data, dict):
+            if data.get("description") and data.get("protocolType", None):
+                commands += [
+                    HonCommand(
                         command,
-                        attr2,
-                        self._api,
+                        data,
                         self,
-                        programs=multi,
-                        program_name=program,
+                        category_name=category,
+                        categories=categories,
                     )
-                    multi[program] = cmd
-                    commands[command] = cmd
-        self._commands = commands
-        await self._recover_last_command_states(commands)
+                ]
+            else:
+                commands += self._get_categories(command, data)
+        elif category:
+            self._additional_data.setdefault(command, {})[category] = data
+        else:
+            self._additional_data[command] = data
+        return commands
+
+    async def load_commands(self):
+        raw = await self.api.load_commands(self)
+        self._appliance_model = raw.pop("applianceModel")
+        raw.pop("dictionaryId", None)
+        self._commands = self._get_commands(raw)
+        await self._recover_last_command_states()
+
+    async def load_attributes(self):
+        self._attributes = await self.api.load_attributes(self)
+        for name, values in self._attributes.pop("shadow").get("parameters").items():
+            self._attributes.setdefault("parameters", {})[name] = values["parNewVal"]
+
+    async def load_statistics(self):
+        self._statistics = await self.api.load_statistics(self)
+        self._statistics |= await self.api.load_maintenance(self)
+
+    async def update(self):
+        now = datetime.now()
+        if not self._last_update or self._last_update < now - timedelta(
+            seconds=self._MINIMAL_UPDATE_INTERVAL
+        ):
+            self._last_update = now
+            await self.load_attributes()
+
+    @property
+    def command_parameters(self):
+        return {n: c.parameter_value for n, c in self._commands.items()}
 
     @property
     def settings(self):
         result = {}
         for name, command in self._commands.items():
-            for key, setting in command.settings.items():
+            for key in command.setting_keys:
+                setting = command.settings.get(key, self._default_setting)
                 result[f"{name}.{key}"] = setting
         if self._extra:
             return self._extra.settings(result)
         return result
 
     @property
-    def parameters(self):
-        result = {}
+    def available_settings(self):
+        result = []
         for name, command in self._commands.items():
-            for key, parameter in (
-                command.parameters | command.ancillary_parameters
-            ).items():
-                result.setdefault(name, {})[key] = parameter.value
+            for key in command.setting_keys:
+                result.append(f"{name}.{key}")
         return result
 
-    async def load_attributes(self):
-        self._attributes = await self._api.load_attributes(self)
-        for name, values in self._attributes.pop("shadow").get("parameters").items():
-            self._attributes.setdefault("parameters", {})[name] = values["parNewVal"]
-
-    async def load_statistics(self):
-        self._statistics = await self._api.load_statistics(self)
-
-    async def update(self):
-        await self.load_attributes()
-
     @property
     def data(self):
         result = {
             "attributes": self.attributes,
             "appliance": self.info,
             "statistics": self.statistics,
-            **self.parameters,
+            "additional_data": self._additional_data,
+            **self.command_parameters,
         }
         if self._extra:
             return self._extra.data(result)
         return result
 
-    @property
-    def diagnose(self):
-        data = self.data.copy()
-        for sensible in ["PK", "SK", "serialNumber", "code", "coords"]:
-            data["appliance"].pop(sensible, None)
-        result = helper.pretty_print({"data": self.data}, whitespace="\u200B \u200B ")
+    def diagnose(self, whitespace="  ", command_only=False):
+        data = {
+            "attributes": self.attributes.copy(),
+            "appliance": self.info,
+            "statistics": self.statistics,
+            "additional_data": self._additional_data,
+        }
+        if command_only:
+            data.pop("attributes")
+            data.pop("appliance")
+            data.pop("statistics")
+        data |= {n: c.parameter_groups for n, c in self._commands.items()}
+        extra = {n: c.data for n, c in self._commands.items() if c.data}
+        if extra:
+            data |= {"extra_command_data": extra}
+        for sensible in ["PK", "SK", "serialNumber", "coords", "device"]:
+            data.get("appliance", {}).pop(sensible, None)
+        result = helper.pretty_print({"data": data}, whitespace=whitespace)
         result += helper.pretty_print(
             {"commands": helper.create_command(self.commands)},
-            whitespace="\u200B \u200B ",
+            whitespace=whitespace,
         )
-        return result.replace(self.mac_address, "12-34-56-78-90-ab")
+        return result.replace(self.mac_address, "xx-xx-xx-xx-xx-xx")
+
+
+class HonApplianceTest(HonAppliance):
+    def __init__(self, name):
+        super().__init__(None, {})
+        self._name = name
+        self.load_commands()
+        self._info = self._appliance_model
+
+    def load_commands(self):
+        device = Path(__file__).parent / "test_data" / f"{self._name}.json"
+        with open(str(device)) as f:
+            raw = json.loads(f.read())
+        self._appliance_model = raw.pop("applianceModel")
+        raw.pop("dictionaryId", None)
+        self._commands = self._get_commands(raw)
+
+    async def update(self):
+        return
+
+    @property
+    def nick_name(self) -> str:
+        return self._name
+
+    @property
+    def unique_id(self) -> str:
+        return self._name
+
+    @property
+    def mac_address(self) -> str:
+        return "xx-xx-xx-xx-xx-xx"

pyhon/appliances/dw.py

@@ -1,4 +1,7 @@
 class Appliance:
+    def __init__(self, appliance):
+        self.parent = appliance
+
     def data(self, data):
         if data["attributes"]["lastConnEvent"]["category"] == "DISCONNECTED":
             data["attributes"]["parameters"]["machMode"] = "0"

pyhon/appliances/ov.py

@@ -0,0 +1,17 @@
+class Appliance:
+    def __init__(self, appliance):
+        self.parent = appliance
+
+    def data(self, data):
+        if data["attributes"]["lastConnEvent"]["category"] == "DISCONNECTED":
+            data["attributes"]["parameters"]["temp"] = "0"
+            data["attributes"]["parameters"]["onOffStatus"] = "0"
+            data["attributes"]["parameters"]["remoteCtrValid"] = "0"
+            data["attributes"]["parameters"]["remainingTimeMM"] = "0"
+
+        data["active"] = data["attributes"]["parameters"]["onOffStatus"] == "1"
+
+        return data
+
+    def settings(self, settings):
+        return settings

pyhon/appliances/td.py

@@ -1,10 +1,22 @@
+from pyhon.parameter.fixed import HonParameterFixed
+
+
 class Appliance:
+    def __init__(self, appliance):
+        self.parent = appliance
+
     def data(self, data):
         if data["attributes"]["lastConnEvent"]["category"] == "DISCONNECTED":
             data["attributes"]["parameters"]["machMode"] = "0"
         data["active"] = bool(data.get("attributes", {}).get("activity"))
         data["pause"] = data["attributes"]["parameters"]["machMode"] == "3"
+        if program := int(data["attributes"]["parameters"]["prCode"]):
+            ids = self.parent.settings["startProgram.program"].ids
+            data["programName"] = ids.get(program, "")
         return data
 
     def settings(self, settings):
+        dry_level = settings.get("startProgram.dryLevel")
+        if isinstance(dry_level, HonParameterFixed) and dry_level.value == "11":
+            settings.pop("startProgram.dryLevel", None)
         return settings

pyhon/appliances/wd.py

@@ -1,4 +1,7 @@
 class Appliance:
+    def __init__(self, appliance):
+        self.parent = appliance
+
     def data(self, data):
         if data["attributes"]["lastConnEvent"]["category"] == "DISCONNECTED":
             data["attributes"]["parameters"]["machMode"] = "0"

pyhon/appliances/wm.py

@@ -1,4 +1,7 @@
 class Appliance:
+    def __init__(self, appliance):
+        self.parent = appliance
+
     def data(self, data):
         if data["attributes"]["lastConnEvent"]["category"] == "DISCONNECTED":
             data["attributes"]["parameters"]["machMode"] = "0"

pyhon/commands.py

@@ -1,5 +1,6 @@
-from typing import Optional, Dict, Any, List, TYPE_CHECKING
+from typing import Optional, Dict, Any, List, TYPE_CHECKING, Union
 
+from pyhon import exceptions
 from pyhon.parameter.base import HonParameter
 from pyhon.parameter.enum import HonParameterEnum
 from pyhon.parameter.fixed import HonParameterFixed
@@ -16,102 +17,125 @@ class HonCommand:
         self,
         name: str,
         attributes: Dict[str, Any],
-        api: "HonAPI",
         appliance: "HonAppliance",
-        programs: Optional[Dict[str, "HonCommand"]] = None,
-        program_name: str = "",
+        categories: Optional[Dict[str, "HonCommand"]] = None,
+        category_name: str = "",
     ):
-        self._api: HonAPI = api
+        self._api: Optional[HonAPI] = appliance.api
         self._appliance: "HonAppliance" = appliance
         self._name: str = name
-        self._programs: Optional[Dict[str, "HonCommand"]] = programs or {}
-        self._program_name: str = program_name
-        self._description: str = attributes.get("description", "")
-        self._parameters: Dict[str, HonParameter] = self._create_parameters(
-            attributes.get("parameters", {})
-        )
-        self._ancillary_parameters: Dict[str, HonParameter] = self._create_parameters(
-            attributes.get("ancillaryParameters", {})
-        )
+        self._categories: Optional[Dict[str, "HonCommand"]] = categories
+        self._category_name: str = category_name
+        self._description: str = attributes.pop("description", "")
+        self._protocol_type: str = attributes.pop("protocolType", "")
+        self._parameters: Dict[str, HonParameter] = {}
+        self._data: Dict[str, Any] = {}
+        self._available_settings: Dict[str, HonParameter] = {}
+        self._load_parameters(attributes)
 
     def __repr__(self) -> str:
         return f"{self._name} command"
 
-    def _create_parameters(self, parameters: Dict) -> Dict[str, HonParameter]:
-        result: Dict[str, HonParameter] = {}
-        for parameter, attributes in parameters.items():
-            if parameter == "zoneMap" and self._appliance.zone:
-                attributes["default"] = self._appliance.zone
-            match attributes.get("typology"):
-                case "range":
-                    result[parameter] = HonParameterRange(parameter, attributes)
-                case "enum":
-                    result[parameter] = HonParameterEnum(parameter, attributes)
-                case "fixed":
-                    result[parameter] = HonParameterFixed(parameter, attributes)
-        if self._programs:
-            result["program"] = HonParameterProgram("program", self)
-        return result
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def api(self) -> "HonAPI":
+        if self._api is None:
+            raise exceptions.NoAuthenticationException
+        return self._api
+
+    @property
+    def data(self):
+        return self._data
 
     @property
     def parameters(self) -> Dict[str, HonParameter]:
         return self._parameters
 
     @property
-    def ancillary_parameters(self) -> Dict[str, HonParameter]:
-        return self._ancillary_parameters
+    def settings(self) -> Dict[str, HonParameter]:
+        return self._parameters
+
+    @property
+    def parameter_groups(self) -> Dict[str, Dict[str, Union[str, float]]]:
+        result: Dict[str, Dict[str, Union[str, float]]] = {}
+        for name, parameter in self._parameters.items():
+            result.setdefault(parameter.group, {})[name] = parameter.value
+        return result
+
+    @property
+    def parameter_value(self) -> Dict[str, Union[str, float]]:
+        return {n: p.value for n, p in self._parameters.items()}
+
+    def _load_parameters(self, attributes):
+        for key, items in attributes.items():
+            for name, data in items.items():
+                self._create_parameters(data, name, key)
+
+    def _create_parameters(self, data: Dict, name: str, parameter: str) -> None:
+        if name == "zoneMap" and self._appliance.zone:
+            data["default"] = self._appliance.zone
+        match data.get("typology"):
+            case "range":
+                self._parameters[name] = HonParameterRange(name, data, parameter)
+            case "enum":
+                self._parameters[name] = HonParameterEnum(name, data, parameter)
+            case "fixed":
+                self._parameters[name] = HonParameterFixed(name, data, parameter)
+            case _:
+                self._data[name] = data
+                return
+        if self._category_name:
+            name = "program" if "PROGRAM" in self._category_name else "category"
+            self._parameters[name] = HonParameterProgram(name, self, "custom")
 
     async def send(self) -> bool:
-        params = {k: v.value for k, v in self._parameters.items()}
-        ancillary_params = {k: v.value for k, v in self._ancillary_parameters.items()}
-        return await self._api.send_command(
+        params = self.parameter_groups.get("parameters", {})
+        ancillary_params = self.parameter_groups.get("ancillaryParameters", {})
+        return await self.api.send_command(
             self._appliance, self._name, params, ancillary_params
         )
 
     @property
-    def programs(self) -> Dict[str, "HonCommand"]:
-        if self._programs is None:
-            return {}
-        return self._programs
+    def categories(self) -> Dict[str, "HonCommand"]:
+        if self._categories is None:
+            return {"_": self}
+        return self._categories
 
     @property
-    def program(self) -> str:
-        return self._program_name
+    def category(self) -> str:
+        return self._category_name
 
-    @program.setter
-    def program(self, program: str) -> None:
-        self._appliance.commands[self._name] = self.programs[program]
-
-    def _get_settings_keys(self, command: Optional["HonCommand"] = None) -> List[str]:
-        if command is None:
-            command = self
-        keys = []
-        for key, parameter in (
-            command._parameters | command._ancillary_parameters
-        ).items():
-            if isinstance(parameter, HonParameterFixed):
-                continue
-            if key not in keys:
-                keys.append(key)
-        return keys
+    @category.setter
+    def category(self, category: str) -> None:
+        if category in self.categories:
+            self._appliance.commands[self._name] = self.categories[category]
 
     @property
     def setting_keys(self) -> List[str]:
-        if not self._programs:
-            return self._get_settings_keys()
-        result = [
-            key
-            for cmd in self._programs.values()
-            for key in self._get_settings_keys(cmd)
-        ]
-        return list(set(result + ["program"]))
+        return list(
+            {param for cmd in self.categories.values() for param in cmd.parameters}
+        )
+
+    @staticmethod
+    def _more_options(first: HonParameter, second: HonParameter):
+        if isinstance(first, HonParameterFixed) and not isinstance(
+            second, HonParameterFixed
+        ):
+            return second
+        if len(second.values) > len(first.values):
+            return second
+        return first
 
     @property
-    def settings(self) -> Dict[str, HonParameter]:
-        """Parameters with typology enum and range"""
-        return {
-            s: param
-            for s in self.setting_keys
-            if (param := self._parameters.get(s)) is not None
-            or (param := self._ancillary_parameters.get(s)) is not None
-        }
+    def available_settings(self) -> Dict[str, HonParameter]:
+        result: Dict[str, HonParameter] = {}
+        for command in self.categories.values():
+            for name, parameter in command.parameters.items():
+                if name in result:
+                    result[name] = self._more_options(result[name], parameter)
+                else:
+                    result[name] = parameter
+        return result

pyhon/connection/api.py

@@ -12,7 +12,7 @@ from pyhon.connection.auth import HonAuth
 from pyhon.connection.handler.anonym import HonAnonymousConnectionHandler
 from pyhon.connection.handler.hon import HonConnectionHandler
 
-_LOGGER = logging.getLogger()
+_LOGGER = logging.getLogger(__name__)
 
 
 class HonAPI:
@@ -72,15 +72,18 @@ class HonAPI:
     async def load_commands(self, appliance: HonAppliance) -> Dict:
         params: Dict = {
             "applianceType": appliance.appliance_type,
-            "code": appliance.info["code"],
             "applianceModelId": appliance.appliance_model_id,
-            "firmwareId": appliance.info["eepromId"],
             "macAddress": appliance.mac_address,
-            "fwVersion": appliance.info["fwVersion"],
             "os": const.OS,
             "appVersion": const.APP_VERSION,
             "series": appliance.info["series"],
         }
+        if firmware_id := appliance.info.get("eepromId"):
+            params["firmwareId"] = firmware_id
+        if firmware_version := appliance.info.get("fwVersion"):
+            params["fwVersion"] = firmware_version
+        if code := appliance.info.get("code"):
+            params["code"] = code
         url: str = f"{const.API_URL}/commands/v1/retrieve"
         async with self._hon.get(url, params=params) as response:
             result: Dict = (await response.json()).get("payload", {})
@@ -98,6 +101,16 @@ class HonAPI:
                 return {}
             return result["payload"]["history"]
 
+    async def command_favourites(self, appliance: HonAppliance) -> Dict:
+        url: str = (
+            f"{const.API_URL}/commands/v1/appliance/{appliance.mac_address}/favourite"
+        )
+        async with self._hon.get(url) as response:
+            result: Dict = await response.json()
+            if not result or not result.get("payload"):
+                return {}
+            return result["payload"]["favourites"]
+
     async def last_activity(self, appliance: HonAppliance) -> Dict:
         url: str = f"{const.API_URL}/commands/v1/retrieve-last-activity"
         params: Dict = {"macAddress": appliance.mac_address}
@@ -107,6 +120,18 @@ class HonAPI:
                 return activity
         return {}
 
+    async def appliance_model(self, appliance: HonAppliance) -> Dict:
+        url: str = f"{const.API_URL}/commands/v1/appliance-model"
+        params: Dict = {
+            "code": appliance.info["code"],
+            "macAddress": appliance.mac_address,
+        }
+        async with self._hon.get(url, params=params) as response:
+            result: Dict = await response.json()
+            if result and (activity := result.get("attributes")):
+                return activity
+        return {}
+
     async def load_attributes(self, appliance: HonAppliance) -> Dict:
         params: Dict = {
             "macAddress": appliance.mac_address,
@@ -126,6 +151,12 @@ class HonAPI:
         async with self._hon.get(url, params=params) as response:
             return (await response.json()).get("payload", {})
 
+    async def load_maintenance(self, appliance: HonAppliance):
+        url = f"{const.API_URL}/commands/v1/maintenance-cycle"
+        params = {"macAddress": appliance.mac_address}
+        async with self._hon.get(url, params=params) as response:
+            return (await response.json()).get("payload", {})
+
     async def send_command(
         self,
         appliance: HonAppliance,
@@ -159,7 +190,7 @@ class HonAPI:
         return False
 
     async def appliance_configuration(self) -> Dict:
-        url: str = f"{const.API_URL}/config/v1/appliance-configuration"
+        url: str = f"{const.API_URL}/config/v1/program-list-rules"
         async with self._hon_anonymous.get(url) as response:
             result: Dict = await response.json()
             if result and (data := result.get("payload")):

pyhon/connection/auth.py

@@ -182,13 +182,14 @@ class HonAuth:
             await self._error_logger(response)
             return ""
 
-    def _parse_token_data(self, text: str) -> None:
+    def _parse_token_data(self, text: str) -> bool:
         if access_token := re.findall("access_token=(.*?)&", text):
             self._access_token = access_token[0]
         if refresh_token := re.findall("refresh_token=(.*?)&", text):
             self._refresh_token = refresh_token[0]
         if id_token := re.findall("id_token=(.*?)&", text):
             self._id_token = id_token[0]
+        return True if access_token and refresh_token and id_token else False
 
     async def _get_token(self, url: str) -> bool:
         async with self._request.get(url) as response:
@@ -214,7 +215,9 @@ class HonAuth:
             if response.status != 200:
                 await self._error_logger(response)
                 return False
-            self._parse_token_data(await response.text())
+            if not self._parse_token_data(await response.text()):
+                await self._error_logger(response)
+                return False
         return True
 
     async def _api_auth(self) -> bool:
@@ -228,7 +231,10 @@ class HonAuth:
             except json.JSONDecodeError:
                 await self._error_logger(response)
                 return False
-            self._cognito_token = json_data["cognitoUser"]["Token"]
+            self._cognito_token = json_data.get("cognitoUser", {}).get("Token", "")
+            if not self._cognito_token:
+                _LOGGER.error(json_data)
+                raise exceptions.HonAuthenticationError()
         return True
 
     async def authenticate(self) -> None:

pyhon/helper.py

@@ -49,7 +49,7 @@ def create_command(commands, concat=False):
     for name, command in commands.items():
         if not concat:
             result[name] = {}
-        for parameter, data in command.settings.items():
+        for parameter, data in command.available_settings.items():
             if data.typology == "enum":
                 value = data.values
             elif data.typology == "range":

pyhon/hon.py

@@ -1,4 +1,5 @@
 import asyncio
+import logging
 from types import TracebackType
 from typing import List, Optional, Dict, Any, Type
 
@@ -8,11 +9,18 @@ from typing_extensions import Self
 from pyhon import HonAPI, exceptions
 from pyhon.appliance import HonAppliance
 
+_LOGGER = logging.getLogger(__name__)
+
 
 class Hon:
-    def __init__(self, email: str, password: str, session: ClientSession | None = None):
-        self._email: str = email
-        self._password: str = password
+    def __init__(
+        self,
+        email: Optional[str] = "",
+        password: Optional[str] = "",
+        session: Optional[ClientSession] = None,
+    ):
+        self._email: Optional[str] = email
+        self._password: Optional[str] = password
         self._session: ClientSession | None = session
         self._appliances: List[HonAppliance] = []
         self._api: Optional[HonAPI] = None
@@ -34,9 +42,21 @@ class Hon:
             raise exceptions.NoAuthenticationException
         return self._api
 
+    @property
+    def email(self) -> str:
+        if not self._email:
+            raise ValueError("Missing email")
+        return self._email
+
+    @property
+    def password(self) -> str:
+        if not self._password:
+            raise ValueError("Missing password")
+        return self._password
+
     async def create(self) -> Self:
         self._api = await HonAPI(
-            self._email, self._password, session=self._session
+            self.email, self.password, session=self._session
         ).create()
         await self.setup()
         return self
@@ -45,17 +65,25 @@ class Hon:
     def appliances(self) -> List[HonAppliance]:
         return self._appliances
 
+    @appliances.setter
+    def appliances(self, appliances) -> None:
+        self._appliances = appliances
+
     async def _create_appliance(self, appliance_data: Dict[str, Any], zone=0) -> None:
         appliance = HonAppliance(self._api, appliance_data, zone=zone)
-        if appliance.mac_address is None:
+        if appliance.mac_address == "":
             return
-        await asyncio.gather(
-            *[
-                appliance.load_attributes(),
-                appliance.load_commands(),
-                appliance.load_statistics(),
-            ]
-        )
+        try:
+            await asyncio.gather(
+                *[
+                    appliance.load_attributes(),
+                    appliance.load_commands(),
+                    appliance.load_statistics(),
+                ]
+            )
+        except (KeyError, ValueError, IndexError) as error:
+            _LOGGER.exception(error)
+            _LOGGER.error("Device data - %s", appliance_data)
         self._appliances.append(appliance)
 
     async def setup(self) -> None:

pyhon/parameter/base.py

@@ -1,13 +1,14 @@
-from typing import Dict, Any
+from typing import Dict, Any, List
 
 
 class HonParameter:
-    def __init__(self, key: str, attributes: Dict[str, Any]) -> None:
+    def __init__(self, key: str, attributes: Dict[str, Any], group: str) -> None:
         self._key = key
         self._category: str = attributes.get("category", "")
         self._typology: str = attributes.get("typology", "")
         self._mandatory: int = attributes.get("mandatory", 0)
         self._value: str | float = ""
+        self._group: str = group
 
     @property
     def key(self) -> str:
@@ -17,6 +18,10 @@ class HonParameter:
     def value(self) -> str | float:
         return self._value if self._value is not None else "0"
 
+    @property
+    def values(self) -> List[str]:
+        return [str(self.value)]
+
     @property
     def category(self) -> str:
         return self._category
@@ -28,3 +33,7 @@ class HonParameter:
     @property
     def mandatory(self) -> int:
         return self._mandatory
+
+    @property
+    def group(self) -> str:
+        return self._group

pyhon/parameter/enum.py

@@ -4,11 +4,13 @@ from pyhon.parameter.base import HonParameter
 
 
 class HonParameterEnum(HonParameter):
-    def __init__(self, key: str, attributes: Dict[str, Any]) -> None:
-        super().__init__(key, attributes)
+    def __init__(self, key: str, attributes: Dict[str, Any], group: str) -> None:
+        super().__init__(key, attributes, group)
         self._default = attributes.get("defaultValue")
         self._value = self._default or "0"
         self._values: List[str] = attributes.get("enumValues", [])
+        if self._default and str(self._default) not in self.values:
+            self._values.append(self._default)
 
     def __repr__(self) -> str:
         return f"{self.__class__} (<{self.key}> {self.values})"

pyhon/parameter/fixed.py

@@ -4,8 +4,8 @@ from pyhon.parameter.base import HonParameter
 
 
 class HonParameterFixed(HonParameter):
-    def __init__(self, key: str, attributes: Dict[str, Any]) -> None:
-        super().__init__(key, attributes)
+    def __init__(self, key: str, attributes: Dict[str, Any], group: str) -> None:
+        super().__init__(key, attributes, group)
         self._value = attributes.get("fixedValue", None)
 
     def __repr__(self) -> str:

pyhon/parameter/program.py

@@ -9,11 +9,14 @@ if TYPE_CHECKING:
 class HonParameterProgram(HonParameterEnum):
     _FILTER = ["iot_recipe", "iot_guided"]
 
-    def __init__(self, key: str, command: "HonCommand") -> None:
-        super().__init__(key, {})
+    def __init__(self, key: str, command: "HonCommand", group: str) -> None:
+        super().__init__(key, {}, group)
         self._command = command
-        self._value: str = command.program
-        self._programs: Dict[str, "HonCommand"] = command.programs
+        if "PROGRAM" in command.category:
+            self._value = command.category.split(".")[-1].lower()
+        else:
+            self._value = command.category
+        self._programs: Dict[str, "HonCommand"] = command.categories
         self._typology: str = "enum"
 
     @property
@@ -23,7 +26,7 @@ class HonParameterProgram(HonParameterEnum):
     @value.setter
     def value(self, value: str) -> None:
         if value in self.values:
-            self._command.program = value
+            self._command.category = value
         else:
             raise ValueError(f"Allowed values {self.values}")
 
@@ -31,3 +34,12 @@ class HonParameterProgram(HonParameterEnum):
     def values(self) -> List[str]:
         values = [v for v in self._programs if all(f not in v for f in self._FILTER)]
         return sorted(values)
+
+    @property
+    def ids(self):
+        values = {
+            int(p.parameters["prCode"].value): n
+            for i, (n, p) in enumerate(self._programs.items())
+            if "iot_" not in n and p.parameters.get("prCode")
+        }
+        return dict(sorted(values.items()))

pyhon/parameter/range.py

@@ -1,4 +1,4 @@
-from typing import Dict, Any
+from typing import Dict, Any, List
 
 from pyhon.parameter.base import HonParameter
 
@@ -11,8 +11,8 @@ def str_to_float(string: str | float) -> float:
 
 
 class HonParameterRange(HonParameter):
-    def __init__(self, key: str, attributes: Dict[str, Any]) -> None:
-        super().__init__(key, attributes)
+    def __init__(self, key: str, attributes: Dict[str, Any], group: str) -> None:
+        super().__init__(key, attributes, group)
         self._min: float = str_to_float(attributes["minimumValue"])
         self._max: float = str_to_float(attributes["maximumValue"])
         self._step: float = str_to_float(attributes["incrementValue"])
@@ -32,6 +32,8 @@ class HonParameterRange(HonParameter):
 
     @property
     def step(self) -> float:
+        if not self._step:
+            return 1
         return self._step
 
     @property
@@ -41,9 +43,13 @@ class HonParameterRange(HonParameter):
     @value.setter
     def value(self, value: float) -> None:
         value = str_to_float(value)
-        if self._min <= value <= self._max and not value % self._step:
+        if self._min <= value <= self._max and not (value - self._min) % self._step:
             self._value = value
         else:
             raise ValueError(
                 f"Allowed: min {self._min} max {self._max} step {self._step}"
             )
+
+    @property
+    def values(self) -> List[str]:
+        return [str(i) for i in range(int(self.min), int(self.max) + 1, int(self.step))]

setup.py

@@ -7,7 +7,7 @@ with open("README.md", "r") as f:
 
 setup(
     name="pyhOn",
-    version="0.8.0",
+    version="0.10.9",
     author="Andre Basche",
     description="Control hOn devices with python",
     long_description=long_description,