pyvesync 3.0.0b0__py3-none-any.whl

pyvesync/models/purifier_models.py

@@ -0,0 +1,204 @@
+"""Data models for VeSync Purifiers.
+
+These models inherit from `ResponseBaseModel` and `RequestBaseModel` from the
+`base_models` module.
+
+The `InnerPurifierBaseResult` class is used as a base class for the inner purifier
+result models for all models and the mashumaro discriminator determines the correct
+subclass when deserializing.
+"""
+from __future__ import annotations
+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,
+    BypassV1Result,
+)
+from pyvesync.models.base_models import (
+    ResponseBaseModel,
+    RequestBaseModel,
+    )
+
+
+@dataclass
+class InnerPurifierBaseResult(BypassV2InnerResult):
+    """Base class for inner purifier results model."""
+
+    class Config(BaseConfig):  # type: ignore[override]
+        """Configure the results model to use subclass discriminator."""
+        discriminator = Discriminator(include_subtypes=True)
+
+
+@dataclass
+class PurifierV2DetailsResult(InnerPurifierBaseResult):
+    """Vital 100S/200S and Everest Purifier Result Model."""
+    powerSwitch: int
+    filterLifePercent: int
+    workMode: str
+    manualSpeedLevel: int
+    fanSpeedLevel: int
+    AQLevel: int
+    PM25: int
+    screenState: int
+    childLockSwitch: int
+    screenSwitch: int
+    lightDetectionSwitch: int
+    environmentLightState: int
+    scheduleCount: int
+    timerRemain: int
+    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
+
+
+@dataclass
+class VitalAutoPreferences:
+    """Vital 100S/200S Auto Preferences."""
+    autoPreferenceType: str
+    roomSize: int
+
+
+@dataclass
+class PurifierCoreDetailsResult(InnerPurifierBaseResult):
+    """Purifier inner Result Dict."""
+    enabled: bool
+    filter_life: int
+    mode: str
+    level: int
+    device_error_code: int
+    air_quality: int | None = None
+    display: bool | None = None
+    child_lock: bool | None = None
+    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
+
+
+# Purifier Timer Models
+
+
+@dataclass
+class PurifierModifyTimerResult(InnerPurifierBaseResult):
+    """Purifier inner Add Timer Result Dict."""
+    id: int
+
+
+@dataclass
+class PurifierGetTimerResult(InnerPurifierBaseResult):
+    """Purifier inner Timer Result Dict."""
+    timers: list[ResponsePurifierTimerItems] | None
+
+
+@dataclass
+class ResponsePurifierTimerItems(ResponseBaseModel):
+    """Purifier Timer Items Response Dict."""
+    id: int
+    remain: int
+    total: int
+    action: str
+
+
+@dataclass
+class PurifierV2TimerPayloadData(RequestBaseModel):
+    """Purifier Timer Payload Data Request Dict."""
+    enabled: bool
+    startAct: list[PurifierV2TimerActionItems]
+    tmgEvt: PurifierV2EventTiming | None = None
+    type: int = 0
+    subDeviceNo: int = 0
+    repeat: int = 0
+
+
+@dataclass
+class PurifierV2TimerActionItems(RequestBaseModel):
+    """Purifier Timer Action Items Request Dict."""
+    type: str
+    act: int
+    num: int = 0
+
+
+@dataclass
+class PurifierV2EventTiming(RequestBaseModel):
+    """Purifier Event Timing Request Dict."""
+    clkSec: int
+
+
+# Internal Purifier Details Models
+
+
+@dataclass
+class PurifierCoreDetailsConfig(ResponseBaseModel):
+    """Config dict in Core purifier details response."""
+    display: bool
+    display_forever: bool
+    auto_preference: None | PurifierCoreAutoConfig
+
+
+@dataclass
+class PurifierCoreAutoConfig(ResponseBaseModel):
+    """Auto configuration Core dict in purifier details response."""
+    type: str
+    room_size: int
+
+
+@dataclass
+class PurifierDetailsExtension(ResponseBaseModel):
+    """Extension dict in purifier details response for Core 200/300/400."""
+    schedule_count: int
+    timer_remain: int
+
+
+# LV - PUR131S Purifier Models
+
+
+@dataclass
+class RequestPurifier131(RequestBypassV1):
+    """Purifier 131 Request Dict."""
+    status: str | None = None
+
+
+@dataclass
+class RequestPurifier131Mode(RequestBypassV1):
+    """Purifier 131 Request Dict."""
+    mode: str
+
+
+@dataclass
+class RequestPurifier131Level(RequestBypassV1):
+    """Purifier 131 Request Dict."""
+    level: int
+
+
+@dataclass
+class Purifier131Result(BypassV1Result):
+    """Purifier 131 Details Response Dict."""
+    screenStatus: str
+    filterLife: Purifier131Filter
+    activeTime: int
+    levelNew: int
+    level: int | None
+    mode: str
+    airQuality: str
+    deviceName: str
+    childLock: str
+    deviceStatus: str
+    connectionStatus: str
+
+
+@dataclass
+class Purifier131Filter(ResponseBaseModel):
+    """Filter details model for LV PUR131."""
+    change: bool
+    useHour: int
+    percent: int

