aiohomematic 2025.10.21__py3-none-any.whl → 2025.10.24__py3-none-any.whl

aiohomematic/model/data_point.py

@@ -143,7 +143,7 @@ class CallbackDataPoint(ABC, LogContextMixin):
         "_custom_id",
         "_data_point_updated_callbacks",
         "_device_removed_callbacks",
-        "_fired_event_at",
+        "_emitted_event_at",
         "_modified_at",
         "_path_data",
         "_refreshed_at",
@@ -163,7 +163,7 @@ class CallbackDataPoint(ABC, LogContextMixin):
         self._device_removed_callbacks: list[Callable] = []
         self._custom_id: str | None = None
         self._path_data = self._get_path_data()
-        self._fired_event_at: datetime = INIT_DATETIME
+        self._emitted_event_at: datetime = INIT_DATETIME
         self._modified_at: datetime = INIT_DATETIME
         self._refreshed_at: datetime = INIT_DATETIME
         self._signature: Final = self._get_signature()
@@ -191,16 +191,16 @@ class CallbackDataPoint(ABC, LogContextMixin):
         return self._custom_id
 
     @property
-    def fired_event_at(self) -> datetime:
-        """Return the data point updated fired an event at."""
-        return self._fired_event_at
+    def emitted_event_at(self) -> datetime:
+        """Return the data point updated emitted an event at."""
+        return self._emitted_event_at
 
     @state_property
-    def fired_event_recently(self) -> bool:
-        """Return the data point fired an event within 500 milliseconds."""
-        if self._fired_event_at == INIT_DATETIME:
+    def emitted_event_recently(self) -> bool:
+        """Return the data point emitted an event within 500 milliseconds."""
+        if self._emitted_event_at == INIT_DATETIME:
             return False
-        return (datetime.now() - self._fired_event_at).total_seconds() < 0.5
+        return (datetime.now() - self._emitted_event_at).total_seconds() < 0.5
 
     @classmethod
     def default_category(cls) -> DataPointCategory:
@@ -357,11 +357,11 @@ class CallbackDataPoint(ABC, LogContextMixin):
             self._device_removed_callbacks.remove(cb)
 
     @loop_check
-    def fire_data_point_updated_callback(self, **kwargs: Any) -> None:
+    def emit_data_point_updated_event(self, **kwargs: Any) -> None:
         """Do what is needed when the value of the data_point has been updated/refreshed."""
-        if not self._should_fire_data_point_updated_callback:
+        if not self._should_emit_data_point_updated_callback:
             return
-        self._fired_event_at = datetime.now()
+        self._emitted_event_at = datetime.now()
         for callback_handler, custom_id in self._data_point_updated_callbacks.items():
             try:
                 # Add the data_point reference once to kwargs to avoid per-callback writes.
@@ -369,19 +369,19 @@ class CallbackDataPoint(ABC, LogContextMixin):
                 kwargs[KWARGS_ARG_CUSTOM_ID] = custom_id
                 callback_handler(**kwargs)
             except Exception as exc:
-                _LOGGER.warning("FIRE_DATA_POINT_UPDATED_EVENT failed: %s", extract_exc_args(exc=exc))
+                _LOGGER.warning("EMIT_DATA_POINT_UPDATED_EVENT failed: %s", extract_exc_args(exc=exc))
 
     @loop_check
-    def fire_device_removed_callback(self) -> None:
+    def emit_device_removed_event(self) -> None:
         """Do what is needed when the data_point has been removed."""
         for callback_handler in self._device_removed_callbacks:
             try:
                 callback_handler()
             except Exception as exc:
-                _LOGGER.warning("FIRE_DEVICE_REMOVED_EVENT failed: %s", extract_exc_args(exc=exc))
+                _LOGGER.warning("EMIT_DEVICE_REMOVED_EVENT failed: %s", extract_exc_args(exc=exc))
 
     @property
-    def _should_fire_data_point_updated_callback(self) -> bool:
+    def _should_emit_data_point_updated_callback(self) -> bool:
         """Check if a data point has been updated or refreshed."""
         return True
 
