casambi-bt-revamped 0.3.7.dev3__py3-none-any.whl → 0.3.7.dev4__py3-none-any.whl

CasambiBt/_casambi.py

@@ -423,14 +423,14 @@ class Casambi:
                 f"Handling switch event: unit_id={data.get('unit_id')}, "
                 f"button={data.get('button')}, event={data.get('event')}"
             )
-
+            
             # Notify listeners
-            for switch_handler in self._switchEventCallbacks:
+            for h in self._switchEventCallbacks:
                 try:
-                    switch_handler(data)
+                    h(data)
                 except Exception:
                     self._logger.error(
-                        f"Exception occurred in switchEventCallback {switch_handler}.",
+                        f"Exception occurred in switchEventCallback {h}.",
                         exc_info=True,
                     )
         else:
@@ -457,9 +457,7 @@ class Casambi:
         self._unitChangedCallbacks.remove(handler)
         self._logger.debug(f"Removed unit changed handler {handler}")
 
-    def registerSwitchEventHandler(
-        self, handler: Callable[[dict[str, Any]], None]
-    ) -> None:
+    def registerSwitchEventHandler(self, handler: Callable[[dict[str, Any]], None]) -> None:
         """Register a new handler for switch events.
 
         This handler is called whenever a switch event is received.
@@ -476,9 +474,7 @@ class Casambi:
         self._switchEventCallbacks.append(handler)
         self._logger.debug(f"Registered switch event handler {handler}")
 
-    def unregisterSwitchEventHandler(
-        self, handler: Callable[[dict[str, Any]], None]
-    ) -> None:
+    def unregisterSwitchEventHandler(self, handler: Callable[[dict[str, Any]], None]) -> None:
         """Unregister an existing switch event handler.
 
         :param handler: The handler to unregister.

CasambiBt/_client.py

@@ -33,6 +33,12 @@ from .errors import (  # noqa: E402
     UnsupportedProtocolVersion,
 )
 
+# Import Android parser for comparison
+try:
+    from ._client_android_parser import AndroidPacketParser
+except ImportError:
+    AndroidPacketParser = None
+
 
 @unique
 class IncommingPacketType(IntEnum):
@@ -414,18 +420,28 @@ class CasambiClient:
     ) -> None:
         # TODO: Check incoming counter and direction flag
         self._inPacketCount += 1
-
-        # Store raw encrypted packet for reference
+        
+        # Store raw encrypted packet for Android parser analysis
         raw_encrypted_packet = data[:]
+        
+        # Android parser comparison - disabled as protocols are incompatible
+        android_switch_event = None
+        # The Android parser expects a completely different packet format than what
+        # this implementation uses. Logging disabled to reduce noise.
 
         try:
-            decrypted_data = self._encryptor.decryptAndVerify(
-                data, data[:4] + self._nonce[4:]
-            )
+            decrypted_data = self._encryptor.decryptAndVerify(data, data[:4] + self._nonce[4:])
         except InvalidSignature:
             # We only drop packets with invalid signature here instead of going into an error state
             self._logger.error(f"Invalid signature for packet {b2a(data)}!")
             return
+            
+        # Protocol analysis: Current implementation vs Android
+        # These are fundamentally different protocols:
+        # - Current: Type 0x07 + message-based protocol (0x10/0x08 messages)
+        # - Android: Complex header with command types 29-36 for buttons
+        # No conversion possible - they're incompatible formats
+        android_switch_event = None
 
         packetType = decrypted_data[0]
         self._logger.debug(f"Incoming data of type {packetType}: {b2a(decrypted_data)}")
@@ -433,9 +449,7 @@ class CasambiClient:
         if packetType == IncommingPacketType.UnitState:
             self._parseUnitStates(decrypted_data[1:])
         elif packetType == IncommingPacketType.SwitchEvent:
