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

bumble/drivers/__init__.py

@@ -24,7 +24,8 @@ from __future__ import annotations
 import logging
 import pathlib
 import platform
-from typing import TYPE_CHECKING, Iterable, Optional
+from collections.abc import Iterable
+from typing import TYPE_CHECKING
 
 from bumble.drivers import intel, rtk
 from bumble.drivers.common import Driver
@@ -41,7 +42,7 @@ logger = logging.getLogger(__name__)
 # -----------------------------------------------------------------------------
 # Functions
 # -----------------------------------------------------------------------------
-async def get_driver_for_host(host: Host) -> Optional[Driver]:
+async def get_driver_for_host(host: Host) -> Driver | None:
     """Probe diver classes until one returns a valid instance for a host, or none is
     found.
     If a "driver" HCI metadata entry is present, only that driver class will be probed.

bumble/drivers/intel.py

@@ -29,7 +29,7 @@ import os
 import pathlib
 import platform
 import struct
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from bumble import core, hci, utils
 from bumble.drivers import common
@@ -353,8 +353,8 @@ class Driver(common.Driver):
         self.reset_complete = asyncio.Event()
 
         # Parse configuration options from the driver name.
-        self.ddc_addon: Optional[bytes] = None
-        self.ddc_override: Optional[bytes] = None
+        self.ddc_addon: bytes | None = None
+        self.ddc_override: bytes | None = None
         driver = host.hci_metadata.get("driver")
         if driver is not None and driver.startswith("intel/"):
             for key, value in [
@@ -380,7 +380,7 @@ class Driver(common.Driver):
 
         if (vendor_id, product_id) not in INTEL_USB_PRODUCTS:
             logger.debug(
-                f"USB device ({vendor_id:04X}, {product_id:04X}) " "not in known list"
+                f"USB device ({vendor_id:04X}, {product_id:04X}) not in known list"
             )
             return False
 
@@ -483,9 +483,7 @@ class Driver(common.Driver):
             raise DriverError("insufficient device info, missing CNVI or CNVR")
 
         firmware_base_name = (
-            "ibt-"
-            f"{device_info[ValueType.CNVI]:04X}-"
-            f"{device_info[ValueType.CNVR]:04X}"
+            f"ibt-{device_info[ValueType.CNVI]:04X}-{device_info[ValueType.CNVR]:04X}"
         )
         logger.debug(f"FW base name: {firmware_base_name}")
 
@@ -604,7 +602,7 @@ class Driver(common.Driver):
 
         await self.load_ddc_if_any(firmware_base_name)
 
-    async def load_ddc_if_any(self, firmware_base_name: Optional[str] = None) -> None:
+    async def load_ddc_if_any(self, firmware_base_name: str | None = None) -> None:
         """
         Check for and load any Device Data Configuration (DDC) blobs.
 

bumble/drivers/rtk.py

@@ -484,7 +484,7 @@ class Driver(common.Driver):
 
         if (vendor_id, product_id) not in RTK_USB_PRODUCTS:
             logger.debug(
-                f"USB device ({vendor_id:04X}, {product_id:04X}) " "not in known list"
+                f"USB device ({vendor_id:04X}, {product_id:04X}) not in known list"
             )
             return False
 

bumble/gatt.py

@@ -28,9 +28,10 @@ import enum
 import functools
 import logging
 import struct
-from typing import Iterable, Optional, Sequence, TypeVar, Union
+from collections.abc import Iterable, Sequence
+from typing import TypeVar
 
-from bumble.att import Attribute, AttributeValue
+from bumble.att import Attribute, AttributeValue, AttributeValueV2
 from bumble.colors import color
 from bumble.core import UUID, BaseBumbleError
 
