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

aiohomematic/const.py

@@ -19,7 +19,7 @@ import sys
 from types import MappingProxyType
 from typing import Any, Final, NamedTuple, Required, TypeAlias, TypedDict
 
-VERSION: Final = "2025.10.21"
+VERSION: Final = "2025.10.22"
 
 # Detect test speedup mode via environment
 _TEST_SPEEDUP: Final = (
@@ -303,7 +303,7 @@ class EventKey(StrEnum):
     INTERFACE_ID = "interface_id"
     MODEL = "model"
     PARAMETER = "parameter"
-    PONG_MISMATCH_ALLOWED = "pong_mismatch_allowed"
+    PONG_MISMATCH_ACCEPTABLE = "pong_mismatch_allowed"
     PONG_MISMATCH_COUNT = "pong_mismatch_count"
     SECONDS_SINCE_LAST_EVENT = "seconds_since_last_event"
     TYPE = "type"

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_fire_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,59 +428,56 @@ 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_fire_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_fire_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:
+    def _check_and_fire_pong_event(self, *, event_type: InterfaceEventType) -> None:
         """Fire an event about the pong status."""
 
         def _fire_event(mismatch_count: int) -> None:
@@ -520,7 +491,7 @@ 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,
                             },
                         }
@@ -528,44 +499,46 @@ class PingPongCache:
                 ),
             )
 
-        if self.low_pending_pongs and event_type == InterfaceEventType.PENDING_PONG:
+        if event_type == InterfaceEventType.PENDING_PONG:
+            self._cleanup_pending_pongs()
+            count = self._pending_pong_count
+            if self._pending_pong_count > self._allowed_delta:
+                # Emit interface event to inform subscribers about high pending pong count.
+                _fire_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:
+            elif self._pending_pong_logged:
                 _fire_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:
+                _fire_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.
+                _fire_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]]] = {

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiohomematic
-Version: 2025.10.21
+Version: 2025.10.22
 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>

{aiohomematic-2025.10.21.dist-info → aiohomematic-2025.10.22.dist-info}/RECORD

@@ -1,6 +1,6 @@
 aiohomematic/__init__.py,sha256=Uo9CIoil0Arl3GwtgMZAwM8jhcgoBKcZEgj8cXYlswY,2258
 aiohomematic/async_support.py,sha256=Fg6RLD7Irt1mTwXbLkfphJbfd7oU_Svhp23i3Bb4Q7k,8762
-aiohomematic/const.py,sha256=YOCIFXt3xTY7GT29XqKpHi8Ir9eYYtY6Ur2bzWwtCIs,27479
+aiohomematic/const.py,sha256=omyYHT1lCVMAju-lRA3nTU0yuX2C_vM8MuZ5K3ofstA,27482
 aiohomematic/context.py,sha256=hGE-iPcPt21dY-1MZar-Hyh9YaKL-VS42xjrulIVyRQ,429
 aiohomematic/converter.py,sha256=FiHU71M5RZ7N5FXJYh2CN14s63-PM-SHdb0cJ_CLx54,3602
 aiohomematic/decorators.py,sha256=cSW0aF3PzrW_qW6H0sjRNH9eqO8ysqhXZDgJ2OJTZM4,11038
@@ -66,11 +66,11 @@ aiohomematic/rega_scripts/get_system_variable_descriptions.fn,sha256=UKXvC0_5lSA
 aiohomematic/rega_scripts/set_program_state.fn,sha256=0bnv7lUj8FMjDZBz325tDVP61m04cHjVj4kIOnUUgpY,279
 aiohomematic/rega_scripts/set_system_variable.fn,sha256=sTmr7vkPTPnPkor5cnLKlDvfsYRbGO1iq2z_2pMXq5E,383
 aiohomematic/store/__init__.py,sha256=PHwF_tw_zL20ODwLywHgpOLWrghQo_BMZzeiQSXN1Fc,1081
-aiohomematic/store/dynamic.py,sha256=K1nTal_bYTxOXF8Brmyv3yl7A4cy9ZZm0SQ9ANbUKi4,22757
+aiohomematic/store/dynamic.py,sha256=7grL-rpIh4CYWVNqL7WO66zRJuw7qfi34S2sxSbsOac,22049
 aiohomematic/store/persistent.py,sha256=SBL8AhqUzpoPtJ50GkLYHwvRJS52fBWqNPjgvykxbY8,40233
-aiohomematic/store/visibility.py,sha256=0y93kPTugqQsrh6kKamfgwBkbIdBPEZpQVv_1NaLz3A,31662
-aiohomematic-2025.10.21.dist-info/licenses/LICENSE,sha256=q-B0xpREuZuvKsmk3_iyVZqvZ-vJcWmzMZpeAd0RqtQ,1083
-aiohomematic-2025.10.21.dist-info/METADATA,sha256=l1aVOPRrDGn6JSPcroaoRuZkFlmja6f-lv35NUnU-oI,7672
-aiohomematic-2025.10.21.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aiohomematic-2025.10.21.dist-info/top_level.txt,sha256=iGUvt1N-E72vKRq7Anpp62HwkQngStrUK0JfL1zj1TE,13
-aiohomematic-2025.10.21.dist-info/RECORD,,
+aiohomematic/store/visibility.py,sha256=VAoaHMsCnIwcaTQjx_RkpPb64o5xjVNRldCfB2MGc1M,31680
+aiohomematic-2025.10.22.dist-info/licenses/LICENSE,sha256=q-B0xpREuZuvKsmk3_iyVZqvZ-vJcWmzMZpeAd0RqtQ,1083
+aiohomematic-2025.10.22.dist-info/METADATA,sha256=EG8oIYVQQVkO-mIfd5qUP8m1dxEULgWytT8DReLcBlo,7672
+aiohomematic-2025.10.22.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aiohomematic-2025.10.22.dist-info/top_level.txt,sha256=iGUvt1N-E72vKRq7Anpp62HwkQngStrUK0JfL1zj1TE,13
+aiohomematic-2025.10.22.dist-info/RECORD,,