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

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)

bumble/transport/serial.py

@@ -17,7 +17,6 @@
 # -----------------------------------------------------------------------------
 import asyncio
 import logging
-from typing import Optional
 
 import serial_asyncio
 
@@ -52,7 +51,7 @@ class SerialPacketSource(StreamPacketSource):
         logger.debug('connection made')
         self._ready.set()
 
-    def connection_lost(self, exc: Optional[Exception]) -> None:
+    def connection_lost(self, exc: Exception | None) -> None:
         logger.debug('connection lost')
         self.on_transport_lost()
 

bumble/transport/vhci.py

@@ -16,7 +16,6 @@
 # Imports
 # -----------------------------------------------------------------------------
 import logging
-from typing import Optional
 
 from bumble.transport.common import Transport
 from bumble.transport.file import open_file_transport
@@ -28,7 +27,7 @@ logger = logging.getLogger(__name__)
 
 
 # -----------------------------------------------------------------------------
-async def open_vhci_transport(spec: Optional[str]) -> Transport:
+async def open_vhci_transport(spec: str | None) -> Transport:
     '''
     Open a VHCI transport (only available on some platforms).
     The parameter string is either empty (to use the default VHCI device

bumble/transport/ws_server.py

@@ -16,7 +16,6 @@
 # Imports
 # -----------------------------------------------------------------------------
 import logging
-from typing import Optional
 
 import websockets.asyncio.server
 
@@ -43,8 +42,8 @@ async def open_ws_server_transport(spec: str) -> Transport:
     class WsServerTransport(Transport):
         sink: PumpedPacketSink
         source: ParserSource
-        connection: Optional[websockets.asyncio.server.ServerConnection]
-        server: Optional[websockets.asyncio.server.Server]
+        connection: websockets.asyncio.server.ServerConnection | None
+        server: websockets.asyncio.server.Server | None
 
         def __init__(self) -> None:
             source = ParserSource()

bumble/utils.py

@@ -22,16 +22,12 @@ import collections
 import enum
 import functools
 import logging
-import sys
 import warnings
+from collections.abc import Awaitable, Callable
 from typing import (
     Any,
-    Awaitable,
-    Callable,
-    Optional,
     Protocol,
     TypeVar,
-    Union,
     overload,
 )
 
@@ -170,8 +166,8 @@ class EventWatcher:
     ) -> _Handler: ...
 
     def on(
-        self, emitter: pyee.EventEmitter, event: str, handler: Optional[_Handler] = None
-    ) -> Union[_Handler, Callable[[_Handler], _Handler]]:
+        self, emitter: pyee.EventEmitter, event: str, handler: _Handler | None = None
+    ) -> _Handler | Callable[[_Handler], _Handler]:
         '''Watch an event until the context is closed.
 
         Args:
