bumble 0.0.212__py3-none-any.whl → 0.0.213__py3-none-any.whl

bumble/drivers/__init__.py

@@ -23,7 +23,7 @@ from __future__ import annotations
 import logging
 import pathlib
 import platform
-from typing import Dict, Iterable, Optional, Type, TYPE_CHECKING
+from typing import Iterable, Optional, TYPE_CHECKING
 
 from bumble.drivers import rtk, intel
 from bumble.drivers.common import Driver
@@ -45,7 +45,7 @@ async def get_driver_for_host(host: Host) -> Optional[Driver]:
     found.
     If a "driver" HCI metadata entry is present, only that driver class will be probed.
     """
-    driver_classes: Dict[str, Type[Driver]] = {"rtk": rtk.Driver, "intel": intel.Driver}
+    driver_classes: dict[str, type[Driver]] = {"rtk": rtk.Driver, "intel": intel.Driver}
     probe_list: Iterable[str]
     if driver_name := host.hci_metadata.get("driver"):
         # Only probe a single driver

bumble/drivers/common.py

@@ -20,8 +20,6 @@ Common types for drivers.
 # -----------------------------------------------------------------------------
 import abc
 
-from bumble import core
-
 
 # -----------------------------------------------------------------------------
 # Classes

bumble/drivers/intel.py

@@ -28,7 +28,7 @@ import os
 import pathlib
 import platform
 import struct
-from typing import Any, Deque, Optional, TYPE_CHECKING
+from typing import Any, Optional, TYPE_CHECKING
 
 from bumble import core
 from bumble.drivers import common
@@ -90,54 +90,51 @@ HCI_INTEL_WRITE_BOOT_PARAMS_COMMAND = hci.hci_vendor_command_op_code(0x000E)
 hci.HCI_Command.register_commands(globals())
 
 
-@hci.HCI_Command.command(
-    fields=[
-        ("param0", 1),
-    ],
-    return_parameters_fields=[
+@hci.HCI_Command.command
+@dataclasses.dataclass
+class HCI_Intel_Read_Version_Command(hci.HCI_Command):
+    param0: int = dataclasses.field(metadata=hci.metadata(1))
+
+    return_parameters_fields = [
         ("status", hci.STATUS_SPEC),
         ("tlv", "*"),
-    ],
-)
-class HCI_Intel_Read_Version_Command(hci.HCI_Command):
-    pass
+    ]
 
 
-@hci.HCI_Command.command(
-    fields=[("data_type", 1), ("data", "*")],
-    return_parameters_fields=[
-        ("status", 1),
-    ],
-)
+@hci.HCI_Command.command
+@dataclasses.dataclass
 class Hci_Intel_Secure_Send_Command(hci.HCI_Command):
-    pass
-
-
-@hci.HCI_Command.command(
-    fields=[
-        ("reset_type", 1),
-        ("patch_enable", 1),
-        ("ddc_reload", 1),
-        ("boot_option", 1),
-        ("boot_address", 4),
-    ],
-    return_parameters_fields=[
-        ("data", "*"),
-    ],
-)
+    data_type: int = dataclasses.field(metadata=hci.metadata(1))
+    data: bytes = dataclasses.field(metadata=hci.metadata("*"))
+
+    return_parameters_fields = [
+        ("status", 1),
+    ]
+
+
+@hci.HCI_Command.command
+@dataclasses.dataclass
 class HCI_Intel_Reset_Command(hci.HCI_Command):
-    pass
+    reset_type: int = dataclasses.field(metadata=hci.metadata(1))
+    patch_enable: int = dataclasses.field(metadata=hci.metadata(1))
+    ddc_reload: int = dataclasses.field(metadata=hci.metadata(1))
+    boot_option: int = dataclasses.field(metadata=hci.metadata(1))
+    boot_address: int = dataclasses.field(metadata=hci.metadata(4))
+
+    return_parameters_fields = [
+        ("data", "*"),
+    ]
 
 
-@hci.HCI_Command.command(
-    fields=[("data", "*")],
-    return_parameters_fields=[
+@hci.HCI_Command.command
+@dataclasses.dataclass
+class Hci_Intel_Write_Device_Config_Command(hci.HCI_Command):
+    data: bytes = dataclasses.field(metadata=hci.metadata("*"))
+
+    return_parameters_fields = [
         ("status", hci.STATUS_SPEC),
         ("params", "*"),
-    ],
-)
-class Hci_Intel_Write_Device_Config_Command(hci.HCI_Command):
-    pass
+    ]
 
 
 # -----------------------------------------------------------------------------
@@ -348,7 +345,7 @@ class Driver(common.Driver):
     def __init__(self, host: Host) -> None:
         self.host = host
         self.max_in_flight_firmware_load_commands = 1
-        self.pending_firmware_load_commands: Deque[hci.HCI_Command] = (
+        self.pending_firmware_load_commands: collections.deque[hci.HCI_Command] = (
             collections.deque()
         )
         self.can_send_firmware_load_command = asyncio.Event()

bumble/drivers/rtk.py

@@ -20,7 +20,7 @@ Based on various online bits of information, including the Linux kernel.
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 import asyncio
 import enum
 import logging
@@ -29,19 +29,11 @@ import os
 import pathlib
 import platform
 import struct
-from typing import Tuple
 import weakref
 
 
 from bumble import core
-from bumble.hci import (
-    hci_vendor_command_op_code,
-    STATUS_SPEC,
-    HCI_SUCCESS,
-    HCI_Command,
-    HCI_Reset_Command,
-    HCI_Read_Local_Version_Information_Command,
-)
+from bumble import hci
 from bumble.drivers import common
 
 # -----------------------------------------------------------------------------
@@ -183,27 +175,29 @@ RTK_USB_PRODUCTS = {
 # -----------------------------------------------------------------------------
 # HCI Commands
 # -----------------------------------------------------------------------------
-HCI_RTK_READ_ROM_VERSION_COMMAND = hci_vendor_command_op_code(0x6D)
-HCI_RTK_DOWNLOAD_COMMAND = hci_vendor_command_op_code(0x20)
-HCI_RTK_DROP_FIRMWARE_COMMAND = hci_vendor_command_op_code(0x66)
-HCI_Command.register_commands(globals())
+HCI_RTK_READ_ROM_VERSION_COMMAND = hci.hci_vendor_command_op_code(0x6D)
+HCI_RTK_DOWNLOAD_COMMAND = hci.hci_vendor_command_op_code(0x20)
+HCI_RTK_DROP_FIRMWARE_COMMAND = hci.hci_vendor_command_op_code(0x66)
+hci.HCI_Command.register_commands(globals())
 
 
-@HCI_Command.command(return_parameters_fields=[("status", STATUS_SPEC), ("version", 1)])
-class HCI_RTK_Read_ROM_Version_Command(HCI_Command):
-    pass
+@hci.HCI_Command.command
+@dataclass
+class HCI_RTK_Read_ROM_Version_Command(hci.HCI_Command):
+    return_parameters_fields = [("status", hci.STATUS_SPEC), ("version", 1)]
 
 
-@HCI_Command.command(
-    fields=[("index", 1), ("payload", RTK_FRAGMENT_LENGTH)],
-    return_parameters_fields=[("status", STATUS_SPEC), ("index", 1)],
-)
-class HCI_RTK_Download_Command(HCI_Command):
-    pass
+@hci.HCI_Command.command
+@dataclass
+class HCI_RTK_Download_Command(hci.HCI_Command):
+    index: int = field(metadata=hci.metadata(1))
+    payload: bytes = field(metadata=hci.metadata(RTK_FRAGMENT_LENGTH))
+    return_parameters_fields = [("status", hci.STATUS_SPEC), ("index", 1)]
 
 
-@HCI_Command.command()
-class HCI_RTK_Drop_Firmware_Command(HCI_Command):
+@hci.HCI_Command.command
+@dataclass
+class HCI_RTK_Drop_Firmware_Command(hci.HCI_Command):
     pass
 
 
@@ -294,7 +288,7 @@ class Driver(common.Driver):
     @dataclass
     class DriverInfo:
         rom: int
-        hci: Tuple[int, int]
+        hci: tuple[int, int]
         config_needed: bool
         has_rom_version: bool
         has_msft_ext: bool = False
@@ -499,17 +493,17 @@ class Driver(common.Driver):
     async def driver_info_for_host(cls, host):
         try:
             await host.send_command(
-                HCI_Reset_Command(),
+                hci.HCI_Reset_Command(),
                 check_result=True,
                 response_timeout=cls.POST_RESET_DELAY,
             )
             host.ready = True  # Needed to let the host know the controller is ready.
         except asyncio.exceptions.TimeoutError:
             logger.warning("timeout waiting for hci reset, retrying")
-            await host.send_command(HCI_Reset_Command(), check_result=True)
+            await host.send_command(hci.HCI_Reset_Command(), check_result=True)
             host.ready = True
 
-        command = HCI_Read_Local_Version_Information_Command()
+        command = hci.HCI_Read_Local_Version_Information_Command()
         response = await host.send_command(command, check_result=True)
         if response.command_opcode != command.op_code:
             logger.error("failed to probe local version information")
@@ -596,7 +590,7 @@ class Driver(common.Driver):
             response = await self.host.send_command(
                 HCI_RTK_Read_ROM_Version_Command(), check_result=True
             )
-            if response.return_parameters.status != HCI_SUCCESS:
+            if response.return_parameters.status != hci.HCI_SUCCESS:
                 logger.warning("can't get ROM version")
                 return
             rom_version = response.return_parameters.version
@@ -634,9 +628,8 @@ class Driver(common.Driver):
             fragment = payload[fragment_offset : fragment_offset + RTK_FRAGMENT_LENGTH]
             logger.debug(f"downloading fragment {fragment_index}")
             await self.host.send_command(
-                HCI_RTK_Download_Command(
-                    index=download_index, payload=fragment, check_result=True
-                )
+                HCI_RTK_Download_Command(index=download_index, payload=fragment),
+                check_result=True,
             )
 
         logger.debug("download complete!")
@@ -645,7 +638,7 @@ class Driver(common.Driver):
         response = await self.host.send_command(
             HCI_RTK_Read_ROM_Version_Command(), check_result=True
         )
-        if response.return_parameters.status != HCI_SUCCESS:
+        if response.return_parameters.status != hci.HCI_SUCCESS:
             logger.warning("can't get ROM version")
         else:
             rom_version = response.return_parameters.version
@@ -668,7 +661,7 @@ class Driver(common.Driver):
 
     async def init_controller(self):
         await self.download_firmware()
-        await self.host.send_command(HCI_Reset_Command(), check_result=True)
+        await self.host.send_command(hci.HCI_Reset_Command(), check_result=True)
         logger.info(f"loaded FW image {self.driver_info.fw_name}")
 
 

bumble/gatt.py

@@ -27,7 +27,7 @@ import enum
 import functools
 import logging
 import struct
-from typing import Iterable, List, Optional, Sequence, TypeVar, Union
+from typing import Iterable, Optional, Sequence, TypeVar, Union
 
 from bumble.colors import color
 from bumble.core import BaseBumbleError, UUID
@@ -350,8 +350,8 @@ class Service(Attribute):
     '''
 
     uuid: UUID
-    characteristics: List[Characteristic]
-    included_services: List[Service]
+    characteristics: list[Characteristic]
+    included_services: list[Service]
 
     def __init__(
         self,
@@ -474,7 +474,7 @@ class Characteristic(Attribute[_T]):
                 # The check for `p.name is not None` here is needed because for InFlag
                 # enums, the .name property can be None, when the enum value is 0,
                 # so the type hint for .name is Optional[str].
-                enum_list: List[str] = [p.name for p in cls if p.name is not None]
+                enum_list: list[str] = [p.name for p in cls if p.name is not None]
                 enum_list_str = ",".join(enum_list)
                 raise TypeError(
                     f"Characteristic.Properties::from_string() error:\nExpected a string containing any of the keys, separated by , or |: {enum_list_str}\nGot: {properties_str}"

bumble/gatt_adapters.py

@@ -28,7 +28,6 @@ from typing import (
     Iterable,
     Literal,
     Optional,
-    Type,
     TypeVar,
 )
 
@@ -270,7 +269,7 @@ class SerializableCharacteristicAdapter(CharacteristicAdapter[_T2]):
     `to_bytes` and `__bytes__` methods, respectively.
     '''
 
-    def __init__(self, characteristic: Characteristic, cls: Type[_T2]) -> None:
+    def __init__(self, characteristic: Characteristic, cls: type[_T2]) -> None:
         super().__init__(characteristic)
         self.cls = cls
 
@@ -289,7 +288,7 @@ class SerializableCharacteristicProxyAdapter(CharacteristicProxyAdapter[_T2]):
     '''
 
     def __init__(
-        self, characteristic_proxy: CharacteristicProxy, cls: Type[_T2]
+        self, characteristic_proxy: CharacteristicProxy, cls: type[_T2]
     ) -> None:
         super().__init__(characteristic_proxy)
         self.cls = cls
@@ -311,7 +310,7 @@ class EnumCharacteristicAdapter(CharacteristicAdapter[_T3]):
     def __init__(
         self,
         characteristic: Characteristic,
-        cls: Type[_T3],
+        cls: type[_T3],
         length: int,
         byteorder: Literal['little', 'big'] = 'little',
     ):
@@ -347,7 +346,7 @@ class EnumCharacteristicProxyAdapter(CharacteristicProxyAdapter[_T3]):
     def __init__(
         self,
         characteristic_proxy: CharacteristicProxy,
-        cls: Type[_T3],
+        cls: type[_T3],
         length: int,
         byteorder: Literal['little', 'big'] = 'little',
     ):

bumble/gatt_client.py

@@ -31,15 +31,10 @@ from datetime import datetime
 from typing import (
     Any,
     Callable,
-    Dict,
     Generic,
     Iterable,
-    List,
     Optional,
-    Set,
-    Tuple,
     Union,
-    Type,
     TypeVar,
     TYPE_CHECKING,
 )
@@ -149,8 +144,8 @@ class AttributeProxy(utils.EventEmitter, Generic[_T]):
 
 class ServiceProxy(AttributeProxy):
     uuid: UUID
-    characteristics: List[CharacteristicProxy[bytes]]
-    included_services: List[ServiceProxy]
+    characteristics: list[CharacteristicProxy[bytes]]
+    included_services: list[ServiceProxy]
 
     @staticmethod
     def from_client(service_class, client: Client, service_uuid: UUID):
@@ -199,8 +194,8 @@ class ServiceProxy(AttributeProxy):
 
 class CharacteristicProxy(AttributeProxy[_T]):
     properties: Characteristic.Properties
-    descriptors: List[DescriptorProxy]
-    subscribers: Dict[Any, Callable[[_T], Any]]
+    descriptors: list[DescriptorProxy]
+    subscribers: dict[Any, Callable[[_T], Any]]
 
     EVENT_UPDATE = "update"
 
@@ -277,7 +272,7 @@ class ProfileServiceProxy:
     Base class for profile-specific service proxies
     '''
 
-    SERVICE_CLASS: Type[TemplateService]
+    SERVICE_CLASS: type[TemplateService]
 
     @classmethod
     def from_client(cls, client: Client) -> Optional[ProfileServiceProxy]:
@@ -288,13 +283,13 @@ class ProfileServiceProxy:
 # GATT Client
 # -----------------------------------------------------------------------------
 class Client:
-    services: List[ServiceProxy]
-    cached_values: Dict[int, Tuple[datetime, bytes]]
-    notification_subscribers: Dict[
-        int, Set[Union[CharacteristicProxy, Callable[[bytes], Any]]]
+    services: list[ServiceProxy]
+    cached_values: dict[int, tuple[datetime, bytes]]
+    notification_subscribers: dict[
+        int, set[Union[CharacteristicProxy, Callable[[bytes], Any]]]
     ]
-    indication_subscribers: Dict[
-        int, Set[Union[CharacteristicProxy, Callable[[bytes], Any]]]
+    indication_subscribers: dict[
+        int, set[Union[CharacteristicProxy, Callable[[bytes], Any]]]
     ]
     pending_response: Optional[asyncio.futures.Future[ATT_PDU]]
     pending_request: Optional[ATT_PDU]
@@ -379,12 +374,12 @@ class Client:
 
         return self.connection.att_mtu
 
-    def get_services_by_uuid(self, uuid: UUID) -> List[ServiceProxy]:
+    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
-    ) -> List[CharacteristicProxy[bytes]]:
+    ) -> list[CharacteristicProxy[bytes]]:
         services = [service] if service else self.services
         return [
             c
@@ -395,8 +390,8 @@ class Client:
     def get_attribute_grouping(self, attribute_handle: int) -> Optional[
         Union[
             ServiceProxy,
-            Tuple[ServiceProxy, CharacteristicProxy],
-            Tuple[ServiceProxy, CharacteristicProxy, DescriptorProxy],
+            tuple[ServiceProxy, CharacteristicProxy],
+            tuple[ServiceProxy, CharacteristicProxy, DescriptorProxy],
         ]
     ]:
         """