pyvesync/models/switch_models.py

@@ -0,0 +1,89 @@
+"""Data models for VeSync switches.
+
+These models inherit from `ResponseBaseModel` and `RequestBaseModel` from the
+`base_models` module.
+"""
+from __future__ import annotations
+from typing import Any
+from dataclasses import dataclass
+import orjson
+from mashumaro.config import BaseConfig
+from pyvesync.models.bypass_models import RequestBypassV1
+from pyvesync.models.base_models import ResponseCodeModel, ResponseBaseModel
+
+
+@dataclass
+class ResponseSwitchDetails(ResponseCodeModel):
+    """Dimmer and Wall Switch Details Response Dict."""
+    result: InternalDimmerDetailsResult | InternalSwitchResult | None = None
+
+
+@dataclass
+class InternalSwitchResult(ResponseBaseModel):
+    """Dimmer Status Response Dict."""
+    deviceStatus: str
+    connectionStatus: str
+    activeTime: int
+
+
+@dataclass
+class InternalDimmerDetailsResult(ResponseBaseModel):
+    """Dimmer Details Result Dict."""
+    devicename: str
+    brightness: int
+    indicatorlightStatus: str
+    rgbStatus: str
+    rgbValue: DimmerRGB
+    deviceStatus: str
+    connectionStatus: str
+    activeTime: int = 0
+    timer: Any | None = None
+    schedule: Any | None = None
+    deviceImg: str | None = None
+
+
+@dataclass
+class DimmerRGB:
+    """Dimmer RGB Color Dict."""
+    red: int
+    green: int
+    blue: int
+
+
+@dataclass
+class RequestSwitchBase(RequestBypassV1):
+    """Base Dimmer Request Dict.
+
+    Inherits from RequestBypassV1 to include the common fields for all requests.
+    """
+
+
+@dataclass
+class RequestDimmerBrightness(RequestBypassV1):
+    """Dimmer Status Request Dict."""
+    brightness: str
+
+
+@dataclass
+class RequestDimmerDetails(RequestBypassV1):
+    """Dimmer Details Request Dict."""
+
+
+@dataclass
+class RequestSwitchStatus(RequestBypassV1):
+    """Dimmer Details Request Dict."""
+    status: str
+    switchNo: int
+
+
+@dataclass
+class RequestDimmerStatus(RequestBypassV1):
+    """Dimmer Status Request Dict."""
+    status: str
+    rgbValue: dict | None = None
+
+    class Config(BaseConfig):  # type: ignore[override]
+        """Dimmer Indicator Control Config Dict."""
+        omit_none = True
+        omit_default = True
+        orjson_options = orjson.OPT_NON_STR_KEYS

pyvesync/models/thermostat_models.py

