casambi-bt-revamped 0.3.7.dev3__py3-none-any.whl → 0.3.12.dev15__py3-none-any.whl

CasambiBt/_switch_events.py

@@ -0,0 +1,329 @@
+from __future__ import annotations
+
+import logging
+import time
+from binascii import b2a_hex as b2a
+from dataclasses import dataclass
+from typing import Any, Final
+
+from ._invocation import InvocationFrame, parse_invocation_stream
+
+
+_BUTTON_EVENT_MIN: Final[int] = 29  # FunctionButtonEvent0
+_BUTTON_EVENT_MAX: Final[int] = 36  # FunctionButtonEvent7
+_INPUT_EVENT_MIN: Final[int] = 64  # FunctionNotifyInput0
+_INPUT_EVENT_MAX: Final[int] = 71  # FunctionNotifyInput7
+
+_TARGET_TYPE_BUTTON: Final[int] = 0x06
+_TARGET_TYPE_INPUT: Final[int] = 0x12
+
+
+def _guess_button_label_4gang(button_event_index: int) -> int:
+    """Casambi app labels a typical 4-button switch as 1..4.
+
+    Observed mapping for 4-gang switches in provided logs:
+    - ButtonEvent0 -> label 4
+    - ButtonEvent1 -> label 1
+    - ButtonEvent2 -> label 2
+    - ButtonEvent3 -> label 3
+    """
+
+    if 0 <= button_event_index <= 3:
+        return ((button_event_index + 3) % 4) + 1
+    return button_event_index
+
+
+@dataclass(slots=True)
+class SwitchDecoderStats:
+    frames_total: int = 0
+    frames_button: int = 0
+    frames_input: int = 0
+    frames_ignored: int = 0
+    events_emitted: int = 0
+    events_suppressed_same_state: int = 0
+
+
+class SwitchEventStreamDecoder:
+    """Decode decrypted packet type=7 payload into high-level switch events."""
+
+    def __init__(self, logger: logging.Logger | None = None) -> None:
+        self._logger = logger or logging.getLogger(__name__)
+        # (unit_id, button_event_index) -> pressed(bool)
+        self._last_pressed: dict[tuple[int, int], bool] = {}
+        # (unit_id, input_index) -> last input code (payload[0]) we emitted as a semantic event.
+        self._last_input_code: dict[tuple[int, int], int] = {}
+        # (unit_id, button_label) -> observed real button stream (target_type=0x06) for that button.
+        # If present, we avoid creating synthetic press/release events from input frames.
+        self._button_stream_seen: set[tuple[int, int]] = set()
+
+    def reset(self) -> None:
+        self._last_pressed.clear()
+        self._last_input_code.clear()
+        self._button_stream_seen.clear()
+
+    def decode(
+        self,
+        data: bytes,
+        *,
+        packet_seq: int | None = None,
+        raw_packet: bytes | None = None,
+        arrival_sequence: int | None = None,
+    ) -> tuple[list[dict[str, Any]], SwitchDecoderStats]:
+        """Decode one decrypted switch packet payload."""
+
+        frames = parse_invocation_stream(data, logger=self._logger)
+        stats = SwitchDecoderStats(frames_total=len(frames))
+        events: list[dict[str, Any]] = []
+
+        for frame in frames:
+            ev = self._decode_frame(
+                frame,
+                data=data,
+                packet_seq=packet_seq,
+                raw_packet=raw_packet,
+                arrival_sequence=arrival_sequence,
+                stats=stats,
+            )
+            if ev is None:
+                continue
+            events.append(ev)
+            stats.events_emitted += 1
+
+        return events, stats
+
+    def _decode_frame(
+        self,
+        frame: InvocationFrame,
+        *,
+        data: bytes,
+        packet_seq: int | None,
+        raw_packet: bytes | None,
+        arrival_sequence: int | None,
+        stats: SwitchDecoderStats,
+    ) -> dict[str, Any] | None:
+        unit_id = (frame.target >> 8) & 0xFF
+        target_type = frame.target & 0xFF
+
+        origin_unit_id = (frame.origin >> 8) & 0xFF
+        origin_type = frame.origin & 0xFF
+
+        # Button events (press/release) are INVOCATIONs targeted at type 0x06.
+        if (
+            target_type == _TARGET_TYPE_BUTTON
+            and _BUTTON_EVENT_MIN <= frame.opcode <= _BUTTON_EVENT_MAX
+        ):
+            stats.frames_button += 1
+
+            button_event_index = frame.opcode - _BUTTON_EVENT_MIN
+            button = _guess_button_label_4gang(button_event_index)
+            self._button_stream_seen.add((unit_id, button))
+
+            pressed = bool(frame.payload and (frame.payload[0] & 0x80))
+            state_key = (unit_id, button_event_index)
+            last_pressed = self._last_pressed.get(state_key)
+
+            # Wireless switches retransmit; drop repeated same-state frames to avoid duplicate events.
+            if last_pressed is not None and last_pressed == pressed:
+                stats.events_suppressed_same_state += 1
+                self._logger.debug(
+                    "[CASAMBI_EVENT_SUPPRESS] unit=%d button_index=%d button=%d pressed=%s opcode=0x%02x origin=0x%04x age=0x%04x",
+                    unit_id,
+                    button_event_index,
+                    button,
+                    pressed,
+                    frame.opcode,
+                    frame.origin,
+                    frame.age,
+                )
+                return None
+            self._last_pressed[state_key] = pressed
+
+            b0 = frame.payload[0] if frame.payload else 0
+            param_p = (b0 >> 3) & 0x0F
+            param_s = b0 & 0x07
+
+            event = "button_press" if pressed else "button_release"
+
+            # Stable identifier for consumers to deduplicate further if needed.
+            event_id = f"invoke:{frame.origin:04x}:{frame.age:04x}:{frame.opcode:02x}:{frame.target:04x}"
+
+            if self._logger.isEnabledFor(logging.DEBUG):
+                self._logger.debug(
+                    "[CASAMBI_BUTTON_EVENT] packet=%s unit=%d button=%d event=%s opcode=0x%02x origin=0x%04x age=0x%04x flags=0x%04x payload=%s",
+                    packet_seq,
+                    unit_id,
+                    button,
+                    event,
+                    frame.opcode,
+                    frame.origin,
+                    frame.age,
+                    frame.flags,
+                    b2a(frame.payload),
+                )
+
+            return {
+                # Back-compat / existing consumers
+                "unit_id": unit_id,
+                "button": button,
+                "event": event,
+                "message_type": 0x07,  # decrypted packet type (SwitchEvent)
+                "message_position": frame.offset,
+                "extra_data": None,
+                # INVOCATION fields
+                "invocation_flags": frame.flags,
+                "opcode": frame.opcode,
+                "origin": frame.origin,
+                "origin_unit_id": origin_unit_id,
+                "origin_type": origin_type,
+                "target": frame.target,
+                "target_type": target_type,
+                "age": frame.age,
+                "origin_handle": frame.origin_handle,
+                "payload": frame.payload,
+                "payload_hex": b2a(frame.payload),
+                "frame_offset": frame.offset,
+                "button_event_index": button_event_index,
+                "param_p": param_p,
+                "param_s": param_s,
+                # Diagnostics / correlation
+                "packet_sequence": packet_seq,
+                "arrival_sequence": arrival_sequence,
+                "event_id": event_id,
+                "raw_packet": b2a(raw_packet) if raw_packet else None,
+                "decrypted_data": b2a(data),
+                "frame_hex": b2a(
+                    data[frame.offset : frame.offset + (9 + (1 if frame.origin_handle is not None else 0) + frame.payload_len)]
+                ),
+                "received_at": time.time(),
+            }
+
+        # Input notify frames (often accompany wireless switches).
+        if (
+            target_type == _TARGET_TYPE_INPUT
+            and _INPUT_EVENT_MIN <= frame.opcode <= _INPUT_EVENT_MAX
+        ):
+            stats.frames_input += 1
+            input_index = frame.opcode - _INPUT_EVENT_MIN
+            input_code = frame.payload[0] if frame.payload else None
+            input_b1 = frame.payload[1] if len(frame.payload) >= 2 else None
+            input_channel = (input_b1 & 0x07) if input_b1 is not None else None
+            input_value16 = (
+                int.from_bytes(frame.payload[2:4], "little")
+                if len(frame.payload) >= 4
+                else None
+            )
+            button = _guess_button_label_4gang(input_index)
+
+            # Map common input codes into the legacy "switch" event taxonomy.
+            # Observed:
+            # - wired: 01xx press, 02xx release, 0cxx release_after_hold
+            # - wireless: 09xx hold, 0cxx release_after_hold (+ separate button stream for press/release)
+            mapped_event: str | None = None
+            if input_code is not None:
+                if input_code == 0x09:
+                    mapped_event = "button_hold"
+                elif input_code == 0x0C:
+                    mapped_event = "button_release_after_hold"
+                elif input_code == 0x01:
+                    mapped_event = "button_press"
+                elif input_code == 0x02:
+                    mapped_event = "button_release"
+
+            input_mapped_event = mapped_event
+
+            # Avoid duplicating press/release for wireless switches that also produce the real button stream.
+            if mapped_event in ("button_press", "button_release") and (unit_id, button) in self._button_stream_seen:
+                mapped_event = None
+
+            if mapped_event is not None and input_code is not None:
+                state_key = (unit_id, input_index)
+                last_code = self._last_input_code.get(state_key)
+                if last_code == input_code:
+                    stats.events_suppressed_same_state += 1
+                    self._logger.debug(
+                        "[CASAMBI_EVENT_SUPPRESS] input unit=%d input_index=%d button=%d code=0x%02x opcode=0x%02x origin=0x%04x age=0x%04x",
+                        unit_id,
+                        input_index,
+                        button,
+                        input_code,
+                        frame.opcode,
+                        frame.origin,
+                        frame.age,
+                    )
+                    return None
+                self._last_input_code[state_key] = input_code
+
+                if self._logger.isEnabledFor(logging.DEBUG):
+                    self._logger.debug(
+                        "[CASAMBI_INPUT_AS_BUTTON] packet=%s unit=%d button=%d event=%s code=0x%02x opcode=0x%02x origin=0x%04x age=0x%04x flags=0x%04x payload=%s",
+                        packet_seq,
+                        unit_id,
+                        button,
+                        mapped_event,
+                        input_code,
+                        frame.opcode,
+                        frame.origin,
+                        frame.age,
+                        frame.flags,
+                        b2a(frame.payload),
+                    )
+            event = mapped_event or "input_event"
+            self._logger.debug(
+                "[CASAMBI_INPUT_EVENT] packet=%s unit=%d input=%d opcode=0x%02x origin=0x%04x age=0x%04x flags=0x%04x code=%s ch=%s val=%s payload=%s",
+                packet_seq,
+                unit_id,
+                input_index,
+                frame.opcode,
+                frame.origin,
+                frame.age,
+                frame.flags,
+                f"0x{input_code:02x}" if input_code is not None else None,
+                input_channel,
+                input_value16,
+                b2a(frame.payload),
+            )
+            return {
+                "unit_id": unit_id,
+                "button": button,
+                "event": event,
+                "message_type": 0x07,
+                "message_position": frame.offset,
+                "extra_data": None,
+                "invocation_flags": frame.flags,
+                "opcode": frame.opcode,
+                "origin": frame.origin,
+                "origin_unit_id": origin_unit_id,
+                "origin_type": origin_type,
+                "target": frame.target,
+                "target_type": target_type,
+                "age": frame.age,
+                "origin_handle": frame.origin_handle,
+                "payload": frame.payload,
+                "payload_hex": b2a(frame.payload),
+                "frame_offset": frame.offset,
+                "input_index": input_index,
+                "input_code": input_code,
+                "input_b1": input_b1,
+                "input_channel": input_channel,
+                "input_value16": input_value16,
+                "input_mapped_event": input_mapped_event,
+                "packet_sequence": packet_seq,
+                "arrival_sequence": arrival_sequence,
+                "event_id": f"invoke:{frame.origin:04x}:{frame.age:04x}:{frame.opcode:02x}:{frame.target:04x}",
+                "raw_packet": b2a(raw_packet) if raw_packet else None,
+                "decrypted_data": b2a(data),
+                "received_at": time.time(),
+            }
+
+        stats.frames_ignored += 1
+        self._logger.debug(
+            "[CASAMBI_INVOKE_IGNORED] packet=%s opcode=0x%02x origin=0x%04x target=0x%04x age=0x%04x flags=0x%04x payload=%s",
+            packet_seq,
+            frame.opcode,
+            frame.origin,
+            frame.target,
+            frame.age,
+            frame.flags,
+            b2a(frame.payload),
+        )
+        return None

