improve exception messages

apps/controller_info.py

@@ -30,8 +30,6 @@ from bumble.hci import (
     HCI_VERSION_NAMES,
     LMP_VERSION_NAMES,
     HCI_Command,
-    HCI_Command_Complete_Event,
-    HCI_Command_Status_Event,
     HCI_READ_BD_ADDR_COMMAND,
     HCI_Read_BD_ADDR_Command,
     HCI_READ_LOCAL_NAME_COMMAND,
@@ -47,20 +45,11 @@ from bumble.host import Host
 from bumble.transport import open_transport_or_link
 
 
-# -----------------------------------------------------------------------------
-def command_succeeded(response):
-    if isinstance(response, HCI_Command_Status_Event):
-        return response.status == HCI_SUCCESS
-    if isinstance(response, HCI_Command_Complete_Event):
-        return response.return_parameters.status == HCI_SUCCESS
-    return False
-
-
 # -----------------------------------------------------------------------------
 async def get_classic_info(host):
     if host.supports_command(HCI_READ_BD_ADDR_COMMAND):
         response = await host.send_command(HCI_Read_BD_ADDR_Command())
-        if command_succeeded(response):
+        if response.return_parameters.status == HCI_SUCCESS:
             print()
             print(
                 color('Classic Address:', 'yellow'), response.return_parameters.bd_addr
@@ -68,7 +57,7 @@ async def get_classic_info(host):
 
     if host.supports_command(HCI_READ_LOCAL_NAME_COMMAND):
         response = await host.send_command(HCI_Read_Local_Name_Command())
-        if command_succeeded(response):
+        if response.return_parameters.status == HCI_SUCCESS:
             print()
             print(
                 color('Local Name:', 'yellow'),
@@ -84,7 +73,7 @@ async def get_le_info(host):
         response = await host.send_command(
             HCI_LE_Read_Number_Of_Supported_Advertising_Sets_Command()
         )
-        if command_succeeded(response):
+        if response.return_parameters.status == HCI_SUCCESS:
             print(
                 color('LE Number Of Supported Advertising Sets:', 'yellow'),
                 response.return_parameters.num_supported_advertising_sets,
@@ -95,7 +84,7 @@ async def get_le_info(host):
         response = await host.send_command(
             HCI_LE_Read_Maximum_Advertising_Data_Length_Command()
         )
-        if command_succeeded(response):
+        if response.return_parameters.status == HCI_SUCCESS:
             print(
                 color('LE Maximum Advertising Data Length:', 'yellow'),
                 response.return_parameters.max_advertising_data_length,
@@ -104,7 +93,7 @@ async def get_le_info(host):
 
     if host.supports_command(HCI_LE_READ_MAXIMUM_DATA_LENGTH_COMMAND):
         response = await host.send_command(HCI_LE_Read_Maximum_Data_Length_Command())
-        if command_succeeded(response):
+        if response.return_parameters.status == HCI_SUCCESS:
             print(
                 color('Maximum Data Length:', 'yellow'),
                 (

bumble/device.py

@@ -50,7 +50,6 @@ from .hci import (
     HCI_LE_EXTENDED_CREATE_CONNECTION_COMMAND,
     HCI_LE_RAND_COMMAND,
     HCI_LE_READ_PHY_COMMAND,
-    HCI_LE_SET_PHY_COMMAND,
     HCI_MITM_NOT_REQUIRED_GENERAL_BONDING_AUTHENTICATION_REQUIREMENTS,
     HCI_MITM_NOT_REQUIRED_NO_BONDING_AUTHENTICATION_REQUIREMENTS,
     HCI_MITM_REQUIRED_GENERAL_BONDING_AUTHENTICATION_REQUIREMENTS,
@@ -1243,11 +1242,6 @@ class Device(CompositeEventEmitter):
         # Done
         self.powered_on = True
 
-    async def power_off(self) -> None:
-        if self.powered_on:
-            await self.host.flush()
-            self.powered_on = False
-
     def supports_le_feature(self, feature):
         return self.host.supports_le_feature(feature)
 
@@ -1672,7 +1666,7 @@ class Device(CompositeEventEmitter):
                         )
                     )
                     if not phys:
-                        raise ValueError('at least one supported PHY needed')
+                        raise ValueError('least one supported PHY needed')
 
                     phy_count = len(phys)
                     initiating_phys = phy_list_to_bits(phys)
@@ -1813,7 +1807,7 @@ class Device(CompositeEventEmitter):
 
                 try:
                     return await self.abort_on('flush', pending_connection)
-                except core.ConnectionError as error:
+                except ConnectionError as error:
                     raise core.TimeoutError() from error
         finally:
             self.remove_listener('connection', on_connection)
@@ -2047,31 +2041,21 @@ class Device(CompositeEventEmitter):
     async def set_connection_phy(
         self, connection, tx_phys=None, rx_phys=None, phy_options=None
     ):
-        if not self.host.supports_command(HCI_LE_SET_PHY_COMMAND):
-            logger.warning('ignoring request, command not supported')
-            return
-
         all_phys_bits = (1 if tx_phys is None else 0) | (
             (1 if rx_phys is None else 0) << 1
         )
 
-        result = await self.send_command(
+        return await self.send_command(
             HCI_LE_Set_PHY_Command(
                 connection_handle=connection.handle,
                 all_phys=all_phys_bits,
                 tx_phys=phy_list_to_bits(tx_phys),
                 rx_phys=phy_list_to_bits(rx_phys),
                 phy_options=0 if phy_options is None else int(phy_options),
-            )
+            ),
+            check_result=True,
         )
 
-        if result.status != HCI_COMMAND_STATUS_PENDING:
-            logger.warning(
-                'HCI_LE_Set_PHY_Command failed: '
-                f'{HCI_Constant.error_name(result.status)}'
-            )
-            raise HCI_StatusError(result)
-
     async def set_default_phy(self, tx_phys=None, rx_phys=None):
         all_phys_bits = (1 if tx_phys is None else 0) | (
             (1 if rx_phys is None else 0) << 1
@@ -2510,7 +2494,7 @@ class Device(CompositeEventEmitter):
             self.advertising = False
 
         # Notify listeners
-        error = core.ConnectionError(
+        error = ConnectionError(
             error_code,
             transport,
             peer_address,
@@ -2583,7 +2567,7 @@ class Device(CompositeEventEmitter):
     @with_connection_from_handle
     def on_disconnection_failure(self, connection, error_code):
         logger.debug(f'*** Disconnection failed: {error_code}')
-        error = core.ConnectionError(
+        error = ConnectionError(
             error_code,
             connection.transport,
             connection.peer_address,

bumble/gatt_server.py

@@ -691,7 +691,7 @@ class Server(EventEmitter):
                 length=entry_size, attribute_data_list=b''.join(attribute_data_list)
             )
         else:
-            logging.debug(f"not found {request}")
+            logging.warning(f"not found {request}")
 
         self.send_response(connection, response)
 

bumble/host.py

@@ -276,7 +276,7 @@ class Host(AbortableEventEmitter):
 
     def send_hci_packet(self, packet):
         if self.snooper:
-            self.snooper.snoop(packet, Snooper.Direction.HOST_TO_CONTROLLER)
+            self.snooper.snoop(bytes(packet), Snooper.Direction.HOST_TO_CONTROLLER)
 
         self.hci_sink.on_packet(packet.to_bytes())
 
@@ -425,7 +425,7 @@ class Host(AbortableEventEmitter):
         logger.debug(f'{color("### CONTROLLER -> HOST", "green")}: {packet}')
 
         if self.snooper:
-            self.snooper.snoop(packet, Snooper.Direction.CONTROLLER_TO_HOST)
+            self.snooper.snoop(bytes(packet), Snooper.Direction.CONTROLLER_TO_HOST)
 
         # If the packet is a command, invoke the handler for this packet
         if packet.hci_packet_type == HCI_COMMAND_PACKET:

bumble/l2cap.py

@@ -796,11 +796,6 @@ class Channel(EventEmitter):
         self.disconnection_result = asyncio.get_running_loop().create_future()
         return await self.disconnection_result
 
-    def abort(self):
-        if self.state == self.OPEN:
-            self.change_state(self.CLOSED)
-            self.emit('close')
-
     def send_configure_request(self):
         options = L2CAP_Control_Frame.encode_configuration_options(
             [
@@ -1110,10 +1105,6 @@ class LeConnectionOrientedChannel(EventEmitter):
         self.disconnection_result = asyncio.get_running_loop().create_future()
         return await self.disconnection_result
 
-    def abort(self):
-        if self.state == self.CONNECTED:
-            self.change_state(self.DISCONNECTED)
-
     def on_pdu(self, pdu):
         if self.sink is None:
             logger.warning('received pdu without a sink')
@@ -1501,12 +1492,8 @@ class ChannelManager:
     def on_disconnection(self, connection_handle, _reason):
         logger.debug(f'disconnection from {connection_handle}, cleaning up channels')
         if connection_handle in self.channels:
-            for _, channel in self.channels[connection_handle].items():
-                channel.abort()
             del self.channels[connection_handle]
         if connection_handle in self.le_coc_channels:
-            for _, channel in self.le_coc_channels[connection_handle].items():
-                channel.abort()
             del self.le_coc_channels[connection_handle]
         if connection_handle in self.identifiers:
             del self.identifiers[connection_handle]

bumble/rfcomm.py

@@ -852,27 +852,17 @@ class Server(EventEmitter):
         # Register ourselves with the L2CAP channel manager
         device.register_l2cap_server(RFCOMM_PSM, self.on_connection)
 
-    def listen(self, acceptor, channel=0):
-        if channel:
-            if channel in self.acceptors:
-                # Busy
-                return 0
-        else:
-            # Find a free channel number
-            for candidate in range(
-                RFCOMM_DYNAMIC_CHANNEL_NUMBER_START,
-                RFCOMM_DYNAMIC_CHANNEL_NUMBER_END + 1,
-            ):
-                if candidate not in self.acceptors:
-                    channel = candidate
-                    break
+    def listen(self, acceptor):
+        # Find a free channel number
+        for channel in range(
+            RFCOMM_DYNAMIC_CHANNEL_NUMBER_START, RFCOMM_DYNAMIC_CHANNEL_NUMBER_END + 1
+        ):
+            if channel not in self.acceptors:
+                self.acceptors[channel] = acceptor
+                return channel
 
-            if channel == 0:
-                # All channels used...
-                return 0
-
-        self.acceptors[channel] = acceptor
-        return channel
+        # All channels used...
+        return 0
 
     def on_connection(self, l2cap_channel):
         logger.debug(f'+++ new L2CAP connection: {l2cap_channel}')

bumble/snoop.py

@@ -15,12 +15,21 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
+from contextlib import contextmanager
 from enum import IntEnum
+import logging
 import struct
 import datetime
-from typing import BinaryIO
+from typing import BinaryIO, Generator
+import os
 
-from bumble.hci import HCI_Packet, HCI_COMMAND_PACKET, HCI_EVENT_PACKET
+from bumble.hci import HCI_COMMAND_PACKET, HCI_EVENT_PACKET
+
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+logger = logging.getLogger(__name__)
 
 
 # -----------------------------------------------------------------------------
@@ -44,7 +53,7 @@ class Snooper:
         HCI_BSCP = 1003
         H5 = 1004
 
-    def snoop(self, hci_packet: HCI_Packet, direction: Direction) -> None:
+    def snoop(self, hci_packet: bytes, direction: Direction) -> None:
         """Snoop on an HCI packet."""
 
 
@@ -67,9 +76,10 @@ class BtSnooper(Snooper):
             self.IDENTIFICATION_PATTERN + struct.pack('>LL', 1, self.DataLinkType.H4)
         )
 
-    def snoop(self, hci_packet: HCI_Packet, direction: Snooper.Direction) -> None:
+    def snoop(self, hci_packet: bytes, direction: Snooper.Direction) -> None:
         flags = int(direction)
-        if hci_packet.hci_packet_type in (HCI_EVENT_PACKET, HCI_COMMAND_PACKET):
+        packet_type = hci_packet[0]
+        if packet_type in (HCI_EVENT_PACKET, HCI_COMMAND_PACKET):
             flags |= 0x10
 
         # Compute the current timestamp
@@ -79,15 +89,82 @@ class BtSnooper(Snooper):
         )
 
         # Emit the record
-        packet_data = bytes(hci_packet)
         self.output.write(
             struct.pack(
                 '>IIIIQ',
-                len(packet_data),  # Original Length
-                len(packet_data),  # Included Length
+                len(hci_packet),  # Original Length
+                len(hci_packet),  # Included Length
                 flags,  # Packet Flags
                 0,  # Cumulative Drops
                 timestamp,  # Timestamp
             )
-            + packet_data
+            + hci_packet
         )
+
+
+# -----------------------------------------------------------------------------
+_SNOOPER_INSTANCE_COUNT = 0
+
+
+@contextmanager
+def create_snooper(spec: str) -> Generator[Snooper, None, None]:
+    """
+    Create a snooper given a specification string.
+
+    The general syntax for the specification string is:
+      <snooper-type>:<type-specific-arguments>
+
+    Supported snooper types are:
+
+      btsnoop
+        The syntax for the type-specific arguments for this type is:
+        <io-type>:<io-type-specific-arguments>
+
+        Supported I/O types are:
+
+        file
+          The type-specific arguments for this I/O type is a string that is converted
+          to a file path using the python `str.format()` string formatting. The log
+          records will be written to that file if it can be opened/created.
+          The keyword args that may be referenced by the string pattern are:
+            now: the value of `datetime.now()`
+            utcnow: the value of `datetime.utcnow()`
+            pid: the current process ID.
+            instance: the instance ID in the current process.
+
+    Examples:
+      btsnoop:file:my_btsnoop.log
+      btsnoop:file:/tmp/bumble_{now:%Y-%m-%d-%H:%M:%S}_{pid}.log
+
+    """
+    if ':' not in spec:
+        raise ValueError('snooper type prefix missing')
+
+    snooper_type, snooper_args = spec.split(':', maxsplit=1)
+
+    if snooper_type == 'btsnoop':
+        if ':' not in snooper_args:
+            raise ValueError('I/O type for btsnoop snooper type missing')
+
+        io_type, io_name = snooper_args.split(':', maxsplit=1)
+        if io_type == 'file':
+            # Process the file name string pattern.
+            global _SNOOPER_INSTANCE_COUNT
+            file_path = io_name.format(
+                now=datetime.datetime.now(),
+                utcnow=datetime.datetime.utcnow(),
+                pid=os.getpid(),
+                instance=_SNOOPER_INSTANCE_COUNT,
+            )
+
+            # Open the file
+            logger.debug(f'Snoop file: {file_path}')
+            with open(file_path, 'wb') as snoop_file:
+                _SNOOPER_INSTANCE_COUNT += 1
+                yield BtSnooper(snoop_file)
+                _SNOOPER_INSTANCE_COUNT -= 1
+                return
+
+        raise ValueError(f'I/O type {io_type} not supported')
+
+    raise ValueError(f'snooper type {snooper_type} not found')

bumble/transport/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2021-2022 Google LLC
+# Copyright 2021-2023 Google LLC
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,10 +15,13 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
+from contextlib import asynccontextmanager
 import logging
+import os
 
-from .common import Transport, AsyncPipeSink
+from .common import Transport, AsyncPipeSink, SnoopingTransport
 from ..controller import Controller
+from ..snoop import create_snooper
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -26,14 +29,53 @@ from ..controller import Controller
 logger = logging.getLogger(__name__)
 
 
+# -----------------------------------------------------------------------------
+def _wrap_transport(transport: Transport) -> Transport:
+    """
+    Automatically wrap a Transport instance when a wrapping class can be inferred
+    from the environment.
+    If no wrapping class is applicable, the transport argument is returned as-is.
+    """
+
+    # If BUMBLE_SNOOPER is set, try to automatically create a snooper.
+    if snooper_spec := os.getenv('BUMBLE_SNOOPER'):
+        try:
+            return SnoopingTransport.create_with(
+                transport, create_snooper(snooper_spec)
+            )
+        except Exception as exc:
+            logger.warning(f'Exception while creating snooper: {exc}')
+
+    return transport
+
+
 # -----------------------------------------------------------------------------
 async def open_transport(name: str) -> Transport:
-    '''
+    """
     Open a transport by name.
     The name must be <type>:<parameters>
     Where <parameters> depend on the type (and may be empty for some types).
-    The supported types are: serial,udp,tcp,pty,usb
-    '''
+    The supported types are:
+      * serial
+      * udp
+      * tcp-client
+      * tcp-server
+      * ws-client
+      * ws-server
+      * pty
+      * file
+      * vhci
+      * hci-socket
+      * usb
+      * pyusb
+      * android-emulator
+    """
+
+    return _wrap_transport(await _open_transport(name))
+
+
+# -----------------------------------------------------------------------------
+async def _open_transport(name: str) -> Transport:
     # pylint: disable=import-outside-toplevel
     # pylint: disable=too-many-return-statements
 
@@ -107,7 +149,18 @@ async def open_transport(name: str) -> Transport:
 
 
 # -----------------------------------------------------------------------------
-async def open_transport_or_link(name):
+async def open_transport_or_link(name: str) -> Transport:
+    """
+    Open a transport or a link relay.
+
+    Args:
+      name:
+        Name of the transport or link relay to open.
+        When the name starts with "link-relay:", open a link relay (see RemoteLink
+        for details on what the arguments are).
+        For other namespaces, see `open_transport`.
+
+    """
     if name.startswith('link-relay:'):
         from ..link import RemoteLink  # lazy import
 
@@ -119,6 +172,6 @@ async def open_transport_or_link(name):
             async def close(self):
                 link.close()
 
-        return LinkTransport(controller, AsyncPipeSink(controller))
+        return _wrap_transport(LinkTransport(controller, AsyncPipeSink(controller)))
 
     return await open_transport(name)

bumble/transport/common.py

@@ -15,12 +15,16 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
+from __future__ import annotations
+import contextlib
 import struct
 import asyncio
 import logging
+from typing import ContextManager
 
 from .. import hci
 from ..colors import color
+from ..snoop import Snooper
 
 
 # -----------------------------------------------------------------------------
@@ -246,6 +250,20 @@ class StreamPacketSink:
 
 # -----------------------------------------------------------------------------
 class Transport:
+    """
+    Base class for all transports.
+
+    A Transport represents a source and a sink together.
+    An instance must be closed by calling close() when no longer used. Instances
+    implement the ContextManager protocol so that they may be used in a `async with`
+    statement.
+    An instance is iterable. The iterator yields, in order, its source and sink, so
+    that it may be used with a convenient call syntax like:
+
+    async with create_transport() as (source, sink):
+        ...
+    """
+
     def __init__(self, source, sink):
         self.source = source
         self.sink = sink
@@ -335,3 +353,60 @@ class PumpedTransport(Transport):
     async def close(self):
         await super().close()
         await self.close_function()
+
+
+# -----------------------------------------------------------------------------
+class SnoopingTransport(Transport):
+    """Transport wrapper that snoops on packets to/from a wrapped transport."""
+
+    @staticmethod
+    def create_with(
+        transport: Transport, snooper: ContextManager[Snooper]
+    ) -> SnoopingTransport:
+        """
+        Create an instance given a snooper that works as as context manager.
+
+        The returned instance will exit the snooper context when it is closed.
+        """
+        with contextlib.ExitStack() as exit_stack:
+            return SnoopingTransport(
+                transport, exit_stack.enter_context(snooper), exit_stack.pop_all().close
+            )
+        raise RuntimeError('unexpected code path')  # Satisfy the type checker
+
+    class Source:
+        def __init__(self, source, snooper):
+            self.source = source
+            self.snooper = snooper
+            self.sink = None
+
+        def set_packet_sink(self, sink):
+            self.sink = sink
+            self.source.set_packet_sink(self)
+
+        def on_packet(self, packet):
+            self.snooper.snoop(packet, Snooper.Direction.CONTROLLER_TO_HOST)
+            if self.sink:
+                self.sink.on_packet(packet)
+
+    class Sink:
+        def __init__(self, sink, snooper):
+            self.sink = sink
+            self.snooper = snooper
+
+        def on_packet(self, packet):
+            self.snooper.snoop(packet, Snooper.Direction.HOST_TO_CONTROLLER)
+            if self.sink:
+                self.sink.on_packet(packet)
+
+    def __init__(self, transport, snooper, close_snooper=None):
+        super().__init__(
+            self.Source(transport.source, snooper), self.Sink(transport.sink, snooper)
+        )
+        self.transport = transport
+        self.close_snooper = close_snooper
+
+    async def close(self):
+        await self.transport.close()
+        if self.close_snooper:
+            self.close_snooper()

bumble/utils.py

@@ -20,7 +20,7 @@ import logging
 import traceback
 import collections
 import sys
-from typing import Awaitable, Set, TypeVar
+from typing import Awaitable, TypeVar
 from functools import wraps
 from pyee import EventEmitter
 
@@ -157,9 +157,6 @@ class AsyncRunner:
     # Shared default queue
     default_queue = WorkQueue()
 
-    # Shared set of running tasks
-    running_tasks: Set[Awaitable] = set()
-
     @staticmethod
     def run_in_task(queue=None):
         """
@@ -190,19 +187,6 @@ class AsyncRunner:
 
         return decorator
 
-    @staticmethod
-    def spawn(coroutine):
-        """
-        Spawn a task to run a coroutine in a "fire and forget" mode.
-
-        Using this method instead of just calling `asyncio.create_task(coroutine)`
-        is necessary when you don't keep a reference to the task, because `asyncio`
-        only keeps weak references to alive tasks.
-        """
-        task = asyncio.create_task(coroutine)
-        AsyncRunner.running_tasks.add(task)
-        task.add_done_callback(AsyncRunner.running_tasks.remove)
-
 
 # -----------------------------------------------------------------------------
 class FlowControlAsyncPipe:

docs/mkdocs/mkdocs.yml

@@ -43,7 +43,7 @@ nav:
   - Apps & Tools:
     - Overview: apps_and_tools/index.md
     - Console: apps_and_tools/console.md
-    - Bench: apps_and_tools/bench.md
+    - Link Relay: apps_and_tools/link_relay.md
     - HCI Bridge: apps_and_tools/hci_bridge.md
     - Golden Gate Bridge: apps_and_tools/gg_bridge.md
     - Show: apps_and_tools/show.md
@@ -51,7 +51,6 @@ nav:
     - Pair: apps_and_tools/pair.md
     - Unbond: apps_and_tools/unbond.md
     - USB Probe: apps_and_tools/usb_probe.md
-    - Link Relay: apps_and_tools/link_relay.md
   - Hardware:
     - Overview: hardware/index.md
   - Platforms:
@@ -63,7 +62,7 @@ nav:
   - Examples:
     - Overview: examples/index.md
 
-copyright: Copyright 2021-2023 Google LLC
+copyright: Copyright 2021-2022 Google LLC
 
 theme:
   name: 'material'

docs/mkdocs/src/apps_and_tools/bench.md

@@ -1,158 +0,0 @@
-BENCH TOOL
-==========
-
-The "bench" tool implements a number of different ways of measuring the
-throughput and/or latency between two devices.
-
-# General Usage
-
-```
-Usage: bench.py [OPTIONS] COMMAND [ARGS]...
-
-Options:
-  --device-config FILENAME        Device configuration file
-  --role [sender|receiver|ping|pong]
-  --mode [gatt-client|gatt-server|l2cap-client|l2cap-server|rfcomm-client|rfcomm-server]
-  --att-mtu MTU                   GATT MTU (gatt-client mode)  [23<=x<=517]
-  -s, --packet-size SIZE          Packet size (server role)  [8<=x<=4096]
-  -c, --packet-count COUNT        Packet count (server role)
-  -sd, --start-delay SECONDS      Start delay (server role)
-  --help                          Show this message and exit.
-
-Commands:
-  central     Run as a central (initiates the connection)
-  peripheral  Run as a peripheral (waits for a connection)
-```
-
-## Options for the ``central`` Command
-```
-Usage: bumble-bench central [OPTIONS] TRANSPORT
-
-  Run as a central (initiates the connection)
-
-Options:
-  --peripheral ADDRESS_OR_NAME    Address or name to connect to
-  --connection-interval, --ci CONNECTION_INTERVAL
-                                  Connection interval (in ms)
-  --phy [1m|2m|coded]             PHY to use
-  --help                          Show this message and exit.
-```
-
-
-To test once device against another, one of the two devices must be running 
-the ``peripheral`` command and the other the ``central`` command. The device
-running the ``peripheral`` command will accept connections from the device
-running the ``central`` command.
-When using Bluetooth LE (all modes except for ``rfcomm-server`` and ``rfcomm-client``utils),
-the default addresses configured in the tool should be sufficient. But when using 
-Bluetooth Classic, the address of the Peripheral must be specified on the Central 
-using the ``--peripheral`` option. The address will be printed by the Peripheral when
-it starts.
-
-Independently of whether the device is the Central or Peripheral, each device selects a
-``mode`` and and ``role`` to run as. The ``mode`` and ``role`` of the Central and Peripheral
-must be compatible.
-
-Device 1 mode     | Device 2 mode
-------------------|------------------
-``gatt-client``   | ``gatt-server``
-``l2cap-client``  | ``l2cap-server``
-``rfcomm-client`` | ``rfcomm-server``
-
-Device 1 role | Device 2 role
---------------|--------------
-``sender``    | ``receiver``
-``ping``      | ``pong``
-
-
-# Examples
-
-In the following examples, we have two USB Bluetooth controllers, one on `usb:0` and
-the other on `usb:1`, and two consoles/terminals. We will run a command in each.
-
-!!! example "GATT Throughput"
-    Using the default mode and role for the Central and Peripheral.
-
-    In the first console/terminal:
-    ```
-    $ bumble-bench peripheral usb:0
-    ```
-
-    In the second console/terminal:
-    ```
-    $ bumble-bench central usb:1
-    ```
-
-    In this default configuration, the Central runs a Sender, as a GATT client, 
-    connecting to the Peripheral running a Receiver, as a GATT server.
-
-!!! example "L2CAP Throughput"
-    In the first console/terminal:
-    ```
-    $ bumble-bench --mode l2cap-server peripheral usb:0
-    ```
-
-    In the second console/terminal:
-    ```
-    $ bumble-bench --mode l2cap-client central usb:1
-    ```
-
-!!! example "RFComm Throughput"
-    In the first console/terminal:
-    ```
-    $ bumble-bench --mode rfcomm-server peripheral usb:0
-    ```
-
-    NOTE: the BT address of the Peripheral will be printed out, use it with the
-    ``--peripheral`` option for the Central.
-
-    In this example, we use a larger packet size and packet count than the default.
-
-    In the second console/terminal:
-    ```
-    $ bumble-bench --mode rfcomm-client --packet-size 2000 --packet-count 100 central --peripheral 00:16:A4:5A:40:F2 usb:1
-    ```
-
-!!! example "Ping/Pong Latency"
-    In the first console/terminal:
-    ```
-    $ bumble-bench --role pong peripheral usb:0
-    ```
-
-    In the second console/terminal:
-    ```
-    $ bumble-bench --role ping central usb:1
-    ```
-
-!!! example "Reversed modes with GATT and custom connection interval"
-    In the first console/terminal:
-    ```
-    $ bumble-bench --mode gatt-client peripheral usb:0
-    ```
-
-    In the second console/terminal:
-    ```
-    $ bumble-bench --mode gatt-server central --ci 10 usb:1
-    ```
-
-!!! example "Reversed modes with L2CAP and custom PHY"
-    In the first console/terminal:
-    ```
-    $ bumble-bench --mode l2cap-client peripheral usb:0
-    ```
-
-    In the second console/terminal:
-    ```
-    $ bumble-bench --mode l2cap-server central --phy 2m usb:1
-    ```
-
-!!! example "Reversed roles with L2CAP"
-    In the first console/terminal:
-    ```
-    $ bumble-bench --mode l2cap-client --role sender peripheral usb:0
-    ```
-
-    In the second console/terminal:
-    ```
-    $ bumble-bench --mode l2cap-server --role receiver central usb:1
-    ```

docs/mkdocs/src/apps_and_tools/index.md

@@ -5,7 +5,6 @@ Included in the project are a few apps and tools, built on top of the core libra
 These include:
 
   * [Console](console.md) - an interactive text-based console
-  * [Bench](bench.md) - Speed and Latency benchmarking between two devices (LE and Classic)
   * [Pair](pair.md) - Pair/bond two devices (LE and Classic)
   * [Unbond](unbond.md) - Remove a previously established bond
   * [HCI Bridge](hci_bridge.md) - a HCI transport bridge to connect two HCI transports and filter/snoop the HCI packets

docs/mkdocs/src/index.md

@@ -8,7 +8,8 @@ The project initially only supported BLE (Bluetooth Low Energy), but support for
 eventually added. Support for BLE is therefore currently somewhat more advanced than for Classic.
 
 !!! warning
-    This project is still in an early state of development where some things are still missing or broken, and what's implemented may change and evolve frequently.
+    This project is still very much experimental and in an alpha state where a lot of things are still missing or broken, and what's there changes frequently.
+    Also, there are still a few hardcoded values/parameters in some of the examples and apps which need to be changed (those will eventually be command line arguments, as appropriate)
 
 Overview
 --------

setup.cfg

@@ -57,7 +57,6 @@ console_scripts =
     bumble-unbond = bumble.apps.unbond:main
     bumble-usb-probe = bumble.apps.usb_probe:main
     bumble-link-relay = bumble.apps.link_relay.link_relay:main
-    bumble-bench = bumble.apps.bench:main
 
 [options.package_data]
 * = py.typed, *.pyi
@@ -73,7 +72,7 @@ test =
 development =
     black == 22.10
     invoke >= 1.7.3
-    mypy == 0.991
+    mypy == 1.1.1
     nox >= 2022
     pylint == 2.15.8
     types-appdirs >= 1.4.3

tests/transport_test.py

@@ -72,5 +72,6 @@ def test_parser_extensions():
 
 
 # -----------------------------------------------------------------------------
-test_parser()
-test_parser_extensions()
+if __name__ == '__main__':
+    test_parser()
+    test_parser_extensions()