blueair-api 1.9.1__py3-none-any.whl → 1.33.1__py3-none-any.whl

blueair_api/__init__.py

@@ -4,3 +4,4 @@ from .http_aws_blueair import HttpAwsBlueair
 from .util_bootstrap import get_devices, get_aws_devices
 from .device import Device
 from .device_aws import DeviceAws
+from .model_enum import ModelEnum, FeatureEnum

blueair_api/callbacks.py

@@ -4,6 +4,8 @@ _LOGGER = logging.getLogger(__name__)
 
 
 class CallbacksMixin:
+    __slots__ = ['_callbacks']
+
     def _setup_callbacks(self):
         self._callbacks = set()
 
@@ -20,6 +22,6 @@ class CallbacksMixin:
     def publish_updates(self) -> None:
         if not hasattr(self, "_callbacks"):
             self._setup_callbacks()
-        _LOGGER.debug(f"{self.name} publishing updates")
+        _LOGGER.debug(f"{id(self)} publishing updates")
         for callback in self._callbacks:
             callback()

blueair_api/const.py

@@ -1,7 +1,5 @@
-from typing import Union
 from collections.abc import Mapping
-from typing_extensions import TypedDict
-
+from typing import TypedDict
 
 SENSITIVE_FIELD_NAMES = [
     "username",
@@ -11,13 +9,6 @@ SENSITIVE_FIELD_NAMES = [
 # The BlueAir API uses a fixed API key.
 API_KEY = "eyJhbGciOiJIUzI1NiJ9.eyJncmFudGVlIjoiYmx1ZWFpciIsImlhdCI6MTQ1MzEyNTYzMiwidmFsaWRpdHkiOi0xLCJqdGkiOiJkNmY3OGE0Yi1iMWNkLTRkZDgtOTA2Yi1kN2JkNzM0MTQ2NzQiLCJwZXJtaXNzaW9ucyI6WyJhbGwiXSwicXVvdGEiOi0xLCJyYXRlTGltaXQiOi0xfQ.CJsfWVzFKKDDA6rWdh-hjVVVE9S3d6Hu9BzXG9htWFw"  # noqa: E501
 
-MeasurementBundle = TypedDict(
-    "MeasurementBundle",
-    {"sensors": list[str], "datapoints": list[list[Union[int, float]]]},
-)
-
-MeasurementList = list[Mapping[str, Union[int, float]]]
-
 AWS_APIKEYS = {
     "us": {
         "gigyaRegion": "us1",
@@ -32,3 +23,11 @@ AWS_APIKEYS = {
         "apiKey": "3_qRseYzrUJl1VyxvSJANalu_kNgQ83swB1B9uzgms58--5w1ClVNmrFdsDnWVQQCl",
     },
 }
+
+
+class MeasurementBundle(TypedDict):
+    sensors: list[str]
+    datapoints: list[list[int | float]]
+
+
+MeasurementList = list[Mapping[str, int | float]]

blueair_api/device.py

@@ -1,97 +1,134 @@
-import logging
-
 from .callbacks import CallbacksMixin
 from .http_blueair import HttpBlueair
+from .util import transform_data_points, safely_get_json_value, convert_none_to_not_implemented
+from dataclasses import dataclass, field
+from logging import getLogger
 
-_LOGGER = logging.getLogger(__name__)
+_LOGGER = getLogger(__name__)
 
 
+@dataclass(slots=True)
 class Device(CallbacksMixin):
-    uuid: str = None
-    name: str = None
-    timezone: str = None
-    compatibility: str = None
-    model: str = None
-    mac: str = None
-    firmware: str = None
-    mcu_firmware: str = None
-    wlan_driver: str = None
-    room_location: str = None
+    @classmethod
+    async def create_device(cls, api, uuid, name, mac, refresh=False):
+        _LOGGER.debug("UUID:"+uuid)
+        info = await api.get_info(uuid)
+        device = Device(
+            api=api,
+            uuid=uuid,
+            name=name,
+            mac=mac,
+            timezone=info["timezone"],
+            compatibility=info["compatibility"],
+            model=info["model"],
+            firmware=info["firmware"],
+            mcu_firmware=info["mcuFirmware"],
+            wlan_driver=info["wlanDriver"],
+            room_location=info["roomLocation"]
+        )
+        if refresh:
+            await device.refresh()
+        _LOGGER.debug(f"create_device blueair device: {device}")
+        return device
+
+    api: HttpBlueair = field(repr=False)
+    raw_info : dict[str: any] = field(repr=False, init=False)
 
-    brightness: int = None
-    child_lock: bool = None
-    night_mode: bool = None
-    fan_speed: int = None
-    fan_mode: str = None
-    filter_expired: bool = None
-    wifi_working: bool = None
+    uuid: str | None = None
+    name: str | None = None
+    timezone: str | None = None
+    compatibility: str | None = None
+    model: str | None = None
+    mac: str | None = None
+    firmware: str | None = None
+    mcu_firmware: str | None = None
+    wlan_driver: str | None = None
+    room_location: str | None = None
 
-    def __init__(
-        self,
-        api: HttpBlueair,
-        uuid: str = None,
-        name: str = None,
-        mac: str = None,
-    ):
-        self.api = api
-        self.uuid = uuid
-        self.name = name
-        self.mac = mac
-        _LOGGER.debug(f"creating blueair device: {self.name}")
+    brightness: int | None = None
+    child_lock: bool | None = None
+    night_mode: bool | None = None
+    fan_speed: int | None = None
+    fan_auto_mode: bool | None = None
+    filter_expired: bool | None = None
+    wifi_working: bool | None = None
 
-    async def init(self):
-        info = await self.api.get_info(self.uuid)
-        self.timezone = info["timezone"]
-        self.compatibility = info["compatibility"]
-        self.model = info["model"]
-        self.firmware = info["firmware"]
-        self.mcu_firmware = info["mcuFirmware"]
-        self.wlan_driver = info["wlanDriver"]
-        self.room_location = info["roomLocation"]
+    pm1: int | None = NotImplemented
+    pm10: int | None = NotImplemented
+    pm25: int | None = NotImplemented
+    voc: int | None = NotImplemented
+    co2: int | None = NotImplemented
+    temperature: float | None = NotImplemented
+    humidity: float | None = NotImplemented
+    all_pollution: float | None = NotImplemented
 
     async def refresh(self):
         _LOGGER.debug("Requesting current attributes...")
+        self.raw_info = {}
         attributes = await self.api.get_attributes(self.uuid)
+        self.raw_info["attributes"] = attributes
         _LOGGER.debug(f"result: {attributes}")
         if "brightness" in attributes:
             self.brightness = int(attributes["brightness"])
         else:
-            self.brightness = 0
-        self.child_lock = bool(attributes["child_lock"])
+            self.brightness = NotImplemented
+        if "child_lock" in attributes:
+            self.child_lock = attributes["child_lock"] == "1"
+        else:
+            self.child_lock = NotImplemented
         if "night_mode" in attributes:
-            self.night_mode = bool(attributes["night_mode"])
-        self.fan_speed = int(attributes["fan_speed"])
-        self.filter_expired = attributes["filter_status"] != "OK"
-        self.fan_mode = attributes["mode"]
+            self.night_mode = attributes["night_mode"] == "1"
+        else:
+            self.night_mode = NotImplemented
+        if "fan_speed" in attributes:
+            self.fan_speed = int(attributes["fan_speed"])
+        else:
+            self.fan_speed = NotImplemented
+        if "filter_status" in attributes:
+            self.filter_expired = attributes["filter_status"] != "OK"
+        else:
+            self.filter_expired = NotImplemented
+        if "mode" in attributes:
+            self.fan_auto_mode = attributes["mode"] == "auto"
+        else:
+            self.fan_auto_mode = NotImplemented
         if "wifi_status" in attributes:
             self.wifi_working = attributes["wifi_status"] == "1"
         else:
-            self.wifi_working = 0
+            self.wifi_working = False
+        if self.compatibility != "sense+":
+            datapoints = transform_data_points(await self.api.get_data_points_since(self.uuid))
+            self.raw_info["datapoints"] = datapoints
+            for data_point in datapoints:
+                _LOGGER.debug(data_point)
+                self.pm25 = convert_none_to_not_implemented(safely_get_json_value(data_point, "pm25", int))
+                self.pm10 = convert_none_to_not_implemented(safely_get_json_value(data_point, "pm10", int))
+                self.pm1 = convert_none_to_not_implemented(safely_get_json_value(data_point, "pm1", int))
+                self.voc = convert_none_to_not_implemented(safely_get_json_value(data_point, "voc", int))
+                self.co2 = convert_none_to_not_implemented(safely_get_json_value(data_point, "co2", int))
+                self.temperature = convert_none_to_not_implemented(safely_get_json_value(data_point, "temperature", int))
+                self.humidity = convert_none_to_not_implemented(safely_get_json_value(data_point, "humidity", int))
+                self.all_pollution = convert_none_to_not_implemented(safely_get_json_value(data_point, "all_pollution", int))
+        _LOGGER.debug(f"refreshed blueair device: {self}")
         self.publish_updates()
 
-    async def set_fan_speed(self, new_speed):
+    async def set_fan_speed(self, new_speed: str):
+        self.fan_speed = int(new_speed)
         await self.api.set_fan_speed(self.uuid, new_speed)
+        self.publish_updates()
+
+    async def set_brightness(self, new_brightness: int):
+        self.brightness = new_brightness
+        await self.api.set_brightness(self.uuid, new_brightness)
+        self.publish_updates()
 
-    def __repr__(self):
-        return {
-            "uuid": self.uuid,
-            "name": self.name,
-            "timezone": self.timezone,
-            "compatibility": self.compatibility,
-            "model": self.model,
-            "mac": self.mac,
-            "firmware": self.firmware,
-            "mcu_firmware": self.mcu_firmware,
-            "wlan_driver": self.wlan_driver,
-            "room_location": self.room_location,
-            "brightness": self.brightness,
-            "child_lock": self.child_lock,
-            "night_mode": self.night_mode,
-            "fan_speed": self.fan_speed,
-            "filter_expired": self.filter_expired,
-            "fan_mode": self.fan_mode,
-            "wifi_working": self.wifi_working,
-        }
+    async def set_child_lock(self, enabled: bool):
+        self.child_lock = enabled
+        await self.api.set_child_lock(self.uuid, enabled)
+        self.publish_updates()
+
+    async def set_fan_auto_mode(self, fan_auto_mode: bool):
+        self.fan_auto_mode = fan_auto_mode
+        await self.api.set_fan_auto_mode(self.uuid, fan_auto_mode)
+        self.publish_updates()
 
-    def __str__(self):
-        return f"{self.__repr__()}"

blueair_api/device_aws.py

@@ -1,78 +1,150 @@
 import logging
+from json import dumps
 
 from .callbacks import CallbacksMixin
 from .http_aws_blueair import HttpAwsBlueair
-from .util import convert_api_array_to_dict, safely_get_json_value
+from .model_enum import ModelEnum
+from . import intermediate_representation_aws as ir
+from dataclasses import dataclass, field
 
 _LOGGER = logging.getLogger(__name__)
 
+type AttributeType[T] = T | None
 
+@dataclass(slots=True)
 class DeviceAws(CallbacksMixin):
-    uuid: str = None
-    name: str = None
-    name_api: str = None
-    mac: str = None
-    firmware: str = None
-    mcu_firmware: str = None
-    serial_number: str = None
-
-    brightness: int = None
-    child_lock: int = None
-    fan_speed: int = None
-    fan_auto_mode: bool = None
-    running: bool = None
-    night_mode: bool = None
-    germ_shield: bool = None
-
-    pm1: int = None
-    pm2_5: int = None
-    pm10: int = None
-    tVOC: int = None
-    temperature: int = None
-    humidity: int = None
-    filter_usage: int = None  # percentage
-    wifi_working: bool = None
-
-    def __init__(
-        self,
-        api: HttpAwsBlueair,
-        uuid: str = None,
-        name_api: str = None,
-        mac: str = None,
-    ):
-        self.api = api
-        self.uuid = uuid
-        self.name_api = name_api
-        self.mac = mac
-        _LOGGER.debug(f"creating blueair device aws: {self.uuid}")
+    @classmethod
+    async def create_device(cls, api, uuid, name, mac, type_name, refresh=False):
+        _LOGGER.debug("UUID:"+uuid)
+        device_aws = DeviceAws(
+            api=api,
+            uuid=uuid,
+            name_api=name,
+            mac=mac,
+            type_name=type_name,
+        )
+        if refresh:
+            await device_aws.refresh()
+        _LOGGER.debug(f"create_device blueair device_aws: {device_aws}")
+        return device_aws
+
+    api: HttpAwsBlueair = field(repr=False)
+    raw_info : dict[str: any] = field(repr=False, init=False)
+
+    uuid : str | None = None
+    name : str | None = None
+    name_api : str | None = None
+    mac : str | None = None
+    type_name : str | None = None
+
+    # Attributes are defined below.
+    # We mandate that unittests shall test all fields of AttributeType.
+    sku : AttributeType[str] = None
+    firmware : AttributeType[str] = None
+    mcu_firmware : AttributeType[str] = None
+    serial_number : AttributeType[str] = None
+
+    brightness : AttributeType[int] = None
+    child_lock : AttributeType[bool] = None
+    fan_speed : AttributeType[int] = None
+    fan_auto_mode : AttributeType[bool] = None
+    standby : AttributeType[bool] = None
+    night_mode : AttributeType[bool] = None
+    germ_shield : AttributeType[bool] = None
+
+    pm1 : AttributeType[int] = None
+    pm2_5 : AttributeType[int] = None
+    pm10 : AttributeType[int] = None
+    tVOC : AttributeType[int] = None
+    temperature : AttributeType[int] = None
+    humidity : AttributeType[int] = None
+    filter_usage_percentage : AttributeType[int] = None
+    wifi_working : AttributeType[bool] = None
+
+    wick_usage_percentage : AttributeType[int] = None
+    wick_dry_mode : AttributeType[bool] = None
+    water_shortage : AttributeType[bool] = None
+    auto_regulated_humidity : AttributeType[int] = None
+
+    main_mode: AttributeType[int] = None # api value 0 purify only, 1 heat on, 2 cool on
+    heat_sub_mode: AttributeType[int] = None # api value 1 heat on, 2 heat on with fan auto
+    heat_fan_speed: AttributeType[int] = None # api value 11/37/64/91
+    heat_temp: AttributeType[int] = None # api value is celsius * 10
+    cool_sub_mode: AttributeType[int] = None # api value 1 cool on, 2 cool on with fan auto
+    cool_fan_speed: AttributeType[int] = None # api value 11/37/64/91
+    ap_sub_mode: AttributeType[int] = None # api value 1 manual speeed, 2 auto fan speed
+    fan_speed_0: AttributeType[int] = None # api value 11/37/64/91
+    temperature_unit: AttributeType[int] = None # api value of 1 is celcius
 
     async def refresh(self):
-        info = await self.api.device_info(self.name_api, self.uuid)
-        sensor_data = convert_api_array_to_dict(info["sensordata"])
-        self.pm1 = safely_get_json_value(sensor_data, "pm1", int)
-        self.pm2_5 = safely_get_json_value(sensor_data, "pm2_5", int)
-        self.pm10 = safely_get_json_value(sensor_data, "pm10", int)
-        self.tVOC = safely_get_json_value(sensor_data, "tVOC", int)
-        self.temperature = safely_get_json_value(sensor_data, "t", int)
-        self.humidity = safely_get_json_value(sensor_data, "h", int)
-
-        self.name = safely_get_json_value(info, "configuration.di.name")
-        self.firmware = safely_get_json_value(info, "configuration.di.cfv")
-        self.mcu_firmware = safely_get_json_value(info, "configuration.di.mfv")
-        self.serial_number = safely_get_json_value(info, "configuration.di.ds")
-
-        states = convert_api_array_to_dict(info["states"])
-        self.running = safely_get_json_value(states, "standby") is False
-        self.night_mode = safely_get_json_value(states, "nightmode", bool)
-        self.germ_shield = safely_get_json_value(states, "germshield", bool)
-        self.brightness = safely_get_json_value(states, "brightness", int)
-        self.child_lock = safely_get_json_value(states, "childlock")
-        self.fan_speed = safely_get_json_value(states, "fanspeed", int)
-        self.fan_auto_mode = safely_get_json_value(states, "automode", bool)
-        self.filter_usage = safely_get_json_value(states, "filterusage", int)
-        self.wifi_working = safely_get_json_value(states, "online", bool)
+        _LOGGER.debug(f"refreshing blueair device aws: {self}")
+        self.raw_info = await self.api.device_info(self.name_api, self.uuid)
+        _LOGGER.debug(dumps(self.raw_info, indent=2))
+
+        # ir.parse_json(ir.Attribute, ir.query_json(info, "configuration.da"))
+        ds = ir.parse_json(ir.Sensor, ir.query_json(self.raw_info, "configuration.ds"))
+        dc = ir.parse_json(ir.Control, ir.query_json(self.raw_info, "configuration.dc"))
+
+        sensor_data = ir.SensorPack(self.raw_info["sensordata"]).to_latest_value()
+
+        def sensor_data_safe_get(key):
+            return sensor_data.get(key) if key in ds else NotImplemented
+
+        self.pm1 = sensor_data_safe_get("pm1")
+        self.pm2_5 = sensor_data_safe_get("pm2_5")
+        self.pm10 = sensor_data_safe_get("pm10")
+        self.tVOC = sensor_data_safe_get("tVOC")
+        self.temperature = sensor_data_safe_get("t")
+        self.humidity = sensor_data_safe_get("h")
+
+        def info_safe_get(path):
+            # directly reads for the schema. If the schema field is
+            # undefined, it is NotImplemented, not merely unavailable.
+            value = ir.query_json(self.raw_info, path)
+            if value is None:
+                return NotImplemented
+            return value
+
+        self.name = info_safe_get("configuration.di.name")
+        self.firmware = info_safe_get("configuration.di.cfv")
+        self.mcu_firmware = info_safe_get("configuration.di.mfv")
+        self.serial_number = info_safe_get("configuration.di.ds")
+        self.sku = info_safe_get("configuration.di.sku")
+
+        states = ir.SensorPack(self.raw_info["states"]).to_latest_value()
+
+        def states_safe_get(key):
+            return states.get(key) if key in dc else NotImplemented
+
+        # "online" is not defined in the schema.
+        self.wifi_working = states.get("online")
+
+        self.standby = states_safe_get("standby")
+        self.night_mode = states_safe_get("nightmode")
+        self.germ_shield = states_safe_get("germshield")
+        self.brightness = states_safe_get("brightness")
+        self.child_lock = states_safe_get("childlock")
+        self.fan_speed = states_safe_get("fanspeed")
+        self.fan_auto_mode = states_safe_get("automode")
+        self.filter_usage_percentage = states_safe_get("filterusage")
+
+        self.wick_usage_percentage = states_safe_get("wickusage")
+        self.wick_dry_mode = states_safe_get("wickdrys")
+        self.auto_regulated_humidity = states_safe_get("autorh")
+        self.water_shortage = states_safe_get("wshortage")
+
+        self.main_mode = states_safe_get("mainmode")
+        self.heat_temp = states_safe_get("heattemp")
+        self.heat_sub_mode = states_safe_get("heatsubmode")
+        self.heat_fan_speed = states_safe_get("heatfs")
+        self.cool_sub_mode = states_safe_get("coolsubmode")
+        self.cool_fan_speed = states_safe_get("coolfs")
+        self.ap_sub_mode = states_safe_get("apsubmode")
+        self.fan_speed_0 = states_safe_get("fsp0")
+        self.temperature_unit = states_safe_get("tu")
 
         self.publish_updates()
+        _LOGGER.debug(f"refreshed blueair device aws: {self}")
 
     async def set_brightness(self, value: int):
         self.brightness = value
@@ -84,9 +156,9 @@ class DeviceAws(CallbacksMixin):
         await self.api.set_device_info(self.uuid, "fanspeed", "v", value)
         self.publish_updates()
 
-    async def set_running(self, running: bool):
-        self.running = running
-        await self.api.set_device_info(self.uuid, "standby", "vb", not running)
+    async def set_standby(self, value: bool):
+        self.standby = value
+        await self.api.set_device_info(self.uuid, "standby", "vb", value)
         self.publish_updates()
 
     async def set_fan_auto_mode(self, fan_auto_mode: bool):
@@ -94,6 +166,11 @@ class DeviceAws(CallbacksMixin):
         await self.api.set_device_info(self.uuid, "automode", "vb", fan_auto_mode)
         self.publish_updates()
 
+    async def set_auto_regulated_humidity(self, value: int):
+        self.auto_regulated_humidity = value
+        await self.api.set_device_info(self.uuid, "autorh", "v", value)
+        self.publish_updates()
+
     async def set_child_lock(self, child_lock: bool):
         self.child_lock = child_lock
         await self.api.set_device_info(self.uuid, "childlock", "vb", child_lock)
@@ -104,30 +181,70 @@ class DeviceAws(CallbacksMixin):
         await self.api.set_device_info(self.uuid, "nightmode", "vb", night_mode)
         self.publish_updates()
 
-    def __repr__(self):
-        return {
-            "uuid": self.uuid,
-            "name": self.name,
-            "name_api": self.name_api,
-            "mac": self.mac,
-            "firmware": self.firmware,
-            "mcu_firmware": self.mcu_firmware,
-            "serial_number": self.serial_number,
-            "brightness": self.brightness,
-            "child_lock": self.child_lock,
-            "fan_speed": self.fan_speed,
-            "fan_auto_mode": self.fan_auto_mode,
-            "running": self.running,
-            "night_mode": self.night_mode,
-            "germ_shield": self.germ_shield,
-            "pm1": self.pm1,
-            "pm2_5": self.pm2_5,
-            "pm10": self.pm10,
-            "tVOC": self.tVOC,
-            "temperature": self.temperature,
-            "humidity": self.humidity,
-            "filter_usage": self.filter_usage,
-        }
-
-    def __str__(self):
-        return f"{self.__repr__()}"
+    async def set_wick_dry_mode(self, value: bool):
+        self.wick_dry_mode = value
+        await self.api.set_device_info(self.uuid, "wickdrys", "vb", value)
+        self.publish_updates()
+
+    async def set_germ_shield(self, value: bool):
+        self.germ_shield = value
+        await self.api.set_device_info(self.uuid, "germshield", "vb", value)
+        self.publish_updates()
+
+    async def set_main_mode(self, value: int):
+        self.main_mode = value
+        await self.api.set_device_info(self.uuid, "mainmode", "v", value)
+        self.publish_updates()
+
+    async def set_heat_temp(self, value: int):
+        self.heat_temp = value
+        await self.api.set_device_info(self.uuid, "heattemp", "v", value)
+        self.publish_updates()
+
+    async def set_heat_sub_mode(self, value: int):
+        self.heat_sub_mode = value
+        await self.api.set_device_info(self.uuid, "heatsubmode", "v", value)
+        self.publish_updates()
+
+    async def set_heat_fan_speed(self, value: int):
+        self.heat_fan_speed = value
+        await self.api.set_device_info(self.uuid, "heatfs", "v", value)
+        self.publish_updates()
+
+    async def set_cool_sub_mode(self, value: int):
+        self.cool_sub_mode = value
+        await self.api.set_device_info(self.uuid, "coolsubmode", "v", value)
+        self.publish_updates()
+
+    async def set_cool_fan_speed(self, value: int):
+        self.cool_fan_speed = value
+        await self.api.set_device_info(self.uuid, "coolfs", "v", value)
+        self.publish_updates()
+
+    async def set_ap_sub_mode(self, value: int):
+        self.ap_sub_mode = value
+        await self.api.set_device_info(self.uuid, "apsubmode", "v", value)
+        self.publish_updates()
+
+    async def set_fan_speed_0(self, value: int):
+        self.fan_speed_0 = value
+        await self.api.set_device_info(self.uuid, "fsp0", "v", value)
+        self.publish_updates()
+
+    @property
+    def model(self) -> ModelEnum:
+        if self.sku == "111633":
+            return ModelEnum.HUMIDIFIER_H35I
+        if self.sku == "105820":
+            return ModelEnum.PROTECT_7440I
+        if self.sku == "105826":
+            return ModelEnum.PROTECT_7470I
+        if self.sku == "110059":
+            return ModelEnum.MAX_211I
+        if self.sku == "110092":
+            return ModelEnum.MAX_311I
+        if self.sku == "110057":
+            return ModelEnum.MAX_411I
+        if self.sku == "112124":
+            return ModelEnum.T10I
+        return ModelEnum.UNKNOWN