homeassistant 2025.9.3__py3-none-any.whl → 2025.10.0b0__py3-none-any.whl

homeassistant/components/vesync/fan.py

@@ -3,10 +3,9 @@
 from __future__ import annotations
 
 import logging
-import math
 from typing import Any
 
-from pyvesync.vesyncbasedevice import VeSyncBaseDevice
+from pyvesync.base_devices.vesyncbasedevice import VeSyncBaseDevice
 
 from homeassistant.components.fan import FanEntity, FanEntityFeature
 from homeassistant.config_entries import ConfigEntry
@@ -15,15 +14,13 @@ from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util.percentage import (
-    percentage_to_ranged_value,
-    ranged_value_to_percentage,
+    ordered_list_item_to_percentage,
+    percentage_to_ordered_list_item,
 )
-from homeassistant.util.scaling import int_states_in_range
 
-from .common import is_fan
+from .common import is_fan, is_purifier
 from .const import (
     DOMAIN,
-    SKU_TO_BASE_DEVICE,
     VS_COORDINATOR,
     VS_DEVICES,
     VS_DISCOVERY,
@@ -35,24 +32,13 @@ from .const import (
     VS_FAN_MODE_PRESET_LIST_HA,
     VS_FAN_MODE_SLEEP,
     VS_FAN_MODE_TURBO,
+    VS_MANAGER,
 )
 from .coordinator import VeSyncDataCoordinator
 from .entity import VeSyncBaseEntity
 
 _LOGGER = logging.getLogger(__name__)
 
-SPEED_RANGE = {  # off is not included
-    "LV-PUR131S": (1, 3),
-    "Core200S": (1, 3),
-    "Core300S": (1, 3),
-    "Core400S": (1, 4),
-    "Core600S": (1, 4),
-    "EverestAir": (1, 3),
-    "Vital200S": (1, 4),
-    "Vital100S": (1, 4),
-    "SmartTowerFan": (1, 13),
-}
-
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -72,7 +58,9 @@ async def async_setup_entry(
         async_dispatcher_connect(hass, VS_DISCOVERY.format(VS_DEVICES), discover)
     )
 
-    _setup_entities(hass.data[DOMAIN][VS_DEVICES], async_add_entities, coordinator)
+    _setup_entities(
+        hass.data[DOMAIN][VS_MANAGER].devices, async_add_entities, coordinator
+    )
 
 
 @callback
@@ -83,7 +71,11 @@ def _setup_entities(
 ):
     """Check if device is fan and add entity."""
 
-    async_add_entities(VeSyncFanHA(dev, coordinator) for dev in devices if is_fan(dev))
+    async_add_entities(
+        VeSyncFanHA(dev, coordinator)
+        for dev in devices
+        if is_fan(dev) or is_purifier(dev)
+    )
 
 
 class VeSyncFanHA(VeSyncBaseEntity, FanEntity):
@@ -101,26 +93,24 @@ class VeSyncFanHA(VeSyncBaseEntity, FanEntity):
     @property
     def is_on(self) -> bool:
         """Return True if device is on."""
-        return self.device.device_status == "on"
+        return self.device.state.device_status == "on"
 
     @property
     def percentage(self) -> int | None:
-        """Return the current speed."""
-        if (
-            self.device.mode == VS_FAN_MODE_MANUAL
-            and (current_level := self.device.fan_level) is not None
-        ):
-            return ranged_value_to_percentage(
-                SPEED_RANGE[SKU_TO_BASE_DEVICE[self.device.device_type]], current_level
+        """Return the currently set speed."""
+
+        current_level = self.device.state.fan_level
+
+        if self.device.state.mode == VS_FAN_MODE_MANUAL and current_level is not None:
+            return ordered_list_item_to_percentage(
+                self.device.fan_levels, current_level
             )
         return None
 
     @property
     def speed_count(self) -> int:
         """Return the number of speeds the fan supports."""
-        return int_states_in_range(
-            SPEED_RANGE[SKU_TO_BASE_DEVICE[self.device.device_type]]
-        )
+        return len(self.device.fan_levels)
 
     @property
     def preset_modes(self) -> list[str]:
@@ -128,7 +118,7 @@ class VeSyncFanHA(VeSyncBaseEntity, FanEntity):
         if hasattr(self.device, "modes"):
             return sorted(
                 [
-                    mode
+                    mode.value
                     for mode in self.device.modes
                     if mode in VS_FAN_MODE_PRESET_LIST_HA
                 ]
@@ -138,8 +128,8 @@ class VeSyncFanHA(VeSyncBaseEntity, FanEntity):
     @property
     def preset_mode(self) -> str | None:
         """Get the current preset mode."""
-        if self.device.mode in VS_FAN_MODE_PRESET_LIST_HA:
-            return self.device.mode
+        if self.device.state.mode in VS_FAN_MODE_PRESET_LIST_HA:
+            return self.device.state.mode
         return None
 
     @property
@@ -147,57 +137,67 @@ class VeSyncFanHA(VeSyncBaseEntity, FanEntity):
         """Return the state attributes of the fan."""
         attr = {}
 
-        if hasattr(self.device, "active_time"):
-            attr["active_time"] = self.device.active_time
+        if hasattr(self.device.state, "active_time"):
+            attr["active_time"] = self.device.state.active_time
 
-        if hasattr(self.device, "screen_status"):
-            attr["screen_status"] = self.device.screen_status
+        if hasattr(self.device.state, "display_status"):
+            attr["display_status"] = self.device.state.display_status.value
 
-        if hasattr(self.device, "child_lock"):
-            attr["child_lock"] = self.device.child_lock
+        if hasattr(self.device.state, "child_lock"):
+            attr["child_lock"] = self.device.state.child_lock
 
-        if hasattr(self.device, "night_light"):
-            attr["night_light"] = self.device.night_light
+        if hasattr(self.device.state, "nightlight_status"):
+            attr["night_light"] = self.device.state.nightlight_status
 
-        if hasattr(self.device, "mode"):
-            attr["mode"] = self.device.mode
+        if hasattr(self.device.state, "mode"):
+            attr["mode"] = self.device.state.mode
 
         return attr
 
-    def set_percentage(self, percentage: int) -> None:
+    async def async_set_percentage(self, percentage: int) -> None:
         """Set the speed of the device.
 
         If percentage is 0, turn off the fan. Otherwise, ensure the fan is on,
         set manual mode if needed, and set the speed.
         """
-        device_type = SKU_TO_BASE_DEVICE[self.device.device_type]
-        speed_range = SPEED_RANGE[device_type]
-
         if percentage == 0:
             # Turning off is a special case: do not set speed or mode
-            if not self.device.turn_off():
-                raise HomeAssistantError("An error occurred while turning off.")
+            if not await self.device.turn_off():
+                raise HomeAssistantError(
+                    "An error occurred while turning off: "
+                    + self.device.last_response.message
+                )
             self.schedule_update_ha_state()
             return
 
         # If the fan is off, turn it on first
         if not self.device.is_on:
-            if not self.device.turn_on():
-                raise HomeAssistantError("An error occurred while turning on.")
+            if not await self.device.turn_on():
+                raise HomeAssistantError(
+                    "An error occurred while turning on: "
+                    + self.device.last_response.message
+                )
 
         # Switch to manual mode if not already set
-        if self.device.mode != VS_FAN_MODE_MANUAL:
-            if not self.device.manual_mode():
-                raise HomeAssistantError("An error occurred while setting manual mode.")
+        if self.device.state.mode != VS_FAN_MODE_MANUAL:
+            if not await self.device.set_manual_mode():
+                raise HomeAssistantError(
+                    "An error occurred while setting manual mode."
+                    + self.device.last_response.message
+                )
 
         # Calculate the speed level and set it
-        speed_level = math.ceil(percentage_to_ranged_value(speed_range, percentage))
-        if not self.device.change_fan_speed(speed_level):
-            raise HomeAssistantError("An error occurred while changing fan speed.")
+        if not await self.device.set_fan_speed(
+            percentage_to_ordered_list_item(self.device.fan_levels, percentage)
+        ):
+            raise HomeAssistantError(
+                "An error occurred while changing fan speed: "
+                + self.device.last_response.message
+            )
 
         self.schedule_update_ha_state()
 
-    def set_preset_mode(self, preset_mode: str) -> None:
+    async def async_set_preset_mode(self, preset_mode: str) -> None:
         """Set the preset mode of device."""
         if preset_mode not in VS_FAN_MODE_PRESET_LIST_HA:
             raise ValueError(
@@ -206,26 +206,26 @@ class VeSyncFanHA(VeSyncBaseEntity, FanEntity):
             )
 
         if not self.device.is_on:
-            self.device.turn_on()
+            await self.device.turn_on()
 
         if preset_mode == VS_FAN_MODE_AUTO:
-            success = self.device.auto_mode()
+            success = await self.device.auto_mode()
         elif preset_mode == VS_FAN_MODE_SLEEP:
-            success = self.device.sleep_mode()
+            success = await self.device.sleep_mode()
         elif preset_mode == VS_FAN_MODE_ADVANCED_SLEEP:
-            success = self.device.advanced_sleep_mode()
+            success = await self.device.advanced_sleep_mode()
         elif preset_mode == VS_FAN_MODE_PET:
-            success = self.device.pet_mode()
+            success = await self.device.pet_mode()
         elif preset_mode == VS_FAN_MODE_TURBO:
-            success = self.device.turbo_mode()
+            success = await self.device.turbo_mode()
         elif preset_mode == VS_FAN_MODE_NORMAL:
-            success = self.device.normal_mode()
+            success = await self.device.normal_mode()
         if not success:
-            raise HomeAssistantError("An error occurred while setting preset mode.")
+            raise HomeAssistantError(self.device.last_response.message)
 
         self.schedule_update_ha_state()
 
-    def turn_on(
+    async def async_turn_on(
         self,
         percentage: int | None = None,
         preset_mode: str | None = None,
@@ -233,15 +233,15 @@ class VeSyncFanHA(VeSyncBaseEntity, FanEntity):
     ) -> None:
         """Turn the device on."""
         if preset_mode:
-            self.set_preset_mode(preset_mode)
+            await self.async_set_preset_mode(preset_mode)
             return
         if percentage is None:
             percentage = 50
-        self.set_percentage(percentage)
+        await self.async_set_percentage(percentage)
 
-    def turn_off(self, **kwargs: Any) -> None:
+    async def async_turn_off(self, **kwargs: Any) -> None:
         """Turn the device off."""
-        success = self.device.turn_off()
+        success = await self.device.turn_off()
         if not success:
-            raise HomeAssistantError("An error occurred while turning off.")
+            raise HomeAssistantError(self.device.last_response.message)
         self.schedule_update_ha_state()

homeassistant/components/vesync/humidifier.py

@@ -3,7 +3,7 @@
 import logging
 from typing import Any
 
-from pyvesync.vesyncbasedevice import VeSyncBaseDevice
+from pyvesync.base_devices.vesyncbasedevice import VeSyncBaseDevice
 
 from homeassistant.components.humidifier import (
     MODE_AUTO,
@@ -18,7 +18,6 @@ from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .common import is_humidifier
 from .const import (
     DOMAIN,
     VS_COORDINATOR,
@@ -28,7 +27,7 @@ from .const import (
     VS_HUMIDIFIER_MODE_HUMIDITY,
     VS_HUMIDIFIER_MODE_MANUAL,
     VS_HUMIDIFIER_MODE_SLEEP,
-    VeSyncHumidifierDevice,
+    VS_MANAGER,
 )
 from .coordinator import VeSyncDataCoordinator
 from .entity import VeSyncBaseEntity
@@ -36,9 +35,6 @@ from .entity import VeSyncBaseEntity
 _LOGGER = logging.getLogger(__name__)
 
 
-MIN_HUMIDITY = 30
-MAX_HUMIDITY = 80
-
 VS_TO_HA_MODE_MAP = {
     VS_HUMIDIFIER_MODE_AUTO: MODE_AUTO,
     VS_HUMIDIFIER_MODE_HUMIDITY: MODE_AUTO,
@@ -65,7 +61,11 @@ async def async_setup_entry(
         async_dispatcher_connect(hass, VS_DISCOVERY.format(VS_DEVICES), discover)
     )
 
-    _setup_entities(hass.data[DOMAIN][VS_DEVICES], async_add_entities, coordinator)
+    _setup_entities(
+        hass.data[DOMAIN][VS_MANAGER].devices.humidifiers,
+        async_add_entities,
+        coordinator,
+    )
 
 
 @callback
@@ -75,9 +75,7 @@ def _setup_entities(
     coordinator: VeSyncDataCoordinator,
 ):
     """Add humidifier entities."""
-    async_add_entities(
-        VeSyncHumidifierHA(dev, coordinator) for dev in devices if is_humidifier(dev)
-    )
+    async_add_entities(VeSyncHumidifierHA(dev, coordinator) for dev in devices)
 
 
 def _get_ha_mode(vs_mode: str) -> str | None:
@@ -93,12 +91,8 @@ class VeSyncHumidifierHA(VeSyncBaseEntity, HumidifierEntity):
     # The base VeSyncBaseEntity has _attr_has_entity_name and this is to follow the device name
     _attr_name = None
 
-    _attr_max_humidity = MAX_HUMIDITY
-    _attr_min_humidity = MIN_HUMIDITY
     _attr_supported_features = HumidifierEntityFeature.MODES
 
-    device: VeSyncHumidifierDevice
-
     def __init__(
         self,
         device: VeSyncBaseDevice,
@@ -113,6 +107,8 @@ class VeSyncHumidifierHA(VeSyncBaseEntity, HumidifierEntity):
 
         self._ha_to_vs_mode_map: dict[str, str] = {}
         self._available_modes: list[str] = []
+        self._attr_max_humidity = max(device.target_minmax)
+        self._attr_min_humidity = min(device.target_minmax)
 
         # Populate maps once.
         for vs_mode in self.device.mist_modes:
@@ -134,37 +130,39 @@ class VeSyncHumidifierHA(VeSyncBaseEntity, HumidifierEntity):
     @property
     def current_humidity(self) -> int:
         """Return the current humidity."""
-        return self.device.humidity
+        return self.device.state.humidity
 
     @property
     def target_humidity(self) -> int:
         """Return the humidity we try to reach."""
-        return self.device.auto_humidity
+        return self.device.state.auto_humidity
 
     @property
     def mode(self) -> str | None:
         """Get the current preset mode."""
-        return None if self.device.mode is None else _get_ha_mode(self.device.mode)
+        return (
+            None
+            if self.device.state.mode is None
+            else _get_ha_mode(self.device.state.mode)
+        )
 
-    def set_humidity(self, humidity: int) -> None:
+    async def async_set_humidity(self, humidity: int) -> None:
         """Set the target humidity of the device."""
-        if not self.device.set_humidity(humidity):
-            raise HomeAssistantError(
-                f"An error occurred while setting humidity {humidity}."
-            )
+        if not await self.device.set_humidity(humidity):
+            raise HomeAssistantError(self.device.last_response.message)
 
-    def set_mode(self, mode: str) -> None:
+    async def async_set_mode(self, mode: str) -> None:
         """Set the mode of the device."""
         if mode not in self.available_modes:
             raise HomeAssistantError(
-                f"{mode} is not one of the valid available modes: {self.available_modes}"
+                f"Invalid mode {mode}. Available modes: {self.available_modes}"
             )
-        if not self.device.set_humidity_mode(self._get_vs_mode(mode)):
-            raise HomeAssistantError(f"An error occurred while setting mode {mode}.")
+        if not await self.device.set_humidity_mode(self._get_vs_mode(mode)):
+            raise HomeAssistantError(self.device.last_response.message)
 
         if mode == MODE_SLEEP:
             # We successfully changed the mode. Consider it a success even if display operation fails.
-            self.device.set_display(False)
+            await self.device.toggle_display(False)
 
         # Changing mode while humidifier is off actually turns it on, as per the app. But
         # the library does not seem to update the device_status. It is also possible that
@@ -172,23 +170,23 @@ class VeSyncHumidifierHA(VeSyncBaseEntity, HumidifierEntity):
         # updated.
         self.schedule_update_ha_state(force_refresh=True)
 
-    def turn_on(self, **kwargs: Any) -> None:
+    async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the device on."""
-        success = self.device.turn_on()
+        success = await self.device.turn_on()
         if not success:
-            raise HomeAssistantError("An error occurred while turning on.")
+            raise HomeAssistantError(self.device.last_response.message)
 
         self.schedule_update_ha_state()
 
-    def turn_off(self, **kwargs: Any) -> None:
+    async def async_turn_off(self, **kwargs: Any) -> None:
         """Turn the device off."""
-        success = self.device.turn_off()
+        success = await self.device.turn_off()
         if not success:
-            raise HomeAssistantError("An error occurred while turning off.")
+            raise HomeAssistantError(self.device.last_response.message)
 
         self.schedule_update_ha_state()
 
     @property
     def is_on(self) -> bool:
         """Return True if device is on."""
-        return self.device.device_status == "on"
+        return self.device.state.device_status == "on"

homeassistant/components/vesync/light.py

@@ -3,7 +3,9 @@
 import logging
 from typing import Any
 
-from pyvesync.vesyncbasedevice import VeSyncBaseDevice
+from pyvesync.base_devices.bulb_base import VeSyncBulb
+from pyvesync.base_devices.switch_base import VeSyncSwitch
+from pyvesync.base_devices.vesyncbasedevice import VeSyncBaseDevice
 
 from homeassistant.components.light import (
     ATTR_BRIGHTNESS,
@@ -17,7 +19,7 @@ from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import color as color_util
 
-from .const import DEV_TYPE_TO_HA, DOMAIN, VS_COORDINATOR, VS_DEVICES, VS_DISCOVERY
+from .const import DOMAIN, VS_COORDINATOR, VS_DEVICES, VS_DISCOVERY, VS_MANAGER
 from .coordinator import VeSyncDataCoordinator
 from .entity import VeSyncBaseEntity
 
@@ -44,7 +46,9 @@ async def async_setup_entry(
         async_dispatcher_connect(hass, VS_DISCOVERY.format(VS_DEVICES), discover)
     )
 
-    _setup_entities(hass.data[DOMAIN][VS_DEVICES], async_add_entities, coordinator)
+    _setup_entities(
+        hass.data[DOMAIN][VS_MANAGER].devices, async_add_entities, coordinator
+    )
 
 
 @callback
@@ -56,10 +60,13 @@ def _setup_entities(
     """Check if device is a light and add entity."""
     entities: list[VeSyncBaseLightHA] = []
     for dev in devices:
-        if DEV_TYPE_TO_HA.get(dev.device_type) in ("walldimmer", "bulb-dimmable"):
+        if isinstance(dev, VeSyncBulb):
+            if dev.supports_color_temp:
+                entities.append(VeSyncTunableWhiteLightHA(dev, coordinator))
+            elif dev.supports_brightness:
+                entities.append(VeSyncDimmableLightHA(dev, coordinator))
+        elif isinstance(dev, VeSyncSwitch) and dev.supports_dimmable:
             entities.append(VeSyncDimmableLightHA(dev, coordinator))
-        elif DEV_TYPE_TO_HA.get(dev.device_type) in ("bulb-tunable-white",):
-            entities.append(VeSyncTunableWhiteLightHA(dev, coordinator))
 
     async_add_entities(entities, update_before_add=True)
 
@@ -72,13 +79,13 @@ class VeSyncBaseLightHA(VeSyncBaseEntity, LightEntity):
     @property
     def is_on(self) -> bool:
         """Return True if device is on."""
-        return self.device.device_status == "on"
+        return self.device.state.device_status == "on"
 
     @property
     def brightness(self) -> int:
         """Get light brightness."""
         # get value from pyvesync library api,
-        result = self.device.brightness
+        result = self.device.state.brightness
         try:
             # check for validity of brightness value received
             brightness_value = int(result)
@@ -92,7 +99,7 @@ class VeSyncBaseLightHA(VeSyncBaseEntity, LightEntity):
         # convert percent brightness to ha expected range
         return round((max(1, brightness_value) / 100) * 255)
 
-    def turn_on(self, **kwargs: Any) -> None:
+    async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the device on."""
         attribute_adjustment_only = False
         # set white temperature
@@ -112,7 +119,7 @@ class VeSyncBaseLightHA(VeSyncBaseEntity, LightEntity):
             # ensure value between 0-100
             color_temp = max(0, min(color_temp, 100))
             # call pyvesync library api method to set color_temp
-            self.device.set_color_temp(color_temp)
+            await self.device.set_color_temp(color_temp)
             # flag attribute_adjustment_only, so it doesn't turn_on the device redundantly
             attribute_adjustment_only = True
         # set brightness level
@@ -129,7 +136,7 @@ class VeSyncBaseLightHA(VeSyncBaseEntity, LightEntity):
             # ensure value between 1-100
             brightness = max(1, min(brightness, 100))
             # call pyvesync library api method to set brightness
-            self.device.set_brightness(brightness)
+            await self.device.set_brightness(brightness)
             # flag attribute_adjustment_only, so it doesn't
             # turn_on the device redundantly
             attribute_adjustment_only = True
@@ -137,11 +144,11 @@ class VeSyncBaseLightHA(VeSyncBaseEntity, LightEntity):
         if attribute_adjustment_only:
             return
         # send turn_on command to pyvesync api
-        self.device.turn_on()
+        await self.device.turn_on()
 
-    def turn_off(self, **kwargs: Any) -> None:
+    async def async_turn_off(self, **kwargs: Any) -> None:
         """Turn the device off."""
-        self.device.turn_off()
+        await self.device.turn_off()
 
 
 class VeSyncDimmableLightHA(VeSyncBaseLightHA, LightEntity):
@@ -162,8 +169,9 @@ class VeSyncTunableWhiteLightHA(VeSyncBaseLightHA, LightEntity):
     @property
     def color_temp_kelvin(self) -> int | None:
         """Return the color temperature value in Kelvin."""
-        # get value from pyvesync library api,
-        result = self.device.color_temp_pct
+        # get value from pyvesync library api
+        # pyvesync v3 provides BulbState.color_temp_kelvin() - possible to use that instead?
+        result = self.device.state.color_temp
         try:
             # check for validity of brightness value received
             color_temp_value = int(result)

homeassistant/components/vesync/manifest.json

@@ -6,11 +6,12 @@
     "@webdjoe",
     "@thegardenmonkey",
     "@cdnninja",
-    "@iprak"
+    "@iprak",
+    "@sapuseven"
   ],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/vesync",
   "iot_class": "cloud_polling",
-  "loggers": ["pyvesync.vesync"],
-  "requirements": ["pyvesync==2.1.18"]
+  "loggers": ["pyvesync"],
+  "requirements": ["pyvesync==3.0.0"]
 }

homeassistant/components/vesync/number.py

@@ -1,10 +1,10 @@
 """Support for VeSync numeric entities."""
 
-from collections.abc import Callable
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 import logging
 
-from pyvesync.vesyncbasedevice import VeSyncBaseDevice
+from pyvesync.base_devices.vesyncbasedevice import VeSyncBaseDevice
 
 from homeassistant.components.number import (
     NumberEntity,
@@ -13,11 +13,12 @@ from homeassistant.components.number import (
 )
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .common import is_humidifier
-from .const import DOMAIN, VS_COORDINATOR, VS_DEVICES, VS_DISCOVERY
+from .const import DOMAIN, VS_COORDINATOR, VS_DEVICES, VS_DISCOVERY, VS_MANAGER
 from .coordinator import VeSyncDataCoordinator
 from .entity import VeSyncBaseEntity
 
@@ -28,22 +29,24 @@ _LOGGER = logging.getLogger(__name__)
 class VeSyncNumberEntityDescription(NumberEntityDescription):
     """Class to describe a Vesync number entity."""
 
-    exists_fn: Callable[[VeSyncBaseDevice], bool]
+    exists_fn: Callable[[VeSyncBaseDevice], bool] = lambda _: True
     value_fn: Callable[[VeSyncBaseDevice], float]
-    set_value_fn: Callable[[VeSyncBaseDevice, float], bool]
+    native_min_value_fn: Callable[[VeSyncBaseDevice], float]
+    native_max_value_fn: Callable[[VeSyncBaseDevice], float]
+    set_value_fn: Callable[[VeSyncBaseDevice, float], Awaitable[bool]]
 
 
 NUMBER_DESCRIPTIONS: list[VeSyncNumberEntityDescription] = [
     VeSyncNumberEntityDescription(
         key="mist_level",
         translation_key="mist_level",
-        native_min_value=1,
-        native_max_value=9,
+        native_min_value_fn=lambda device: min(device.mist_levels),
+        native_max_value_fn=lambda device: max(device.mist_levels),
         native_step=1,
         mode=NumberMode.SLIDER,
         exists_fn=is_humidifier,
         set_value_fn=lambda device, value: device.set_mist_level(value),
-        value_fn=lambda device: device.mist_level,
+        value_fn=lambda device: device.state.mist_level,
     )
 ]
 
@@ -66,7 +69,9 @@ async def async_setup_entry(
         async_dispatcher_connect(hass, VS_DISCOVERY.format(VS_DEVICES), discover)
     )
 
-    _setup_entities(hass.data[DOMAIN][VS_DEVICES], async_add_entities, coordinator)
+    _setup_entities(
+        hass.data[DOMAIN][VS_MANAGER].devices, async_add_entities, coordinator
+    )
 
 
 @callback
@@ -106,9 +111,18 @@ class VeSyncNumberEntity(VeSyncBaseEntity, NumberEntity):
         """Return the value reported by the number."""
         return self.entity_description.value_fn(self.device)
 
+    @property
+    def native_min_value(self) -> float:
+        """Return the value reported by the number."""
+        return self.entity_description.native_min_value_fn(self.device)
+
+    @property
+    def native_max_value(self) -> float:
+        """Return the value reported by the number."""
+        return self.entity_description.native_max_value_fn(self.device)
+
     async def async_set_native_value(self, value: float) -> None:
         """Set new value."""
-        if await self.hass.async_add_executor_job(
-            self.entity_description.set_value_fn, self.device, value
-        ):
-            await self.coordinator.async_request_refresh()
+        if not await self.entity_description.set_value_fn(self.device, value):
+            raise HomeAssistantError(self.device.last_response.message)
+        self.schedule_update_ha_state()