Fix messed up parameters in request

README.md

@@ -107,3 +107,6 @@ This library is used for the custom [HomeAssistant Integration "Haier hOn"](http
 ## Contribution
 Any kind of contribution is welcome!
 
+| Please add your appliances data to our [hon-test-data collection](https://github.com/Andre0512/hon-test-data). <br/>This helps us to develop new features and not to break compatibility in newer versions. |
+|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+

mypy.ini

@@ -0,0 +1,4 @@
+[mypy]
+check_untyped_defs = True
+disallow_any_generics = True
+disallow_untyped_defs = True

pyhon/__main__.py

@@ -6,16 +6,17 @@ import logging
 import sys
 from getpass import getpass
 from pathlib import Path
+from typing import Tuple, Dict, Any
 
 if __name__ == "__main__":
     sys.path.insert(0, str(Path(__file__).parent.parent))
 
-from pyhon import Hon, HonAPI, helper
+from pyhon import Hon, HonAPI, diagnose, printer
 
 _LOGGER = logging.getLogger(__name__)
 
 
-def get_arguments():
+def get_arguments() -> Dict[str, Any]:
     """Get parsed arguments."""
     parser = argparse.ArgumentParser(description="pyhOn: Command Line Utility")
     parser.add_argument("-u", "--user", help="user for haier hOn account")
@@ -24,6 +25,11 @@ def get_arguments():
     keys = subparser.add_parser("keys", help="print as key format")
     keys.add_argument("keys", help="print as key format", action="store_true")
     keys.add_argument("--all", help="print also full keys", action="store_true")
+    export = subparser.add_parser("export")
+    export.add_argument("export", help="export pyhon data", action="store_true")
+    export.add_argument("--zip", help="create zip archive", action="store_true")
+    export.add_argument("--anonymous", help="anonymize data", action="store_true")
+    export.add_argument("directory", nargs="?", default=Path().cwd())
     translate = subparser.add_parser(
         "translate", help="print available translation keys"
     )
@@ -31,10 +37,13 @@ def get_arguments():
         "translate", help="language (de, en, fr...)", metavar="LANGUAGE"
     )
     translate.add_argument("--json", help="print as json", action="store_true")
+    parser.add_argument(
+        "-i", "--import", help="import pyhon data", nargs="?", default=Path().cwd()
+    )
     return vars(parser.parse_args())
 
 
-async def translate(language, json_output=False):
+async def translate(language: str, json_output: bool = False) -> None:
     async with HonAPI(anonymous=True) as hon:
         keys = await hon.translation_keys(language)
     if json_output:
@@ -47,46 +56,57 @@ async def translate(language, json_output=False):
             .replace("\\r", "")
         )
         keys = json.loads(clean_keys)
-        print(helper.pretty_print(keys))
+        print(printer.pretty_print(keys))
 
 
-async def main():
+def get_login_data(args: Dict[str, str]) -> Tuple[str, str]:
-    args = get_arguments()
-    if language := args.get("translate"):
-        await translate(language, json_output=args.get("json"))
-        return
     if not (user := args["user"]):
         user = input("User for hOn account: ")
     if not (password := args["password"]):
         password = getpass("Password for hOn account: ")
-    async with Hon(user, password) as hon:
+    return user, password
+
+
+async def main() -> None:
+    args = get_arguments()
+    if language := args.get("translate"):
+        await translate(language, json_output=args.get("json", ""))
+        return
+    async with Hon(
+        *get_login_data(args), test_data_path=Path(args.get("import", ""))
+    ) as hon:
         for device in hon.appliances:
