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

bumble/smp.py

@@ -27,17 +27,9 @@ from __future__ import annotations
 import asyncio
 import enum
 import logging
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Awaitable,
-    Callable,
-    ClassVar,
-    Optional,
-    TypeVar,
-    cast,
-)
+from typing import TYPE_CHECKING, ClassVar, TypeVar, cast
 
 from bumble import crypto, utils
 from bumble.colors import color
@@ -213,10 +205,10 @@ class SMP_Command:
     fields: ClassVar[Fields]
     code: int = field(default=0, init=False)
     name: str = field(default='', init=False)
-    _payload: Optional[bytes] = field(default=None, init=False)
+    _payload: bytes | None = field(default=None, init=False)
 
     @classmethod
-    def from_bytes(cls, pdu: bytes) -> "SMP_Command":
+    def from_bytes(cls, pdu: bytes) -> SMP_Command:
         code = pdu[0]
 
         subclass = SMP_Command.smp_classes.get(code)
@@ -554,7 +546,7 @@ class OobContext:
     r: bytes
 
     def __init__(
-        self, ecc_key: Optional[crypto.EccKey] = None, r: Optional[bytes] = None
+        self, ecc_key: crypto.EccKey | None = None, r: bytes | None = None
     ) -> None:
         self.ecc_key = crypto.EccKey.generate() if ecc_key is None else ecc_key
         self.r = crypto.r() if r is None else r
@@ -570,7 +562,7 @@ class OobLegacyContext:
 
     tk: bytes
 
-    def __init__(self, tk: Optional[bytes] = None) -> None:
+    def __init__(self, tk: bytes | None = None) -> None:
         self.tk = crypto.r() if tk is None else tk
 
 
@@ -677,31 +669,31 @@ class Session:
         self.stk = None
         self.ltk_ediv = 0
         self.ltk_rand = bytes(8)
-        self.link_key: Optional[bytes] = None
+        self.link_key: bytes | None = None
         self.maximum_encryption_key_size: int = 0
         self.initiator_key_distribution: int = 0
         self.responder_key_distribution: int = 0
-        self.peer_random_value: Optional[bytes] = None
+        self.peer_random_value: bytes | None = None
         self.peer_public_key_x: bytes = bytes(32)
         self.peer_public_key_y = bytes(32)
         self.peer_ltk = None
         self.peer_ediv = None
-        self.peer_rand: Optional[bytes] = None
+        self.peer_rand: bytes | None = None
         self.peer_identity_resolving_key = None
-        self.peer_bd_addr: Optional[Address] = None
+        self.peer_bd_addr: Address | None = None
         self.peer_signature_key = None
         self.peer_expected_distributions: list[type[SMP_Command]] = []
         self.dh_key = b''
         self.confirm_value = None
-        self.passkey: Optional[int] = None
+        self.passkey: int | None = None
         self.passkey_ready = asyncio.Event()
         self.passkey_step = 0
         self.passkey_display = False
         self.pairing_method: PairingMethod = PairingMethod.JUST_WORKS
         self.pairing_config = pairing_config
-        self.wait_before_continuing: Optional[asyncio.Future[None]] = None
+        self.wait_before_continuing: asyncio.Future[None] | None = None
         self.completed = False
-        self.ctkd_task: Optional[Awaitable[None]] = None
+        self.ctkd_task: Awaitable[None] | None = None
 
         # Decide if we're the initiator or the responder
         self.is_initiator = is_initiator
@@ -720,7 +712,7 @@ class Session:
 
         # Create a future that can be used to wait for the session to complete
         if self.is_initiator:
-            self.pairing_result: Optional[asyncio.Future[None]] = (
+            self.pairing_result: asyncio.Future[None] | None = (
                 asyncio.get_running_loop().create_future()
             )
         else:
@@ -828,7 +820,7 @@ class Session:
     def auth_req(self) -> int:
         return smp_auth_req(self.bonding, self.mitm, self.sc, self.keypress, self.ct2)
 
-    def get_long_term_key(self, rand: bytes, ediv: int) -> Optional[bytes]:
+    def get_long_term_key(self, rand: bytes, ediv: int) -> bytes | None:
         if not self.sc and not self.completed:
             if rand == self.ltk_rand and ediv == self.ltk_ediv:
                 return self.stk
@@ -939,7 +931,7 @@ class Session:
             self.pairing_config.delegate.display_number(self.passkey, digits=6)
         )
 