@@ -895,7 +895,7 @@ class BaseParameterDataPoint[
         if value == NO_CACHE_ENTRY:
             if self.refreshed_at != INIT_DATETIME:
                 self._state_uncertain = True
-                self.fire_data_point_updated_callback()
+                self.emit_data_point_updated_event()
             return (old_value, None)  # type: ignore[return-value]
 
         new_value = self._convert_value(value=value)
@@ -906,7 +906,7 @@ class BaseParameterDataPoint[
             self._previous_value = old_value
             self._current_value = new_value
         self._state_uncertain = False
-        self.fire_data_point_updated_callback()
+        self.emit_data_point_updated_event()
         return (old_value, new_value)
 
     def write_temporary_value(self, *, value: Any, write_at: datetime) -> None:
@@ -920,7 +920,7 @@ class BaseParameterDataPoint[
             self._set_temporary_modified_at(modified_at=write_at)
             self._temporary_value = temp_value
             self._state_uncertain = True
-        self.fire_data_point_updated_callback()
+        self.emit_data_point_updated_event()
 
     def update_parameter_data(self) -> None:
         """Update parameter data."""

aiohomematic/model/device.py

@@ -598,7 +598,7 @@ class Device(LogContextMixin, PayloadMixin):
         if self._forced_availability != forced_availability:
             self._forced_availability = forced_availability
             for dp in self.generic_data_points:
-                dp.fire_data_point_updated_callback()
+                dp.emit_data_point_updated_event()
 
     @inspector
     async def export_device_definition(self) -> None:
@@ -674,17 +674,17 @@ class Device(LogContextMixin, PayloadMixin):
         await self._central.save_files(save_paramset_descriptions=True)
         for dp in self.generic_data_points:
             dp.update_parameter_data()
-        self.fire_device_updated_callback()
+        self.emit_device_updated_callback()
 
     @loop_check
-    def fire_device_updated_callback(self) -> None:
+    def emit_device_updated_callback(self) -> None:
         """Do what is needed when the state of the device has been updated."""
         self._set_modified_at()
         for callback_handler in self._device_updated_callbacks:
             try:
                 callback_handler()
             except Exception as exc:
-                _LOGGER.warning("FIRE_DEVICE_UPDATED failed: %s", extract_exc_args(exc=exc))
+                _LOGGER.warning("EMIT_DEVICE_UPDATED failed: %s", extract_exc_args(exc=exc))
 
     def __str__(self) -> str:
         """Provide some useful information."""
@@ -963,7 +963,7 @@ class Channel(LogContextMixin, PayloadMixin):
             self._calculated_data_points[data_point.dpk] = data_point
         if isinstance(data_point, GenericDataPoint):
             self._generic_data_points[data_point.dpk] = data_point
-            self._device.register_device_updated_callback(cb=data_point.fire_data_point_updated_callback)
+            self._device.register_device_updated_callback(cb=data_point.emit_data_point_updated_event)
         if isinstance(data_point, hmce.CustomDataPoint):
             self._custom_data_point = data_point
         if isinstance(data_point, GenericEvent):
@@ -977,12 +977,12 @@ class Channel(LogContextMixin, PayloadMixin):
             del self._calculated_data_points[data_point.dpk]
         if isinstance(data_point, GenericDataPoint):
             del self._generic_data_points[data_point.dpk]
-            self._device.unregister_device_updated_callback(cb=data_point.fire_data_point_updated_callback)
+            self._device.unregister_device_updated_callback(cb=data_point.emit_data_point_updated_event)
         if isinstance(data_point, hmce.CustomDataPoint):
             self._custom_data_point = None
         if isinstance(data_point, GenericEvent):
             del self._generic_events[data_point.dpk]
-        data_point.fire_device_removed_callback()
+        data_point.emit_device_removed_event()
 
     def remove(self) -> None:
         """Remove data points from collections and central."""

aiohomematic/model/event.py

@@ -8,7 +8,7 @@ button presses, device errors, and impulse notifications to applications.
 
 Included classes:
 - GenericEvent: Base event that integrates with the common data point API
-  (category, usage, names/paths, callbacks) and provides fire_event handling.
+  (category, usage, names/paths, callbacks) and provides emit_event handling.
 - ClickEvent: Represents key press events (EventType.KEYPRESS).
 - DeviceErrorEvent: Represents device error signaling with special value change
   semantics before emitting an event (EventType.DEVICE_ERROR).
@@ -102,14 +102,14 @@ class GenericEvent(BaseParameterDataPoint[Any, Any]):
     async def event(self, *, value: Any, received_at: datetime) -> None:
         """Handle event for which this handler has subscribed."""
         if self.event_type in DATA_POINT_EVENTS:
-            self.fire_data_point_updated_callback()
+            self.emit_data_point_updated_event()
         self._set_modified_at(modified_at=received_at)
-        self.fire_event(value=value)
+        self.emit_event(value=value)
 
     @loop_check
-    def fire_event(self, *, value: Any) -> None:
-        """Do what is needed to fire an event."""
-        self._central.fire_homematic_callback(event_type=self.event_type, event_data=self.get_event_data(value=value))
+    def emit_event(self, *, value: Any) -> None:
+        """Do what is needed to emit an event."""
+        self._central.emit_homematic_callback(event_type=self.event_type, event_data=self.get_event_data(value=value))
 
     def _get_data_point_name(self) -> DataPointNameData:
         """Create the name for the data_point."""
@@ -149,7 +149,7 @@ class DeviceErrorEvent(GenericEvent):
             isinstance(new_value, int)
             and ((old_value is None and new_value > 0) or (isinstance(old_value, int) and old_value != new_value))
         ):
-            self.fire_event(value=new_value)
+            self.emit_event(value=new_value)
 
 
 class ImpulseEvent(GenericEvent):

aiohomematic/model/generic/data_point.py

@@ -83,8 +83,8 @@ class GenericDataPoint[ParameterT: GenericParameterType, InputParameterT: Generi
             Parameter.UN_REACH,
             Parameter.STICKY_UN_REACH,
         ):
-            self._device.fire_device_updated_callback()
-            self._central.fire_homematic_callback(
+            self._device.emit_device_updated_callback()
+            self._central.emit_homematic_callback(
                 event_type=EventType.DEVICE_AVAILABILITY,
                 event_data=self.get_event_data(value=new_value),
             )

aiohomematic/model/hub/__init__.py

@@ -204,7 +204,7 @@ class Hub:
                 new_programs.append(program_dp.switch)
 
         if new_programs:
-            self._central.fire_backend_system_callback(
+            self._central.emit_backend_system_callback(
                 system_event=BackendSystemEvent.HUB_REFRESHED,
                 new_data_points=_get_new_hub_data_points(data_points=new_programs),
             )
@@ -240,7 +240,7 @@ class Hub:
                 new_sysvars.append(self._create_system_variable(data=sysvar))
 
         if new_sysvars:
-            self._central.fire_backend_system_callback(
+            self._central.emit_backend_system_callback(
                 system_event=BackendSystemEvent.HUB_REFRESHED,
                 new_data_points=_get_new_hub_data_points(data_points=new_sysvars),
             )

aiohomematic/model/hub/data_point.py

@@ -230,7 +230,7 @@ class GenericSysvarDataPoint(GenericHubDataPoint):
             self._previous_value = old_value
             self._current_value = new_value
         self._state_uncertain = False
-        self.fire_data_point_updated_callback()
+        self.emit_data_point_updated_event()
 
     def _write_temporary_value(self, *, value: Any, write_at: datetime) -> None:
         """Update the temporary value of the data_point."""
@@ -243,7 +243,7 @@ class GenericSysvarDataPoint(GenericHubDataPoint):
             self._set_temporary_modified_at(modified_at=write_at)
             self._temporary_value = temp_value
             self._state_uncertain = True
-        self.fire_data_point_updated_callback()
+        self.emit_data_point_updated_event()
 
     def _convert_value(self, *, old_value: Any, new_value: Any) -> Any:
         """Convert to value to SYSVAR_TYPE."""
@@ -333,7 +333,7 @@ class GenericProgramDataPoint(GenericHubDataPoint):
             self._last_execute_time = data.last_execute_time
             do_update = True
         if do_update:
-            self.fire_data_point_updated_callback()
+            self.emit_data_point_updated_event()
 
     def _get_path_data(self) -> PathData:
         """Return the path data of the data_point."""

aiohomematic/property_decorators.py

@@ -117,7 +117,7 @@ class _GenericProperty[GETTER, SETTER](property):
             kind=self.kind,
             cached=self._cached,
             log_context=self.log_context,
-        )  # pragma: no cover
+        )
 
     def setter(self, fset: Callable[[Any, SETTER], None], /) -> _GenericProperty:
         """Return generic setter."""
@@ -155,7 +155,7 @@ class _GenericProperty[GETTER, SETTER](property):
             return cast(GETTER, self)
 
         if (fget := self.fget) is None:
-            raise AttributeError("unreadable attribute")  # pragma: no cover
+            raise AttributeError("unreadable attribute")
 
         if not self._cached:
             return fget(instance)
@@ -194,7 +194,7 @@ class _GenericProperty[GETTER, SETTER](property):
                     delattr(instance, self._cache_attr)
 
         if self.fset is None:
-            raise AttributeError("can't set attribute")  # pragma: no cover
+            raise AttributeError("can't set attribute")
         self.fset(instance, value)
 
     def __delete__(self, instance: Any, /) -> None:
@@ -210,7 +210,7 @@ class _GenericProperty[GETTER, SETTER](property):
                     delattr(instance, self._cache_attr)
 
         if self.fdel is None:
-            raise AttributeError("can't delete attribute")  # pragma: no cover
+            raise AttributeError("can't delete attribute")
         self.fdel(instance)
 
 

aiohomematic/store/dynamic.py

@@ -392,36 +392,12 @@ class PingPongCache:
         return self._allowed_delta
 
     @property
-    def high_pending_pongs(self) -> bool:
-        """Check, if store contains too many pending pongs."""
-        self._cleanup_pending_pongs()
-        return len(self._pending_pongs) > self._allowed_delta
-
-    @property
-    def high_unknown_pongs(self) -> bool:
-        """Check, if store contains too many unknown pongs."""
-        self._cleanup_unknown_pongs()
-        return len(self._unknown_pongs) > self._allowed_delta
-
-    @property
-    def low_pending_pongs(self) -> bool:
-        """Return True when pending pong count is at or below the allowed delta (i.e., not high)."""
-        self._cleanup_pending_pongs()
-        return len(self._pending_pongs) <= self._allowed_delta
-
-    @property
-    def low_unknown_pongs(self) -> bool:
-        """Return True when unknown pong count is at or below the allowed delta (i.e., not high)."""
-        self._cleanup_unknown_pongs()
-        return len(self._unknown_pongs) <= self._allowed_delta
-
-    @property
-    def pending_pong_count(self) -> int:
+    def _pending_pong_count(self) -> int:
         """Return the pending pong count."""
         return len(self._pending_pongs)
 
     @property
-    def unknown_pong_count(self) -> int:
+    def _unknown_pong_count(self) -> int:
         """Return the unknown pong count."""
         return len(self._unknown_pongs)
 
@@ -435,18 +411,16 @@ class PingPongCache:
     def handle_send_ping(self, *, ping_ts: datetime) -> None:
         """Handle send ping timestamp."""
         self._pending_pongs.add(ping_ts)
+        self._cleanup_pending_pongs()
         # Throttle event emission to every second ping to avoid spamming callbacks,
         # but always emit when crossing the high threshold.
-        count = self.pending_pong_count
+        count = self._pending_pong_count
         if (count > self._allowed_delta) or (count % 2 == 0):
-            self._check_and_fire_pong_event(
-                event_type=InterfaceEventType.PENDING_PONG,
-                pong_mismatch_count=count,
-            )
+            self._check_and_emit_pong_event(event_type=InterfaceEventType.PENDING_PONG)
         _LOGGER.debug(
             "PING PONG CACHE: Increase pending PING count: %s - %i for ts: %s",
             self._interface_id,
-            self.pending_pong_count,
+            count,
             ping_ts,
         )
 
@@ -454,63 +428,61 @@ class PingPongCache:
         """Handle received pong timestamp."""
         if pong_ts in self._pending_pongs:
             self._pending_pongs.remove(pong_ts)
-            self._check_and_fire_pong_event(
-                event_type=InterfaceEventType.PENDING_PONG,
-                pong_mismatch_count=self.pending_pong_count,
-            )
+            self._cleanup_pending_pongs()
+            count = self._pending_pong_count
+            self._check_and_emit_pong_event(event_type=InterfaceEventType.PENDING_PONG)
             _LOGGER.debug(
                 "PING PONG CACHE: Reduce pending PING count: %s - %i for ts: %s",
                 self._interface_id,
-                self.pending_pong_count,
+                count,
+                pong_ts,
+            )
+        else:
+            self._unknown_pongs.add(pong_ts)
+            self._cleanup_unknown_pongs()
+            count = self._unknown_pong_count
+            self._check_and_emit_pong_event(event_type=InterfaceEventType.UNKNOWN_PONG)
+            _LOGGER.debug(
+                "PING PONG CACHE: Increase unknown PONG count: %s - %i for ts: %s",
+                self._interface_id,
+                count,
                 pong_ts,
             )
-            return
-
-        self._unknown_pongs.add(pong_ts)
-        self._check_and_fire_pong_event(
-            event_type=InterfaceEventType.UNKNOWN_PONG,
-            pong_mismatch_count=self.unknown_pong_count,
-        )
-        _LOGGER.debug(
-            "PING PONG CACHE: Increase unknown PONG count: %s - %i for ts: %s",
-            self._interface_id,
-            self.unknown_pong_count,
-            pong_ts,
-        )
 
     def _cleanup_pending_pongs(self) -> None:
         """Cleanup too old pending pongs."""
         dt_now = datetime.now()
-        for pong_ts in list(self._pending_pongs):
+        for pp_pong_ts in list(self._pending_pongs):
             # Only expire entries that are actually older than the TTL.
-            if (dt_now - pong_ts).total_seconds() > self._ttl:
-                self._pending_pongs.remove(pong_ts)
+            if (dt_now - pp_pong_ts).total_seconds() > self._ttl:
+                self._pending_pongs.remove(pp_pong_ts)
                 _LOGGER.debug(
                     "PING PONG CACHE: Removing expired pending PONG: %s - %i for ts: %s",
                     self._interface_id,
-                    self.pending_pong_count,
-                    pong_ts,
+                    self._pending_pong_count,
+                    pp_pong_ts,
                 )
 
     def _cleanup_unknown_pongs(self) -> None:
         """Cleanup too old unknown pongs."""
         dt_now = datetime.now()
-        for pong_ts in list(self._unknown_pongs):
+        for up_pong_ts in list(self._unknown_pongs):
             # Only expire entries that are actually older than the TTL.
-            if (dt_now - pong_ts).total_seconds() > self._ttl:
-                self._unknown_pongs.remove(pong_ts)
+            if (dt_now - up_pong_ts).total_seconds() > self._ttl:
+                self._unknown_pongs.remove(up_pong_ts)
                 _LOGGER.debug(
                     "PING PONG CACHE: Removing expired unknown PONG: %s - %i or ts: %s",
                     self._interface_id,
-                    self.unknown_pong_count,
-                    pong_ts,
+                    self._unknown_pong_count,
+                    up_pong_ts,
                 )
 
-    def _check_and_fire_pong_event(self, *, event_type: InterfaceEventType, pong_mismatch_count: int) -> None:
-        """Fire an event about the pong status."""
+    def _check_and_emit_pong_event(self, *, event_type: InterfaceEventType) -> None:
+        """Emit an event about the pong status."""
 
-        def _fire_event(mismatch_count: int) -> None:
-            self._central.fire_homematic_callback(
+        def _emit_event(mismatch_count: int) -> None:
+            """Emit event."""
+            self._central.emit_homematic_callback(
                 event_type=EventType.INTERFACE,
                 event_data=cast(
                     dict[EventKey, Any],
@@ -520,52 +492,60 @@ class PingPongCache:
                             EventKey.TYPE: event_type,
                             EventKey.DATA: {
                                 EventKey.CENTRAL_NAME: self._central.name,
-                                EventKey.PONG_MISMATCH_ALLOWED: mismatch_count <= self._allowed_delta,
+                                EventKey.PONG_MISMATCH_ACCEPTABLE: mismatch_count <= self._allowed_delta,
                                 EventKey.PONG_MISMATCH_COUNT: mismatch_count,
                             },
                         }
                     ),
                 ),
             )
+            _LOGGER.debug(
+                "PING PONG CACHE: Emitting event %s for %s with mismatch_count: %i with %i acceptable",
+                event_type,
+                self._interface_id,
+                mismatch_count,
+                self._allowed_delta,
+            )
 
-        if self.low_pending_pongs and event_type == InterfaceEventType.PENDING_PONG:
+        if event_type == InterfaceEventType.PENDING_PONG:
+            self._cleanup_pending_pongs()
+            if (count := self._pending_pong_count) > self._allowed_delta:
+                # Emit interface event to inform subscribers about high pending pong count.
+                _emit_event(mismatch_count=count)
+                if self._pending_pong_logged is False:
+                    _LOGGER.warning(
+                        "Pending PONG mismatch: There is a mismatch between send ping events and received pong events for instance %s. "
+                        "Possible reason 1: You are running multiple instances with the same instance name configured for this integration. "
+                        "Re-add one instance! Otherwise this instance will not receive update events from your CCU. "
+                        "Possible reason 2: Something is stuck on the CCU or hasn't been cleaned up. Therefore, try a CCU restart."
+                        "Possible reason 3: Your setup is misconfigured and this instance is not able to receive events from the CCU.",
+                        self._interface_id,
+                    )
+                self._pending_pong_logged = True
             # In low state:
             # - If we previously logged a high state, emit a reset event (mismatch=0) exactly once.
             # - Otherwise, throttle emission to every second ping (even counts > 0) to avoid spamming.
-            if self._pending_pong_logged:
-                _fire_event(mismatch_count=0)
+            elif self._pending_pong_logged:
+                _emit_event(mismatch_count=0)
                 self._pending_pong_logged = False
-                return
-            if pong_mismatch_count > 0 and pong_mismatch_count % 2 == 0:
-                _fire_event(mismatch_count=pong_mismatch_count)
-            return
-
-        if self.low_unknown_pongs and event_type == InterfaceEventType.UNKNOWN_PONG:
-            # For unknown pongs, only reset the logged flag when we drop below the threshold.
-            # We do not emit an event here since there is no explicit expectation for a reset notification.
-            self._unknown_pong_logged = False
-            return
-
-        if self.high_pending_pongs and event_type == InterfaceEventType.PENDING_PONG:
-            _fire_event(mismatch_count=pong_mismatch_count)
-            if self._pending_pong_logged is False:
-                _LOGGER.warning(
-                    "Pending PONG mismatch: There is a mismatch between send ping events and received pong events for instance %s. "
-                    "Possible reason 1: You are running multiple instances with the same instance name configured for this integration. "
-                    "Re-add one instance! Otherwise this instance will not receive update events from your CCU. "
-                    "Possible reason 2: Something is stuck on the CCU or hasn't been cleaned up. Therefore, try a CCU restart."
-                    "Possible reason 3: Your setup is misconfigured and this instance is not able to receive events from the CCU.",
-                    self._interface_id,
-                )
-            self._pending_pong_logged = True
-
-        if self.high_unknown_pongs and event_type == InterfaceEventType.UNKNOWN_PONG:
-            if self._unknown_pong_logged is False:
-                _LOGGER.warning(
-                    "Unknown PONG Mismatch: Your instance %s receives PONG events, that it hasn't send. "
-                    "Possible reason 1: You are running multiple instances with the same instance name configured for this integration. "
-                    "Re-add one instance! Otherwise the other instance will not receive update events from your CCU. "
-                    "Possible reason 2: Something is stuck on the CCU or hasn't been cleaned up. Therefore, try a CCU restart.",
-                    self._interface_id,
-                )
-            self._unknown_pong_logged = True
+            elif count > 0 and count % 2 == 0:
+                _emit_event(mismatch_count=count)
+        elif event_type == InterfaceEventType.UNKNOWN_PONG:
+            self._cleanup_unknown_pongs()
+            count = self._unknown_pong_count
+            if self._unknown_pong_count > self._allowed_delta:
+                # Emit interface event to inform subscribers about high unknown pong count.
+                _emit_event(mismatch_count=count)
+                if self._unknown_pong_logged is False:
+                    _LOGGER.warning(
+                        "Unknown PONG Mismatch: Your instance %s receives PONG events, that it hasn't send. "
+                        "Possible reason 1: You are running multiple instances with the same instance name configured for this integration. "
+                        "Re-add one instance! Otherwise the other instance will not receive update events from your CCU. "
+                        "Possible reason 2: Something is stuck on the CCU or hasn't been cleaned up. Therefore, try a CCU restart.",
+                        self._interface_id,
+                    )
+                self._unknown_pong_logged = True
+            else:
+                # For unknown pongs, only reset the logged flag when we drop below the threshold.
+                # We do not emit an event here since there is no explicit expectation for a reset notification.
+                self._unknown_pong_logged = False

aiohomematic/store/visibility.py

@@ -317,7 +317,7 @@ _IGNORE_PARAMETERS_BY_DEVICE: Final[Mapping[Parameter, frozenset[TModelName]]] =
             "HmIP-WGT",
         }
     ),
