casambi-bt-revamped 0.3.12.dev7__py3-none-any.whl → 0.3.12.dev9__py3-none-any.whl

CasambiBt/_client.py

@@ -25,7 +25,13 @@ from cryptography.exceptions import InvalidSignature
 from cryptography.hazmat.primitives.asymmetric import ec
 
 from ._constants import CASA_AUTH_CHAR_UUID, ConnectionState
-from ._constants import CASA_CLASSIC_DATA_CHAR_UUID, CASA_CLASSIC_HASH_CHAR_UUID
+from ._constants import (
+    CASA_CLASSIC_CA53_CHAR_UUID,
+    CASA_CLASSIC_CONFORMANT_CA51_CHAR_UUID,
+    CASA_CLASSIC_CONFORMANT_CA53_CHAR_UUID,
+    CASA_CLASSIC_DATA_CHAR_UUID,
+    CASA_CLASSIC_HASH_CHAR_UUID,
+)
 from ._classic_crypto import classic_cmac_prefix
 from ._encryption import Encryptor
 from ._network import Network
@@ -135,6 +141,12 @@ class CasambiClient:
         # - "legacy":     [sig][payload]
         # Ground truth: casambi-android `t1.P.n(...)` and `t1.P.o(...)`.
         self._classicHeaderMode: str | None = None  # "conformant" | "legacy"
+        # Classic transport diagnostics / channel selection.
+        self._classicTxCharUuid: str | None = None
+        self._classicNotifyCharUuids: set[str] = set()
+        self._classicHashSource: str | None = None  # "ca51" | "ca52_0001" | None
+        self._classicFirstRxTs: float | None = None
+        self._classicNoRxTask: asyncio.Task[None] | None = None
 
         # Rate limit WARNING logs (especially Classic RX) to keep HA usable.
         self._logLimiter = _LogBurstLimiter()
@@ -142,6 +154,13 @@ class CasambiClient:
         self._classicRxVerified = 0
         self._classicRxUnverifiable = 0
         self._classicRxParseFail = 0
+        self._classicRxType6 = 0
+        self._classicRxType7 = 0
+        self._classicRxType9 = 0
+        self._classicRxCmdStream = 0
+        self._classicRxUnknown = 0
+        # Per-kind sample counters to ensure we emit at least a few examples for reverse engineering.
+        self._classicRxKindSamples: dict[str, int] = {}
         self._classicRxLastStatsTs = time.monotonic()
 
     @property
@@ -179,6 +198,23 @@ class CasambiClient:
         self._outPacketCount = 2
         self._inPacketCount = 1
 
+        # Reset protocol-specific state (important for reconnects).
+        self._protocolMode = None
+        self._dataCharUuid = None
+        self._deviceProtocolVersion = None
+
+        self._classicConnHash8 = None
+        self._classicTxSeq = 0
+        self._classicCmdDiv = 0
+        self._classicHeaderMode = None
+        self._classicTxCharUuid = None
+        self._classicNotifyCharUuids.clear()
+        self._classicHashSource = None
+        self._classicFirstRxTs = None
+        if self._classicNoRxTask is not None:
+            self._classicNoRxTask.cancel()
+            self._classicNoRxTask = None
+
         # Reset callback queue
         self._callbackQueue = asyncio.Queue()
         self._callbackTask = asyncio.create_task(self._processCallbacks())
@@ -255,25 +291,43 @@ class CasambiClient:
         cloud_protocol = getattr(self._network, "protocolVersion", None)
         ca51_prefix: bytes | None = None
         ca51_err: str | None = None
+        ca52_notify_err: str | None = None
+        ca53_notify_err: str | None = None
         auth_prefix: bytes | None = None
         auth_err: str | None = None
+        c0002_prefix: bytes | None = None
+        c0002_err: str | None = None
+        c0003_notify_err: str | None = None
         device_nodeinfo_protocol: int | None = None
 
