aiohomematic 2025.8.6__py3-none-any.whl

aiohomematic/model/calculated/data_point.py

@@ -0,0 +1,319 @@
+"""Module with base class for calculated data points."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from datetime import datetime
+import logging
+from typing import Any, Final, cast
+
+from aiohomematic.const import (
+    CALLBACK_TYPE,
+    INIT_DATETIME,
+    CallSource,
+    CalulatedParameter,
+    DataPointKey,
+    DataPointUsage,
+    Operations,
+    ParameterType,
+    ParamsetKey,
+)
+from aiohomematic.model import device as hmd
+from aiohomematic.model.custom import definition as hmed
+from aiohomematic.model.data_point import BaseDataPoint, NoneTypeDataPoint
+from aiohomematic.model.decorators import cached_slot_property, config_property, state_property
+from aiohomematic.model.generic import data_point as hmge
+from aiohomematic.model.support import (
+    DataPointNameData,
+    DataPointPathData,
+    GenericParameterType,
+    PathData,
+    generate_unique_id,
+    get_data_point_name_data,
+)
+
+_LOGGER: Final = logging.getLogger(__name__)
+
+
+class CalculatedDataPoint[ParameterT: GenericParameterType](BaseDataPoint):
+    """Base class for calculated data point."""
+
+    __slots__ = (
+        "_data_points",
+        "_default",
+        "_max",
+        "_min",
+        "_multiplier",
+        "_operations",
+        "_service",
+        "_type",
+        "_unit",
+        "_unregister_callbacks",
+        "_values",
+        "_visible",
+    )
+
+    _calculated_parameter: CalulatedParameter = None  # type: ignore[assignment]
+
+    def __init__(
+        self,
+        channel: hmd.Channel,
+    ) -> None:
+        """Initialize the data point."""
+        self._unregister_callbacks: list[CALLBACK_TYPE] = []
+        unique_id = generate_unique_id(
+            central=channel.central, address=channel.address, parameter=self._calculated_parameter, prefix="calculated"
+        )
+        super().__init__(
+            channel=channel,
+            unique_id=unique_id,
+            is_in_multiple_channels=hmed.is_multi_channel_device(model=channel.device.model, category=self.category),
+        )
+        self._data_points: Final[list[hmge.GenericDataPoint]] = []
+        self._type: ParameterType = None  # type: ignore[assignment]
+        self._values: tuple[str, ...] | None = None
+        self._max: ParameterT = None  # type: ignore[assignment]
+        self._min: ParameterT = None  # type: ignore[assignment]
+        self._default: ParameterT = None  # type: ignore[assignment]
+        self._visible: bool = True
+        self._service: bool = False
+        self._operations: int = 5
+        self._unit: str | None = None
+        self._multiplier: float = 1.0
+        self._init_data_point_fields()
+
+    def _init_data_point_fields(self) -> None:
+        """Init the data point fields."""
+        _LOGGER.debug(
+            "INIT_DATA_POINT_FIELDS: Initialising the data point fields for %s",
+            self.full_name,
+        )
+
+    def _add_data_point[DataPointT: hmge.GenericDataPoint](
+        self, parameter: str, paramset_key: ParamsetKey | None, data_point_type: type[DataPointT]
+    ) -> DataPointT:
+        """Add a new data point."""
+        if generic_data_point := self._channel.get_generic_data_point(parameter=parameter, paramset_key=paramset_key):
+            self._data_points.append(generic_data_point)
+            self._unregister_callbacks.append(
+                generic_data_point.register_internal_data_point_updated_callback(
+                    cb=self.fire_data_point_updated_callback
+                )
+            )
+            return cast(data_point_type, generic_data_point)  # type: ignore[valid-type]
+        return cast(
+            data_point_type,  # type:ignore[valid-type]
+            NoneTypeDataPoint(),
+        )
+
+    def _add_device_data_point[DataPointT: hmge.GenericDataPoint](
+        self, channel_address: str, parameter: str, paramset_key: ParamsetKey | None, data_point_type: type[DataPointT]
+    ) -> DataPointT:
+        """Add a new data point."""
+        if generic_data_point := self._channel.device.get_generic_data_point(
+            channel_address=channel_address, parameter=parameter, paramset_key=paramset_key
+        ):
+            self._data_points.append(generic_data_point)
+            self._unregister_callbacks.append(
+                generic_data_point.register_internal_data_point_updated_callback(
+                    cb=self.fire_data_point_updated_callback
+                )
+            )
+            return cast(data_point_type, generic_data_point)  # type: ignore[valid-type]
+        return cast(
+            data_point_type,  # type:ignore[valid-type]
+            NoneTypeDataPoint(),
+        )
+
+    @property
+    def is_readable(self) -> bool:
+        """Return, if data_point is readable."""
+        return bool(self._operations & Operations.READ)
+
+    @staticmethod
+    def is_relevant_for_model(channel: hmd.Channel) -> bool:
+        """Return if this calculated data point is relevant for the channel."""
+        return False
+
+    @property
+    def is_writeable(self) -> bool:
+        """Return, if data_point is writeable."""
+        return bool(self._operations & Operations.WRITE)
+
+    @property
+    def default(self) -> ParameterT:
+        """Return default value."""
+        return self._default
+
+    @cached_slot_property
+    def dpk(self) -> DataPointKey:
+        """Return data_point key value."""
+        return DataPointKey(
+            interface_id=self._device.interface_id,
+            channel_address=self._channel.address,
+            paramset_key=ParamsetKey.CALCULATED,
+            parameter=self._calculated_parameter,
+        )
+
+    @property
+    def hmtype(self) -> ParameterType:
+        """Return the HomeMatic type."""
+        return self._type
+
+    @config_property
+    def max(self) -> ParameterT:
+        """Return max value."""
+        return self._max
+
+    @config_property
+    def min(self) -> ParameterT:
+        """Return min value."""
+        return self._min
+
+    @property
+    def multiplier(self) -> float:
+        """Return multiplier value."""
+        return self._multiplier
+
+    @property
+    def parameter(self) -> str:
+        """Return parameter name."""
+        return self._calculated_parameter
+
+    @property
+    def paramset_key(self) -> ParamsetKey:
+        """Return paramset_key name."""
+        return ParamsetKey.CALCULATED
+
+    @property
+    def service(self) -> bool:
+        """Return the if data_point is visible in ccu."""
+        return self._service
+
+    @property
+    def supports_events(self) -> bool:
+        """Return, if data_point is supports events."""
+        return bool(self._operations & Operations.EVENT)
+
+    @config_property
+    def unit(self) -> str | None:
+        """Return unit value."""
+        return self._unit
+
+    @config_property
+    def values(self) -> tuple[str, ...] | None:
+        """Return the values."""
+        return self._values
+
+    @property
+    def visible(self) -> bool:
+        """Return the if data_point is visible in ccu."""
+        return self._visible
+
+    @state_property
+    def modified_at(self) -> datetime:
+        """Return the latest last update timestamp."""
+        modified_at: datetime = INIT_DATETIME
+        for dp in self._readable_data_points:
+            if (data_point_modified_at := dp.modified_at) and data_point_modified_at > modified_at:
+                modified_at = data_point_modified_at
+        return modified_at
+
+    @state_property
+    def refreshed_at(self) -> datetime:
+        """Return the latest last refresh timestamp."""
+        refreshed_at: datetime = INIT_DATETIME
+        for dp in self._readable_data_points:
+            if (data_point_refreshed_at := dp.refreshed_at) and data_point_refreshed_at > refreshed_at:
+                refreshed_at = data_point_refreshed_at
+        return refreshed_at
+
+    @property
+    def has_data_points(self) -> bool:
+        """Return if there are data points."""
+        return len(self._data_points) > 0
+
+    @property
+    def is_valid(self) -> bool:
+        """Return if the state is valid."""
+        return all(dp.is_valid for dp in self._relevant_data_points)
+
+    @property
+    def state_uncertain(self) -> bool:
+        """Return, if the state is uncertain."""
+        return any(dp.state_uncertain for dp in self._relevant_data_points)
+
+    @property
+    def _readable_data_points(self) -> tuple[hmge.GenericDataPoint, ...]:
+        """Returns the list of readable data points."""
+        return tuple(dp for dp in self._data_points if dp.is_readable)
+
+    @property
+    def _relevant_data_points(self) -> tuple[hmge.GenericDataPoint, ...]:
+        """Returns the list of relevant data points. To be overridden by subclasses."""
+        return self._readable_data_points
+
+    @property
+    def _relevant_values_data_points(self) -> tuple[hmge.GenericDataPoint, ...]:
+        """Returns the list of relevant VALUES data points. To be overridden by subclasses."""
+        return tuple(dp for dp in self._readable_data_points if dp.paramset_key == ParamsetKey.VALUES)
+
+    @property
+    def data_point_name_postfix(self) -> str:
+        """Return the data point name postfix."""
+        return ""
+
+    def _get_path_data(self) -> PathData:
+        """Return the path data of the data_point."""
+        return DataPointPathData(
+            interface=self._device.client.interface,
+            address=self._device.address,
+            channel_no=self._channel.no,
+            kind=self._category,
+        )
+
+    def _get_data_point_name(self) -> DataPointNameData:
+        """Create the name for the data point."""
+        return get_data_point_name_data(channel=self._channel, parameter=self._calculated_parameter)
+
+    def _get_data_point_usage(self) -> DataPointUsage:
+        """Generate the usage for the data point."""
+        return DataPointUsage.DATA_POINT
+
+    async def load_data_point_value(self, call_source: CallSource, direct_call: bool = False) -> None:
+        """Init the data point values."""
+        for dp in self._readable_data_points:
+            await dp.load_data_point_value(call_source=call_source, direct_call=direct_call)
+        self.fire_data_point_updated_callback()
+
+    def is_state_change(self, **kwargs: Any) -> bool:
+        """
+        Check if the state changes due to kwargs.
+
+        If the state is uncertain, the state should also marked as changed.
+        """
+        if self.state_uncertain:
+            return True
+        _LOGGER.debug("NO_STATE_CHANGE: %s", self.name)
+        return False
+
+    @property
+    def _should_fire_data_point_updated_callback(self) -> bool:
+        """Check if a data point has been updated or refreshed."""
+        if self.fired_recently:  # pylint: disable=using-constant-test
+            return False
+
+        if (relevant_values_data_point := self._relevant_values_data_points) is not None and len(
+            relevant_values_data_point
+        ) <= 1:
+            return True
+
+        return all(dp.fired_recently for dp in relevant_values_data_point)
+
+    def _unregister_data_point_updated_callback(self, cb: Callable, custom_id: str) -> None:
+        """Unregister update callback."""
+        for unregister in self._unregister_callbacks:
+            if unregister is not None:
+                unregister()
+
+        super()._unregister_data_point_updated_callback(cb=cb, custom_id=custom_id)

aiohomematic/model/calculated/operating_voltage_level.py

@@ -0,0 +1,311 @@
+"""Module for calculating the operating voltage level in the sensor category."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from enum import StrEnum
+import logging
+from typing import Any, Final
+
+from aiohomematic.const import CalulatedParameter, DataPointCategory, Parameter, ParameterType, ParamsetKey
+from aiohomematic.model import device as hmd
+from aiohomematic.model.calculated.data_point import CalculatedDataPoint
+from aiohomematic.model.decorators import state_property
+from aiohomematic.model.generic import DpFloat, DpSensor
+from aiohomematic.support import element_matches_key, extract_exc_args
+
+_BATTERY_QTY: Final = "Battery Qty"
+_BATTERY_TYPE: Final = "Battery Type"
+_LOW_BAT_LIMIT: Final = "Low Battery Limit"
+_LOW_BAT_LIMIT_DEFAULT: Final = "Low Battery Limit Default"
+_VOLTAGE_MAX: Final = "Voltage max"
+
+_LOGGER: Final = logging.getLogger(__name__)
+
+
+class OperatingVoltageLevel[SensorT: float | None](CalculatedDataPoint[SensorT]):
+    """Implementation of a calculated sensor for operating voltage level."""
+
+    __slots__ = (
+        "_battery_data",
+        "_dp_low_bat_limit",
+        "_dp_operating_voltage",
+        "_low_bat_limit_default",
+        "_voltage_max",
+    )
+
+    _calculated_parameter = CalulatedParameter.OPERATING_VOLTAGE_LEVEL
+    _category = DataPointCategory.SENSOR
+
+    def __init__(self, channel: hmd.Channel) -> None:
+        """Initialize the data point."""
+        super().__init__(channel=channel)
+        self._type = ParameterType.FLOAT
+        self._unit = "%"
+
+    def _init_data_point_fields(self) -> None:
+        """Init the data point fields."""
+        super()._init_data_point_fields()
+        self._battery_data = _get_battery_data(model=self._channel.device.model)
+
+        operating_voltage: DpSensor = self._add_data_point(
+            parameter=Parameter.OPERATING_VOLTAGE, paramset_key=ParamsetKey.VALUES, data_point_type=DpSensor
+        )
+
+        self._dp_operating_voltage: DpSensor = (
+            operating_voltage
+            if isinstance(operating_voltage, DpSensor)
+            else self._add_data_point(
+                parameter=Parameter.BATTERY_STATE, paramset_key=ParamsetKey.VALUES, data_point_type=DpSensor
+            )
+        )
+
+        low_bat_limit: DpSensor = self._add_data_point(
+            parameter=Parameter.LOW_BAT_LIMIT, paramset_key=ParamsetKey.MASTER, data_point_type=DpSensor
+        )
+
+        self._dp_low_bat_limit: DpFloat = (
+            low_bat_limit
+            if isinstance(low_bat_limit, DpFloat)
+            else self._add_device_data_point(
+                channel_address=self.channel.device.address,
+                parameter=Parameter.LOW_BAT_LIMIT,
+                paramset_key=ParamsetKey.MASTER,
+                data_point_type=DpFloat,
+            )
+        )
+
+        self._low_bat_limit_default = (
+            float(self._dp_low_bat_limit.default) if isinstance(self._dp_low_bat_limit, DpFloat) else None
+        )
+        self._voltage_max = (
+            float(_BatteryVoltage.get(self._battery_data.battery) * self._battery_data.quantity)  # type: ignore[operator]
+            if self._battery_data is not None
+            else None
+        )
+
+    @staticmethod
+    def is_relevant_for_model(channel: hmd.Channel) -> bool:
+        """Return if this calculated data point is relevant for the model."""
+        if element_matches_key(
+            search_elements=_IGNORE_OPERATING_VOLTAGE_LEVEL_MODELS, compare_with=channel.device.model
+        ):
+            return False
+        return element_matches_key(
+            search_elements=_OPERATING_VOLTAGE_LEVEL_MODELS.keys(), compare_with=channel.device.model
+        ) and (
+            (
+                channel.get_generic_data_point(
+                    parameter=Parameter.OPERATING_VOLTAGE,
+                    paramset_key=ParamsetKey.VALUES,
+                )
+                and channel.get_generic_data_point(parameter=Parameter.LOW_BAT_LIMIT, paramset_key=ParamsetKey.MASTER)
+            )
+            is not None
+            or (
+                channel.get_generic_data_point(
+                    parameter=Parameter.BATTERY_STATE,
+                    paramset_key=ParamsetKey.VALUES,
+                )
+                and channel.device.get_generic_data_point(
+                    channel_address=channel.device.address,
+                    parameter=Parameter.LOW_BAT_LIMIT,
+                    paramset_key=ParamsetKey.MASTER,
+                )
+            )
+            is not None
+        )
+
+    @state_property
+    def additional_information(self) -> dict[str, Any]:
+        """Return additional information about the entity."""
+        ainfo = super().additional_information
+        if self._battery_data is not None:
+            ainfo.update(
+                {
+                    _BATTERY_QTY: self._battery_data.quantity,
+                    _BATTERY_TYPE: self._battery_data.battery,
+                    _LOW_BAT_LIMIT: f"{self._low_bat_limit}V",
+                    _LOW_BAT_LIMIT_DEFAULT: f"{self._low_bat_limit_default}V",
+                    _VOLTAGE_MAX: f"{self._voltage_max}V",
+                }
+            )
+        return ainfo
+
+    @state_property
+    def value(self) -> float | None:
+        """Return the value."""
+        try:
+            if (low_bat_limit := self._low_bat_limit) is None or self._voltage_max is None:
+                return None
+            if self._dp_operating_voltage and self._dp_operating_voltage.value is not None:
+                return max(
+                    0,
+                    min(
+                        100,
+                        float(
+                            round(
+                                (
+                                    (float(self._dp_operating_voltage.value) - low_bat_limit)
+                                    / (self._voltage_max - low_bat_limit)
+                                    * 100
+                                ),
+                                1,
+                            )
+                        ),
+                    ),
+                )
+        except Exception as exc:
+            _LOGGER.debug(
+                "OperatingVoltageLevel: Failed to calculate sensor for %s: %s",
+                self._channel.name,
+                extract_exc_args(exc=exc),
+            )
+            return None
+        return None
+
+    @property
+    def _low_bat_limit(self) -> float | None:
+        """Return the min value."""
+        return (
+            float(self._dp_low_bat_limit.value)
+            if self._dp_low_bat_limit is not None and self._dp_low_bat_limit.value is not None
+            else None
+        )
+
+
+class _BatteryType(StrEnum):
+    CR2032 = "CR2032"
+    LR44 = "LR44"
+    R03 = "AAA"
+    R14 = "BABY"
+    R6 = "AA"
+    UNKNOWN = "UNKNOWN"
+
+
+_BatteryVoltage: Final[Mapping[_BatteryType, float]] = {
+    _BatteryType.CR2032: 3.0,
+    _BatteryType.LR44: 1.5,
+    _BatteryType.R03: 1.5,
+    _BatteryType.R14: 1.5,
+    _BatteryType.R6: 1.5,
+}
+
+
+@dataclass(frozen=True, kw_only=True, slots=True)
+class _BatteryData:
+    model: str
+    battery: _BatteryType
+    quantity: int = 1
+
+
+# This list is sorted. models with shorted model types are sorted to
+_BATTERY_DATA: Final = (
+    # HM long model str
+    _BatteryData(model="HM-CC-RT-DN", battery=_BatteryType.R6, quantity=2),
+    _BatteryData(model="HM-Dis-EP-WM55", battery=_BatteryType.R03, quantity=2),
+    _BatteryData(model="HM-ES-TX-WM", battery=_BatteryType.R6, quantity=4),
+    _BatteryData(model="HM-OU-CFM-TW", battery=_BatteryType.R14, quantity=2),
+    _BatteryData(model="HM-PB-2-FM", battery=_BatteryType.R03, quantity=2),
+    _BatteryData(model="HM-PB-2-WM55", battery=_BatteryType.R03, quantity=2),
+    _BatteryData(model="HM-PB-6-WM55", battery=_BatteryType.R03, quantity=2),
+    _BatteryData(model="HM-PBI-4-FM", battery=_BatteryType.CR2032),
+    _BatteryData(model="HM-RC-4-2", battery=_BatteryType.R03),
+    _BatteryData(model="HM-RC-8", battery=_BatteryType.R03, quantity=2),
+    _BatteryData(model="HM-RC-Key4-3", battery=_BatteryType.R03),
+    _BatteryData(model="HM-SCI-3-FM", battery=_BatteryType.CR2032),
+    _BatteryData(model="HM-Sec-Key", battery=_BatteryType.R6, quantity=3),
+    _BatteryData(model="HM-Sec-MDIR-2", battery=_BatteryType.R6, quantity=3),
+    _BatteryData(model="HM-Sec-RHS", battery=_BatteryType.LR44, quantity=2),
+    _BatteryData(model="HM-Sec-SC-2", battery=_BatteryType.LR44, quantity=2),
+    _BatteryData(model="HM-Sec-SCo", battery=_BatteryType.R03),
+    _BatteryData(model="HM-Sec-SD-2", battery=_BatteryType.UNKNOWN),
+    _BatteryData(model="HM-Sec-Sir-WM", battery=_BatteryType.R14, quantity=2),
+    _BatteryData(model="HM-Sec-TiS", battery=_BatteryType.CR2032),
+    _BatteryData(model="HM-Sec-Win", battery=_BatteryType.UNKNOWN),
+    _BatteryData(model="HM-Sen-MDIR-O-2", battery=_BatteryType.R6, quantity=3),
+    _BatteryData(model="HM-Sen-MDIR-SM", battery=_BatteryType.R6, quantity=3),
+    _BatteryData(model="HM-Sen-MDIR-WM55", battery=_BatteryType.R03, quantity=2),
+    _BatteryData(model="HM-SwI-3-FM", battery=_BatteryType.CR2032),
+    _BatteryData(model="HM-TC-IT-WM-W-EU", battery=_BatteryType.R03, quantity=2),
+    _BatteryData(model="HM-WDS10-TH-O", battery=_BatteryType.R6, quantity=2),
+    _BatteryData(model="HM-WDS30-OT2-SM", battery=_BatteryType.R6, quantity=2),
+    _BatteryData(model="HM-WDS30-T-O", battery=_BatteryType.R03, quantity=2),
+    _BatteryData(model="HM-WDS40-TH-I", battery=_BatteryType.R6, quantity=2),
+    # HM short model str
+    _BatteryData(model="HM-Sec-SD", battery=_BatteryType.R6, quantity=3),
+    # HmIP model > 4
+    _BatteryData(model="HmIP-ASIR-O", battery=_BatteryType.UNKNOWN),
+    _BatteryData(model="HmIP-DSD-PCB", battery=_BatteryType.R03, quantity=2),
+    _BatteryData(model="HmIP-PCBS-BAT", battery=_BatteryType.UNKNOWN),
+    _BatteryData(model="HmIP-SMI55", battery=_BatteryType.R03, quantity=2),
+    _BatteryData(model="HmIP-SMO230", battery=_BatteryType.UNKNOWN),
+    _BatteryData(model="HmIP-STE2-PCB", battery=_BatteryType.R6, quantity=2),
+    _BatteryData(model="HmIP-SWDO-I", battery=_BatteryType.R03, quantity=2),
+    _BatteryData(model="HmIP-SWDO-PL", battery=_BatteryType.R03, quantity=2),
+    _BatteryData(model="HmIP-WTH-B-2", battery=_BatteryType.R6, quantity=2),
+    _BatteryData(model="HmIP-eTRV-CL", battery=_BatteryType.R6, quantity=4),
+    # HmIP model 4
+    _BatteryData(model="ELV-SH-SW1-BAT", battery=_BatteryType.R6, quantity=2),
+    _BatteryData(model="ELV-SH-TACO", battery=_BatteryType.R03, quantity=1),
+    _BatteryData(model="HmIP-ASIR", battery=_BatteryType.R6, quantity=3),
+    _BatteryData(model="HmIP-FCI1", battery=_BatteryType.CR2032),
+    _BatteryData(model="HmIP-FCI6", battery=_BatteryType.R03),
+    _BatteryData(model="HmIP-MP3P", battery=_BatteryType.R14, quantity=2),
+    _BatteryData(model="HmIP-RCB1", battery=_BatteryType.R03, quantity=2),
+    _BatteryData(model="HmIP-SPDR", battery=_BatteryType.R6, quantity=2),
+    _BatteryData(model="HmIP-STHD", battery=_BatteryType.R03, quantity=2),
+    _BatteryData(model="HmIP-STHO", battery=_BatteryType.R6, quantity=2),
+    _BatteryData(model="HmIP-SWDM", battery=_BatteryType.R03, quantity=2),
+    _BatteryData(model="HmIP-SWDO", battery=_BatteryType.R03),
+    _BatteryData(model="HmIP-SWSD", battery=_BatteryType.UNKNOWN),
+    _BatteryData(model="HmIP-eTRV", battery=_BatteryType.R6, quantity=2),
+    # HmIP model 3
+    _BatteryData(model="ELV-SH-CTH", battery=_BatteryType.CR2032),
+    _BatteryData(model="ELV-SH-WSM", battery=_BatteryType.R6, quantity=2),
+    _BatteryData(model="HmIP-DBB", battery=_BatteryType.R03),
+    _BatteryData(model="HmIP-DLD", battery=_BatteryType.R6, quantity=3),
+    _BatteryData(model="HmIP-DLS", battery=_BatteryType.CR2032),
+    _BatteryData(model="HmIP-ESI", battery=_BatteryType.R6, quantity=2),
+    _BatteryData(model="HmIP-KRC", battery=_BatteryType.R03),
+    _BatteryData(model="HmIP-RC8", battery=_BatteryType.R03, quantity=2),
+    _BatteryData(model="HmIP-SAM", battery=_BatteryType.R6, quantity=2),
+    _BatteryData(model="HmIP-SCI", battery=_BatteryType.R03, quantity=2),
+    _BatteryData(model="HmIP-SLO", battery=_BatteryType.R6, quantity=2),
+    _BatteryData(model="HmIP-SMI", battery=_BatteryType.R6, quantity=2),
+    _BatteryData(model="HmIP-SMO", battery=_BatteryType.R6, quantity=2),
+    _BatteryData(model="HmIP-SPI", battery=_BatteryType.R6, quantity=2),
+    _BatteryData(model="HmIP-SRH", battery=_BatteryType.R03),
+    _BatteryData(model="HmIP-STH", battery=_BatteryType.R03, quantity=2),
+    _BatteryData(model="HmIP-STV", battery=_BatteryType.R03, quantity=2),
+    _BatteryData(model="HmIP-SWD", battery=_BatteryType.R03, quantity=2),
+    _BatteryData(model="HmIP-SWO", battery=_BatteryType.R6, quantity=3),
+    _BatteryData(model="HmIP-WGC", battery=_BatteryType.R6, quantity=2),
+    _BatteryData(model="HmIP-WKP", battery=_BatteryType.R03, quantity=2),
+    _BatteryData(model="HmIP-WRC", battery=_BatteryType.R03, quantity=2),
+    _BatteryData(model="HmIP-WSM", battery=_BatteryType.R6, quantity=2),
+    _BatteryData(model="HmIP-WTH", battery=_BatteryType.R03, quantity=2),
+)
+
+_OPERATING_VOLTAGE_LEVEL_MODELS: Final[Mapping[str, _BatteryData]] = {
+    battery.model: battery for battery in _BATTERY_DATA if battery.battery != _BatteryType.UNKNOWN
+}
+
+_IGNORE_OPERATING_VOLTAGE_LEVEL_MODELS: Final[tuple[str, ...]] = tuple(
+    [battery.model for battery in _BATTERY_DATA if battery.battery == _BatteryType.UNKNOWN]
+)
+
+
+def _get_battery_data(model: str) -> _BatteryData | None:
+    """Return the battery data by model."""
+    model_l = model.lower()
+    for battery_data in _OPERATING_VOLTAGE_LEVEL_MODELS.values():
+        if battery_data.model.lower() == model_l:
+            return battery_data
+
+    for battery_data in _OPERATING_VOLTAGE_LEVEL_MODELS.values():
+        if model_l.startswith(battery_data.model.lower()):
+            return battery_data
+
+    return None