@@ -199,8 +195,8 @@ class EventWatcher:
     ) -> _Handler: ...
 
     def once(
-        self, emitter: pyee.EventEmitter, event: str, handler: Optional[_Handler] = None
-    ) -> Union[_Handler, Callable[[_Handler], _Handler]]:
+        self, emitter: pyee.EventEmitter, event: str, handler: _Handler | None = None
+    ) -> _Handler | Callable[[_Handler], _Handler]:
         '''Watch an event for once.
 
         Args:
@@ -241,11 +237,7 @@ def cancel_on_event(
             return
         msg = f'abort: {event} event occurred.'
         if isinstance(future, asyncio.Task):
-            # python < 3.9 does not support passing a message on `Task.cancel`
-            if sys.version_info < (3, 9, 0):
-                future.cancel()
-            else:
-                future.cancel(msg)
+            future.cancel(msg)
         else:
             future.set_exception(asyncio.CancelledError(msg))
 
@@ -537,3 +529,20 @@ class IntConvertible(Protocol):
 
     def __init__(self, value: int) -> None: ...
     def __int__(self) -> int: ...
+
+
+# -----------------------------------------------------------------------------
+def crc_16(data: bytes) -> int:
+    """Calculate CRC-16-IBM of given data.
+
+    Polynomial = x^16 + x^15 + x^2 + 1 = 0x8005 or 0xA001(Reversed)
+    """
+    crc = 0x0000
+    for byte in data:
+        crc ^= byte
+        for _ in range(8):
+            if (crc & 0x0001) > 0:
+                crc = (crc >> 1) ^ 0xA001
+            else:
+                crc = crc >> 1
+    return crc

bumble/vendor/android/hci.py

@@ -18,7 +18,6 @@
 import dataclasses
 import struct
 from dataclasses import field
-from typing import Optional
 
 from bumble import hci
 
@@ -51,6 +50,7 @@ class HCI_LE_Get_Vendor_Capabilities_Command(hci.HCI_Command):
     '''
     See https://source.android.com/docs/core/connect/bluetooth/hci_requirements#vendor-specific-capabilities
     '''
+
     return_parameters_fields = [
         ('status', hci.STATUS_SPEC),
         ('max_advt_instances', 1),
@@ -137,6 +137,7 @@ class HCI_Get_Controller_Activity_Energy_Info_Command(hci.HCI_Command):
     '''
     See https://source.android.com/docs/core/connect/bluetooth/hci_requirements#le_get_controller_activity_energy_info
     '''
+
     return_parameters_fields = [
         ('status', hci.STATUS_SPEC),
         ('total_tx_time_ms', 4),
@@ -207,7 +208,7 @@ class HCI_Android_Vendor_Event(hci.HCI_Extended_Event):
     @classmethod
     def subclass_from_parameters(
         cls, parameters: bytes
-    ) -> Optional[hci.HCI_Extended_Event]:
+    ) -> hci.HCI_Extended_Event | None:
         subevent_code = parameters[0]
         if subevent_code == HCI_BLUETOOTH_QUALITY_REPORT_EVENT:
             quality_report_id = parameters[1]
@@ -229,6 +230,7 @@ class HCI_Bluetooth_Quality_Report_Event(HCI_Android_Vendor_Event):
     '''
     See https://source.android.com/docs/core/connect/bluetooth/hci_requirements#bluetooth-quality-report-sub-event
     '''
+
     quality_report_id: int = field(metadata=hci.metadata(1))
     packet_types: int = field(metadata=hci.metadata(1))
     connection_handle: int = field(metadata=hci.metadata(2))

{bumble-0.0.219.dist-info → bumble-0.0.221.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: bumble
-Version: 0.0.219
+Version: 0.0.221
 Summary: Bluetooth Stack for Apps, Emulation, Test and Experimentation
 Author-email: Google <bumble-dev@google.com>
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://github.com/google/bumble
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp~=3.8; platform_system != "Emscripten"
@@ -25,6 +25,7 @@ Requires-Dist: pyee>=13.0.0
 Requires-Dist: pyserial-asyncio>=0.5; platform_system != "Emscripten"
 Requires-Dist: pyserial>=3.5; platform_system != "Emscripten"
 Requires-Dist: pyusb>=1.2; platform_system != "Emscripten"
+Requires-Dist: tomli~=2.2.1; platform_system != "Emscripten"
 Requires-Dist: websockets>=15.0.1; platform_system != "Emscripten"
 Provides-Extra: build
 Requires-Dist: build>=0.7; extra == "build"
@@ -38,12 +39,12 @@ Requires-Dist: black~=25.1; extra == "development"
 Requires-Dist: bt-test-interfaces>=0.0.6; extra == "development"
 Requires-Dist: grpcio-tools>=1.62.1; extra == "development"
 Requires-Dist: invoke>=1.7.3; extra == "development"
-Requires-Dist: isort~=5.13.2; extra == "development"
 Requires-Dist: mobly>=1.12.2; extra == "development"
 Requires-Dist: mypy==1.12.0; extra == "development"
 Requires-Dist: nox>=2022; extra == "development"
 Requires-Dist: pylint==3.3.1; extra == "development"
 Requires-Dist: pyyaml>=6.0; extra == "development"
+Requires-Dist: ruff==0.14.10; extra == "development"
 Requires-Dist: types-appdirs>=1.4.3; extra == "development"
 Requires-Dist: types-invoke>=1.7.3; extra == "development"
 Requires-Dist: types-protobuf>=4.21.0; extra == "development"