-        def _log_probe_summary(mode: str) -> None:
+        def _log_probe_summary(mode: str, *, classic_variant: str | None = None) -> None:
             # One stable, high-signal line for testers.
             self._logger.warning(
-                "[CASAMBI_PROTOCOL_PROBE] address=%s mode=%s cloud_protocol=%s nodeinfo_b1=%s "
-                "data_uuid=%s classic_hash8_present=%s auth_read_prefix=%s ca51_read_prefix=%s ca51_read_error=%s auth_read_error=%s",
+                "[CASAMBI_PROTOCOL_PROBE] address=%s mode=%s cloud_protocol=%s nodeinfo_b1=%s data_uuid=%s "
+                "classic_variant=%s hash_source=%s classic_tx_uuid=%s classic_notify_uuids=%s "
+                "ca51_hash8_present=%s conn_hash8_ready=%s "
+                "auth_read_prefix=%s ca51_read_prefix=%s ca51_read_error=%s auth_read_error=%s "
+                "ca52_notify_error=%s ca53_notify_error=%s c0002_read_prefix=%s c0002_read_error=%s c0003_notify_error=%s",
                 self.address,
                 mode,
                 cloud_protocol,
                 device_nodeinfo_protocol,
                 self._dataCharUuid,
+                classic_variant,
+                self._classicHashSource,
+                self._classicTxCharUuid,
+                sorted(self._classicNotifyCharUuids) if self._classicNotifyCharUuids else None,
                 bool(classic_hash and len(classic_hash) >= 8),
+                self._classicConnHash8 is not None,
                 auth_prefix,
                 ca51_prefix,
                 ca51_err,
                 auth_err,
+                ca52_notify_err,
+                ca53_notify_err,
+                c0002_prefix,
+                c0002_err,
+                c0003_notify_err,
             )
 
         classic_hash: bytes | None = None
@@ -295,7 +349,9 @@ class CasambiClient:
         if classic_hash and len(classic_hash) >= 8:
             self._protocolMode = ProtocolMode.CLASSIC
             self._dataCharUuid = CASA_CLASSIC_DATA_CHAR_UUID
+            self._classicTxCharUuid = CASA_CLASSIC_DATA_CHAR_UUID
             self._classicHeaderMode = "legacy"
+            self._classicHashSource = "ca51"
 
             # Read connection hash (first 8 bytes are used for CMAC signing).
             raw_hash = classic_hash
@@ -320,6 +376,7 @@ class CasambiClient:
                     **notify_kwargs,
                 )
             except Exception as e:
+                ca52_notify_err = type(e).__name__
                 # Some firmwares may expose Classic signing on the EVO UUID instead.
                 # Fall through to auth-char probing if CA52 isn't available.
                 if self._logger.isEnabledFor(logging.DEBUG):
@@ -331,8 +388,25 @@ class CasambiClient:
                 self._protocolMode = None
                 self._dataCharUuid = None
                 self._classicConnHash8 = None
+                self._classicTxCharUuid = None
+                self._classicNotifyCharUuids.clear()
+                self._classicHeaderMode = None
+                self._classicHashSource = None
                 # continue detection below
             else:
+                self._classicNotifyCharUuids.add(CASA_CLASSIC_DATA_CHAR_UUID.lower())
+                # Some Classic firmwares also expose state/config notifications on CA53.
+                try:
+                    await self._gattClient.start_notify(
+                        CASA_CLASSIC_CA53_CHAR_UUID,
+                        self._queueCallback,
+                        **notify_kwargs,
+                    )
+                except Exception as e:
+                    ca53_notify_err = type(e).__name__
+                else:
+                    self._classicNotifyCharUuids.add(CASA_CLASSIC_CA53_CHAR_UUID.lower())
+
                 # Classic has no EVO-style key exchange/auth; we can send immediately.
                 self._connectionState = ConnectionState.AUTHENTICATED
                 self._logger.info("Protocol mode selected: CLASSIC")
@@ -343,7 +417,24 @@ class CasambiClient:
                         len(self._classicConnHash8),
                         b2a(self._classicConnHash8),
                     )
-                _log_probe_summary("CLASSIC")
+                self._logger.warning(
+                    "[CASAMBI_CLASSIC_SELECTED] address=%s variant=ca52_legacy data_uuid=%s tx_uuid=%s notify_uuids=%s header_mode=%s conn_hash8_prefix=%s",
+                    self.address,
+                    self._dataCharUuid,
+                    self._classicTxCharUuid,
+                    sorted(self._classicNotifyCharUuids) if self._classicNotifyCharUuids else None,
+                    self._classicHeaderMode,
+                    b2a(self._classicConnHash8),
+                )
+                self._logger.warning(
+                    "[CASAMBI_CLASSIC_KEYS] visitor=%s manager=%s cloud_session_is_manager=%s",
+                    self._network.classicVisitorKey() is not None,
+                    self._network.classicManagerKey() is not None,
+                    getattr(self._network, "isManager", lambda: False)(),
+                )
+                _log_probe_summary("CLASSIC", classic_variant="ca52_legacy")
+                # Emit a warning if we never see Classic RX frames; this is a common failure mode.
+                self._classicNoRxTask = asyncio.create_task(self._classic_no_rx_watchdog(30.0))
                 return
 
         # Conformant devices can expose the Classic signed channel on the EVO-style UUID too.
