casambi-bt-revamped 0.3.7.dev13__tar.gz → 0.3.12.dev3__tar.gz

casambi_bt_revamped-0.3.12.dev3/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: casambi-bt-revamped
+Version: 0.3.12.dev3
+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
+Author-email: rankjie@gmail.com
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: bleak!=2.0.0,>=0.22
+Requires-Dist: cryptography>=40.0.0
+Requires-Dist: httpx>=0.25
+Requires-Dist: bleak_retry_connector>=3.6.0
+Requires-Dist: anyio>=4.10.0
+Dynamic: license-file
+
+![PyPI](https://img.shields.io/pypi/v/casambi-bt-revamped)
+[![Discord](https://img.shields.io/discord/1186445089317326888)](https://discord.gg/jgZVugfx)
+
+# Casambi Bluetooth Revamped - Python library for Casambi networks
+
+This is a customized fork of the original [casambi-bt](https://github.com/lkempf/casambi-bt) library with additional features and should only be used for special needs:
+
+- **Switch event support** - Receive button press/release/hold events from Casambi switches (wired + wireless)
+- **Improved relay status handling** - Better support for relay units
+- **Classic protocol (experimental)** - Basic unit control for Classic (legacy) firmware networks
+- **Bug fixes and improvements** - Various fixes based on real-world usage
+
+This library provides a bluetooth interface to Casambi-based lights. It is not associated with Casambi.
+
+For Home Assistant integration using this library, see [casambi-bt-hass](https://github.com/rankjie/casambi-bt-hass).
+
+## Getting started
+
+This library is available on PyPi:
+
+```
+pip install casambi-bt-revamped
+```
+
+Have a look at `demo.py` for a small example.
+
+### Switch Event Support
+
+This library supports receiving physical switch events as a decoded stream of INVOCATION frames (ground truth from the official Android app).
+
+Event types you can expect:
+- `button_press`
+- `button_release`
+- `button_hold`
+- `button_release_after_hold`
+- `input_event` (raw NotifyInput frame that may accompany presses/holds; useful for diagnostics and some wired devices)
+
+```python
+from CasambiBt import Casambi
+
+def handle_switch_event(event_data):
+    print(
+        "Switch event:",
+        {
+            "unit_id": event_data.get("unit_id"),
+            "button": event_data.get("button"),
+            "event": event_data.get("event"),
+            # INVOCATION metadata (useful for debugging/correlation)
+            "event_id": event_data.get("event_id"),
+            "opcode": event_data.get("opcode"),
+            "target_type": event_data.get("target_type"),
+            "origin": event_data.get("origin"),
+            "age": event_data.get("age"),
+            # NotifyInput fields (target_type=0x12)
+            "input_code": event_data.get("input_code"),
+            "input_channel": event_data.get("input_channel"),
+            "input_value16": event_data.get("input_value16"),
+            "input_mapped_event": event_data.get("input_mapped_event"),
+        },
+    )
+
+casa = Casambi()
+# ... connect to network ...
+
+# Register switch event handler
+casa.registerSwitchEventHandler(handle_switch_event)
+
+# Events will be received when buttons are pressed/released
+```
+
+Notes:
+- Wireless (battery) switches typically send a "button stream" (target_type `0x06`) for press/release, and a NotifyInput stream (target_type `0x12`) for hold/release-after-hold.
+- Wired switches often only send NotifyInput (target_type `0x12`), so `input_code` is mapped into `button_press/button_release/...` when appropriate.
+- The library suppresses same-state retransmits at the protocol layer (edge detection), so Home Assistant-style time-window deduplication should generally not be necessary.
+
+For the parsing details and field layout, see `doc/PROTOCOL_PARSING.md`.
+
+### Classic (Legacy Firmware) Support (Experimental)
+
+This library can also connect to **Classic** Casambi networks and send **unit control** commands.
+
+How it works (ground truth: the bundled Android app sources):
+- Classic devices expose a CMAC-signed data channel (`ca51`/`ca52`) or a "Classic conformant" signed channel on the EVO UUID.
+- The cloud network JSON exposes `visitorKey` / `managerKey` (hex strings) instead of an EVO `keyStore`.
+- Commands are signed with AES-CMAC and sent as Classic "command records" (see `doc/PROTOCOL_PARSING.md`).
+
+Environment flags:
+- `CASAMBI_BT_DISABLE_CLASSIC=1` to refuse Classic connections (fail fast)
+- `CASAMBI_BT_CLASSIC_USE_MANAGER=1` to sign with the 16-byte manager signature (default is visitor/4-byte prefix)
+- `CASAMBI_BT_LOG_RAW_NOTIFIES=1` to enable very verbose per-notify hexdumps (mainly for Classic debugging)
+
+### MacOS
+
+MacOS [does not expose the Bluetooth MAC address via their official API](https://github.com/hbldh/bleak/issues/140),
+if you're running this library on MacOS, it will use an undocumented IOBluetooth API to get the MAC Address.
+Without the real MAC address the integration with Casambi will not work.
+If you're running into problems fetching the MAC address on MacOS, try it on a Raspberry Pi.
+
+### Casambi network setup
+
+If you have problems connecting to the network please check that your network is configured appropriately before creating an issue. The network I test this with uses the **Evoultion firmware** and is configured as follows (screenshots are for the iOS app but the Android app should look very similar):
+
+![Gateway settings](/doc/img/gateway.png)
+![Network settings](/doc/img/network.png)
+![Performance settings](/doc/img/perf.png)
+
+## Development / Offline Testing
+
+This repo includes log-driven unit tests for switch parsing:
+
+```bash
+cd casambi-bt
+python -m unittest -v
+```

casambi_bt_revamped-0.3.12.dev3/README.md

@@ -0,0 +1,114 @@
+![PyPI](https://img.shields.io/pypi/v/casambi-bt-revamped)
+[![Discord](https://img.shields.io/discord/1186445089317326888)](https://discord.gg/jgZVugfx)
+
+# Casambi Bluetooth Revamped - Python library for Casambi networks
+
+This is a customized fork of the original [casambi-bt](https://github.com/lkempf/casambi-bt) library with additional features and should only be used for special needs:
+
+- **Switch event support** - Receive button press/release/hold events from Casambi switches (wired + wireless)
+- **Improved relay status handling** - Better support for relay units
+- **Classic protocol (experimental)** - Basic unit control for Classic (legacy) firmware networks
+- **Bug fixes and improvements** - Various fixes based on real-world usage
+
+This library provides a bluetooth interface to Casambi-based lights. It is not associated with Casambi.
+
+For Home Assistant integration using this library, see [casambi-bt-hass](https://github.com/rankjie/casambi-bt-hass).
+
+## Getting started
+
+This library is available on PyPi:
+
+```
+pip install casambi-bt-revamped
+```
+
+Have a look at `demo.py` for a small example.
+
+### Switch Event Support
+
+This library supports receiving physical switch events as a decoded stream of INVOCATION frames (ground truth from the official Android app).
+
+Event types you can expect:
+- `button_press`
+- `button_release`
+- `button_hold`
+- `button_release_after_hold`
+- `input_event` (raw NotifyInput frame that may accompany presses/holds; useful for diagnostics and some wired devices)
+
+```python
+from CasambiBt import Casambi
+
+def handle_switch_event(event_data):
+    print(
+        "Switch event:",
+        {
+            "unit_id": event_data.get("unit_id"),
+            "button": event_data.get("button"),
+            "event": event_data.get("event"),
+            # INVOCATION metadata (useful for debugging/correlation)
+            "event_id": event_data.get("event_id"),
+            "opcode": event_data.get("opcode"),
+            "target_type": event_data.get("target_type"),
+            "origin": event_data.get("origin"),
+            "age": event_data.get("age"),
+            # NotifyInput fields (target_type=0x12)
+            "input_code": event_data.get("input_code"),
+            "input_channel": event_data.get("input_channel"),
+            "input_value16": event_data.get("input_value16"),
+            "input_mapped_event": event_data.get("input_mapped_event"),
+        },
+    )
+
+casa = Casambi()
+# ... connect to network ...
+
+# Register switch event handler
+casa.registerSwitchEventHandler(handle_switch_event)
+
+# Events will be received when buttons are pressed/released
+```
+
+Notes:
+- Wireless (battery) switches typically send a "button stream" (target_type `0x06`) for press/release, and a NotifyInput stream (target_type `0x12`) for hold/release-after-hold.
+- Wired switches often only send NotifyInput (target_type `0x12`), so `input_code` is mapped into `button_press/button_release/...` when appropriate.
+- The library suppresses same-state retransmits at the protocol layer (edge detection), so Home Assistant-style time-window deduplication should generally not be necessary.
+
+For the parsing details and field layout, see `doc/PROTOCOL_PARSING.md`.
+
+### Classic (Legacy Firmware) Support (Experimental)
+
+This library can also connect to **Classic** Casambi networks and send **unit control** commands.
+
+How it works (ground truth: the bundled Android app sources):
+- Classic devices expose a CMAC-signed data channel (`ca51`/`ca52`) or a "Classic conformant" signed channel on the EVO UUID.
+- The cloud network JSON exposes `visitorKey` / `managerKey` (hex strings) instead of an EVO `keyStore`.
+- Commands are signed with AES-CMAC and sent as Classic "command records" (see `doc/PROTOCOL_PARSING.md`).
+
+Environment flags:
+- `CASAMBI_BT_DISABLE_CLASSIC=1` to refuse Classic connections (fail fast)
+- `CASAMBI_BT_CLASSIC_USE_MANAGER=1` to sign with the 16-byte manager signature (default is visitor/4-byte prefix)
+- `CASAMBI_BT_LOG_RAW_NOTIFIES=1` to enable very verbose per-notify hexdumps (mainly for Classic debugging)
+
+### MacOS
+
+MacOS [does not expose the Bluetooth MAC address via their official API](https://github.com/hbldh/bleak/issues/140),
+if you're running this library on MacOS, it will use an undocumented IOBluetooth API to get the MAC Address.
+Without the real MAC address the integration with Casambi will not work.
+If you're running into problems fetching the MAC address on MacOS, try it on a Raspberry Pi.
+
+### Casambi network setup
+
+If you have problems connecting to the network please check that your network is configured appropriately before creating an issue. The network I test this with uses the **Evoultion firmware** and is configured as follows (screenshots are for the iOS app but the Android app should look very similar):
+
+![Gateway settings](/doc/img/gateway.png)
+![Network settings](/doc/img/network.png)
+![Performance settings](/doc/img/perf.png)
+
+## Development / Offline Testing
+
+This repo includes log-driven unit tests for switch parsing:
+
+```bash
+cd casambi-bt
+python -m unittest -v
+```

{casambi_bt_revamped-0.3.7.dev13 → casambi_bt_revamped-0.3.12.dev3}/setup.cfg

@@ -1,9 +1,9 @@
 [metadata]
 name = casambi-bt-revamped
-version = 0.3.7.dev13
+version = 0.3.12.dev3
 author = rankjie
 author_email = rankjie@gmail.com
-description = Enhanced Casambi Bluetooth client library with switch event support
+description = Forked Casambi Bluetooth client library with switch event support, use original if no special need. https://github.com/lkempf/casambi-bt
 long_description = file: README.md
 long_description_content_type = text/markdown
 url = https://github.com/rankjie/casambi-bt
@@ -19,11 +19,11 @@ package_dir =
 packages = find:
 python_requires = >=3.11
 install_requires = 
-	bleak>=0.22
+	bleak>=0.22,!=2.0.0
 	cryptography>=40.0.0
 	httpx>=0.25
 	bleak_retry_connector >= 3.6.0
-	aiopath==0.7.*
+	anyio>=4.10.0
 
 [options.packages.find]
 where = src

{casambi_bt_revamped-0.3.7.dev13 → casambi_bt_revamped-0.3.12.dev3}/src/CasambiBt/_cache.py

@@ -6,28 +6,28 @@ import shutil
 from types import TracebackType
 from typing import Final
 
-from aiopath import AsyncPath  # type: ignore
+from anyio import Path
 
 _LOGGER = logging.getLogger(__name__)
 
-CACHE_PATH_DEFAULT: Final = AsyncPath(os.getcwd()) / "casambi-bt-store"
+CACHE_PATH_DEFAULT: Final = Path(os.getcwd()) / "casambi-bt-store"
 CACHE_VERSION: Final = 2
 
-# We need a global lock since there could be multiple Caambi instances
+# We need a global lock since there could be multiple Casambi instances
 # with their own cache instances pointing to the same folder.
 _cacheLock = asyncio.Lock()
 
 
-def _blocking_delete(path: AsyncPath) -> None:
+def _blocking_delete(path: Path) -> None:
     shutil.rmtree(pathlib.Path(path))
 
 
 class Cache:
-    def __init__(self, cachePath: AsyncPath | pathlib.Path | None) -> None:
+    def __init__(self, cachePath: Path | pathlib.Path | None) -> None:
         if cachePath is None:
             self._cachePath = CACHE_PATH_DEFAULT
-        elif not isinstance(cachePath, AsyncPath):
-            self._cachePath = AsyncPath(cachePath)
+        elif not isinstance(cachePath, Path):
+            self._cachePath = Path(cachePath)
         else:
             self._cachePath = cachePath
 
@@ -69,7 +69,7 @@ class Cache:
             await self._cachePath.mkdir(mode=0o700)
             await self._cacheVersionFile.write_text(str(CACHE_VERSION))
 
-    async def __aenter__(self) -> AsyncPath:
+    async def __aenter__(self) -> Path:
         await _cacheLock.acquire()
 
         if self._uuid is None:
@@ -78,7 +78,7 @@ class Cache:
         try:
             await self._ensureCacheValid()
 
-            cacheDir = AsyncPath(self._cachePath / self._uuid)
+            cacheDir = Path(self._cachePath / self._uuid)
             if not await cacheDir.exists():
                 _LOGGER.debug("Creating cache entry for id %s", self._uuid)
                 await cacheDir.mkdir()

{casambi_bt_revamped-0.3.7.dev13 → casambi_bt_revamped-0.3.12.dev3}/src/CasambiBt/_casambi.py

@@ -10,7 +10,7 @@ from bleak.backends.device import BLEDevice
 from httpx import AsyncClient, RequestError
 
 from ._cache import Cache
-from ._client import CasambiClient, ConnectionState, IncommingPacketType
+from ._client import CasambiClient, ConnectionState, IncommingPacketType, ProtocolMode
 from ._network import Network
 from ._operation import OpCode, OperationsContext
 from ._unit import Group, Scene, Unit, UnitControlType, UnitState
@@ -169,8 +169,10 @@ class Casambi:
         self._casaClient = cast(CasambiClient, self._casaClient)
         await self._casaClient.connect()
         try:
-            await self._casaClient.exchangeKey()
-            await self._casaClient.authenticate()
+            # EVO requires key exchange + authenticate; Classic is ready after `connect()`.
+            if self._casaClient.protocolMode == ProtocolMode.EVO:
+                await self._casaClient.exchangeKey()
+                await self._casaClient.authenticate()
         except ProtocolError as e:
             await self._casaClient.disconnect()
             raise e
@@ -201,6 +203,23 @@ class Casambi:
             raise ValueError()
 
         payload = level.to_bytes(1, byteorder="big", signed=False)
+
+        # Classic protocol uses signed command frames (u1.C1753e / u1.EnumC1754f).
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # EnumC1754f ordinals (ground truth: casambi-android u1.EnumC1754f):
+            # - AllUnitsLevel=4, UnitLevel=7, GroupLevel=26
+            if isinstance(target, Unit):
+                cmd = self._casaClient.buildClassicCommand(7, payload, target_id=target.deviceId)
+            elif isinstance(target, Group):
+                cmd = self._casaClient.buildClassicCommand(26, payload, target_id=target.groudId)
+            elif target is None:
+                cmd = self._casaClient.buildClassicCommand(4, payload)
+            else:
+                raise TypeError(f"Unkown target type {type(target)}")
+
+            await self._casaClient.send(cmd)
+            return
+
         await self._send(target, payload, OpCode.SetLevel)
 
     async def setVertical(self, target: Unit | Group | None, vertical: int) -> None:
@@ -219,6 +238,21 @@ class Casambi:
             raise ValueError()
 
         payload = vertical.to_bytes(1, byteorder="big", signed=False)
+
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # EnumC1754f ordinals: AllUnitsVertical=22, UnitVertical=24, GroupVertical=29
+            if isinstance(target, Unit):
+                cmd = self._casaClient.buildClassicCommand(24, payload, target_id=target.deviceId)
+            elif isinstance(target, Group):
+                cmd = self._casaClient.buildClassicCommand(29, payload, target_id=target.groudId)
+            elif target is None:
+                cmd = self._casaClient.buildClassicCommand(22, payload)
+            else:
+                raise TypeError(f"Unkown target type {type(target)}")
+
+            await self._casaClient.send(cmd)
+            return
+
         await self._send(target, payload, OpCode.SetVertical)
 
     async def setSlider(self, target: Unit | Group | None, value: int) -> None:
@@ -255,6 +289,21 @@ class Casambi:
             raise ValueError()
 
         payload = level.to_bytes(1, byteorder="big", signed=False)
+
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # EnumC1754f ordinals: AllUnitsWhite=23, UnitWhite=25, GroupWhite=30
+            if isinstance(target, Unit):
+                cmd = self._casaClient.buildClassicCommand(25, payload, target_id=target.deviceId)
+            elif isinstance(target, Group):
+                cmd = self._casaClient.buildClassicCommand(30, payload, target_id=target.groudId)
+            elif target is None:
+                cmd = self._casaClient.buildClassicCommand(23, payload)
+            else:
+                raise TypeError(f"Unkown target type {type(target)}")
+
+            await self._casaClient.send(cmd)
+            return
+
         await self._send(target, payload, OpCode.SetWhite)
 
     async def setColor(
@@ -272,6 +321,27 @@ class Casambi:
         :raises ValueError: The supplied rgbColor isn't in range
         """
 
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # Classic uses RGB payload (3 bytes) directly.
+            r, g, b = rgbColor
+            if not (0 <= r <= 255 and 0 <= g <= 255 and 0 <= b <= 255):
+                raise ValueError("rgbColor out of range.")
+            payload = bytes([r & 0xFF, g & 0xFF, b & 0xFF])
+
+            # EnumC1754f ordinals: AllUnitsColor=6, UnitColor=9, GroupColor=28
+            if isinstance(target, Unit):
+                cmd = self._casaClient.buildClassicCommand(9, payload, target_id=target.deviceId)
+            elif isinstance(target, Group):
+                cmd = self._casaClient.buildClassicCommand(28, payload, target_id=target.groudId)
+            elif target is None:
+                cmd = self._casaClient.buildClassicCommand(6, payload)
+            else:
+                raise TypeError(f"Unkown target type {type(target)}")
+
+            await self._casaClient.send(cmd)
+            return
+
+        # Evolution uses HS payload (hue 10-bit + sat 8-bit) for SetColor.
         state = UnitState()
         state.rgb = rgbColor
         hs: tuple[float, float] = state.hs  # type: ignore[assignment]
@@ -300,6 +370,21 @@ class Casambi:
 
         temperature = int(temperature / 50)
         payload = temperature.to_bytes(1, byteorder="big", signed=False)
+
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # EnumC1754f ordinals: AllUnitsTemperature=5, UnitTemperature=8, GroupTemperature=27
+            if isinstance(target, Unit):
+                cmd = self._casaClient.buildClassicCommand(8, payload, target_id=target.deviceId)
+            elif isinstance(target, Group):
+                cmd = self._casaClient.buildClassicCommand(27, payload, target_id=target.groudId)
+            elif target is None:
+                cmd = self._casaClient.buildClassicCommand(5, payload)
+            else:
+                raise TypeError(f"Unkown target type {type(target)}")
+
+            await self._casaClient.send(cmd)
+            return
+
         await self._send(target, payload, OpCode.SetTemperature)
 
     async def setColorXY(
@@ -317,6 +402,10 @@ class Casambi:
         :raises ValueError: The supplied XYColor isn't in range or not supported by the supplied unit.
         """
 
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # Classic command set (u1.EnumC1754f) only exposes RGB color control.
+            raise ValueError("XY color control is not supported on Classic networks.")
+
         if xyColor[0] < 0.0 or xyColor[0] > 1.0 or xyColor[1] < 0.0 or xyColor[1] > 1.0:
             raise ValueError("Color out of range.")
 
@@ -345,6 +434,22 @@ class Casambi:
         :return: Nothing is returned by this function. To get the new state register a change handler.
         """
 
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # Classic uses a longer payload for "restore last level" (ground truth: casambi-android u1.C1751c.o()).
+            payload = bytes([0xFF, 0x01, 0x00, 0x00, 0x01])
+            # EnumC1754f ordinals: AllUnitsLevel=4, UnitLevel=7, GroupLevel=26
+            if isinstance(target, Unit):
+                cmd = self._casaClient.buildClassicCommand(7, payload, target_id=target.deviceId)
+            elif isinstance(target, Group):
+                cmd = self._casaClient.buildClassicCommand(26, payload, target_id=target.groudId)
+            elif target is None:
+                cmd = self._casaClient.buildClassicCommand(4, payload)
+            else:
+                raise TypeError(f"Unkown target type {type(target)}")
+
+            await self._casaClient.send(cmd)
+            return
+
         # Use -1 to indicate special packet format
         # Use RestoreLastLevel flag (1) and UseFullTimeFlag (4).
         # Not sure what UseFullTime does but this is what the app uses.
@@ -367,6 +472,11 @@ class Casambi:
                 ConnectionState.AUTHENTICATED,
                 ConnectionState.NONE,
             )
+        if self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # Classic uses a completely different command encoding (u1.C1753e/u1.EnumC1754f).
+            # Public APIs that support Classic handle it explicitly; anything reaching here would
+            # send an EVO INVOCATION packet which is not valid on Classic.
+            raise ProtocolError(f"Operation {opcode.name} is not supported on Classic networks via INVOCATION.")
 
         targetCode = 0
         if isinstance(target, Unit):
@@ -400,7 +510,7 @@ class Casambi:
     def _dataCallback(
         self, packetType: IncommingPacketType, data: dict[str, Any]
     ) -> None:
-        self._logger.info(f"Incomming data callback of type {packetType}")
+        self._logger.debug("Incomming data callback of type %s", packetType)
         if packetType == IncommingPacketType.UnitState:
             self._logger.debug(
                 f"Handling changed state {b2a(data['state'])} for unit {data['id']}"
@@ -473,13 +583,17 @@ class Casambi:
         """Register a new handler for switch events.
 
         This handler is called whenever a switch event is received.
-        The handler is supplied with a dictionary containing:
-        - unit_id: The ID of the switch unit
-        - button: The button number that was pressed/released
-        - event: Either "button_press" or "button_release"
-        - message_type: The raw message type (0x08 or 0x10)
-        - flags: Additional flags from the message
-        - extra_data: Any additional data from the message
+        The handler is supplied with a dictionary containing (at minimum):
+        - unit_id: target unit id (from INVOCATION target high byte)
+        - button: best-effort "label" (typically 1..4 for 4-gang switches)
+        - event: "button_press" | "button_release" | "input_event"
+
+        Switch events are parsed from decrypted packet type=7 (INVOCATION stream),
+        matching casambi-android `v1.C1775b.Q(Q2.h)`. Extra diagnostic keys include:
+        - invocation_flags, opcode, origin, target, target_type, age, origin_handle
+        - button_event_index (0..7), param_p, param_s
+        - input_index (0..7), input_code, input_b1, input_channel, input_value16, input_mapped_event
+        - packet_sequence, arrival_sequence, raw_packet, decrypted_data, payload_hex, frame_offset, event_id
 
         :param handler: The method to call when a switch event is received.
         """

casambi_bt_revamped-0.3.12.dev3/src/CasambiBt/_classic_crypto.py

@@ -0,0 +1,31 @@
+"""Classic Casambi protocol helpers (CMAC signing/verification).
+
+Ground truth:
+- casambi-android `t1.P.o(...)` calculates a CMAC over:
+    connection_hash[0:8] + payload
+  and stores the CMAC (prefix) into the packet header.
+"""
+
+from __future__ import annotations
+
+from cryptography.hazmat.primitives.cmac import CMAC
+from cryptography.hazmat.primitives.ciphers.algorithms import AES
+
+
+def classic_cmac(key: bytes, conn_hash8: bytes, payload: bytes) -> bytes:
+    """Compute the Classic CMAC (16 bytes) over connection hash + payload."""
+    if len(conn_hash8) != 8:
+        raise ValueError("conn_hash8 must be 8 bytes")
+    cmac = CMAC(AES(key))
+    cmac.update(conn_hash8)
+    cmac.update(payload)
+    return cmac.finalize()
+
+
+def classic_cmac_prefix(
+    key: bytes, conn_hash8: bytes, payload: bytes, prefix_len: int
+) -> bytes:
+    """Return the prefix bytes that are embedded into the Classic packet header."""
+    mac = classic_cmac(key, conn_hash8, payload)
+    return mac[:prefix_len]
+