pyvesync 3.0.0b0__tar.gz → 3.0.0b2__tar.gz

{pyvesync-3.0.0b0/src/pyvesync.egg-info → pyvesync-3.0.0b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyvesync
-Version: 3.0.0b0
+Version: 3.0.0b2
 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>
@@ -340,7 +340,7 @@ manager.devices.outlets = [VeSyncOutletInstances]
 manager.devices.switches = [VeSyncSwitchInstances]
 manager.devices.fans = [VeSyncFanInstances]
 manager.devices.bulbs = [VeSyncBulbInstances]
-manager.devices.purifiers = [VeSyncPurifierInstances]
+manager.devices.air_purifiers = [VeSyncPurifierInstances]
 manager.devices.humidifiers = [VeSyncHumidifierInstances]
 manager.devices.air_fryers = [VeSyncAirFryerInstances]
 managers.devices.thermostats = [VeSyncThermostatInstances]

{pyvesync-3.0.0b0 → pyvesync-3.0.0b2}/README.md

@@ -309,7 +309,7 @@ manager.devices.outlets = [VeSyncOutletInstances]
 manager.devices.switches = [VeSyncSwitchInstances]
 manager.devices.fans = [VeSyncFanInstances]
 manager.devices.bulbs = [VeSyncBulbInstances]
-manager.devices.purifiers = [VeSyncPurifierInstances]
+manager.devices.air_purifiers = [VeSyncPurifierInstances]
 manager.devices.humidifiers = [VeSyncHumidifierInstances]
 manager.devices.air_fryers = [VeSyncAirFryerInstances]
 managers.devices.thermostats = [VeSyncThermostatInstances]

{pyvesync-3.0.0b0 → pyvesync-3.0.0b2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyvesync"
-version = "3.0.0b0"
+version = "3.0.0b2"
 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.0.0b0 → pyvesync-3.0.0b2}/src/pyvesync/base_devices/fan_base.py

@@ -6,13 +6,7 @@ from abc import abstractmethod
 from typing_extensions import deprecated
 
 from pyvesync.base_devices.vesyncbasedevice import VeSyncBaseToggleDevice, DeviceState
-from pyvesync.const import (
-    FanModes,
-    FanFeatures,
-    DeviceStatus,
-    FanSleepPreference,
-    StrFlag,
-    )
+from pyvesync.const import FanModes, FanFeatures
 
 if TYPE_CHECKING:
     from pyvesync import VeSync
@@ -26,10 +20,7 @@ logger = logging.getLogger(__name__)
 class FanState(DeviceState):
     """Base state class for Purifiers.
 
-    Not all attributes are supported by all devices. Attributes are set to
-    UNKNOWN by default and attributes that are not supported by all devices are
-    set to [StrFlag.NOT_SUPPORTED][pyvesync.const.StrFlag] or
-    [IntFlag.NOT_SUPPORTED][pyvesync.const.IntFlag].
+    Not all attributes are supported by all devices.
 
 
     Attributes:
@@ -93,17 +84,17 @@ class FanState(DeviceState):
         self.humidity: int | None = None
         self.temperature: int | None = None
         self.thermal_comfort: int | None = None
-        self.sleep_preference_type: str | None = FanSleepPreference.UNKNOWN
-        self.sleep_fallasleep_remain: str | None = DeviceStatus.UNKNOWN
-        self.sleep_oscillation_switch: str | None = DeviceStatus.UNKNOWN
-        self.sleep_change_fan_level: str | None = DeviceStatus.UNKNOWN
-        self.mute_status: str = DeviceStatus.UNKNOWN
-        self.mute_set_state: str = DeviceStatus.UNKNOWN
-        self.oscillation_status: str = DeviceStatus.UNKNOWN
-        self.oscillation_set_state: str = DeviceStatus.UNKNOWN
-        self.display_status: str = DeviceStatus.UNKNOWN
-        self.display_set_state: str = DeviceStatus.UNKNOWN
-        self.displaying_type: str = StrFlag.NOT_SUPPORTED
+        self.sleep_preference_type: str | None = None
+        self.sleep_fallasleep_remain: str | None = None
+        self.sleep_oscillation_switch: str | None = None
+        self.sleep_change_fan_level: str | None = None
+        self.mute_status: str | None = None
+        self.mute_set_state: str | None = None
+        self.oscillation_status: str | None = None
+        self.oscillation_set_state: str | None = None
+        self.display_status: str | None = None
+        self.display_set_state: str | None = None
+        self.displaying_type: str | None = None
 
 
 class VeSyncFanBase(VeSyncBaseToggleDevice):

{pyvesync-3.0.0b0 → pyvesync-3.0.0b2}/src/pyvesync/base_devices/humidifier_base.py

@@ -9,9 +9,7 @@ from pyvesync.base_devices.vesyncbasedevice import VeSyncBaseToggleDevice, Devic
 from pyvesync.const import (
     HumidifierFeatures,
     HumidifierModes,
-    DeviceStatus,
-    IntFlag,
-    StrFlag
+    DeviceStatus
     )
 
 if TYPE_CHECKING:
@@ -27,8 +25,7 @@ class HumidifierState(DeviceState):
     """State Class for VeSync Humidifiers.
 
     This is the state class for all vesync humidifiers. If there are
-    new features or state attributes, they should be added directly to
-    this class and be set to the default `NOT_SUPPORTED` flag.
+    new features or state attributes.
 
     Attributes:
         auto_preference (int): Auto preference level.
@@ -97,29 +94,29 @@ class HumidifierState(DeviceState):
         """
         super().__init__(device, details, feature_map)
         self.auto_stop_target_reached: bool = False
-        self.auto_target_humidity: int = IntFlag.NOT_SUPPORTED
+        self.auto_target_humidity: int | None = None
         self.automatic_stop_config: bool = False
         self.display_set_status: str = DeviceStatus.UNKNOWN
         self.display_status: str = DeviceStatus.UNKNOWN
-        self.humidity: int = IntFlag.NOT_SUPPORTED
+        self.humidity: int | None = None
         self.humidity_high: bool = False
         self.mist_level: int | None = None
         self.mist_virtual_level: int | None = None
-        self.mode: str = HumidifierModes.UNKNOWN
-        self.nightlight_brightness: int = IntFlag.NOT_SUPPORTED
-        self.nightlight_status: str = StrFlag.NOT_SUPPORTED
+        self.mode: str | None = None
+        self.nightlight_brightness: int | None = None
+        self.nightlight_status: str | None = None
         self.warm_mist_enabled: bool | None = None
-        self.warm_mist_level: int = IntFlag.NOT_SUPPORTED
+        self.warm_mist_level: int | None = None
         self.water_lacks: bool = False
         self.water_tank_lifted: bool = False
-        self.temperature: int = IntFlag.NOT_SUPPORTED
+        self.temperature: int | None = None
         # Superior 6000S States
-        self.auto_preference: int = IntFlag.NOT_SUPPORTED
-        self.filter_life_percent: int = IntFlag.NOT_SUPPORTED
-        self.drying_mode_level: int = IntFlag.NOT_SUPPORTED
-        self.drying_mode_auto_switch: str = StrFlag.NOT_SUPPORTED
-        self.drying_mode_status: str = StrFlag.NOT_SUPPORTED
-        self.drying_mode_time_remain: int = IntFlag.NOT_SUPPORTED
+        self.auto_preference: int | None = None
+        self.filter_life_percent: int | None = None
+        self.drying_mode_level: int | None = None
+        self.drying_mode_auto_switch: str | None = None
+        self.drying_mode_status: str | None = None
+        self.drying_mode_time_remain: int | None = None
 
     @property
     def automatic_stop(self) -> bool:
@@ -141,7 +138,7 @@ class HumidifierState(DeviceState):
         return self.auto_stop_target_reached
 
     @property
-    def target_humidity(self) -> int:
+    def target_humidity(self) -> int | None:
         """Return the target humidity level.
 
         Returns:
@@ -150,7 +147,7 @@ class HumidifierState(DeviceState):
         return self.auto_target_humidity
 
     @property
-    def auto_humidity(self) -> int:
+    def auto_humidity(self) -> int | None:
         """Return the auto humidity level.
 
         Returns:
@@ -174,7 +171,7 @@ class HumidifierState(DeviceState):
         return self.humidity
 
     @property
-    def drying_mode_state(self) -> str:
+    def drying_mode_state(self) -> str | None:
         """Return the drying mode state.
 
         Returns:
@@ -183,7 +180,7 @@ class HumidifierState(DeviceState):
         return self.drying_mode_status
 
     @property
-    def drying_mode_seconds_remaining(self) -> int:
+    def drying_mode_seconds_remaining(self) -> int | None:
         """Return the drying mode seconds remaining.
 
         Return:

{pyvesync-3.0.0b0 → pyvesync-3.0.0b2}/src/pyvesync/base_devices/outlet_base.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING
 
-from pyvesync.const import OutletFeatures, IntFlag, StrFlag, NightlightModes
+from pyvesync.const import OutletFeatures, NightlightModes
 from pyvesync.utils.helpers import Helpers
 from pyvesync.base_devices.vesyncbasedevice import VeSyncBaseToggleDevice, DeviceState
 from pyvesync.models.outlet_models import RequestEnergyHistory, ResponseEnergyHistory
@@ -89,12 +89,12 @@ class OutletState(DeviceState):
         self.device: VeSyncOutlet = device
         self.features: list[str] = feature_map.features
         self.active_time: int | None = 0
-        self.power: float = IntFlag.NOT_SUPPORTED
-        self.energy: float = IntFlag.NOT_SUPPORTED
-        self.voltage: float = IntFlag.NOT_SUPPORTED
-        self.nightlight_status: str | None = StrFlag.NOT_SUPPORTED
-        self.nightlight_brightness: int | None = IntFlag.NOT_SUPPORTED
-        self.nightlight_automode: str | None = StrFlag.NOT_SUPPORTED
+        self.power: float | None = None
+        self.energy: float | None = None
+        self.voltage: float | None = None
+        self.nightlight_status: str | None = None
+        self.nightlight_brightness: int | None = None
+        self.nightlight_automode: str | None = None
         self.weekly_history: ResponseEnergyResult | None = None
         self.monthly_history: ResponseEnergyResult | None = None
         self.yearly_history: ResponseEnergyResult | None = None

{pyvesync-3.0.0b0 → pyvesync-3.0.0b2}/src/pyvesync/base_devices/purifier_base.py

@@ -4,7 +4,7 @@ import logging
 from typing import TYPE_CHECKING
 from abc import abstractmethod
 
-from deprecated import deprecated
+from typing_extensions import deprecated
 
 from pyvesync.base_devices.vesyncbasedevice import VeSyncBaseToggleDevice, DeviceState
 from pyvesync.const import (
@@ -12,10 +12,7 @@ from pyvesync.const import (
     PurifierFeatures,
     PurifierModes,
     DeviceStatus,
-    NightlightModes,
-    PurifierAutoPreference,
-    IntFlag,
-    StrFlag,
+    NightlightModes
     )
 
 if TYPE_CHECKING:
@@ -97,25 +94,23 @@ class PurifierState(DeviceState):
         self.fan_level: int | None = None
         self.fan_set_level: int | None = None
         self.filter_life: int | None = None
-        self.auto_preference_type: str | None = PurifierAutoPreference.UNKNOWN
+        self.auto_preference_type: str | None = None
         self.auto_room_size: int | None = None
-        self._air_quality_level: AirQualityLevel = AirQualityLevel.UNKNOWN
+        self._air_quality_level: AirQualityLevel | None = None
         self.child_lock: bool = False
         self.filter_open_state: bool = False
-        self.display_status: str = DeviceStatus.UNKNOWN
-        self.display_set_state: str = DeviceStatus.UNKNOWN
+        self.display_status: str | None = None
+        self.display_set_state: str | None = None
         self.display_forever: bool = False
         # Attributes not supported by all purifiers
-        # When update is first called, devices that support these attributes will
-        # update them from NOT_SUPPORTED, whether to None or another value.
-        self.pm25: int | None = IntFlag.NOT_SUPPORTED
-        self.pm1: int | None = IntFlag.NOT_SUPPORTED
-        self.pm10: int | None = IntFlag.NOT_SUPPORTED
-        self.aq_percent: int | None = IntFlag.NOT_SUPPORTED
-        self.light_detection_switch: str = StrFlag.NOT_SUPPORTED
-        self.light_detection_status: str = StrFlag.NOT_SUPPORTED
-        self.nightlight_status: str = StrFlag.NOT_SUPPORTED
-        self.fan_rotate_angle: int | None = IntFlag.NOT_SUPPORTED
+        self.pm25: int | None = None
+        self.pm1: int | None = None
+        self.pm10: int | None = None
+        self.aq_percent: int | None = None
+        self.light_detection_switch: str | None = None
+        self.light_detection_status: str | None = None
+        self.nightlight_status: str | None = None
+        self.fan_rotate_angle: int | None = None
 
     @property
     def air_quality_level(self) -> int:
@@ -171,19 +166,19 @@ class PurifierState(DeviceState):
 
     @property
     @deprecated("Use PurifierState.nightlight_status instead.")
-    def night_light(self) -> str:
+    def night_light(self) -> str | None:
         """Return night light status."""
         return self.nightlight_status
 
     @property
     @deprecated("Use display_status instead.")
-    def display_state(self) -> str:
+    def display_state(self) -> str | None:
         """Return display status."""
         return self.display_status
 
     @property
     @deprecated("Use display_set_state instead.")
-    def display_switch(self) -> str:
+    def display_switch(self) -> str | None:
         """Return display switch status."""
         return self.display_set_state
 
@@ -499,7 +494,7 @@ class VeSyncPurifier(VeSyncBaseToggleDevice):
 
     @property
     @deprecated("Use self.state.nightlight_status instead.")
-    def night_light(self) -> str:
+    def night_light(self) -> str | None:
         """Get night light state.
 
         Returns:

{pyvesync-3.0.0b0 → pyvesync-3.0.0b2}/src/pyvesync/base_devices/switch_base.py

@@ -7,7 +7,7 @@ from typing_extensions import deprecated
 from pyvesync.base_devices.vesyncbasedevice import VeSyncBaseToggleDevice, DeviceState
 
 from pyvesync.utils.colors import Color
-from pyvesync.const import SwitchFeatures, StrFlag, IntFlag
+from pyvesync.const import SwitchFeatures
 
 if TYPE_CHECKING:
     from pyvesync import VeSync
@@ -57,11 +57,11 @@ class SwitchState(DeviceState):
         """Initialize VeSync Switch State."""
         super().__init__(device, details, feature_map)
         self.device: VeSyncSwitch = device
-        self._backlight_color: Color | str | None = StrFlag.NOT_SUPPORTED
-        self.brightness: int = IntFlag.NOT_SUPPORTED
+        self._backlight_color: Color | None = None
+        self.brightness: int | None = None
         self.active_time: int | None = 0
-        self.backlight_status: str = StrFlag.NOT_SUPPORTED
-        self.indicator_status: str = StrFlag.NOT_SUPPORTED
+        self.backlight_status: str | None = None
+        self.indicator_status: str | None = None
 
     @property
     def backlight_rgb(self) -> RGB | None:

{pyvesync-3.0.0b0 → pyvesync-3.0.0b2}/src/pyvesync/base_devices/vesyncbasedevice.py

@@ -10,7 +10,7 @@ from typing_extensions import deprecated
 # import warnings
 import orjson
 
-from pyvesync.const import DeviceStatus, ConnectionStatus, IntFlag, StrFlag
+from pyvesync.const import DeviceStatus, ConnectionStatus
 
 logger = logging.getLogger(__name__)
 
@@ -53,6 +53,7 @@ class VeSyncBaseDevice(ABC, Generic[VS_STATE_T]):
         config_module (str): Configuration module of device.
         mac_id (str): MAC ID of device.
         current_firm_version (str): Current firmware version of device.
+        latest_firm_version (str | None): Latest 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.
@@ -96,6 +97,7 @@ class VeSyncBaseDevice(ABC, Generic[VS_STATE_T]):
         "enabled",
         "features",
         "last_response",
+        "latest_firm_version",
         "mac_id",
         "manager",
         "pid",
@@ -129,9 +131,10 @@ class VeSyncBaseDevice(ABC, Generic[VS_STATE_T]):
         self.config_module: str = details.configModule
         self.mac_id: str | None = details.macID
         self.current_firm_version = details.currentFirmVersion
+        self.latest_firm_version: str | None = None
         self.device_region: str | None = details.deviceRegion
         self.pid: str | None = None
-        self.sub_device_no: int = details.subDeviceNo
+        self.sub_device_no: int | None = details.subDeviceNo
         # From feature_map
         self.product_type: str = feature_map.product_type
         self.features: list[str] = feature_map.features
@@ -192,7 +195,7 @@ class VeSyncBaseDevice(ABC, Generic[VS_STATE_T]):
 
         This is going to be updated.
         """
-        return False
+        return self.latest_firm_version != self.current_firm_version
 
     async def set_timer(self, duration: int, action: str | None = None) -> bool:
         """Set timer for device.
@@ -542,8 +545,6 @@ class DeviceState:
                 or attr_name in [*self.__base_exclusions, *self._exclude_serialization]
             ):
                 continue