-    Parameter.VALVE_STATE: frozenset({"HmIPW-FALMOT-C12", "HmIP-FALMOT-C12"}),
+    Parameter.VALVE_STATE: frozenset({"HmIP-FALMOT-C8", "HmIPW-FALMOT-C12", "HmIP-FALMOT-C12"}),
 }
 
 _IGNORE_PARAMETERS_BY_DEVICE_LOWER: Final[dict[TParameterName, frozenset[TModelName]]] = {
@@ -423,8 +423,7 @@ class ParameterVisibilityCache:
         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:
+        if (dt_short_key := cache_dict.get(model_l)) 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
@@ -486,7 +485,7 @@ class ParameterVisibilityCache:
                 return False
 
             if parameter in self._custom_un_ignore_complex[model_l][channel.no][ParamsetKey.MASTER]:
-                return False  # pragma: no cover
+                return False
 
             dt_short_key = self._resolve_prefix_key(
                 model_l=model_l,
@@ -545,7 +544,7 @@ class ParameterVisibilityCache:
         for ml, cno in search_matrix:
             if parameter in self._custom_un_ignore_complex[ml][cno][paramset_key]:
                 self._param_un_ignored_cache[cache_key] = True
-                return True  # pragma: no cover
+                return True
 
         # check if parameter is in _UN_IGNORE_PARAMETERS_BY_DEVICE
         result = bool(

{aiohomematic-2025.10.21.dist-info → aiohomematic-2025.10.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiohomematic
-Version: 2025.10.21
+Version: 2025.10.24
 Summary: Homematic interface for Home Assistant running on Python 3.
 Home-page: https://github.com/sukramj/aiohomematic
 Author-email: SukramJ <sukramj@icloud.com>, Daniel Perna <danielperna84@gmail.com>
@@ -15,10 +15,16 @@ Classifier: Intended Audience :: End Users/Desktop
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Framework :: AsyncIO
+Classifier: Typing :: Typed
 Classifier: Topic :: Home Automation
-Requires-Python: >=3.13.0
+Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp>=3.12.0