-    def input_passkey(self, next_steps: Optional[Callable[[], None]] = None) -> None:
+    def input_passkey(self, next_steps: Callable[[], None] | None = None) -> None:
         # Prompt the user for the passkey displayed on the peer
         def after_input(passkey: int) -> None:
             self.passkey = passkey
@@ -956,7 +948,7 @@ class Session:
         self.prompt_user_for_number(after_input)
 
     def display_or_input_passkey(
-        self, next_steps: Optional[Callable[[], None]] = None
+        self, next_steps: Callable[[], None] | None = None
     ) -> None:
         if self.passkey_display:
 
@@ -1006,7 +998,6 @@ class Session:
         self.send_command(response)
 
     def send_pairing_confirm_command(self) -> None:
-
         if self.pairing_method != PairingMethod.OOB:
             self.r = crypto.r()
             logger.debug(f'generated random: {self.r.hex()}')
@@ -1842,7 +1833,6 @@ class Session:
             self.send_public_key_command()
 
             def next_steps() -> None:
-
                 if self.pairing_method in (
                     PairingMethod.JUST_WORKS,
                     PairingMethod.NUMERIC_COMPARISON,
@@ -1929,7 +1919,7 @@ class Manager(utils.EventEmitter):
     sessions: dict[int, Session]
     pairing_config_factory: Callable[[Connection], PairingConfig]
     session_proxy: type[Session]
-    _ecc_key: Optional[crypto.EccKey]
+    _ecc_key: crypto.EccKey | None
 
     def __init__(
         self,
@@ -2022,7 +2012,7 @@ class Manager(utils.EventEmitter):
         self.device.on_pairing_start(session.connection)
 
     async def on_pairing(
-        self, session: Session, identity_address: Optional[Address], keys: PairingKeys
+        self, session: Session, identity_address: Address | None, keys: PairingKeys
     ) -> None:
         # Store the keys in the key store
         if self.device.keystore and identity_address is not None:
@@ -2041,7 +2031,7 @@ class Manager(utils.EventEmitter):
 
     def get_long_term_key(
         self, connection: Connection, rand: bytes, ediv: int
-    ) -> Optional[bytes]:
+    ) -> bytes | None:
         if session := self.sessions.get(connection.handle):
             return session.get_long_term_key(rand, ediv)
 

bumble/snoop.py

@@ -16,13 +16,14 @@ import datetime
 import logging
 import os
 import struct
+from collections.abc import Generator
 
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
 from contextlib import contextmanager
 from enum import IntEnum
-from typing import BinaryIO, Generator
+from typing import BinaryIO
 
 from bumble import core
 from bumble.hci import HCI_COMMAND_PACKET, HCI_EVENT_PACKET

bumble/tools/generate_company_id_list.py

@@ -27,7 +27,7 @@ import sys
 import yaml
 
 # -----------------------------------------------------------------------------
-with open(sys.argv[1], "r") as yaml_file:
+with open(sys.argv[1]) as yaml_file:
     root = yaml.safe_load(yaml_file)
     companies = {}
     for company in root["company_identifiers"]:

bumble/tools/intel_util.py

@@ -18,7 +18,7 @@ import asyncio
 # Imports
 # -----------------------------------------------------------------------------
 import logging
-from typing import Any, Optional
+from typing import Any
 
 import click
 
@@ -47,7 +47,7 @@ def print_device_info(device_info: dict[intel.ValueType, Any]) -> None:
 
 
 # -----------------------------------------------------------------------------
-async def get_driver(host: Host, force: bool) -> Optional[intel.Driver]:
+async def get_driver(host: Host, force: bool) -> intel.Driver | None:
     # Create a driver
     driver = await intel.Driver.for_host(host, force)
     if driver is None:

bumble/tools/rtk_fw_download.py

@@ -21,11 +21,11 @@ import urllib.error
 import urllib.request
 
 import click
+from bumble.tools import rtk_util
 
 import bumble.logging
 from bumble.colors import color
 from bumble.drivers import rtk
-from bumble.tools import rtk_util
 
 # -----------------------------------------------------------------------------
 # Logging

bumble/tools/rtk_util.py

@@ -21,7 +21,7 @@ import logging
 import click
 
 import bumble.logging
-from bumble import company_ids, hci, transport
+from bumble import transport
 from bumble.drivers import rtk
 from bumble.host import Host
 

bumble/transport/__init__.py

@@ -18,7 +18,6 @@
 import logging
 import os
 import re
-from typing import Optional
 
 from bumble import utils
 from bumble.snoop import create_snooper
@@ -111,7 +110,7 @@ async def open_transport(name: str) -> Transport:
 
 
 # -----------------------------------------------------------------------------
-async def _open_transport(scheme: str, spec: Optional[str]) -> Transport:
+async def _open_transport(scheme: str, spec: str | None) -> Transport:
     # pylint: disable=import-outside-toplevel
     # pylint: disable=too-many-return-statements
 

bumble/transport/android_emulator.py

@@ -16,7 +16,6 @@
 # Imports
 # -----------------------------------------------------------------------------
 import logging
-from typing import Optional, Union
 
 import grpc.aio
 
@@ -44,7 +43,7 @@ logger = logging.getLogger(__name__)
 
 
 # -----------------------------------------------------------------------------
-async def open_android_emulator_transport(spec: Optional[str]) -> Transport:
+async def open_android_emulator_transport(spec: str | None) -> Transport:
     '''
     Open a transport connection to an Android emulator via its gRPC interface.
     The parameter string has this syntax:
@@ -89,7 +88,7 @@ async def open_android_emulator_transport(spec: Optional[str]) -> Transport:
     logger.debug('connecting to gRPC server at %s', server_address)
     channel = grpc.aio.insecure_channel(server_address)
 
-    service: Union[EmulatedBluetoothServiceStub, VhciForwardingServiceStub]
+    service: EmulatedBluetoothServiceStub | VhciForwardingServiceStub
     if mode == 'host':
         # Connect as a host
         service = EmulatedBluetoothServiceStub(channel)

bumble/transport/android_netsim.py

@@ -22,7 +22,6 @@ import os
 import pathlib
 import platform
 import sys
-from typing import Optional
 
 import grpc.aio
 
@@ -66,7 +65,7 @@ DEFAULT_VARIANT = ''
 
 
 # -----------------------------------------------------------------------------
-def get_ini_dir() -> Optional[pathlib.Path]:
+def get_ini_dir() -> pathlib.Path | None:
     if sys.platform == 'darwin':
         if tmpdir := os.getenv('TMPDIR', None):
             return pathlib.Path(tmpdir)
@@ -100,7 +99,7 @@ def find_grpc_port(instance_number: int) -> int:
     ini_file = ini_dir / ini_file_name(instance_number)
     logger.debug(f'Looking for .ini file at {ini_file}')
     if ini_file.is_file():
-        with open(ini_file, 'r') as ini_file_data:
+        with open(ini_file) as ini_file_data:
             for line in ini_file_data.readlines():
                 if '=' in line:
                     key, value = line.split('=')
@@ -146,7 +145,7 @@ def publish_grpc_port(grpc_port: int, instance_number: int) -> bool:
 
 # -----------------------------------------------------------------------------
 async def open_android_netsim_controller_transport(
-    server_host: Optional[str], server_port: int, options: dict[str, str]
+    server_host: str | None, server_port: int, options: dict[str, str]
 ) -> Transport:
     if server_host == '_' or not server_host:
         server_host = 'localhost'
@@ -156,21 +155,26 @@ async def open_android_netsim_controller_transport(
         logger.warning("unable to publish gRPC port")
 
     class HciDevice:
-        def __init__(self, context, on_data_received):
+        def __init__(self, context, server):
             self.context = context
-            self.on_data_received = on_data_received
+            self.server = server
             self.name = None
+            self.sink = None
             self.loop = asyncio.get_running_loop()
             self.done = self.loop.create_future()
-            self.task = self.loop.create_task(self.pump())
 
         async def pump(self):
             try:
                 await self.pump_loop()
             except asyncio.CancelledError:
                 logger.debug('Pump task canceled')
-                if not self.done.done():
-                    self.done.set_result(None)
+            finally:
+                if self.sink:
+                    logger.debug('Releasing sink')
+                    self.server.release_sink()
+                    self.sink = None
+
+                logger.debug('Pump task terminated')
 
         async def pump_loop(self):
             while True:
@@ -186,15 +190,26 @@ async def open_android_netsim_controller_transport(
                     if request.WhichOneof('request_type') == 'initial_info':
                         logger.debug(f'Received initial info: {request}')
 
+                        self.name = request.initial_info.name
+
                         # We only accept BLUETOOTH
                         if request.initial_info.chip.kind != ChipKind.BLUETOOTH:
                             logger.warning('Unsupported chip type')
                             error = PacketResponse(error='Unsupported chip type')
                             await self.context.write(error)
-                            return
+                            # return
+                            continue
+
+                        # Lease the sink so that no other device can send
+                        self.sink = self.server.lease_sink(self)
+                        if self.sink is None:
+                            logger.warning('Another device is already connected')
+                            error = PacketResponse(error='Device busy')
+                            await self.context.write(error)
+                            # return
+                            continue
 
-                    self.name = request.initial_info.name
-                    continue
+                        continue
 
                 # Expect a data packet
                 request_type = request.WhichOneof('request_type')
@@ -205,10 +220,10 @@ async def open_android_netsim_controller_transport(
                     continue
 
                 # Process the packet
-                data = (
+                assert self.sink is not None
+                self.sink(
                     bytes([request.hci_packet.packet_type]) + request.hci_packet.packet
                 )
-                self.on_data_received(data)
 
         async def send_packet(self, data):
             return await self.context.write(
@@ -217,12 +232,6 @@ async def open_android_netsim_controller_transport(
                 )
             )
 
-        def terminate(self):
-            self.task.cancel()
-
-        async def wait_for_termination(self):
-            await self.done
-
     server_address = f'{server_host}:{server_port}'
 
     class Server(PacketStreamerServicer, ParserSource):
@@ -258,27 +267,27 @@ async def open_android_netsim_controller_transport(
 
             return await self.device.send_packet(packet)
 
-        async def StreamPackets(self, _request_iterator, context):
-            logger.debug('StreamPackets request')
-
-            # Check that we don't already have a device
+        def lease_sink(self, device):
             if self.device:
-                logger.debug('Busy, already serving a device')
-                return PacketResponse(error='Busy')
+                return None
+            self.device = device
+            return self.parser.feed_data
+
+        def release_sink(self):
+            self.device = None
+
+        async def StreamPackets(self, request_iterator, context):
+            logger.debug('StreamPackets request')
 
             # Instantiate a new device
-            self.device = HciDevice(context, self.parser.feed_data)
+            device = HciDevice(context, self)
 
-            # Wait for the device to terminate
-            logger.debug('Waiting for device to terminate')
+            # Pump packets to/from the device
+            logger.debug('Pumping device packets')
             try:
-                await self.device.wait_for_termination()
-            except asyncio.CancelledError:
-                logger.debug('Request canceled')
-                self.device.terminate()
-
-            logger.debug('Device terminated')
-            self.device = None
+                await device.pump()
+            finally:
+                logger.debug('Pump terminated')
 
     server = Server()
     await server.start()
@@ -291,9 +300,9 @@ async def open_android_netsim_controller_transport(
 
 # -----------------------------------------------------------------------------
 async def open_android_netsim_host_transport_with_address(
-    server_host: Optional[str],
+    server_host: str | None,
     server_port: int,
-    options: Optional[dict[str, str]] = None,
+    options: dict[str, str] | None = None,
 ):
     if server_host == '_' or not server_host:
         server_host = 'localhost'
@@ -318,7 +327,7 @@ async def open_android_netsim_host_transport_with_address(
 
 # -----------------------------------------------------------------------------
 async def open_android_netsim_host_transport_with_channel(
-    channel, options: Optional[dict[str, str]] = None
+    channel, options: dict[str, str] | None = None
 ):
     # Wrapper for I/O operations
     class HciDevice:
@@ -398,7 +407,7 @@ async def open_android_netsim_host_transport_with_channel(
 
 
 # -----------------------------------------------------------------------------
-async def open_android_netsim_transport(spec: Optional[str]) -> Transport:
+async def open_android_netsim_transport(spec: str | None) -> Transport:
     '''
     Open a transport connection as a client or server, implementing Android's `netsim`
     simulator protocol over gRPC.

bumble/transport/common.py

@@ -23,7 +23,7 @@ import io
 import logging
 import struct
 from collections.abc import Awaitable, Callable
-from typing import Any, ContextManager, Optional, Protocol
+from typing import Any, Protocol
 
 from bumble import core, hci
 from bumble.colors import color
@@ -107,11 +107,11 @@ class PacketParser:
     NEED_LENGTH = 1
     NEED_BODY = 2
 
-    sink: Optional[TransportSink]
+    sink: TransportSink | None
     extended_packet_info: dict[int, tuple[int, int, str]]
-    packet_info: Optional[tuple[int, int, str]] = None
+    packet_info: tuple[int, int, str] | None = None
 
-    def __init__(self, sink: Optional[TransportSink] = None) -> None:
+    def __init__(self, sink: TransportSink | None = None) -> None:
         self.sink = sink
         self.extended_packet_info = {}
         self.reset()
@@ -176,7 +176,7 @@ class PacketReader:
         self.source = source
         self.at_end = False
 
-    def next_packet(self) -> Optional[bytes]:
+    def next_packet(self) -> bytes | None:
         # Get the packet type
         packet_type = self.source.read(1)
         if len(packet_type) != 1:
@@ -253,7 +253,7 @@ class BaseSource:
     """
 
     terminated: asyncio.Future[None]
-    sink: Optional[TransportSink]
+    sink: TransportSink | None
 
     def __init__(self) -> None:
         self.terminated = asyncio.get_running_loop().create_future()
@@ -357,7 +357,7 @@ class Transport:
 
 # -----------------------------------------------------------------------------
 class PumpedPacketSource(ParserSource):
-    pump_task: Optional[asyncio.Task[None]]
+    pump_task: asyncio.Task[None] | None
 
     def __init__(self, receive) -> None:
         super().__init__()
@@ -390,7 +390,7 @@ class PumpedPacketSource(ParserSource):
 
 # -----------------------------------------------------------------------------
 class PumpedPacketSink:
-    pump_task: Optional[asyncio.Task[None]]
+    pump_task: asyncio.Task[None] | None
 
     def __init__(self, send: Callable[[bytes], Awaitable[Any]]):
         self.send_function = send
@@ -443,7 +443,7 @@ class SnoopingTransport(Transport):
 
     @staticmethod
     def create_with(
-        transport: Transport, snooper: ContextManager[Snooper]
+        transport: Transport, snooper: contextlib.AbstractContextManager[Snooper]
     ) -> SnoopingTransport:
         """
         Create an instance given a snooper that works as as context manager.

bumble/transport/file.py

@@ -16,7 +16,6 @@
 # Imports
 # -----------------------------------------------------------------------------
 import asyncio
-import io
 import logging
 
 from bumble.transport.common import StreamPacketSink, StreamPacketSource, Transport
@@ -36,7 +35,7 @@ async def open_file_transport(spec: str) -> Transport:
     '''
 
     # Open the file
-    file = io.open(spec, 'r+b', buffering=0)
+    file = open(spec, 'r+b', buffering=0)
 
     # Setup reading
     read_transport, packet_source = await asyncio.get_running_loop().connect_read_pipe(

bumble/transport/hci_socket.py

@@ -22,7 +22,6 @@ import logging
 import os
 import socket
 import struct
-from typing import Optional
 
 from bumble.transport.common import ParserSource, Transport
 
@@ -33,7 +32,7 @@ logger = logging.getLogger(__name__)
 
 
 # -----------------------------------------------------------------------------
-async def open_hci_socket_transport(spec: Optional[str]) -> Transport:
+async def open_hci_socket_transport(spec: str | None) -> Transport:
     '''
     Open an HCI Socket (only available on some platforms).
     The parameter string is either empty (to use the first/default Bluetooth adapter)
@@ -87,7 +86,7 @@ async def open_hci_socket_transport(spec: Optional[str]) -> Transport:
         )
         != 0
     ):
