homeassistant 2025.6.3__py3-none-any.whl → 2025.7.0b5__py3-none-any.whl

homeassistant/components/switchbot/humidifier.py

@@ -2,11 +2,16 @@
 
 from __future__ import annotations
 
+import logging
+from typing import Any
+
 import switchbot
+from switchbot import HumidifierAction as SwitchbotHumidifierAction, HumidifierMode
 
 from homeassistant.components.humidifier import (
     MODE_AUTO,
     MODE_NORMAL,
+    HumidifierAction,
     HumidifierDeviceClass,
     HumidifierEntity,
     HumidifierEntityFeature,
@@ -17,7 +22,13 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from .coordinator import SwitchbotConfigEntry
 from .entity import SwitchbotSwitchedEntity, exception_handler
 
+_LOGGER = logging.getLogger(__name__)
 PARALLEL_UPDATES = 0
+EVAPORATIVE_HUMIDIFIER_ACTION_MAP: dict[int, HumidifierAction] = {
+    SwitchbotHumidifierAction.OFF: HumidifierAction.OFF,
+    SwitchbotHumidifierAction.HUMIDIFYING: HumidifierAction.HUMIDIFYING,
+    SwitchbotHumidifierAction.DRYING: HumidifierAction.DRYING,
+}
 
 
 async def async_setup_entry(
@@ -26,7 +37,11 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Switchbot based on a config entry."""
-    async_add_entities([SwitchBotHumidifier(entry.runtime_data)])
+    coordinator = entry.runtime_data
+    if isinstance(coordinator.device, switchbot.SwitchbotEvaporativeHumidifier):
+        async_add_entities([SwitchBotEvaporativeHumidifier(coordinator)])
+    else:
+        async_add_entities([SwitchBotHumidifier(coordinator)])
 
 
 class SwitchBotHumidifier(SwitchbotSwitchedEntity, HumidifierEntity):
@@ -69,3 +84,71 @@ class SwitchBotHumidifier(SwitchbotSwitchedEntity, HumidifierEntity):
         else:
             self._last_run_success = await self._device.async_set_manual()
         self.async_write_ha_state()
+
+
+class SwitchBotEvaporativeHumidifier(SwitchbotSwitchedEntity, HumidifierEntity):
+    """Representation of a Switchbot evaporative humidifier."""
+
+    _device: switchbot.SwitchbotEvaporativeHumidifier
+    _attr_device_class = HumidifierDeviceClass.HUMIDIFIER
+    _attr_supported_features = HumidifierEntityFeature.MODES
+    _attr_available_modes = HumidifierMode.get_modes()
+    _attr_min_humidity = 1
+    _attr_max_humidity = 99
+    _attr_translation_key = "evaporative_humidifier"
+    _attr_name = None
+
+    @property
+    def is_on(self) -> bool | None:
+        """Return true if device is on."""
+        return self._device.is_on()
+
+    @property
+    def mode(self) -> str:
+        """Return the evaporative humidifier current mode."""
+        return self._device.get_mode().name.lower()
+
+    @property
+    def current_humidity(self) -> int | None:
+        """Return the current humidity."""
+        return self._device.get_humidity()
+
+    @property
+    def target_humidity(self) -> int | None:
+        """Return the humidity we try to reach."""
+        return self._device.get_target_humidity()
+
+    @property
+    def action(self) -> HumidifierAction | None:
+        """Return the current action."""
+        return EVAPORATIVE_HUMIDIFIER_ACTION_MAP.get(
+            self._device.get_action(), HumidifierAction.IDLE
+        )
+
+    @exception_handler
+    async def async_set_humidity(self, humidity: int) -> None:
+        """Set new target humidity."""
+        _LOGGER.debug("Setting target humidity to: %s %s", humidity, self._address)
+        await self._device.set_target_humidity(humidity)
+        self.async_write_ha_state()
+
+    @exception_handler
+    async def async_set_mode(self, mode: str) -> None:
+        """Set new evaporative humidifier mode."""
+        _LOGGER.debug("Setting mode to: %s %s", mode, self._address)
+        await self._device.set_mode(HumidifierMode[mode.upper()])
+        self.async_write_ha_state()
+
+    @exception_handler
+    async def async_turn_on(self, **kwargs: Any) -> None:
+        """Turn on the humidifier."""
+        _LOGGER.debug("Turning on the humidifier %s", self._address)
+        await self._device.turn_on()
+        self.async_write_ha_state()
+
+    @exception_handler
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Turn off the humidifier."""
+        _LOGGER.debug("Turning off the humidifier %s", self._address)
+        await self._device.turn_off()
+        self.async_write_ha_state()

homeassistant/components/switchbot/icons.json

@@ -1,5 +1,16 @@
 {
   "entity": {
+    "sensor": {
+      "water_level": {
+        "default": "mdi:water-percent",
+        "state": {
+          "empty": "mdi:water-off",
+          "low": "mdi:water-outline",
+          "medium": "mdi:water",
+          "high": "mdi:water-check"
+        }
+      }
+    },
     "fan": {
       "fan": {
         "state_attributes": {
@@ -31,6 +42,53 @@
           }
         }
       }
+    },
+    "humidifier": {
+      "evaporative_humidifier": {
+        "state_attributes": {
+          "mode": {
+            "state": {
+              "high": "mdi:water-plus",
+              "medium": "mdi:water",
+              "low": "mdi:water-outline",
+              "quiet": "mdi:volume-off",
+              "target_humidity": "mdi:target",
+              "sleep": "mdi:weather-night",
+              "auto": "mdi:autorenew",
+              "drying_filter": "mdi:water-remove"
+            }
+          }
+        }
+      }
+    },
+    "light": {
+      "light": {
+        "state_attributes": {
+          "effect": {
+            "state": {
+              "christmas": "mdi:string-lights",
+              "halloween": "mdi:halloween",
+              "sunset": "mdi:weather-sunset",
+              "vitality": "mdi:parachute",
+              "flashing": "mdi:flash",
+              "strobe": "mdi:led-strip-variant",
+              "fade": "mdi:water-opacity",
+              "smooth": "mdi:led-strip-variant",
+              "forest": "mdi:forest",
+              "ocean": "mdi:waves",
+              "autumn": "mdi:leaf-maple",
+              "cool": "mdi:emoticon-cool-outline",
+              "flow": "mdi:pulse",
+              "relax": "mdi:coffee",
+              "modern": "mdi:school-outline",
+              "rose": "mdi:flower",
+              "colorful": "mdi:looks",
+              "flickering": "mdi:led-strip-variant",
+              "breathing": "mdi:heart-pulse"
+            }
+          }
+        }
+      }
     }
   }
 }

homeassistant/components/switchbot/light.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import logging
 from typing import Any, cast
 
 import switchbot
@@ -10,14 +11,16 @@ from switchbot import ColorMode as SwitchBotColorMode
 from homeassistant.components.light import (
     ATTR_BRIGHTNESS,
     ATTR_COLOR_TEMP_KELVIN,
+    ATTR_EFFECT,
     ATTR_RGB_COLOR,
     ColorMode,
     LightEntity,
+    LightEntityFeature,
 )
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .coordinator import SwitchbotConfigEntry, SwitchbotDataUpdateCoordinator
+from .coordinator import SwitchbotConfigEntry
 from .entity import SwitchbotEntity, exception_handler
 
 SWITCHBOT_COLOR_MODE_TO_HASS = {
@@ -25,6 +28,7 @@ SWITCHBOT_COLOR_MODE_TO_HASS = {
     SwitchBotColorMode.COLOR_TEMP: ColorMode.COLOR_TEMP,
 }
 
+_LOGGER = logging.getLogger(__name__)
 PARALLEL_UPDATES = 0
 
 
@@ -42,34 +46,69 @@ class SwitchbotLightEntity(SwitchbotEntity, LightEntity):
 
     _device: switchbot.SwitchbotBaseLight
     _attr_name = None
+    _attr_translation_key = "light"
+
+    @property
+    def max_color_temp_kelvin(self) -> int:
+        """Return the max color temperature."""
+        return self._device.max_temp
+
+    @property
+    def min_color_temp_kelvin(self) -> int:
+        """Return the min color temperature."""
+        return self._device.min_temp
+
+    @property
+    def supported_color_modes(self) -> set[ColorMode]:
+        """Return the supported color modes."""
+        return {SWITCHBOT_COLOR_MODE_TO_HASS[mode] for mode in self._device.color_modes}
+
+    @property
+    def supported_features(self) -> LightEntityFeature:
+        """Return the supported features."""
+        return LightEntityFeature.EFFECT if self.effect_list else LightEntityFeature(0)
+
+    @property
+    def brightness(self) -> int | None:
+        """Return the brightness of the light."""
+        return max(0, min(255, round(self._device.brightness * 2.55)))
+
+    @property
+    def color_mode(self) -> ColorMode | None:
+        """Return the color mode of the light."""
+        return SWITCHBOT_COLOR_MODE_TO_HASS.get(
+            self._device.color_mode, ColorMode.UNKNOWN
+        )
 
-    def __init__(self, coordinator: SwitchbotDataUpdateCoordinator) -> None:
-        """Initialize the Switchbot light."""
-        super().__init__(coordinator)
-        device = self._device
-        self._attr_max_color_temp_kelvin = device.max_temp
-        self._attr_min_color_temp_kelvin = device.min_temp
-        self._attr_supported_color_modes = {
-            SWITCHBOT_COLOR_MODE_TO_HASS[mode] for mode in device.color_modes
-        }
-        self._async_update_attrs()
-
-    @callback
-    def _async_update_attrs(self) -> None:
-        """Handle updating _attr values."""
-        device = self._device
-        self._attr_is_on = self._device.on
-        self._attr_brightness = max(0, min(255, round(device.brightness * 2.55)))
-        if device.color_mode == SwitchBotColorMode.COLOR_TEMP:
-            self._attr_color_temp_kelvin = device.color_temp
-            self._attr_color_mode = ColorMode.COLOR_TEMP
-            return
-        self._attr_rgb_color = device.rgb
-        self._attr_color_mode = ColorMode.RGB
+    @property
+    def effect_list(self) -> list[str] | None:
+        """Return the list of effects supported by the light."""
+        return self._device.get_effect_list
+
+    @property
+    def effect(self) -> str | None:
+        """Return the current effect of the light."""
+        return self._device.get_effect()
+
+    @property
+    def rgb_color(self) -> tuple[int, int, int] | None:
+        """Return the RGB color of the light."""
+        return self._device.rgb
+
+    @property
+    def color_temp_kelvin(self) -> int | None:
+        """Return the color temperature of the light."""
+        return self._device.color_temp
+
+    @property
+    def is_on(self) -> bool:
+        """Return true if the light is on."""
+        return self._device.on
 
     @exception_handler
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Instruct the light to turn on."""
+        _LOGGER.debug("Turning on light %s, address %s", kwargs, self._address)
         brightness = round(
             cast(int, kwargs.get(ATTR_BRIGHTNESS, self.brightness)) / 255 * 100
         )
@@ -82,6 +121,10 @@ class SwitchbotLightEntity(SwitchbotEntity, LightEntity):
             kelvin = max(2700, min(6500, kwargs[ATTR_COLOR_TEMP_KELVIN]))
             await self._device.set_color_temp(brightness, kelvin)
             return
+        if ATTR_EFFECT in kwargs:
+            effect = kwargs[ATTR_EFFECT]
+            await self._device.set_effect(effect)
+            return
         if ATTR_RGB_COLOR in kwargs:
             rgb = kwargs[ATTR_RGB_COLOR]
             await self._device.set_rgb(brightness, rgb[0], rgb[1], rgb[2])
@@ -94,4 +137,5 @@ class SwitchbotLightEntity(SwitchbotEntity, LightEntity):
     @exception_handler
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Instruct the light to turn off."""
+        _LOGGER.debug("Turning off light %s, address %s", kwargs, self._address)
         await self._device.turn_off()

homeassistant/components/switchbot/manifest.json

@@ -41,5 +41,5 @@
   "iot_class": "local_push",
   "loggers": ["switchbot"],
   "quality_scale": "gold",
-  "requirements": ["PySwitchbot==0.64.1"]
+  "requirements": ["PySwitchbot==0.67.0"]
 }

homeassistant/components/switchbot/sensor.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from switchbot import HumidifierWaterLevel
 from switchbot.const.air_purifier import AirQualityLevel
 
 from homeassistant.components.bluetooth import async_last_service_info
@@ -19,6 +20,7 @@ from homeassistant.const import (
     EntityCategory,
     UnitOfElectricCurrent,
     UnitOfElectricPotential,
+    UnitOfEnergy,
     UnitOfPower,
     UnitOfTemperature,
 )
@@ -94,7 +96,7 @@ SENSOR_TYPES: dict[str, SensorEntityDescription] = {
     ),
     "current": SensorEntityDescription(
         key="current",
-        native_unit_of_measurement=UnitOfElectricCurrent.MILLIAMPERE,
+        native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         state_class=SensorStateClass.MEASUREMENT,
         device_class=SensorDeviceClass.CURRENT,
     ),
@@ -110,6 +112,18 @@ SENSOR_TYPES: dict[str, SensorEntityDescription] = {
         device_class=SensorDeviceClass.ENUM,
         options=[member.name.lower() for member in AirQualityLevel],
     ),
+    "energy": SensorEntityDescription(
+        key="energy",
+        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
+        state_class=SensorStateClass.TOTAL_INCREASING,
+        device_class=SensorDeviceClass.ENERGY,
+    ),
+    "water_level": SensorEntityDescription(
+        key="water_level",
+        translation_key="water_level",
+        device_class=SensorDeviceClass.ENUM,
+        options=HumidifierWaterLevel.get_levels(),
+    ),
 }
 
 