-            self._parseSwitchEvent(
-                decrypted_data[1:], self._inPacketCount, raw_encrypted_packet
-            )
+            self._parseSwitchEvent(decrypted_data[1:], self._inPacketCount, raw_encrypted_packet, android_switch_event)
         elif packetType == IncommingPacketType.NetworkConfig:
             # We don't care about the config the network thinks it has.
             # We assume that cloud config and local config match.
@@ -489,29 +503,23 @@ class CasambiClient:
                 f"Ran out of data while parsing unit state! Remaining data {b2a(data[oldPos:])} in {b2a(data)}."
             )
 
-    def _parseSwitchEvent(
-        self, data: bytes, packet_seq: int = None, raw_packet: bytes = None
-    ) -> None:
-        """Parse switch event packet which contains multiple message types."""
-        self._logger.info(
-            f"Parsing incoming switch event packet #{packet_seq}... Data: {b2a(data)}"
-        )
-
+    def _parseSwitchEvent(self, data: bytes, packet_seq: int = None, raw_packet: bytes = None, android_switch_event: dict = None) -> None:
+        """Parse switch event packet which contains multiple message types"""
+        self._logger.info(f"Parsing incoming switch event packet #{packet_seq}... Data: {b2a(data)}")
+        
         # Special handling for message type 0x29 - not a switch event
         if len(data) >= 1 and data[0] == 0x29:
-            self._logger.debug(
-                f"Ignoring message type 0x29 (not a switch event): {b2a(data)}"
-            )
+            self._logger.debug(f"Ignoring message type 0x29 (not a switch event): {b2a(data)}")
             return
 
         pos = 0
         oldPos = 0
         switch_events_found = 0
-
+        
         try:
             while pos <= len(data) - 3:
                 oldPos = pos
-
+                
                 # Parse message header
                 message_type = data[pos]
                 flags = data[pos + 1]
@@ -546,19 +554,15 @@ class CasambiClient:
                     # Extract button ID - try both upper and lower nibbles
                     button_lower = parameter & 0x0F
                     button_upper = (parameter >> 4) & 0x0F
-
+                    
                     # Use upper 4 bits if lower 4 bits are 0, otherwise use lower 4 bits
                     if button_lower == 0 and button_upper != 0:
                         button = button_upper
-                        self._logger.debug(
-                            f"EVO button extraction: parameter=0x{parameter:02x}, using upper nibble, button={button}"
-                        )
+                        self._logger.debug(f"EVO button extraction: parameter=0x{parameter:02x}, using upper nibble, button={button}")
                     else:
                         button = button_lower
-                        self._logger.debug(
-                            f"EVO button extraction: parameter=0x{parameter:02x}, using lower nibble, button={button}"
-                        )
-
+                        self._logger.debug(f"EVO button extraction: parameter=0x{parameter:02x}, using lower nibble, button={button}")
+                    
                     # For type 0x10 messages, we need to pass additional data beyond the declared payload
                     if message_type == 0x10:
                         # Extend to include at least 10 bytes from message start for state byte
@@ -566,20 +570,11 @@ class CasambiClient:
                         full_message_data = data[oldPos:extended_end]
                     else:
                         full_message_data = data
-                    self._processSwitchMessage(
-                        message_type,
-                        flags,
-                        button,
-                        payload,
-                        full_message_data,
-                        oldPos,
-                        packet_seq,
-                        raw_packet,
-                    )
+                    self._processSwitchMessage(message_type, flags, button, payload, full_message_data, oldPos, packet_seq, raw_packet, android_switch_event)
                 elif message_type == 0x29:
                     # This shouldn't happen due to check above, but just in case
-                    self._logger.debug("Ignoring embedded type 0x29 message")
-                elif message_type in [0x00, 0x06, 0x09, 0x1F, 0x2A]:
+                    self._logger.debug(f"Ignoring embedded type 0x29 message")
+                elif message_type in [0x00, 0x06, 0x09, 0x1f, 0x2a]:
                     # Known non-switch message types - log at debug level
                     self._logger.debug(
                         f"Non-switch message type 0x{message_type:02x}: flags=0x{flags:02x}, "
@@ -599,22 +594,12 @@ class CasambiClient:
                 f"Ran out of data while parsing switch event packet! "
                 f"Remaining data {b2a(data[oldPos:])} in {b2a(data)}."
             )
