bumble 0.0.219__py3-none-any.whl → 0.0.221__py3-none-any.whl

bumble/apps/bench.py

@@ -22,7 +22,6 @@ import logging
 import statistics
 import struct
 import time
-from typing import Optional
 
 import click
 
@@ -257,8 +256,8 @@ async def pre_power_on(device: Device, classic: bool) -> None:
 
 async def post_power_on(
     device: Device,
-    le_scan: Optional[tuple[int, int]],
-    le_advertise: Optional[int],
+    le_scan: tuple[int, int] | None,
+    le_advertise: int | None,
     classic_page_scan: bool,
     classic_inquiry_scan: bool,
 ) -> None:
@@ -1300,7 +1299,7 @@ class IsoClient(StreamedPacketIO):
         super().__init__()
         self.device = device
         self.ready = asyncio.Event()
-        self.cis_link: Optional[CisLink] = None
+        self.cis_link: CisLink | None = None
 
     async def on_connection(
         self, connection: Connection, cis_link: CisLink, sender: bool
@@ -1341,7 +1340,7 @@ class IsoServer(StreamedPacketIO):
     ):
         super().__init__()
         self.device = device
-        self.cis_link: Optional[CisLink] = None
+        self.cis_link: CisLink | None = None
         self.ready = asyncio.Event()
 
         logging.info(

bumble/apps/console.py

@@ -24,7 +24,6 @@ import logging
 import os
 import re
 from collections import OrderedDict
-from typing import Optional, Union
 
 import click
 import humanize
@@ -126,8 +125,8 @@ def parse_phys(phys):
 # Console App
 # -----------------------------------------------------------------------------
 class ConsoleApp:
-    connected_peer: Optional[Peer]
-    connection_phy: Optional[ConnectionPHY]
+    connected_peer: Peer | None
+    connection_phy: ConnectionPHY | None
 
     def __init__(self):
         self.known_addresses = set()
@@ -520,7 +519,7 @@ class ConsoleApp:
 
         self.show_attributes(attributes)
 
-    def find_remote_characteristic(self, param) -> Optional[CharacteristicProxy]:
+    def find_remote_characteristic(self, param) -> CharacteristicProxy | None:
         if not self.connected_peer:
             return None
         parts = param.split('.')
@@ -542,9 +541,7 @@ class ConsoleApp:
 
         return None
 
-    def find_local_attribute(
-        self, param
-    ) -> Optional[Union[Characteristic, Descriptor]]:
+    def find_local_attribute(self, param) -> Characteristic | Descriptor | None:
         parts = param.split('.')
         if len(parts) == 3:
             service_uuid = UUID(parts[0])
@@ -1096,9 +1093,7 @@ class DeviceListener(Device.Listener, Connection.Listener):
             if self.app.connected_peer.connection.is_encrypted
             else 'not encrypted'
         )