@@ -414,30 +505,90 @@ class CasambiClient:
 
             self._protocolMode = ProtocolMode.CLASSIC
             self._dataCharUuid = CASA_AUTH_CHAR_UUID
+            self._classicTxCharUuid = CASA_AUTH_CHAR_UUID
             self._classicHeaderMode = "conformant"
+            self._classicHashSource = "ca52_0001"
             self._classicConnHash8 = bytes(first[:8])
             self._classicCmdDiv = int.from_bytes(os.urandom(1), "big") or 1
             self._classicTxSeq = 0
 
+            # Probe mapped Classic CA51 (0002) for diagnostics; some firmwares use it for time/config.
+            try:
+                v = await self._gattClient.read_gatt_char(CASA_CLASSIC_CONFORMANT_CA51_CHAR_UUID)
+                c0002_prefix = b2a(v[:10]) if v else None
+                if self._logger.isEnabledFor(logging.DEBUG):
+                    self._logger.debug(
+                        "[CASAMBI_GATT_PROBE] read classic-0002 ok len=%d prefix=%s",
+                        0 if v is None else len(v),
+                        c0002_prefix,
+                    )
+            except Exception as e:
+                c0002_err = type(e).__name__
+                if self._logger.isEnabledFor(logging.DEBUG):
+                    self._logger.debug(
+                        "[CASAMBI_GATT_PROBE] read classic-0002 fail err=%s",
+                        c0002_err,
+                    )
+
             notify_kwargs: dict[str, Any] = {}
             notify_params = inspect.signature(self._gattClient.start_notify).parameters
             if "bluez" in notify_params:
                 notify_kwargs["bluez"] = {"use_start_notify": True}
-            await self._gattClient.start_notify(
-                CASA_AUTH_CHAR_UUID,
-                self._queueCallback,
-                **notify_kwargs,
-            )
+            try:
+                await self._gattClient.start_notify(
+                    CASA_AUTH_CHAR_UUID,
+                    self._queueCallback,
+                    **notify_kwargs,
+                )
+            except Exception as e:
+                ca52_notify_err = type(e).__name__
+            else:
+                self._classicNotifyCharUuids.add(CASA_AUTH_CHAR_UUID.lower())
+
+            # Probe mapped Classic CA53 (0003) notify: some firmwares may emit state/config here.
+            try:
+                await self._gattClient.start_notify(
+                    CASA_CLASSIC_CONFORMANT_CA53_CHAR_UUID,
+                    self._queueCallback,
+                    **notify_kwargs,
+                )
+            except Exception as e:
+                c0003_notify_err = type(e).__name__
+            else:
+                self._classicNotifyCharUuids.add(CASA_CLASSIC_CONFORMANT_CA53_CHAR_UUID.lower())
+
             self._connectionState = ConnectionState.AUTHENTICATED
             self._logger.info("Protocol mode selected: CLASSIC")
             if self._logger.isEnabledFor(logging.DEBUG):
-                self._logger.debug("[CASAMBI_GATT_PROBE] start_notify auth ok (classic conformant)")
+                if ca52_notify_err is None:
+                    self._logger.debug("[CASAMBI_GATT_PROBE] start_notify auth ok (classic conformant)")
+                else:
+                    self._logger.debug(
+                        "[CASAMBI_GATT_PROBE] start_notify auth fail err=%s (classic conformant)",
+                        ca52_notify_err,
+                    )
                 self._logger.debug(
                     "[CASAMBI_CLASSIC_CONN_HASH] len=%d hash=%s",
                     len(self._classicConnHash8),
                     b2a(self._classicConnHash8),
                 )