homeassistant/components/switchbot/strings.json

@@ -114,6 +114,15 @@
           "moderate": "Moderate",
           "unhealthy": "Unhealthy"
         }
+      },
+      "water_level": {
+        "name": "Water level",
+        "state": {
+          "empty": "Empty",
+          "low": "[%key:common::state::low%]",
+          "medium": "[%key:common::state::medium%]",
+          "high": "[%key:common::state::high%]"
+        }
       }
     },
     "cover": {
@@ -138,6 +147,22 @@
             }
           }
         }
+      },
+      "evaporative_humidifier": {
+        "state_attributes": {
+          "mode": {
+            "state": {
+              "high": "[%key:common::state::high%]",
+              "medium": "[%key:common::state::medium%]",
+              "low": "[%key:common::state::low%]",
+              "quiet": "Quiet",
+              "target_humidity": "Target humidity",
+              "sleep": "Sleep",
+              "auto": "[%key:common::state::auto%]",
+              "drying_filter": "Drying filter"
+            }
+          }
+        }
       }
     },
     "lock": {
@@ -221,6 +246,35 @@
           }
         }
       }
+    },
+    "light": {
+      "light": {
+        "state_attributes": {
+          "effect": {
+            "state": {
+              "christmas": "Christmas",
+              "halloween": "Halloween",
+              "sunset": "Sunset",
+              "vitality": "Vitality",
+              "flashing": "Flashing",
+              "strobe": "Strobe",
+              "fade": "Fade",
+              "smooth": "Smooth",
+              "forest": "Forest",
+              "ocean": "Ocean",
+              "autumn": "Autumn",
+              "cool": "Cool",
+              "flow": "Flow",
+              "relax": "Relax",
+              "modern": "Modern",
+              "rose": "Rose",
+              "colorful": "Colorful",
+              "flickering": "Flickering",
+              "breathing": "Breathing"
+            }
+          }
+        }
+      }
     }
   },
   "exceptions": {

homeassistant/components/switchbot/translations/bg.json

@@ -101,6 +101,15 @@
             }
         },
         "humidifier": {
+            "evaporative_humidifier": {
+                "state_attributes": {
+                    "mode": {
+                        "state": {
+                            "auto": "\u0410\u0432\u0442\u043e\u043c\u0430\u0442\u0438\u0447\u043d\u043e"
+                        }
+                    }
+                }
+            },
             "humidifier": {
                 "state_attributes": {
                     "last_run_success": {
@@ -112,6 +121,20 @@
                 }
             }
         },
+        "light": {
+            "light": {
+                "state_attributes": {
+                    "effect": {
+                        "state": {
+                            "autumn": "\u0415\u0441\u0435\u043d",
+                            "christmas": "\u041a\u043e\u043b\u0435\u0434\u0430",
+                            "forest": "\u0413\u043e\u0440\u0430",
+                            "ocean": "\u041e\u043a\u0435\u0430\u043d"
+                        }
+                    }
+                }
+            }
+        },
         "lock": {
             "lock": {
                 "state_attributes": {
@@ -131,6 +154,9 @@
             "light_level": {
                 "name": "\u041d\u0438\u0432\u043e \u043d\u0430 \u043e\u0441\u0432\u0435\u0442\u0435\u043d\u043e\u0441\u0442"
             },
+            "water_level": {
+                "name": "\u041d\u0438\u0432\u043e \u043d\u0430 \u0432\u043e\u0434\u0430\u0442\u0430"
+            },
             "wifi_signal": {
                 "name": "Wi-Fi \u0441\u0438\u0433\u043d\u0430\u043b"
             }

homeassistant/components/switchbot/translations/cs.json

@@ -135,6 +135,22 @@
             }
         },
         "humidifier": {
+            "evaporative_humidifier": {
+                "state_attributes": {
+                    "mode": {
+                        "state": {
+                            "auto": "Automaticky",
+                            "drying_filter": "Su\u0161en\u00ed filtru",
+                            "high": "Vysok\u00fd",
+                            "low": "N\u00edzk\u00fd",
+                            "medium": "St\u0159edn\u00ed",
+                            "quiet": "Tich\u00fd",
+                            "sleep": "Sp\u00e1nek",
+                            "target_humidity": "C\u00edlov\u00e1 vlhkost"
+                        }
+                    }
+                }
+            },
             "humidifier": {
                 "state_attributes": {
                     "last_run_success": {
@@ -146,6 +162,35 @@
                 }
             }
         },
+        "light": {
+            "light": {
+                "state_attributes": {
+                    "effect": {
+                        "state": {
+                            "autumn": "Podzim",
+                            "breathing": "D\u00fdch\u00e1n\u00ed",
+                            "christmas": "V\u00e1noce",
+                            "colorful": "Barevn\u00e9",
+                            "cool": "Cool",
+                            "fade": "Sl\u00e1bnut\u00ed",
+                            "flashing": "Z\u00e1blesky",
+                            "flickering": "Blik\u00e1n\u00ed",
+                            "flow": "Pr\u016ftok",
+                            "forest": "Les",
+                            "halloween": "Halloween",
+                            "modern": "Modern\u00ed",
+                            "ocean": "Oce\u00e1n",
+                            "relax": "Relax",
+                            "rose": "R\u016f\u017ee",
+                            "smooth": "Hladk\u00e9",
+                            "strobe": "Stroboskop",
+                            "sunset": "Z\u00e1pad slunce",
+                            "vitality": "Vitalita"
+                        }
+                    }
+                }
+            }
+        },
         "lock": {
             "lock": {
                 "state_attributes": {
@@ -174,6 +219,15 @@
             "light_level": {
                 "name": "\u00darove\u0148 sv\u011btla"
             },
+            "water_level": {
+                "name": "Hladina vody",
+                "state": {
+                    "empty": "Pr\u00e1zdn\u00e9",
+                    "high": "Vysok\u00fd",
+                    "low": "N\u00edzk\u00fd",
+                    "medium": "St\u0159edn\u00ed"
+                }
+            },
             "wifi_signal": {
                 "name": "Sign\u00e1l Wi-Fi"
             }

homeassistant/components/switchbot/translations/de.json

@@ -135,6 +135,22 @@
             }
         },
         "humidifier": {
+            "evaporative_humidifier": {
+                "state_attributes": {
+                    "mode": {
+                        "state": {
+                            "auto": "Auto",
+                            "drying_filter": "Filtertrocknung",
+                            "high": "Hoch",
+                            "low": "Niedrig",
+                            "medium": "Mittel",
+                            "quiet": "Leise",
+                            "sleep": "Schlaf",
+                            "target_humidity": "Soll-Luftfeuchtigkeit"
+                        }
+                    }
+                }
+            },
             "humidifier": {
                 "state_attributes": {
                     "last_run_success": {
@@ -146,6 +162,35 @@
                 }
             }
         },
+        "light": {
+            "light": {
+                "state_attributes": {
+                    "effect": {
+                        "state": {
+                            "autumn": "Herbst",
+                            "breathing": "Atmung",
+                            "christmas": "Weihnachten",
+                            "colorful": "Bunt",
+                            "cool": "K\u00fchl",
+                            "fade": "Verblassen",
+                            "flashing": "Blinken",
+                            "flickering": "Flackern",
+                            "flow": "Fluss",
+                            "forest": "Wald",
+                            "halloween": "Halloween",
+                            "modern": "Modern",
+                            "ocean": "Ozean",
+                            "relax": "Entspannen",
+                            "rose": "Rose",
+                            "smooth": "Smooth",
+                            "strobe": "Stroboskop",
+                            "sunset": "Sonnenuntergang",
+                            "vitality": "Vitalit\u00e4t"
+                        }
+                    }
+                }
+            }
+        },
         "lock": {
             "lock": {
                 "state_attributes": {
@@ -174,6 +219,15 @@
             "light_level": {
                 "name": "Lichtst\u00e4rke"
             },
+            "water_level": {
+                "name": "Wasserstand",
+                "state": {
+                    "empty": "Leer",
+                    "high": "Hoch",
+                    "low": "Niedrig",
+                    "medium": "Mittel"
+                }
+            },
             "wifi_signal": {
                 "name": "WLAN-Signal"
             }