-        self.app.append_to_output(
-            'connection encryption change: ' f'{encryption_state}'
-        )
+        self.app.append_to_output(f'connection encryption change: {encryption_state}')
 
     def on_connection_data_length_change(self):
         self.app.append_to_output(

bumble/apps/controller_info.py

@@ -35,8 +35,6 @@ from bumble.hci import (
     HCI_READ_BUFFER_SIZE_COMMAND,
     HCI_READ_LOCAL_NAME_COMMAND,
     HCI_SUCCESS,
-    HCI_VERSION_NAMES,
-    LMP_VERSION_NAMES,
     CodecID,
     HCI_Command,
     HCI_Command_Complete_Event,
@@ -54,6 +52,7 @@ from bumble.hci import (
     HCI_Read_Local_Supported_Codecs_V2_Command,
     HCI_Read_Local_Version_Information_Command,
     LeFeature,
+    SpecificationVersion,
     map_null_terminated_utf8_string,
 )
 from bumble.host import Host
@@ -275,7 +274,7 @@ async def async_main(
                 (
                     f'min={min(latencies):.2f}, '
                     f'max={max(latencies):.2f}, '
-                    f'average={sum(latencies)/len(latencies):.2f},'
+                    f'average={sum(latencies) / len(latencies):.2f},'
                 ),
                 [f'{latency:.4}' for latency in latencies],
                 '\n',
@@ -289,14 +288,20 @@ async def async_main(
         )
         print(
             color('  HCI Version:   ', 'green'),
-            name_or_number(HCI_VERSION_NAMES, host.local_version.hci_version),
+            SpecificationVersion(host.local_version.hci_version).name,
+        )
+        print(
+            color('  HCI Subversion:', 'green'),
+            f'0x{host.local_version.hci_subversion:04x}',
         )
-        print(color('  HCI Subversion:', 'green'), host.local_version.hci_subversion)
         print(
             color('  LMP Version:   ', 'green'),
-            name_or_number(LMP_VERSION_NAMES, host.local_version.lmp_version),
+            SpecificationVersion(host.local_version.lmp_version).name,
+        )
+        print(
+            color('  LMP Subversion:', 'green'),
+            f'0x{host.local_version.lmp_subversion:04x}',
         )
-        print(color('  LMP Subversion:', 'green'), host.local_version.lmp_subversion)
 
         # Get the Classic info
         await get_classic_info(host)

bumble/apps/controller_loopback.py

@@ -17,7 +17,6 @@
 # -----------------------------------------------------------------------------
 import asyncio
 import time
-from typing import Optional
 
 import click
 
@@ -41,7 +40,7 @@ class Loopback:
         self.transport = transport
         self.packet_size = packet_size
         self.packet_count = packet_count
-        self.connection_handle: Optional[int] = None
+        self.connection_handle: int | None = None
         self.connection_event = asyncio.Event()
         self.done = asyncio.Event()
         self.expected_cid = 0

bumble/apps/device_info.py

@@ -16,7 +16,7 @@
 # Imports
 # -----------------------------------------------------------------------------
 import asyncio
-from typing import Callable, Iterable, Optional
+from collections.abc import Callable, Iterable
 
 import click
 
@@ -174,7 +174,7 @@ async def show_vcs(vcs: VolumeControlServiceProxy) -> None:
 
 
 # -----------------------------------------------------------------------------
-async def show_device_info(peer, done: Optional[asyncio.Future]) -> None:
+async def show_device_info(peer, done: asyncio.Future | None) -> None:
     try:
         # Discover all services
         print(color('### Discovering Services and Characteristics', 'magenta'))
@@ -215,7 +215,6 @@ async def show_device_info(peer, done: Optional[asyncio.Future]) -> None:
 # -----------------------------------------------------------------------------
 async def async_main(device_config, encrypt, transport, address_or_name):
     async with await open_transport(transport) as (hci_source, hci_sink):
-
         # Create a device
         if device_config:
             device = Device.from_config_file_with_hci(

bumble/apps/gatt_dump.py

@@ -61,7 +61,6 @@ async def dump_gatt_db(peer, done):
 # -----------------------------------------------------------------------------
 async def async_main(device_config, encrypt, transport, address_or_name):
     async with await open_transport(transport) as (hci_source, hci_sink):
-
         # Create a device
         if device_config:
             device = Device.from_config_file_with_hci(

bumble/apps/lea_unicast/app.py

@@ -268,7 +268,6 @@ class UiServer:
 
 # -----------------------------------------------------------------------------
 class Speaker:
-
     def __init__(
         self,
         device_config_path: str | None,
@@ -299,6 +298,7 @@ class Speaker:
                     advertising_interval_max=25,
                     address=Address('F1:F2:F3:F4:F5:F6'),
                     identity_address_type=Address.RANDOM_DEVICE_ADDRESS,
+                    eatt_enabled=True,
                 )
 
             device_config.le_enabled = True

bumble/apps/pair.py

@@ -15,10 +15,11 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
+from __future__ import annotations
+
 import asyncio
 import logging
 import os
-import struct
 
 import click
 from prompt_toolkit.shortcuts import PromptSession
@@ -64,7 +65,7 @@ POST_PAIRING_DELAY = 1
 
 # -----------------------------------------------------------------------------
 class Waiter:
-    instance = None
+    instance: Waiter | None = None
 
     def __init__(self, linger=False):
         self.done = asyncio.get_running_loop().create_future()
@@ -328,25 +329,25 @@ async def on_pairing_failure(connection, reason):
 
 # -----------------------------------------------------------------------------
 async def pair(
-    mode,
-    sc,
-    mitm,
-    bond,
-    ctkd,
-    advertising_address,
-    identity_address,
-    linger,
-    io,
-    oob,
-    prompt,
-    request,
-    print_keys,
-    keystore_file,
-    advertise_service_uuids,
-    advertise_appearance,
-    device_config,
-    hci_transport,
-    address_or_name,
+    mode: str,
+    sc: bool,
+    mitm: bool,
+    bond: bool,
+    ctkd: bool,
+    advertising_address: str,
+    identity_address: str,
+    linger: bool,
+    io: str,
+    oob: str,
+    prompt: bool,
+    request: bool,
+    print_keys: bool,
+    keystore_file: str,
+    advertise_service_uuids: str,
+    advertise_appearance: str,
+    device_config: str,
+    hci_transport: str,
+    address_or_name: str,
 ):
     Waiter.instance = Waiter(linger=linger)
 
@@ -404,6 +405,7 @@ async def pair(
         # Create an OOB context if needed
         if oob:
             our_oob_context = OobContext()
+            legacy_context: OobLegacyContext | None
             if oob == '-':
                 shared_data = None
                 legacy_context = OobLegacyContext()
@@ -528,7 +530,9 @@ async def pair(
                 if advertise_appearance:
                     advertise_appearance = advertise_appearance.upper()
                     try:
-                        advertise_appearance_int = int(advertise_appearance)
+                        appearance = data_types.Appearance.from_int(
+                            int(advertise_appearance)
+                        )
                     except ValueError:
                         category, subcategory = advertise_appearance.split('/')
                         try:
@@ -546,12 +550,11 @@ async def pair(
                         except ValueError:
                             print(color(f'Invalid subcategory {subcategory}', 'red'))
                             return
-                        advertise_appearance_int = int(
-                            Appearance(category_enum, subcategory_enum)
+                        appearance = data_types.Appearance(
+                            category_enum, subcategory_enum
                         )
-                    advertising_data_types.append(
-                        data_types.Appearance(category_enum, subcategory_enum)
-                    )
+
+                    advertising_data_types.append(appearance)
                 device.advertising_data = bytes(AdvertisingData(advertising_data_types))
                 await device.start_advertising(
                     auto_restart=True,
@@ -661,25 +664,25 @@ class LogHandler(logging.Handler):
 @click.argument('hci_transport')
 @click.argument('address-or-name', required=False)
 def main(
-    mode,
-    sc,
-    mitm,
-    bond,
-    ctkd,
-    advertising_address,
-    identity_address,
-    linger,
-    io,
-    oob,
-    prompt,
-    request,
-    print_keys,
-    keystore_file,
-    advertise_service_uuid,
-    advertise_appearance,
-    device_config,
-    hci_transport,
-    address_or_name,
+    mode: str,
+    sc: bool,
+    mitm: bool,
+    bond: bool,
+    ctkd: bool,
+    advertising_address: str,
+    identity_address: str,
+    linger: bool,
+    io: str,
+    oob: str,
+    prompt: bool,
+    request: bool,
+    print_keys: bool,
+    keystore_file: str,
+    advertise_service_uuid: str,
+    advertise_appearance: str,
+    device_config: str,
+    hci_transport: str,
+    address_or_name: str,
 ):
     # Setup logging
     log_handler = LogHandler()

bumble/apps/pandora_server.py

@@ -19,7 +19,7 @@ ROOTCANAL_PORT_CUTTLEFISH = 7300
 @click.option(
     '--transport',
     help='HCI transport',
-    default=f'tcp-client:127.0.0.1:<rootcanal-port>',
+    default='tcp-client:127.0.0.1:<rootcanal-port>',
 )
 @click.option(
     '--config',
@@ -44,7 +44,7 @@ def retrieve_config(config: str) -> dict[str, Any]:
     if not config:
         return {}
 
-    with open(config, 'r') as f:
+    with open(config) as f:
         return json.load(f)
 
 

bumble/apps/player/player.py

@@ -19,7 +19,6 @@ from __future__ import annotations
 
 import asyncio
 import logging
-from typing import Optional, Union
 
 import click
 
@@ -47,14 +46,13 @@ from bumble.avdtp import (
     AVDTP_DELAY_REPORTING_SERVICE_CATEGORY,
     MediaCodecCapabilities,
     MediaPacketPump,
+    find_avdtp_service_with_connection,
 )
 from bumble.avdtp import Protocol as AvdtpProtocol
-from bumble.avdtp import find_avdtp_service_with_connection
 from bumble.avrcp import Protocol as AvrcpProtocol
 from bumble.colors import color
-from bumble.core import AdvertisingData
+from bumble.core import AdvertisingData, DeviceClass, PhysicalTransport
 from bumble.core import ConnectionError as BumbleConnectionError
-from bumble.core import DeviceClass, PhysicalTransport
 from bumble.device import Connection, Device, DeviceConfiguration
 from bumble.hci import HCI_CONNECTION_ALREADY_EXISTS_ERROR, Address, HCI_Constant
 from bumble.pairing import PairingConfig
@@ -191,7 +189,7 @@ class Player:
     def __init__(
         self,
         transport: str,
-        device_config: Optional[str],
+        device_config: str | None,
         authenticate: bool,
         encrypt: bool,
     ) -> None:
@@ -199,8 +197,8 @@ class Player:
         self.device_config = device_config
         self.authenticate = authenticate
         self.encrypt = encrypt
-        self.avrcp_protocol: Optional[AvrcpProtocol] = None
-        self.done: Optional[asyncio.Event]
+        self.avrcp_protocol: AvrcpProtocol | None = None
+        self.done: asyncio.Event | None
 
     async def run(self, workload) -> None:
         self.done = asyncio.Event()
@@ -315,7 +313,7 @@ class Player:
         codec_type: int,
         vendor_id: int,
         codec_id: int,
-        packet_source: Union[SbcPacketSource, AacPacketSource, OpusPacketSource],
+        packet_source: SbcPacketSource | AacPacketSource | OpusPacketSource,
         codec_capabilities: MediaCodecCapabilities,
     ):
         # Discover all endpoints on the remote device
@@ -381,11 +379,11 @@ class Player:
             print(f">>> {color(address.to_string(False), 'yellow')}:")
             print(f"  Device Class (raw): {class_of_device:06X}")
             major_class_name = DeviceClass.major_device_class_name(major_device_class)
-            print("  Device Major Class: " f"{major_class_name}")
+            print(f"  Device Major Class: {major_class_name}")
             minor_class_name = DeviceClass.minor_device_class_name(
                 major_device_class, minor_device_class
             )
-            print("  Device Minor Class: " f"{minor_class_name}")
+            print(f"  Device Minor Class: {minor_class_name}")
             print(
                 "  Device Services: "
                 f"{', '.join(DeviceClass.service_class_labels(service_classes))}"
@@ -420,7 +418,7 @@ class Player:
     async def play(
         self,
         device: Device,
-        address: Optional[str],
+        address: str | None,
         audio_format: str,
         audio_file: str,
     ) -> None:
@@ -449,7 +447,7 @@ class Player:
                     return input_file.read(byte_count)
 
                 # Obtain the codec capabilities from the stream
-                packet_source: Union[SbcPacketSource, AacPacketSource, OpusPacketSource]
+                packet_source: SbcPacketSource | AacPacketSource | OpusPacketSource
                 vendor_id = 0
                 codec_id = 0
                 if audio_format == "sbc":

bumble/apps/rfcomm_bridge.py

@@ -17,7 +17,6 @@
 # -----------------------------------------------------------------------------
 import asyncio
 import time
-from typing import Optional
 
 import click
 
@@ -82,14 +81,14 @@ class ServerBridge:
     def __init__(
         self, channel: int, uuid: str, trace: bool, tcp_host: str, tcp_port: int
     ) -> None:
-        self.device: Optional[Device] = None
+        self.device: Device | None = None
         self.channel = channel
         self.uuid = uuid
         self.tcp_host = tcp_host
         self.tcp_port = tcp_port
-        self.rfcomm_channel: Optional[rfcomm.DLC] = None
-        self.tcp_tracer: Optional[Tracer]
-        self.rfcomm_tracer: Optional[Tracer]
+        self.rfcomm_channel: rfcomm.DLC | None = None
+        self.tcp_tracer: Tracer | None
+        self.rfcomm_tracer: Tracer | None
 
         if trace:
             self.tcp_tracer = Tracer(color("RFCOMM->TCP", "cyan"))
@@ -242,14 +241,14 @@ class ClientBridge:
         self.tcp_port = tcp_port
         self.authenticate = authenticate
         self.encrypt = encrypt
-        self.device: Optional[Device] = None
-        self.connection: Optional[Connection] = None
-        self.rfcomm_client: Optional[rfcomm.Client]
-        self.rfcomm_mux: Optional[rfcomm.Multiplexer]
+        self.device: Device | None = None
+        self.connection: Connection | None = None
+        self.rfcomm_client: rfcomm.Client | None
+        self.rfcomm_mux: rfcomm.Multiplexer | None
         self.tcp_connected: bool = False
 
-        self.tcp_tracer: Optional[Tracer]
-        self.rfcomm_tracer: Optional[Tracer]
+        self.tcp_tracer: Tracer | None
+        self.rfcomm_tracer: Tracer | None
 
         if trace:
             self.tcp_tracer = Tracer(color("RFCOMM->TCP", "cyan"))

bumble/apps/scan.py

@@ -217,9 +217,7 @@ async def scan(
 @click.option(
     '--irk',
     metavar='<IRK_HEX>:<ADDRESS>',
-    help=(
-        'Use this IRK for resolving private addresses ' '(may be used more than once)'
-    ),
+    help=('Use this IRK for resolving private addresses (may be used more than once)'),
     multiple=True,
 )
 @click.option(

bumble/apps/speaker/speaker.py

@@ -26,7 +26,6 @@ import pathlib
 import subprocess
 import weakref
 from importlib import resources
-from typing import Optional
 
 import aiohttp
 import click
@@ -156,7 +155,7 @@ class QueuedOutput(Output):
 
     packets: asyncio.Queue
     extractor: AudioExtractor
-    packet_pump_task: Optional[asyncio.Task]
+    packet_pump_task: asyncio.Task | None
     started: bool
 
     def __init__(self, extractor):
@@ -230,8 +229,8 @@ class WebSocketOutput(QueuedOutput):
 class FfplayOutput(QueuedOutput):
     MAX_QUEUE_SIZE = 32768
 
-    subprocess: Optional[asyncio.subprocess.Process]
-    ffplay_task: Optional[asyncio.Task]
+    subprocess: asyncio.subprocess.Process | None
+    ffplay_task: asyncio.Task | None
 
     def __init__(self, codec: str) -> None:
         super().__init__(AudioExtractor.create(codec))

bumble/at.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Union
 
 from bumble import core
 
@@ -36,7 +35,7 @@ def tokenize_parameters(buffer: bytes) -> list[bytes]:
 
         if in_quotes:
             token.extend(char)
-            if char == b'\"':
+            if char == b'"':
                 in_quotes = False
                 tokens.append(token[1:-1])
                 token = bytearray()
@@ -63,18 +62,18 @@ def tokenize_parameters(buffer: bytes) -> list[bytes]:
     return [bytes(token) for token in tokens if len(token) > 0]
 
 
-def parse_parameters(buffer: bytes) -> list[Union[bytes, list]]:
+def parse_parameters(buffer: bytes) -> list[bytes | list]:
     """Parse the parameters using the comma and parenthesis separators.
     Raises AtParsingError in case of invalid input string."""
 
     tokens = tokenize_parameters(buffer)
     accumulator: list[list] = [[]]
-    current: Union[bytes, list] = bytes()
+    current: bytes | list = b''
 
     for token in tokens:
         if token == b',':
             accumulator[-1].append(current)
-            current = bytes()
+            current = b''
         elif token == b'(':
             accumulator.append([])
         elif token == b')':