bumble 0.0.222__py3-none-any.whl → 0.0.223__py3-none-any.whl

bumble/hci.py

@@ -2090,9 +2090,9 @@ class Address:
     RANDOM_IDENTITY_ADDRESS = AddressType.RANDOM_IDENTITY
 
     # Type declarations
-    NIL: Address
-    ANY: Address
-    ANY_RANDOM: Address
+    NIL: ClassVar[Address]
+    ANY: ClassVar[Address]
+    ANY_RANDOM: ClassVar[Address]
 
     # pylint: disable-next=unnecessary-lambda
     ADDRESS_TYPE_SPEC = {'size': 1, 'mapper': lambda x: Address.address_type_name(x)}
@@ -2204,38 +2204,38 @@ class Address:
 
         self.address_type = address_type
 
-    def clone(self):
+    def clone(self) -> Address:
         return Address(self.address_bytes, self.address_type)
 
     @property
-    def is_public(self):
+    def is_public(self) -> bool:
         return self.address_type in (
             self.PUBLIC_DEVICE_ADDRESS,
             self.PUBLIC_IDENTITY_ADDRESS,
         )
 
     @property
-    def is_random(self):
+    def is_random(self) -> bool:
         return not self.is_public
 
     @property
-    def is_resolved(self):
+    def is_resolved(self) -> bool:
         return self.address_type in (
             self.PUBLIC_IDENTITY_ADDRESS,
             self.RANDOM_IDENTITY_ADDRESS,
         )
 
     @property
-    def is_resolvable(self):
+    def is_resolvable(self) -> bool:
         return self.address_type == self.RANDOM_DEVICE_ADDRESS and (
             self.address_bytes[5] >> 6 == 1
         )
 
     @property
-    def is_static(self):
+    def is_static(self) -> bool:
         return self.is_random and (self.address_bytes[5] >> 6 == 3)
 
-    def to_string(self, with_type_qualifier=True):
+    def to_string(self, with_type_qualifier: bool = True) -> str:
         '''
         String representation of the address, MSB first, with an optional type
         qualifier.
@@ -2245,23 +2245,23 @@ class Address:
             return result
         return result + '/P'
 
-    def __bytes__(self):
+    def __bytes__(self) -> bytes:
         return self.address_bytes
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         return hash(self.address_bytes)
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any) -> bool:
         return (
             isinstance(other, Address)
             and self.address_bytes == other.address_bytes
             and self.is_public == other.is_public
         )
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.to_string()
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f'Address({self.to_string(False)}/{self.address_type_name(self.address_type)})'
 
 
@@ -2300,10 +2300,10 @@ class HCI_Packet:
     Abstract Base class for HCI packets
     '''
 
-    hci_packet_type: ClassVar[int]
+    hci_packet_type: int
 
-    @staticmethod
-    def from_bytes(packet: bytes) -> HCI_Packet:
+    @classmethod
+    def from_bytes(cls, packet: bytes) -> HCI_Packet:
         packet_type = packet[0]
 
         if packet_type == HCI_COMMAND_PACKET:
@@ -2323,7 +2323,7 @@ class HCI_Packet:
 
         return HCI_CustomPacket(packet)
 
-    def __init__(self, name):
+    def __init__(self, name: str) -> None:
         self.name = name
 
     def __bytes__(self) -> bytes:
@@ -2335,7 +2335,7 @@ class HCI_Packet:
 
 # -----------------------------------------------------------------------------
 class HCI_CustomPacket(HCI_Packet):
-    def __init__(self, payload):
+    def __init__(self, payload: bytes) -> None:
         super().__init__('HCI_CUSTOM_PACKET')
         self.hci_packet_type = payload[0]
         self.payload = payload
@@ -7452,6 +7452,7 @@ class HCI_Vendor_Event(HCI_Event):
 
 
 # -----------------------------------------------------------------------------
