PyPlumIO 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

pyplumio/structures/boiler_load.py

@@ -1,32 +0,0 @@
-"""Contains a boiler load structure decoder."""
-
-from __future__ import annotations
-
-from typing import Any, Final
-
-from pyplumio.const import BYTE_UNDEFINED
-from pyplumio.structures import StructureDecoder
-from pyplumio.utils import ensure_dict
-
-ATTR_BOILER_LOAD: Final = "boiler_load"
-
-
-class BoilerLoadStructure(StructureDecoder):
-    """Represents a boiler load sensor data structure."""
-
-    __slots__ = ()
-
-    def decode(
-        self, message: bytearray, offset: int = 0, data: dict[str, Any] | None = None
-    ) -> tuple[dict[str, Any], int]:
-        """Decode bytes and return message data and offset."""
-        boiler_load = message[offset]
-        offset += 1
-
-        if boiler_load == BYTE_UNDEFINED:
-            return ensure_dict(data), offset
-
-        return (ensure_dict(data, {ATTR_BOILER_LOAD: boiler_load}), offset)
-
-
-__all__ = ["ATTR_BOILER_LOAD", "BoilerLoadStructure"]

pyplumio/structures/boiler_power.py

@@ -1,33 +0,0 @@
-"""Contains a boiler power structure decoder."""
-
-from __future__ import annotations
-
-import math
-from typing import Any, Final
-
-from pyplumio.data_types import Float
-from pyplumio.structures import StructureDecoder
-from pyplumio.utils import ensure_dict
-
-ATTR_BOILER_POWER: Final = "boiler_power"
-
-
-class BoilerPowerStructure(StructureDecoder):
-    """Represents a boiler power sensor data structure."""
-
-    __slots__ = ()
-
-    def decode(
-        self, message: bytearray, offset: int = 0, data: dict[str, Any] | None = None
-    ) -> tuple[dict[str, Any], int]:
-        """Decode bytes and return message data and offset."""
-        boiler_power = Float.from_bytes(message, offset)
-        offset += boiler_power.size
-
-        if math.isnan(boiler_power.value):
-            return ensure_dict(data), offset
-
-        return ensure_dict(data, {ATTR_BOILER_POWER: boiler_power.value}), offset
-
-
-__all__ = ["ATTR_BOILER_POWER", "BoilerPowerStructure"]

pyplumio/structures/fan_power.py

@@ -1,33 +0,0 @@
-"""Contains a fan power structure decoder."""
-
-from __future__ import annotations
-
-import math
-from typing import Any, Final
-
-from pyplumio.data_types import Float
-from pyplumio.structures import StructureDecoder
-from pyplumio.utils import ensure_dict
-
-ATTR_FAN_POWER: Final = "fan_power"
-
-
-class FanPowerStructure(StructureDecoder):
-    """Represents a fan power sensor data structure."""
-
-    __slots__ = ()
-
-    def decode(
-        self, message: bytearray, offset: int = 0, data: dict[str, Any] | None = None
-    ) -> tuple[dict[str, Any], int]:
-        """Decode bytes and return message data and offset."""
-        fan_power = Float.from_bytes(message, offset)
-        offset += fan_power.size
-
-        if math.isnan(fan_power.value):
-            return ensure_dict(data), offset
-
-        return ensure_dict(data, {ATTR_FAN_POWER: fan_power.value}), offset
-
-
-__all__ = ["ATTR_FAN_POWER", "FanPowerStructure"]

pyplumio/structures/fuel_consumption.py

@@ -1,36 +0,0 @@
-"""Contains fuel consumption structure decoder."""
-
-from __future__ import annotations
-
-import math
-from typing import Any, Final
-
-from pyplumio.data_types import Float
-from pyplumio.structures import StructureDecoder
-from pyplumio.utils import ensure_dict
-
-ATTR_FUEL_CONSUMPTION: Final = "fuel_consumption"
-
-
-class FuelConsumptionStructure(StructureDecoder):
-    """Represents a fuel consumption sensor data structure."""
-
-    __slots__ = ()
-
-    def decode(
-        self, message: bytearray, offset: int = 0, data: dict[str, Any] | None = None
-    ) -> tuple[dict[str, Any], int]:
-        """Decode bytes and return message data and offset."""
-        fuel_consumption = Float.from_bytes(message, offset)
-        offset += fuel_consumption.size
-
-        if math.isnan(fuel_consumption.value):
-            return ensure_dict(data), offset
-
-        return (
-            ensure_dict(data, {ATTR_FUEL_CONSUMPTION: fuel_consumption.value}),
-            offset,
-        )
-
-
-__all__ = ["ATTR_FUEL_CONSUMPTION", "FuelConsumptionStructure"]

