Initialize and cache descriptors only once

miio/device.py

@@ -62,6 +62,8 @@ def __init__(
         self.token: Optional[str] = token
         self._model: Optional[str] = model
         self._info: Optional[DeviceInfo] = None
+        self._settings: Optional[Dict[str, SettingDescriptor]] = None
+        self._sensors: Optional[Dict[str, SensorDescriptor]] = None
         timeout = timeout if timeout is not None else self.timeout
         self._protocol = MiIOProtocol(
             ip, token, start_id, debug, lazy_discover, timeout
@@ -126,12 +128,16 @@ def info(self, *, skip_cache=False) -> DeviceInfo:
 
         This includes information about connected wlan network, and hardware and
         software versions.
+        This also caches the descriptors for sensors, settings and actions
+        which makes additional IO calls.
 
         :param skip_cache bool: Skip the cache
         """
         if self._info is not None and not skip_cache:
             return self._info
 
+        self._initialize_descriptors()
+
         return self._fetch_info()
 
     def _fetch_info(self) -> DeviceInfo:
@@ -155,6 +161,32 @@ def _fetch_info(self) -> DeviceInfo:
                 "Unable to request miIO.info from the device"
             ) from ex
 
+    def _initialize_descriptors(self) -> None:
+        """Cache all the descriptors once on the first call."""
+        if self._sensors is not None:
+            return
+
+        status = self.status()
+
+        # Sensors
+        self._sensors = status.sensors()
+
+        # Settings
+        self._settings = status.settings()
+        for setting in self._settings.values():
+            if setting.setter_name is not None:
+                setting.setter = getattr(self, setting.setter_name)
+            if setting.setter is None:
+                raise Exception(
+                    f"Neither setter or setter_name was defined for {setting}"
+                )
+            if (
+                setting.type == SettingType.Enum
+                and setting.choices_attribute is not None
+            ):
+                retrieve_choices_function = getattr(self, setting.choices_attribute)
+                setting.choices = retrieve_choices_function()
+
     @property
     def device_id(self) -> int:
         """Return device id (did), if available."""
@@ -252,31 +284,17 @@ def actions(self) -> Dict[str, ActionDescriptor]:
 
     def settings(self) -> Dict[str, SettingDescriptor]:
         """Return device settings."""
-        settings = self.status().settings()
-        for setting in settings.values():
-            # TODO: Bind setter methods, this should probably done only once during init.
-            if setting.setter is None:
-                # TODO: this is ugly, how to fix the issue where setter_name is optional and thus not acceptable for getattr?
-                if setting.setter_name is None:
-                    raise Exception(
-                        f"Neither setter or setter_name was defined for {setting}"
-                    )
-
-                setting.setter = getattr(self, setting.setter_name)
-            if (
-                isinstance(setting, EnumSettingDescriptor)
-                and setting.choices_attribute is not None
-            ):
-                retrieve_choices_function = getattr(self, setting.choices_attribute)
-                setting.choices = retrieve_choices_function()  # This can do IO
+        if self._settings is None:
+            self._initialize_descriptors()
 
-        return settings
+        return self._settings
 
     def sensors(self) -> Dict[str, SensorDescriptor]:
         """Return device sensors."""
-        # TODO: the latest status should be cached and re-used by all meta information getters
-        sensors = self.status().sensors()
-        return sensors
+        if self._sensors is None:
+            self._initialize_descriptors()
+
+        return self._sensors
 
     def __repr__(self):
         return f"<{self.__class__.__name__ }: {self.ip} (token: {self.token})>"