+@dataclasses.dataclass
 class HCI_AclDataPacket(HCI_Packet):
     '''
     See Bluetooth spec @ 5.4.2 HCI ACL Data Packets
@@ -7459,8 +7460,14 @@ class HCI_AclDataPacket(HCI_Packet):
 
     hci_packet_type = HCI_ACL_DATA_PACKET
 
-    @staticmethod
-    def from_bytes(packet: bytes) -> HCI_AclDataPacket:
+    connection_handle: int
+    pb_flag: int
+    bc_flag: int
+    data_total_length: int
+    data: bytes
+
+    @classmethod
+    def from_bytes(cls, packet: bytes) -> HCI_AclDataPacket:
         # Read the header
         h, data_total_length = struct.unpack_from('<HH', packet, 1)
         connection_handle = h & 0xFFF
@@ -7469,25 +7476,22 @@ class HCI_AclDataPacket(HCI_Packet):
         data = packet[5:]
         if len(data) != data_total_length:
             raise InvalidPacketError('invalid packet length')
-        return HCI_AclDataPacket(
-            connection_handle, pb_flag, bc_flag, data_total_length, data
+        return cls(
+            connection_handle=connection_handle,
+            pb_flag=pb_flag,
+            bc_flag=bc_flag,
+            data_total_length=data_total_length,
+            data=data,
         )
 
-    def __bytes__(self):
+    def __bytes__(self) -> bytes:
         h = (self.pb_flag << 12) | (self.bc_flag << 14) | self.connection_handle
         return (
             struct.pack('<BHH', HCI_ACL_DATA_PACKET, h, self.data_total_length)
             + self.data
         )
 
-    def __init__(self, connection_handle, pb_flag, bc_flag, data_total_length, data):
-        self.connection_handle = connection_handle
-        self.pb_flag = pb_flag
-        self.bc_flag = bc_flag
-        self.data_total_length = data_total_length
-        self.data = data
-
-    def __str__(self):
+    def __str__(self) -> str:
         return (
             f'{color("ACL", "blue")}: '
             f'handle=0x{self.connection_handle:04x}, '
@@ -7498,6 +7502,7 @@ class HCI_AclDataPacket(HCI_Packet):
 
 
 # -----------------------------------------------------------------------------
+@dataclasses.dataclass
 class HCI_SynchronousDataPacket(HCI_Packet):
     '''
     See Bluetooth spec @ 5.4.3 HCI SCO Data Packets
@@ -7505,8 +7510,13 @@ class HCI_SynchronousDataPacket(HCI_Packet):
 
     hci_packet_type = HCI_SYNCHRONOUS_DATA_PACKET
 
-    @staticmethod
-    def from_bytes(packet: bytes) -> HCI_SynchronousDataPacket:
+    connection_handle: int
+    packet_status: int
+    data_total_length: int
+    data: bytes
+
+    @classmethod
+    def from_bytes(cls, packet: bytes) -> HCI_SynchronousDataPacket:
         # Read the header
         h, data_total_length = struct.unpack_from('<HB', packet, 1)
         connection_handle = h & 0xFFF
@@ -7516,8 +7526,11 @@ class HCI_SynchronousDataPacket(HCI_Packet):
             raise InvalidPacketError(
                 f'invalid packet length {len(data)} != {data_total_length}'
             )
-        return HCI_SynchronousDataPacket(
-            connection_handle, packet_status, data_total_length, data
+        return cls(
+            connection_handle=connection_handle,
+            packet_status=packet_status,
+            data_total_length=data_total_length,
+            data=data,
         )
 
     def __bytes__(self) -> bytes:
@@ -7527,18 +7540,6 @@ class HCI_SynchronousDataPacket(HCI_Packet):
             + self.data
         )
 
