blueair-api 1.25.0__tar.gz → 1.26.0__tar.gz

{blueair_api-1.25.0 → blueair_api-1.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: blueair_api
-Version: 1.25.0
+Version: 1.26.0
 Summary: Blueair Api Wrapper
 Author-email: Brendan Dahl <dahl.brendan@gmail.com>
 Project-URL: Homepage, https://github.com/dahlb/blueair_api

{blueair_api-1.25.0 → blueair_api-1.26.0}/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "blueair_api"
-version = "1.25.0"
+version = "1.26.0"
 authors = [
   { name="Brendan Dahl", email="dahl.brendan@gmail.com" },
 ]

{blueair_api-1.25.0 → blueair_api-1.26.0}/src/blueair_api/const.py

@@ -1,5 +1,5 @@
 from collections.abc import Mapping
-from typing_extensions import TypedDict
+from typing import TypedDict
 
 SENSITIVE_FIELD_NAMES = [
     "username",

blueair_api-1.26.0/src/blueair_api/device_aws.py

@@ -0,0 +1,194 @@
+import dataclasses
+import logging
+from json import dumps
+
+from .callbacks import CallbacksMixin
+from .http_aws_blueair import HttpAwsBlueair
+from .model_enum import ModelEnum
+from . import intermediate_representation_aws as ir
+
+_LOGGER = logging.getLogger(__name__)
+
+type AttributeType[T] = T | None | type[NotImplemented]
+
+@dataclasses.dataclass(slots=True)
+class DeviceAws(CallbacksMixin):
+    @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
+    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
+
+    async def refresh(self):
+        _LOGGER.debug(f"refreshing blueair device aws: {self}")
+        info = await self.api.device_info(self.name_api, self.uuid)
+        _LOGGER.debug(dumps(info, indent=2))
+
+        # ir.parse_json(ir.Attribute, ir.query_json(info, "configuration.da"))
+        ds = ir.parse_json(ir.Sensor, ir.query_json(info, "configuration.ds"))
+        dc = ir.parse_json(ir.Control, ir.query_json(info, "configuration.dc"))
+
+        sensor_data = ir.SensorPack(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(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(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.publish_updates()
+        _LOGGER.debug(f"refreshed blueair device aws: {self}")
+
+    async def set_brightness(self, value: int):
+        self.brightness = value
+        await self.api.set_device_info(self.uuid, "brightness", "v", value)
+        self.publish_updates()
+
+    async def set_fan_speed(self, value: int):
+        self.fan_speed = value
+        await self.api.set_device_info(self.uuid, "fanspeed", "v", value)
+        self.publish_updates()
+
+    async def set_standby(self, value: bool):
+        self.standby = value
+        await self.api.set_device_info(self.uuid, "standby", "vb", value)
+        self.publish_updates()
+
+    # FIXME: avoid state translation at the API level and depreate running.
+    # replace with standby which is standard across aws devices.
+    @property
+    def running(self) -> AttributeType[bool]:
+        if self.standby is None or self.standby is NotImplemented:
+            return self.standby
+        return not self.standby
+
+    async def set_running(self, running: bool):
+        await self.set_standby(not running)
+
+    async def set_fan_auto_mode(self, fan_auto_mode: bool):
+        self.fan_auto_mode = fan_auto_mode
+        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)
+        self.publish_updates()
+
+    async def set_night_mode(self, night_mode: bool):
+        self.night_mode = night_mode
+        await self.api.set_device_info(self.uuid, "nightmode", "vb", night_mode)
+        self.publish_updates()
+
+    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()
+
+    @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
+

blueair_api-1.26.0/src/blueair_api/intermediate_representation_aws.py

@@ -0,0 +1,176 @@
+from typing import Any, TypeVar
+from collections.abc import Iterable
+import dataclasses
+import base64
+
+type ScalarType = str | float | bool
+type MappingType = dict[str, "ObjectType"]
+type SequenceType = list["ObjectType"]
+type ObjectType = ScalarType | MappingType | SequenceType
+
+
+def query_json(jsonobj: ObjectType, path: str):
+    value = jsonobj
+    segs = path.split(".")
+    for i, seg in enumerate(segs[:-1]):
+        if not isinstance(value, dict | list):
+            raise KeyError(
+                f"cannot resolve path segment on a scalar "
+                f"when resolving segment {i}:{seg} of {path}.")
+        if isinstance(value, list):
+            value = value[int(seg)]
+        else:
+            try:
+                value = value[seg]
+            except KeyError:
+                raise KeyError(
+                f"cannot resolve path segment on a scalar "
+                f"when resolving segment {i}:{seg} of {path}. "
+                f"available keys are {value.keys()}.")
+
+    # last segment returns None if it is not found.
+    return value.get(segs[-1])
+
+
+def parse_json[T](kls: type[T], jsonobj: MappingType) -> dict[str, T]:
+    """Parses a json mapping object to dict.
+
+    The key is preserved. The value is parsed as dataclass type kls.
+    """
+    result = {}
+    fields = dataclasses.fields(kls)
+
+    for key, value in jsonobj.items():
+        a = dict(value)  # make a copy.
+        kwargs = {}
+        for field in fields:
+            if field.name == "extra_fields":
+                continue
+            if field.default is dataclasses.MISSING:
+                kwargs[field.name] = a.pop(field.name)
+            else:
+                kwargs[field.name] = a.pop(field.name, field.default)
+
+        result[key] = kls(**kwargs, extra_fields=a)
+    return result
+
+
+########################
+# Blueair AWS API Schema.
+
+@dataclasses.dataclass
+class Attribute:
+    """DeviceAttribute(da); defines an attribute
+
+    An attribute is most likely mutable. An attribute may
+    also have alias names, likely derived from the 'dc' relation
+    e.g. a/sb, a/standby all refer to the 'sb' attribute.
+    """
+    extra_fields : MappingType
+    n: str   # name
+    a: int | bool   # default attribute value, example value?
+    e: bool     # ??? always True
+    fe:bool     # ???  always True
+    ot: str     # object type? topic type?
+    p: bool     # only false for reboot and sflu
+    tn: str   # topic name a path-like name d/????/a/{n}
+
+
+@dataclasses.dataclass
+class Sensor:
+    """DeviceSensor(ds); seems to define a sensor.
+
+    We never directly access these objects. Thos this defines
+    the schema for 'h', 't', 'pm10' etc that gets returned in
+    the sensor_data senml SensorPack.
+    """
+    extra_fields : MappingType
+    n: str    # name
+    i: int    # integration time? in millis
+    e: bool   # ???
+    fe: bool  # ??? always True.
+    ot: str   # object type / topic name
+    tf: str   # senml+json; topic format
+    tn: str   # topic name a path-like name d/????/s/{n}
+    ttl: int  # only seen 0 or -1, not sure if used.
+
+@dataclasses.dataclass
+class Control:
+    """DeviceControl (dc); seems to define a state.
+
+    The states SensorPack seem to be using fields defined
+    in dc. The only exception is 'online' which is not defined
+    here.
+    """
+    extra_fields : MappingType
+    n: str  # name
+    v: int | bool
+    a: str | None = None
+    s: str | None = None
+    d: str | None = None  # device info json path
+
+
+########################
+# SenML RFC8428
+
+@dataclasses.dataclass
+class Record:
+    """A RFC8428 SenML record, resolved to Python types."""
+    name: str
+    unit: str | None
+    value: ScalarType
+    timestamp: float | None
+    integral: float | None
+
+
+class SensorPack(list[Record]):
+    """Represents a RFC8428 SensorPack, resolved to Python Types."""
+
+    def __init__(self, stream: Iterable[MappingType]):
+        seq = []
+        for record in stream:
+            rs = None
+            rt = None
+            rn = 0
+            ru = None
+            for label, value in record.items():
+                match label:
+                    case 'bn' | 'bt' | 'bu' | 'bv' | 'bs' | 'bver':
+                        raise ValueError("TODO: base fields not supported. c.f. RFC8428, 4.1")
+                    case 't':
+                        rt = float(value)
+                    case 's':
+                        rs = float(value)
+                    case 'v':
+                        rv = float(value)
+                    case 'vb':
+                        rv = bool(value)
+                    case 'vs':
+                        rv = str(value)
+                    case 'vd':
+                        rv = bytes(base64.b64decode(value))
+                    case 'n':
+                        rn = str(value)
+                    case 'u':
+                        ru = str(value)
+                    case 't':
+                        rn = float(value)
+            seq.append(Record(name=rn, unit=ru, value=rv, integral=rs, timestamp=rt))
+        super().__init__(seq)
+
+    def to_latest_value(self) -> dict[str, ScalarType]:
+        return {rn : record.value for rn, record in self.to_latest().items()}
+
+    def to_latest(self) -> dict[str, Record]:
+        latest = {}
+        for record in self:
+            rn = record.name
+            if record.name not in latest:
+                latest[rn] = record
+            elif record.timestamp is None:
+                latest[rn] = record
+            elif latest[record.name].timestamp is None:
+                latest[rn] = record
+            elif latest[record.name].timestamp < record.timestamp:
+                latest[rn] = record
+        return latest

{blueair_api-1.25.0 → blueair_api-1.26.0}/src/blueair_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: blueair_api
-Version: 1.25.0
+Version: 1.26.0
 Summary: Blueair Api Wrapper
 Author-email: Brendan Dahl <dahl.brendan@gmail.com>
 Project-URL: Homepage, https://github.com/dahlb/blueair_api

{blueair_api-1.25.0 → blueair_api-1.26.0}/src/blueair_api.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ src/blueair_api/device_aws.py
 src/blueair_api/errors.py
 src/blueair_api/http_aws_blueair.py
 src/blueair_api/http_blueair.py
+src/blueair_api/intermediate_representation_aws.py
 src/blueair_api/model_enum.py
 src/blueair_api/stub.py
 src/blueair_api/util.py
@@ -19,4 +20,5 @@ src/blueair_api.egg-info/SOURCES.txt
 src/blueair_api.egg-info/dependency_links.txt
 src/blueair_api.egg-info/requires.txt
 src/blueair_api.egg-info/top_level.txt
-tests/test_device_aws.py
+tests/test_device_aws.py
+tests/test_intermediate_representation_aws.py