More type hints

pyhon/parameter.py

@@ -1,4 +1,10 @@
-def str_to_float(string):
+from typing import Dict, Any, List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pyhon.commands import HonCommand
+
+
+def str_to_float(string: str | float) -> float:
     try:
         return int(string)
     except ValueError:
@@ -6,43 +12,44 @@ def str_to_float(string):
 
 
 class HonParameter:
-    def __init__(self, key, attributes):
+    def __init__(self, key: str, attributes: Dict[str, Any]) -> None:
         self._key = key
-        self._category = attributes.get("category")
-        self._typology = attributes.get("typology")
-        self._mandatory = attributes.get("mandatory")
+        self._category: str = attributes.get("category", "")
+        self._typology: str = attributes.get("typology", "")
+        self._mandatory: int = attributes.get("mandatory", 0)
+        self._value: str | float = ""
 
     @property
-    def key(self):
+    def key(self) -> str:
         return self._key
 
     @property
-    def value(self):
+    def value(self) -> str | float:
         return self._value if self._value is not None else "0"
 
     @property
-    def category(self):
+    def category(self) -> str:
         return self._category
 
     @property
-    def typology(self):
+    def typology(self) -> str:
         return self._typology
 
     @property
-    def mandatory(self):
+    def mandatory(self) -> int:
         return self._mandatory
 
 
 class HonParameterFixed(HonParameter):
-    def __init__(self, key, attributes):
+    def __init__(self, key: str, attributes: Dict[str, Any]) -> None:
         super().__init__(key, attributes)
         self._value = attributes.get("fixedValue", None)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"{self.__class__} (<{self.key}> fixed)"
 
     @property
-    def value(self):
+    def value(self) -> str | float:
         return self._value if self._value is not None else "0"
 
     @value.setter
@@ -52,35 +59,35 @@ class HonParameterFixed(HonParameter):
 
 
 class HonParameterRange(HonParameter):
-    def __init__(self, key, attributes):
+    def __init__(self, key: str, attributes: Dict[str, Any]) -> None:
         super().__init__(key, attributes)
-        self._min = str_to_float(attributes["minimumValue"])
-        self._max = str_to_float(attributes["maximumValue"])
-        self._step = str_to_float(attributes["incrementValue"])
-        self._default = str_to_float(attributes.get("defaultValue", self._min))
-        self._value = self._default
+        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._value: float = self._default
 
     def __repr__(self):
         return f"{self.__class__} (<{self.key}> [{self._min} - {self._max}])"
 
     @property
-    def min(self):
+    def min(self) -> float:
         return self._min
 
     @property
-    def max(self):
+    def max(self) -> float:
         return self._max
 
     @property
-    def step(self):
+    def step(self) -> float:
         return self._step
 
     @property
-    def value(self):
+    def value(self) -> float:
         return self._value if self._value is not None else self._min
 
     @value.setter
-    def value(self, value):
+    def value(self, value: float) -> None:
         value = str_to_float(value)
         if self._min <= value <= self._max and not value % self._step:
             self._value = value
@@ -91,25 +98,25 @@ class HonParameterRange(HonParameter):
 
 
 class HonParameterEnum(HonParameter):
-    def __init__(self, key, attributes):
+    def __init__(self, key: str, attributes: Dict[str, Any]) -> None:
         super().__init__(key, attributes)
         self._default = attributes.get("defaultValue")
         self._value = self._default or "0"
-        self._values = attributes.get("enumValues")
+        self._values: List[str] = attributes.get("enumValues", [])
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"{self.__class__} (<{self.key}> {self.values})"
 
     @property
-    def values(self):
+    def values(self) -> List[str]:
         return [str(value) for value in self._values]
 
     @property
-    def value(self):
+    def value(self) -> str | float:
         return self._value if self._value is not None else self.values[0]
 
     @value.setter
-    def value(self, value):
+    def value(self, value: str) -> None:
         if value in self.values:
             self._value = value
         else:
@@ -119,26 +126,25 @@ class HonParameterEnum(HonParameter):
 class HonParameterProgram(HonParameterEnum):
     _FILTER = ["iot_recipe", "iot_guided"]
 
-    def __init__(self, key, command):
+    def __init__(self, key: str, command: "HonCommand") -> None:
         super().__init__(key, {})
         self._command = command
-        self._value = command.program
-        self._values = command.programs
-        self._typology = "enum"
-        self._filter = ""
+        self._value: str = command.program
+        self._values: List[str] = list(command.programs)
+        self._typology: str = "enum"
 
     @property
-    def value(self):
+    def value(self) -> str | float:
         return self._value
 
     @value.setter
-    def value(self, value):
+    def value(self, value: str) -> None:
         if value in self.values:
             self._command.program = value
         else:
             raise ValueError(f"Allowed values {self._values}")
 
     @property
-    def values(self):
+    def values(self) -> List[str]:
         values = [v for v in self._values if all(f not in v for f in self._FILTER)]
         return sorted(values)