-            if attr_value in [IntFlag.NOT_SUPPORTED, StrFlag.NOT_SUPPORTED]:
-                continue
             state_dict[attr_name] = attr_value
         return state_dict
 

{pyvesync-3.0.0b0 → pyvesync-3.0.0b2}/src/pyvesync/const.py

@@ -21,7 +21,7 @@ Attributes:
     TERMINAL_ID (str): Unique identifier for new API calls
 """
 from random import randint
-from uuid import uuid1
+from uuid import uuid4
 from enum import StrEnum, IntEnum, Enum
 from types import MappingProxyType
 from pyvesync.utils.enum_utils import IntEnumMixin
@@ -36,15 +36,15 @@ USER_AGENT = (
 )
 DEFAULT_TZ = "America/New_York"
 DEFAULT_REGION = "US"
-APP_VERSION = "2.8.6"
+APP_VERSION = "5.5.60"
 PHONE_BRAND = "SM N9005"
 PHONE_OS = "Android"
 # MOBILE_ID = "1234567890123456"
 MOBILE_ID = str(randint(1000000000000000, 9999999999999999))  # noqa: S311
 USER_TYPE = "1"
-BYPASS_APP_V = "VeSync 3.0.51"
+BYPASS_APP_V = f"VeSync {APP_VERSION}"
 BYPASS_HEADER_UA = "okhttp/3.12.1"
-TERMINAL_ID = '2' + uuid1().hex
+TERMINAL_ID = '2' + str(uuid4()).replace('-', '')
 
 
 # Generic Constants
@@ -64,7 +64,7 @@ class ProductTypes(StrEnum):
 
 
 class IntFlag(IntEnum):
-    """Integer flag to indicate if a device is not supported.
+    """DEPRECATED. Integer flag to indicate if a device is not supported.
 
     This is used by data models as a default value for feature attributes
     that are not supported by all devices.
@@ -82,7 +82,7 @@ class IntFlag(IntEnum):
 
 
 class StrFlag(StrEnum):
-    """String flag to indicate if a device is not supported.
+    """DEPRECATED. String flag to indicate if a device is not supported.
 
     This is used by data models as a default value for feature attributes
     that are not supported by all devices.

{pyvesync-3.0.0b0 → pyvesync-3.0.0b2}/src/pyvesync/device_container.py

@@ -184,7 +184,7 @@ class DeviceContainer(_DeviceContainerBase):
         if device_obj is not None:
             self.add(device_obj)
 
-    def device_exists(self, cid: str, sub_device_no: int = 0) -> bool:
+    def device_exists(self, cid: str, sub_device_no: int | None = None) -> bool:
         """Check if a device with the given cid & sub_dev_no exists.
 
         Args:

{pyvesync-3.0.0b0 → pyvesync-3.0.0b2}/src/pyvesync/device_map.py

@@ -746,7 +746,7 @@ purifier_modules: list[PurifierMap] = [
         dev_types=["LV-PUR131S", "LV-RH131S"],
         modes=[PurifierModes.SLEEP, PurifierModes.MANUAL, PurifierModes.AUTO],
         features=[PurifierFeatures.AIR_QUALITY],
-        fan_levels=list(range(1, 3)),
+        fan_levels=list(range(1, 4)),
         device_alias="LV-PUR131S",
         model_display="LV-PUR131S/RH131S Series",
         model_name="LV131S",

{pyvesync-3.0.0b0 → pyvesync-3.0.0b2}/src/pyvesync/devices/vesynchumidifier.py

@@ -8,7 +8,7 @@ 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.const import DeviceStatus, ConnectionStatus
 from pyvesync.models.bypass_models import ResultV2GetTimer, ResultV2SetTimer
 from pyvesync.models.humidifier_models import (
     ClassicLVHumidResult,
@@ -75,7 +75,7 @@ class VeSyncHumid200300S(BypassV2Mixin, VeSyncHumidifier):
         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.humidity = resp_model.humidity
         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
@@ -84,7 +84,7 @@ class VeSyncHumid200300S(BypassV2Mixin, VeSyncHumidifier):
         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
+            and resp_model.night_light_brightness is not None
         ):
             self.state.nightlight_brightness = resp_model.night_light_brightness
             self.state.nightlight_status = (
@@ -93,7 +93,7 @@ class VeSyncHumid200300S(BypassV2Mixin, VeSyncHumidifier):
                 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:
+        if self.supports_warm_mist and resp_model.warm_level is not None:
             self.state.warm_mist_level = resp_model.warm_level
             self.state.warm_mist_enabled = resp_model.warm_enabled
         config = resp_model.configuration
@@ -388,6 +388,7 @@ class VeSyncHumid200S(VeSyncHumid200300S):
             return False
 
         self.state.display_set_status = DeviceStatus.from_bool(toggle)
+        self.state.display_status = DeviceStatus.from_bool(toggle)
         self.state.connection_status = ConnectionStatus.ONLINE
         return True
 

{pyvesync-3.0.0b0 → pyvesync-3.0.0b2}/src/pyvesync/devices/vesyncpurifier.py

@@ -14,8 +14,6 @@ from pyvesync.utils.device_mixins import (
 from pyvesync.utils.helpers import Helpers, Timer
 # from pyvesync.models.base_models import DefaultValues
 from pyvesync.const import (
-    IntFlag,
-    StrFlag,
     PurifierAutoPreference,
     DeviceStatus,
     ConnectionStatus,
@@ -135,7 +133,7 @@ class VeSyncAirBypass(BypassV2Mixin, VeSyncPurifier):
         if self.supports_air_quality is True:
             self.state.pm25 = result.air_quality_value
             self.state.set_air_quality_level(result.air_quality)
-        if result.night_light != StrFlag.NOT_SUPPORTED:
+        if result.night_light is not None:
             self.state.nightlight_status = DeviceStatus.ON if result.night_light \
                 else DeviceStatus.OFF
 
@@ -490,7 +488,7 @@ class VeSyncAirBaseV2(VeSyncAirBypass):
         self.state.pm10 = details.PM10
         self.state.aq_percent = details.AQPercent
         self.state.fan_rotate_angle = details.fanRotateAngle
-        if details.filterOpenState != IntFlag.NOT_SUPPORTED:
+        if details.filterOpenState is not None:
             self.state.filter_open_state = bool(details.filterOpenState)
         if details.timerRemain > 0:
             self.state.timer = Timer(details.timerRemain, 'off')
@@ -812,7 +810,7 @@ class VeSyncAir131(BypassV1Mixin, VeSyncPurifier):
         self.state.child_lock = bool(DeviceStatus(details.childLock))
         self.state.mode = details.mode
         self.state.fan_level = details.level or 0
-        self.state.fan_set_level = details.levelNew
+        self.state.fan_set_level = details.level or 0
         self.state.set_air_quality_level(details.airQuality)
 
     async def get_details(self) -> None:
@@ -928,6 +926,12 @@ class VeSyncAir131(BypassV1Mixin, VeSyncPurifier):
             _LOGGER.debug('Invalid purifier mode used - %s', mode)
             return False
 
+        if mode == PurifierModes.MANUAL:
+            set_level = (
+                1 if self.state.fan_set_level in [0, None] else self.state.fan_set_level
+            )
+            return await self.set_fan_speed(set_level)
+
         update_dict = {
             "mode": mode
         }

{pyvesync-3.0.0b0 → pyvesync-3.0.0b2}/src/pyvesync/models/fan_models.py

@@ -33,7 +33,7 @@ class TowerFanResult(BypassV2InnerResult):
     thermalComfort: int
     errorCode: int
     scheduleCount: int
-    displayingType: int = IntFlag.NOT_SUPPORTED
+    displayingType: int | None = None
     sleepPreference: FanSleepPreferences | None = None
 
 

{pyvesync-3.0.0b0 → pyvesync-3.0.0b2}/src/pyvesync/models/home_models.py

@@ -20,7 +20,6 @@ from dataclasses import dataclass, field
 
 from pyvesync.models.base_models import (
     ResponseCodeModel,
-    ResponseBaseModel,
     RequestBaseModel,
     DefaultValues,
     )
@@ -36,9 +35,9 @@ class RequestHomeModel(RequestBaseModel):
     """
     # Arguments set by Manager Instance by passing kw_argument manager
     # these fields should be set to init=False
-    accountID: str = field(init=False)
-    token: str = field(init=False)
-    userCountryCode: str = field(init=False)
+    accountID: str
+    token: str
+    userCountryCode: str
     # Non-default constants
     method: str = 'getHomeList'
     # default values
@@ -52,17 +51,17 @@ class RequestHomeModel(RequestBaseModel):
 
 
 @dataclass
-class ResponseHomeModel(ResponseBaseModel):
+class ResponseHomeModel(ResponseCodeModel):
     """Model for the home data response.
 
-    Inherits from `ResponseBaseModel`. The `ResponseBaseModel` class provides the
+    Inherits from `ResponseCodeModel`. The `ResponseCodeModel` class provides the
     `code` and `msg` fields. The `ResponseHomeModel` class provides the `result`
     field containing the home data.
 
     Attributes:
         result: dict: The home data.
     """
-    result: IntResponseHomeResultModel
+    result: IntResponseHomeResultModel | IntResponseHomeInfoResultModel | None
 
 
 @dataclass
@@ -154,5 +153,6 @@ class IntResponseHomeResultModel:
 @dataclass
 class IntResponseHomeListModel:
     """Internal model for the 'homeList' field in home response result."""
-    homeID: str
+    homeId: int
     homeName: str
+    nickname: str | None = None

{pyvesync-3.0.0b0 → pyvesync-3.0.0b2}/src/pyvesync/models/humidifier_models.py

@@ -73,8 +73,8 @@ class ClassicLVHumidResult(InnerHumidifierBaseResult):
     automatic_stop_reach_target: bool = False
     water_tank_lifted: bool = False
     warm_enabled: bool = False
-    warm_level: int = IntFlag.NOT_SUPPORTED
-    night_light_brightness: int = IntFlag.NOT_SUPPORTED
+    warm_level: int | None = None
+    night_light_brightness: int | None = None
     configuration: ClassicConfig | None = None
 
 

{pyvesync-3.0.0b0 → pyvesync-3.0.0b2}/src/pyvesync/models/purifier_models.py

@@ -12,7 +12,6 @@ from dataclasses import dataclass
 # import orjson
 from mashumaro.config import BaseConfig
 from mashumaro.types import Discriminator
-from pyvesync.const import IntFlag, StrFlag
 from pyvesync.models.bypass_models import (
     RequestBypassV1,
     BypassV2InnerResult,
@@ -53,11 +52,11 @@ class PurifierV2DetailsResult(InnerPurifierBaseResult):
     efficientModeTimeRemain: int
     errorCode: int
     autoPreference: VitalAutoPreferences | None = None
-    fanRotateAngle: int | None = IntFlag.NOT_SUPPORTED
-    filterOpenState: int | None = IntFlag.NOT_SUPPORTED
-    PM1: int | None = IntFlag.NOT_SUPPORTED
-    PM10: int | None = IntFlag.NOT_SUPPORTED
-    AQPercent: int | None = IntFlag.NOT_SUPPORTED
+    fanRotateAngle: int | None = None
+    filterOpenState: int | None = None
+    PM1: int | None = None
+    PM10: int | None = None
+    AQPercent: int | None = None
 
 
 @dataclass
@@ -81,8 +80,8 @@ class PurifierCoreDetailsResult(InnerPurifierBaseResult):
     configuration: PurifierCoreDetailsConfig | None = None
     extension: dict | None = None
     air_quality_value: int | None = None
-    night_light: str | None = StrFlag.NOT_SUPPORTED
-    fan_rotate: str | None = StrFlag.NOT_SUPPORTED
+    night_light: str | None = None
+    fan_rotate: str | None = None
 
 
 # Purifier Timer Models

{pyvesync-3.0.0b0 → pyvesync-3.0.0b2}/src/pyvesync/models/vesync_models.py

@@ -31,14 +31,19 @@ class RequestLoginModel(RequestBaseModel):
     password: str
     # default values
     acceptLanguage: str = DefaultValues.acceptLanguage
-    appVersion: str = DefaultValues.appVersion
+    accountID: str = ''
+    clientInfo: str = DefaultValues.phoneBrand
+    clientType: str = "vesyncApp"
+    clientVersion: str = f"VeSync {DefaultValues.appVersion}"
+    debugMode: bool = False
+    osInfo: str = DefaultValues.phoneOS
+    terminalId: str = DefaultValues.terminalId
     timeZone: str = DefaultValues.timeZone
-    phoneBrand: str = DefaultValues.phoneBrand
-    phoneOS: str = DefaultValues.phoneOS
-    traceId: str = field(default_factory=DefaultValues.traceId)
-    # Non-default constants
-    userType: str = '1'
+    token: str = ''
+    userCountryCode: str = ''
     devToken: str = ''
+    userType: str = DefaultValues.userType
+    traceId: str = field(default_factory=DefaultValues.newTraceId)
 
     def __post_init__(self) -> None:
         """Set the method field."""
@@ -54,7 +59,7 @@ class RequestLoginModel(RequestBaseModel):
 class IntRespLoginResultModel(ResponseBaseModel):
     """Model for the 'result' field in login response containing token and account ID.
 
-    This class is inherited by the `ResponseLoginModel` class.
+    This class is referenced by the `ResponseLoginModel` class.
     """
     accountID: str
     acceptLanguage: str
@@ -85,6 +90,7 @@ class ResponseLoginModel(ResponseCodeModel):
                 "accountID": "123456",
                 "acceptLanguage": "en",
                 "countryCode": "US",
+                "token": "abcdef1234567890"
                 }
         }
         b = ResponseLoginModel.from_dict(a)
@@ -93,8 +99,6 @@ class ResponseLoginModel(ResponseCodeModel):
         ```
     """
     result: IntRespLoginResultModel
-    stacktrace: str | None
-    module: str | None
 
 
 @dataclass
@@ -154,7 +158,7 @@ class ResponseDeviceDetailsModel(ResponseBaseModel):
     subDeviceType: str | None
     subDeviceList: None | str
     extension: None | InternalDeviceListExtension
-    subDeviceNo: int = 0
+    subDeviceNo: int | None = None
     deviceStatus: str = "off"
     connectionStatus: str = "offline"
     productType: str | None = None
@@ -182,8 +186,6 @@ class ResponseDeviceDetailsModel(ResponseBaseModel):
         """
         super().__pre_deserialize__(d)
         d = _flatten_device_prop(d)
-        if d.get('subDeviceNo') is None:
-            d['subDeviceNo'] = 0
         if d.get('cid') is None:
             d['cid'] = d.get('uuid') if d.get('uuid') is not None else d.get("macID")
         return d
@@ -250,3 +252,52 @@ class RequestPID(RequestBaseModel):
     mobileID: str
     configModule: str
     region: str
+
+
+@dataclass
+class RequestFirmwareModel(RequestBaseModel):
+    """Model for the firmware request."""
+    accountID: str
+    timeZone: str
+    token: str
+    userCountryCode: str
+    cidList: list[str]
+    acceptLanguage: str = DefaultValues.acceptLanguage
+    traceId: str = field(default_factory=DefaultValues.traceId)
+    appVersion: str = DefaultValues.appVersion
+    phoneBrand: str = DefaultValues.phoneBrand
+    phoneOS: str = DefaultValues.phoneOS
+    method: str = "getFirmwareUpdateInfoList"
+    debugMode: bool = False
+
+
+@dataclass
+class ResponseFirmwareModel(ResponseCodeModel):
+    """Model for the firmware response."""
+    result: FirmwareResultModel
+
+
+@dataclass
+class FirmwareUpdateInfoModel(ResponseBaseModel):
+    """Firmware update information model."""
+    currentVersion: str
+    latestVersion: str
+    releaseNotes: str
+    pluginName: str
+    isMainFw: bool
+
+
+@dataclass
+class FirmwareDeviceItemModel(ResponseBaseModel):
+    """Model for the firmware device item in the firmware response."""
+    deviceCid: str
+    deviceName: str
+    code: int
+    msg: str | None
+    firmUpdateInfos: list[FirmwareUpdateInfoModel]
+
+
+@dataclass
+class FirmwareResultModel(ResponseBaseModel):
+    """Model for the firmware response result."""
+    cidFwInfoList: list[FirmwareDeviceItemModel]

{pyvesync-3.0.0b0 → pyvesync-3.0.0b2}/src/pyvesync/utils/errors.py

@@ -794,7 +794,7 @@ class VeSyncTokenError(VeSyncError):
 
     def __init__(self) -> None:
         """Initialize the exception with a message."""
-        super().__init__("Token expired or invalid - please re-authenticate")
+        super().__init__("Token expired or invalid - please re-authenticate with login()")
 
 
 class VeSyncServerError(VeSyncError):

{pyvesync-3.0.0b0 → pyvesync-3.0.0b2}/src/pyvesync/utils/helpers.py

@@ -38,8 +38,6 @@ T_MODEL = TypeVar('T_MODEL', bound=DataClassORJSONMixin)
 
 _LOGGER = logging.getLogger(__name__)
 
-API_BASE_URL = 'https://smartapi.vesync.com'
-API_RATE_LIMIT = 30
 NUMERIC_OPT = Union[float, str, None]
 
 NUMERIC_STRICT = Union[float, str]

{pyvesync-3.0.0b0 → pyvesync-3.0.0b2}/src/pyvesync/utils/logs.py

@@ -19,6 +19,7 @@ from __future__ import annotations
 import logging
 import os
 import re
+from pathlib import Path
 from collections.abc import Mapping
 from dataclasses import fields, is_dataclass
 from typing import TYPE_CHECKING
@@ -210,7 +211,11 @@ class LibraryLogger:
         handler.setFormatter(formatter)
         root_logger.addHandler(handler)
         if file_name:
-            file_handler = logging.FileHandler(file_name)
+            if not Path(file_name).is_absolute():
+                file_name_path = Path(file_name).joinpath(Path.cwd(), file_name)
+            else:
+                file_name_path = Path(file_name)
+            file_handler = logging.FileHandler(file_name_path)
             file_handler.setFormatter(formatter)
             root_logger.addHandler(file_handler)
         for log_name, logger in root_logger.manager.loggerDict.items():

{pyvesync-3.0.0b0 → pyvesync-3.0.0b2}/src/pyvesync/vesync.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 import logging
 import asyncio
 from typing import Self
+from dataclasses import fields, MISSING
 from aiohttp import ClientSession
 from aiohttp.client_exceptions import ClientResponseError
 from mashumaro.mixins.orjson import DataClassORJSONMixin
@@ -16,7 +17,10 @@ from pyvesync.models.vesync_models import (
     RequestDeviceListModel,
     ResponseDeviceListModel,
     RequestLoginModel,
-    ResponseLoginModel
+    ResponseLoginModel,
+    RequestFirmwareModel,
+    ResponseFirmwareModel,
+    FirmwareDeviceItemModel
     )
 from pyvesync.utils.errors import (
     ErrorCodes,
@@ -130,7 +134,6 @@ class VeSync:  # pylint: disable=function-redefined
         self._verbose: bool = False
         self.time_zone: str = time_zone
         self.language: str = 'en'
-
         self.enabled = False
         self.in_process = False
         self._device_container: DeviceContainer = DeviceContainerInstance
@@ -299,11 +302,11 @@ class VeSync:  # pylint: disable=function-redefined
             raise VesyncLoginError('Username and password must be specified')
         request_login = RequestLoginModel(
             email=self.username,
-            method='login',
+            method='appLoginV3',
             password=self.password,
         )
         resp_dict, _ = await self.async_call_api(
-            '/cloud/v1/user/login', 'post',
+            '/user/api/accountManage/v3/appLoginV3', 'post',
             json_object=request_login
         )
         if resp_dict is None:
@@ -443,3 +446,69 @@ class VeSync:  # pylint: disable=function-redefined
         except ClientResponseError as e:
             LibraryLogger.log_api_exception(logger, exception=e, request_body=req_dict)
             raise
+
+    def _update_fw_version(self, info_list: list[FirmwareDeviceItemModel]) -> bool:
+        """Update device firmware versions from API response."""
+        if not info_list:
+            logger.debug('No devices found in firmware response')
+            return False
+        update_dict = {}
+        for device in info_list:
+            if not device.firmUpdateInfos:
+                if device.code != 0:
+                    logger.debug(
+                        'Device %s has error code %s with message: %s',
+                        device.deviceName, device.code, device.msg
+                    )
+                else:
+                    logger.debug(
+                        'Device %s has no firmware updates available',
+                        device.deviceName
+                    )
+                continue
+            for update_info in device.firmUpdateInfos:
+                update_dict[device.deviceCid] = (
+                    update_info.currentVersion, update_info.latestVersion
+                    )
+                if update_info.isMainFw is True:
+                    break
+        for device_obj in self._device_container:
+            if device_obj.cid in update_dict:
+                device_obj.latest_firm_version = update_dict[device_obj.cid][1]
+                device_obj.current_firm_version = update_dict[device_obj.cid][0]
+        return True
+
+    async def check_firmware(self) -> bool:
+        """Check for firmware updates for all devices.
+
+        This method will check for firmware updates for all devices in the
+        device container. It will call the `get_firmware_update()` method on
+        each device and log the results.
+        """
+        if len(self._device_container) == 0:
+            logger.debug('No devices to check for firmware updates')
+            return False
+        body_fields = [
+            field.name for field in fields(RequestFirmwareModel)
+            if field.default_factory is MISSING and field.default is MISSING
+        ]
+        body = Helpers.get_class_attributes(self, body_fields)
+        body['cidList'] = [device.cid for device in self._device_container]
+        resp_dict, _ = await self.async_call_api(
+            '/cloud/v2/deviceManaged/getFirmwareUpdateInfoList',
+            'post',
+            json_object=RequestFirmwareModel(**body),
+        )
+        if resp_dict is None:
+            raise VeSyncAPIResponseError(
+                'Error receiving response to firmware update request')
+        resp_model = ResponseFirmwareModel.from_dict(resp_dict)
+        if resp_model.code != 0:
+            error_info = ErrorCodes.get_error_info(resp_model.code)
+            resp_message = resp_model.msg
+            if resp_message is not None:
+                error_info.message = f'{error_info.message} ({resp_message})'
+            logger.debug('Error in firmware update response: %s', error_info.message)
+            return False
+        info_list = resp_model.result.cidFwInfoList
+        return self._update_fw_version(info_list)

pyvesync-3.0.0b2/src/pyvesync/vesynchome.py

@@ -0,0 +1,162 @@
+"""This is a WIP, not implemented yet."""
+from __future__ import annotations
+import logging
+import asyncio
+from typing import TYPE_CHECKING
+from dataclasses import fields
+
+from pyvesync.utils.errors import ErrorCodes, VeSyncAPIResponseError
+from pyvesync.utils.helpers import Helpers
+from pyvesync.models.home_models import (
+    IntResponseHomeResultModel,
+    IntResponseHomeListModel,
+    ResponseHomeModel,
+    RequestHomeModel,
+)
+from pyvesync.models.base_models import DefaultValues
+
+if TYPE_CHECKING:
+    from pyvesync.vesync import VeSync
+    from pyvesync.models.base_models import RequestBaseModel
+    from pyvesync.base_devices import VeSyncBaseDevice
+
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class VeSyncHome:
+    """Class to handle home-related operations in VeSync."""
+
+    def __init__(self, home_id: int, name: str, nickname: str | None = None) -> None:
+        """Initialize the VeSyncHome instance."""
+        self.home_id: int = home_id
+        self.name: str = name
+        self.nickname: str | None = nickname
+        self.rooms: list[VeSyncRoom] = []
+
+    @property
+    def devices(self) -> list[VeSyncBaseDevice]:
+        """Return a list of all devices in the home."""
+        devices = []
+        for room in self.rooms:
+            devices.extend(room.devices)
+        return devices
+
+    async def update_devices(self, devices: list[VeSyncBaseDevice]) -> None:
+        """Update the devices in the home."""
+        update_tasks = [device.update() for device in devices]
+        for update_coro in asyncio.as_completed(update_tasks):
+            try:
+                await update_coro
+            except Exception as e:
+                _LOGGER.debug('Error updating device %s', e)
+
+    @staticmethod
+    def _build_request_model(
+        manager: VeSync, request_model: type[RequestBaseModel]
+    ) -> RequestBaseModel:
+        """Build the request model for home data."""
+        req_fields = [field.name for field in fields(request_model) if field.init]
+        body = Helpers.get_class_attributes(DefaultValues, req_fields)
+        body.update(Helpers.get_class_attributes(manager, req_fields))
+        return request_model(**body)
+
+    @classmethod
+    def _process_home_list(
+        cls, home_list: list[IntResponseHomeListModel]
+    ) -> list[VeSyncHome]:
+        """Process the home list and return a list of VeSyncHome instances."""
+        homes = []
+        for home in home_list:
+            if not isinstance(home, IntResponseHomeListModel):
+                raise VeSyncAPIResponseError(
+                    "Invalid home list item type."
+                    f"Expected IntResponseHomeListModel, got {home}"
+                )
+            homes.append(VeSyncHome(home.homeId, home.homeName, home.nickname))
+        return homes
+
+    @classmethod
+    async def build_homes(cls, manager: VeSync) -> bool:
+        """Get home information.
+
+        This method retrieves the home list from the VeSync API and populates
+        the VeSyncHome instances in the manager. The objects are stored in
+        `manager.homes` attribute as a list.
+
+        Args:
+            manager (VeSync): The VeSync instance to use for the API call.
+
+        Returns:
+            bool: True if the home list was successfully retrieved and populated.
+
+        Raises:
+            VeSyncAPIResponseError: If the API response contains an error or
+                if the home list is empty.
+        """
+        body = cls._build_request_model(manager, RequestHomeModel)
+        response, _ = await manager.async_call_api(
+            '/cloud/v1/homeManaged/getHomeList',
+            method='post',
+            json_object=body
+        )
+        if response is None:
+            raise VeSyncAPIResponseError(
+                "Response is None, enable debugging to see more information."
+            )
+
+        resp_model = ResponseHomeModel.from_dict(response)
+        if resp_model.code != 0:
+            error = ErrorCodes.get_error_info(resp_model.code)
+            if resp_model.msg is not None:
+                error.message = f"{resp_model.msg} ({error.message})"
+            raise VeSyncAPIResponseError(
+                f"Failed to get home list with error: {error.to_json()}"
+            )
+        result = resp_model.result
+        if not isinstance(result, IntResponseHomeResultModel):
+            raise VeSyncAPIResponseError(
+                "Error in home list API response."
+                f"Expected IntResponseHomeResultModel, got {result}"
+            )
+        home_list = result.homeList
+        if not home_list:
+            raise VeSyncAPIResponseError(
+                "No homes found in the response."
+            )
+        for home in home_list:
+            if not isinstance(home, IntResponseHomeListModel):
+                raise VeSyncAPIResponseError(
+                    "Invalid home list item type."
+                    f"Expected IntResponseHomeListModel, got {home}"
+                )
+            # clear existing homes
+            # manager.homes = []
+            # manager.homes.append(
+            #     VeSyncHome(
+            #         home_id=home.homeId,
+            #         name=home.homeName,
+            #         nickname=home.nickname
+            #     )
+            # )
+        return True
+
+
+class VeSyncRoom:
+    """Class to handle room-related operations in VeSync."""
+
+    def __init__(self, room_id: str, name: str) -> None:
+        """Initialize the VeSyncRoom instance."""
+        self.room_id: str = room_id
+        self.name: str = name
+        self.devices: list[VeSyncBaseDevice] = []
+
+    @staticmethod
+    def _build_request_model(
+        manager: VeSync, request_model: type[RequestBaseModel]
+    ) -> RequestBaseModel:
+        """Build the request model for room data."""
+        req_fields = [field.name for field in fields(request_model) if field.init]
+        body = Helpers.get_class_attributes(DefaultValues, req_fields)
+        body.update(Helpers.get_class_attributes(manager, req_fields))
+        return request_model(**body)

{pyvesync-3.0.0b0 → pyvesync-3.0.0b2/src/pyvesync.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyvesync
-Version: 3.0.0b0
+Version: 3.0.0b2
 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>
@@ -340,7 +340,7 @@ manager.devices.outlets = [VeSyncOutletInstances]
 manager.devices.switches = [VeSyncSwitchInstances]
 manager.devices.fans = [VeSyncFanInstances]
 manager.devices.bulbs = [VeSyncBulbInstances]
-manager.devices.purifiers = [VeSyncPurifierInstances]
+manager.devices.air_purifiers = [VeSyncPurifierInstances]
 manager.devices.humidifiers = [VeSyncHumidifierInstances]
 manager.devices.air_fryers = [VeSyncAirFryerInstances]
 managers.devices.thermostats = [VeSyncThermostatInstances]

{pyvesync-3.0.0b0 → pyvesync-3.0.0b2}/src/pyvesync.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ src/pyvesync/const.py
 src/pyvesync/device_container.py
 src/pyvesync/device_map.py
 src/pyvesync/vesync.py
+src/pyvesync/vesynchome.py
 src/pyvesync.egg-info/PKG-INFO
 src/pyvesync.egg-info/SOURCES.txt
 src/pyvesync.egg-info/dependency_links.txt