Fix none-type attributes

pyhon/appliance.py

@@ -1,6 +1,7 @@
 import importlib
 import logging
 from contextlib import suppress
+from datetime import datetime, timedelta
 from typing import Optional, Dict, Any
 from typing import TYPE_CHECKING
 
@@ -16,6 +17,8 @@ _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:
@@ -30,6 +33,8 @@ class HonAppliance:
         self._attributes: Dict = {}
         self._zone: int = zone
         self._additional_data: Dict[str, Any] = {}
+        self._last_update = None
+        self._default_setting = HonParameter("", {}, "")
 
         try:
             self._extra = importlib.import_module(
@@ -139,8 +144,13 @@ class HonAppliance:
             if last is None:
                 continue
             parameters = command_history[last].get("command", {}).get("parameters", {})
-            if command.categories and parameters.get("category"):
-                command.category = parameters.pop("category").split(".")[-1].lower()
+            if command.categories and (
+                parameters.get("program") or parameters.get("category")
+            ):
+                if parameters.get("program"):
+                    command.category = parameters.pop("program").split(".")[-1].lower()
+                else:
+                    command.category = parameters.pop("category")
                 command = self.commands[name]
             for key, data in command.settings.items():
                 if (
@@ -192,7 +202,7 @@ class HonAppliance:
     async def load_commands(self):
         raw = await self.api.load_commands(self)
         self._appliance_model = raw.pop("applianceModel")
-        raw.pop("dictionaryId")
+        raw.pop("dictionaryId", None)
         self._commands = self._get_commands(raw)
         await self._recover_last_command_states()
 
@@ -205,7 +215,12 @@ class HonAppliance:
         self._statistics = await self.api.load_statistics(self)
 
     async def update(self):
-        await self.load_attributes()
+        now = datetime.now()
+        if not self._last_update or self._last_update < now - timedelta(
+            seconds=self._MINIMAL_UPDATE_INTERVAL
+        ):
+            self._last_update = now
+            await self.load_attributes()
 
     @property
     def command_parameters(self):
@@ -216,12 +231,20 @@ class HonAppliance:
         result = {}
         for name, command in self._commands.items():
             for key in command.setting_keys:
-                setting = command.settings.get(key, HonParameter(key, {}, name))
+                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 available_settings(self):
+        result = []
+        for name, command in self._commands.items():
+            for key in command.setting_keys:
+                result.append(f"{name}.{key}")
+        return result
+
     @property
     def data(self):
         result = {
@@ -235,18 +258,21 @@ class HonAppliance:
             return self._extra.data(result)
         return result
 
-    def diagnose(self, whitespace="\u200B \u200B "):
+    def diagnose(self, whitespace="\u200B \u200B ", command_only=False):
         data = {
             "attributes": self.attributes.copy(),
             "appliance": self.info,
             "additional_data": self._additional_data,
         }
+        if command_only:
+            data.pop("attributes")
+            data.pop("appliance")
         data |= {n: c.parameter_groups for n, c in self._commands.items()}
         extra = {n: c.data for n, c in self._commands.items() if c.data}
         if extra:
             data |= {"extra_command_data": extra}
         for sensible in ["PK", "SK", "serialNumber", "code", "coords"]:
-            data["appliance"].pop(sensible, None)
+            data.get("appliance", {}).pop(sensible, None)
         result = helper.pretty_print({"data": data}, whitespace=whitespace)
         result += helper.pretty_print(
             {"commands": helper.create_command(self.commands)},

pyhon/commands.py

@@ -29,6 +29,7 @@ class HonCommand:
         self._protocol_type: str = attributes.pop("protocolType", "")
         self._parameters: Dict[str, HonParameter] = {}
         self._data: Dict[str, Any] = {}
+        self._available_settings: Dict[str, HonParameter] = {}
         self._load_parameters(attributes)
 
     def __repr__(self) -> str:
@@ -46,6 +47,10 @@ class HonCommand:
     def parameters(self) -> Dict[str, HonParameter]:
         return self._parameters
 
+    @property
+    def settings(self) -> Dict[str, HonParameter]:
+        return self._parameters
+
     @property
     def parameter_groups(self) -> Dict[str, Dict[str, Union[str, float]]]:
         result: Dict[str, Dict[str, Union[str, float]]] = {}
@@ -76,14 +81,12 @@ class HonCommand:
                 self._data[name] = data
                 return
         if self._category_name:
-            if not self._categories:
-                self._parameters["program"] = HonParameterProgram(
-                    "program", self, "custom"
-                )
+            name = "program" if "PROGRAM" in self._category_name else "category"
+            self._parameters[name] = HonParameterProgram(name, self, "custom")
 
     async def send(self) -> bool:
-        params = self.parameter_groups["parameters"]
-        ancillary_params = self.parameter_groups["ancillary_parameters"]
+        params = self.parameter_groups.get("parameters", {})
+        ancillary_params = self.parameter_groups.get("ancillaryParameters", {})
         return await self._api.send_command(
             self._appliance, self._name, params, ancillary_params
         )
@@ -100,7 +103,8 @@ class HonCommand:
 
     @category.setter
     def category(self, category: str) -> None:
-        self._appliance.commands[self._name] = self.categories[category]
+        if category in self.categories:
+            self._appliance.commands[self._name] = self.categories[category]
 
     @property
     def setting_keys(self) -> List[str]:
@@ -119,7 +123,7 @@ class HonCommand:
         return first
 
     @property
-    def settings(self) -> Dict[str, HonParameter]:
+    def available_settings(self) -> Dict[str, HonParameter]:
         result: Dict[str, HonParameter] = {}
         for command in self.categories.values():
             for name, parameter in command.parameters.items():

pyhon/helper.py

@@ -1,6 +1,3 @@
-from pyhon.parameter.base import HonParameter
-
-
 def key_print(data, key="", start=True):
     result = ""
     if isinstance(data, list):
@@ -47,21 +44,12 @@ def pretty_print(data, key="", intend=0, is_list=False, whitespace="  "):
     return result
 
 
-def get_parameter(command, parameter):
-    if programs := command.categories:
-        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)
+        for parameter, data in command.available_settings.items():
             if data.typology == "enum":
                 value = data.values
             elif data.typology == "range":

pyhon/parameter/program.py

@@ -12,7 +12,10 @@ class HonParameterProgram(HonParameterEnum):
     def __init__(self, key: str, command: "HonCommand", group: str) -> None:
         super().__init__(key, {}, group)
         self._command = command
-        self._value: str = command.category
+        if "PROGRAM" in command.category:
+            self._value = command.category.split(".")[-1].lower()
+        else:
+            self._value = command.category
         self._programs: Dict[str, "HonCommand"] = command.categories
         self._typology: str = "enum"
 

pyhon/parameter/range.py

@@ -32,6 +32,8 @@ class HonParameterRange(HonParameter):
 
     @property
     def step(self) -> float:
+        if not self._step:
+            return 1
         return self._step
 
     @property

setup.py

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