aiohomematic 2025.8.8__py3-none-any.whl → 2025.8.9__py3-none-any.whl

aiohomematic/caches/visibility.py

@@ -30,11 +30,11 @@ available on the CentralUnit and model descriptors.
 from __future__ import annotations
 
 from collections import defaultdict
-from collections.abc import Mapping
+from collections.abc import Iterable, Mapping
 from functools import cache
 import logging
 import re
-from typing import Final
+from typing import Final, TypeAlias
 
 from aiohomematic import central as hmcu, support as hms
 from aiohomematic.const import ADDRESS_SEPARATOR, CLICK_EVENTS, UN_IGNORE_WILDCARD, Parameter, ParamsetKey
@@ -43,7 +43,12 @@ from aiohomematic.model.custom import get_required_parameters
 from aiohomematic.support import element_matches_key
 
 _LOGGER: Final = logging.getLogger(__name__)
-_CACHE_KEY_TYPE = tuple[str, int, ParamsetKey, str]
+
+# Readability type aliases for internal cache structures
+TModelName: TypeAlias = str
+TChannelNo: TypeAlias = int | None
+TUnIgnoreChannelNo: TypeAlias = TChannelNo | str
+TParameterName: TypeAlias = str
 
 # Define which additional parameters from MASTER paramset should be created as data_point.
 # By default these are also on the _HIDDEN_PARAMETERS, which prevents these data points
@@ -51,172 +56,174 @@ _CACHE_KEY_TYPE = tuple[str, int, ParamsetKey, str]
 # and not for general display.
 # {model: (channel_no, parameter)}
 