+            if args.get("export"):
+                anonymous = args.get("anonymous", False)
+                path = Path(args.get("directory", "."))
+                if not args.get("zip"):
+                    for file in await diagnose.appliance_data(device, path, anonymous):
+                        print(f"Created {file}")
+                else:
+                    archive = await diagnose.zip_archive(device, path, anonymous)
+                    print(f"Created {archive}")
+                continue
             print("=" * 10, device.appliance_type, "-", device.nick_name, "=" * 10)
             if args.get("keys"):
                 data = device.data.copy()
                 attr = "get" if args.get("all") else "pop"
                 print(
-                    helper.key_print(
+                    printer.key_print(
                         data["attributes"].__getattribute__(attr)("parameters")
                     )
                 )
-                print(helper.key_print(data.__getattribute__(attr)("appliance")))
+                print(printer.key_print(data.__getattribute__(attr)("appliance")))
-                print(helper.key_print(data))
+                print(printer.key_print(data))
                 print(
-                    helper.pretty_print(
+                    printer.pretty_print(
-                        helper.create_command(device.commands, concat=True)
+                        printer.create_command(device.commands, concat=True)
                     )
                 )
             else:
-                print(helper.pretty_print({"data": device.data}))
+                print(diagnose.yaml_export(device))
-                print(
-                    helper.pretty_print(
-                        {"settings": helper.create_command(device.commands)}
-                    )
-                )
 
 
-def start():
+def start() -> None:
     try:
         asyncio.run(main())
     except KeyboardInterrupt:

pyhon/appliance.py

@@ -1,35 +1,43 @@
 import importlib
 import logging
-from contextlib import suppress
+import re
-from typing import Optional, Dict, Any
+from datetime import datetime, timedelta
-from typing import TYPE_CHECKING
+from pathlib import Path
+from typing import Optional, Dict, Any, TYPE_CHECKING, List
 
-from pyhon import helper
+from pyhon import diagnose, exceptions
+from pyhon.attributes import HonAttribute
+from pyhon.command_loader import HonCommandLoader
 from pyhon.commands import HonCommand
 from pyhon.parameter.base import HonParameter
-from pyhon.parameter.fixed import HonParameterFixed
+from pyhon.parameter.range import HonParameterRange
+from pyhon.typedefs import Parameter
 
 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:
         if attributes := info.get("attributes"):
             info["attributes"] = {v["parName"]: v["parValue"] for v in attributes}
-        self._info: Dict = info
+        self._info: Dict[str, Any] = info
         self._api: Optional[HonAPI] = api
-        self._appliance_model: Dict = {}
+        self._appliance_model: Dict[str, Any] = {}
 
-        self._commands: Dict = {}
+        self._commands: Dict[str, HonCommand] = {}
-        self._statistics: Dict = {}
+        self._statistics: Dict[str, Any] = {}
-        self._attributes: Dict = {}
+        self._attributes: Dict[str, Any] = {}
         self._zone: int = zone
+        self._additional_data: Dict[str, Any] = {}
+        self._last_update: Optional[datetime] = None
+        self._default_setting = HonParameter("", {}, "")
 
         try:
             self._extra = importlib.import_module(
@@ -38,7 +46,7 @@ class HonAppliance:
         except ModuleNotFoundError:
             self._extra = None
 
-    def __getitem__(self, item):
+    def __getitem__(self, item: str) -> Any:
         if self._zone:
             item += f"Z{self._zone}"
         if "." in item:
@@ -52,19 +60,19 @@ class HonAppliance:
         if item in self.data:
             return self.data[item]
         if item in self.attributes["parameters"]:
-            return self.attributes["parameters"].get(item)
+            return self.attributes["parameters"][item].value
         return self.info[item]
 
-    def get(self, item, default=None):
+    def get(self, item: str, default: Any = None) -> Any:
         try:
             return self[item]
         except (KeyError, IndexError):
             return default
 
     def _check_name_zone(self, name: str, frontend: bool = True) -> str:
-        middle = " Z" if frontend else "_z"
+        zone = " Z" if frontend else "_z"
         if (attribute := self._info.get(name, "")) and self._zone:
-            return f"{attribute}{middle}{self._zone}"
+            return f"{attribute}{zone}{self._zone}"
         return attribute
 
     @property
@@ -81,143 +89,175 @@ class HonAppliance:
 
     @property
     def unique_id(self) -> str:
-        return self._check_name_zone("macAddress", frontend=False)
+        default_mac = "xx-xx-xx-xx-xx-xx"
+        import_name = f"{self.appliance_type.lower()}_{self.appliance_model_id}"
+        result = self._check_name_zone("macAddress", frontend=False)
+        result = result.replace(default_mac, import_name)
+        return result
 
     @property
     def model_name(self) -> str:
         return self._check_name_zone("modelName")
 
+    @property
+    def brand(self) -> str:
+        return self._check_name_zone("brand")
+
     @property
     def nick_name(self) -> str:
-        return self._check_name_zone("nickName")
+        result = self._check_name_zone("nickName")
+        if not result or re.findall("^[xX\s]+$", result):
+            return self.model_name
+        return result
 
     @property
-    def commands_options(self):
+    def code(self) -> str:
-        return self._appliance_model.get("options")
+        if code := self.info.get("code"):
+            return code
+        serial_number = self.info.get("serialNumber", "")
+        return serial_number[:8] if len(serial_number) < 18 else serial_number[:11]
 
     @property
-    def commands(self):
+    def model_id(self) -> int:
+        return self._info.get("applianceModelId", 0)
+
+    @property
+    def options(self) -> Dict[str, Any]:
+        return self._appliance_model.get("options", {})
+
+    @property
+    def commands(self) -> Dict[str, HonCommand]:
         return self._commands
 
     @property
-    def attributes(self):
+    def attributes(self) -> Dict[str, Any]:
         return self._attributes
 
     @property
-    def statistics(self):
+    def statistics(self) -> Dict[str, Any]:
         return self._statistics
 
     @property
-    def info(self):
+    def info(self) -> Dict[str, Any]:
         return self._info
 
+    @property
+    def additional_data(self) -> Dict[str, Any]:
+        return self._additional_data
+
     @property
     def zone(self) -> int:
         return self._zone
 
-    async def _recover_last_command_states(self, commands):
+    @property
-        command_history = await self._api.command_history(self)
+    def api(self) -> "HonAPI":
-        for name, command in commands.items():
+        """api connection object"""
-            last = next(
+        if self._api is None:
-                (
+            raise exceptions.NoAuthenticationException("Missing hOn login")
-                    index
+        return self._api
-                    for (index, d) in enumerate(command_history)
-                    if d.get("command", {}).get("commandName") == name
-                ),
-                None,
-            )
-            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()
-                command = self.commands[name]
-            for key, data in command.settings.items():
-                if (
-                    not isinstance(data, HonParameterFixed)
-                    and parameters.get(key) is not None
-                ):
-                    with suppress(ValueError):
-                        data.value = parameters.get(key)
 
-    async def load_commands(self):
+    async def load_commands(self) -> None:
-        raw = await self._api.load_commands(self)
+        command_loader = HonCommandLoader(self.api, self)
-        self._appliance_model = raw.pop("applianceModel")
+        await command_loader.load_commands()
-        for item in ["settings", "options", "dictionaryId"]:
+        self._commands = command_loader.commands
-            raw.pop(item)
+        self._additional_data = command_loader.additional_data
-        commands = {}
+        self._appliance_model = command_loader.appliance_data
-        for command, attr in raw.items():
+
-            if "parameters" in attr:
+    async def load_attributes(self) -> None:
-                commands[command] = HonCommand(command, attr, self._api, self)
+        self._attributes = await self.api.load_attributes(self)
-            elif "parameters" in attr[list(attr)[0]]:
+        for name, values in self._attributes.pop("shadow").get("parameters").items():
-                multi = {}
+            if name in self._attributes.get("parameters", {}):
-                for program, attr2 in attr.items():
+                self._attributes["parameters"][name].update(values)
-                    program = program.split(".")[-1].lower()
+            else:
-                    cmd = HonCommand(
+                self._attributes.setdefault("parameters", {})[name] = HonAttribute(
-                        command,
+                    values
-                        attr2,
+                )
-                        self._api,
+        if self._extra:
-                        self,
+            self._attributes = self._extra.attributes(self._attributes)
-                        programs=multi,
+
-                        program_name=program,
+    async def load_statistics(self) -> None:
-                    )
+        self._statistics = await self.api.load_statistics(self)
-                    multi[program] = cmd
+        self._statistics |= await self.api.load_maintenance(self)
-                    commands[command] = cmd
+
-        self._commands = commands
+    async def update(self, force: bool = False) -> None:
-        await self._recover_last_command_states(commands)
+        now = datetime.now()
+        if (
+            force
+            or 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 settings(self):
+    def command_parameters(self) -> Dict[str, Dict[str, str | float]]:
+        return {n: c.parameter_value for n, c in self._commands.items()}
+
+    @property
+    def settings(self) -> Dict[str, Parameter]:
         result = {}
         for name, command in self._commands.items():
             for key in command.setting_keys:
-                setting = command.settings.get(key, HonParameter(key, {}))
+                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):
+    def available_settings(self) -> List[str]:
-        result = {}
+        result = []
         for name, command in self._commands.items():
-            for key, parameter in (
+            for key in command.setting_keys:
-                command.parameters | command.ancillary_parameters
+                result.append(f"{name}.{key}")
-            ).items():
-                result.setdefault(name, {})[key] = parameter.value
         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):
+    def data(self) -> Dict[str, Any]:
         result = {
             "attributes": self.attributes,
             "appliance": self.info,
             "statistics": self.statistics,
-            **self.parameters,
+            "additional_data": self._additional_data,
+            **self.command_parameters,
+            **self.attributes,
         }
-        if self._extra:
-            return self._extra.data(result)
         return result
 
     @property
-    def diagnose(self):
+    def diagnose(self) -> str:
-        data = self.data.copy()
+        return diagnose.yaml_export(self, anonymous=True)
-        for sensible in ["PK", "SK", "serialNumber", "code", "coords"]:
+
-            data["appliance"].pop(sensible, None)
+    async def data_archive(self, path: Path) -> str:
-        result = helper.pretty_print({"data": self.data}, whitespace="\u200B \u200B ")
+        return await diagnose.zip_archive(self, path, anonymous=True)
-        result += helper.pretty_print(
+
-            {"commands": helper.create_command(self.commands)},
+    def sync_to_params(self, command_name: str) -> None:
-            whitespace="\u200B \u200B ",
+        if not (command := self.commands.get(command_name)):
-        )
+            return
-        return result.replace(self.mac_address, "xx-xx-xx-xx-xx-xx")
+        for key, value in self.attributes.get("parameters", {}).items():
+            if isinstance(value, str) and (new := command.parameters.get(key)):
+                self.attributes["parameters"][key].update(
+                    str(new.intern_value), shield=True
+                )
+
+    def sync_command(self, main: str, target: Optional[List[str]] = None) -> None:
+        base: Optional[HonCommand] = self.commands.get(main)
+        if not base:
+            return
+        for command, data in self.commands.items():
+            if command == main or target and command not in target:
+                continue
+            for name, parameter in data.parameters.items():
+                if base_value := base.parameters.get(name):
+                    if isinstance(base_value, HonParameterRange) and isinstance(
+                        parameter, HonParameterRange
+                    ):
+                        parameter.max = base_value.max
+                        parameter.min = base_value.min
+                        parameter.step = base_value.step
+                    elif isinstance(parameter, HonParameterRange):
+                        parameter.max = int(base_value.value)
+                        parameter.min = int(base_value.value)
+                        parameter.step = 1
+                    parameter.value = base_value.value

pyhon/appliances/base.py

@@ -0,0 +1,25 @@
+from typing import Dict, Any, TYPE_CHECKING
+
+from pyhon.parameter.program import HonParameterProgram
+
+if TYPE_CHECKING:
+    from pyhon.appliance import HonAppliance
+
+
+class ApplianceBase:
+    def __init__(self, appliance: "HonAppliance"):
+        self.parent = appliance
+
+    def attributes(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        program_name = "No Program"
+        if program := int(str(data.get("parameters", {}).get("prCode", "0"))):
+            if start_cmd := self.parent.settings.get("startProgram.program"):
+                if isinstance(start_cmd, HonParameterProgram) and (
+                    ids := start_cmd.ids
+                ):
+                    program_name = ids.get(program, program_name)
+        data["programName"] = program_name
+        return data
+
+    def settings(self, settings: Dict[str, Any]) -> Dict[str, Any]:
+        return settings

pyhon/appliances/dw.py

@@ -1,12 +1,12 @@
-class Appliance:
+from typing import Any, Dict
-    def __init__(self, appliance):
-        self.parent = appliance
 
-    def data(self, data):
+from pyhon.appliances.base import ApplianceBase
-        if data["attributes"]["lastConnEvent"]["category"] == "DISCONNECTED":
+
-            data["attributes"]["parameters"]["machMode"] = "0"
+
-        data["active"] = bool(data.get("attributes", {}).get("activity"))
+class Appliance(ApplianceBase):
+    def attributes(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        data = super().attributes(data)
+        if data.get("lastConnEvent", {}).get("category", "") == "DISCONNECTED":
+            data["parameters"]["machMode"].value = "0"
+        data["active"] = bool(data.get("activity"))
         return data
-
-    def settings(self, settings):
-        return settings

pyhon/appliances/ov.py

@@ -1,17 +1,24 @@
-class Appliance:
+from typing import Any, Dict
-    def __init__(self, appliance):
-        self.parent = appliance
 
-    def data(self, data):
+from pyhon.appliances.base import ApplianceBase
-        if data["attributes"]["lastConnEvent"]["category"] == "DISCONNECTED":
+from pyhon.parameter.program import HonParameterProgram
-            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"
+
+class Appliance(ApplianceBase):
+    def attributes(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        data = super().attributes(data)
+        if data.get("lastConnEvent", {}).get("category", "") == "DISCONNECTED":
+            data["parameters"]["temp"].value = "0"
+            data["parameters"]["onOffStatus"].value = "0"
+            data["parameters"]["remoteCtrValid"].value = "0"
+            data["parameters"]["remainingTimeMM"].value = "0"
+
+        data["active"] = data["parameters"]["onOffStatus"] == "1"
+
+        if program := int(data["parameters"]["prCode"]):
+            if (setting := self.parent.settings["startProgram.program"]) and isinstance(
+                setting, HonParameterProgram
+            ):
+                data["programName"] = setting.ids.get(program, "")
 
         return data
-
-    def settings(self, settings):
-        return settings

pyhon/appliances/ref.py

@@ -0,0 +1,25 @@
+from typing import Dict, Any
+
+from pyhon.appliances.base import ApplianceBase
+
+
+class Appliance(ApplianceBase):
+    def attributes(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        data = super().attributes(data)
+        if data["parameters"]["holidayMode"] == "1":
+            data["modeZ1"] = "holiday"
+        elif data["parameters"]["intelligenceMode"] == "1":
+            data["modeZ1"] = "auto_set"
+        elif data["parameters"]["quickModeZ1"] == "1":
+            data["modeZ1"] = "super_cool"
+        else:
+            data["modeZ1"] = "no_mode"
+
+        if data["parameters"]["quickModeZ2"] == "1":
+            data["modeZ2"] = "super_freeze"
+        elif data["parameters"]["intelligenceMode"] == "1":
+            data["modeZ2"] = "auto_set"
+        else:
+            data["modeZ2"] = "no_mode"
+
+        return data

pyhon/appliances/td.py

@@ -1,21 +1,19 @@
+from typing import Any, Dict
+
+from pyhon.appliances.base import ApplianceBase
 from pyhon.parameter.fixed import HonParameterFixed
 
 
-class Appliance:
+class Appliance(ApplianceBase):
-    def __init__(self, appliance):
+    def attributes(self, data: Dict[str, Any]) -> Dict[str, Any]:
-        self.parent = appliance
+        data = super().attributes(data)
-
+        if data.get("lastConnEvent", {}).get("category", "") == "DISCONNECTED":
-    def data(self, data):
+            data["parameters"]["machMode"].value = "0"
-        if data["attributes"]["lastConnEvent"]["category"] == "DISCONNECTED":
+        data["active"] = bool(data.get("activity"))
-            data["attributes"]["parameters"]["machMode"] = "0"
+        data["pause"] = data["parameters"]["machMode"] == "3"
-        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):
+    def settings(self, settings: Dict[str, Any]) -> Dict[str, Any]:
         dry_level = settings.get("startProgram.dryLevel")
         if isinstance(dry_level, HonParameterFixed) and dry_level.value == "11":
             settings.pop("startProgram.dryLevel", None)

pyhon/appliances/wc.py

@@ -0,0 +1,5 @@
+from pyhon.appliances.base import ApplianceBase
+
+
+class Appliance(ApplianceBase):
+    pass

pyhon/appliances/wd.py

@@ -1,13 +1,16 @@
-class Appliance:
+from typing import Dict, Any
-    def __init__(self, appliance):
-        self.parent = appliance
 
-    def data(self, data):
+from pyhon.appliances.base import ApplianceBase
-        if data["attributes"]["lastConnEvent"]["category"] == "DISCONNECTED":
+
-            data["attributes"]["parameters"]["machMode"] = "0"
+
-        data["active"] = bool(data.get("attributes", {}).get("activity"))
+class Appliance(ApplianceBase):
-        data["pause"] = data["attributes"]["parameters"]["machMode"] == "3"
+    def attributes(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        data = super().attributes(data)
+        if data.get("lastConnEvent", {}).get("category", "") == "DISCONNECTED":
+            data["parameters"]["machMode"].value = "0"
+        data["active"] = bool(data.get("activity"))
+        data["pause"] = data["parameters"]["machMode"] == "3"
         return data
 
-    def settings(self, settings):
+    def settings(self, settings: Dict[str, Any]) -> Dict[str, Any]:
         return settings

pyhon/appliances/wm.py

@@ -1,13 +1,16 @@
-class Appliance:
+from typing import Any, Dict
-    def __init__(self, appliance):
-        self.parent = appliance
 
-    def data(self, data):
+from pyhon.appliances.base import ApplianceBase
-        if data["attributes"]["lastConnEvent"]["category"] == "DISCONNECTED":
+
-            data["attributes"]["parameters"]["machMode"] = "0"
+
-        data["active"] = bool(data.get("attributes", {}).get("activity"))
+class Appliance(ApplianceBase):
-        data["pause"] = data["attributes"]["parameters"]["machMode"] == "3"
+    def attributes(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        data = super().attributes(data)
+        if data.get("lastConnEvent", {}).get("category", "") == "DISCONNECTED":
+            data["parameters"]["machMode"].value = "0"
+        data["active"] = bool(data.get("activity"))
+        data["pause"] = data["parameters"]["machMode"] == "3"
         return data
 
-    def settings(self, settings):
+    def settings(self, settings: Dict[str, Any]) -> Dict[str, Any]:
         return settings

pyhon/attributes.py

@@ -0,0 +1,58 @@
+from datetime import datetime, timedelta
+from typing import Optional, Final, Dict
+
+from pyhon.helper import str_to_float
+
+
+class HonAttribute:
+    _LOCK_TIMEOUT: Final = 10
+
+    def __init__(self, data: Dict[str, str] | str):
+        self._value: str = ""
+        self._last_update: Optional[datetime] = None
+        self._lock_timestamp: Optional[datetime] = None
+        self.update(data)
+
+    @property
+    def value(self) -> float | str:
+        """Attribute value"""
+        try:
+            return str_to_float(self._value)
+        except ValueError:
+            return self._value
+
+    @value.setter
+    def value(self, value: str) -> None:
+        self._value = value
+
+    @property
+    def last_update(self) -> Optional[datetime]:
+        """Timestamp of last api update"""
+        return self._last_update
+
+    @property
+    def lock(self) -> bool:
+        """Shows if value changes are forbidden"""
+        if not self._lock_timestamp:
+            return False
+        lock_until = self._lock_timestamp + timedelta(seconds=self._LOCK_TIMEOUT)
+        return lock_until >= datetime.utcnow()
+
+    def update(self, data: Dict[str, str] | str, shield: bool = False) -> bool:
+        if self.lock and not shield:
+            return False
+        if shield:
+            self._lock_timestamp = datetime.utcnow()
+        if isinstance(data, str):
+            self.value = data
+            return True
+        self.value = data.get("parNewVal", "")
+        if last_update := data.get("lastUpdate"):
+            try:
+                self._last_update = datetime.fromisoformat(last_update)
+            except ValueError:
+                self._last_update = None
+        return True
+
+    def __str__(self) -> str:
+        return self._value

pyhon/command_loader.py

@@ -0,0 +1,204 @@
+import asyncio
+from contextlib import suppress
+from copy import copy
+from typing import Dict, Any, Optional, TYPE_CHECKING, List, Collection
+
+from pyhon.commands import HonCommand
+from pyhon.parameter.fixed import HonParameterFixed
+from pyhon.parameter.program import HonParameterProgram
+
+if TYPE_CHECKING:
+    from pyhon import HonAPI, exceptions
+    from pyhon.appliance import HonAppliance
+
+
+class HonCommandLoader:
+    """Loads and parses hOn command data"""
+
+    def __init__(self, api: "HonAPI", appliance: "HonAppliance") -> None:
+        self._api_commands: Dict[str, Any] = {}
+        self._favourites: List[Dict[str, Any]] = []
+        self._command_history: List[Dict[str, Any]] = []
+        self._commands: Dict[str, HonCommand] = {}
+        self._api: "HonAPI" = api
+        self._appliance: "HonAppliance" = appliance
+        self._appliance_data: Dict[str, Any] = {}
+        self._additional_data: Dict[str, Any] = {}
+
+    @property
+    def api(self) -> "HonAPI":
+        """api connection object"""
+        if self._api is None:
+            raise exceptions.NoAuthenticationException("Missing hOn login")
+        return self._api
+
+    @property
+    def appliance(self) -> "HonAppliance":
+        """appliance object"""
+        return self._appliance
+
+    @property
+    def commands(self) -> Dict[str, HonCommand]:
+        """Get list of hon commands"""
+        return self._commands
+
+    @property
+    def appliance_data(self) -> Dict[str, Any]:
+        """Get command appliance data"""
+        return self._appliance_data
+
+    @property
+    def additional_data(self) -> Dict[str, Any]:
+        """Get command additional data"""
+        return self._additional_data
+
+    async def load_commands(self) -> None:
+        """Trigger loading of command data"""
+        await self._load_data()
+        self._appliance_data = self._api_commands.pop("applianceModel")
+        self._get_commands()
+        self._add_favourites()
+        self._recover_last_command_states()
+
+    async def _load_commands(self) -> None:
+        self._api_commands = await self._api.load_commands(self._appliance)
+
+    async def _load_favourites(self) -> None:
+        self._favourites = await self._api.load_favourites(self._appliance)
+
+    async def _load_command_history(self) -> None:
+        self._command_history = await self._api.load_command_history(self._appliance)
+
+    async def _load_data(self) -> None:
+        """Callback parallel all relevant data"""
+        await asyncio.gather(
+            *[
+                self._load_commands(),
+                self._load_favourites(),
+                self._load_command_history(),
+            ]
+        )
+
+    @staticmethod
+    def _is_command(data: Dict[str, Any]) -> bool:
+        """Check if dict can be parsed as command"""
+        return (
+            data.get("description") is not None and data.get("protocolType") is not None
+        )
+
+    @staticmethod
+    def _clean_name(category: str) -> str:
+        """Clean up category name"""
+        if "PROGRAM" in category:
+            return category.split(".")[-1].lower()
+        return category
+
+    def _get_commands(self) -> None:
+        """Generates HonCommand dict from api data"""
+        commands = []
+        for name, data in self._api_commands.items():
+            if command := self._parse_command(data, name):
+                commands.append(command)
+        self._commands = {c.name: c for c in commands}
+
+    def _parse_command(
+        self,
+        data: Dict[str, Any] | str,
+        command_name: str,
+        categories: Optional[Dict[str, "HonCommand"]] = None,
+        category_name: str = "",
+    ) -> Optional[HonCommand]:
+        """Try to crate HonCommand object"""
+        if not isinstance(data, dict):
+            self._additional_data[command_name] = data
+            return None
+        if self._is_command(data):
+            return HonCommand(
+                command_name,
+                data,
+                self._appliance,
+                category_name=category_name,
+                categories=categories,
+            )
+        if category := self._parse_categories(data, command_name):
+            return category
+        return None
+
+    def _parse_categories(
+        self, data: Dict[str, Any], command_name: str
+    ) -> Optional[HonCommand]:
+        """Parse categories and create reference to other"""
+        categories: Dict[str, HonCommand] = {}
+        for category, value in data.items():
+            if command := self._parse_command(
+                value, command_name, category_name=category, categories=categories
+            ):
+                categories[self._clean_name(category)] = command
+        if categories:
+            # setParameters should be at first place
+            if "setParameters" in categories:
+                return categories["setParameters"]
+            return list(categories.values())[0]
+        return None
+
+    def _get_last_command_index(self, name: str) -> Optional[int]:
+        """Get index of last command execution"""
+        return next(
+            (
+                index
+                for (index, d) in enumerate(self._command_history)
+                if d.get("command", {}).get("commandName") == name
+            ),
+            None,
+        )
+
+    def _set_last_category(
+        self, command: HonCommand, name: str, parameters: Dict[str, Any]
+    ) -> HonCommand:
+        """Set category to last state"""
+        if command.categories:
+            if program := parameters.pop("program", None):
+                command.category = self._clean_name(program)
+            elif category := parameters.pop("category", None):
+                command.category = category
+            else:
+                return command
+            return self.commands[name]
+        return command
+
+    def _recover_last_command_states(self) -> None:
+        """Set commands to last state"""
+        for name, command in self.commands.items():
+            if (last_index := self._get_last_command_index(name)) is None:
+                continue
+            last_command = self._command_history[last_index]
+            parameters = last_command.get("command", {}).get("parameters", {})
+            command = self._set_last_category(command, name, parameters)
+            for key, data in command.settings.items():
+                if parameters.get(key) is None:
+                    continue
+                with suppress(ValueError):
+                    data.value = parameters.get(key)
+
+    def _add_favourites(self) -> None:
+        """Patch program categories with favourites"""
+        for favourite in self._favourites:
+            name = favourite.get("favouriteName", {})
+            command = favourite.get("command", {})
+            command_name = command.get("commandName", "")
+            program_name = self._clean_name(command.get("programName", ""))
+            base: HonCommand = copy(
+                self.commands[command_name].categories[program_name]
+            )
+            for data in command.values():
+                if isinstance(data, str):
+                    continue
+                for key, value in data.items():
+                    if parameter := base.parameters.get(key):
+                        with suppress(ValueError):
+                            parameter.value = value
+            extra_param = HonParameterFixed("favourite", {"fixedValue": "1"}, "custom")
+            base.parameters.update(favourite=extra_param)
+            if isinstance(program := base.parameters["program"], HonParameterProgram):
+                program.set_value(name)
+            self.commands[command_name].categories[name] = base

pyhon/commands.py

@@ -1,114 +1,171 @@
-from typing import Optional, Dict, Any, List, TYPE_CHECKING
+import logging
+from typing import Optional, Dict, Any, List, TYPE_CHECKING, Union
 
+from pyhon import exceptions
+from pyhon.exceptions import ApiError, NoAuthenticationException
 from pyhon.parameter.base import HonParameter
 from pyhon.parameter.enum import HonParameterEnum
 from pyhon.parameter.fixed import HonParameterFixed
 from pyhon.parameter.program import HonParameterProgram
 from pyhon.parameter.range import HonParameterRange
+from pyhon.rules import HonRuleSet
+from pyhon.typedefs import Parameter
 
 if TYPE_CHECKING:
     from pyhon import HonAPI
     from pyhon.appliance import HonAppliance
 
+_LOGGER = logging.getLogger(__name__)
+
 
 class HonCommand:
     def __init__(
         self,
         name: str,
         attributes: Dict[str, Any],
-        api: "HonAPI",
         appliance: "HonAppliance",
-        programs: Optional[Dict[str, "HonCommand"]] = None,
+        categories: Optional[Dict[str, "HonCommand"]] = None,
-        program_name: str = "",
+        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
+        self._categories: Optional[Dict[str, "HonCommand"]] = categories
-        self._program_name: str = program_name
+        self._category_name: str = category_name
-        self._description: str = attributes.get("description", "")
+        self._description: str = attributes.pop("description", "")
-        self._parameters: Dict[str, HonParameter] = self._create_parameters(
+        self._protocol_type: str = attributes.pop("protocolType", "")
-            attributes.get("parameters", {})
+        self._parameters: Dict[str, HonParameter] = {}
-        )
+        self._data: Dict[str, Any] = {}
-        self._ancillary_parameters: Dict[str, HonParameter] = self._create_parameters(
+        self._available_settings: Dict[str, HonParameter] = {}
-            attributes.get("ancillaryParameters", {})
+        self._rules: List[HonRuleSet] = []
-        )
+        self._load_parameters(attributes)
 
     def __repr__(self) -> str:
         return f"{self._name} command"
 
-    def _create_parameters(self, parameters: Dict) -> Dict[str, HonParameter]:
+    @property
-        result: Dict[str, HonParameter] = {}
+    def name(self) -> str:
-        for parameter, attributes in parameters.items():
+        return self._name
-            if parameter == "zoneMap" and self._appliance.zone:
+
-                attributes["default"] = self._appliance.zone
+    @property
-            match attributes.get("typology"):
+    def api(self) -> "HonAPI":
-                case "range":
+        if self._api is None:
-                    result[parameter] = HonParameterRange(parameter, attributes)
+            raise exceptions.NoAuthenticationException("Missing hOn login")
-                case "enum":
+        return self._api
-                    result[parameter] = HonParameterEnum(parameter, attributes)
+
-                case "fixed":
+    @property
-                    result[parameter] = HonParameterFixed(parameter, attributes)
+    def appliance(self) -> "HonAppliance":
-        if self._programs:
+        return self._appliance
-            result["program"] = HonParameterProgram("program", self)
+
-        return result
+    @property
+    def data(self) -> Dict[str, Any]:
+        return self._data
 
     @property
     def parameters(self) -> Dict[str, HonParameter]:
         return self._parameters
 
     @property
-    def ancillary_parameters(self) -> Dict[str, HonParameter]:
+    def settings(self) -> Dict[str, HonParameter]:
-        return self._ancillary_parameters
+        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.intern_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: Dict[str, Dict[str, Any]]) -> None:
+        for key, items in attributes.items():
+            for name, data in items.items():
+                self._create_parameters(data, name, key)
+        for rule in self._rules:
+            rule.patch()
+
+    def _create_parameters(
+        self, data: Dict[str, Any], name: str, parameter: str
+    ) -> None:
+        if name == "zoneMap" and self._appliance.zone:
+            data["default"] = self._appliance.zone
+        if data.get("category") == "rule":
+            if "fixedValue" not in data:
+                _LOGGER.error("Rule not supported: %s", data)
+            else:
+                self._rules.append(HonRuleSet(self, data["fixedValue"]))
+        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()}
+        params = self.parameter_groups.get("parameters", {})
-        ancillary_params = {k: v.value for k, v in self._ancillary_parameters.items()}
+        ancillary_params = self.parameter_groups.get("ancillaryParameters", {})
-        return await self._api.send_command(
+        ancillary_params.pop("programRules", None)
-            self._appliance, self._name, params, ancillary_params
+        self.appliance.sync_to_params(self.name)
-        )
+        try:
+            result = await self.api.send_command(
+                self._appliance, self._name, params, ancillary_params
+            )
+            if not result:
+                _LOGGER.error(result)
+                raise ApiError("Can't send command")
+        except NoAuthenticationException:
+            _LOGGER.error("No Authentication")
+            return False
+        return result
 
     @property
-    def programs(self) -> Dict[str, "HonCommand"]:
+    def categories(self) -> Dict[str, "HonCommand"]:
-        if self._programs is None:
+        if self._categories is None:
-            return {}
+            return {"_": self}
-        return self._programs
+        return self._categories
 
     @property
-    def program(self) -> str:
+    def category(self) -> str:
-        return self._program_name
+        return self._category_name
 
-    @program.setter
+    @category.setter
-    def program(self, program: str) -> None:
+    def category(self, category: str) -> None:
-        self._appliance.commands[self._name] = self.programs[program]
+        if category in self.categories:
-
+            self._appliance.commands[self._name] = self.categories[category]
-    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 key not in keys:
-                keys.append(key)
-        return keys
 
     @property
     def setting_keys(self) -> List[str]:
-        if not self._programs:
+        return list(
-            return self._get_settings_keys()
+            {param for cmd in self.categories.values() for param in cmd.parameters}
-        result = [
+        )
-            key
+
-            for cmd in self._programs.values()
+    @staticmethod
-            for key in self._get_settings_keys(cmd)
+    def _more_options(first: Parameter, second: Parameter) -> Parameter:
-        ]
+        if isinstance(first, HonParameterFixed) and not isinstance(
-        return list(set(result + ["program"]))
+            second, HonParameterFixed
+        ):
+            return second
+        if len(second.values) > len(first.values):
+            return second
+        return first
 
     @property
-    def settings(self) -> Dict[str, HonParameter]:
+    def available_settings(self) -> Dict[str, Parameter]:
-        return {
+        result: Dict[str, Parameter] = {}
-            s: param
+        for command in self.categories.values():
-            for s in self.setting_keys
+            for name, parameter in command.parameters.items():
-            if (param := self._parameters.get(s)) is not None
+                if name in result:
-            or (param := self._ancillary_parameters.get(s)) is not None
+                    result[name] = self._more_options(result[name], parameter)
-        }
+                else:
+                    result[name] = parameter
+        return result

pyhon/connection/api.py

@@ -1,7 +1,10 @@
 import json
 import logging
 from datetime import datetime
-from typing import Dict, Optional
+from pathlib import Path
+from pprint import pformat
+from types import TracebackType
+from typing import Dict, Optional, Any, List, no_type_check, Type
 
 from aiohttp import ClientSession
 from typing_extensions import Self
@@ -34,7 +37,12 @@ class HonAPI:
     async def __aenter__(self) -> Self:
         return await self.create()
 
-    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> None:
         await self.close()
 
     @property
@@ -44,13 +52,13 @@ class HonAPI:
         return self._hon.auth
 
     @property
-    def _hon(self):
+    def _hon(self) -> HonConnectionHandler:
         if self._hon_handler is None:
             raise exceptions.NoAuthenticationException
         return self._hon_handler
 
     @property
-    def _hon_anonymous(self):
+    def _hon_anonymous(self) -> HonAnonymousConnectionHandler:
         if self._hon_anonymous_handler is None:
             raise exceptions.NoAuthenticationException
         return self._hon_anonymous_handler
@@ -65,52 +73,80 @@ class HonAPI:
             ).create()
         return self
 
-    async def load_appliances(self) -> Dict:
+    async def load_appliances(self) -> List[Dict[str, Any]]:
         async with self._hon.get(f"{const.API_URL}/commands/v1/appliance") as resp:
-            return await resp.json()
+            if result := await resp.json():
+                return result.get("payload", {}).get("appliances", {})
+        return []
 
-    async def load_commands(self, appliance: HonAppliance) -> Dict:
+    async def load_commands(self, appliance: HonAppliance) -> Dict[str, Any]:
-        params: Dict = {
+        params: Dict[str, str | int] = {
             "applianceType": appliance.appliance_type,
-            "code": appliance.info["code"],
             "applianceModelId": appliance.appliance_model_id,
             "macAddress": appliance.mac_address,
             "os": const.OS,
             "appVersion": const.APP_VERSION,
-            "series": appliance.info["series"],
+            "code": appliance.code,
         }
         if firmware_id := appliance.info.get("eepromId"):
             params["firmwareId"] = firmware_id
         if firmware_version := appliance.info.get("fwVersion"):
             params["fwVersion"] = firmware_version
+        if series := appliance.info.get("series"):
+            params["series"] = series
         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", {})
+            result: Dict[str, Any] = (await response.json()).get("payload", {})
             if not result or result.pop("resultCode") != "0":
+                _LOGGER.error(await response.json())
                 return {}
             return result
 
-    async def command_history(self, appliance: HonAppliance) -> Dict:
+    async def load_command_history(
+        self, appliance: HonAppliance
+    ) -> List[Dict[str, Any]]:
         url: str = (
             f"{const.API_URL}/commands/v1/appliance/{appliance.mac_address}/history"
         )
         async with self._hon.get(url) as response:
-            result: Dict = await response.json()
+            result: Dict[str, Any] = await response.json()
             if not result or not result.get("payload"):
-                return {}
+                return []
             return result["payload"]["history"]
 
-    async def last_activity(self, appliance: HonAppliance) -> Dict:
+    async def load_favourites(self, appliance: HonAppliance) -> List[Dict[str, Any]]:
+        url: str = (
+            f"{const.API_URL}/commands/v1/appliance/{appliance.mac_address}/favourite"
+        )
+        async with self._hon.get(url) as response:
+            result: Dict[str, Any] = await response.json()
+            if not result or not result.get("payload"):
+                return []
+            return result["payload"]["favourites"]
+
+    async def load_last_activity(self, appliance: HonAppliance) -> Dict[str, Any]:
         url: str = f"{const.API_URL}/commands/v1/retrieve-last-activity"
-        params: Dict = {"macAddress": appliance.mac_address}
+        params: Dict[str, str] = {"macAddress": appliance.mac_address}
         async with self._hon.get(url, params=params) as response:
-            result: Dict = await response.json()
+            result: Dict[str, Any] = await response.json()
             if result and (activity := result.get("attributes")):
                 return activity
         return {}
 
-    async def load_attributes(self, appliance: HonAppliance) -> Dict:
+    async def load_appliance_data(self, appliance: HonAppliance) -> Dict[str, Any]:
-        params: Dict = {
+        url: str = f"{const.API_URL}/commands/v1/appliance-model"
+        params: Dict[str, str] = {
+            "code": appliance.code,
+            "macAddress": appliance.mac_address,
+        }
+        async with self._hon.get(url, params=params) as response:
+            result: Dict[str, Any] = await response.json()
+            if result:
+                return result.get("payload", {}).get("applianceModel", {})
+        return {}
+
+    async def load_attributes(self, appliance: HonAppliance) -> Dict[str, Any]:
+        params: Dict[str, str] = {
             "macAddress": appliance.mac_address,
             "applianceType": appliance.appliance_type,
             "category": "CYCLE",
@@ -119,8 +155,8 @@ class HonAPI:
         async with self._hon.get(url, params=params) as response:
             return (await response.json()).get("payload", {})
 
-    async def load_statistics(self, appliance: HonAppliance) -> Dict:
+    async def load_statistics(self, appliance: HonAppliance) -> Dict[str, Any]:
-        params: Dict = {
+        params: Dict[str, str] = {
             "macAddress": appliance.mac_address,
             "applianceType": appliance.appliance_type,
         }
@@ -128,20 +164,26 @@ 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) -> Dict[str, Any]:
+        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,
         command: str,
-        parameters: Dict,
+        parameters: Dict[str, Any],
-        ancillary_parameters: Dict,
+        ancillary_parameters: Dict[str, Any],
     ) -> bool:
         now: str = datetime.utcnow().isoformat()
-        data: Dict = {
+        data: Dict[str, Any] = {
             "macAddress": appliance.mac_address,
             "timestamp": f"{now[:-3]}Z",
             "commandName": command,
             "transactionId": f"{appliance.mac_address}_{now[:-3]}Z",
-            "applianceOptions": appliance.commands_options,
+            "applianceOptions": appliance.options,
             "device": self._hon.device.get(mobile=True),
             "attributes": {
                 "channel": "mobileApp",
@@ -154,23 +196,26 @@ class HonAPI:
         }
         url: str = f"{const.API_URL}/commands/v1/send"
         async with self._hon.post(url, json=data) as response:
-            json_data: Dict = await response.json()
+            json_data: Dict[str, Any] = await response.json()
             if json_data.get("payload", {}).get("resultCode") == "0":
                 return True
             _LOGGER.error(await response.text())
+            _LOGGER.error("%s - Payload:\n%s", url, pformat(data))
         return False
 
-    async def appliance_configuration(self) -> Dict:
+    async def appliance_configuration(self) -> Dict[str, Any]:
-        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()
+            result: Dict[str, Any] = await response.json()
             if result and (data := result.get("payload")):
                 return data
         return {}
 
-    async def app_config(self, language: str = "en", beta: bool = True) -> Dict:
+    async def app_config(
+        self, language: str = "en", beta: bool = True
+    ) -> Dict[str, Any]:
         url: str = f"{const.API_URL}/app-config"
-        payload_data: Dict = {
+        payload_data: Dict[str, str | int] = {
             "languageCode": language,
             "beta": beta,
             "appVersion": const.APP_VERSION,
@@ -182,7 +227,7 @@ class HonAPI:
                 return data
         return {}
 
-    async def translation_keys(self, language: str = "en") -> Dict:
+    async def translation_keys(self, language: str = "en") -> Dict[str, Any]:
         config = await self.app_config(language=language)
         if url := config.get("language", {}).get("jsonPath"):
             async with self._hon_anonymous.get(url) as response:
@@ -195,3 +240,61 @@ class HonAPI:
             await self._hon_handler.close()
         if self._hon_anonymous_handler is not None:
             await self._hon_anonymous_handler.close()
+
+
+class TestAPI(HonAPI):
+    def __init__(self, path: Path):
+        super().__init__()
+        self._anonymous = True
+        self._path: Path = path
+
+    def _load_json(self, appliance: HonAppliance, file: str) -> Dict[str, Any]:
+        directory = f"{appliance.appliance_type}_{appliance.appliance_model_id}".lower()
+        path = f"{self._path}/{directory}/{file}.json"
+        with open(path, "r", encoding="utf-8") as json_file:
+            return json.loads(json_file.read())
+
+    async def load_appliances(self) -> List[Dict[str, Any]]:
+        result = []
+        for appliance in self._path.glob("*/"):
+            with open(
+                appliance / "appliance_data.json", "r", encoding="utf-8"
+            ) as json_file:
+                result.append(json.loads(json_file.read()))
+        return result
+
+    async def load_commands(self, appliance: HonAppliance) -> Dict[str, Any]:
+        return self._load_json(appliance, "commands")
+
+    @no_type_check
+    async def load_command_history(
+        self, appliance: HonAppliance
+    ) -> List[Dict[str, Any]]:
+        return self._load_json(appliance, "command_history")
+
+    async def load_favourites(self, appliance: HonAppliance) -> List[Dict[str, Any]]:
+        return []
+
+    async def load_last_activity(self, appliance: HonAppliance) -> Dict[str, Any]:
+        return {}
+
+    async def load_appliance_data(self, appliance: HonAppliance) -> Dict[str, Any]:
+        return self._load_json(appliance, "appliance_data")
+
+    async def load_attributes(self, appliance: HonAppliance) -> Dict[str, Any]:
+        return self._load_json(appliance, "attributes")
+
+    async def load_statistics(self, appliance: HonAppliance) -> Dict[str, Any]:
+        return self._load_json(appliance, "statistics")
+
+    async def load_maintenance(self, appliance: HonAppliance) -> Dict[str, Any]:
+        return self._load_json(appliance, "maintenance")
+
+    async def send_command(
+        self,
+        appliance: HonAppliance,
+        command: str,
+        parameters: Dict[str, Any],
+        ancillary_parameters: Dict[str, Any],
+    ) -> bool:
+        return True

pyhon/connection/auth.py

@@ -6,14 +6,16 @@ import urllib
 from contextlib import suppress
 from dataclasses import dataclass
 from datetime import datetime, timedelta
-from typing import Dict, Optional
+from typing import Dict, Optional, Any
 from urllib import parse
 from urllib.parse import quote
 
+import aiohttp
 from aiohttp import ClientResponse
 from yarl import URL
 
 from pyhon import const, exceptions
+from pyhon.connection.device import HonDevice
 from pyhon.connection.handler.auth import HonAuthConnectionHandler
 
 _LOGGER = logging.getLogger(__name__)
@@ -25,14 +27,20 @@ class HonLoginData:
     email: str = ""
     password: str = ""
     fw_uid: str = ""
-    loaded: Optional[Dict] = None
+    loaded: Optional[Dict[str, Any]] = None
 
 
 class HonAuth:
     _TOKEN_EXPIRES_AFTER_HOURS = 8
     _TOKEN_EXPIRE_WARNING_HOURS = 7
 
-    def __init__(self, session, email, password, device) -> None:
+    def __init__(
+        self,
+        session: aiohttp.ClientSession,
+        email: str,
+        password: str,
+        device: HonDevice,
+    ) -> None:
         self._session = session
         self._request = HonAuthConnectionHandler(session)
         self._login_data = HonLoginData()
@@ -120,7 +128,7 @@ class HonAuth:
                 await self._error_logger(response)
         return new_location
 
-    async def _handle_redirects(self, login_url) -> str:
+    async def _handle_redirects(self, login_url: str) -> str:
         redirect1 = await self._manual_redirect(login_url)
         redirect2 = await self._manual_redirect(redirect1)
         return f"{redirect2}&System=IoT_Mobile_App&RegistrationSubChannel=hOn"
@@ -134,9 +142,7 @@ class HonAuth:
                 fw_uid, loaded_str = context[0]
                 self._login_data.fw_uid = fw_uid
                 self._login_data.loaded = json.loads(loaded_str)
-                self._login_data.url = login_url.replace(
+                self._login_data.url = login_url.replace(const.AUTH_API, "")
-                    "/".join(const.AUTH_API.split("/")[:-1]), ""
-                )
                 return True
             await self._error_logger(response)
         return False
@@ -149,8 +155,8 @@ class HonAuth:
             "descriptor": "apex://LightningLoginCustomController/ACTION$login",
             "callingDescriptor": "markup://c:loginForm",
             "params": {
-                "username": quote(self._login_data.email),
+                "username": self._login_data.email,
-                "password": quote(self._login_data.password),
+                "password": self._login_data.password,
                 "startUrl": start_url,
             },
         }
@@ -172,7 +178,7 @@ class HonAuth:
         async with self._request.post(
             const.AUTH_API + "/s/sfsites/aura",
             headers={"Content-Type": "application/x-www-form-urlencoded"},
-            data="&".join(f"{k}={json.dumps(v)}" for k, v in data.items()),
+            data="&".join(f"{k}={quote(json.dumps(v))}" for k, v in data.items()),
             params=params,
         ) as response:
             if response.status == 200:
@@ -182,13 +188,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:
@@ -209,12 +216,14 @@ class HonAuth:
                 url_search = re.findall(
                     "href\\s*=\\s*[\"'](.*?)[\"']", await response.text()
                 )
-        url = "/".join(const.AUTH_API.split("/")[:-1]) + url_search[0]
+        url = const.AUTH_API + url_search[0]
         async with self._request.get(url) as response:
             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:

pyhon/connection/device.py

@@ -32,12 +32,14 @@ class HonDevice:
     def mobile_id(self) -> str:
         return self._mobile_id
 
-    def get(self, mobile: bool = False) -> Dict:
+    def get(self, mobile: bool = False) -> Dict[str, str | int]:
-        result = {
+        result: Dict[str, str | int] = {
             "appVersion": self.app_version,
             "mobileId": self.mobile_id,
             "os": self.os,
             "osVersion": self.os_version,
             "deviceModel": self.device_model,
         }
-        return (result | {"mobileOs": result.pop("os")}) if mobile else result
+        if mobile:
+            result |= {"mobileOs": result.pop("os", "")}
+        return result

pyhon/connection/handler/anonym.py

@@ -1,21 +1,27 @@
 import logging
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
-from typing import Callable, Dict
+from typing import Dict, Any
+
+import aiohttp
+from yarl import URL
 
 from pyhon import const
 from pyhon.connection.handler.base import ConnectionHandler
+from pyhon.typedefs import Callback
 
 _LOGGER = logging.getLogger(__name__)
 
 
 class HonAnonymousConnectionHandler(ConnectionHandler):
-    _HEADERS: Dict = ConnectionHandler._HEADERS | {"x-api-key": const.API_KEY}
+    _HEADERS: Dict[str, str] = ConnectionHandler._HEADERS | {"x-api-key": const.API_KEY}
 
     @asynccontextmanager
-    async def _intercept(self, method: Callable, *args, **kwargs) -> AsyncIterator:
+    async def _intercept(
+        self, method: Callback, url: str | URL, *args: Any, **kwargs: Dict[str, Any]
+    ) -> AsyncIterator[aiohttp.ClientResponse]:
         kwargs["headers"] = kwargs.pop("headers", {}) | self._HEADERS
-        async with method(*args, **kwargs) as response:
+        async with method(url, *args, **kwargs) as response:
             if response.status == 403:
                 _LOGGER.error("Can't authenticate anymore")
             yield response

pyhon/connection/handler/auth.py

@@ -1,12 +1,14 @@
 import logging
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
-from typing import Optional, Callable, List, Tuple
+from typing import Optional, List, Tuple, Any, Dict
 
 import aiohttp
+from yarl import URL
 
 from pyhon import const
 from pyhon.connection.handler.base import ConnectionHandler
+from pyhon.typedefs import Callback
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -28,9 +30,9 @@ class HonAuthConnectionHandler(ConnectionHandler):
 
     @asynccontextmanager
     async def _intercept(
-        self, method: Callable, *args, loop: int = 0, **kwargs
+        self, method: Callback, url: str | URL, *args: Any, **kwargs: Dict[str, Any]
-    ) -> AsyncIterator:
+    ) -> AsyncIterator[aiohttp.ClientResponse]:
         kwargs["headers"] = kwargs.pop("headers", {}) | self._HEADERS
-        async with method(*args, **kwargs) as response:
+        async with method(url, *args, **kwargs) as response:
-            self._called_urls.append((response.status, response.request_info.url))
+            self._called_urls.append((response.status, str(response.request_info.url)))
             yield response

pyhon/connection/handler/base.py

@@ -1,18 +1,21 @@
 import logging
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
-from typing import Optional, Callable, Dict
+from types import TracebackType
+from typing import Optional, Dict, Type, Any, Protocol
 
 import aiohttp
 from typing_extensions import Self
+from yarl import URL
 
 from pyhon import const, exceptions
+from pyhon.typedefs import Callback
 
 _LOGGER = logging.getLogger(__name__)
 
 
 class ConnectionHandler:
-    _HEADERS: Dict = {
+    _HEADERS: Dict[str, str] = {
         "user-agent": const.USER_AGENT,
         "Content-Type": "application/json",
     }
@@ -24,32 +27,49 @@ class ConnectionHandler:
     async def __aenter__(self) -> Self:
         return await self.create()
 
-    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> None:
         await self.close()
 
+    @property
+    def session(self) -> aiohttp.ClientSession:
+        if self._session is None:
+            raise exceptions.NoSessionException
+        return self._session
+
     async def create(self) -> Self:
         if self._create_session:
             self._session = aiohttp.ClientSession()
         return self
 
     @asynccontextmanager
-    def _intercept(self, method: Callable, *args, loop: int = 0, **kwargs):
+    def _intercept(
+        self, method: Callback, url: str | URL, *args: Any, **kwargs: Dict[str, Any]
+    ) -> AsyncIterator[aiohttp.ClientResponse]:
         raise NotImplementedError
 
     @asynccontextmanager
-    async def get(self, *args, **kwargs) -> AsyncIterator[aiohttp.ClientResponse]:
+    async def get(
+        self, *args: Any, **kwargs: Any
+    ) -> AsyncIterator[aiohttp.ClientResponse]:
         if self._session is None:
             raise exceptions.NoSessionException()
         response: aiohttp.ClientResponse
-        async with self._intercept(self._session.get, *args, **kwargs) as response:
+        async with self._intercept(self._session.get, *args, **kwargs) as response:  # type: ignore[arg-type]
             yield response
 
     @asynccontextmanager
-    async def post(self, *args, **kwargs) -> AsyncIterator[aiohttp.ClientResponse]:
+    async def post(
+        self, *args: Any, **kwargs: Any
+    ) -> AsyncIterator[aiohttp.ClientResponse]:
         if self._session is None:
             raise exceptions.NoSessionException()
         response: aiohttp.ClientResponse
-        async with self._intercept(self._session.post, *args, **kwargs) as response:
+        async with self._intercept(self._session.post, *args, **kwargs) as response:  # type: ignore[arg-type]
             yield response
 
     async def close(self) -> None:

pyhon/connection/handler/hon.py

@@ -2,15 +2,17 @@ import json
 import logging
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
-from typing import Optional, Callable, Dict
+from typing import Optional, Dict, Any
 
 import aiohttp
 from typing_extensions import Self
+from yarl import URL
 
 from pyhon.connection.auth import HonAuth
 from pyhon.connection.device import HonDevice
 from pyhon.connection.handler.base import ConnectionHandler
 from pyhon.exceptions import HonAuthenticationError, NoAuthenticationException
+from pyhon.typedefs import Callback
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -41,10 +43,10 @@ class HonConnectionHandler(ConnectionHandler):
 
     async def create(self) -> Self:
         await super().create()
-        self._auth = HonAuth(self._session, self._email, self._password, self._device)
+        self._auth = HonAuth(self.session, self._email, self._password, self._device)
         return self
 
-    async def _check_headers(self, headers: Dict) -> Dict:
+    async def _check_headers(self, headers: Dict[str, str]) -> Dict[str, str]:
         if not (self.auth.cognito_token and self.auth.id_token):
             await self.auth.authenticate()
         headers["cognito-token"] = self.auth.cognito_token
@@ -53,17 +55,18 @@ class HonConnectionHandler(ConnectionHandler):
 
     @asynccontextmanager
     async def _intercept(
-        self, method: Callable, *args, loop: int = 0, **kwargs
+        self, method: Callback, url: str | URL, *args: Any, **kwargs: Any
-    ) -> AsyncIterator:
+    ) -> AsyncIterator[aiohttp.ClientResponse]:
+        loop: int = kwargs.get("loop", 0)
         kwargs["headers"] = await self._check_headers(kwargs.get("headers", {}))
-        async with method(*args, **kwargs) as response:
+        async with method(url, *args, **kwargs) as response:
             if (
                 self.auth.token_expires_soon or response.status in [401, 403]
             ) and loop == 0:
                 _LOGGER.info("Try refreshing token...")
                 await self.auth.refresh()
                 async with self._intercept(
-                    method, *args, loop=loop + 1, **kwargs
+                    method, url, *args, loop=loop + 1, **kwargs
                 ) as result:
                     yield result
             elif (
@@ -77,7 +80,7 @@ class HonConnectionHandler(ConnectionHandler):
                 )
                 await self.create()
                 async with self._intercept(
-                    method, *args, loop=loop + 1, **kwargs
+                    method, url, *args, loop=loop + 1, **kwargs
                 ) as result:
                     yield result
             elif loop >= 2:

pyhon/const.py

@@ -1,10 +1,10 @@
-AUTH_API = "https://he-accounts.force.com/SmartHome"
+AUTH_API = "https://account2.hon-smarthome.com"
 API_URL = "https://api-iot.he.services"
 API_KEY = "GRCqFhC6Gk@ikWXm1RmnSmX1cm,MxY-configuration"
 APP = "hon"
 # All seen id's (different accounts, different devices) are the same, so I guess this hash is static
 CLIENT_ID = "3MVG9QDx8IX8nP5T2Ha8ofvlmjLZl5L_gvfbT9.HJvpHGKoAS_dcMN8LYpTSYeVFCraUnV.2Ag1Ki7m4znVO6"
-APP_VERSION = "1.53.7"
+APP_VERSION = "2.0.10"
 OS_VERSION = 31
 OS = "android"
 DEVICE_MODEL = "exynos9820"

pyhon/diagnose.py

@@ -0,0 +1,100 @@
+import asyncio
+import json
+import re
+import shutil
+from pathlib import Path
+from typing import TYPE_CHECKING, List, Tuple
+
+from pyhon import printer
+
+if TYPE_CHECKING:
+    from pyhon.appliance import HonAppliance
+
+
+def anonymize_data(data: str) -> str:
+    default_date = "1970-01-01T00:00:00.0Z"
+    default_mac = "xx-xx-xx-xx-xx-xx"
+    data = re.sub("[0-9A-Fa-f]{2}(-[0-9A-Fa-f]{2}){5}", default_mac, data)
+    data = re.sub("[\\d-]{10}T[\\d:]{8}(.\\d+)?Z", default_date, data)
+    for sensible in [
+        "serialNumber",
+        "code",
+        "nickName",
+        "mobileId",
+        "PK",
+        "SK",
+        "lat",
+        "lng",
+    ]:
+        for match in re.findall(f'"{sensible}.*?":\\s"?(.+?)"?,?\\n', data):
+            replace = re.sub("[a-z]", "x", match)
+            replace = re.sub("[A-Z]", "X", replace)
+            replace = re.sub("\\d", "1", replace)
+            data = data.replace(match, replace)
+    return data
+
+
+async def load_data(appliance: "HonAppliance", topic: str) -> Tuple[str, str]:
+    return topic, await getattr(appliance.api, f"load_{topic}")(appliance)
+
+
+def write_to_json(data: str, topic: str, path: Path, anonymous: bool = False) -> Path:
+    json_data = json.dumps(data, indent=4)
+    if anonymous:
+        json_data = anonymize_data(json_data)
+    file = path / f"{topic}.json"
+    with open(file, "w", encoding="utf-8") as json_file:
+        json_file.write(json_data)
+    return file
+
+
+async def appliance_data(
+    appliance: "HonAppliance", path: Path, anonymous: bool = False
+) -> List[Path]:
+    requests = [
+        "commands",
+        "attributes",
+        "command_history",
+        "statistics",
+        "maintenance",
+        "appliance_data",
+    ]
+    path /= f"{appliance.appliance_type}_{appliance.model_id}".lower()
+    path.mkdir(parents=True, exist_ok=True)
+    api_data = await asyncio.gather(*[load_data(appliance, name) for name in requests])
+    return [write_to_json(data, topic, path, anonymous) for topic, data in api_data]
+
+
+async def zip_archive(
+    appliance: "HonAppliance", path: Path, anonymous: bool = False
+) -> str:
+    data = await appliance_data(appliance, path, anonymous)
+    archive = data[0].parent
+    shutil.make_archive(str(archive.parent), "zip", archive)
+    shutil.rmtree(archive)
+    return f"{archive.stem}.zip"
+
+
+def yaml_export(appliance: "HonAppliance", anonymous: bool = False) -> str:
+    data = {
+        "attributes": appliance.attributes.copy(),
+        "appliance": appliance.info,
+        "statistics": appliance.statistics,
+        "additional_data": appliance.additional_data,
+    }
+    data |= {n: c.parameter_groups for n, c in appliance.commands.items()}
+    extra = {n: c.data for n, c in appliance.commands.items() if c.data}
+    if extra:
+        data |= {"extra_command_data": extra}
+    if anonymous:
+        for sensible in ["serialNumber", "coords"]:
+            data.get("appliance", {}).pop(sensible, None)
+    data = {
+        "data": data,
+        "commands": printer.create_command(appliance.commands),
+        "rules": printer.create_rules(appliance.commands),
+    }
+    result = printer.pretty_print(data)
+    if anonymous:
+        result = anonymize_data(result)
+    return result

pyhon/exceptions.py

@@ -12,3 +12,7 @@ class NoSessionException(Exception):
 
 class NoAuthenticationException(Exception):
     pass
+
+
+class ApiError(Exception):
+    pass

pyhon/helper.py

@@ -1,75 +1,5 @@
-from pyhon.parameter.base import HonParameter
+def str_to_float(string: str | float) -> float:
-
+    try:
-
+        return int(string)
-def key_print(data, key="", start=True):
+    except ValueError:
-    result = ""
+        return float(str(string).replace(",", "."))
-    if isinstance(data, list):
-        for i, value in enumerate(data):
-            result += key_print(value, key=f"{key}.{i}", start=False)
-    elif isinstance(data, dict):
-        for k, value in sorted(data.items()):
-            result += key_print(value, key=k if start else f"{key}.{k}", start=False)
-    else:
-        result += f"{key}: {data}\n"
-    return result
-
-
-# yaml.dump() would be done the same, but needs an additional dependency...
-def pretty_print(data, key="", intend=0, is_list=False, whitespace="  "):
-    result = ""
-    if isinstance(data, list):
-        if key:
-            result += f"{whitespace * intend}{'- ' if is_list else ''}{key}:\n"
-            intend += 1
-        for i, value in enumerate(data):
-            result += pretty_print(
-                value, intend=intend, is_list=True, whitespace=whitespace
-            )
-    elif isinstance(data, dict):
-        if key:
-            result += f"{whitespace * intend}{'- ' if is_list else ''}{key}:\n"
-            intend += 1
-        for i, (key, value) in enumerate(sorted(data.items())):
-            if is_list and not i:
-                result += pretty_print(
-                    value, key=key, intend=intend, is_list=True, whitespace=whitespace
-                )
-            elif is_list:
-                result += pretty_print(
-                    value, key=key, intend=intend + 1, whitespace=whitespace
-                )
-            else:
-                result += pretty_print(
-                    value, key=key, intend=intend, whitespace=whitespace
-                )
-    else:
-        result += f"{whitespace * intend}{'- ' if is_list else ''}{key}{': ' if key else ''}{data}\n"
-    return result
-
-
-def get_parameter(command, parameter):
-    if programs := command.programs:
-        for program in programs.values():
-            if data := program.settings.get(parameter):
-                return data
-    return command.settings.get(parameter)
-
-
-def create_command(commands, concat=False):
-    result = {}
-    for name, command in commands.items():
-        if not concat:
-            result[name] = {}
-        for parameter in command.setting_keys:
-            data = get_parameter(command, parameter)
-            if data.typology == "enum":
-                value = data.values
-            elif data.typology == "range":
-                value = {"min": data.min, "max": data.max, "step": data.step}
-            else:
-                continue
-            if not concat:
-                result[name][parameter] = value
-            else:
-                result[f"{name}.{parameter}"] = value
-    return result

pyhon/hon.py

@@ -1,4 +1,6 @@
 import asyncio
+import logging
+from pathlib import Path
 from types import TracebackType
 from typing import List, Optional, Dict, Any, Type
 
@@ -7,15 +9,25 @@ from typing_extensions import Self
 
 from pyhon import HonAPI, exceptions
 from pyhon.appliance import HonAppliance
+from pyhon.connection.api import TestAPI
+
+_LOGGER = logging.getLogger(__name__)
 
 
 class Hon:
-    def __init__(self, email: str, password: str, session: ClientSession | None = None):
+    def __init__(
-        self._email: str = email
+        self,
-        self._password: str = password
+        email: Optional[str] = "",
+        password: Optional[str] = "",
+        session: Optional[ClientSession] = None,
+        test_data_path: Optional[Path] = 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
+        self._test_data_path: Path = test_data_path or Path().cwd()
 
     async def __aenter__(self) -> Self:
         return await self.create()
@@ -34,9 +46,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,26 +69,44 @@ class Hon:
     def appliances(self) -> List[HonAppliance]:
         return self._appliances
 
-    async def _create_appliance(self, appliance_data: Dict[str, Any], zone=0) -> None:
+    @appliances.setter
-        appliance = HonAppliance(self._api, appliance_data, zone=zone)
+    def appliances(self, appliances: List[HonAppliance]) -> None:
+        self._appliances = appliances
+
+    async def _create_appliance(
+        self, appliance_data: Dict[str, Any], api: HonAPI, zone: int = 0
+    ) -> None:
+        appliance = HonAppliance(api, appliance_data, zone=zone)
         if appliance.mac_address == "":
             return
-        await asyncio.gather(
+        try:
-            *[
+            await asyncio.gather(
-                appliance.load_attributes(),
+                *[
-                appliance.load_commands(),
+                    appliance.load_attributes(),
-                appliance.load_statistics(),
+                    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:
-        appliance: Dict
+        appliances = await self.api.load_appliances()
-        for appliance in (await self.api.load_appliances())["payload"]["appliances"]:
+        for appliance in appliances:
             if (zones := int(appliance.get("zone", "0"))) > 1:
                 for zone in range(zones):
-                    await self._create_appliance(appliance.copy(), zone=zone + 1)
+                    await self._create_appliance(
-            await self._create_appliance(appliance)
+                        appliance.copy(), self.api, zone=zone + 1
+                    )
+            await self._create_appliance(appliance, self.api)
+        if (
+            test_data := self._test_data_path / "hon-test-data" / "test_data"
+        ).exists() or (test_data := test_data / "test_data").exists():
+            api = TestAPI(test_data)
+            for appliance in await api.load_appliances():
+                await self._create_appliance(appliance, api)
 
     async def close(self) -> None:
         await self.api.close()

pyhon/parameter/base.py

@@ -1,13 +1,20 @@
-from typing import Dict, Any, List
+from typing import Dict, Any, List, Tuple, Callable, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pyhon.rules import HonRule
 
 
 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
+        self._triggers: Dict[
+            str, List[Tuple[Callable[["HonRule"], None], "HonRule"]]
+        ] = {}
 
     @property
     def key(self) -> str:
@@ -17,9 +24,18 @@ class HonParameter:
     def value(self) -> str | float:
         return self._value if self._value is not None else "0"
 
+    @value.setter
+    def value(self, value: str | float) -> None:
+        self._value = value
+        self.check_trigger(value)
+
+    @property
+    def intern_value(self) -> str:
+        return str(self.value)
+
     @property
     def values(self) -> List[str]:
-        return list(str(self.value))
+        return [str(self.value)]
 
     @property
     def category(self) -> str:
@@ -32,3 +48,40 @@ class HonParameter:
     @property
     def mandatory(self) -> int:
         return self._mandatory
+
+    @property
+    def group(self) -> str:
+        return self._group
+
+    def add_trigger(
+        self, value: str, func: Callable[["HonRule"], None], data: "HonRule"
+    ) -> None:
+        if self._value == value:
+            func(data)
+        self._triggers.setdefault(value, []).append((func, data))
+
+    def check_trigger(self, value: str | float) -> None:
+        if str(value) in self._triggers:
+            for trigger in self._triggers[str(value)]:
+                func, args = trigger
+                func(args)
+
+    @property
+    def triggers(self) -> Dict[str, Any]:
+        result: Dict[str, Any] = {}
+        for value, rules in self._triggers.items():
+            for _, rule in rules:
+                if rule.extras:
+                    param = result.setdefault(value, {})
+                    for extra_key, extra_value in rule.extras.items():
+                        param = param.setdefault(extra_key, {}).setdefault(
+                            extra_value, {}
+                        )
+                else:
+                    param = result.setdefault(value, {})
+                if fixed_value := rule.param_data.get("fixedValue"):
+                    param[rule.param_key] = fixed_value
+                else:
+                    param[rule.param_key] = rule.param_data.get("defaultValue", "")
+
+        return result

pyhon/parameter/enum.py

@@ -3,27 +3,42 @@ from typing import Dict, Any, List
 from pyhon.parameter.base import HonParameter
 
 
+def clean_value(value: str | float) -> str:
+    return str(value).strip("[]").replace("|", "_").lower()
+
+
 class HonParameterEnum(HonParameter):
-    def __init__(self, key: str, attributes: Dict[str, Any]) -> None:
+    def __init__(self, key: str, attributes: Dict[str, Any], group: str) -> None:
-        super().__init__(key, attributes)
+        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 clean_value(self._default.strip("[]")) not in self.values:
+            self._values.append(self._default)
 
     def __repr__(self) -> str:
         return f"{self.__class__} (<{self.key}> {self.values})"
 
     @property
     def values(self) -> List[str]:
-        return [str(value) for value in self._values]
+        return [clean_value(value) for value in self._values]
+
+    @values.setter
+    def values(self, values: List[str]) -> None:
+        self._values = values
+
+    @property
+    def intern_value(self) -> str:
+        return str(self._value) if self._value is not None else str(self.values[0])
 
     @property
     def value(self) -> str | float:
-        return self._value if self._value is not None else self.values[0]
+        return clean_value(self._value) if self._value is not None else self.values[0]
 
     @value.setter
     def value(self, value: str) -> None:
         if value in self.values:
             self._value = value
+            self.check_trigger(value)
         else:
-            raise ValueError(f"Allowed values {self._value}")
+            raise ValueError(f"Allowed values {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:
+    def __init__(self, key: str, attributes: Dict[str, Any], group: str) -> None:
-        super().__init__(key, attributes)
+        super().__init__(key, attributes, group)
         self._value = attributes.get("fixedValue", None)
 
     def __repr__(self) -> str:
@@ -19,3 +19,4 @@ class HonParameterFixed(HonParameter):
     def value(self, value: str | float) -> None:
         # Fixed values seems being not so fixed as thought
         self._value = value
+        self.check_trigger(value)

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:
+    def __init__(self, key: str, command: "HonCommand", group: str) -> None:
-        super().__init__(key, {})
+        super().__init__(key, {}, group)
         self._command = command
-        self._value: str = command.program
+        if "PROGRAM" in command.category:
-        self._programs: Dict[str, "HonCommand"] = command.programs
+            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}")
 
@@ -32,11 +35,20 @@ class HonParameterProgram(HonParameterEnum):
         values = [v for v in self._programs if all(f not in v for f in self._FILTER)]
         return sorted(values)
 
+    @values.setter
+    def values(self, values: List[str]) -> None:
+        return
+
     @property
-    def ids(self):
+    def ids(self) -> Dict[int, str]:
         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")
+            if "iot_" not in n
+            and p.parameters.get("prCode")
+            and not ((fav := p.parameters.get("favourite")) and fav.value == "1")
         }
         return dict(sorted(values.items()))
+
+    def set_value(self, value: str) -> None:
+        self._value = value

pyhon/parameter/range.py

@@ -1,52 +1,59 @@
 from typing import Dict, Any, List
 
+from pyhon.helper import str_to_float
 from pyhon.parameter.base import HonParameter
 
 
-def str_to_float(string: str | float) -> float:
-    try:
-        return int(string)
-    except ValueError:
-        return float(str(string).replace(",", "."))
-
-
 class HonParameterRange(HonParameter):
-    def __init__(self, key: str, attributes: Dict[str, Any]) -> None:
+    def __init__(self, key: str, attributes: Dict[str, Any], group: str) -> None:
-        super().__init__(key, attributes)
+        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"])
-        self._default: float = str_to_float(attributes.get("defaultValue", self._min))
+        self._default: float = str_to_float(attributes.get("defaultValue", self.min))
         self._value: float = self._default
 
-    def __repr__(self):
+    def __repr__(self) -> str:
-        return f"{self.__class__} (<{self.key}> [{self._min} - {self._max}])"
+        return f"{self.__class__} (<{self.key}> [{self.min} - {self.max}])"
 
     @property
     def min(self) -> float:
         return self._min
 
+    @min.setter
+    def min(self, mini: float) -> None:
+        self._min = mini
+
     @property
     def max(self) -> float:
         return self._max
 
+    @max.setter
+    def max(self, maxi: float) -> None:
+        self._max = maxi
+
     @property
     def step(self) -> float:
+        if not self._step:
+            return 1
         return self._step
 
+    @step.setter
+    def step(self, step: float) -> None:
+        self._step = step
+
     @property
-    def value(self) -> float:
+    def value(self) -> str | float:
-        return self._value if self._value is not None else self._min
+        return self._value if self._value is not None else self.min
 
     @value.setter
-    def value(self, value: float) -> None:
+    def value(self, value: str | 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
+            self.check_trigger(value)
         else:
-            raise ValueError(
+            raise ValueError(f"Allowed: min {self.min} max {self.max} step {self.step}")
-                f"Allowed: min {self._min} max {self._max} step {self._step}"
-            )
 
     @property
     def values(self) -> List[str]:

pyhon/printer.py

@@ -0,0 +1,94 @@
+from typing import Dict, Any, TYPE_CHECKING, List
+
+from pyhon.parameter.enum import HonParameterEnum
+from pyhon.parameter.range import HonParameterRange
+
+if TYPE_CHECKING:
+    from pyhon.commands import HonCommand
+
+
+def key_print(data: Any, key: str = "", start: bool = True) -> str:
+    result = ""
+    if isinstance(data, list):
+        for i, value in enumerate(data):
+            result += key_print(value, key=f"{key}.{i}", start=False)
+    elif isinstance(data, dict):
+        for k, value in sorted(data.items()):
+            result += key_print(value, key=k if start else f"{key}.{k}", start=False)
+    else:
+        result += f"{key}: {data}\n"
+    return result
+
+
+# yaml.dump() would be done the same, but needs an additional dependency...
+def pretty_print(
+    data: Any,
+    key: str = "",
+    intend: int = 0,
+    is_list: bool = False,
+    whitespace: str = "  ",
+) -> str:
+    result = ""
+    if isinstance(data, list):
+        if key:
+            result += f"{whitespace * intend}{'- ' if is_list else ''}{key}:\n"
+            intend += 1
+        for i, value in enumerate(data):
+            result += pretty_print(
+                value, intend=intend, is_list=True, whitespace=whitespace
+            )
+    elif isinstance(data, dict):
+        if key:
+            result += f"{whitespace * intend}{'- ' if is_list else ''}{key}:\n"
+            intend += 1
+        for i, (key, value) in enumerate(sorted(data.items())):
+            if is_list and not i:
+                result += pretty_print(
+                    value, key=key, intend=intend, is_list=True, whitespace=whitespace
+                )
+            elif is_list:
+                result += pretty_print(
+                    value, key=key, intend=intend + 1, whitespace=whitespace
+                )
+            else:
+                result += pretty_print(
+                    value, key=key, intend=intend, whitespace=whitespace
+                )
+    else:
+        result += f"{whitespace * intend}{'- ' if is_list else ''}{key}{': ' if key else ''}{data}\n"
+    return result
+
+
+def create_command(
+    commands: Dict[str, "HonCommand"], concat: bool = False
+) -> Dict[str, Any]:
+    result: Dict[str, Any] = {}
+    for name, command in commands.items():
+        for parameter, data in command.available_settings.items():
+            if isinstance(data, HonParameterEnum):
+                value: List[str] | Dict[str, str | float] = data.values
+            elif isinstance(data, HonParameterRange):
+                value = {"min": data.min, "max": data.max, "step": data.step}
+            else:
+                continue
+            if not concat:
+                result.setdefault(name, {})[parameter] = value
+            else:
+                result[f"{name}.{parameter}"] = value
+    return result
+
+
+def create_rules(
+    commands: Dict[str, "HonCommand"], concat: bool = False
+) -> Dict[str, Any]:
+    result: Dict[str, Any] = {}
+    for name, command in commands.items():
+        for parameter, data in command.available_settings.items():
+            value = data.triggers
+            if not value:
+                continue
+            if not concat:
+                result.setdefault(name, {})[parameter] = value
+            else:
+                result[f"{name}.{parameter}"] = value
+    return result

pyhon/rules.py

@@ -0,0 +1,117 @@
+from dataclasses import dataclass
+from typing import List, Dict, TYPE_CHECKING, Any, Optional
+
+from pyhon.parameter.enum import HonParameterEnum
+from pyhon.parameter.range import HonParameterRange
+
+if TYPE_CHECKING:
+    from pyhon.commands import HonCommand
+    from pyhon.parameter.base import HonParameter
+
+
+@dataclass
+class HonRule:
+    trigger_key: str
+    trigger_value: str
+    param_key: str
+    param_data: Dict[str, Any]
+    extras: Optional[Dict[str, str]] = None
+
+
+class HonRuleSet:
+    def __init__(self, command: "HonCommand", rule: Dict[str, Any]):
+        self._command: "HonCommand" = command
+        self._rules: Dict[str, List[HonRule]] = {}
+        self._parse_rule(rule)
+
+    def _parse_rule(self, rule: Dict[str, Any]) -> None:
+        for param_key, params in rule.items():
+            param_key = self._command.appliance.options.get(param_key, param_key)
+            for trigger_key, trigger_data in params.items():
+                self._parse_conditions(param_key, trigger_key, trigger_data)
+
+    def _parse_conditions(
+        self,
+        param_key: str,
+        trigger_key: str,
+        trigger_data: Dict[str, Any],
+        extra: Optional[Dict[str, str]] = None,
+    ) -> None:
+        trigger_key = trigger_key.replace("@", "")
+        trigger_key = self._command.appliance.options.get(trigger_key, trigger_key)
+        for multi_trigger_value, param_data in trigger_data.items():
+            for trigger_value in multi_trigger_value.split("|"):
+                if isinstance(param_data, dict) and "typology" in param_data:
+                    self._create_rule(
+                        param_key, trigger_key, trigger_value, param_data, extra
+                    )
+                elif isinstance(param_data, dict):
+                    if extra is None:
+                        extra = {}
+                    extra[trigger_key] = trigger_value
+                    for extra_key, extra_data in param_data.items():
+                        self._parse_conditions(param_key, extra_key, extra_data, extra)
+
+    def _create_rule(
+        self,
+        param_key: str,
+        trigger_key: str,
+        trigger_value: str,
+        param_data: Dict[str, Any],
+        extras: Optional[Dict[str, str]] = None,
+    ) -> None:
+        if param_data.get("fixedValue") == f"@{param_key}":
+            return
+        self._rules.setdefault(trigger_key, []).append(
+            HonRule(trigger_key, trigger_value, param_key, param_data, extras)
+        )
+
+    def _duplicate_for_extra_conditions(self) -> None:
+        new: Dict[str, List[HonRule]] = {}
+        for rules in self._rules.values():
+            for rule in rules:
+                if rule.extras is None:
+                    continue
+                for key, value in rule.extras.items():
+                    extras = rule.extras.copy()
+                    extras.pop(key)
+                    extras[rule.trigger_key] = rule.trigger_value
+                    new.setdefault(key, []).append(
+                        HonRule(key, value, rule.param_key, rule.param_data, extras)
+                    )
+        for key, rules in new.items():
+            for rule in rules:
+                self._rules.setdefault(key, []).append(rule)
+
+    def _add_trigger(self, parameter: "HonParameter", data: HonRule) -> None:
+        def apply(rule: HonRule) -> None:
+            if rule.extras is not None:
+                for key, value in rule.extras.items():
+                    if str(self._command.parameters.get(key)) != str(value):
+                        return
+            if param := self._command.parameters.get(rule.param_key):
+                if value := rule.param_data.get("fixedValue", ""):
+                    if isinstance(param, HonParameterEnum) and set(param.values) != {
+                        str(value)
+                    }:
+                        param.values = [str(value)]
+                    elif isinstance(param, HonParameterRange):
+                        param.value = float(value)
+                        return
+                    param.value = str(value)
+                elif rule.param_data.get("typology") == "enum":
+                    if isinstance(param, HonParameterEnum):
+                        if enum_values := rule.param_data.get("enumValues"):
+                            param.values = enum_values.split("|")
+                        if default_value := rule.param_data.get("defaultValue"):
+                            param.value = default_value
+
+        parameter.add_trigger(data.trigger_value, apply, data)
+
+    def patch(self) -> None:
+        self._duplicate_for_extra_conditions()
+        for name, parameter in self._command.parameters.items():
+            if name not in self._rules:
+                continue
+            for data in self._rules.get(name, []):
+                self._add_trigger(parameter, data)

pyhon/typedefs.py

@@ -0,0 +1,27 @@
+from typing import Union, Any, TYPE_CHECKING, Protocol
+
+import aiohttp
+from yarl import URL
+
+if TYPE_CHECKING:
+    from pyhon.parameter.base import HonParameter
+    from pyhon.parameter.enum import HonParameterEnum
+    from pyhon.parameter.fixed import HonParameterFixed
+    from pyhon.parameter.program import HonParameterProgram
+    from pyhon.parameter.range import HonParameterRange
+
+
+class Callback(Protocol):
+    def __call__(
+        self, url: str | URL, *args: Any, **kwargs: Any
+    ) -> aiohttp.client._RequestContextManager:
+        ...
+
+
+Parameter = Union[
+    "HonParameter",
+    "HonParameterRange",
+    "HonParameterEnum",
+    "HonParameterFixed",
+    "HonParameterProgram",
+]

setup.py

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