-            _log_probe_summary("CLASSIC")
+            self._logger.warning(
+                "[CASAMBI_CLASSIC_SELECTED] address=%s variant=auth_uuid_conformant data_uuid=%s tx_uuid=%s notify_uuids=%s header_mode=%s conn_hash8_prefix=%s",
+                self.address,
+                self._dataCharUuid,
+                self._classicTxCharUuid,
+                sorted(self._classicNotifyCharUuids) if self._classicNotifyCharUuids else None,
+                self._classicHeaderMode,
+                b2a(self._classicConnHash8),
+            )
+            self._logger.warning(
+                "[CASAMBI_CLASSIC_KEYS] visitor=%s manager=%s cloud_session_is_manager=%s",
+                self._network.classicVisitorKey() is not None,
+                self._network.classicManagerKey() is not None,
+                getattr(self._network, "isManager", lambda: False)(),
+            )
+            _log_probe_summary("CLASSIC", classic_variant="auth_uuid_conformant")
+            self._classicNoRxTask = asyncio.create_task(self._classic_no_rx_watchdog(30.0))
             return
 
         _log_probe_summary("UNKNOWN")
@@ -445,12 +596,45 @@ class CasambiClient:
             "No supported Casambi characteristics found (Classic ca51/ca52 or EVO/Classic-conformant auth char)."
         )
 
+    async def _classic_no_rx_watchdog(self, after_s: float) -> None:
+        """Emit one high-signal log if Classic RX stays silent after connect.
+
+        This helps testers capture actionable logs when Classic control/updates don't work yet.
+        """
+        try:
+            await asyncio.sleep(after_s)
+            if self._protocolMode != ProtocolMode.CLASSIC:
+                return
+            if self._classicFirstRxTs is not None:
+                return
+
+            self._logger.warning(
+                "[CASAMBI_CLASSIC_NO_RX] after_s=%s notify_uuids=%s tx_uuid=%s header_mode=%s "
+                "conn_hash8_prefix=%s visitor=%s manager=%s cloud_session_is_manager=%s",
+                after_s,
+                sorted(self._classicNotifyCharUuids) if self._classicNotifyCharUuids else None,
+                self._classicTxCharUuid,
+                self._classicHeaderMode,
+                None if self._classicConnHash8 is None else b2a(self._classicConnHash8),
+                self._network.classicVisitorKey() is not None,
+                self._network.classicManagerKey() is not None,
+                getattr(self._network, "isManager", lambda: False)(),
+            )
+        except asyncio.CancelledError:
+            return
+        except Exception:
+            # Never fail the connection because of diagnostics.
+            self._logger.debug("Classic no-RX watchdog failed.", exc_info=True)
+
     def _on_disconnect(self, client: BleakClient) -> None:
         if self._connectionState != ConnectionState.NONE:
             self._logger.info(f"Received disconnect callback from {self.address}")
         if self._connectionState == ConnectionState.AUTHENTICATED:
             self._logger.debug("Executing disconnect callback.")
             self._disconnectedCallback()
+        if self._classicNoRxTask is not None:
+            self._classicNoRxTask.cancel()
+            self._classicNoRxTask = None
         self._connectionState = ConnectionState.NONE
 
     async def exchangeKey(self) -> None:
@@ -824,14 +1008,43 @@ class CasambiClient:
         self._checkState(ConnectionState.AUTHENTICATED)
         if self._protocolMode != ProtocolMode.CLASSIC:
             raise ProtocolError("Classic send called while not in Classic protocol mode.")
-        if not self._dataCharUuid:
-            raise ProtocolError("Classic data characteristic UUID not set.")
+        tx_uuid = self._classicTxCharUuid or self._dataCharUuid
+        if not tx_uuid:
+            raise ProtocolError("Classic TX characteristic UUID not set.")
         if self._classicConnHash8 is None:
             raise ClassicHandshakeError("Classic connection hash not available.")
 
         visitor_key = self._network.classicVisitorKey()
         manager_key = self._network.classicManagerKey()
 
+        # Parse the command record for logs (u1.C1753e export format).
+        cmd_ordinal: int | None = None
+        cmd_div: int | None = None
+        cmd_target: int | None = None
+        cmd_lifetime: int | None = None
+        cmd_payload_len: int | None = None
+        try:
+            if len(command_bytes) >= 2:
+                typ = command_bytes[1]
+                cmd_ordinal = typ & 0x3F
+                has_div = (typ & 0x40) != 0
+                has_target = (typ & 0x80) != 0
+                p = 2
+                if has_div and p < len(command_bytes):
+                    cmd_div = command_bytes[p]
+                    p += 1
+                if has_target and p < len(command_bytes):
+                    cmd_target = command_bytes[p]
+                    p += 1
+                if p < len(command_bytes):
+                    cmd_lifetime = command_bytes[p]
+                    p += 1
+                if p <= len(command_bytes):
+                    cmd_payload_len = len(command_bytes) - p
+        except Exception:
+            # If parsing fails, keep fields as None.
+            pass
+
         # Key selection mirrors Android's intent:
         # - Use manager key if our cloud session is manager and a managerKey exists.
         # - Else use visitor key if present.
