Improve rule parsing

pyhon/appliance.py

@@ -2,6 +2,7 @@ import importlib
 import json
 import logging
 from contextlib import suppress
+from copy import copy
 from datetime import datetime, timedelta
 from pathlib import Path
 from typing import Optional, Dict, Any
@@ -11,6 +12,7 @@ from pyhon import helper
 from pyhon.commands import HonCommand
 from pyhon.parameter.base import HonParameter
 from pyhon.parameter.fixed import HonParameterFixed
+from pyhon.parameter.range import HonParameterRange
 
 if TYPE_CHECKING:
     from pyhon import HonAPI
@@ -99,8 +101,15 @@ class HonAppliance:
         return self._check_name_zone("nickName")
 
     @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 options(self):
+        return self._appliance_model.get("options", {})
 
     @property
     def commands(self):
@@ -206,21 +215,47 @@ class HonAppliance:
         self._appliance_model = raw.pop("applianceModel")
         raw.pop("dictionaryId", None)
         self._commands = self._get_commands(raw)
+        await self._add_favourites()
         await self._recover_last_command_states()
 
+    async def _add_favourites(self):
+        favourites = await self._api.command_favourites(self)
+        for favourite in favourites:
+            name = favourite.get("favouriteName")
+            command = favourite.get("command")
+            command_name = command.get("commandName")
+            program_name = command.get("programName", "").split(".")[-1].lower()
+            base = 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)
+            base.parameters["program"].set_value(name)
+            self._commands[command_name].categories[name] = base
+
     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"]
+        if self._extra:
+            self._attributes = self._extra.attributes(self._attributes)
 
     async def load_statistics(self):
         self._statistics = await self.api.load_statistics(self)
         self._statistics |= await self.api.load_maintenance(self)
 
-    async def update(self):
+    async def update(self, force=False):
         now = datetime.now()
-        if not self._last_update or self._last_update < now - timedelta(
+        if (
-            seconds=self._MINIMAL_UPDATE_INTERVAL
+            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()
@@ -256,9 +291,8 @@ class HonAppliance:
             "statistics": self.statistics,
             "additional_data": self._additional_data,
             **self.command_parameters,
+            **self.attributes,
         }
-        if self._extra:
-            return self._extra.data(result)
         return result
 
     def diagnose(self, whitespace="  ", command_only=False):
@@ -276,21 +310,50 @@ class HonAppliance:
         extra = {n: c.data for n, c in self._commands.items() if c.data}
         if extra:
             data |= {"extra_command_data": extra}
-        for sensible in ["PK", "SK", "serialNumber", "code", "coords", "device"]:
+        for sensible in ["PK", "SK", "serialNumber", "coords", "device"]:
             data.get("appliance", {}).pop(sensible, None)
         result = helper.pretty_print({"data": data}, whitespace=whitespace)
         result += helper.pretty_print(
-            {"commands": helper.create_command(self.commands)},
+            {
+                "commands": helper.create_command(self.commands),
+                "rules": helper.create_rules(self.commands),
+            },
             whitespace=whitespace,
         )
         return result.replace(self.mac_address, "xx-xx-xx-xx-xx-xx")
 
+    def sync_to_params(self, command_name):
+        command: HonCommand = self.commands.get(command_name)
+        for key, value in self.attributes.get("parameters", {}).items():
+            if isinstance(value, str) and (new := command.parameters.get(key)):
+                self.attributes["parameters"][key] = str(new.intern_value)
+
+    def sync_command(self, main, target=None) -> None:
+        base: HonCommand = self.commands.get(main)
+        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
+
 
 class HonApplianceTest(HonAppliance):
     def __init__(self, name):
         super().__init__(None, {})
         self._name = name
         self.load_commands()
+        self.load_attributes()
         self._info = self._appliance_model
 
     def load_commands(self):

pyhon/appliances/base.py

@@ -0,0 +1,15 @@
+class ApplianceBase:
+    def __init__(self, appliance):
+        self.parent = appliance
+
+    def attributes(self, data):
+        program_name = "No Program"
+        if program := int(data["parameters"].get("prCode", "0")):
+            if start_cmd := self.parent.settings.get("startProgram.program"):
+                if ids := start_cmd.ids:
+                    program_name = ids.get(program, program_name)
+        data["programName"] = program_name
+        return data
+
+    def settings(self, settings):
+        return settings

pyhon/appliances/dw.py

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

pyhon/appliances/ov.py

@@ -1,17 +1,19 @@
-class Appliance:
+from pyhon.appliances.base import ApplianceBase
-    def __init__(self, appliance):
-        self.parent = appliance
 
-    def data(self, data):
-        if data["attributes"]["lastConnEvent"]["category"] == "DISCONNECTED":
-            data["attributes"]["parameters"]["temp"] = "0"
-            data["attributes"]["parameters"]["onOffStatus"] = "0"
-            data["attributes"]["parameters"]["remoteCtrValid"] = "0"
-            data["attributes"]["parameters"]["remainingTimeMM"] = "0"
 
-        data["active"] = data["attributes"]["parameters"]["onOffStatus"] == "1"
+class Appliance(ApplianceBase):
+    def attributes(self, data):
+        data = super().attributes(data)
+        if data["lastConnEvent"]["category"] == "DISCONNECTED":
+            data["parameters"]["temp"] = "0"
+            data["parameters"]["onOffStatus"] = "0"
+            data["parameters"]["remoteCtrValid"] = "0"
+            data["parameters"]["remainingTimeMM"] = "0"
+
+        data["active"] = data["parameters"]["onOffStatus"] == "1"
+
+        if program := int(data["parameters"]["prCode"]):
+            ids = self.parent.settings["startProgram.program"].ids
+            data["programName"] = ids.get(program, "")
 
         return data
-
-    def settings(self, settings):
-        return settings

pyhon/appliances/ref.py

@@ -0,0 +1,23 @@
+from pyhon.appliances.base import ApplianceBase
+
+
+class Appliance(ApplianceBase):
+    def attributes(self, data):
+        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,18 +1,14 @@
+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):
-        self.parent = appliance
+        data = super().attributes(data)
-
+        if data["lastConnEvent"]["category"] == "DISCONNECTED":
-    def data(self, data):
+            data["parameters"]["machMode"] = "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):