@@ -227,7 +228,6 @@ GATT_MEDIA_CONTROL_POINT_CHARACTERISTIC                   = UUID.from_16_bits(0x
 GATT_MEDIA_CONTROL_POINT_OPCODES_SUPPORTED_CHARACTERISTIC = UUID.from_16_bits(0x2BA5, 'Media Control Point Opcodes Supported')
 GATT_SEARCH_RESULTS_OBJECT_ID_CHARACTERISTIC              = UUID.from_16_bits(0x2BA6, 'Search Results Object ID')
 GATT_SEARCH_CONTROL_POINT_CHARACTERISTIC                  = UUID.from_16_bits(0x2BA7, 'Search Control Point')
-GATT_CONTENT_CONTROL_ID_CHARACTERISTIC                    = UUID.from_16_bits(0x2BBA, 'Content Control Id')
 
 # Telephone Bearer Service (TBS)
 GATT_BEARER_PROVIDER_NAME_CHARACTERISTIC                      = UUID.from_16_bits(0x2BB3, 'Bearer Provider Name')
@@ -356,7 +356,7 @@ class Service(Attribute):
 
     def __init__(
         self,
-        uuid: Union[str, UUID],
+        uuid: str | UUID,
         characteristics: Iterable[Characteristic],
         primary=True,
         included_services: Iterable[Service] = (),
@@ -379,7 +379,7 @@ class Service(Attribute):
         self.characteristics = list(characteristics)
         self.primary = primary
 
-    def get_advertising_data(self) -> Optional[bytes]:
+    def get_advertising_data(self) -> bytes | None:
         """
         Get Service specific advertising data
         Defined by each Service, default value is empty
@@ -503,10 +503,10 @@ class Characteristic(Attribute[_T]):
 
     def __init__(
         self,
-        uuid: Union[str, bytes, UUID],
+        uuid: str | bytes | UUID,
         properties: Characteristic.Properties,
-        permissions: Union[str, Attribute.Permissions],
-        value: Union[AttributeValue[_T], _T, None] = None,
+        permissions: str | Attribute.Permissions,
+        value: AttributeValue[_T] | _T | None = None,
         descriptors: Sequence[Descriptor] = (),
     ):
         super().__init__(uuid, permissions, value)
@@ -579,7 +579,7 @@ class Descriptor(Attribute):
     def __str__(self) -> str:
         if isinstance(self.value, bytes):
             value_str = self.value.hex()
-        elif isinstance(self.value, CharacteristicValue):
+        elif isinstance(self.value, (AttributeValue, AttributeValueV2)):
             value_str = '<dynamic>'
         else:
             value_str = '<...>'

bumble/gatt_adapters.py

@@ -22,7 +22,8 @@
 from __future__ import annotations
 
 import struct
-from typing import Any, Callable, Generic, Iterable, Literal, Optional, TypeVar
+from collections.abc import Callable, Iterable
+from typing import Any, Generic, Literal, TypeVar
 
 from bumble import utils
 from bumble.core import InvalidOperationError
@@ -74,8 +75,8 @@ class DelegatedCharacteristicAdapter(CharacteristicAdapter[_T]):
     def __init__(
         self,
         characteristic: Characteristic,
-        encode: Optional[Callable[[_T], bytes]] = None,
-        decode: Optional[Callable[[bytes], _T]] = None,
+        encode: Callable[[_T], bytes] | None = None,
+        decode: Callable[[bytes], _T] | None = None,
     ):
         super().__init__(characteristic)
         self.encode = encode
@@ -101,8 +102,8 @@ class DelegatedCharacteristicProxyAdapter(CharacteristicProxyAdapter[_T]):
     def __init__(
         self,
         characteristic_proxy: CharacteristicProxy,
-        encode: Optional[Callable[[_T], bytes]] = None,
-        decode: Optional[Callable[[bytes], _T]] = None,
+        encode: Callable[[_T], bytes] | None = None,
+        decode: Callable[[bytes], _T] | None = None,
     ):
         super().__init__(characteristic_proxy)
         self.encode = encode
@@ -361,5 +362,4 @@ class EnumCharacteristicProxyAdapter(CharacteristicProxyAdapter[_T3]):
 
     def decode_value(self, value: bytes) -> _T3:
         int_value = int.from_bytes(value, self.byteorder)
-        a = self.cls(int_value)
         return self.cls(int_value)

bumble/gatt_client.py

@@ -26,21 +26,20 @@
 from __future__ import annotations
 
 import asyncio
+import functools
 import logging
 import struct
+from collections.abc import Callable, Iterable
 from datetime import datetime
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
     Generic,
-    Iterable,
-    Optional,
     TypeVar,
-    Union,
+    overload,
 )
 
-from bumble import att, core, utils
+from bumble import att, core, l2cap, utils
 from bumble.colors import color
 from bumble.core import UUID, InvalidStateError
 from bumble.gatt import (
@@ -57,12 +56,12 @@ from bumble.gatt import (
 )
 from bumble.hci import HCI_Constant
 
+if TYPE_CHECKING:
+    from bumble import device as device_module
+
 # -----------------------------------------------------------------------------
 # Typing
 # -----------------------------------------------------------------------------
-if TYPE_CHECKING:
-    from bumble.device import Connection
-
 _T = TypeVar('_T')
 
 # -----------------------------------------------------------------------------
@@ -192,7 +191,7 @@ class CharacteristicProxy(AttributeProxy[_T]):
         self.descriptors_discovered = False
         self.subscribers = {}  # Map from subscriber to proxy subscriber
 
-    def get_descriptor(self, descriptor_type: UUID) -> Optional[DescriptorProxy]:
+    def get_descriptor(self, descriptor_type: UUID) -> DescriptorProxy | None:
         for descriptor in self.descriptors:
             if descriptor.type == descriptor_type:
                 return descriptor
@@ -204,7 +203,7 @@ class CharacteristicProxy(AttributeProxy[_T]):
 
     async def subscribe(
         self,
-        subscriber: Optional[Callable[[_T], Any]] = None,
+        subscriber: Callable[[_T], Any] | None = None,
         prefer_notify: bool = True,
     ) -> None:
         if subscriber is not None:
@@ -253,7 +252,7 @@ class ProfileServiceProxy:
     SERVICE_CLASS: type[TemplateService]
 
     @classmethod
-    def from_client(cls, client: Client) -> Optional[ProfileServiceProxy]:
+    def from_client(cls, client: Client) -> ProfileServiceProxy | None:
         return ServiceProxy.from_client(cls, client, cls.SERVICE_CLASS.UUID)
 
 
@@ -264,16 +263,14 @@ class Client:
     services: list[ServiceProxy]
     cached_values: dict[int, tuple[datetime, bytes]]
     notification_subscribers: dict[
-        int, set[Union[CharacteristicProxy, Callable[[bytes], Any]]]
+        int, set[CharacteristicProxy | Callable[[bytes], Any]]
     ]
-    indication_subscribers: dict[
-        int, set[Union[CharacteristicProxy, Callable[[bytes], Any]]]
-    ]
-    pending_response: Optional[asyncio.futures.Future[att.ATT_PDU]]
-    pending_request: Optional[att.ATT_PDU]
+    indication_subscribers: dict[int, set[CharacteristicProxy | Callable[[bytes], Any]]]
+    pending_response: asyncio.futures.Future[att.ATT_PDU] | None
+    pending_request: att.ATT_PDU | None
 
-    def __init__(self, connection: Connection) -> None:
-        self.connection = connection
+    def __init__(self, bearer: att.Bearer) -> None:
+        self.bearer = bearer
         self.mtu_exchange_done = False
         self.request_semaphore = asyncio.Semaphore(1)
         self.pending_request = None
@@ -283,21 +280,78 @@ class Client:
         self.services = []
         self.cached_values = {}
 
-        connection.on(connection.EVENT_DISCONNECTION, self.on_disconnection)
+        if att.is_enhanced_bearer(bearer):
+            bearer.on(bearer.EVENT_CLOSE, self.on_disconnection)
+            self._bearer_id = (
+                f'[0x{bearer.connection.handle:04X}|CID=0x{bearer.source_cid:04X}]'
+            )
+            # Fill the mtu.
+            bearer.on_att_mtu_update(att.ATT_DEFAULT_MTU)
+            self.connection = bearer.connection
+        else:
+            bearer.on(bearer.EVENT_DISCONNECTION, self.on_disconnection)
+            self._bearer_id = f'[0x{bearer.handle:04X}]'
+            self.connection = bearer
+
+    @overload
+    @classmethod
+    async def connect_eatt(
+        cls,
+        connection: device_module.Connection,
+        spec: l2cap.LeCreditBasedChannelSpec | None = None,
+    ) -> Client: ...
+
+    @overload
+    @classmethod
+    async def connect_eatt(
+        cls,
+        connection: device_module.Connection,
+        spec: l2cap.LeCreditBasedChannelSpec | None = None,
+        count: int = 1,
+    ) -> list[Client]: ...
+
+    @classmethod
+    async def connect_eatt(
+        cls,
+        connection: device_module.Connection,
+        spec: l2cap.LeCreditBasedChannelSpec | None = None,
+        count: int = 1,
+    ) -> list[Client] | Client:
+        channels = await connection.device.l2cap_channel_manager.create_enhanced_credit_based_channels(
+            connection,
+            spec or l2cap.LeCreditBasedChannelSpec(psm=att.EATT_PSM),
+            count,
+        )
+
+        def on_pdu(client: Client, pdu: bytes):
+            client.on_gatt_pdu(att.ATT_PDU.from_bytes(pdu))
+
+        clients = [cls(channel) for channel in channels]
+        for channel, client in zip(channels, clients):
+            channel.sink = functools.partial(on_pdu, client)
+            channel.att_mtu = att.ATT_DEFAULT_MTU
+        return clients[0] if count == 1 else clients
+
+    @property
+    def mtu(self) -> int:
+        return self.bearer.att_mtu
+
+    @mtu.setter
+    def mtu(self, value: int) -> None:
+        self.bearer.on_att_mtu_update(value)
 
     def send_gatt_pdu(self, pdu: bytes) -> None:
-        self.connection.send_l2cap_pdu(att.ATT_CID, pdu)
+        if att.is_enhanced_bearer(self.bearer):
+            self.bearer.write(pdu)
+        else:
+            self.bearer.send_l2cap_pdu(att.ATT_CID, pdu)
 
     async def send_command(self, command: att.ATT_PDU) -> None:
-        logger.debug(
-            f'GATT Command from client: [0x{self.connection.handle:04X}] {command}'
-        )
+        logger.debug(f'GATT Command from client: {self._bearer_id} {command}')
         self.send_gatt_pdu(bytes(command))
 
     async def send_request(self, request: att.ATT_PDU):
-        logger.debug(
-            f'GATT Request from client: [0x{self.connection.handle:04X}] {request}'
-        )
+        logger.debug(f'GATT Request from client: {self._bearer_id} {request}')
 
         # Wait until we can send (only one pending command at a time for the connection)
         response = None
@@ -326,10 +380,7 @@ class Client:
     def send_confirmation(
         self, confirmation: att.ATT_Handle_Value_Confirmation
     ) -> None:
-        logger.debug(
-            f'GATT Confirmation from client: [0x{self.connection.handle:04X}] '
-            f'{confirmation}'
-        )
+        logger.debug(f'GATT Confirmation from client: {self._bearer_id} {confirmation}')
         self.send_gatt_pdu(bytes(confirmation))
 
     async def request_mtu(self, mtu: int) -> int:
@@ -341,7 +392,7 @@ class Client:
 
         # We can only send one request per connection
         if self.mtu_exchange_done:
-            return self.connection.att_mtu
+            return self.mtu
 
         # Send the request
         self.mtu_exchange_done = True
@@ -352,15 +403,15 @@ class Client:
             raise att.ATT_Error(error_code=response.error_code, message=response)
 
         # Compute the final MTU
-        self.connection.att_mtu = min(mtu, response.server_rx_mtu)
+        self.mtu = min(mtu, response.server_rx_mtu)
 
-        return self.connection.att_mtu
+        return self.mtu
 
     def get_services_by_uuid(self, uuid: UUID) -> list[ServiceProxy]:
         return [service for service in self.services if service.uuid == uuid]
 
     def get_characteristics_by_uuid(
-        self, uuid: UUID, service: Optional[ServiceProxy] = None
+        self, uuid: UUID, service: ServiceProxy | None = None
     ) -> list[CharacteristicProxy[bytes]]:
         services = [service] if service else self.services
         return [
@@ -369,13 +420,14 @@ class Client:
             if c.uuid == uuid
         ]
 
-    def get_attribute_grouping(self, attribute_handle: int) -> Optional[
-        Union[
-            ServiceProxy,
-            tuple[ServiceProxy, CharacteristicProxy],
-            tuple[ServiceProxy, CharacteristicProxy, DescriptorProxy],
-        ]
-    ]:
+    def get_attribute_grouping(
+        self, attribute_handle: int
+    ) -> (
+        ServiceProxy
+        | tuple[ServiceProxy, CharacteristicProxy]
+        | tuple[ServiceProxy, CharacteristicProxy, DescriptorProxy]
+        | None
+    ):
         """
         Get the attribute(s) associated with an attribute handle
         """
@@ -478,7 +530,7 @@ class Client:
 
         return services
 
-    async def discover_service(self, uuid: Union[str, UUID]) -> list[ServiceProxy]:
+    async def discover_service(self, uuid: str | UUID) -> list[ServiceProxy]:
         '''
         See Vol 3, Part G - 4.4.2 Discover Primary Service by Service UUID
         '''
@@ -612,7 +664,7 @@ class Client:
         return included_services
 
     async def discover_characteristics(
-        self, uuids, service: Optional[ServiceProxy]
+        self, uuids, service: ServiceProxy | None
     ) -> list[CharacteristicProxy[bytes]]:
         '''
         See Vol 3, Part G - 4.6.1 Discover All Characteristics of a Service and 4.6.2
@@ -699,9 +751,9 @@ class Client:
 
     async def discover_descriptors(
         self,
-        characteristic: Optional[CharacteristicProxy] = None,
-        start_handle: Optional[int] = None,
-        end_handle: Optional[int] = None,
+        characteristic: CharacteristicProxy | None = None,
+        start_handle: int | None = None,
+        end_handle: int | None = None,
     ) -> list[DescriptorProxy]:
         '''
         See Vol 3, Part G - 4.7.1 Discover All Characteristic Descriptors
@@ -810,7 +862,7 @@ class Client:
     async def subscribe(
         self,
         characteristic: CharacteristicProxy,
-        subscriber: Optional[Callable[[Any], Any]] = None,
+        subscriber: Callable[[Any], Any] | None = None,
         prefer_notify: bool = True,
     ) -> None:
         # If we haven't already discovered the descriptors for this characteristic,
@@ -860,7 +912,7 @@ class Client:
     async def unsubscribe(
         self,
         characteristic: CharacteristicProxy,
-        subscriber: Optional[Callable[[Any], Any]] = None,
+        subscriber: Callable[[Any], Any] | None = None,
         force: bool = False,
     ) -> None:
         '''
@@ -925,7 +977,7 @@ class Client:
             await self.write_value(cccd, b'\x00\x00', with_response=True)
 
     async def read_value(
-        self, attribute: Union[int, AttributeProxy], no_long_read: bool = False
+        self, attribute: int | AttributeProxy, no_long_read: bool = False
     ) -> bytes:
         '''
         See Vol 3, Part G - 4.8.1 Read Characteristic Value
@@ -946,7 +998,7 @@ class Client:
         # If the value is the max size for the MTU, try to read more unless the caller
         # specifically asked not to do that
         attribute_value = response.attribute_value
-        if not no_long_read and len(attribute_value) == self.connection.att_mtu - 1:
+        if not no_long_read and len(attribute_value) == self.mtu - 1:
             logger.debug('using READ BLOB to get the rest of the value')
             offset = len(attribute_value)
             while True:
@@ -970,7 +1022,7 @@ class Client:
                 part = response.part_attribute_value
                 attribute_value += part
 
-                if len(part) < self.connection.att_mtu - 1:
+                if len(part) < self.mtu - 1:
                     break
 
                 offset += len(part)
@@ -980,7 +1032,7 @@ class Client:
         return attribute_value
 
     async def read_characteristics_by_uuid(
-        self, uuid: UUID, service: Optional[ServiceProxy]
+        self, uuid: UUID, service: ServiceProxy | None
     ) -> list[bytes]:
         '''
         See Vol 3, Part G - 4.8.2 Read Using Characteristic UUID
@@ -1038,7 +1090,7 @@ class Client:
 
     async def write_value(
         self,
-        attribute: Union[int, AttributeProxy],
+        attribute: int | AttributeProxy,
         value: bytes,
         with_response: bool = False,
     ) -> None:
@@ -1066,14 +1118,13 @@ class Client:
                 )
             )
 
-    def on_disconnection(self, _) -> None:
+    def on_disconnection(self, *args) -> None:
+        del args  # unused.
         if self.pending_response and not self.pending_response.done():
             self.pending_response.cancel()
 
     def on_gatt_pdu(self, att_pdu: att.ATT_PDU) -> None:
-        logger.debug(
-            f'GATT Response to client: [0x{self.connection.handle:04X}] {att_pdu}'
-        )
+        logger.debug(f'GATT Response to client: {self._bearer_id} {att_pdu}')
         if att_pdu.op_code in att.ATT_RESPONSES:
             if self.pending_request is None:
                 # Not expected!
@@ -1103,8 +1154,7 @@ class Client:
             else:
                 logger.warning(
                     color(
-                        '--- Ignoring GATT Response from '
-                        f'[0x{self.connection.handle:04X}]: ',
+                        '--- Ignoring GATT Response from ' f'{self._bearer_id}: ',
                         'red',
                     )
                     + str(att_pdu)