CasambiBt/_unit.py

@@ -3,7 +3,7 @@ from binascii import b2a_hex as b2a
 from colorsys import hsv_to_rgb, rgb_to_hsv
 from dataclasses import dataclass
 from enum import Enum, unique
-from typing import Final
+from typing import Any, Final
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -111,6 +111,40 @@ class UnitState:
         self._colorsource: ColorSource | None = None
         self._xy: tuple[float, float] | None = None
         self._slider: int | None = None
+        self._onoff: bool | None = None
+        # Last raw state bytes, as received from the network.
+        self._raw_state: bytes | None = None
+        # Unknown controls that we don't have semantic parsing for yet.
+        # Items are (offset_bits, length_bits, value_int).
+        self._unknown_controls: list[tuple[int, int, int]] = []
+
+    @property
+    def raw_state(self) -> bytes | None:
+        return self._raw_state
+
+    @property
+    def unknown_controls(self) -> list[tuple[int, int, int]]:
+        # Expose a copy so callers can't mutate internal tracking.
+        return list(self._unknown_controls)
+
+    def as_dict(self) -> dict[str, Any]:
+        """Return a stable, JSON-friendly representation for diagnostics."""
+        return {
+            "dimmer": self.dimmer,
+            "vertical": self.vertical,
+            "rgb": self.rgb,
+            "white": self.white,
+            "temperature": self.temperature,
+            "colorsource": self.colorsource.name if self.colorsource is not None else None,
+            "xy": self.xy,
+            "slider": self.slider,
+            "onoff": self.onoff,
+            "raw_state_hex": b2a(self._raw_state).decode("ascii") if self._raw_state is not None else None,
+            "unknown_controls": [
+                {"offset": off, "length": length, "value": val}
+                for (off, length, val) in self._unknown_controls
+            ],
+        }
 
     def _check_range(
         self, value: int | float, min: int | float, max: int | float
@@ -269,9 +303,20 @@ class UnitState:
     def slider(self) -> None:
         self.slider = None
 
-    def __repr__(self) -> str:
-        return f"UnitState(dimmer={self.dimmer}, vertical={self._vertical}, rgb={self.rgb.__repr__()}, white={self.white}, temperature={self.temperature}, colorsource={self.colorsource}, xy={self.xy}, slider={self.slider})"
+    @property
+    def onoff(self) -> bool | None:
+        return self._onoff
+
+    @onoff.setter
+    def onoff(self, value: bool) -> None:
+        self._onoff = value
 
+    @onoff.deleter
+    def onoff(self) -> None:
+        self._onoff = None
+
+    def __repr__(self) -> str:
+        return f"UnitState(dimmer={self.dimmer}, vertical={self._vertical}, rgb={self.rgb.__repr__()}, white={self.white}, temperature={self.temperature}, colorsource={self.colorsource}, xy={self.xy}, slider={self.slider}, onoff={self.onoff})"
 
 # TODO: Make unit immutable (refactor state, on, online out of it)
 @dataclass(init=True, repr=True)
@@ -285,6 +330,7 @@ class Unit:
     :ivar firmwareVersion: Firmware version of the unit.
 
     :ivar unitType: Type of the unit. Determines the capabilities.
+    :ivar securityKey: Optional per-unit key (seen on some legacy/mixed networks). Not used yet.
     """
 
     _typeId: int
@@ -295,6 +341,7 @@ class Unit:
     firmwareVersion: str
 
     unitType: UnitType
+    securityKey: bytes | None = None
 
     _state: UnitState | None = None
     _on: bool = False
@@ -308,6 +355,8 @@ class Unit:
     @property
     def is_on(self) -> bool:
         """Determine whether the unit is turned on."""
+        if self.unitType.get_control(UnitControlType.ONOFF) and self._state:
+            return self._on and self._state.onoff is True
         if self.unitType.get_control(UnitControlType.DIMMER) and self._state:
             return (
                 self._on and self._state.dimmer is not None and self._state.dimmer > 0
@@ -385,6 +434,8 @@ class Unit:
             elif c.type == UnitControlType.SLIDER and state.slider is not None:
                 scale = UnitState.SLIDER_RESOLUTION - c.length
                 scaledValue = state.slider >> scale
+            elif c.type == UnitControlType.ONOFF and state.onoff is not None:
+                scaledValue = 1 if state.onoff else 0
 
             # Use default if unsupported type or unset value in state
             else:
@@ -413,6 +464,8 @@ class Unit:
         """
         if not self._state:
             self._state = UnitState()
+        self._state._raw_state = value
+        self._state._unknown_controls = []
 
         # TODO: Support for resolutions >8 byte?
         for c in self.unitType.controls:
@@ -477,11 +530,14 @@ class Unit:
             elif c.type == UnitControlType.SLIDER:
                 scale = UnitState.SLIDER_RESOLUTION - c.length
                 self._state.slider = cInt << scale
+            elif c.type == UnitControlType.ONOFF:
+                self._state.onoff = cInt != 0
             elif c.type == UnitControlType.UNKOWN:
                 # Might be useful for implementing more state types
                 _LOGGER.debug(
                     f"Value for unkown control type at {c.offset}: {cInt}. Unit type is {self.unitType.id}."
                 )
+                self._state._unknown_controls.append((c.offset, c.length, cInt))
 
         _LOGGER.debug(f"Parsed {b2a(value)} to {self.state.__repr__()}")
 

CasambiBt/_version.py

@@ -0,0 +1,10 @@
+"""Package version (kept in-sync with setup.cfg).
+
+Home Assistant integrations sometimes run with strict event-loop blocking checks.
+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.dev15"

CasambiBt/errors.py

@@ -69,3 +69,15 @@ class UnsupportedProtocolVersion(CasambiBtError):
     """Exception that is raised when the network has an unsupported version."""
 
     pass
+
+
+class ClassicKeysMissingError(ProtocolError):
+    """Classic network is missing visitorKey/managerKey required for signing packets."""
+
+    pass
+
+
+class ClassicHandshakeError(ProtocolError):
+    """Classic network handshake/initialization failed (e.g. connection hash unavailable)."""
+
+    pass

casambi_bt_revamped-0.3.12.dev15.dist-info/METADATA

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: casambi-bt-revamped
+Version: 0.3.12.dev15
+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.dev15.dist-info/RECORD

@@ -0,0 +1,22 @@
+CasambiBt/__init__.py,sha256=iJdTF4oeXfj5d5gfGxQkacqUjtnQo0IW-zFPJvFjWWk,336
+CasambiBt/_cache.py,sha256=3bQil8vhSy4f4sf9JusMfEdQC7d3cJuva9qHhyKro-0,3808
+CasambiBt/_casambi.py,sha256=dAZZ0S2-t2ShLbW78AE9lOLBzOmhBOTTXJky-6khdkE,41981
+CasambiBt/_classic_crypto.py,sha256=XIp3JBaeY8hIUv5kB0ygVG_eRx9AgHHF4ts2--CFm78,4973
+CasambiBt/_client.py,sha256=desVYyMhMB0vKjEHLWw2C-7CO7yvB6FWwoqySaN1Huk,104023
+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=3ZUedQlHzzuHHiG5KxDLnK0AIz0TjzG1_vwg0UGsO9U,22132
+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=IDHDoRoj0CDeYUiiYZnh5B9lFsUQxzQcLpRI4i7oeag,338
+CasambiBt/errors.py,sha256=1L_Q8og_N_BRYEKizghAQXr6tihlHykFgtcCHUDcBas,1961
+CasambiBt/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+casambi_bt_revamped-0.3.12.dev15.dist-info/licenses/LICENSE,sha256=TAIIitFxpxEDi6Iju7foW4TDQmWvC-IhLVLhl67jKmQ,11341
+casambi_bt_revamped-0.3.12.dev15.dist-info/METADATA,sha256=Od28-hLz4ACPfPu81xo72RmmIxjHucz61kprTotR9Wg,5878
+casambi_bt_revamped-0.3.12.dev15.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+casambi_bt_revamped-0.3.12.dev15.dist-info/top_level.txt,sha256=uNbqLjtecFosoFzpGAC89-5icikWODKI8rOjbi8v_sA,10
+casambi_bt_revamped-0.3.12.dev15.dist-info/RECORD,,

{casambi_bt_revamped-0.3.7.dev3.dist-info → casambi_bt_revamped-0.3.12.dev15.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any