Implement Horizontal and Vertical Swing Options (FR #841)

Author: ollo69

custom_components/smartthinq_sensors/climate.py

@@ -45,10 +45,7 @@
 # general ac attributes
 ATTR_FRIDGE = "fridge"
 ATTR_FREEZER = "freezer"
-ATTR_SWING_HORIZONTAL = "swing_mode_horizontal"
-ATTR_SWING_VERTICAL = "swing_mode_vertical"
 HVAC_MODE_NONE = "--"
-SWING_PREFIX = ["Vertical", "Horizontal"]
 
 # service definitions
 SERVICE_SET_SLEEP_TIME = "set_sleep_time"
@@ -211,16 +208,21 @@ def __init__(self, api: LGEDevice) -> None:
         self._attr_fan_modes = [
             FAN_MODE_LOOKUP.get(s, s) for s in self._device.fan_speeds
         ]
-        self._attr_swing_modes = [
-            f"{SWING_PREFIX[0]}{mode}" for mode in self._device.vertical_step_modes
-        ] + [f"{SWING_PREFIX[1]}{mode}" for mode in self._device.horizontal_step_modes]
+
+        self._use_h_mode = False
+        self._attr_swing_modes = self._device.vertical_step_modes or None
+        if not self._attr_swing_modes:
+            self._attr_swing_modes = self._device.horizontal_step_modes or None
+            self._use_h_mode = self._attr_swing_modes is not None
+        else:
+            self._attr_swing_horizontal_modes = (
+                self._device.horizontal_step_modes or None
+            )
+
         self._attr_preset_mode = None
 
         self._hvac_mode_lookup: dict[str, HVACMode] | None = None
         self._preset_mode_lookup: dict[str, str] | None = None
-        self._support_ver_swing = len(self._device.vertical_step_modes) > 0
-        self._support_hor_swing = len(self._device.horizontal_step_modes) > 0
-        self._set_hor_swing = self._support_hor_swing and not self._support_ver_swing
 
     def _available_hvac_modes(self) -> dict[str, HVACMode]:
         """Return available hvac modes from lookup dict."""
@@ -253,16 +255,6 @@ def _available_preset_modes(self) -> dict[str, str]:
             self._preset_mode_lookup = {v: k for k, v in modes.items()}
         return self._preset_mode_lookup
 
-    def _get_swing_mode(self, hor_mode=False) -> str | None:
-        """Return the current swing mode for vert of hor mode."""
-        if hor_mode:
-            mode = self._api.state.horizontal_step_mode
-        else:
-            mode = self._api.state.vertical_step_mode
-        if mode:
-            return f"{SWING_PREFIX[1 if hor_mode else 0]}{mode}"
-        return None
-
     @property
     def supported_features(self) -> ClimateEntityFeature:
         """Return the list of supported features."""
@@ -271,21 +263,12 @@ def supported_features(self) -> ClimateEntityFeature:
             features |= ClimateEntityFeature.FAN_MODE
         if self.preset_modes:
             features |= ClimateEntityFeature.PRESET_MODE
-        if self._support_ver_swing or self._support_hor_swing:
+        if self.swing_modes:
             features |= ClimateEntityFeature.SWING_MODE
+        if self.swing_horizontal_modes:
+            features |= ClimateEntityFeature.SWING_HORIZONTAL_MODE
         return features
 
-    @property
-    def extra_state_attributes(self):
-        """Return the optional state attributes with device specific additions."""
-        attr = {}
-        if self._support_hor_swing:
-            attr[ATTR_SWING_HORIZONTAL] = self._get_swing_mode(True)
-        if self._support_ver_swing:
-            attr[ATTR_SWING_VERTICAL] = self._get_swing_mode(False)
-
-        return attr
-
     @property
     def target_temperature_step(self) -> float:
         """Return the supported step of target temperature."""
@@ -410,35 +393,37 @@ async def async_set_fan_mode(self, fan_mode: str) -> None:
     @property
     def swing_mode(self) -> str | None:
         """Return the swing mode setting."""
-        if self._set_hor_swing and self._support_hor_swing:
-            return self._get_swing_mode(True)
-        return self._get_swing_mode(False)
+        if self._use_h_mode:
+            return self._api.state.horizontal_step_mode
+        return self._api.state.vertical_step_mode
 
     async def async_set_swing_mode(self, swing_mode: str) -> None:
-        """Set new target swing mode."""
-        avl_mode = False
-        curr_mode = None
-        set_hor_swing = swing_mode.startswith(SWING_PREFIX[1])
-        dev_mode = remove_prefix(swing_mode, SWING_PREFIX[1 if set_hor_swing else 0])
-        if set_hor_swing:
-            if dev_mode in self._device.horizontal_step_modes:
-                avl_mode = True
-                curr_mode = self._api.state.horizontal_step_mode
-        elif swing_mode.startswith(SWING_PREFIX[0]):
-            if dev_mode in self._device.vertical_step_modes:
-                avl_mode = True
-                curr_mode = self._api.state.vertical_step_mode
-
-        if not avl_mode:
+        """Set new target swing operation."""
+        if swing_mode not in (self.swing_modes or []):
             raise ValueError(f"Invalid swing_mode [{swing_mode}].")
 
-        if curr_mode != dev_mode:
-            if set_hor_swing:
-                await self._device.set_horizontal_step_mode(dev_mode)
+        if swing_mode != self.swing_mode:
+            if self._use_h_mode:
+                await self._device.set_horizontal_step_mode(swing_mode)
             else:
-                await self._device.set_vertical_step_mode(dev_mode)
+                await self._device.set_vertical_step_mode(swing_mode)
+            self._api.async_set_updated()
+
+    @property
+    def swing_horizontal_mode(self) -> str | None:
+        """Return the horizontal swing mode setting."""
+        return self._api.state.horizontal_step_mode
+
+    async def async_set_swing_horizontal_mode(self, swing_horizontal_mode: str) -> None:
+        """Set new target horizontal swing operation."""
+        if swing_horizontal_mode not in (self.swing_horizontal_modes or []):
+            raise ValueError(
+                f"Invalid horizontal swing_mode [{swing_horizontal_mode}]."
+            )
+
+        if swing_horizontal_mode != self.swing_horizontal_mode:
+            await self._device.set_horizontal_step_mode(swing_horizontal_mode)
             self._api.async_set_updated()
-        self._set_hor_swing = set_hor_swing
 
     async def async_turn_on(self) -> None:
         """Turn the entity on."""