feat: support bleak 2.0 (#334)

Author: bdraco

src/habluetooth/wrappers.py

@@ -61,6 +61,7 @@ class _HaWrappedBleakBackend:
     scanner: BaseHaScanner
     client: type[BaseBleakClient]
     source: str | None
+    backend_name: str | None = None
 
 
 class HaBleakScannerWrapper(BaseBleakScanner):
@@ -334,8 +335,17 @@ async def connect(self, **kwargs: Any) -> None:
                 assert device_adv is not None
             adv = device_adv[1]
             rssi = adv.rssi
+            backend_name = (
+                f" [{wrapped_backend.backend_name}]"
+                if wrapped_backend.backend_name
+                else ""
+            )
             _LOGGER.debug(
-                "%s: Connecting via %s (last rssi: %s)", description, scanner.name, rssi
+                "%s: Connecting via %s%s (last rssi: %s)",
+                description,
+                scanner.name,
+                backend_name,
+                rssi,
             )
 
         # Load fast connection parameters before connecting if mgmt API is available
@@ -376,10 +386,11 @@ async def connect(self, **kwargs: Any) -> None:
 
         if debug_logging:
             _LOGGER.debug(
-                "%s: %s via %s (last rssi: %s)",
+                "%s: %s via %s%s (last rssi: %s)",
                 description,
                 "Connected" if connected else "Failed to connect",
                 scanner.name,
+                backend_name,
                 rssi,
             )
         return
@@ -415,16 +426,28 @@ def _async_get_backend_for_ble_device(
             # its the client for this platform
             if not manager.async_allocate_connection_slot(ble_device):
                 return None
-            cls = get_platform_client_backend_type()
-            return _HaWrappedBleakBackend(ble_device, scanner, cls, source)
+            backend = get_platform_client_backend_type()
+            # bleak 2.0.0+ returns a tuple (backend_class, backend_id)
+            if isinstance(backend, tuple):
+                cls, backend_name = backend
+            else:
+                cls = backend
+                backend_name = type(cls).__name__
+            return _HaWrappedBleakBackend(
+                ble_device, scanner, cls, source, backend_name
+            )
 
         # Make sure the backend can connect to the device
         # as some backends have connection limits
         if not scanner.connector or not scanner.connector.can_connect():
             return None
 
         return _HaWrappedBleakBackend(
-            ble_device, scanner, scanner.connector.client, source
+            ble_device,
+            scanner,
+            scanner.connector.client,
+            source,
+            type(scanner.connector.client).__name__,
         )
 
     def _async_get_best_available_backend_and_device(

tests/test_wrappers.py

@@ -1954,3 +1954,93 @@ async def connect_device(address: str) -> tuple[str, str | None]:
         cancel1()
         cancel2()
         cancel3()
+
+
+@pytest.mark.asyncio
+async def test_backend_name_from_tuple(
+    enable_bluetooth: None,
+    install_bleak_catcher: None,
+    mock_platform_client: None,
+) -> None:
+    """Test that backend name is extracted from tuple (bleak 2.0.0+)."""
+    manager = _get_manager()
+    hci0_device_advs, cancel_hci0, _ = _generate_scanners_with_fake_devices()
+
+    with patch(
+        "habluetooth.wrappers.get_platform_client_backend_type",
+        return_value=(FakeBleakClient, "TestBackend"),
+    ):
+        ble_device = hci0_device_advs["00:00:00:00:00:01"][0]
+        client = bleak.BleakClient(ble_device)
+
+        # Access the wrapped backend through the client
+        # The backend name should be extracted from the tuple
+        wrapped_backend = client._async_get_best_available_backend_and_device(manager)
+        assert wrapped_backend.backend_name == "TestBackend"
+        assert wrapped_backend.client == FakeBleakClient
+
+    cancel_hci0()
+
+
+@pytest.mark.asyncio
+async def test_backend_name_from_class(
+    enable_bluetooth: None,
+    install_bleak_catcher: None,
+    mock_platform_client: None,
+) -> None:
+    """Test that backend name is derived from class name (pre-bleak 2.0.0)."""
+    manager = _get_manager()
+    hci0_device_advs, cancel_hci0, _ = _generate_scanners_with_fake_devices()
+
+    with patch(
+        "habluetooth.wrappers.get_platform_client_backend_type",
+        return_value=FakeBleakClient,
+    ):
+        ble_device = hci0_device_advs["00:00:00:00:00:01"][0]
+        client = bleak.BleakClient(ble_device)
+
+        # Access the wrapped backend through the client
+        # The backend name should be derived from the class name
+        wrapped_backend = client._async_get_best_available_backend_and_device(manager)
+        assert wrapped_backend.backend_name == "type"
+        assert wrapped_backend.client == FakeBleakClient
+
+    cancel_hci0()
+
+
+@pytest.mark.asyncio
+async def test_backend_name_in_logs(
+    enable_bluetooth: None,
+    install_bleak_catcher: None,
+    mock_platform_client: None,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test that backend name appears in debug logs."""
+    caplog.set_level(logging.DEBUG)
+
+    hci0_device_advs, cancel_hci0, _ = _generate_scanners_with_fake_devices()
+
+    with patch(
+        "habluetooth.wrappers.get_platform_client_backend_type",
+        return_value=(FakeBleakClient, "TestBackend"),
+    ):
+        ble_device = hci0_device_advs["00:00:00:00:00:01"][0]
+        with patch.object(FakeBleakClient, "is_connected", return_value=True):
+            client = bleak.BleakClient(ble_device)
+            await client.connect()
+
+        # Check that the backend name appears in the logs
+        assert any(
+            "[TestBackend]" in record.message
+            for record in caplog.records
+            if "Connecting via" in record.message
+        ), f"Backend name not found in logs: {[r.message for r in caplog.records]}"
+        assert any(
+            "[TestBackend]" in record.message
+            for record in caplog.records
+            if "Connected via" in record.message
+        ), f"Backend name not found in logs: {[r.message for r in caplog.records]}"
+
+        await client.disconnect()
+
+    cancel_hci0()