pyhon/appliances/wc.py

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

pyhon/appliances/wd.py

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

pyhon/appliances/wm.py

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

pyhon/commands.py

@@ -1,16 +1,21 @@
+import logging
 from typing import Optional, Dict, Any, List, TYPE_CHECKING, Union
 
 from pyhon import exceptions
+from pyhon.exceptions import ApiError
 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
 
 if TYPE_CHECKING:
     from pyhon import HonAPI
     from pyhon.appliance import HonAppliance
 
+_LOGGER = logging.getLogger(__name__)
+
 
 class HonCommand:
     def __init__(
@@ -31,6 +36,7 @@ class HonCommand:
         self._parameters: Dict[str, HonParameter] = {}
         self._data: Dict[str, Any] = {}
         self._available_settings: Dict[str, HonParameter] = {}
+        self._rules: List[HonRuleSet] = []
         self._load_parameters(attributes)
 
     def __repr__(self) -> str:
@@ -43,9 +49,13 @@ class HonCommand:
     @property
     def api(self) -> "HonAPI":
         if self._api is None:
-            raise exceptions.NoAuthenticationException
+            raise exceptions.NoAuthenticationException("Missing hOn login")
         return self._api
 
+    @property
+    def appliance(self) -> "HonAppliance":
+        return self._appliance
+
     @property
     def data(self):
         return self._data
@@ -62,7 +72,7 @@ class HonCommand:
     def parameter_groups(self) -> Dict[str, Dict[str, Union[str, float]]]:
         result: Dict[str, Dict[str, Union[str, float]]] = {}
         for name, parameter in self._parameters.items():
-            result.setdefault(parameter.group, {})[name] = parameter.value
+            result.setdefault(parameter.group, {})[name] = parameter.intern_value
         return result
 
     @property
@@ -73,10 +83,17 @@ class HonCommand:
         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, 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)
@@ -94,9 +111,14 @@ class HonCommand:
     async def send(self) -> bool:
         params = self.parameter_groups.get("parameters", {})
         ancillary_params = self.parameter_groups.get("ancillaryParameters", {})