-
+            
         if switch_events_found == 0:
             self._logger.debug(f"No switch events found in packet: {b2a(data)}")
 
-    def _processSwitchMessage(
-        self,
-        message_type: int,
-        flags: int,
-        button: int,
-        payload: bytes,
-        full_data: bytes,
-        start_pos: int,
-        packet_seq: int = None,
-        raw_packet: bytes = None,
-    ) -> None:
-        """Process a switch/button message (types 0x08 or 0x10)."""
+    def _processSwitchMessage(self, message_type: int, flags: int, button: int, payload: bytes, full_data: bytes, start_pos: int, packet_seq: int = None, raw_packet: bytes = None, android_switch_event: dict = None) -> None:
+        """Process a switch/button message (types 0x08 or 0x10)"""
         if not payload:
             self._logger.error("Switch message has empty payload")
             return
@@ -623,14 +608,14 @@ class CasambiClient:
         if message_type == 0x10 and len(payload) >= 3:
             # Type 0x10: unit_id is at payload[2]
             unit_id = payload[2]
-            extra_data = payload[3:] if len(payload) > 3 else b""
+            extra_data = payload[3:] if len(payload) > 3 else b''
         else:
             # Standard parsing for other message types
             unit_id = payload[0]
-            extra_data = b""
+            extra_data = b''
             if len(payload) > 2:
                 extra_data = payload[2:]
-
+        
         # Extract action based on message type (action SHOULD be different for press vs release)
         if message_type == 0x10 and len(payload) > 1:
             # Type 0x10: action is at payload[1]
@@ -642,7 +627,7 @@ class CasambiClient:
             action = None
 
         event_string = "unknown"
-
+        
         # Different interpretation based on message type
         if message_type == 0x08:
             # Type 0x08: Use bit 1 of action for press/release
@@ -662,12 +647,10 @@ class CasambiClient:
                     event_string = "button_release"
                 elif state_byte == 0x09:
                     event_string = "button_hold"
-                elif state_byte == 0x0C:
+                elif state_byte == 0x0c:
                     event_string = "button_release_after_hold"
                 else:
-                    self._logger.debug(
-                        f"Type 0x10: Unknown state byte 0x{state_byte:02x} at message pos {state_pos}"
-                    )
+                    self._logger.debug(f"Type 0x10: Unknown state byte 0x{state_byte:02x} at message pos {state_pos}")
                     # Fallback: check if extra_data starts with 0x12 (indicates release)
                     if len(extra_data) >= 1 and extra_data[0] == 0x12:
                         event_string = "button_release"
@@ -677,14 +660,10 @@ class CasambiClient:
                 # Fallback when message is too short
                 if len(extra_data) >= 1 and extra_data[0] == 0x12:
                     event_string = "button_release"
-                    self._logger.debug(
-                        "Type 0x10: Using extra_data pattern for release detection"
-                    )
+                    self._logger.debug(f"Type 0x10: Using extra_data pattern for release detection")
                 else:
                     # Cannot determine state
-                    self._logger.warning(
-                        f"Type 0x10 message missing state info, unit_id={unit_id}, payload={b2a(payload)}"
-                    )
+                    self._logger.warning(f"Type 0x10 message missing state info, unit_id={unit_id}, payload={b2a(payload)}")
                     event_string = "unknown"
 
         action_display = f"{action:#04x}" if action is not None else "N/A"
@@ -693,11 +672,33 @@ class CasambiClient:
             f"Switch event (type 0x{message_type:02x}): button={button}, unit_id={unit_id}, "
             f"action={action_display} ({event_string}), flags=0x{flags:02x}"
         )