@@ -895,28 +1108,55 @@ class CasambiClient:
         else:
             raise ProtocolError(f"Unknown Classic header mode: {header_mode}")
 
+        signed = key is not None
+        if not signed and self._logLimiter.allow("classic_tx_unsigned", burst=10, window_s=300.0):
+            self._logger.warning(
+                "[CASAMBI_CLASSIC_TX_UNSIGNED] reason=keys_missing visitor=%s manager=%s",
+                visitor_key is not None,
+                manager_key is not None,
+            )
+
         # WARNING-level TX logs are intentional: they are needed for Classic reverse engineering.
         # Keep payload logging minimal (prefix only).
         if self._logLimiter.allow("classic_tx", burst=50, window_s=60.0):
+            auth_str = f"0x{auth_level:02x}" if header_mode == "conformant" else None
             self._logger.warning(
-                "[CASAMBI_CLASSIC_TX] header=%s key=%s auth=0x%02x sig_len=%d seq=%s cmd_len=%d total_len=%d prefix=%s",
+                "[CASAMBI_CLASSIC_TX] header=%s key=%s signed=%s tx_uuid=%s auth=%s sig_len=%d seq=%s "
+                "cmd_len=%d cmd_ord=%s target=%s div=%s lifetime=%s payload_len=%s "
+                "total_len=%d prefix=%s",
                 header_mode,
                 key_name,
-                auth_level,
+                signed,
+                tx_uuid,
+                auth_str,
                 sig_len,
                 None if seq is None else f"0x{seq:04x}",
                 len(command_bytes),
+                cmd_ordinal,
+                cmd_target,
+                cmd_div,
+                cmd_lifetime,
+                cmd_payload_len,
                 len(pkt),
                 b2a(bytes(pkt[: min(len(pkt), 24)])),
             )
 
         # Classic packets can exceed 20 bytes when using a 16-byte manager signature.
         # Bleak needs a write-with-response for long writes on most backends.
-        await self._gattClient.write_gatt_char(self._dataCharUuid, bytes(pkt), response=True)
+        await self._gattClient.write_gatt_char(tx_uuid, bytes(pkt), response=True)
 
     def _establishedNofityCallback(
         self, handle: BleakGATTCharacteristic, data: bytes
     ) -> None:
+        # Route notifications based on characteristic UUID when available.
+        # This helps with mixed/legacy setups where multiple Classic channels might be active.
+        try:
+            handle_uuid = str(getattr(handle, "uuid", "")).lower()
+        except Exception:
+            handle_uuid = ""
+        if handle_uuid and handle_uuid in self._classicNotifyCharUuids:
+            self._classicEstablishedNotifyCallback(handle, data)
+            return
         if self._protocolMode == ProtocolMode.CLASSIC:
             self._classicEstablishedNotifyCallback(handle, data)
             return