-        raise IOError(ctypes.get_errno(), os.strerror(ctypes.get_errno()))
+        raise OSError(ctypes.get_errno(), os.strerror(ctypes.get_errno()))
 
     class HciSocketSource(ParserSource):
         def __init__(self, hci_socket):

bumble/transport/pty.py

@@ -17,12 +17,10 @@
 # -----------------------------------------------------------------------------
 import asyncio
 import atexit
-import io
 import logging
 import os
 import pty
 import tty
-from typing import Optional
 
 from bumble.transport.common import StreamPacketSink, StreamPacketSource, Transport
 
@@ -33,7 +31,7 @@ logger = logging.getLogger(__name__)
 
 
 # -----------------------------------------------------------------------------
-async def open_pty_transport(spec: Optional[str]) -> Transport:
+async def open_pty_transport(spec: str | None) -> Transport:
     '''
     Open a PTY transport.
     The parameter string may be empty, or a path name where a symbolic link
@@ -48,11 +46,11 @@ async def open_pty_transport(spec: Optional[str]) -> Transport:
     tty.setraw(replica)
 
     read_transport, packet_source = await asyncio.get_running_loop().connect_read_pipe(
-        StreamPacketSource, io.open(primary, 'rb', closefd=False)
+        StreamPacketSource, open(primary, 'rb', closefd=False)
     )
 
     write_transport, _ = await asyncio.get_running_loop().connect_write_pipe(
-        asyncio.BaseProtocol, io.open(primary, 'wb', closefd=False)
+        asyncio.BaseProtocol, open(primary, 'wb', closefd=False)
     )
     packet_sink = StreamPacketSink(write_transport)
 

bumble/transport/pyusb.py

@@ -19,7 +19,6 @@ import asyncio
 import logging
 import threading
 import time
-from typing import Optional
 
 import usb.core
 import usb.util
@@ -284,7 +283,9 @@ async def open_pyusb_transport(spec: str) -> Transport:
             device = await _power_cycle(device)  # type: ignore
         except Exception as e:
             logging.debug(e, stack_info=True)
-            logging.info(f"Unable to power cycle {hex(device.idVendor)} {hex(device.idProduct)}")  # type: ignore
+            logging.info(
+                f"Unable to power cycle {hex(device.idVendor)} {hex(device.idProduct)}"
+            )  # type: ignore
 
     # Collect the metadata
     device_metadata = {'vendor_id': device.idVendor, 'product_id': device.idProduct}
@@ -370,7 +371,9 @@ async def _power_cycle(device: UsbDevice) -> UsbDevice:
             # Device needs to be find again otherwise it will appear as disconnected
             return usb.core.find(idVendor=device.idVendor, idProduct=device.idProduct)  # type: ignore
         except USBError:
-            logger.exception(f"Adjustment needed: Please revise the udev rule for device {hex(device.idVendor)}:{hex(device.idProduct)} for proper recognition.")  # type: ignore
+            logger.exception(
+                f"Adjustment needed: Please revise the udev rule for device {hex(device.idVendor)}:{hex(device.idProduct)} for proper recognition."
+            )  # type: ignore
 
     return device
 
@@ -385,7 +388,7 @@ def _set_port_status(device: UsbDevice, port: int, on: bool):
     )
 
 
-def _find_device_by_path(sys_path: str) -> Optional[UsbDevice]:
+def _find_device_by_path(sys_path: str) -> UsbDevice | None:
     """Finds a USB device based on its system path."""
     bus_num, *port_parts = sys_path.split('-')
     ports = [int(port) for port in port_parts[0].split('.')]
@@ -398,7 +401,7 @@ def _find_device_by_path(sys_path: str) -> Optional[UsbDevice]:
     return None
 
 
-def _find_hub_by_device_path(sys_path: str) -> Optional[UsbDevice]:
+def _find_hub_by_device_path(sys_path: str) -> UsbDevice | None:
     """Finds the USB hub associated with a specific device path."""
     hub_sys_path = sys_path.rsplit('.', 1)[0]
     hub_device = _find_device_by_path(hub_sys_path)