-    def __init__(
-        self,
-        connection_handle: int,
-        packet_status: int,
-        data_total_length: int,
-        data: bytes,
-    ) -> None:
-        self.connection_handle = connection_handle
-        self.packet_status = packet_status
-        self.data_total_length = data_total_length
-        self.data = data
-
     def __str__(self) -> str:
         return (
             f'{color("SCO", "blue")}: '
@@ -7556,7 +7557,7 @@ class HCI_IsoDataPacket(HCI_Packet):
     See Bluetooth spec @ 5.4.5 HCI ISO Data Packets
     '''
 
-    hci_packet_type: ClassVar[int] = HCI_ISO_DATA_PACKET
+    hci_packet_type = HCI_ISO_DATA_PACKET
 
     connection_handle: int
     data_total_length: int

bumble/hid.py

@@ -312,11 +312,11 @@ class HID(ABC, utils.EventEmitter):
 
     def send_pdu_on_ctrl(self, msg: bytes) -> None:
         assert self.l2cap_ctrl_channel
-        self.l2cap_ctrl_channel.send_pdu(msg)
+        self.l2cap_ctrl_channel.write(msg)
 
     def send_pdu_on_intr(self, msg: bytes) -> None:
         assert self.l2cap_intr_channel
-        self.l2cap_intr_channel.send_pdu(msg)
+        self.l2cap_intr_channel.write(msg)
 
     def send_data(self, data: bytes) -> None:
         if self.role == HID.Role.HOST:

bumble/host.py

@@ -732,6 +732,16 @@ class Host(utils.EventEmitter):
             )
             packet_queue.enqueue(acl_packet, connection_handle)
 
+    def send_sco_sdu(self, connection_handle: int, sdu: bytes) -> None:
+        self.send_hci_packet(
+            hci.HCI_SynchronousDataPacket(
+                connection_handle=connection_handle,
+                packet_status=0,
+                data_total_length=len(sdu),
+                data=sdu,
+            )
+        )
+
     def send_l2cap_pdu(self, connection_handle: int, cid: int, pdu: bytes) -> None:
         self.send_acl_sdu(connection_handle, bytes(L2CAP_PDU(cid, pdu)))
 

bumble/l2cap.py

@@ -1647,7 +1647,9 @@ class LeCreditBasedChannel(utils.EventEmitter):
         self.connection_result = None
         self.disconnection_result = None
         self.drained = asyncio.Event()
-        self.att_mtu = 0  # Filled by GATT client or server later.
+        # Core Specification Vol 3, Part G, 5.3.1 ATT_MTU
+        # ATT_MTU shall be set to the minimum of the MTU field values of the two devices.
+        self.att_mtu = min(mtu, peer_mtu)
 
         self.drained.set()
 

bumble/pandora/l2cap.py

@@ -278,7 +278,7 @@ class L2CAPService(L2CAPServicer):
             if not l2cap_channel:
                 return SendResponse(error=COMMAND_NOT_UNDERSTOOD)
             if isinstance(l2cap_channel, ClassicChannel):
-                l2cap_channel.send_pdu(request.data)
+                l2cap_channel.write(request.data)
             else:
                 l2cap_channel.write(request.data)
             return SendResponse(success=empty_pb2.Empty())

bumble/profiles/battery_service.py

@@ -16,35 +16,28 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
+from collections.abc import Callable
 
-from bumble.gatt import (
-    GATT_BATTERY_LEVEL_CHARACTERISTIC,
-    GATT_BATTERY_SERVICE,
-    Characteristic,
-    CharacteristicValue,
-    TemplateService,
-)
-from bumble.gatt_adapters import (
-    PackedCharacteristicAdapter,
-    PackedCharacteristicProxyAdapter,
-)
-from bumble.gatt_client import CharacteristicProxy, ProfileServiceProxy
+from bumble import device, gatt, gatt_adapters, gatt_client
 
 
 # -----------------------------------------------------------------------------
-class BatteryService(TemplateService):
-    UUID = GATT_BATTERY_SERVICE
+class BatteryService(gatt.TemplateService):
+    UUID = gatt.GATT_BATTERY_SERVICE
     BATTERY_LEVEL_FORMAT = 'B'
 
-    battery_level_characteristic: Characteristic[int]
-
-    def __init__(self, read_battery_level):
-        self.battery_level_characteristic = PackedCharacteristicAdapter(
-            Characteristic(
-                GATT_BATTERY_LEVEL_CHARACTERISTIC,
-                Characteristic.Properties.READ | Characteristic.Properties.NOTIFY,
-                Characteristic.READABLE,
-                CharacteristicValue(read=read_battery_level),
+    battery_level_characteristic: gatt.Characteristic[int]
+
+    def __init__(self, read_battery_level: Callable[[device.Connection], int]) -> None:
+        self.battery_level_characteristic = gatt_adapters.PackedCharacteristicAdapter(
+            gatt.Characteristic(
+                gatt.GATT_BATTERY_LEVEL_CHARACTERISTIC,
+                properties=(
+                    gatt.Characteristic.Properties.READ
+                    | gatt.Characteristic.Properties.NOTIFY
+                ),
+                permissions=gatt.Characteristic.READABLE,
+                value=gatt.CharacteristicValue(read=read_battery_level),
             ),
             pack_format=BatteryService.BATTERY_LEVEL_FORMAT,
         )
@@ -52,19 +45,17 @@ class BatteryService(TemplateService):
 
 
 # -----------------------------------------------------------------------------
-class BatteryServiceProxy(ProfileServiceProxy):
+class BatteryServiceProxy(gatt_client.ProfileServiceProxy):
     SERVICE_CLASS = BatteryService
 
-    battery_level: CharacteristicProxy[int] | None
+    battery_level: gatt_client.CharacteristicProxy[int]
 
-    def __init__(self, service_proxy):
+    def __init__(self, service_proxy: gatt_client.ServiceProxy) -> None:
         self.service_proxy = service_proxy
 
-        if characteristics := service_proxy.get_characteristics_by_uuid(
-            GATT_BATTERY_LEVEL_CHARACTERISTIC
-        ):
-            self.battery_level = PackedCharacteristicProxyAdapter(
-                characteristics[0], pack_format=BatteryService.BATTERY_LEVEL_FORMAT
-            )
-        else:
-            self.battery_level = None
+        self.battery_level = gatt_adapters.PackedCharacteristicProxyAdapter(
+            service_proxy.get_required_characteristic_by_uuid(
+                gatt.GATT_BATTERY_LEVEL_CHARACTERISTIC
+            ),
+            pack_format=BatteryService.BATTERY_LEVEL_FORMAT,
+        )