-
-        # Filter out type 0x08 messages with button=0 (likely notifications)
-        if message_type == 0x08 and button == 0:
+        
+        # Include Android parser comparison if available
+        android_comparison = None
+        if android_switch_event:
+            android_comparison = {
+                'unit_id': android_switch_event['unit_id'],
+                'button': android_switch_event['button'],
+                'state': android_switch_event['state'],
+                'param_p': android_switch_event['param_p'],
+                'param_s': android_switch_event['param_s'],
+                'android_log': android_switch_event['android_log']
+            }
+            # Log differences
+            if android_switch_event['unit_id'] != unit_id:
+                self._logger.warning(f"Unit ID mismatch: current={unit_id}, android={android_switch_event['unit_id']}")
+            if android_switch_event['button'] != button:
+                self._logger.warning(f"Button mismatch: current={button}, android={android_switch_event['button']}")
+                
+        # Extract controlling unit if present
+        controlling_unit = None
+        # This is redundant since we already return early if unit_id_echo != unit_id
+        # Removing to avoid confusion
+        
+        # Filter out all type 0x08 messages
+        if message_type == 0x08:
             self._logger.debug(
-                f"Filtering out type 0x08 notification event: button={button}, unit_id={unit_id}, "
+                f"Filtering out type 0x08 event: button={button}, unit_id={unit_id}, "
                 f"action={action_display}, flags=0x{flags:02x}"
             )
             return
@@ -712,11 +713,13 @@ class CasambiClient:
                 "event": event_string,
                 "flags": flags,
                 "extra_data": extra_data,
+                "controlling_unit": controlling_unit,
                 "packet_sequence": packet_seq,
                 "raw_packet": b2a(raw_packet) if raw_packet else None,
                 "decrypted_data": b2a(full_data),
                 "message_position": start_pos,
                 "payload_hex": b2a(payload),
+                "android_comparison": android_comparison,
             },
         )
 

CasambiBt/_client_android_parser.py