pyplumio/structures/fuel_level.py

@@ -1,39 +0,0 @@
-"""Contains a fuel level structure decoder."""
-
-from __future__ import annotations
-
-from typing import Any, Final
-
-from pyplumio.const import BYTE_UNDEFINED
-from pyplumio.structures import StructureDecoder
-from pyplumio.utils import ensure_dict
-
-ATTR_FUEL_LEVEL: Final = "fuel_level"
-
-FUEL_LEVEL_OFFSET: Final = 101
-
-
-class FuelLevelStructure(StructureDecoder):
-    """Represents a fuel level sensor data structure."""
-
-    __slots__ = ()
-
-    def decode(
-        self, message: bytearray, offset: int = 0, data: dict[str, Any] | None = None
-    ) -> tuple[dict[str, Any], int]:
-        """Decode bytes and return message data and offset."""
-        fuel_level = message[offset]
-        offset += 1
-
-        if fuel_level == BYTE_UNDEFINED:
-            return ensure_dict(data), offset
-
-        if fuel_level >= FUEL_LEVEL_OFFSET:
-            # Observed on at least ecoMAX 860P6-O.
-            # See: https://github.com/denpamusic/PyPlumIO/issues/19
-            fuel_level -= FUEL_LEVEL_OFFSET
-
-        return (ensure_dict(data, {ATTR_FUEL_LEVEL: fuel_level}), offset)
-
-
-__all__ = ["ATTR_FUEL_LEVEL", "FuelLevelStructure"]

pyplumio/structures/lambda_sensor.py

@@ -1,57 +0,0 @@
-"""Contains a lambda sensor structure decoder."""
-
-from __future__ import annotations
-
-from contextlib import suppress
-from typing import Any, Final
-
-from pyplumio.const import BYTE_UNDEFINED, LambdaState
-from pyplumio.data_types import UnsignedShort
-from pyplumio.structures import StructureDecoder
-from pyplumio.utils import ensure_dict
-
-ATTR_LAMBDA_STATE: Final = "lambda_state"
-ATTR_LAMBDA_TARGET: Final = "lambda_target"
-ATTR_LAMBDA_LEVEL: Final = "lambda_level"
-
-
-class LambdaSensorStructure(StructureDecoder):
-    """Represents a lambda sensor data structure."""
-
-    __slots__ = ()
-
-    def decode(
-        self, message: bytearray, offset: int = 0, data: dict[str, Any] | None = None
-    ) -> tuple[dict[str, Any], int]:
-        """Decode bytes and return message data and offset."""
-        lambda_state = message[offset]
-        offset += 1
-        if lambda_state == BYTE_UNDEFINED:
-            return ensure_dict(data), offset
-
-        lambda_target = message[offset]
-        offset += 1
-        level = UnsignedShort.from_bytes(message, offset)
-        offset += level.size
-        with suppress(ValueError):
-            lambda_state = LambdaState(lambda_state)
-
-        return (
-            ensure_dict(
-                data,
-                {
-                    ATTR_LAMBDA_STATE: lambda_state,
-                    ATTR_LAMBDA_TARGET: lambda_target,
-                    ATTR_LAMBDA_LEVEL: level.value / 10,
-                },
-            ),
-            offset,
-        )
-
-
-__all__ = [
-    "ATTR_LAMBDA_STATE",
-    "ATTR_LAMBDA_TARGET",
-    "ATTR_LAMBDA_LEVEL",
-    "LambdaSensorStructure",
-]

pyplumio/structures/mixer_sensors.py