@@ -0,0 +1,122 @@
+"""Data models for VeSync thermostats."""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+from mashumaro.mixins.orjson import DataClassORJSONMixin
+from mashumaro import field_options
+
+from pyvesync.const import ThermostatConst
+from pyvesync.models.bypass_models import BypassV2InnerResult
+
+
+@dataclass
+class ResultThermostatDetails(BypassV2InnerResult):
+    """Result model for thermostat details."""
+    supportMode: list[int]
+    workMode: int
+    workStatus: int
+    fanMode: int
+    fanStatus: int
+    tempUnit: str
+    temperature: float
+    humidity: int
+    heatToTemp: int
+    coolToTemp: int
+    lockStatus: bool
+    scheduleOrHold: int
+    holdEndTime: int
+    holdOption: int
+    deadband: int
+    ecoType: int
+    alertStatus: int
+    routines: list[ThermostatSimpleRoutine]
+    routineRunningId: int | None = None
+
+
+@dataclass
+class ThermostatSimpleRoutine(DataClassORJSONMixin):
+    """Thermostat routine model."""
+    name: str
+    routineId: int
+
+
+@dataclass
+class ThermostatRoutine(DataClassORJSONMixin):
+    """Model for full thermostat routine."""
+    name: str
+    routineId: int
+    type: int
+    heatToTemp: int
+    coolToTemp: int
+    heatFanMode: int
+    coolFanMode: int
+    usuallyMask: int
+    sensorIds: list[str]
+
+
+@dataclass
+class ThermostatMinorDetails(DataClassORJSONMixin):
+    """Model for thermostat minor details."""
+    mcu_version: str = field(metadata=field_options(alias="mcuVersion"))
+    hvac_capacity: int = field(metadata=field_options(alias="hvacCapcity"))
+    timestamp: int = field(metadata=field_options(alias="timeStamp"))
+    time_zone: int = field(metadata=field_options(alias="timeZone"))
+    offset_in_sec: int = field(metadata=field_options(alias="offsetInSec"))
+    time_fmt: int = field(metadata=field_options(alias="timeFmt"))
+    date_fmt: int = field(metadata=field_options(alias="dateFmt"))
+    fan_delay_time: int = field(metadata=field_options(alias="fanDelayTime"))
+    fan_circulation_time: int = field(metadata=field_options(alias="fanCirTime"))
+    hvac_protect_time: int = field(metadata=field_options(alias="hvacProtecTime"))
+    hvac_min_on_time: int = field(metadata=field_options(alias="hvacMinOnTime"))
+    aux_min_on_time: int = field(metadata=field_options(alias="auxMinOnTime"))
+    screen_brightness: int = field(metadata=field_options(alias="screenBrightness"))
+    standby_timeout: int = field(metadata=field_options(alias="standbyTimeOut"))
+    aux_low_temperature: int = field(metadata=field_options(alias="auxLowBalanceTemp"))
+    aux_high_temperature: int = field(metadata=field_options(alias="auxHighBalanceTemp"))
+    keytone: bool = field(metadata=field_options(alias="keyTone"))
+    smart_schedule_enabled: bool = field(
+        metadata=field_options(alias="smartScheduleEnabled")
+        )
+    time_to_temp_enabled: bool = field(metadata=field_options(alias="timeToTempEnabled"))
+    early_on_enabled: bool = field(metadata=field_options(alias="earlyOnEnabled"))
+    reminder_list: list[ThermostatReminder] = field(
+        metadata=field_options(alias="reminderList")
+    )
+    alarm_list: list[ThermostatAlarm] = field(metadata=field_options(alias="alarmList"))
+
+
+@dataclass
+class ThermostatReminder(DataClassORJSONMixin):
+    """Model for thermostat reminder."""
+    code: int
+    enabled: bool
+    frequency: int
+    code_name: str | None = None
+    last_maintenance_time: int | None = field(
+        default=None, metadata=field_options(alias="lastMaintenTime")
+    )
+
+    @classmethod
+    def __post_deserialize__(cls, obj: ThermostatReminder) -> ThermostatReminder:  # type: ignore[override]
+        """Post-deserialization processing."""
+        if isinstance(obj.code, int):
+            obj.code_name = ThermostatConst.ReminderCode(obj.code).name
+        return obj
+
+
+@dataclass
+class ThermostatAlarm(DataClassORJSONMixin):
+    """Model for thermostat alarm."""
+    code: int
+    enabled: bool
+    code_name: str | None = None
+    aux_runtime_limit: int | None = field(
+        default=None, metadata=field_options(alias="auxRunTimeLimit")
+    )
+
+    @classmethod
+    def __post_deserialize__(cls, obj: ThermostatAlarm) -> ThermostatAlarm:  # type: ignore[override]
+        """Post-deserialization processing."""
+        if obj.code is not None:
+            obj.code_name = ThermostatConst.AlarmCode(obj.code).name
+        return obj