@@ -991,6 +1231,8 @@ class CasambiClient:
         """
         self._inPacketCount += 1
         self._classicRxFrames += 1
+        if self._classicFirstRxTs is None:
+            self._classicFirstRxTs = time.monotonic()
 
         raw = bytes(data)
         if self._logger.isEnabledFor(logging.DEBUG):
@@ -1213,17 +1455,47 @@ class CasambiClient:
         ):
             self._classicRxLastStatsTs = now
             self._logger.warning(
-                "[CASAMBI_CLASSIC_RX_STATS] frames=%d verified=%d unverifiable=%d parse_fail=%d header=%s",
+                "[CASAMBI_CLASSIC_RX_STATS] frames=%d verified=%d unverifiable=%d parse_fail=%d header=%s "
+                "type6=%d type7=%d type9=%d cmdstream=%d unknown=%d",
                 self._classicRxFrames,
                 self._classicRxVerified,
                 self._classicRxUnverifiable,
                 self._classicRxParseFail,
                 self._classicHeaderMode,
+                self._classicRxType6,
+                self._classicRxType7,
+                self._classicRxType9,
+                self._classicRxCmdStream,
+                self._classicRxUnknown,
             )
 
         # If the payload starts with a known EVO packet type, reuse existing parsers.
         packet_type = payload[0]
         if packet_type in (IncommingPacketType.UnitState, IncommingPacketType.SwitchEvent, IncommingPacketType.NetworkConfig):
+            kind = f"type{int(packet_type)}"
+            if packet_type == IncommingPacketType.UnitState:
+                self._classicRxType6 += 1
+                kind = "type6_unitstate"
+            elif packet_type == IncommingPacketType.SwitchEvent:
+                self._classicRxType7 += 1
+                kind = "type7_switch"
+            else:
+                self._classicRxType9 += 1
+                kind = "type9_netconf"
+
+            # Emit a few per-kind examples for reverse engineering.
+            if self._classicRxKindSamples.get(kind, 0) < 3:
+                self._classicRxKindSamples[kind] = self._classicRxKindSamples.get(kind, 0) + 1
+                self._logger.warning(
+                    "[CASAMBI_CLASSIC_RX_KIND] kind=%s header=%s verified=%s sig_len=%d seq=%s payload_prefix=%s",
+                    kind,
+                    best["mode"],
+                    verified,
+                    best["sig_len"],
+                    None if best["seq"] is None else f"0x{best['seq']:04x}",
+                    b2a(payload[: min(len(payload), 32)]),
+                )
+
             if self._logger.isEnabledFor(logging.DEBUG):
                 self._logger.debug(
                     "[CASAMBI_CLASSIC_RX_PAYLOAD] type=%d len=%d hex=%s",
@@ -1244,6 +1516,7 @@ class CasambiClient:
         # Otherwise, attempt to parse a stream of Classic "command" records:
         # record[0] = (len + 239) mod 256, so len = (b0 - 239) & 0xFF.
         pos = 0
+        parsed_any = False
         while pos + 2 <= len(payload):
             enc_len = payload[pos]
             rec_len = (enc_len - 239) & 0xFF
@@ -1251,6 +1524,7 @@ class CasambiClient:
                 break
             rec = payload[pos : pos + rec_len]
             pos += rec_len
+            parsed_any = True
 
             typ = rec[1]
             ordinal = typ & 0x3F
@@ -1278,6 +1552,25 @@ class CasambiClient:
                     b2a(rec_payload),
                 )
 
+        if parsed_any:
+            self._classicRxCmdStream += 1
+            kind = "cmdstream"
+        else:
+            self._classicRxUnknown += 1
+            kind = "unknown"
+
+        if self._classicRxKindSamples.get(kind, 0) < 3:
+            self._classicRxKindSamples[kind] = self._classicRxKindSamples.get(kind, 0) + 1
+            self._logger.warning(
+                "[CASAMBI_CLASSIC_RX_KIND] kind=%s header=%s verified=%s sig_len=%d seq=%s payload_prefix=%s",
+                kind,
+                best["mode"],
+                verified,
+                best["sig_len"],
+                None if best["seq"] is None else f"0x{best['seq']:04x}",
+                b2a(payload[: min(len(payload), 32)]),
+            )
+
         # Any trailing bytes that don't form a full record are logged for analysis.
         if self._logger.isEnabledFor(logging.DEBUG) and pos < len(payload):
             self._logger.debug(
@@ -1547,6 +1840,10 @@ class CasambiClient:
     async def disconnect(self) -> None:
         self._logger.info("Disconnecting...")
 
+        if self._classicNoRxTask is not None:
+            self._classicNoRxTask.cancel()
+            self._classicNoRxTask = None
+
         if self._callbackTask is not None:
             # Cancel and await the background callback task to avoid
             # 'Task was destroyed but it is pending' warnings.

CasambiBt/_constants.py

@@ -12,6 +12,15 @@ CASA_AUTH_CHAR_UUID: Final = "c9ffde48-ca5a-0001-ab83-8f519b482f77"
 CASA_UUID_CLASSIC: Final = "0000ca5a-0000-1000-8000-00805f9b34fb"
 CASA_CLASSIC_HASH_CHAR_UUID: Final = "0000ca51-0000-1000-8000-00805f9b34fb"
 CASA_CLASSIC_DATA_CHAR_UUID: Final = "0000ca52-0000-1000-8000-00805f9b34fb"
+CASA_CLASSIC_CA53_CHAR_UUID: Final = "0000ca53-0000-1000-8000-00805f9b34fb"
+
+# Classic "conformant" firmware maps the legacy CA5A/CA5x UUIDs onto the FE4D service.
+# Ground truth: casambi-android `t1.C1713d.e(UUID)` mapping:
+# - CA52 -> 0001 (same as CASA_AUTH_CHAR_UUID)
+# - CA51 -> 0002
+# - CA53 -> 0003
+CASA_CLASSIC_CONFORMANT_CA51_CHAR_UUID: Final = "c9ffde48-ca5a-0002-ab83-8f519b482f77"
+CASA_CLASSIC_CONFORMANT_CA53_CHAR_UUID: Final = "c9ffde48-ca5a-0003-ab83-8f519b482f77"
 
 
 @unique

CasambiBt/_network.py

@@ -291,7 +291,7 @@ class Network:
                         "[CASAMBI_CLOUD_UPDATE_RETRY] status=400 retry_with_token_clientInfo=true body_prefix=%r",
                         (res.text or "")[:200],
                     )
-                    payload2 = dict(payload)
+                    payload2: dict[str, Any] = dict(payload)
                     payload2["token"] = self._token
                     payload2["clientInfo"] = self._clientInfo
                     res = await self._httpClient.put(
@@ -301,26 +301,33 @@ class Network:
                     )
 
                 if res.status_code != httpx.codes.OK:
-                    self._logger.error(
-                        "Update failed: %s body_prefix=%r",
+                    body_prefix = (res.text or "")[:500]
+                    # If we have cached network data, do not fail setup; continue offline.
+                    # This is important for HA stability and for "cloud down / API changed" scenarios.
+                    have_cache = bool(self._networkRevision and self._networkRevision > 0 and self._rawNetworkData)
+                    self._logger.warning(
+                        "[CASAMBI_CLOUD_UPDATE_FAILED] status=%s cached_revision=%s continuing_offline=%s body_prefix=%r",
                         res.status_code,
-                        (res.text or "")[:500],
-                    )
-                    raise NetworkUpdateError("Could not update network!")
-
-                self._logger.debug(f"Network: {res.text}")
-
-                updateResult = res.json()
-                if updateResult["status"] != "UPTODATE":
-                    self._networkRevision = updateResult["network"]["revision"]
-                    self._rawNetworkData = updateResult
-                    async with self._cache as cachePath:
-                        cachedNetworkPah = cachePath / f"{self._id}.json"
-                        await cachedNetworkPah.write_bytes(res.content)
-                    network = updateResult
-                    self._logger.info(
-                        f"Fetched updated network with revision {self._networkRevision}"
+                        self._networkRevision,
+                        have_cache,
+                        body_prefix,
                     )
+                    if not have_cache:
+                        raise NetworkUpdateError("Could not update network!")
+                else:
+                    self._logger.debug(f"Network: {res.text}")
+
+                    updateResult = res.json()
+                    if updateResult["status"] != "UPTODATE":
+                        self._networkRevision = updateResult["network"]["revision"]
+                        self._rawNetworkData = updateResult
+                        async with self._cache as cachePath:
+                            cachedNetworkPah = cachePath / f"{self._id}.json"
+                            await cachedNetworkPah.write_bytes(res.content)
+                        network = updateResult
+                        self._logger.info(
+                            f"Fetched updated network with revision {self._networkRevision}"
+                        )
             except RequestError as err:
                 if self._networkRevision == 0:
                     raise NetworkUpdateError from err

CasambiBt/_version.py

@@ -7,4 +7,4 @@ Avoid using importlib.metadata in hot paths by providing a static version string
 __all__ = ["__version__"]
 
 # NOTE: Must match `casambi-bt/setup.cfg` [metadata] version.
-__version__ = "0.3.12.dev7"
+__version__ = "0.3.12.dev9"

{casambi_bt_revamped-0.3.12.dev7.dist-info → casambi_bt_revamped-0.3.12.dev9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: casambi-bt-revamped
-Version: 0.3.12.dev7
+Version: 0.3.12.dev9
 Summary: Forked Casambi Bluetooth client library with switch event support, use original if no special need. https://github.com/lkempf/casambi-bt
 Home-page: https://github.com/rankjie/casambi-bt
 Author: rankjie

{casambi_bt_revamped-0.3.12.dev7.dist-info → casambi_bt_revamped-0.3.12.dev9.dist-info}/RECORD

@@ -2,21 +2,21 @@ CasambiBt/__init__.py,sha256=iJdTF4oeXfj5d5gfGxQkacqUjtnQo0IW-zFPJvFjWWk,336
 CasambiBt/_cache.py,sha256=3bQil8vhSy4f4sf9JusMfEdQC7d3cJuva9qHhyKro-0,3808
 CasambiBt/_casambi.py,sha256=TN4ecgjm95nSJ4h9TsKayNn577Y82fdsGK4IGUZF23Q,40666
 CasambiBt/_classic_crypto.py,sha256=6DcCOdjLQo7k2cOOutNdUKupykOG_E2TDDwg6fH-ODM,998
-CasambiBt/_client.py,sha256=PNYBwMdehh-YvSdxf8I-74bpn008VjNvwZyru5H_LuM,63618
-CasambiBt/_constants.py,sha256=sbElg5W8eeQvvL1rHn_E0jhP1wOrrabc7dFLLnlDMsU,810
+CasambiBt/_client.py,sha256=yn6DckDCKap1YJ0xyDhk5wlvE6wvPIUGPe9M1veRDVs,77317
+CasambiBt/_constants.py,sha256=86heoDdb5iPaRrPmK2DIIl-4uSxbFFcnCo9zlCvTLww,1290
 CasambiBt/_discover.py,sha256=jLc6H69JddrCURgtANZEjws6_UbSzXJtvJkbKTaIUHY,1849
 CasambiBt/_encryption.py,sha256=CLcoOOrggQqhJbnr_emBnEnkizpWDvb_0yFnitq4_FM,3831
 CasambiBt/_invocation.py,sha256=fkG4R0Gv5_amFfD_P6DKuIEe3oKWZW0v8RSU8zDjPdI,2985
 CasambiBt/_keystore.py,sha256=Jdiq0zMPDmhfpheSojKY6sTUpmVrvX_qOyO7yCYd3kw,2788
-CasambiBt/_network.py,sha256=nB_pRB9dZL6P7THeuOce7ctWd0wXyCWF13h67SauZVQ,20714
+CasambiBt/_network.py,sha256=ai1o3EybsAhjyPohSOxeE0cWoFvEqdcc3PE3uFDaTfE,21346
 CasambiBt/_operation.py,sha256=Q5UccsrtNp_B_wWqwH_3eLFW_yF6A55FMmfUKDk2WrI,1059
 CasambiBt/_switch_events.py,sha256=S8OD0dBcw5T4J2C7qfmOQMnTJ7omIXRUYv4PqDOB87E,13137
 CasambiBt/_unit.py,sha256=nxbg_8UCCVB9WI8dUS21g2JrGyPKcefqKMSusMOhLOo,18721
-CasambiBt/_version.py,sha256=eONTRjFMNE1oRTOTcoScFZ4eVqZj6WKN07jnjauq8Ao,337
+CasambiBt/_version.py,sha256=VtWwYBijhWhHtBHLmr-n1eqgiJjNkNATaUweLPXTAo4,337
 CasambiBt/errors.py,sha256=1L_Q8og_N_BRYEKizghAQXr6tihlHykFgtcCHUDcBas,1961
 CasambiBt/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-casambi_bt_revamped-0.3.12.dev7.dist-info/licenses/LICENSE,sha256=TAIIitFxpxEDi6Iju7foW4TDQmWvC-IhLVLhl67jKmQ,11341
-casambi_bt_revamped-0.3.12.dev7.dist-info/METADATA,sha256=q4QM-1wpUKiobHPUoZXXqfwQlI_hf5iA_aYS4fBhPLE,5877
-casambi_bt_revamped-0.3.12.dev7.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-casambi_bt_revamped-0.3.12.dev7.dist-info/top_level.txt,sha256=uNbqLjtecFosoFzpGAC89-5icikWODKI8rOjbi8v_sA,10
-casambi_bt_revamped-0.3.12.dev7.dist-info/RECORD,,
+casambi_bt_revamped-0.3.12.dev9.dist-info/licenses/LICENSE,sha256=TAIIitFxpxEDi6Iju7foW4TDQmWvC-IhLVLhl67jKmQ,11341
+casambi_bt_revamped-0.3.12.dev9.dist-info/METADATA,sha256=R31XEvi4eCtF_CYH_DfCnN9lvMmhDS8zCYJlqFAuu2U,5877
+casambi_bt_revamped-0.3.12.dev9.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+casambi_bt_revamped-0.3.12.dev9.dist-info/top_level.txt,sha256=uNbqLjtecFosoFzpGAC89-5icikWODKI8rOjbi8v_sA,10
+casambi_bt_revamped-0.3.12.dev9.dist-info/RECORD,,