@@ -1,80 +0,0 @@
-"""Contains a mixer sensors structure decoder."""
-
-from __future__ import annotations
-
-from collections.abc import Generator
-import math
-from typing import Any, Final
-
-from pyplumio.const import ATTR_CURRENT_TEMP, ATTR_TARGET_TEMP
-from pyplumio.data_types import Float
-from pyplumio.structures import StructureDecoder
-from pyplumio.utils import ensure_dict
-
-ATTR_PUMP: Final = "pump"
-ATTR_MIXERS_AVAILABLE: Final = "mixers_available"
-ATTR_MIXERS_CONNECTED: Final = "mixers_connected"
-ATTR_MIXER_SENSORS: Final = "mixer_sensors"
-
-MIXER_SENSOR_SIZE: Final = 8
-
-
-class MixerSensorsStructure(StructureDecoder):
-    """Represents a mixer sensors data structure."""
-
-    __slots__ = ("_offset",)
-
-    _offset: int
-
-    def _unpack_mixer_sensors(self, message: bytearray) -> dict[str, Any] | None:
-        """Unpack sensors for a mixer."""
-        offset = self._offset
-        current_temp = Float.from_bytes(message, offset)
-        try:
-            return (
-                {
-                    ATTR_CURRENT_TEMP: current_temp.value,
-                    ATTR_TARGET_TEMP: message[offset + 4],
-                    ATTR_PUMP: bool(message[offset + 6] & 0x01),
-                }
-                if not math.isnan(current_temp.value)
-                else None
-            )
-        finally:
-            self._offset = offset + MIXER_SENSOR_SIZE
-
-    def _mixer_sensors(
-        self, message: bytearray, mixers: int
-    ) -> Generator[tuple[int, dict[str, Any]], None, None]:
-        """Get sensors for a mixer."""
-        for index in range(mixers):
-            if sensors := self._unpack_mixer_sensors(message):
-                yield (index, sensors)
-
-    def decode(
-        self, message: bytearray, offset: int = 0, data: dict[str, Any] | None = None
-    ) -> tuple[dict[str, Any], int]:
-        """Decode bytes and return message data and offset."""
-        mixers = message[offset]
-        self._offset = offset + 1
-        mixer_sensors = dict(self._mixer_sensors(message, mixers))
-        return (
-            ensure_dict(
-                data,
-                {
-                    ATTR_MIXER_SENSORS: mixer_sensors,
-                    ATTR_MIXERS_AVAILABLE: mixers,
-                    ATTR_MIXERS_CONNECTED: len(mixer_sensors),
-                },
-            ),
-            self._offset,
-        )
-
-
-__all__ = [
-    "ATTR_PUMP",
-    "ATTR_MIXERS_AVAILABLE",
-    "ATTR_MIXERS_CONNECTED",
-    "ATTR_MIXER_SENSORS",
-    "MixerSensorsStructure",
-]

pyplumio/structures/modules.py