pyvesync/models/vesync_models.py

@@ -0,0 +1,252 @@
+"""Models for general VeSync API requests and responses.
+
+Dataclasses should follow the naming convention of Request/Response + <API Name> + Model.
+Internal models should be named starting with IntResp/IntReq<API Name>Model.
+
+Note:
+    All models should inherit `ResponseBaseModel` or `RequestBaseModel`. Use
+    `pyvesync.models.base_models.DefaultValues` to set default values. There
+    should be no repeating keys set in the child models.
+
+"""
+from __future__ import annotations
+from dataclasses import dataclass, field
+import hashlib
+from typing import Any
+
+from pyvesync.models.base_models import (
+    ResponseCodeModel,
+    ResponseBaseModel,
+    RequestBaseModel,
+    DefaultValues,
+    )
+
+
+@dataclass
+class RequestLoginModel(RequestBaseModel):
+    """Request model for login."""
+    # Arguments to set
+    email: str
+    method: str
+    password: str
+    # default values
+    acceptLanguage: str = DefaultValues.acceptLanguage
+    appVersion: str = DefaultValues.appVersion
+    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'
+    devToken: str = ''
+
+    def __post_init__(self) -> None:
+        """Set the method field."""
+        self.password = self.hash_password(self.password)
+
+    @staticmethod
+    def hash_password(string: str) -> str:
+        """Encode password."""
+        return hashlib.md5(string.encode('utf-8')).hexdigest()  # noqa: S324
+
+
+@dataclass
+class IntRespLoginResultModel(ResponseBaseModel):
+    """Model for the 'result' field in login response containing token and account ID.
+
+    This class is inherited by the `ResponseLoginModel` class.
+    """
+    accountID: str
+    acceptLanguage: str
+    countryCode: str
+    token: str
+
+
+@dataclass
+class ResponseLoginModel(ResponseCodeModel):
+    """Model for the login response.
+
+    Inherits from `BaseResultModel`. The `BaseResultModel` class provides the
+    defaults "code" and "msg" fields for the response.
+
+    Attributes:
+        result: ResponseLoginResultModel
+            The inner model for the 'result' field in the login response.
+
+    Examples:
+        ```python
+        a = {
+            "code": 0,
+            "msg": "success",
+            "stacktrace": null,
+            "module": null,
+            "traceId": "123456",
+            "result": {
+                "accountID": "123456",
+                "acceptLanguage": "en",
+                "countryCode": "US",
+                }
+        }
+        b = ResponseLoginModel.from_dict(a)
+        account_id = b.result.accountId
+        token = b.result.token
+        ```
+    """
+    result: IntRespLoginResultModel
+    stacktrace: str | None
+    module: str | None
+
+
+@dataclass
+class RequestDeviceListModel(RequestBaseModel):
+    """Model for the device list request."""
+    token: str
+    accountID: str
+    timeZone: str = DefaultValues.timeZone
+    method: str = 'devices'
+    pageNo: int = 1
+    pageSize: int = 100
+    appVersion: str = DefaultValues.appVersion
+    phoneBrand: str = DefaultValues.phoneBrand
+    phoneOS: str = DefaultValues.phoneOS
+    acceptLanguage: str = DefaultValues.acceptLanguage
+    traceId: str = str(DefaultValues.traceId())
+
+
+def _flatten_device_prop(d: dict[str, Any]) -> dict[str, Any]:
+    """Flatten deviceProp field in device list response."""
+    if isinstance(d.get('deviceProp'), dict):
+        device_prop = d['deviceProp']
+        if device_prop.get('powerSwitch') is not None:
+            d['deviceStatus'] = "on" if device_prop['powerSwitch'] == 1 else "off"
+        if device_prop.get('connectionStatus') is not None:
+            d['connectionStatus'] = device_prop['connectionStatus']
+        if device_prop.get('wifiMac') is not None:
+            d['macID'] = device_prop['wifiMac']
+    del d['deviceProp']
+    return d
+
+
+@dataclass
+class ResponseDeviceDetailsModel(ResponseBaseModel):
+    """Internal response model for each device in device list response.
+
+    Populates the 'list' field in the `InternalDeviceListResult`.
+
+    Certain Devices have device status information in the `deviceProp` or `extension`
+    fields. This model flattens those fields into the `deviceStatus` and
+    `connectionStatus` fields before deserialization.
+    """
+    deviceRegion: str
+    isOwner: bool
+    deviceName: str
+    deviceImg: str
+    cid: str
+    connectionType: str
+    deviceType: str
+    type: str
+    uuid: str | None
+    configModule: str
+    macID: str
+    mode: str
+    speed: str | None
+    currentFirmVersion: str
+    subDeviceType: str | None
+    subDeviceList: None | str
+    extension: None | InternalDeviceListExtension
+    subDeviceNo: int = 0
+    deviceStatus: str = "off"
+    connectionStatus: str = "offline"
+    productType: str | None = None
+    # deviceProp: InitVar[None | InternalDevicePropModel] = None
+
+    # def __post_init__(self, deviceProp: None | IntRespDevicePropModel) -> None:
+    #     """Set productType based on deviceType."""
+    #     if deviceProp is not None:
+    #         if deviceProp.powerSwitch == 1:
+    #             self.deviceStatus = "on"
+    #         elif deviceProp.powerSwitch == 0:
+    #             self.deviceStatus = "off"
+    #         if isinstance(deviceProp.connectionStatus, str) and \
+    #                 self.connectionStatus != deviceProp.connectionStatus:
+    #             self.connectionStatus = deviceProp.connectionStatus
+
+    @classmethod
+    def __pre_deserialize__(cls, d: dict[Any, Any]) -> dict[Any, Any]:
+        """Perform device_list pre-deserialization processes.
+
+        This performs the following:
+            - Flattens the deviceProp field into deviceStatus and connectionStatus fields
+            - Sets subDeviceNo to 0 if not present
+            - Sets cid to uuid or macID if null
+        """
+        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
+
+
+@dataclass
+class InternalDeviceListResult(ResponseBaseModel):
+    """Internal model for the 'result' field in device list response.
+
+    Notes:
+      Used by the `ResponseDeviceListModel` class to populate result field.
+    """
+    total: int
+    pageSize: int
+    pageNo: int
+    list: list[ResponseDeviceDetailsModel]
+
+
+@dataclass
+class ResponseDeviceListModel(ResponseCodeModel):
+    """Device list response model.
+
+    Inherits from `BaseResultModel`. The `BaseResultModel` class provides the
+    defaults "code" and "msg" fields for the response.
+
+    Attributes:
+        result: InternalDeviceListResult
+            The inner model for the 'result' field in the device list response.
+        module: str | None
+        stacktrace: str | None
+
+    Notes:
+        See the `DeviceListResultModel` and `DeviceListDeviceModel` classes for
+        the inner model of the 'result' field.
+    """
+    module: str | None
+    stacktrace: str | None
+    result: InternalDeviceListResult
+
+
+@dataclass
+class InternalDeviceListExtension(ResponseBaseModel):
+    """Internal Optional 'extension' field in device list response.
+
+    Used by the `InnerRespDeviceListDevModel` class to populate
+    the extension field in the device list response.
+    """
+    airQuality: None | int
+    airQualityLevel: None | int
+    mode: None | str
+    fanSpeedLevel: None | str
+
+
+@dataclass
+class RequestPID(RequestBaseModel):
+    """Model for the PID request."""
+    method: str
+    appVersion: str
+    phoneBrand: str
+    phoneOS: str
+    traceId: str
+    token: str
+    accountID: str
+    mobileID: str
+    configModule: str
+    region: str

pyvesync/utils/__init__.py

@@ -0,0 +1 @@
+"""Helper utilities and classes for the VeSync API."""