-_RELEVANT_MASTER_PARAMSETS_BY_CHANNEL: Final[Mapping[int | str | None, tuple[Parameter, ...]]] = {
-    None: (Parameter.GLOBAL_BUTTON_LOCK, Parameter.LOW_BAT_LIMIT),
-    0: (Parameter.GLOBAL_BUTTON_LOCK, Parameter.LOW_BAT_LIMIT),
+_RELEVANT_MASTER_PARAMSETS_BY_CHANNEL: Final[Mapping[TChannelNo, frozenset[Parameter]]] = {
+    None: frozenset({Parameter.GLOBAL_BUTTON_LOCK, Parameter.LOW_BAT_LIMIT}),
+    0: frozenset({Parameter.GLOBAL_BUTTON_LOCK, Parameter.LOW_BAT_LIMIT}),
 }
 
-_CLIMATE_MASTER_PARAMETERS: Final[tuple[Parameter, ...]] = (
-    Parameter.HEATING_VALVE_TYPE,
-    Parameter.MIN_MAX_VALUE_NOT_RELEVANT_FOR_MANU_MODE,
-    Parameter.OPTIMUM_START_STOP,
-    Parameter.TEMPERATURE_MAXIMUM,
-    Parameter.TEMPERATURE_MINIMUM,
-    Parameter.TEMPERATURE_OFFSET,
-    Parameter.WEEK_PROGRAM_POINTER,
+_CLIMATE_MASTER_PARAMETERS: Final[frozenset[Parameter]] = frozenset(
+    {
+        Parameter.HEATING_VALVE_TYPE,
+        Parameter.MIN_MAX_VALUE_NOT_RELEVANT_FOR_MANU_MODE,
+        Parameter.OPTIMUM_START_STOP,
+        Parameter.TEMPERATURE_MAXIMUM,
+        Parameter.TEMPERATURE_MINIMUM,
+        Parameter.TEMPERATURE_OFFSET,
+        Parameter.WEEK_PROGRAM_POINTER,
+    }
 )
 
-_RELEVANT_MASTER_PARAMSETS_BY_DEVICE: Final[Mapping[str, tuple[tuple[int | None, ...], tuple[Parameter, ...]]]] = {
-    "ALPHA-IP-RBG": ((1,), _CLIMATE_MASTER_PARAMETERS),
-    "ELV-SH-TACO": ((2,), (Parameter.CHANNEL_OPERATION_MODE,)),
+_RELEVANT_MASTER_PARAMSETS_BY_DEVICE: Final[Mapping[TModelName, tuple[frozenset[TChannelNo], frozenset[Parameter]]]] = {
+    "ALPHA-IP-RBG": (frozenset({1}), _CLIMATE_MASTER_PARAMETERS),
+    "ELV-SH-TACO": (frozenset({2}), frozenset({Parameter.CHANNEL_OPERATION_MODE})),
     "HM-CC-RT-DN": (
-        (None,),
+        frozenset({None}),
         _CLIMATE_MASTER_PARAMETERS,
     ),
     "HM-CC-VG-1": (
-        (None,),
+        frozenset({None}),
         _CLIMATE_MASTER_PARAMETERS,
     ),
     "HM-TC-IT-WM-W-EU": (
-        (None,),
+        frozenset({None}),
         _CLIMATE_MASTER_PARAMETERS,
     ),
-    "HmIP-BWTH": ((1, 8), _CLIMATE_MASTER_PARAMETERS),
+    "HmIP-BWTH": (frozenset({1, 8}), _CLIMATE_MASTER_PARAMETERS),
     "HmIP-DRBLI4": (
-        (1, 2, 3, 4, 5, 6, 7, 8, 9, 13, 17, 21),
-        (Parameter.CHANNEL_OPERATION_MODE,),
+        frozenset({1, 2, 3, 4, 5, 6, 7, 8, 9, 13, 17, 21}),
+        frozenset({Parameter.CHANNEL_OPERATION_MODE}),
     ),
-    "HmIP-DRDI3": ((1, 2, 3), (Parameter.CHANNEL_OPERATION_MODE,)),
-    "HmIP-DRSI1": ((1,), (Parameter.CHANNEL_OPERATION_MODE,)),
-    "HmIP-DRSI4": ((1, 2, 3, 4), (Parameter.CHANNEL_OPERATION_MODE,)),
-    "HmIP-DSD-PCB": ((1,), (Parameter.CHANNEL_OPERATION_MODE,)),
-    "HmIP-FCI1": ((1,), (Parameter.CHANNEL_OPERATION_MODE,)),
-    "HmIP-FCI6": (tuple(range(1, 7)), (Parameter.CHANNEL_OPERATION_MODE,)),
-    "HmIP-FSI16": ((1,), (Parameter.CHANNEL_OPERATION_MODE,)),
-    "HmIP-HEATING": ((1,), _CLIMATE_MASTER_PARAMETERS),
-    "HmIP-MIO16-PCB": ((13, 14, 15, 16), (Parameter.CHANNEL_OPERATION_MODE,)),
-    "HmIP-MOD-RC8": (tuple(range(1, 9)), (Parameter.CHANNEL_OPERATION_MODE,)),
-    "HmIP-RGBW": ((0,), (Parameter.DEVICE_OPERATION_MODE,)),
-    "HmIP-STH": ((1,), _CLIMATE_MASTER_PARAMETERS),
-    "HmIP-WGT": ((8, 14), _CLIMATE_MASTER_PARAMETERS),
-    "HmIP-WTH": ((1,), _CLIMATE_MASTER_PARAMETERS),
-    "HmIP-eTRV": ((1,), _CLIMATE_MASTER_PARAMETERS),
-    "HmIPW-DRBL4": ((1, 5, 9, 13), (Parameter.CHANNEL_OPERATION_MODE,)),
-    "HmIPW-DRI16": (tuple(range(1, 17)), (Parameter.CHANNEL_OPERATION_MODE,)),
-    "HmIPW-DRI32": (tuple(range(1, 33)), (Parameter.CHANNEL_OPERATION_MODE,)),
-    "HmIPW-FIO6": (tuple(range(1, 7)), (Parameter.CHANNEL_OPERATION_MODE,)),
-    "HmIPW-STH": ((1,), _CLIMATE_MASTER_PARAMETERS),
+    "HmIP-DRDI3": (frozenset({1, 2, 3}), frozenset({Parameter.CHANNEL_OPERATION_MODE})),
+    "HmIP-DRSI1": (frozenset({1}), frozenset({Parameter.CHANNEL_OPERATION_MODE})),
+    "HmIP-DRSI4": (frozenset({1, 2, 3, 4}), frozenset({Parameter.CHANNEL_OPERATION_MODE})),
+    "HmIP-DSD-PCB": (frozenset({1}), frozenset({Parameter.CHANNEL_OPERATION_MODE})),
+    "HmIP-FCI1": (frozenset({1}), frozenset({Parameter.CHANNEL_OPERATION_MODE})),
+    "HmIP-FCI6": (frozenset(range(1, 7)), frozenset({Parameter.CHANNEL_OPERATION_MODE})),
+    "HmIP-FSI16": (frozenset({1}), frozenset({Parameter.CHANNEL_OPERATION_MODE})),
+    "HmIP-HEATING": (frozenset({1}), _CLIMATE_MASTER_PARAMETERS),
+    "HmIP-MIO16-PCB": (frozenset({13, 14, 15, 16}), frozenset({Parameter.CHANNEL_OPERATION_MODE})),
+    "HmIP-MOD-RC8": (frozenset(range(1, 9)), frozenset({Parameter.CHANNEL_OPERATION_MODE})),
+    "HmIP-RGBW": (frozenset({0}), frozenset({Parameter.DEVICE_OPERATION_MODE})),
+    "HmIP-STH": (frozenset({1}), _CLIMATE_MASTER_PARAMETERS),
+    "HmIP-WGT": (frozenset({8, 14}), _CLIMATE_MASTER_PARAMETERS),
+    "HmIP-WTH": (frozenset({1}), _CLIMATE_MASTER_PARAMETERS),
+    "HmIP-eTRV": (frozenset({1}), _CLIMATE_MASTER_PARAMETERS),
+    "HmIPW-DRBL4": (frozenset({1, 5, 9, 13}), frozenset({Parameter.CHANNEL_OPERATION_MODE})),
+    "HmIPW-DRI16": (frozenset(range(1, 17)), frozenset({Parameter.CHANNEL_OPERATION_MODE})),
+    "HmIPW-DRI32": (frozenset(range(1, 33)), frozenset({Parameter.CHANNEL_OPERATION_MODE})),
+    "HmIPW-FIO6": (frozenset(range(1, 7)), frozenset({Parameter.CHANNEL_OPERATION_MODE})),
+    "HmIPW-STH": (frozenset({1}), _CLIMATE_MASTER_PARAMETERS),
 }
 
 # Ignore events for some devices
-_IGNORE_DEVICES_FOR_DATA_POINT_EVENTS: Final[Mapping[str, tuple[Parameter, ...]]] = {
+_IGNORE_DEVICES_FOR_DATA_POINT_EVENTS: Final[Mapping[TModelName, frozenset[Parameter]]] = {
     "HmIP-PS": CLICK_EVENTS,
 }
 
-_IGNORE_DEVICES_FOR_DATA_POINT_EVENTS_LOWER: Final[dict[str, tuple[str, ...]]] = {
-    model.lower(): tuple(event for event in events) for model, events in _IGNORE_DEVICES_FOR_DATA_POINT_EVENTS.items()
+_IGNORE_DEVICES_FOR_DATA_POINT_EVENTS_LOWER: Final[Mapping[TModelName, frozenset[Parameter]]] = {
+    model.lower(): frozenset(events) for model, events in _IGNORE_DEVICES_FOR_DATA_POINT_EVENTS.items()
 }
 
 # data points that will be created, but should be hidden.
-_HIDDEN_PARAMETERS: Final[tuple[Parameter, ...]] = (
-    Parameter.ACTIVITY_STATE,
-    Parameter.CHANNEL_OPERATION_MODE,
-    Parameter.CONFIG_PENDING,
-    Parameter.DIRECTION,
-    Parameter.ERROR,
-    Parameter.HEATING_VALVE_TYPE,
-    Parameter.LOW_BAT_LIMIT,
-    Parameter.MIN_MAX_VALUE_NOT_RELEVANT_FOR_MANU_MODE,
-    Parameter.OPTIMUM_START_STOP,
-    Parameter.SECTION,
-    Parameter.STICKY_UN_REACH,
-    Parameter.TEMPERATURE_MAXIMUM,
-    Parameter.TEMPERATURE_MINIMUM,
-    Parameter.TEMPERATURE_OFFSET,
-    Parameter.UN_REACH,
-    Parameter.UPDATE_PENDING,
-    Parameter.WORKING,
+_HIDDEN_PARAMETERS: Final[frozenset[Parameter]] = frozenset(
+    {
+        Parameter.ACTIVITY_STATE,
+        Parameter.CHANNEL_OPERATION_MODE,
+        Parameter.CONFIG_PENDING,
+        Parameter.DIRECTION,
+        Parameter.ERROR,
+        Parameter.HEATING_VALVE_TYPE,
+        Parameter.LOW_BAT_LIMIT,
+        Parameter.MIN_MAX_VALUE_NOT_RELEVANT_FOR_MANU_MODE,
+        Parameter.OPTIMUM_START_STOP,
+        Parameter.SECTION,
+        Parameter.STICKY_UN_REACH,
+        Parameter.TEMPERATURE_MAXIMUM,
+        Parameter.TEMPERATURE_MINIMUM,
+        Parameter.TEMPERATURE_OFFSET,
+        Parameter.UN_REACH,
+        Parameter.UPDATE_PENDING,
+        Parameter.WORKING,
+    }
 )
-# Fast membership for hidden parameters
-_HIDDEN_PARAMETERS_SET: Final[set[Parameter]] = set(_HIDDEN_PARAMETERS)
 
 # Parameters within the VALUES paramset for which we don't create data points.
-_IGNORED_PARAMETERS: Final[tuple[str, ...]] = (
-    "ACCESS_AUTHORIZATION",
-    "ACOUSTIC_NOTIFICATION_SELECTION",
-    "ADAPTION_DRIVE",
-    "AES_KEY",
-    "ALARM_COUNT",
-    "ALL_LEDS",
-    "ARROW_DOWN",
-    "ARROW_UP",
-    "BACKLIGHT",
-    "BEEP",
-    "BELL",
-    "BLIND",
-    "BOOST_STATE",
-    "BOOST_TIME",
-    "BOOT",
-    "BULB",
-    "CLEAR_ERROR",
-    "CLEAR_WINDOW_OPEN_SYMBOL",
-    "CLOCK",
-    "CONTROL_DIFFERENTIAL_TEMPERATURE",
-    "DATE_TIME_UNKNOWN",
-    "DECISION_VALUE",
-    "DEVICE_IN_BOOTLOADER",
-    "DISPLAY_DATA_ALIGNMENT",
-    "DISPLAY_DATA_BACKGROUND_COLOR",
-    "DISPLAY_DATA_COMMIT",
-    "DISPLAY_DATA_ICON",
-    "DISPLAY_DATA_ID",
-    "DISPLAY_DATA_STRING",
-    "DISPLAY_DATA_TEXT_COLOR",
-    "DOOR",
-    "EXTERNAL_CLOCK",
-    "FROST_PROTECTION",
-    "HUMIDITY_LIMITER",
-    "IDENTIFICATION_MODE_KEY_VISUAL",
-    "IDENTIFICATION_MODE_LCD_BACKLIGHT",
-    "INCLUSION_UNSUPPORTED_DEVICE",
-    "INHIBIT",
-    "INSTALL_MODE",
-    "INTERVAL",
-    "LEVEL_REAL",
-    "OLD_LEVEL",
-    "OVERFLOW",
-    "OVERRUN",
-    "PARTY_SET_POINT_TEMPERATURE",
-    "PARTY_TEMPERATURE",
-    "PARTY_TIME_END",
-    "PARTY_TIME_START",
-    "PHONE",
-    "PROCESS",
-    "QUICK_VETO_TIME",
-    "RAMP_STOP",
-    "RELOCK_DELAY",
-    "SCENE",
-    "SELF_CALIBRATION",
-    "SERVICE_COUNT",
-    "SET_SYMBOL_FOR_HEATING_PHASE",
-    "SHADING_SPEED",
-    "SHEV_POS",
-    "SPEED",
-    "STATE_UNCERTAIN",
-    "SUBMIT",
-    "SWITCH_POINT_OCCURED",
-    "TEMPERATURE_LIMITER",
-    "TEMPERATURE_OUT_OF_RANGE",
-    "TEXT",
-    "USER_COLOR",
-    "USER_PROGRAM",
-    "VALVE_ADAPTION",
-    "WINDOW",
-    "WIN_RELEASE",
-    "WIN_RELEASE_ACT",
+_IGNORED_PARAMETERS: Final[frozenset[TParameterName]] = frozenset(
+    {
+        "ACCESS_AUTHORIZATION",
+        "ACOUSTIC_NOTIFICATION_SELECTION",
+        "ADAPTION_DRIVE",
+        "AES_KEY",
+        "ALARM_COUNT",
+        "ALL_LEDS",
+        "ARROW_DOWN",
+        "ARROW_UP",
+        "BACKLIGHT",
+        "BEEP",
+        "BELL",
+        "BLIND",
+        "BOOST_STATE",
+        "BOOST_TIME",
+        "BOOT",
+        "BULB",
+        "CLEAR_ERROR",
+        "CLEAR_WINDOW_OPEN_SYMBOL",
+        "CLOCK",
+        "CONTROL_DIFFERENTIAL_TEMPERATURE",
+        "DATE_TIME_UNKNOWN",
+        "DECISION_VALUE",
+        "DEVICE_IN_BOOTLOADER",
+        "DISPLAY_DATA_ALIGNMENT",
+        "DISPLAY_DATA_BACKGROUND_COLOR",
+        "DISPLAY_DATA_COMMIT",
+        "DISPLAY_DATA_ICON",
+        "DISPLAY_DATA_ID",
+        "DISPLAY_DATA_STRING",
+        "DISPLAY_DATA_TEXT_COLOR",
+        "DOOR",
+        "EXTERNAL_CLOCK",
+        "FROST_PROTECTION",
+        "HUMIDITY_LIMITER",
+        "IDENTIFICATION_MODE_KEY_VISUAL",
+        "IDENTIFICATION_MODE_LCD_BACKLIGHT",
+        "INCLUSION_UNSUPPORTED_DEVICE",
+        "INHIBIT",
+        "INSTALL_MODE",
+        "INTERVAL",
+        "LEVEL_REAL",
+        "OLD_LEVEL",
+        "OVERFLOW",
+        "OVERRUN",
+        "PARTY_SET_POINT_TEMPERATURE",
+        "PARTY_TEMPERATURE",
+        "PARTY_TIME_END",
+        "PARTY_TIME_START",
+        "PHONE",
+        "PROCESS",
+        "QUICK_VETO_TIME",
+        "RAMP_STOP",
+        "RELOCK_DELAY",
+        "SCENE",
+        "SELF_CALIBRATION",
+        "SERVICE_COUNT",
+        "SET_SYMBOL_FOR_HEATING_PHASE",
+        "SHADING_SPEED",
+        "SHEV_POS",
+        "SPEED",
+        "STATE_UNCERTAIN",
+        "SUBMIT",
+        "SWITCH_POINT_OCCURED",
+        "TEMPERATURE_LIMITER",
+        "TEMPERATURE_OUT_OF_RANGE",
+        "TEXT",
+        "USER_COLOR",
+        "USER_PROGRAM",
+        "VALVE_ADAPTION",
+        "WINDOW",
+        "WIN_RELEASE",
+        "WIN_RELEASE_ACT",
+    }
 )
-# Fast membership for ignored VALUE parameters
-_IGNORED_PARAMETERS_SET: Final[set[str]] = set(_IGNORED_PARAMETERS)
 
 
 # Precompile Regex patterns for wildcard checks
@@ -228,31 +235,28 @@ _IGNORED_PARAMETERS_START_RE: Final = re.compile(
 )
 
 
-def _parameter_is_wildcard_ignored(parameter: str) -> bool:
+def _parameter_is_wildcard_ignored(parameter: TParameterName) -> bool:
     """Check if a parameter matches common wildcard patterns."""
     return bool(_IGNORED_PARAMETERS_END_RE.match(parameter) or _IGNORED_PARAMETERS_START_RE.match(parameter))
 
 
 # Parameters within the paramsets for which we create data points.
-_UN_IGNORE_PARAMETERS_BY_DEVICE: Final[Mapping[str, tuple[Parameter, ...]]] = {
-    "HmIP-DLD": (Parameter.ERROR_JAMMED,),
-    "HmIP-SWSD": (Parameter.SMOKE_DETECTOR_ALARM_STATUS,),
-    "HM-OU-LED16": (Parameter.LED_STATUS,),
-    "HM-Sec-Win": (Parameter.DIRECTION, Parameter.WORKING, Parameter.ERROR, Parameter.STATUS),
-    "HM-Sec-Key": (Parameter.DIRECTION, Parameter.ERROR),
-    "HmIP-PCBS-BAT": (
-        Parameter.OPERATING_VOLTAGE,
-        Parameter.LOW_BAT,
-    ),  # To override ignore for HmIP-PCBS
+_UN_IGNORE_PARAMETERS_BY_DEVICE: Final[Mapping[TModelName, frozenset[Parameter]]] = {
+    "HmIP-DLD": frozenset({Parameter.ERROR_JAMMED}),
+    "HmIP-SWSD": frozenset({Parameter.SMOKE_DETECTOR_ALARM_STATUS}),
+    "HM-OU-LED16": frozenset({Parameter.LED_STATUS}),
+    "HM-Sec-Win": frozenset({Parameter.DIRECTION, Parameter.WORKING, Parameter.ERROR, Parameter.STATUS}),
+    "HM-Sec-Key": frozenset({Parameter.DIRECTION, Parameter.ERROR}),
+    "HmIP-PCBS-BAT": frozenset({Parameter.OPERATING_VOLTAGE, Parameter.LOW_BAT}),  # To override ignore for HmIP-PCBS
 }
 
-_UN_IGNORE_PARAMETERS_BY_MODEL_LOWER: Final[dict[str, tuple[str, ...]]] = {
-    model.lower(): parameters for model, parameters in _UN_IGNORE_PARAMETERS_BY_DEVICE.items()
+_UN_IGNORE_PARAMETERS_BY_MODEL_LOWER: Final[dict[TModelName, frozenset[Parameter]]] = {
+    model.lower(): frozenset(parameters) for model, parameters in _UN_IGNORE_PARAMETERS_BY_DEVICE.items()
 }
 
 
 @cache
-def _get_parameters_for_model_prefix(model_prefix: str | None) -> tuple[str, ...] | None:
+def _get_parameters_for_model_prefix(model_prefix: str | None) -> frozenset[Parameter] | None:
     """Return the dict value by wildcard type."""
     if model_prefix is None:
         return None
@@ -264,59 +268,74 @@ def _get_parameters_for_model_prefix(model_prefix: str | None) -> tuple[str, ...
 
 
 # Parameters by device within the VALUES paramset for which we don't create data points.
-_IGNORE_PARAMETERS_BY_DEVICE: Final[Mapping[Parameter, tuple[str, ...]]] = {
-    Parameter.CURRENT_ILLUMINATION: (
-        "HmIP-SMI",
-        "HmIP-SMO",
-        "HmIP-SPI",
+_IGNORE_PARAMETERS_BY_DEVICE: Final[Mapping[Parameter, frozenset[TModelName]]] = {
+    Parameter.CURRENT_ILLUMINATION: frozenset(
+        {
+            "HmIP-SMI",
+            "HmIP-SMO",
+            "HmIP-SPI",
+        }
     ),
-    Parameter.LOWBAT: (
-        "HM-LC-Sw1-DR",
-        "HM-LC-Sw1-FM",
-        "HM-LC-Sw1-PCB",
-        "HM-LC-Sw1-Pl",
-        "HM-LC-Sw1-Pl-DN-R1",
-        "HM-LC-Sw1PBU-FM",
-        "HM-LC-Sw2-FM",
-        "HM-LC-Sw4-DR",
-        "HM-SwI-3-FM",
+    Parameter.LOWBAT: frozenset(
+        {
+            "HM-LC-Sw1-DR",
+            "HM-LC-Sw1-FM",
+            "HM-LC-Sw1-PCB",
+            "HM-LC-Sw1-Pl",
+            "HM-LC-Sw1-Pl-DN-R1",
+            "HM-LC-Sw1PBU-FM",
+            "HM-LC-Sw2-FM",
+            "HM-LC-Sw4-DR",
+            "HM-SwI-3-FM",
+        }
     ),
-    Parameter.LOW_BAT: ("HmIP-BWTH", "HmIP-PCBS"),
-    Parameter.OPERATING_VOLTAGE: (
-        "ELV-SH-BS2",
-        "HmIP-BDT",
-        "HmIP-BROLL",
-        "HmIP-BS2",
-        "HmIP-BSL",
-        "HmIP-BSM",
-        "HmIP-BWTH",
-        "HmIP-DR",
-        "HmIP-FDT",
-        "HmIP-FROLL",
-        "HmIP-FSM",
-        "HmIP-MOD-OC8",
-        "HmIP-PCBS",
-        "HmIP-PDT",
-        "HmIP-PMFS",
-        "HmIP-PS",
-        "HmIP-SFD",
-        "HmIP-SMO230",
-        "HmIP-WGT",
+    Parameter.LOW_BAT: frozenset({"HmIP-BWTH", "HmIP-PCBS"}),
+    Parameter.OPERATING_VOLTAGE: frozenset(
+        {
+            "ELV-SH-BS2",
+            "HmIP-BDT",
+            "HmIP-BROLL",
+            "HmIP-BS2",
+            "HmIP-BSL",
+            "HmIP-BSM",
+            "HmIP-BWTH",
+            "HmIP-DR",
+            "HmIP-FDT",
+            "HmIP-FROLL",
+            "HmIP-FSM",
+            "HmIP-MOD-OC8",
+            "HmIP-PCBS",
+            "HmIP-PDT",
+            "HmIP-PMFS",
+            "HmIP-PS",
+            "HmIP-SFD",
+            "HmIP-SMO230",
+            "HmIP-WGT",
+        }
     ),
-    Parameter.VALVE_STATE: ("HmIPW-FALMOT-C12", "HmIP-FALMOT-C12"),
+    Parameter.VALVE_STATE: frozenset({"HmIPW-FALMOT-C12", "HmIP-FALMOT-C12"}),
 }
 
-_IGNORE_PARAMETERS_BY_DEVICE_LOWER: Final[dict[str, tuple[str, ...]]] = {
-    parameter: tuple(model.lower() for model in s) for parameter, s in _IGNORE_PARAMETERS_BY_DEVICE.items()
+_IGNORE_PARAMETERS_BY_DEVICE_LOWER: Final[dict[TParameterName, frozenset[TModelName]]] = {
+    parameter: frozenset(model.lower() for model in s) for parameter, s in _IGNORE_PARAMETERS_BY_DEVICE.items()
 }
 
 # Some devices have parameters on multiple channels,
 # but we want to use it only from a certain channel.
-_ACCEPT_PARAMETER_ONLY_ON_CHANNEL: Final[Mapping[str, int]] = {Parameter.LOWBAT: 0}
+_ACCEPT_PARAMETER_ONLY_ON_CHANNEL: Final[Mapping[TParameterName, int]] = {Parameter.LOWBAT: 0}
 
 
 class ParameterVisibilityCache:
-    """Cache for parameter visibility."""
+    """
+    Cache for parameter visibility.
+
+    The cache centralizes rules that determine whether a data point parameter is
+    created, ignored, un-ignored, or merely hidden for UI purposes. It combines
+    static rules (per-model/per-channel) with dynamic user-provided overrides and
+    memoizes decisions per (model/channel/paramset/parameter) to avoid repeated
+    computations during runtime. Behavior is unchanged; this class only clarifies
+    intent and structure through documentation and small naming improvements.
+    """
 
     __slots__ = (
         "_central",
@@ -342,36 +361,36 @@ class ParameterVisibilityCache:
         self._central = central
         self._storage_folder: Final = central.config.storage_folder
         self._required_parameters: Final = get_required_parameters()
-        self._raw_un_ignores: Final[tuple[str, ...]] = central.config.un_ignore_list or ()
+        self._raw_un_ignores: Final[frozenset[str]] = central.config.un_ignore_list or frozenset()
 
         # un_ignore from custom un_ignore files
         # parameter
-        self._custom_un_ignore_values_parameters: Final[set[str]] = set()
+        self._custom_un_ignore_values_parameters: Final[set[TParameterName]] = set()
 
-        # model, channel_no, paramset_key, parameter
-        self._custom_un_ignore_complex: Final[dict[str, dict[int | str | None, dict[str, set[str]]]]] = defaultdict(
-            lambda: defaultdict(lambda: defaultdict(set))
-        )
-        self._ignore_custom_device_definition_models: Final[tuple[str, ...]] = (
+        # model -> channel_no -> paramset_key -> set(parameter)
+        self._custom_un_ignore_complex: Final[
+            dict[TModelName, dict[TUnIgnoreChannelNo, dict[ParamsetKey, set[TParameterName]]]]
+        ] = defaultdict(lambda: defaultdict(lambda: defaultdict(set)))
+        self._ignore_custom_device_definition_models: Final[frozenset[TModelName]] = (
             central.config.ignore_custom_device_definition_models
         )
 
         # model, channel_no, paramset_key, set[parameter]
         self._un_ignore_parameters_by_device_paramset_key: Final[
-            dict[str, dict[int | None, dict[ParamsetKey, set[str]]]]
+            dict[TModelName, dict[TChannelNo, dict[ParamsetKey, set[TParameterName]]]]
         ] = defaultdict(lambda: defaultdict(lambda: defaultdict(set)))
 
         # model, channel_no
-        self._relevant_master_paramsets_by_device: Final[dict[str, set[int | None]]] = defaultdict(set)
+        self._relevant_master_paramsets_by_device: Final[dict[TModelName, set[TChannelNo]]] = defaultdict(set)
         # Cache for resolving matching prefix key in _un_ignore_parameters_by_device_paramset_key
-        self._un_ignore_prefix_cache: dict[str, str | None] = {}
+        self._un_ignore_prefix_cache: dict[TModelName, str | None] = {}
         # Cache for resolving matching prefix key in _relevant_master_paramsets_by_device
-        self._relevant_prefix_cache: dict[str, str | None] = {}
+        self._relevant_prefix_cache: dict[TModelName, str | None] = {}
         # Per-instance memoization for repeated queries.
         # Key: (model_l, channel_no, paramset_key, parameter)
-        self._param_ignored_cache: dict[tuple[str, int, ParamsetKey, str], bool] = {}
+        self._param_ignored_cache: dict[tuple[TModelName, TChannelNo, ParamsetKey, TParameterName], bool] = {}
         # Key: (model_l, channel_no, paramset_key, parameter, custom_only)
-        self._param_un_ignored_cache: dict[tuple[str, int, ParamsetKey, str, bool], bool] = {}
+        self._param_un_ignored_cache: dict[tuple[TModelName, TChannelNo, ParamsetKey, TParameterName, bool], bool] = {}
         self._init()
 
     def _init(self) -> None:
@@ -383,7 +402,7 @@ class ParameterVisibilityCache:
             model_l = model.lower()
             channel_nos, parameters = channels_parameter
 
-            def _add_channel(dt_l: str, params: tuple[Parameter, ...], ch_no: int | None) -> None:
+            def _add_channel(dt_l: str, params: frozenset[Parameter], ch_no: TChannelNo) -> None:
                 self._relevant_master_paramsets_by_device[dt_l].add(ch_no)
                 self._un_ignore_parameters_by_device_paramset_key[dt_l][ch_no][ParamsetKey.MASTER].update(params)
 
@@ -395,7 +414,17 @@ class ParameterVisibilityCache:
 
         self._process_un_ignore_entries(lines=self._raw_un_ignores)
 
-    def model_is_ignored(self, model: str) -> bool:
+    def _resolve_prefix_key(
+        self, model_l: TModelName, mapping: Mapping[str, object], cache_dict: dict[TModelName, str | None]
+    ) -> str | None:
+        """Resolve and memoize the first key in mapping that prefixes model_l."""
+        dt_short_key = cache_dict.get(model_l)
+        if dt_short_key is None and model_l not in cache_dict:
+            dt_short_key = next((k for k in mapping if model_l.startswith(k)), None)
+            cache_dict[model_l] = dt_short_key
+        return dt_short_key
+
+    def model_is_ignored(self, model: TModelName) -> bool:
         """Check if a model should be ignored for custom data points."""
         return element_matches_key(
             search_elements=self._ignore_custom_device_definition_models,
@@ -406,13 +435,12 @@ class ParameterVisibilityCache:
         self,
         channel: hmd.Channel,
         paramset_key: ParamsetKey,
-        parameter: str,
+        parameter: TParameterName,
     ) -> bool:
         """Check if parameter can be ignored."""
         model_l = channel.device.model.lower()
         # Fast path via per-instance memoization
-        ch_no_key = channel.no if isinstance(channel.no, int) else (-1 if channel.no is None else channel.no)
-        if (cache_key := (model_l, ch_no_key, paramset_key, parameter)) in self._param_ignored_cache:
+        if (cache_key := (model_l, channel.no, paramset_key, parameter)) in self._param_ignored_cache:
             return self._param_ignored_cache[cache_key]
 
         if paramset_key == ParamsetKey.VALUES:
@@ -425,7 +453,7 @@ class ParameterVisibilityCache:
 
             if (
                 (
-                    (parameter in _IGNORED_PARAMETERS_SET or _parameter_is_wildcard_ignored(parameter=parameter))
+                    (parameter in _IGNORED_PARAMETERS or _parameter_is_wildcard_ignored(parameter=parameter))
                     and parameter not in self._required_parameters
                 )
                 or hms.element_matches_key(
@@ -454,14 +482,11 @@ class ParameterVisibilityCache:
             if parameter in self._custom_un_ignore_complex[model_l][channel.no][ParamsetKey.MASTER]:
                 return False  # pragma: no cover
 
-            # Resolve matching device type prefix once and cache per model
-            dt_short_key = self._un_ignore_prefix_cache.get(model_l)
-            if dt_short_key is None and model_l not in self._un_ignore_prefix_cache:
-                # Find first key that is a prefix of model_l
-                dt_short_key = next(
-                    (k for k in self._un_ignore_parameters_by_device_paramset_key if model_l.startswith(k)), None
-                )
-                self._un_ignore_prefix_cache[model_l] = dt_short_key
+            dt_short_key = self._resolve_prefix_key(
+                model_l=model_l,
+                mapping=self._un_ignore_parameters_by_device_paramset_key,
+                cache_dict=self._un_ignore_prefix_cache,
+            )
             if (
                 dt_short_key is not None
                 and parameter
@@ -479,7 +504,7 @@ class ParameterVisibilityCache:
         self,
         channel: hmd.Channel,
         paramset_key: ParamsetKey,
-        parameter: str,
+        parameter: TParameterName,
         custom_only: bool = False,
     ) -> bool:
         """
@@ -496,8 +521,7 @@ class ParameterVisibilityCache:
         # check if parameter is in custom_un_ignore with paramset_key
         model_l = channel.device.model.lower()
         # Fast path via per-instance memoization
-        ch_no_key = channel.no if isinstance(channel.no, int) else (-1 if channel.no is None else channel.no)
-        if (cache_key := (model_l, ch_no_key, paramset_key, parameter, custom_only)) in self._param_un_ignored_cache:
+        if (cache_key := (model_l, channel.no, paramset_key, parameter, custom_only)) in self._param_un_ignored_cache:
             return self._param_un_ignored_cache[cache_key]
 
         search_matrix = (
@@ -529,7 +553,7 @@ class ParameterVisibilityCache:
         self,
         channel: hmd.Channel,
         paramset_key: ParamsetKey,
-        parameter: str,
+        parameter: TParameterName,
         custom_only: bool = False,
     ) -> bool:
         """
@@ -540,13 +564,11 @@ class ParameterVisibilityCache:
         """
         if not custom_only:
             model_l = channel.device.model.lower()
-            # Resolve matching device type prefix once and cache per model
-            dt_short_key = self._un_ignore_prefix_cache.get(model_l)
-            if dt_short_key is None and model_l not in self._un_ignore_prefix_cache:
-                dt_short_key = next(
-                    (k for k in self._un_ignore_parameters_by_device_paramset_key if model_l.startswith(k)), None
-                )
-                self._un_ignore_prefix_cache[model_l] = dt_short_key
+            dt_short_key = self._resolve_prefix_key(
+                model_l=model_l,
+                mapping=self._un_ignore_parameters_by_device_paramset_key,
+                cache_dict=self._un_ignore_prefix_cache,
+            )
 
             # check if parameter is in _RELEVANT_MASTER_PARAMSETS_BY_DEVICE
             if (
@@ -564,7 +586,7 @@ class ParameterVisibilityCache:
         )
 
     def should_skip_parameter(
-        self, channel: hmd.Channel, paramset_key: ParamsetKey, parameter: str, parameter_is_un_ignored: bool
+        self, channel: hmd.Channel, paramset_key: ParamsetKey, parameter: TParameterName, parameter_is_un_ignored: bool
     ) -> bool:
         """Determine if a parameter should be skipped."""
         if self.parameter_is_ignored(
@@ -587,7 +609,7 @@ class ParameterVisibilityCache:
 
         return paramset_key == ParamsetKey.MASTER and not parameter_is_un_ignored
 
-    def _process_un_ignore_entries(self, lines: tuple[str, ...]) -> None:
+    def _process_un_ignore_entries(self, lines: Iterable[str]) -> None:
         """Batch process un_ignore entries into cache."""
         for line in lines:
             # ignore empty line
@@ -610,17 +632,19 @@ class ParameterVisibilityCache:
                     line,
                 )
 
-    def _get_un_ignore_line_details(self, line: str) -> tuple[str, int | str | None, str, ParamsetKey] | str | None:
+    def _get_un_ignore_line_details(
+        self, line: str
+    ) -> tuple[TModelName, TUnIgnoreChannelNo, TParameterName, ParamsetKey] | str | None:
         """
         Check the format of the line for un_ignore file.
 
         model, channel_no, paramset_key, parameter
         """
 
-        model: str | None = None
-        channel_no: int | str | None = None
+        model: TModelName | None = None
+        channel_no: TUnIgnoreChannelNo = None
         paramset_key: ParamsetKey | None = None
-        parameter: str | None = None
+        parameter: TParameterName | None = None
 
         if "@" in line:
             data = line.split("@")
@@ -687,10 +711,10 @@ class ParameterVisibilityCache:
 
     def _add_complex_un_ignore_entry(
         self,
-        model: str,
-        channel_no: int | str | None,
+        model: TModelName,
+        channel_no: TUnIgnoreChannelNo,
         paramset_key: ParamsetKey,
-        parameter: str,
+        parameter: TParameterName,
     ) -> None:
         """Add line to un ignore cache."""
         if paramset_key == ParamsetKey.MASTER:
@@ -713,7 +737,7 @@ class ParameterVisibilityCache:
         self,
         channel: hmd.Channel,
         paramset_key: ParamsetKey,
-        parameter: str,
+        parameter: TParameterName,
     ) -> bool:
         """
         Return if parameter should be hidden.
@@ -721,7 +745,7 @@ class ParameterVisibilityCache:
         This is required to determine the data_point usage.
         Return only hidden parameters, that are no defined in the un_ignore file.
         """
-        return parameter in _HIDDEN_PARAMETERS_SET and not self._parameter_is_un_ignored(
+        return parameter in _HIDDEN_PARAMETERS and not self._parameter_is_un_ignored(
             channel=channel,
             paramset_key=paramset_key,
             parameter=parameter,
@@ -744,12 +768,11 @@ class ParameterVisibilityCache:
                 return True
             model_l = channel.device.model.lower()
             # Resolve matching device type prefix once and cache per model
-            dt_short_key = self._relevant_prefix_cache.get(model_l)
-            if dt_short_key is None and model_l not in self._relevant_prefix_cache:
-                dt_short_key = next(
-                    (k for k in self._relevant_master_paramsets_by_device if model_l.startswith(k)), None
-                )
-                self._relevant_prefix_cache[model_l] = dt_short_key
+            dt_short_key = self._resolve_prefix_key(
+                model_l=model_l,
+                mapping=self._relevant_master_paramsets_by_device,
+                cache_dict=self._relevant_prefix_cache,
+            )
             if dt_short_key is not None and channel.no in self._relevant_master_paramsets_by_device[dt_short_key]:
                 return True
         return False
@@ -766,7 +789,7 @@ def check_ignore_parameters_is_clean() -> bool:
             [
                 parameter
                 for parameter in get_required_parameters()
-                if (parameter in _IGNORED_PARAMETERS_SET or _parameter_is_wildcard_ignored(parameter=parameter))
+                if (parameter in _IGNORED_PARAMETERS or _parameter_is_wildcard_ignored(parameter=parameter))
                 and parameter not in un_ignore_parameters_by_device
             ]
         )