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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: blueair_api
-Version: 1.24.1
+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.24.1 → blueair_api-1.26.0}/pyproject.toml

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

{blueair_api-1.24.1 → 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.24.1 → 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.24.1
+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.24.1 → 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
@@ -18,4 +19,6 @@ src/blueair_api.egg-info/PKG-INFO
 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
+src/blueair_api.egg-info/top_level.txt
+tests/test_device_aws.py
+tests/test_intermediate_representation_aws.py

blueair_api-1.26.0/tests/test_device_aws.py

@@ -0,0 +1,366 @@
+"""Tests for DeviceAws.
+
+Here is one way to run it:
+
+First install the package in developer mode
+
+    $ pip install -e .
+
+Then use pytest to drive the tests
+
+    $ pytest tests
+"""
+import typing
+from typing import Any
+
+import contextlib
+import dataclasses
+from importlib import resources
+import json
+from unittest import mock
+from unittest import IsolatedAsyncioTestCase
+
+import pytest
+
+from blueair_api.device_aws import DeviceAws, AttributeType
+from blueair_api.model_enum import ModelEnum
+from blueair_api import http_aws_blueair
+from blueair_api import intermediate_representation_aws as ir
+
+
+class FakeDeviceInfoHelper:
+    """Fake for the 'device info' interface of HttpAwsBlueAir class."""
+    def __init__(self, info: dict[str, Any]):
+        self.info = info
+
+    async def device_info(self, *args, **kwargs):
+        return self.info
+
+    async def set_device_info(self, device_uuid, service_name, action_verb, action_value):
+        # this function seems to be only updating the states consider rename the method.
+        # action_verb seems to be a type annotation:
+        # c.f. senml: https://www.rfc-editor.org/rfc/rfc8428.html#section-5
+        # the senml parsing library (utils.py) could use some additional love.
+        # to make it more conformal to the RFC standard.
+        for state in self.info['states']:
+            if state['n'] == service_name:
+                break
+        else:
+            state = {'n': service_name}
+            self.info['states'].append(state)
+        # Watch out: mutate after append produces desired mutation to info.
+        state[action_verb] = action_value
+
+
+class AssertFullyCheckedHelper:
+    """Assert that all attributes of AttributeType are accessed once."""
+    def __init__(self, device : DeviceAws):
+        self.device = device
+        self.logs = []
+        self.fields = set()
+        for field in dataclasses.fields(self.device):
+            if typing.get_origin(field.type) is AttributeType:
+                self.fields.add(field.name)
+
+    def __getattr__(self, attr):
+        if attr in self.fields:
+            self.logs.append(attr)
+        return getattr(self.device, attr)
+
+
+@contextlib.contextmanager
+def assert_fully_checked(device):
+    helper = AssertFullyCheckedHelper(device)
+    yield helper
+    assert set(helper.logs) == helper.fields
+
+
+class DeviceAwsTestBase(IsolatedAsyncioTestCase):
+
+    def setUp(self):
+
+        patcher = mock.patch('blueair_api.http_aws_blueair.HttpAwsBlueair', autospec=True)
+        self.api_class = patcher.start()
+        self.addCleanup(patcher.stop)
+        self.api = self.api_class(username="fake-username", password="fake-password")
+
+        self.device = DeviceAws(self.api,
+             name_api="fake-name-api",
+             uuid="fake-uuid",
+             name="fake-name",
+             mac="fake-mac",
+             type_name='fake-type-name')
+
+        self.device_info_helper = FakeDeviceInfoHelper(
+           {"configuration": {"di" : {}, "ds" : {}, "dc" : {}, "da" : {},},
+            "sensordata": [],
+            "states": [],
+           })
+
+        self.api.device_info.side_effect = self.device_info_helper.device_info
+        self.api.set_device_info.side_effect = self.device_info_helper.set_device_info
+
+
+class DeviceAwsSetterTest(DeviceAwsTestBase):
+    """Tests for all of the setters."""
+
+    def setUp(self):
+        super().setUp()
+        # minimally populate dc to define the states.
+        fake = {"n": "n", "v": 0}
+        ir.query_json(self.device_info_helper.info, "configuration.dc").update({
+          "brightness": fake,
+          "fanspeed": fake,
+          "standby": fake,
+          "automode": fake,
+          "autorh": fake,
+          "childlock": fake,
+          "nightmode": fake,
+          "wickdrys": fake,
+        })
+
+    async def test_brightness(self):
+        # test cache works
+        self.device.brightness = None
+        await self.device.set_brightness(1)
+        assert self.device.brightness == 1
+
+        # test refresh works
+        await self.device.set_brightness(2)
+        self.device.brightness = None
+        await self.device.refresh()
+        assert self.device.brightness == 2
+
+    async def test_fan_speed(self):
+        # test cache works
+        self.device.fan_speed = None
+        await self.device.set_fan_speed(1)
+        assert self.device.fan_speed == 1
+
+        # test refresh works
+        await self.device.set_fan_speed(2)
+        self.device.fan_speed = None
+        await self.device.refresh()
+        assert self.device.fan_speed == 2
+
+    async def test_running(self):
+        # test cache works
+        self.device.standby = None
+        await self.device.set_running(False)
+        assert self.device.running is False
+
+        # test refresh works
+        await self.device.set_running(True)
+        self.device.standby = None
+        await self.device.refresh()
+        assert self.device.running is True
+
+    async def test_standby(self):
+        # test cache works
+        self.device.standby = None
+        await self.device.set_standby(False)
+        assert self.device.standby is False
+
+        # test refresh works
+        await self.device.set_standby(True)
+        self.device.standby = None
+        await self.device.refresh()
+        assert self.device.standby is True
+
+    async def test_fan_auto_mode(self):
+        # test cache works
+        self.device.fan_auto_mode = None
+        await self.device.set_fan_auto_mode(False)
+        assert self.device.fan_auto_mode is False
+
+        # test refresh works
+        await self.device.set_fan_auto_mode(True)
+        self.device.fan_auto_mode = None
+        await self.device.refresh()
+        assert self.device.fan_auto_mode is True
+
+    async def test_auto_regulated_humidity(self):
+        # test cache works
+        self.device.auto_regulated_humidity = None
+        await self.device.set_auto_regulated_humidity(1)
+        assert self.device.auto_regulated_humidity == 1
+
+        # test refresh works
+        await self.device.set_auto_regulated_humidity(2)
+        self.device.auto_regulated_humidity = None
+        await self.device.refresh()
+        assert self.device.auto_regulated_humidity == 2
+
+    async def test_child_lock(self):
+        # test cache works
+        self.device.child_lock = None
+        await self.device.set_child_lock(False)
+        assert self.device.child_lock is False
+
+        # test refresh works
+        await self.device.set_child_lock(True)
+        self.device.child_lock = None
+        await self.device.refresh()
+        assert self.device.child_lock is True
+
+    async def test_night_mode(self):
+        # test cache works
+        self.device.night_mode = None
+        await self.device.set_night_mode(False)
+        assert self.device.night_mode is False
+
+        # test refresh works
+        await self.device.set_night_mode(True)
+        self.device.night_mode = None
+        await self.device.refresh()
+        assert self.device.night_mode is True
+
+    async def test_wick_dry_mode(self):
+        # test cache works
+        self.device.wick_dry_mode = None
+        await self.device.set_wick_dry_mode(False)
+        assert self.device.wick_dry_mode is False
+
+        # test refresh works
+        await self.device.set_wick_dry_mode(True)
+        self.device.wick_dry_mode = None
+        await self.device.refresh()
+        assert self.device.wick_dry_mode is True
+
+
+class EmptyDeviceAwsTest(DeviceAwsTestBase):
+    """Tests for a emptydevice.
+
+    This is a made-up device. All attrs are not implemented.
+
+    Other device types shall override setUp and populate self.info with the
+    golden dataset.
+    """
+
+    async def test_attributes(self):
+
+        await self.device.refresh()
+        self.api.device_info.assert_awaited_with("fake-name-api", "fake-uuid")
+
+        with assert_fully_checked(self.device) as device:
+
+            assert device.model == ModelEnum.UNKNOWN
+
+            assert device.pm1 is NotImplemented
+            assert device.pm2_5 is NotImplemented
+            assert device.pm10 is NotImplemented
+            assert device.tVOC is NotImplemented
+            assert device.temperature is NotImplemented
+            assert device.humidity is NotImplemented
+            assert device.name is NotImplemented
+            assert device.firmware is NotImplemented
+            assert device.mcu_firmware is NotImplemented
+            assert device.serial_number is NotImplemented
+            assert device.sku is NotImplemented
+
+            assert device.running is NotImplemented
+            assert device.standby is NotImplemented
+            assert device.night_mode is NotImplemented
+            assert device.germ_shield is NotImplemented
+            assert device.brightness is NotImplemented
+            assert device.child_lock is NotImplemented
+            assert device.fan_speed is NotImplemented
+            assert device.fan_auto_mode is NotImplemented
+            assert device.filter_usage_percentage is NotImplemented
+            assert device.wifi_working is None
+            assert device.wick_usage_percentage is NotImplemented
+            assert device.auto_regulated_humidity is NotImplemented
+            assert device.water_shortage is NotImplemented
+            assert device.wick_dry_mode is NotImplemented
+
+
+class H35iTest(DeviceAwsTestBase):
+    """Tests for H35i."""
+
+    def setUp(self):
+        super().setUp()
+        with open(resources.files().joinpath('device_info/H35i.json')) as sample_file:
+            info = json.load(sample_file)
+        self.device_info_helper.info.update(info)
+
+    async def test_attributes(self):
+
+        await self.device.refresh()
+        self.api.device_info.assert_awaited_with("fake-name-api", "fake-uuid")
+
+        with assert_fully_checked(self.device) as device:
+
+            assert device.model == ModelEnum.HUMIDIFIER_H35I
+
+            assert device.pm1 is NotImplemented
+            assert device.pm2_5 is NotImplemented
+            assert device.pm10 is NotImplemented
+            assert device.tVOC is NotImplemented
+            assert device.temperature == 19
+            assert device.humidity == 50
+            assert device.name == "Bedroom"
+            assert device.firmware == "1.0.1"
+            assert device.mcu_firmware == "1.0.1"
+            assert device.serial_number == "111163300201110210004036"
+            assert device.sku == "111633"
+
+            assert device.running is True
+            assert device.standby is False
+            assert device.night_mode is False
+            assert device.germ_shield is NotImplemented
+            assert device.brightness == 49
+            assert device.child_lock is False
+            assert device.fan_speed == 24
+            assert device.fan_auto_mode is False
+            assert device.filter_usage_percentage is NotImplemented
+            assert device.wifi_working is True
+            assert device.wick_usage_percentage == 13
+            assert device.auto_regulated_humidity == 50
+            assert device.water_shortage is False
+            assert device.wick_dry_mode is False
+
+
+class T10iTest(DeviceAwsTestBase):
+    """Tests for T10i."""
+
+    def setUp(self):
+        super().setUp()
+        with open(resources.files().joinpath('device_info/T10i.json')) as sample_file:
+            info = json.load(sample_file)
+        self.device_info_helper.info.update(info)
+
+    async def test_attributes(self):
+
+        await self.device.refresh()
+        self.api.device_info.assert_awaited_with("fake-name-api", "fake-uuid")
+
+        with assert_fully_checked(self.device) as device:
+
+            assert device.model == ModelEnum.T10I
+
+            assert device.pm1 is NotImplemented
+            assert device.pm2_5 == 0
+            assert device.pm10 is NotImplemented
+            assert device.tVOC is NotImplemented
+            assert device.temperature == 18
+            assert device.humidity == 28
+            assert device.name == "Allen's Office"
+            assert device.firmware == "1.0.4"
+            assert device.mcu_firmware == "1.0.4"
+            assert device.serial_number == "111212400002313210001961"
+            assert device.sku == "112124"
+
+            assert device.running is True
+            assert device.standby is False
+            assert device.night_mode is NotImplemented
+            assert device.germ_shield is NotImplemented
+            assert device.brightness == 100
+            assert device.child_lock is False
+            assert device.fan_speed is NotImplemented
+            assert device.fan_auto_mode is NotImplemented
+            assert device.filter_usage_percentage == 0
+            assert device.wifi_working is True
+            assert device.wick_usage_percentage is NotImplemented
+            assert device.auto_regulated_humidity is NotImplemented
+            assert device.water_shortage is NotImplemented
+            assert device.wick_dry_mode is NotImplemented

blueair_api-1.26.0/tests/test_intermediate_representation_aws.py

@@ -0,0 +1,127 @@
+import dataclasses
+from unittest import TestCase
+
+import pytest
+
+from blueair_api import intermediate_representation_aws as ir
+
+class SensorPackTest(TestCase):
+
+  def testSimple(self):
+    sp = ir.SensorPack( [
+            {'n': 'v', 't': 1, 'v': 1},
+            {'n': 'vb', 't': 2, 'vb': True},
+            {'n': 'vs', 't': 3, 'vs': "s"},
+            {'n': 'vd', 't': 4, 'vd': "MTIzCg=="},  # b'123\n'
+            {'n': 'no_t', 'v': 1},
+            {'n': 'no_s', 'v': 1},
+            {'n': 's', 'v': 1, 's': 2},
+            {'n': 'u', 'v': 1, 'u': "unit"},
+            {'n': 'no_u', 'v': 1},
+     ])
+
+    latest = sp.to_latest()
+
+    assert latest['v'].timestamp == 1
+    assert latest['v'].value == 1
+    assert isinstance(latest['v'].value, float)
+
+    assert latest['vb'].timestamp == 2
+    assert latest['vb'].value is True
+    assert isinstance(latest['vb'].value, bool)
+
+    assert latest['vs'].timestamp == 3
+    assert latest['vs'].value == "s"
+    assert isinstance(latest['vs'].value, str)
+
+    assert latest['vd'].timestamp == 4
+    assert latest['vd'].value == b"123\n"
+    assert isinstance(latest['vd'].value, bytes)
+
+    assert latest['no_t'].timestamp is None
+
+    assert latest['no_s'].integral is None
+    assert latest['s'].integral == 2
+    assert latest['s'].value == 1
+
+    assert latest['no_u'].unit is None
+    assert latest['u'].unit == "unit"
+
+  def testToLatestMissingT1None(self):
+    sp = ir.SensorPack( [
+            {'n': 'missing_t', 't': 1, 'v': 1},
+            {'n': 'missing_t', 'v': 2},
+    ])
+
+    latest = sp.to_latest()
+    assert latest['missing_t'].value == 2
+
+  def testToLatestMissingTNoneNone(self):
+    sp = ir.SensorPack( [
+            {'n': 'missing_t', 'v': 1},
+            {'n': 'missing_t', 'v': 2},
+    ])
+
+    latest = sp.to_latest()
+    assert latest['missing_t'].value == 2
+
+  def testToLatestMissingTNone1(self):
+    sp = ir.SensorPack( [
+            {'n': 'missing_t', 'v': 1},
+            {'n': 'missing_t', 't': 1, 'v': 2},
+    ])
+
+    latest = sp.to_latest()
+    assert latest['missing_t'].value == 2
+
+  def testToLatestReversedOrder(self):
+    sp = ir.SensorPack( [
+            {'n': 'missing_t', 't': 2, 'v': 2},
+            {'n': 'missing_t', 't': 1, 'v': 1},
+    ])
+
+    latest = sp.to_latest()
+    assert latest['missing_t'].value == 2
+
+
+class QueryJsonTest(TestCase):
+
+    def test_mapping_one(self):
+        assert ir.query_json({"a": 0}, "a") == 0
+
+    def test_mapping_two(self):
+        assert ir.query_json({"a": {"b": 0}}, "a.b") == 0
+
+    def test_sequence(self):
+        assert ir.query_json([{"a": 1}], "0.a") == 1
+
+    def test_none(self):
+        # last segment not found produces None.
+        assert ir.query_json([{"a": 1}], "0.r") is None
+
+    def test_scalar_error(self):
+        with pytest.raises(KeyError):
+            ir.query_json(3, "0.r")
+
+    def test_key_error(self):
+        with pytest.raises(KeyError):
+            # intermediate segment not found produces KeyError
+            ir.query_json({"a": {"b": 3}}, "r.b")
+
+@dataclasses.dataclass
+class FakeObjectType:
+    a : str
+    extra_fields: ir.MappingType
+
+class ParseJsonTest(TestCase):
+
+    def test_mapping_one(self):
+        d = ir.parse_json(FakeObjectType, {
+              "one" :{"a": "1", "e" : 1},
+              "two" :{"a": "2", "e" : 2},
+            })
+        assert d == {
+                "one" : FakeObjectType(a="1", extra_fields={"e":1}),
+                "two" : FakeObjectType(a="2", extra_fields={"e":2}),
+            }
+

blueair_api-1.24.1/src/blueair_api/device_aws.py

@@ -1,156 +0,0 @@
-import dataclasses
-import logging
-
-from .callbacks import CallbacksMixin
-from .http_aws_blueair import HttpAwsBlueair
-from .model_enum import ModelEnum
-from .util import convert_api_array_to_dict, safely_get_json_value
-
-_LOGGER = logging.getLogger(__name__)
-
-
-@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
-    name: str = None
-    name_api: str = None
-    mac: str = None
-    type_name: str = None
-
-    sku: str = None
-    firmware: str = None
-    mcu_firmware: str = None
-    serial_number: str = None
-
-    brightness: int = None
-    child_lock: bool = 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
-
-    # i35
-    wick_usage: int = None  # percentage
-    wick_dry_mode: bool = None
-    water_shortage: bool = None
-    auto_regulated_humidity: 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)
-        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")
-        self.sku = safely_get_json_value(info, "configuration.di.sku")
-
-        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", bool)
-        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)
-        self.wick_usage = safely_get_json_value(states, "wickusage", int)
-        self.wick_dry_mode = safely_get_json_value(states, "wickdrys", bool)
-        self.auto_regulated_humidity = safely_get_json_value(states, "autorh", int)
-        self.water_shortage = safely_get_json_value(states, "wshortage", bool)
-
-        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_running(self, running: bool):
-        self.running = running
-        await self.api.set_device_info(self.uuid, "standby", "vb", not running)
-        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_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
-