pyvesync 3.0.0b0__py3-none-any.whl

pyvesync/devices/vesynchumidifier.py

@@ -0,0 +1,785 @@
+"""VeSync Humidifier Devices."""
+from __future__ import annotations
+import logging
+from typing import TYPE_CHECKING
+from typing_extensions import deprecated
+import orjson
+
+from pyvesync.base_devices import VeSyncHumidifier
+from pyvesync.utils.helpers import Helpers, Validators, Timer
+from pyvesync.utils.device_mixins import BypassV2Mixin, process_bypassv2_result
+from pyvesync.const import DeviceStatus, IntFlag, ConnectionStatus
+from pyvesync.models.bypass_models import ResultV2GetTimer, ResultV2SetTimer
+from pyvesync.models.humidifier_models import (
+    ClassicLVHumidResult,
+    Levoit1000SResult,
+    InnerHumidifierBaseResult,
+    Superior6000SResult,
+)
+
+if TYPE_CHECKING:
+    from pyvesync import VeSync
+    from pyvesync.models.vesync_models import ResponseDeviceDetailsModel
+    from pyvesync.device_map import (
+        HumidifierMap
+        )
+
+
+logger = logging.getLogger(__name__)
+
+
+class VeSyncHumid200300S(BypassV2Mixin, VeSyncHumidifier):
+    """300S Humidifier Class.
+
+    Primary class for VeSync humidifier devices.
+
+    Args:
+        details (ResponseDeviceDetailsModel): The device details.
+        manager (VeSync): The manager object for API calls.
+        feature_map (HumidifierMap): The feature map for the device.
+
+    Attributes:
+        state (HumidifierState): The state of the humidifier.
+        last_response (ResponseInfo): Last response info from API call.
+        manager (VeSync): Manager object for API calls.
+        device_name (str): Name of device.
+        device_image (str): URL for device image.
+        cid (str): Device ID.
+        connection_type (str): Connection type of device.
+        device_type (str): Type of device.
+        type (str): Type of device.
+        uuid (str): UUID of device, not always present.
+        config_module (str): Configuration module of device.
+        mac_id (str): MAC ID of device.
+        current_firm_version (str): Current firmware version of device.
+        device_region (str): Region of device. (US, EU, etc.)
+        pid (str): Product ID of device, pulled by some devices on update.
+        sub_device_no (int): Sub-device number of device.
+        product_type (str): Product type of device.
+        features (dict): Features of device.
+        mist_levels (list): List of mist levels.
+        mist_modes (list): List of mist modes.
+        target_minmax (tuple): Tuple of target min and max values.
+        warm_mist_levels (list): List of warm mist levels.
+    """
+
+    __slots__ = ()
+
+    def __init__(self, details: ResponseDeviceDetailsModel,
+                 manager: VeSync, feature_map: HumidifierMap) -> None:
+        """Initialize 200S/300S Humidifier class."""
+        super().__init__(details, manager, feature_map)
+
+    def _set_state(self, resp_model: ClassicLVHumidResult) -> None:
+        """Set state from get_details API model."""
+        self.state.connection_status = ConnectionStatus.ONLINE
+        self.state.device_status = DeviceStatus.from_bool(resp_model.enabled)
+        self.state.mode = resp_model.mode
+        self.state.humidity = resp_model.humidity or IntFlag.NOT_SUPPORTED
+        self.state.mist_virtual_level = resp_model.mist_virtual_level or 0
+        self.state.mist_level = resp_model.mist_level or 0
+        self.state.water_lacks = resp_model.water_lacks
+        self.state.humidity_high = resp_model.humidity_high
+        self.state.water_tank_lifted = resp_model.water_tank_lifted
+        self.state.auto_stop_target_reached = resp_model.automatic_stop_reach_target
+        if (
+            self.supports_nightlight
+            and resp_model.night_light_brightness != IntFlag.NOT_SUPPORTED
+        ):
+            self.state.nightlight_brightness = resp_model.night_light_brightness
+            self.state.nightlight_status = (
+                DeviceStatus.ON
+                if resp_model.night_light_brightness > 0
+                else DeviceStatus.OFF
+            )
+        self.state.display_status = DeviceStatus.from_bool(resp_model.display)
+        if self.supports_warm_mist and resp_model.warm_level != IntFlag.NOT_SUPPORTED:
+            self.state.warm_mist_level = resp_model.warm_level
+            self.state.warm_mist_enabled = resp_model.warm_enabled
+        config = resp_model.configuration
+        if config is not None:
+            self.state.auto_target_humidity = config.auto_target_humidity
+            self.state.automatic_stop_config = config.automatic_stop
+            self.state.display_set_status = DeviceStatus.from_bool(config.display)
+
+    async def get_details(self) -> None:
+        r_dict = await self.call_bypassv2_api("getHumidifierStatus")
+        r_model = process_bypassv2_result(
+            self, logger, 'get_details', r_dict, ClassicLVHumidResult
+            )
+        if r_model is None:
+            return
+        self._set_state(r_model)
+
+    async def toggle_switch(self, toggle: bool | None = None) -> bool:
+        if toggle is None:
+            toggle = self.state.device_status == DeviceStatus.ON
+
+        payload_data = {'enabled': toggle, 'id': 0}
+        r_dict = await self.call_bypassv2_api("setSwitch", payload_data)
+        r = Helpers.process_dev_response(logger, "toggle_switch", self, r_dict)
+        if r is None:
+            return False
+
+        self.state.device_status = DeviceStatus.from_bool(toggle)
+        self.state.connection_status = ConnectionStatus.ONLINE
+        return True
+
+    async def get_timer(self) -> Timer | None:
+        r_dict = await self.call_bypassv2_api("getTimer")
+        result_model = process_bypassv2_result(
+            self, logger, "get_timer", r_dict, ResultV2GetTimer
+        )
+        if result_model is None:
+            return None
+        if not result_model.timers:
+            logger.debug("No timers found")
+            return None
+        timer = result_model.timers[0]
+        self.state.timer = Timer(
+            timer_duration=timer.total,
+            action=timer.action,
+            id=timer.id,
+        )
+        return self.state.timer
+
+    async def clear_timer(self) -> bool:
+        if self.state.timer is None:
+            logger.debug("No timer to clear, run get_timer() first.")
+            return False
+        payload = {
+            "id": self.state.timer.id,
+        }
+        r_dict = await self.call_bypassv2_api("delTimer", payload)
+        r = Helpers.process_dev_response(logger, "clear_timer", self, r_dict)
+        if r is None:
+            return False
+        self.state.timer = None
+        return True
+
+    async def set_timer(self, duration: int, action: str | None = None) -> bool:
+        if action is None:
+            action = (
+                DeviceStatus.OFF
+                if self.state.device_status == DeviceStatus.ON
+                else DeviceStatus.ON
+            )
+        payload_data = {
+            "action": str(action),
+            "total": duration,
+        }
+        r_dict = await self.call_bypassv2_api("addTimer", payload_data)
+        r = process_bypassv2_result(self, logger, "set_timer", r_dict, ResultV2SetTimer)
+        if r is None:
+            return False
+
+        self.state.timer = Timer(
+            timer_duration=duration, action=action, id=r.id, remaining=0
+        )
+        return True
+
+    @deprecated("Use turn_on_automatic_stop() instead.")
+    async def automatic_stop_on(self) -> bool:
+        """Turn 200S/300S Humidifier automatic stop on."""
+        return await self.toggle_automatic_stop(True)
+
+    @deprecated("Use turn_off_automatic_stop() instead.")
+    async def automatic_stop_off(self) -> bool:
+        """Turn 200S/300S Humidifier automatic stop on."""
+        return await self.toggle_automatic_stop(False)
+
+    @deprecated("Use toggle_automatic_stop(toggle: bool) instead.")
+    async def set_automatic_stop(self, mode: bool) -> bool:
+        """Set 200S/300S Humidifier to automatic stop."""
+        return await self.toggle_automatic_stop(mode)
+
+    async def toggle_automatic_stop(self, toggle: bool | None = None) -> bool:
+        if toggle is None:
+            toggle = self.state.automatic_stop_config != DeviceStatus.ON
+
+        payload_data = {'enabled': toggle}
+        r_dict = await self.call_bypassv2_api("setAutomaticStop", payload_data)
+        r = Helpers.process_dev_response(logger, "set_automatic_stop", self, r_dict)
+        if r is None:
+            return False
+        self.state.automatic_stop_config = toggle
+        self.state.connection_status = ConnectionStatus.ONLINE
+        return True
+
+    @deprecated("Use toggle_display(toggle: bool) instead.")
+    async def set_display(self, toggle: bool) -> bool:
+        """Deprecated method to toggle display on/off.
+
+        Use toggle_display(toggle: bool) instead.
+        """
+        return await self.toggle_display(toggle)
+
+    async def toggle_display(self, toggle: bool) -> bool:
+        payload_data = {'state': toggle}
+        r_dict = await self.call_bypassv2_api("setDisplay", payload_data)
+        r = Helpers.process_dev_response(logger, "set_display", self, r_dict)
+        if r is None:
+            return False
+        self.state.display_set_status = DeviceStatus.from_bool(toggle)
+        self.state.connection_status = ConnectionStatus.ONLINE
+        return True
+
+    async def set_humidity(self, humidity: int) -> bool:
+        if not Validators.validate_range(humidity, *self.target_minmax):
+            logger.debug(
+                "Invalid humidity, must be between %s and %s", *self.target_minmax
+            )
+            return False
+
+        payload_data = {"target_humidity": humidity}
+        r_dict = await self.call_bypassv2_api("setTargetHumidity", payload_data)
+        r = Helpers.process_dev_response(logger, "set_humidity", self, r_dict)
+        if r is None:
+            return False
+        self.state.auto_target_humidity = humidity
+        self.state.connection_status = ConnectionStatus.ONLINE
+        return True
+
+    async def set_nightlight_brightness(self, brightness: int) -> bool:
+        if not self.supports_nightlight:
+            logger.debug('%s is a %s does not have a nightlight',
+                         self.device_name, self.device_type)
+            return False
+
+        if Validators.validate_zero_to_hundred(brightness):
+            logger.debug("Brightness value must be set between 0 and 100")
+            return False
+
+        payload_data = {"night_light_brightness": brightness}
+        r_dict = await self.call_bypassv2_api("setNightLightBrightness", payload_data)
+        r = Helpers.process_dev_response(
+            logger, "set_night_light_brightness", self, r_dict
+            )
+        if r is None:
+            return False
+        self.state.nightlight_brightness = brightness
+        self.state.nightlight_status = (
+            DeviceStatus.ON if brightness > 0 else DeviceStatus.OFF
+        )
+        return True
+
+    @deprecated("Use set_mode(mode: str) instead.")
+    async def set_humidity_mode(self, mode: str) -> bool:
+        """Deprecated method to set humidifier mode.
+
+        Use `set_mode(mode: str)` instead.
+        """
+        return await self.set_mode(mode)
+
+    async def set_mode(self, mode: str) -> bool:
+        if mode.lower() not in self.mist_modes:
+            logger.debug("Invalid humidity mode used - %s", mode)
+            logger.debug(
+                "Proper modes for this device are - %s",
+                orjson.dumps(
+                    self.mist_modes, option=orjson.OPT_INDENT_2 | orjson.OPT_NON_STR_KEYS
+                ),
+            )
+            return False
+
+        payload_data = {"mode": self.mist_modes[mode.lower()]}
+        r_dict = await self.call_bypassv2_api("setHumidityMode", payload_data)
+        r = Helpers.process_dev_response(logger, "set_humidity_mode", self, r_dict)
+        if r is None:
+            return False
+
+        self.state.mode = mode
+        self.state.connection_status = ConnectionStatus.ONLINE
+        return True
+
+    async def set_warm_level(self, warm_level: int) -> bool:
+        if not self.supports_warm_mist:
+            logger.debug('%s is a %s does not have a mist warmer',
+                         self.device_name, self.device_type)
+            return False
+
+        if warm_level not in self.warm_mist_levels:
+            logger.debug("warm_level value must be - %s",
+                         str(self.warm_mist_levels))
+            return False
+
+        payload_data = {"type": "warm", "level": warm_level, "id": 0}
+        r_dict = await self.call_bypassv2_api("setVirtualLevel", payload_data)
+        r = Helpers.process_dev_response(logger, "set_warm_level", self, r_dict)
+        if r is None:
+            return False
+
+        self.state.warm_mist_level = warm_level
+        self.state.warm_mist_enabled = True
+        self.state.connection_status = ConnectionStatus.ONLINE
+        return True
+
+    async def set_mist_level(self, level: int) -> bool:
+        if level not in self.mist_levels:
+            logger.debug(
+                "Humidifier mist level must be between %s and %s",
+                self.mist_levels[0],
+                self.mist_levels[-1],
+            )
+            return False
+
+        payload_data = {"id": 0, "level": level, "type": "mist"}
+        r_dict = await self.call_bypassv2_api("setVirtualLevel", payload_data)
+        r = Helpers.process_dev_response(logger, "set_mist_level", self, r_dict)
+        if r is None:
+            return False
+
+        self.state.mist_virtual_level = level
+        self.state.mist_level = level
+        self.state.connection_status = ConnectionStatus.ONLINE
+        return True
+
+
+class VeSyncHumid200S(VeSyncHumid200300S):
+    """Levoit Classic 200S Specific class.
+
+    Overrides the `toggle_display(toggle: bool)` method of the
+    VeSyncHumid200300S class.
+
+    Args:
+        details (ResponseDeviceDetailsModel): The device details.
+        manager (VeSync): The manager object for API calls.
+        feature_map (HumidifierMap): The feature map for the device.
+
+    Attributes:
+        state (HumidifierState): The state of the humidifier.
+        last_response (ResponseInfo): Last response from API call.
+        manager (VeSync): Manager object for API calls.
+        device_name (str): Name of device.
+        device_image (str): URL for device image.
+        cid (str): Device ID.
+        connection_type (str): Connection type of device.
+        device_type (str): Type of device.
+        type (str): Type of device.
+        uuid (str): UUID of device, not always present.
+        config_module (str): Configuration module of device.
+        mac_id (str): MAC ID of device.
+        current_firm_version (str): Current firmware version of device.
+        device_region (str): Region of device. (US, EU, etc.)
+        pid (str): Product ID of device, pulled by some devices on update.
+        sub_device_no (int): Sub-device number of device.
+        product_type (str): Product type of device.
+        features (dict): Features of device.
+        mist_levels (list): List of mist levels.
+        mist_modes (list): List of mist modes.
+        target_minmax (tuple): Tuple of target min and max values.
+        warm_mist_levels (list): List of warm mist levels.
+    """
+
+    def __init__(self, details: ResponseDeviceDetailsModel,
+                 manager: VeSync, feature_map: HumidifierMap) -> None:
+        """Initialize levoit 200S device class.
+
+        This overrides the `toggle_display(toggle: bool)` method of the
+        VeSyncHumid200300S class.
+        """
+        super().__init__(details, manager, feature_map)
+
+    async def toggle_display(self, toggle: bool) -> bool:
+        payload_data = {"enabled": toggle, "id": 0}
+        r_dict = await self.call_bypassv2_api("setIndicatorLightSwitch", payload_data)
+        r = Helpers.process_dev_response(logger, "toggle_display", self, r_dict)
+        if r is None:
+            return False
+
+        self.state.display_set_status = DeviceStatus.from_bool(toggle)
+        self.state.connection_status = ConnectionStatus.ONLINE
+        return True
+
+
+class VeSyncSuperior6000S(BypassV2Mixin, VeSyncHumidifier):
+    """Superior 6000S Humidifier.
+
+    Args:
+        details (ResponseDeviceDetailsModel): The device details.
+        manager (VeSync): The manager object for API calls.
+        feature_map (HumidifierMap): The feature map for the device.
+
+    Attributes:
+        state (HumidifierState): The state of the humidifier.
+        last_response (ResponseInfo): Last response from API call.
+        manager (VeSync): Manager object for API calls.
+        device_name (str): Name of device.
+        device_image (str): URL for device image.
+        cid (str): Device ID.
+        connection_type (str): Connection type of device.
+        device_type (str): Type of device.
+        type (str): Type of device.
+        uuid (str): UUID of device, not always present.
+        config_module (str): Configuration module of device.
+        mac_id (str): MAC ID of device.
+        current_firm_version (str): Current firmware version of device.
+        device_region (str): Region of device. (US, EU, etc.)
+        pid (str): Product ID of device, pulled by some devices on update.
+        sub_device_no (int): Sub-device number of device.
+        product_type (str): Product type of device.
+        features (dict): Features of device.
+        mist_levels (list): List of mist levels.
+        mist_modes (list): List of mist modes.
+        target_minmax (tuple): Tuple of target min and max values.
+        warm_mist_levels (list): List of warm mist levels.
+    """
+
+    def __init__(self, details: ResponseDeviceDetailsModel,
+                 manager: VeSync, feature_map: HumidifierMap) -> None:
+        """Initialize Superior 6000S Humidifier class."""
+        super().__init__(details, manager, feature_map)
+
+    def _set_state(self, resp_model: Superior6000SResult) -> None:
+        """Set state from Superior 6000S API result model."""
+        self.state.device_status = DeviceStatus.from_int(resp_model.powerSwitch)
+        self.state.connection_status = ConnectionStatus.ONLINE
+        self.state.mode = resp_model.workMode
+        self.state.auto_target_humidity = resp_model.targetHumidity
+        self.state.mist_level = resp_model.mistLevel
+        self.state.mist_virtual_level = resp_model.virtualLevel
+        self.state.water_lacks = bool(resp_model.waterLacksState)
+        self.state.water_tank_lifted = bool(resp_model.waterTankLifted)
+        self.state.automatic_stop_config = bool(resp_model.autoStopSwitch)
+        self.state.auto_stop_target_reached = bool(resp_model.autoStopState)
+        self.state.display_set_status = DeviceStatus.from_int(resp_model.screenSwitch)
+        self.state.display_status = DeviceStatus.from_int(resp_model.screenState)
+        self.state.auto_preference = resp_model.autoPreference
+        self.state.filter_life_percent = resp_model.filterLifePercent
+        self.state.temperature = resp_model.temperature  # Unknown units
+
+        drying_mode = resp_model.dryingMode
+        if drying_mode is not None:
+            self.state.drying_mode_status = DeviceStatus.from_int(drying_mode.dryingState)
+            self.state.drying_mode_level = drying_mode.dryingLevel
+            self.state.drying_mode_auto_switch = DeviceStatus.from_int(
+                drying_mode.autoDryingSwitch
+                )
+
+        if resp_model.timerRemain > 0:
+            self.state.timer = Timer(
+                resp_model.timerRemain,
+                DeviceStatus.from_bool(self.state.device_status != DeviceStatus.ON)
+            )
+
+    async def get_details(self) -> None:
+        r_dict = await self.call_bypassv2_api("getHumidifierStatus")
+        r_model = process_bypassv2_result(
+            self, logger, "get_details", r_dict, Superior6000SResult
+        )
+        if r_model is None:
+            return
+
+        self._set_state(r_model)
+
+    async def toggle_switch(self, toggle: bool | None = None) -> bool:
+        if toggle is None:
+            toggle = self.state.device_status != DeviceStatus.ON
+
+        payload_data = {"powerSwitch": int(toggle), "switchIdx": 0}
+        r_dict = await self.call_bypassv2_api("setSwitch", payload_data)
+        r = Helpers.process_dev_response(logger, "toggle_switch", self, r_dict)
+        if r is None:
+            return False
+
+        self.state.device_status = DeviceStatus.from_bool(toggle)
+        self.state.connection_status = ConnectionStatus.ONLINE
+        return True
+
+    async def toggle_automatic_stop(self, toggle: bool | None = None) -> bool:
+        if toggle is None:
+            toggle = self.state.automatic_stop_config is not True
+
+        payload_data = {"autoStopSwitch": int(toggle)}
+        r_dict = await self.call_bypassv2_api("setAutoStopSwitch", payload_data)
+        r = Helpers.process_dev_response(logger, "toggle_automatic_stop", self, r_dict)
+        if r is None:
+            return False
+
+        self.state.device_status = DeviceStatus.from_bool(toggle)
+        self.state.connection_status = ConnectionStatus.ONLINE
+        return True
+
+    @deprecated("Use toggle_drying_mode() instead.")
+    async def set_drying_mode_enabled(self, mode: bool) -> bool:
+        """Set drying mode on/off."""
+        return await self.toggle_drying_mode(mode)
+
+    async def toggle_drying_mode(self, toggle: bool | None = None) -> bool:
+        if toggle is None:
+            toggle = self.state.drying_mode_status != DeviceStatus.ON
+
+        payload_data = {"autoDryingSwitch": int(toggle)}
+        r_dict = await self.call_bypassv2_api("setDryingMode", payload_data)
+        r = Helpers.process_dev_response(logger, "set_drying_mode_enabled", self, r_dict)
+        if r is None:
+            return False
+
+        self.state.connection_status = ConnectionStatus.ONLINE
+        self.state.drying_mode_auto_switch = DeviceStatus.from_bool(toggle)
+        return True
+
+    @deprecated("Use toggle_display() instead.")
+    async def set_display_enabled(self, mode: bool) -> bool:
+        """Set display on/off.
+
+        Deprecated method, please use toggle_display() instead.
+        """
+        return await self.toggle_display(mode)
+
+    async def toggle_display(self, toggle: bool | None = None) -> bool:
+        if toggle is None:
+            toggle = self.state.display_set_status != DeviceStatus.ON
+
+        payload_data = {"screenSwitch": int(toggle)}
+        r_dict = await self.call_bypassv2_api("setDisplay", payload_data)
+        r = Helpers.process_dev_response(logger, "set_display", self, r_dict)
+        if r is None:
+            return False
+
+        self.state.display_set_status = DeviceStatus.from_bool(toggle)
+        self.state.connection_status = ConnectionStatus.ONLINE
+        return True
+
+    async def set_humidity(self, humidity: int) -> bool:
+        if Validators.validate_range(humidity, *self.target_minmax):
+            logger.debug("Humidity value must be set between 30 and 80")
+            return False
+
+        payload_data = {"targetHumidity": humidity}
+        r_dict = await self.call_bypassv2_api("setTargetHumidity", payload_data)
+        r = Helpers.process_dev_response(logger, "set_humidity", self, r_dict)
+        if r is None:
+            return False
+
+        self.state.auto_target_humidity = humidity
+        self.state.connection_status = ConnectionStatus.ONLINE
+        return True
+
+    @deprecated("Use set_mode(mode: str) instead.")
+    async def set_humidity_mode(self, mode: str) -> bool:
+        """Set humidifier mode."""
+        return await self.set_mode(mode)
+
+    async def set_mode(self, mode: str) -> bool:
+        if mode.lower() not in self.mist_modes:
+            logger.debug('Invalid humidity mode used - %s',
+                         mode)
+            logger.debug(
+                "Proper modes for this device are - %s",
+                orjson.dumps(
+                    self.mist_modes, option=orjson.OPT_INDENT_2 | orjson.OPT_NON_STR_KEYS
+                ),
+            )
+            return False
+
+        payload_data = {"workMode": self.mist_modes[mode.lower()]}
+        r_dict = await self.call_bypassv2_api("setHumidityMode", payload_data)
+
+        r = Helpers.process_dev_response(logger, "set_humidity_mode", self, r_dict)
+        if r is None:
+            return False
+        self.state.mode = mode
+        self.state.connection_status = ConnectionStatus.ONLINE
+        return True
+
+    async def set_mist_level(self, level: int) -> bool:
+        if level not in self.mist_levels:
+            logger.debug("Humidifier mist level must be between 0 and 9")
+            return False
+
+        payload_data = {"levelIdx": 0, "virtualLevel": level, "levelType": "mist"}
+        r_dict = await self.call_bypassv2_api("setVirtualLevel", payload_data)
+        r = Helpers.process_dev_response(logger, "set_mist_level", self, r_dict)
+        if r is None:
+            return False
+
+        self.state.mist_level = level
+        self.state.mist_virtual_level = level
+        self.state.connection_status = ConnectionStatus.ONLINE
+        return True
+
+
+class VeSyncHumid1000S(VeSyncHumid200300S):
+    """Levoit OasisMist 1000S Specific class.
+
+    Args:
+        details (ResponseDeviceDetailsModel): The device details.
+        manager (VeSync): The manager object for API calls.
+        feature_map (HumidifierMap): The feature map for the device.
+
+    Attributes:
+        state (HumidifierState): The state of the humidifier.
+        last_response (ResponseInfo): Last response from API call.
+        manager (VeSync): Manager object for API calls.
+        device_name (str): Name of device.
+        device_image (str): URL for device image.
+        cid (str): Device ID.
+        connection_type (str): Connection type of device.
+        device_type (str): Type of device.
+        type (str): Type of device.
+        uuid (str): UUID of device, not always present.
+        config_module (str): Configuration module of device.
+        mac_id (str): MAC ID of device.
+        current_firm_version (str): Current firmware version of device.
+        device_region (str): Region of device. (US, EU, etc.)
+        pid (str): Product ID of device, pulled by some devices on update.
+        sub_device_no (int): Sub-device number of device.
+        product_type (str): Product type of device.
+        features (dict): Features of device.
+        mist_levels (list): List of mist levels.
+        mist_modes (list): List of mist modes.
+        target_minmax (tuple): Tuple of target min and max values.
+        warm_mist_levels (list): List of warm mist levels.
+    """
+
+    def __init__(self, details: ResponseDeviceDetailsModel,
+                 manager: VeSync, feature_map: HumidifierMap) -> None:
+        """Initialize levoit 1000S device class."""
+        super().__init__(details, manager, feature_map)
+
+    def _set_state(self, resp_model: InnerHumidifierBaseResult) -> None:
+        """Set state of Levoit 1000S from API result model."""
+        if not isinstance(resp_model, Levoit1000SResult):
+            return
+        self.state.device_status = DeviceStatus.from_int(resp_model.powerSwitch)
+        self.state.connection_status = ConnectionStatus.ONLINE
+        self.state.mode = resp_model.workMode
+        self.state.auto_target_humidity = resp_model.targetHumidity
+        self.state.mist_level = resp_model.mistLevel
+        self.state.mist_virtual_level = resp_model.virtualLevel
+        self.state.water_lacks = bool(resp_model.waterLacksState)
+        self.state.water_tank_lifted = bool(resp_model.waterTankLifted)
+        self.state.automatic_stop_config = bool(resp_model.autoStopSwitch)
+        self.state.auto_stop_target_reached = bool(resp_model.autoStopState)
+        self.state.display_set_status = DeviceStatus.from_int(resp_model.screenSwitch)
+        self.state.display_status = DeviceStatus.from_int(resp_model.screenState)
+
+    async def get_details(self) -> None:
+        r_dict = await self.call_bypassv2_api("getHumidifierStatus")
+        r_model = process_bypassv2_result(
+            self, logger, 'get_details', r_dict, Levoit1000SResult
+            )
+        if r_model is None:
+            return
+
+        self._set_state(r_model)
+
+    @deprecated("Use toggle_switch() instead.")
+    async def set_display(self, toggle: bool) -> bool:
+        """Toggle display on/off.
+
+        This is a deprecated method, please use toggle_display() instead.
+        """
+        return await self.toggle_switch(toggle)
+
+    async def toggle_display(self, toggle: bool) -> bool:
+        payload_data = {"screenSwitch": int(toggle)}
+        body = self._build_request("setDisplay", payload_data)
+        headers = Helpers.req_header_bypass()
+
+        r_dict, _ = await self.manager.async_call_api(
+            '/cloud/v2/deviceManaged/bypassV2',
+            method='post',
+            headers=headers,
+            json_object=body.to_dict(),
+        )
+        r = Helpers.process_dev_response(logger, "set_display", self, r_dict)
+        if r is None:
+            return False
+        self.state.display_set_status = DeviceStatus.from_bool(toggle)
+        self.state.connection_status = ConnectionStatus.ONLINE
+        return True
+
+    @deprecated("Use set_mode() instead.")
+    async def set_humidity_mode(self, mode: str) -> bool:
+        """Set humidifier mode - sleep, auto or manual.
+
+        Deprecated, please use set_mode() instead.
+        """
+        return await self.set_mode(mode)
+
+    async def set_mode(self, mode: str) -> bool:
+        if mode.lower() not in self.mist_modes:
+            logger.debug("Invalid humidity mode used - %s", mode)
+            logger.debug(
+                "Proper modes for this device are - %s",
+                orjson.dumps(
+                    self.mist_modes, option=orjson.OPT_INDENT_2 | orjson.OPT_NON_STR_KEYS
+                ),
+            )
+            return False
+
+        payload_data = {"workMode": mode.lower()}
+        r_dict = await self.call_bypassv2_api("setHumidityMode", payload_data)
+        r = Helpers.process_dev_response(logger, "set_mode", self, r_dict)
+        if r is None:
+            return False
+
+        self.state.mode = mode
+        self.state.connection_status = ConnectionStatus.ONLINE
+        return True
+
+    async def set_mist_level(self, level: int) -> bool:
+        if level not in self.mist_levels:
+            logger.debug('Humidifier mist level out of range')
+            return False
+
+        payload_data = {"levelIdx": 0, "virtualLevel": level, "levelType": "mist"}
+        r_dict = await self.call_bypassv2_api('virtualLevel', payload_data)
+        r = Helpers.process_dev_response(logger, "set_mist_level", self, r_dict)
+        if r is None:
+            return False
+
+        self.state.mist_level = level
+        self.state.mist_virtual_level = level
+        self.state.connection_status = ConnectionStatus.ONLINE
+        return True
+
+    async def toggle_switch(self, toggle: bool | None = None) -> bool:
+        if toggle is None:
+            toggle = self.state.device_status != DeviceStatus.ON
+
+        payload_data = {"powerSwitch": int(toggle), "switchIdx": 0}
+        r_dict = await self.call_bypassv2_api("setSwitch", payload_data)
+        r = Helpers.process_dev_response(logger, "toggle_switch", self, r_dict)
+        if r is None:
+            return False
+
+        self.state.device_status = DeviceStatus.from_bool(toggle)
+        self.state.connection_status = ConnectionStatus.ONLINE
+        return True
+
+    async def set_humidity(self, humidity: int) -> bool:
+        if Validators.validate_range(humidity, *self.target_minmax):
+            logger.debug("Humidity value must be set between %s and %s",
+                         self.target_minmax[0], self.target_minmax[1])
+            return False
+
+        payload_data = {"targetHumidity": humidity}
+        r_dict = await self.call_bypassv2_api("setTargetHumidity", payload_data)
+        r = Helpers.process_dev_response(logger, "set_humidity", self, r_dict)
+        if r is None:
+            return False
+
+        self.state.auto_target_humidity = humidity
+        self.state.connection_status = ConnectionStatus.ONLINE
+        return True
+
+    @deprecated("Use toggle_automatic_stop() instead.")
+    async def set_automatic_stop(self, mode: bool) -> bool:
+        return await self.toggle_automatic_stop(mode)
+
+    async def toggle_automatic_stop(self, toggle: bool | None = None) -> bool:
+        if toggle is None:
+            toggle = self.state.automatic_stop_config != DeviceStatus.ON
+
+        payload_data = {"autoStopSwitch": int(toggle)}
+        r_dict = await self.call_bypassv2_api("setAutoStopSwitch", payload_data)
+        r = Helpers.process_dev_response(logger, "set_automatic_stop", self, r_dict)
+
+        if r is None:
+            return False
+        self.state.automatic_stop_config = toggle
+        self.state.connection_status = ConnectionStatus.ONLINE
+        return True