@@ -1,102 +0,0 @@
-"""Contains a modules structure decoder."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-import struct
-from typing import Any, Final
-
-from pyplumio.const import BYTE_UNDEFINED
-from pyplumio.structures import StructureDecoder
-from pyplumio.utils import ensure_dict
-
-ATTR_MODULES: Final = "modules"
-ATTR_MODULE_A: Final = "module_a"
-ATTR_MODULE_B: Final = "module_b"
-ATTR_MODULE_C: Final = "module_c"
-ATTR_ECOLAMBDA: Final = "ecolambda"
-ATTR_ECOSTER: Final = "ecoster"
-ATTR_PANEL: Final = "panel"
-MODULES: tuple[str, ...] = (
-    ATTR_MODULE_A,
-    ATTR_MODULE_B,
-    ATTR_MODULE_C,
-    ATTR_ECOLAMBDA,
-    ATTR_ECOSTER,
-    ATTR_PANEL,
-)
-
-struct_version = struct.Struct("<BBB")
-struct_vendor = struct.Struct("<BB")
-
-
-@dataclass(slots=True)
-class ConnectedModules:
-    """Represents a firmware version info for connected module."""
-
-    module_a: str | None = None
-    module_b: str | None = None
-    module_c: str | None = None
-    ecolambda: str | None = None
-    ecoster: str | None = None
-    panel: str | None = None
-
-
-class ModulesStructure(StructureDecoder):
-    """Represents a modules data structure."""
-
-    __slots__ = ("_offset",)
-
-    _offset: int
-
-    def _unpack_module_version(self, module: str, message: bytearray) -> str | None:
-        """Unpack a module version."""
-        if message[self._offset] == BYTE_UNDEFINED:
-            self._offset += 1
-            return None
-
-        offset = self._offset
-        version_data = struct_version.unpack_from(message, offset)
-        version = ".".join(str(i) for i in version_data)
-        offset += struct_version.size
-        if module == ATTR_MODULE_A:
-            vendor_code, vendor_version = struct_vendor.unpack_from(message, offset)
-            version += f".{chr(vendor_code) + str(vendor_version)}"
-            offset += struct_vendor.size
-
-        self._offset = offset
-        return version
-
-    def decode(
-        self, message: bytearray, offset: int = 0, data: dict[str, Any] | None = None
-    ) -> tuple[dict[str, Any], int]:
-        """Decode bytes and return message data and offset."""
-        self._offset = offset
-        return (
-            ensure_dict(
-                data,
-                {
-                    ATTR_MODULES: ConnectedModules(
-                        **{
-                            module: self._unpack_module_version(module, message)
-                            for module in MODULES
-                        }
-                    )
-                },
-            ),
-            self._offset,
-        )
-
-
-__all__ = [
-    "ATTR_MODULES",
-    "ATTR_MODULE_A",
-    "ATTR_MODULE_B",
-    "ATTR_MODULE_C",
-    "ATTR_ECOLAMBDA",
-    "ATTR_ECOSTER",
-    "ATTR_PANEL",
-    "MODULES",
-    "ConnectedModules",
-    "ModulesStructure",
-]

pyplumio/structures/output_flags.py

@@ -1,47 +0,0 @@
-"""Contains an output flags structure decoder."""
-
-from __future__ import annotations
-
-from typing import Any, Final
-
-from pyplumio.data_types import UnsignedInt
-from pyplumio.structures import StructureDecoder
-from pyplumio.utils import ensure_dict
-
-ATTR_HEATING_PUMP_FLAG: Final = "heating_pump_flag"
-ATTR_WATER_HEATER_PUMP_FLAG: Final = "water_heater_pump_flag"
-ATTR_CIRCULATION_PUMP_FLAG: Final = "circulation_pump_flag"
-ATTR_SOLAR_PUMP_FLAG: Final = "solar_pump_flag"
-
-
-class OutputFlagsStructure(StructureDecoder):
-    """Represents an output flags structure."""
-
-    __slots__ = ()
-
-    def decode(
-        self, message: bytearray, offset: int = 0, data: dict[str, Any] | None = None
-    ) -> tuple[dict[str, Any], int]:
-        """Decode bytes and return message data and offset."""
-        output_flags = UnsignedInt.from_bytes(message, offset)
-        return (
-            ensure_dict(
-                data,
-                {
-                    ATTR_HEATING_PUMP_FLAG: bool(output_flags.value & 0x04),
-                    ATTR_WATER_HEATER_PUMP_FLAG: bool(output_flags.value & 0x08),
-                    ATTR_CIRCULATION_PUMP_FLAG: bool(output_flags.value & 0x10),
-                    ATTR_SOLAR_PUMP_FLAG: bool(output_flags.value & 0x800),
-                },
-            ),
-            offset + output_flags.size,
-        )
-
-
-__all__ = [
-    "ATTR_HEATING_PUMP_FLAG",
-    "ATTR_WATER_HEATER_PUMP_FLAG",
-    "ATTR_CIRCULATION_PUMP_FLAG",
-    "ATTR_SOLAR_PUMP_FLAG",
-    "OutputFlagsStructure",
-]

pyplumio/structures/outputs.py

@@ -1,88 +0,0 @@
-"""Contains an outputs structure decoder."""
-
-from __future__ import annotations
-
-from typing import Any, Final
-
-from pyplumio.data_types import UnsignedInt
-from pyplumio.structures import StructureDecoder
-from pyplumio.utils import ensure_dict
-
-ATTR_FAN: Final = "fan"
-ATTR_FEEDER: Final = "feeder"
-ATTR_HEATING_PUMP: Final = "heating_pump"
-ATTR_WATER_HEATER_PUMP: Final = "water_heater_pump"
-ATTR_CIRCULATION_PUMP: Final = "circulation_pump"
-ATTR_LIGHTER: Final = "lighter"
-ATTR_ALARM: Final = "alarm"
-ATTR_OUTER_BOILER: Final = "outer_boiler"
-ATTR_FAN2_EXHAUST: Final = "fan2_exhaust"
-ATTR_FEEDER2: Final = "feeder2"
-ATTR_OUTER_FEEDER: Final = "outer_feeder"
-ATTR_SOLAR_PUMP: Final = "solar_pump"
-ATTR_FIREPLACE_PUMP: Final = "fireplace_pump"
-ATTR_GCZ_CONTACT: Final = "gcz_contact"
-ATTR_BLOW_FAN1: Final = "blow_fan1"
-ATTR_BLOW_FAN2: Final = "blow_fan2"
-
-OUTPUTS: tuple[str, ...] = (
-    ATTR_FAN,
-    ATTR_FEEDER,
-    ATTR_HEATING_PUMP,
-    ATTR_WATER_HEATER_PUMP,
-    ATTR_CIRCULATION_PUMP,
-    ATTR_LIGHTER,
-    ATTR_ALARM,
-    ATTR_OUTER_BOILER,
-    ATTR_FAN2_EXHAUST,
-    ATTR_FEEDER2,
-    ATTR_OUTER_FEEDER,
-    ATTR_SOLAR_PUMP,
-    ATTR_FIREPLACE_PUMP,
-    ATTR_GCZ_CONTACT,
-    ATTR_BLOW_FAN1,
-    ATTR_BLOW_FAN2,
-)
-
-
-class OutputsStructure(StructureDecoder):
-    """Represents an outputs data structure."""
-
-    __slots__ = ()
-
-    def decode(
-        self, message: bytearray, offset: int = 0, data: dict[str, Any] | None = None
-    ) -> tuple[dict[str, Any], int]:
-        """Decode bytes and return message data and offset."""
-        outputs = UnsignedInt.from_bytes(message, offset)
-        return (
-            ensure_dict(
-                data,
-                {
-                    output: bool(outputs.value & 2**index)
-                    for index, output in enumerate(OUTPUTS)
-                },
-            ),
-            offset + outputs.size,
-        )
-
-
-__all__ = [
-    "ATTR_FAN",
-    "ATTR_FEEDER",
-    "ATTR_HEATING_PUMP",
-    "ATTR_WATER_HEATER_PUMP",
-    "ATTR_CIRCULATION_PUMP",
-    "ATTR_LIGHTER",
-    "ATTR_ALARM",
-    "ATTR_OUTER_BOILER",
-    "ATTR_FAN2_EXHAUST",
-    "ATTR_FEEDER2",
-    "ATTR_OUTER_FEEDER",
-    "ATTR_SOLAR_PUMP",
-    "ATTR_FIREPLACE_PUMP",
-    "ATTR_GCZ_CONTACT",
-    "ATTR_BLOW_FAN1",
-    "ATTR_BLOW_FAN2",
-    "OutputsStructure",
-]

pyplumio/structures/pending_alerts.py

@@ -1,28 +0,0 @@
-"""Contains a pending alerts structure decoder."""
-
-from __future__ import annotations
-
-from typing import Any, Final
-
-from pyplumio.structures import StructureDecoder
-from pyplumio.utils import ensure_dict
-
-ATTR_PENDING_ALERTS: Final = "pending_alerts"
-
-
-class PendingAlertsStructure(StructureDecoder):
-    """Represents a pending alerts structure."""
-
-    __slots__ = ()
-
-    def decode(
-        self, message: bytearray, offset: int = 0, data: dict[str, Any] | None = None
-    ) -> tuple[dict[str, Any], int]:
-        """Decode bytes and return message data and offset."""
-        alerts_number = message[offset]
-        return ensure_dict(data, {ATTR_PENDING_ALERTS: alerts_number}), (
-            offset + alerts_number + 1
-        )
-
-
-__all__ = ["ATTR_PENDING_ALERTS", "PendingAlertsStructure"]

pyplumio/structures/statuses.py

@@ -1,52 +0,0 @@
-"""Contains a statuses structure decoder."""
-
-from __future__ import annotations
-
-from typing import Any, Final
-
-from pyplumio.structures import StructureDecoder
-from pyplumio.utils import ensure_dict
-
-ATTR_HEATING_TARGET: Final = "heating_target"
-ATTR_HEATING_STATUS: Final = "heating_status"
-ATTR_WATER_HEATER_TARGET: Final = "water_heater_target"
-ATTR_WATER_HEATER_STATUS: Final = "water_heater_status"
-
-STATUSES: tuple[str, ...] = (
-    ATTR_HEATING_TARGET,
-    ATTR_HEATING_STATUS,
-    ATTR_WATER_HEATER_TARGET,
-    ATTR_WATER_HEATER_STATUS,
-)
-
-STATUSES_SIZE: Final = 4
-
-
-class StatusesStructure(StructureDecoder):
-    """Represents a statuses data structure."""
-
-    __slots__ = ()
-
-    def decode(
-        self, message: bytearray, offset: int = 0, data: dict[str, Any] | None = None
-    ) -> tuple[dict[str, Any], int]:
-        """Decode bytes and return message data and offset."""
-        return (
-            ensure_dict(
-                data,
-                {
-                    status: message[offset + index]
-                    for index, status in enumerate(STATUSES)
-                },
-            ),
-            offset + STATUSES_SIZE,
-        )
-
-
-__all__ = [
-    "ATTR_HEATING_TARGET",
-    "ATTR_HEATING_STATUS",
-    "ATTR_WATER_HEATER_TARGET",
-    "ATTR_WATER_HEATER_STATUS",
-    "StatusesStructure",
-]