@@ -0,0 +1,215 @@
+"""
+Android App Compatible Parser for Casambi Switch Events
+
+This module implements the exact parsing logic from the decompiled Android app
+to compare with our current implementation.
+"""
+
+import struct
+from typing import Dict, Any, Optional, Tuple
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class AndroidPacketParser:
+    """Parser that follows the exact Android app implementation"""
+    
+    @staticmethod
+    def parse_packet_header(data: bytes, pos: int = 0) -> Tuple[Dict[str, Any], int]:
+        """
+        Parse packet header according to Android app C1775b.Q method (lines 230-243)
+        
+        Returns: (header_dict, new_position)
+        """
+        if len(data) - pos < 9:
+            raise ValueError("Insufficient data for packet header")
+            
+        # Read header (2 bytes)
+        unsigned_short = struct.unpack_from('>H', data, pos)[0]
+        pos += 2
+        
+        # Extract flags from header
+        has_origin_handle = (unsigned_short & 64) != 0    # bit 6
+        is_unique = (unsigned_short & 128) != 0           # bit 7
+        has_session = (unsigned_short & 256) != 0         # bit 8
+        has_origin_handle_alt = (unsigned_short & 512) != 0  # bit 9
+        flag_1024 = (unsigned_short & 1024) != 0         # bit 10
+        
+        # Read command type (1 byte) - this is the EnumC1777d ordinal
+        command_type = data[pos] & 0xFF
+        pos += 1
+        
+        # Read origin (2 bytes)
+        origin = struct.unpack_from('>H', data, pos)[0]
+        pos += 2
+        
+        # Read target (2 bytes)
+        target = struct.unpack_from('>H', data, pos)[0]
+        pos += 2
+        
+        # Extract lifetime from header bits 11-14
+        lifetime = (unsigned_short >> 11) & 15
+        
+        # Read age (2 bytes)
+        age = struct.unpack_from('>H', data, pos)[0]
+        pos += 2
+        
+        # Read optional origin handle if flag is set
+        origin_handle = None
+        if has_origin_handle_alt:
+            origin_handle = data[pos] & 0xFF
+            pos += 1
+            
+        # Extract payload length from header bits 0-5
+        payload_length = unsigned_short & 63
+        
+        header = {
+            'header_raw': unsigned_short,
+            'command_type': command_type,
+            'origin': origin,
+            'target': target,
+            'lifetime': lifetime,
+            'age': age,
+            'origin_handle': origin_handle,
+            'payload_length': payload_length,
+            'flags': {
+                'has_origin_handle': has_origin_handle,
+                'is_unique': is_unique,
+                'has_session': has_session,
+                'has_origin_handle_alt': has_origin_handle_alt,
+                'flag_1024': flag_1024
+            }
+        }
+        
+        return header, pos
+    
+    @staticmethod
+    def parse_switch_event(header: Dict[str, Any], payload: bytes) -> Optional[Dict[str, Any]]:
+        """
+        Parse switch event according to Android app logic (lines 271-280)
+        
+        The Android app checks:
+        - target & 0xFF == 6 (lower byte of target must be 6)
+        - command_type ordinal must be between 29-36 (FunctionButtonEvent0-7)
+        - payload must have at least 3 bytes
+        """
+        target_type = header['target'] & 0xFF
+        target_unit_id = header['target'] >> 8
+        command_type = header['command_type']
+        
+        # Check if this is a switch event
+        if target_type != 6:
+            return None
+            
+        # Check if command type is in range for button events (29-36)
+        if command_type < 29 or command_type > 36:
+            return None
+            
+        # Check payload length
+        if len(payload) < 3:
+            logger.warning(f"Switch event payload too short: {len(payload)} bytes")
+            return None
+            
+        # Parse according to Android logic
+        first_byte = payload[0]
+        button_index = command_type - 29  # 0-7
+        
+        # Extract parameters from first byte
+        param_p = (first_byte >> 3) & 15  # bits 3-6
+        param_s = first_byte & 7          # bits 0-2
+        state = 1 if (first_byte & 128) else 0  # bit 7
+        
+        return {
+            'unit_id': target_unit_id,
+            'button': button_index,
+            'state': state,  # 1 = pressed, 0 = released
+            'param_p': param_p,
+            'param_s': param_s,
+            'target_type': target_type,
+            'command_type': command_type,
+            'payload_hex': payload.hex(),
+            'android_log': f"Unit {target_unit_id} Switch event: #{button_index} (P{param_p} S{param_s}) = {state}"
+        }
+    
+    @staticmethod
+    def parse_complete_packet(data: bytes) -> Dict[str, Any]:
+        """Parse a complete packet and extract switch events if present"""
+        try:
+            header, payload_start = AndroidPacketParser.parse_packet_header(data)
+            
+            # Read payload
+            payload_length = header['payload_length']
+            if len(data) - payload_start < payload_length:
+                raise ValueError(f"Insufficient data for payload: need {payload_length}, have {len(data) - payload_start}")
+                
+            payload = data[payload_start:payload_start + payload_length]
+            
+            # Try to parse as switch event
+            switch_event = AndroidPacketParser.parse_switch_event(header, payload)
+            
+            return {
+                'header': header,
+                'payload': payload.hex(),
+                'switch_event': switch_event
+            }
+            
+        except Exception as e:
+            logger.error(f"Failed to parse packet: {e}")
+            return {'error': str(e), 'data': data.hex()}
+
+
+# Command type constants from EnumC1777d
+class FunctionType:
+    """Function type constants from Android app"""
+    BUTTON_EVENT_0 = 29
+    BUTTON_EVENT_1 = 30
+    BUTTON_EVENT_2 = 31
+    BUTTON_EVENT_3 = 32
+    BUTTON_EVENT_4 = 33
+    BUTTON_EVENT_5 = 34
+    BUTTON_EVENT_6 = 35
+    BUTTON_EVENT_7 = 36
+
+
+def compare_with_current_parser(data: bytes, current_parser_result: Dict[str, Any]) -> Dict[str, Any]:
+    """Compare Android parser results with current implementation"""
+    android_result = AndroidPacketParser.parse_complete_packet(data)
+    
+    comparison = {
+        'android_parser': android_result,
+        'current_parser': current_parser_result,
+        'differences': []
+    }
+    
+    # Compare results
+    if android_result.get('switch_event') and current_parser_result:
+        android_evt = android_result['switch_event']
+        
+        # Check unit_id
+        if android_evt['unit_id'] != current_parser_result.get('unit_id'):
+            comparison['differences'].append({
+                'field': 'unit_id',
+                'android': android_evt['unit_id'],
+                'current': current_parser_result.get('unit_id')
+            })
+            
+        # Check button
+        if android_evt['button'] != current_parser_result.get('button'):
+            comparison['differences'].append({
+                'field': 'button',
+                'android': android_evt['button'],
+                'current': current_parser_result.get('button')
+            })
+            
+        # Map Android state to current event names
+        android_event = 'button_press' if android_evt['state'] == 1 else 'button_release'
+        if android_event != current_parser_result.get('event'):
+            comparison['differences'].append({
+                'field': 'event',
+                'android': android_event,
+                'current': current_parser_result.get('event'),
+                'note': 'Android only has press/release, no hold detection'
+            })
+    
+    return comparison

