pyvesync 3.2.1__tar.gz → 3.3.2__tar.gz

{pyvesync-3.2.1/src/pyvesync.egg-info → pyvesync-3.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyvesync
-Version: 3.2.1
+Version: 3.3.2
 Summary: pyvesync is a library to manage Etekcity Devices, Cosori Air Fryers, and Levoit Air Purifiers run on the VeSync app.
 Author: Mark Perdue
 Author-email: Joe Trabulsy <webdjoe@gmail.com>

{pyvesync-3.2.1 → pyvesync-3.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyvesync"
-version = "3.2.1"
+version = "3.3.2"
 description = "pyvesync is a library to manage Etekcity Devices, Cosori Air Fryers, and Levoit Air Purifiers run on the VeSync app."
 readme = "README.md"
 requires-python = ">=3.11"

{pyvesync-3.2.1 → pyvesync-3.3.2}/src/pyvesync/base_devices/humidifier_base.py

@@ -416,6 +416,22 @@ class VeSyncHumidifier(VeSyncBaseToggleDevice):
         logger.error('Nightlight brightness has not been configured.')
         return False
 
+    async def toggle_nightlight(self, toggle: bool | None = None) -> bool:
+        """Toggle night light on/off.
+
+        Args:
+            toggle (bool): True to turn on night light, False to turn off.
+
+        Returns:
+            bool: Success of request.
+        """
+        del toggle
+        if not self.supports_nightlight:
+            logger.error('Nightlight is not supported for this device.')
+            return False
+        logger.error('Nightlight has not been configured.')
+        return False
+
     async def set_warm_level(self, warm_level: int) -> bool:
         """Set Humidifier Warm Level.
 
@@ -432,6 +448,22 @@ class VeSyncHumidifier(VeSyncBaseToggleDevice):
         logger.error('Warm level is not supported for this device.')
         return False
 
+    async def turn_on_nightlight(self) -> bool:
+        """Turn on night light.
+
+        Returns:
+            bool: Success of request.
+        """
+        return await self.toggle_nightlight(True)
+
+    async def turn_off_nightlight(self) -> bool:
+        """Turn off night light.
+
+        Returns:
+            bool: Success of request.
+        """
+        return await self.toggle_nightlight(False)
+
     async def toggle_drying_mode(self, toggle: bool | None = None) -> bool:
         """enable/disable drying filters after turning off."""
         del toggle

{pyvesync-3.2.1 → pyvesync-3.3.2}/src/pyvesync/base_devices/purifier_base.py

@@ -109,7 +109,7 @@ class PurifierState(DeviceState):
         self.auto_preference_type: str | None = None
         self.auto_room_size: int | None = None
         self._air_quality_level: AirQualityLevel | None = None
-        self.child_lock: bool = False
+        self.child_lock: bool | None = None
         self.filter_open_state: bool = False
         self.display_status: str | None = None
         self.display_set_status: str | None = None
@@ -301,6 +301,10 @@ class VeSyncPurifier(VeSyncBaseToggleDevice):
             bool: True if successful, False otherwise.
         """
         del mode
+        if not self.supports_nightlight:
+            logger.error('Nightlight not supported for this device.')
+        else:
+            logger.error('Nightlight not configured for this device.')
         return False
 
     async def set_nightlight_dim(self) -> bool:
@@ -492,34 +496,6 @@ class VeSyncPurifier(VeSyncBaseToggleDevice):
         """
         return await self.toggle_child_lock(True)
 
-    @deprecated('Use `turn_off_child_lock()` instead.')
-    async def child_lock_off(self) -> bool:
-        """Turn off child lock (display lock).
-
-        This has been deprecated, use `turn_off_child_lock()` instead.
-        """
-        return await self.toggle_child_lock(False)
-
-    @property
-    @deprecated('Use self.state.child_lock instead.')
-    def child_lock(self) -> bool:
-        """Get child lock state.
-
-        Returns:
-            bool : True if child lock is enabled, False if not.
-        """
-        return self.state.child_lock
-
-    @property
-    @deprecated('Use self.state.nightlight_status instead.')
-    def night_light(self) -> str | None:
-        """Get night light state.
-
-        Returns:
-            str : Night light state (on, dim, off)
-        """
-        return self.state.nightlight_status
-
     @deprecated('Use turn_on_light_detection() instead.')
     async def set_light_detection_on(self) -> bool:
         """Turn on light detection feature."""

{pyvesync-3.2.1 → pyvesync-3.3.2}/src/pyvesync/device_map.py

@@ -697,7 +697,7 @@ humidifier_modules = [
     ),
     HumidifierMap(
         class_name='VeSyncHumid1000S',
-        dev_types=['LUH-M101S-WUS', 'LUH-M101S-WEUR', 'LUH-M101S-WUSR'],
+        dev_types=['LUH-M101S-WUS', 'LUH-M101S-WUSR'],
         features=[],
         mist_modes={
             HumidifierModes.AUTO: 'auto',
@@ -823,15 +823,26 @@ purifier_modules: list[PurifierMap] = [
     ),
     PurifierMap(
         class_name='VeSyncAir131',
-        dev_types=['LV-PUR131S', 'LV-RH131S', 'LV-RH131S-WM'],
+        dev_types=['LV-PUR131S'],
         modes=[PurifierModes.SLEEP, PurifierModes.MANUAL, PurifierModes.AUTO],
         features=[PurifierFeatures.AIR_QUALITY],
         fan_levels=list(range(1, 4)),
         device_alias='LV-PUR131S',
-        model_display='LV-PUR131S/RH131S Series',
+        model_display='LV-PUR131S Series',
         model_name='LV131S',
         setup_entry='LV-PUR131S',
     ),
+    PurifierMap(
+        class_name='VeSyncAirRH131',
+        dev_types=['LV-RH131S-WM', 'LV-RH131S'],
+        modes=[PurifierModes.SLEEP, PurifierModes.MANUAL, PurifierModes.AUTO],
+        features=[PurifierFeatures.AIR_QUALITY],
+        fan_levels=list(range(1, 4)),
+        device_alias='LV-RH131S',
+        model_display='LV-RH131S Series',
+        model_name='LV131S',
+        setup_entry='LV-RH131S',
+    ),
     PurifierMap(
         class_name='VeSyncAirBaseV2',
         dev_types=[

{pyvesync-3.2.1 → pyvesync-3.3.2}/src/pyvesync/devices/vesynchumidifier.py

@@ -269,13 +269,19 @@ class VeSyncHumid200300S(BypassV2Mixin, VeSyncHumidifier):
         )
         return True
 
-    @deprecated('Use set_mode(mode: str) instead.')
-    async def set_humidity_mode(self, mode: str) -> bool:
-        """Deprecated - set humidifier mode.
+    async def toggle_nightlight(self, toggle: bool | None = None) -> bool:
+        if not self.supports_nightlight:
+            logger.warning(
+                '%s is a %s does not have a nightlight or it is not supported.',
+                self.device_name,
+                self.device_type,
+            )
+            return False
 
-        Use `set_mode(mode: str)` instead.
-        """
-        return await self.set_mode(mode)
+        if toggle is None:
+            toggle = self.state.nightlight_status != DeviceStatus.ON
+        brightness = 100 if toggle else 0
+        return await self.set_nightlight_brightness(brightness)
 
     async def set_mode(self, mode: str) -> bool:
         if mode.lower() not in self.mist_modes:
@@ -711,14 +717,6 @@ class VeSyncHumid1000S(VeSyncHumid200300S):
         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.warning('Invalid humidity mode used - %s', mode)
@@ -792,10 +790,6 @@ class VeSyncHumid1000S(VeSyncHumid200300S):
         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
@@ -809,3 +803,56 @@ class VeSyncHumid1000S(VeSyncHumid200300S):
         self.state.automatic_stop_config = toggle
         self.state.connection_status = ConnectionStatus.ONLINE
         return True
+
+    async def toggle_nightlight(self, toggle: bool | None = None) -> bool:
+        if not self.supports_nightlight:
+            logger.warning(
+                '%s is a %s does not have a nightlight or it is not supported.',
+                self.device_name,
+                self.device_type,
+            )
+            return False
+
+        if toggle is None:
+            toggle = self.state.nightlight_status != DeviceStatus.ON
+
+        payload_data = {'nightLightSwitch': int(toggle)}
+        r_dict = await self.call_bypassv2_api('setNightLightStatus', payload_data)
+        r = Helpers.process_dev_response(logger, 'toggle_nightlight', self, r_dict)
+        if r is None:
+            return False
+
+        self.state.nightlight_status = DeviceStatus.from_bool(toggle)
+        self.state.connection_status = ConnectionStatus.ONLINE
+        return True
+
+    async def set_nightlight_brightness(self, brightness: int) -> bool:
+        if not self.supports_nightlight:
+            logger.warning(
+                '%s is a %s does not have a nightlight or it is not supported.',
+                self.device_name,
+                self.device_type,
+            )
+            return False
+
+        if not Validators.validate_zero_to_hundred(brightness):
+            logger.warning('Brightness value must be set between 0 and 100')
+            return False
+
+        payload_data = {
+            'brightness': brightness,
+            'nightLightSwitch': 1 if brightness > 0 else 0,
+        }
+        r_dict = await self.call_bypassv2_api('setLightStatus', 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
+        )
+        self.state.connection_status = ConnectionStatus.ONLINE
+        return True

{pyvesync-3.2.1 → pyvesync-3.3.2}/src/pyvesync/devices/vesyncoutlet.py

@@ -94,6 +94,7 @@ class VeSyncOutlet7A(VeSyncOutlet):
         self, details: ResponseDeviceDetailsModel, manager: VeSync, feature_map: OutletMap
     ) -> None:
         """Initialize Etekcity 7A round outlet class."""
+        self.request_keys: list[str] = []
         super().__init__(details, manager, feature_map)
 
     def _build_headers(self) -> dict:
@@ -169,7 +170,7 @@ class VeSyncOutlet7A(VeSyncOutlet):
             return False
 
         if isinstance(r_dict, dict) and 'error' in r_dict:
-            _ = Helpers.process_dev_response(logger, 'get_details', self, r_dict)
+            _ = Helpers.process_dev_response(logger, 'toggle_switch', self, r_dict)
             return False
 
         self.state.update_ts()
@@ -803,7 +804,7 @@ class VeSyncOutletWHOGPlug(BypassV2Mixin, VeSyncOutlet):
     async def toggle_switch(self, toggle: bool | None = None) -> bool:
         if toggle is None:
             toggle = self.state.device_status != DeviceStatus.ON
-        toggle_int = bool(toggle)
+        toggle_int = int(toggle)
         r_dict = await self.call_bypassv2_api(
             'setProperty',
             data={'powerSwitch_1': toggle_int},

{pyvesync-3.2.1 → pyvesync-3.3.2}/src/pyvesync/devices/vesyncpurifier.py

@@ -23,6 +23,7 @@ from pyvesync.models.purifier_models import (
     InnerPurifierBaseResult,
     Purifier131Result,
     PurifierCoreDetailsResult,
+    PurifierRH131Result,
     PurifierSproutResult,
     PurifierV2EventTiming,
     PurifierV2TimerActionItems,
@@ -980,3 +981,151 @@ class VeSyncAir131(BypassV1Mixin, VeSyncPurifier):
         self.state.mode = mode
         self.state.connection_status = ConnectionStatus.ONLINE
         return True
+
+
+class VeSyncAirRH131(BypassV2Mixin, VeSyncPurifier):
+    """Levoit Air Purifier Class.
+
+    Class for LV-PUR131S, using BypassV1 API.
+
+    Attributes:
+        state (PurifierState): State of the device.
+        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.
+        modes (list[str]): List of modes supported by the device.
+        fan_levels (list[int]): List of fan levels supported by the device.
+        nightlight_modes (list[str]): List of nightlight modes supported by the device.
+        auto_preferences (list[str]): List of auto preferences supported by the device.
+    """
+
+    __slots__ = ()
+
+    def __init__(
+        self,
+        details: ResponseDeviceDetailsModel,
+        manager: VeSync,
+        feature_map: PurifierMap,
+    ) -> None:
+        """Initialize air purifier class."""
+        super().__init__(details, manager, feature_map)
+
+    def _set_state(self, details: PurifierRH131Result) -> None:
+        """Set state from purifier API get_details() response."""
+        self.state.device_status = DeviceStatus.from_bool(details.enabled)
+        self.state.connection_status = ConnectionStatus.ONLINE
+        if details.filter_life is not None:
+            self.state.filter_life = details.filter_life
+        self.state.display_status = DeviceStatus.from_bool(details.display)
+        self.state.display_set_status = DeviceStatus.from_bool(details.display)
+        self.state.mode = details.mode
+        self.state.fan_level = details.level or 0
+        self.state.fan_set_level = details.level or 0
+        self.state.set_air_quality_level(details.air_quality or 0)
+        self.state.child_lock = details.child_lock
+
+    async def get_details(self) -> None:
+        r_dict = await self.call_bypassv2_api('getPurifierStatus')
+        r_model = process_bypassv2_result(
+            self, _LOGGER, 'get_details', r_dict, PurifierRH131Result
+        )
+        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 toggle_display(self, mode: bool) -> bool:
+        update_dict = {'state': mode}
+        r_dict = await self.call_bypassv2_api('setDisplay', update_dict)
+        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(mode)
+        self.state.display_status = DeviceStatus.from_bool(mode)
+        self.state.connection_status = ConnectionStatus.ONLINE
+        return True
+
+    async def set_mode(self, mode: str) -> bool:
+        if mode not in self.modes:
+            _LOGGER.warning('Invalid purifier mode used - %s', mode)
+            return False
+
+        payload_data = {'mode': mode}
+        r_dict = await self.call_bypassv2_api('setPurifierMode', 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_fan_speed(self, speed: int | None = None) -> bool:
+        if speed is not None:
+            if speed not in self.fan_levels:
+                _LOGGER.warning(
+                    '%s is invalid speed - valid speeds are %s',
+                    speed,
+                    str(self.fan_levels),
+                )
+                return False
+            new_speed = speed
+        else:
+            new_speed = Helpers.bump_level(self.state.fan_level or 0, self.fan_levels)
+
+        payload_data = {'level': new_speed, 'id': 0, 'type': 'wind'}
+
+        r_dict = await self.call_bypassv2_api('setLevel', payload_data)
+
+        r = Helpers.process_dev_response(_LOGGER, 'set_fan_speed', self, r_dict)
+        if r is None:
+            return False
+
+        self.state.fan_level = new_speed
+        self.state.fan_set_level = new_speed
+        self.state.connection_status = ConnectionStatus.ONLINE
+        self.state.mode = PurifierModes.MANUAL
+        return True
+
+    async def toggle_child_lock(self, toggle: bool | None = None) -> bool:
+        if toggle is None:
+            toggle = not bool(self.state.child_lock)
+        payload_data = {'child_lock': toggle}
+        r_dict = await self.call_bypassv2_api('setChildLock', payload_data)
+
+        r = Helpers.process_dev_response(_LOGGER, 'toggle_child_lock', self, r_dict)
+        if r is None:
+            return False
+
+        self.state.child_lock = toggle
+        self.state.connection_status = ConnectionStatus.ONLINE
+        return True

{pyvesync-3.2.1 → pyvesync-3.3.2}/src/pyvesync/models/humidifier_models.py

@@ -72,7 +72,7 @@ class ClassicLVHumidResult(InnerHumidifierBaseResult):
     mist_virtual_level: int
     mist_level: int
     mode: str
-    display: Annotated[bool, Alias('indicator_light_status')]
+    display: Annotated[bool, Alias('indicator_light_switch')]
     water_lacks: bool
     humidity: int | None = None
     humidity_high: bool = False
@@ -89,7 +89,7 @@ class ClassicConfig(ResponseBaseModel):
     """Classic 200S Humidifier Configuration Model."""
 
     auto_target_humidity: int = 0
-    display: Annotated[bool, Alias('indicator_light_status')] = False
+    display: Annotated[bool, Alias('indicator_light_switch')] = False
     automatic_stop: bool = False
 
     class Config(BaseConfig):  # type: ignore[override]

{pyvesync-3.2.1 → pyvesync-3.3.2}/src/pyvesync/models/purifier_models.py

@@ -258,3 +258,27 @@ class Purifier131Filter(ResponseBaseModel):
     change: bool
     useHour: int
     percent: int
+
+
+@dataclass
+class PurifierRH131Result(BypassV2InnerResult):
+    """Purifier RH131 Details Response Dict."""
+
+    enabled: bool
+    filter_life: int
+    mode: str
+    level: int
+    air_quality: int
+    display: bool
+    child_lock: bool
+    buzzer: bool
+    configuration: dict
+    extension: PurifierRH131DetailsExtension | None = None
+
+
+@dataclass
+class PurifierRH131DetailsExtension(ResponseBaseModel):
+    """Extension dict in RH131 purifier details response."""
+
+    schedule_count: int
+    timer_remain: int

{pyvesync-3.2.1 → pyvesync-3.3.2}/src/pyvesync/utils/errors.py

@@ -695,7 +695,7 @@ class ErrorCodes:
                 'TOKEN_EXPIRED', ErrorTypes.TOKEN_ERROR, 'Invalid token'
             ),
             '-999999999': ResponseInfo(
-                'UNKNOWN', ErrorTypes.SERVER_ERROR, 'Unknown error'
+                'UNKNOWN', ErrorTypes.UNKNOWN_ERROR, 'Unknown error'
             ),
             '-11307000': ResponseInfo(
                 'UUID_NOT_EXIST',
@@ -757,23 +757,23 @@ class ErrorCodes:
         """
         try:
             if error_code is None:
-                return ResponseInfo('UNKNOWN', ErrorTypes.UNKNOWN_ERROR, 'Unknown error')
+                error_code = '-999999999'
             error_str = str(error_code)
             error_int = int(error_code)
             if error_str == '0':
-                return ResponseInfo('SUCCESS', ErrorTypes.SUCCESS, 'Success')
-
-            if error_str in cls.errors:
+                error_info = ResponseInfo('SUCCESS', ErrorTypes.SUCCESS, 'Success')
+            elif error_str in cls.errors:
                 error_info = cls.errors[error_str]
             else:
                 error_code = int(error_int / 1000) * 1000
-                error_object = cls.errors[str(error_code)]
-                error_info = replace(error_object)
-
+                error_info = cls.errors[str(error_code)]
             if msg:
+                error_info = replace(error_info)
                 error_info.message = f'{error_info.message} - {msg}'
         except (ValueError, TypeError, KeyError):
-            return ResponseInfo('UNKNOWN', ErrorTypes.UNKNOWN_ERROR, 'Unknown error')
+            error_info = ResponseInfo(
+                'UNKNOWN', ErrorTypes.UNKNOWN_ERROR, 'Unknown error'
+            )
         return error_info
 
     @classmethod

{pyvesync-3.2.1 → pyvesync-3.3.2/src/pyvesync.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyvesync
-Version: 3.2.1
+Version: 3.3.2
 Summary: pyvesync is a library to manage Etekcity Devices, Cosori Air Fryers, and Levoit Air Purifiers run on the VeSync app.
 Author: Mark Perdue
 Author-email: Joe Trabulsy <webdjoe@gmail.com>