blueair-api 1.9.1__tar.gz → 1.33.2__tar.gz

{blueair_api-1.9.1/src/blueair_api.egg-info → blueair_api-1.33.2}/PKG-INFO

@@ -1,21 +1,19 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: blueair_api
-Version: 1.9.1
+Version: 1.33.2
 Summary: Blueair Api Wrapper
-Home-page: https://github.com/dahlb/blueair_api
-Author: Brendan Dahl
-Author-email: dahl.brendan@gmail.com
-Project-URL: Bug Reports, https://github.com/dahlb/blueair_api/issues
-Project-URL: Source, https://github.com/dahlb/blueair_api
-Keywords: blueair,api
+Author-email: Brendan Dahl <dahl.brendan@gmail.com>
+Project-URL: Homepage, https://github.com/dahlb/blueair_api
+Project-URL: Bug Tracker, https://github.com/dahlb/blueair_api/issues
+Keywords: hatch,rest-mini,api
 Classifier: Development Status :: 4 - Beta
-Classifier: Framework :: AsyncIO
 Classifier: License :: OSI Approved :: MIT License
+Classifier: Framework :: AsyncIO
 Classifier: Natural Language :: English
 Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Operating System :: MacOS :: MacOS X
-Requires-Python: >=3.9, <4
+Requires-Python: <4,>=3.12.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp>=3.8.1
@@ -42,5 +40,3 @@ a lot of this is based on [hass-blueair](https://github.com/aijayadams/hass-blue
 [releases]: https://github.com/dahlb/blueair_api/releases
 [buymecoffee]: https://www.buymeacoffee.com/dahlb
 [buymecoffeebadge]: https://img.shields.io/badge/buy%20me%20a%20coffee-donate-yellow.svg?style=for-the-badge
-
-

{blueair_api-1.9.1 → blueair_api-1.33.2}/README.md

@@ -20,5 +20,3 @@ a lot of this is based on [hass-blueair](https://github.com/aijayadams/hass-blue
 [releases]: https://github.com/dahlb/blueair_api/releases
 [buymecoffee]: https://www.buymeacoffee.com/dahlb
 [buymecoffeebadge]: https://img.shields.io/badge/buy%20me%20a%20coffee-donate-yellow.svg?style=for-the-badge
-
-

blueair_api-1.33.2/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = [
+    "setuptools>=68.0.0",
+    "wheel",
+    "aiohttp>=3.8.1",
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "blueair_api"
+version = "1.33.2"
+authors = [
+  { name="Brendan Dahl", email="dahl.brendan@gmail.com" },
+]
+description = "Blueair Api Wrapper"
+readme = "README.md"
+requires-python = ">=3.12.0, <4"
+dependencies = [
+    "aiohttp>=3.8.1",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "License :: OSI Approved :: MIT License",
+    "Framework :: AsyncIO",
+    "Natural Language :: English",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.12",
+    "Operating System :: MacOS :: MacOS X",
+]
+keywords = [
+    "hatch",
+    "rest-mini",
+    "api"
+]
+
+[project.urls]
+"Homepage" = "https://github.com/dahlb/blueair_api"
+"Bug Tracker" = "https://github.com/dahlb/blueair_api/issues"

{blueair_api-1.9.1 → blueair_api-1.33.2}/src/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-1.9.1 → blueair_api-1.33.2}/src/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-1.9.1 → blueair_api-1.33.2}/src/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-1.33.2/src/blueair_api/device.py

@@ -0,0 +1,134 @@
+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 = getLogger(__name__)
+
+
+@dataclass(slots=True)
+class Device(CallbacksMixin):
+    @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)
+
+    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
+
+    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
+
+    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 = 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 = 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 = 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: 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()
+
+    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()
+

blueair_api-1.33.2/src/blueair_api/device_aws.py

@@ -0,0 +1,250 @@
+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
+from dataclasses import dataclass, field
+
+_LOGGER = logging.getLogger(__name__)
+
+type AttributeType[T] = T | None
+
+@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 = 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):
+        _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
+        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()
+
+    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()
+
+    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