CasambiBt/_network.py

@@ -382,6 +382,7 @@ class Network:
             unitTypeJson["mode"],
             unitTypeJson["stateLength"],
             controls,
+            unitTypeJson.get("pushButtonCount"),
         )
 
         # Chache unit type

CasambiBt/_unit.py

@@ -75,6 +75,7 @@ class UnitType:
     :ivar model: The model name of this unit type.
     :ivar manufacturer: The manufacturer of this unit type.
     :ivar controls: The different types of controls this unit type is capable of.
+    :ivar pushButtonCount: The number of push buttons this unit type has (optional).
     """
 
     id: int
@@ -83,6 +84,7 @@ class UnitType:
     mode: str
     stateLength: int
     controls: list[UnitControl]
+    pushButtonCount: int | None = None
 
     def get_control(self, controlType: UnitControlType) -> UnitControl | None:
         """Return the control description if the unit type supports the given type of control.
@@ -111,6 +113,7 @@ class UnitState:
         self._colorsource: ColorSource | None = None
         self._xy: tuple[float, float] | None = None
         self._slider: int | None = None
+        self._onoff: bool | None = None
 
     def _check_range(
         self, value: int | float, min: int | float, max: int | float
@@ -269,8 +272,20 @@ class UnitState:
     def slider(self) -> None:
         self.slider = None
 
+    @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})"
+        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)
@@ -308,6 +323,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 +402,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:
@@ -477,6 +496,8 @@ 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(

{casambi_bt_revamped-0.3.7.dev3.dist-info → casambi_bt_revamped-0.3.7.dev4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: casambi-bt-revamped
-Version: 0.3.7.dev3
+Version: 0.3.7.dev4
 Summary: Enhanced Casambi Bluetooth client library with switch event support
 Home-page: https://github.com/rankjie/casambi-bt
 Author: rankjie
@@ -46,7 +46,7 @@ Have a look at `demo.py` for a small example.
 
 ### Switch Event Support
 
-This library now supports receiving switch button events:
+This fork adds support for receiving switch button events:
 
 ```python
 from CasambiBt import Casambi

{casambi_bt_revamped-0.3.7.dev3.dist-info → casambi_bt_revamped-0.3.7.dev4.dist-info}/RECORD

@@ -1,18 +1,19 @@
 CasambiBt/__init__.py,sha256=TW445xSu5PV3TyMjJfwaA1JoWvQQ8LXhZgGdDTfWf3s,302
 CasambiBt/_cache.py,sha256=KZ2xbiHAHXUPa8Gw_75Nw9NL4QSY_sTWHbyYXYUDaB0,3865
-CasambiBt/_casambi.py,sha256=tQgmG-8lHbl4_FDS7NwPrucrqcQZd2kimcJa43TYFaw,23156
-CasambiBt/_client.py,sha256=2kHgkf3ERobTDF47ZMNSFl5WrEkWYgDSXfh6R6PsU0Q,28926
+CasambiBt/_casambi.py,sha256=gLLkhEcObgapqTx5Mk7WRClyG29UyfZYZCCIhhOg4H4,23101
+CasambiBt/_client.py,sha256=8a1sYxvuNStb7ldgeEHDFyonPIfPTIjFtqZQIbDo62U,30511
+CasambiBt/_client_android_parser.py,sha256=1lVkVYMO0Nhh9_nkNwgb68hlCS_uD8WxYQDir5hOdHs,7744
 CasambiBt/_constants.py,sha256=_AxkG7Btxl4VeS6mO7GJW5Kc9dFs3s9sDmtJ83ZEKNw,359
 CasambiBt/_discover.py,sha256=H7HpiFYIy9ELvmPXXd_ck-5O5invJf15dDIRk-vO5IE,1696
 CasambiBt/_encryption.py,sha256=CLcoOOrggQqhJbnr_emBnEnkizpWDvb_0yFnitq4_FM,3831
 CasambiBt/_keystore.py,sha256=Jdiq0zMPDmhfpheSojKY6sTUpmVrvX_qOyO7yCYd3kw,2788
-CasambiBt/_network.py,sha256=qcsWn_EsBexzXCv14JcpSIymhuR6Eaf479lZdzpfYBM,14417
+CasambiBt/_network.py,sha256=B5uVDrfwFKZ3UQgf5THUwasBxh1nzl7KJlq9CqoIyqU,14466
 CasambiBt/_operation.py,sha256=-BuC1Bvtg-G-zSN_b_0JMvXdHZaR6LbTw0S425jg96c,842
-CasambiBt/_unit.py,sha256=M-Q8-Xd3qjJSUEvsFtic8E4xDc_gtWYakbTGyoIA-P8,16377
+CasambiBt/_unit.py,sha256=B1ce5MaNdoF9ljHAhoiRfV1Tn6CBM4oD3OPDmShIMm8,17167
 CasambiBt/errors.py,sha256=0JgDjaKlAKDes0poWzA8nrTUYQ8qdNfBb8dfaqqzCRA,1664
 CasambiBt/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-casambi_bt_revamped-0.3.7.dev3.dist-info/licenses/LICENSE,sha256=TAIIitFxpxEDi6Iju7foW4TDQmWvC-IhLVLhl67jKmQ,11341
-casambi_bt_revamped-0.3.7.dev3.dist-info/METADATA,sha256=grmzh3IRXluM845lDfwqMJHeP-2QlqslRyOI-wlebAk,3048
-casambi_bt_revamped-0.3.7.dev3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-casambi_bt_revamped-0.3.7.dev3.dist-info/top_level.txt,sha256=uNbqLjtecFosoFzpGAC89-5icikWODKI8rOjbi8v_sA,10
-casambi_bt_revamped-0.3.7.dev3.dist-info/RECORD,,
+casambi_bt_revamped-0.3.7.dev4.dist-info/licenses/LICENSE,sha256=TAIIitFxpxEDi6Iju7foW4TDQmWvC-IhLVLhl67jKmQ,11341
+casambi_bt_revamped-0.3.7.dev4.dist-info/METADATA,sha256=7DgCkhLn7OMDycRzDzB7EevVTt1gZqnGr5UVCvbemZo,3049
+casambi_bt_revamped-0.3.7.dev4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+casambi_bt_revamped-0.3.7.dev4.dist-info/top_level.txt,sha256=uNbqLjtecFosoFzpGAC89-5icikWODKI8rOjbi8v_sA,10
+casambi_bt_revamped-0.3.7.dev4.dist-info/RECORD,,