@@ -429,7 +424,7 @@ class Client:
         if not already_known:
             self.services.append(service)
 
-    async def discover_services(self, uuids: Iterable[UUID] = ()) -> List[ServiceProxy]:
+    async def discover_services(self, uuids: Iterable[UUID] = ()) -> list[ServiceProxy]:
         '''
         See Vol 3, Part G - 4.4.1 Discover All Primary Services
         '''
@@ -501,7 +496,7 @@ class Client:
 
         return services
 
-    async def discover_service(self, uuid: Union[str, UUID]) -> List[ServiceProxy]:
+    async def discover_service(self, uuid: Union[str, UUID]) -> list[ServiceProxy]:
         '''
         See Vol 3, Part G - 4.4.2 Discover Primary Service by Service UUID
         '''
@@ -572,7 +567,7 @@ class Client:
 
     async def discover_included_services(
         self, service: ServiceProxy
-    ) -> List[ServiceProxy]:
+    ) -> list[ServiceProxy]:
         '''
         See Vol 3, Part G - 4.5.1 Find Included Services
         '''
@@ -580,7 +575,7 @@ class Client:
         starting_handle = service.handle
         ending_handle = service.end_group_handle
 
-        included_services: List[ServiceProxy] = []
+        included_services: list[ServiceProxy] = []
         while starting_handle <= ending_handle:
             response = await self.send_request(
                 ATT_Read_By_Type_Request(
@@ -636,7 +631,7 @@ class Client:
 
     async def discover_characteristics(
         self, uuids, service: Optional[ServiceProxy]
-    ) -> List[CharacteristicProxy[bytes]]:
+    ) -> list[CharacteristicProxy[bytes]]:
         '''
         See Vol 3, Part G - 4.6.1 Discover All Characteristics of a Service and 4.6.2
         Discover Characteristics by UUID
@@ -649,12 +644,12 @@ class Client:
         services = [service] if service else self.services
 
         # Perform characteristic discovery for each service
-        discovered_characteristics: List[CharacteristicProxy[bytes]] = []
+        discovered_characteristics: list[CharacteristicProxy[bytes]] = []
         for service in services:
             starting_handle = service.handle
             ending_handle = service.end_group_handle
 
-            characteristics: List[CharacteristicProxy[bytes]] = []
+            characteristics: list[CharacteristicProxy[bytes]] = []
             while starting_handle <= ending_handle:
                 response = await self.send_request(
                     ATT_Read_By_Type_Request(
@@ -725,7 +720,7 @@ class Client:
         characteristic: Optional[CharacteristicProxy] = None,
         start_handle: Optional[int] = None,
         end_handle: Optional[int] = None,
-    ) -> List[DescriptorProxy]:
+    ) -> list[DescriptorProxy]:
         '''
         See Vol 3, Part G - 4.7.1 Discover All Characteristic Descriptors
         '''
@@ -738,7 +733,7 @@ class Client:
         else:
             return []
 
-        descriptors: List[DescriptorProxy] = []
+        descriptors: list[DescriptorProxy] = []
         while starting_handle <= ending_handle:
             response = await self.send_request(
                 ATT_Find_Information_Request(
@@ -787,7 +782,7 @@ class Client:
 
         return descriptors
 
-    async def discover_attributes(self) -> List[AttributeProxy[bytes]]:
+    async def discover_attributes(self) -> list[AttributeProxy[bytes]]:
         '''
         Discover all attributes, regardless of type
         '''
@@ -1002,7 +997,7 @@ class Client:
 
     async def read_characteristics_by_uuid(
         self, uuid: UUID, service: Optional[ServiceProxy]
-    ) -> List[bytes]:
+    ) -> list[bytes]:
         '''
         See Vol 3, Part G - 4.8.2 Read Using Characteristic UUID
         '''

bumble/gatt_server.py

@@ -29,13 +29,9 @@ import logging
 from collections import defaultdict
 import struct
 from typing import (
-    Dict,
     Iterable,
-    List,
     Optional,
-    Tuple,
     TypeVar,
-    Type,
     TYPE_CHECKING,
 )
 
@@ -103,10 +99,10 @@ GATT_SERVER_DEFAULT_MAX_MTU = 517
 # GATT Server
 # -----------------------------------------------------------------------------
 class Server(utils.EventEmitter):
-    attributes: List[Attribute]
-    services: List[Service]
-    attributes_by_handle: Dict[int, Attribute]
-    subscribers: Dict[int, Dict[int, bytes]]
+    attributes: list[Attribute]
+    services: list[Service]
+    attributes_by_handle: dict[int, Attribute]
+    subscribers: dict[int, dict[int, bytes]]
     indication_semaphores: defaultdict[int, asyncio.Semaphore]
     pending_confirmations: defaultdict[int, Optional[asyncio.futures.Future]]
 
@@ -136,7 +132,7 @@ class Server(utils.EventEmitter):
     def next_handle(self) -> int:
         return 1 + len(self.attributes)
 
-    def get_advertising_service_data(self) -> Dict[Attribute, bytes]:
+    def get_advertising_service_data(self) -> dict[Attribute, bytes]:
         return {
             attribute: data
             for attribute in self.attributes
@@ -160,7 +156,7 @@ class Server(utils.EventEmitter):
     AttributeGroupType = TypeVar('AttributeGroupType', Service, Characteristic)
 
     def get_attribute_group(
-        self, handle: int, group_type: Type[AttributeGroupType]
+        self, handle: int, group_type: type[AttributeGroupType]
     ) -> Optional[AttributeGroupType]:
         return next(
             (
@@ -186,7 +182,7 @@ class Server(utils.EventEmitter):
 
     def get_characteristic_attributes(
         self, service_uuid: UUID, characteristic_uuid: UUID
-    ) -> Optional[Tuple[CharacteristicDeclaration, Characteristic]]:
+    ) -> Optional[tuple[CharacteristicDeclaration, Characteristic]]:
         service_handle = self.get_service_attribute(service_uuid)
         if not service_handle:
             return None