-        return await self.api.send_command(
+        ancillary_params.pop("programRules", None)
+        self.appliance.sync_to_params(self.name)
+        result = await self.api.send_command(
             self._appliance, self._name, params, ancillary_params
         )
+        if not result:
+            raise ApiError("Can't send command")
+        return result
 
     @property
     def categories(self) -> Dict[str, "HonCommand"]:

pyhon/connection/api.py

@@ -1,6 +1,7 @@
 import json
 import logging
 from datetime import datetime
+from pprint import pformat
 from typing import Dict, Optional
 
 from aiohttp import ClientSession
@@ -72,23 +73,23 @@ class HonAPI:
     async def load_commands(self, appliance: HonAppliance) -> Dict:
         params: Dict = {
             "applianceType": appliance.appliance_type,
-            "code": appliance.info["code"],
             "applianceModelId": appliance.appliance_model_id,
             "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 code := appliance.info.get("code"):
+        if series := appliance.info.get("series"):
-            params["code"] = code
+            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", {})
             if not result or result.pop("resultCode") != "0":
+                _LOGGER.error(await response.json())
                 return {}
             return result
 
@@ -171,7 +172,7 @@ class HonAPI:
             "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",
@@ -188,6 +189,7 @@ class HonAPI:
             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:

pyhon/connection/auth.py

@@ -134,9 +134,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 +147,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 +170,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:
@@ -210,7 +208,7 @@ 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)

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/exceptions.py

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

pyhon/helper.py

@@ -47,8 +47,6 @@ def pretty_print(data, key="", intend=0, is_list=False, whitespace="  "):
 def create_command(commands, concat=False):
     result = {}
     for name, command in commands.items():
-        if not concat:
-            result[name] = {}
         for parameter, data in command.available_settings.items():
             if data.typology == "enum":
                 value = data.values
@@ -57,7 +55,21 @@ def create_command(commands, concat=False):
             else:
                 continue
             if not concat:
-                result[name][parameter] = value
+                result.setdefault(name, {})[parameter] = value
+            else:
+                result[f"{name}.{parameter}"] = value
+    return result
+
+
+def create_rules(commands, concat=False):
+    result = {}
+    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/hon.py

@@ -83,7 +83,7 @@ class Hon:
             )
         except (KeyError, ValueError, IndexError) as error:
             _LOGGER.exception(error)
-            _LOGGER.error(f"Device data - %s", appliance_data)
+            _LOGGER.error("Device data - %s", appliance_data)
         self._appliances.append(appliance)
 
     async def setup(self) -> None:

pyhon/parameter/base.py

@@ -1,4 +1,7 @@
-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:
@@ -9,6 +12,7 @@ class HonParameter:
         self._mandatory: int = attributes.get("mandatory", 0)
         self._value: str | float = ""
         self._group: str = group
+        self._triggers: Dict[str, List[Tuple[Callable, "HonRule"]]] = {}
 
     @property
     def key(self) -> str:
@@ -18,6 +22,15 @@ 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 [str(self.value)]
@@ -37,3 +50,34 @@ class HonParameter:
     @property
     def group(self) -> str:
         return self._group
+
+    def add_trigger(self, value, func, data):
+        if self._value == value:
+            func(data)
+        self._triggers.setdefault(value, []).append((func, data))
+
+    def check_trigger(self, value) -> None:
+        if str(value) in self._triggers:
+            for trigger in self._triggers[str(value)]:
+                func, args = trigger
+                func(args)
+
+    @property
+    def triggers(self):
+        result = {}
+        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,13 +3,17 @@ from typing import Dict, Any, List
 from pyhon.parameter.base import HonParameter
 
 
+def clean_value(value):
+    return str(value).strip("[]").replace("|", "_").lower()
+
+
 class HonParameterEnum(HonParameter):
     def __init__(self, key: str, attributes: Dict[str, Any], group: str) -> None:
         super().__init__(key, attributes, group)
         self._default = attributes.get("defaultValue")
         self._value = self._default or "0"
         self._values: List[str] = attributes.get("enumValues", [])
-        if self._default and self._default not in self._values:
+        if self._default and clean_value(self._default.strip("[]")) not in self.values:
             self._values.append(self._default)
 
     def __repr__(self) -> str:
@@ -17,15 +21,24 @@ class HonParameterEnum(HonParameter):
 
     @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) -> 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

@@ -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

@@ -35,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) -> 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):
+        self._value = value

pyhon/parameter/range.py

@@ -16,39 +16,50 @@ class HonParameterRange(HonParameter):
         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):
-        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._min) % 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/rules.py

@@ -0,0 +1,105 @@
+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
+
+
+@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):
+        self._command: "HonCommand" = command
+        self._rules: Dict[str, List[HonRule]] = {}
+        self._parse_rule(rule)
+
+    def _parse_rule(self, rule):
+        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, trigger_key, trigger_data, extra=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, trigger_key, trigger_value, param_data, extras=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):
+        new = {}
+        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, data):
+        def apply(rule: HonRule):
+            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):
+        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)

setup.py

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