feat: refactor scanner history to live on the scanner itself (#227)

Author: bdraco

src/habluetooth/base_scanner.pxd

@@ -28,6 +28,37 @@ cdef class BaseHaScanner:
     cdef public object details
     cdef public object current_mode
     cdef public object requested_mode
+    cdef public dict _connect_failures
+    cdef public dict _connect_in_progress
+
+    cpdef void _clear_connection_history(self) except *
+
+    cpdef void _finished_connecting(self, str address, bint connected) except *
+
+    cdef void _increase_count(self, dict target, str address) except *
+
+    cdef void _add_connect_failure(self, str address) except *
+
+    cpdef void _add_connecting(self, str address) except *
+
+    cdef void _remove_connecting(self, str address) except *
+
+    cdef void _clear_connect_failure(self, str address) except *
+
+    @cython.locals(
+        in_progress=Py_ssize_t,
+        count=Py_ssize_t
+    )
+    cpdef _connections_in_progress(self)
+
+    cpdef _connection_failures(self, str address)
+
+    @cython.locals(
+        score=double,
+        scanner_connections_in_progress=Py_ssize_t,
+        previous_failures=Py_ssize_t
+    )
+    cpdef _score_connection_paths(self, int rssi_diff, object scanner_device)
 
     cpdef tuple get_discovered_device_advertisement_data(self, str address)
 

src/habluetooth/base_scanner.py

@@ -11,6 +11,7 @@
 
 from bleak.backends.device import BLEDevice
 from bleak.backends.scanner import AdvertisementData
+from bleak_retry_connector import NO_RSSI_VALUE
 from bluetooth_adapters import adapter_human_name
 from bluetooth_data_tools import monotonic_time_coarse, parse_advertisement_data_bytes
 
@@ -27,6 +28,7 @@
     HaBluetoothConnector,
     HaScannerDetails,
 )
+from .scanner_device import BluetoothScannerDevice
 from .storage import DiscoveredDeviceAdvertisementData
 
 SCANNER_WATCHDOG_INTERVAL_SECONDS: Final = SCANNER_WATCHDOG_INTERVAL.total_seconds()
@@ -44,6 +46,9 @@ class BaseHaScanner:
 
     __slots__ = (
         "_cancel_watchdog",
+        "_connect_failures",
+        "_connect_in_progress",
+        "_connecting",
         "_connecting",
         "_last_detection",
         "_loop",
@@ -90,6 +95,78 @@ def __init__(
             name=self.name,
             adapter=self.adapter,
         )
+        self._connect_failures: dict[str, int] = {}
+        self._connect_in_progress: dict[str, int] = {}
+
+    def _clear_connection_history(self) -> None:
+        """Clear the connection history for a scanner."""
+        self._connect_failures.clear()
+        self._connect_in_progress.clear()
+
+    def _finished_connecting(self, address: str, connected: bool) -> None:
+        """Finished connecting."""
+        self._remove_connecting(address)
+        if connected:
+            self._clear_connect_failure(address)
+        else:
+            self._add_connect_failure(address)
+
+    def _increase_count(self, target: dict[str, int], address: str) -> None:
+        """Increase the reference count."""
+        if address in target:
+            target[address] += 1
+        else:
+            target[address] = 1
+
+    def _add_connect_failure(self, address: str) -> None:
+        """Add a connect failure."""
+        self._increase_count(self._connect_failures, address)
+
+    def _add_connecting(self, address: str) -> None:
+        """Add a connecting."""
+        self._increase_count(self._connect_in_progress, address)
+
+    def _remove_connecting(self, address: str) -> None:
+        """Remove a connecting."""
+        if address not in self._connect_in_progress:
+            _LOGGER.warning(
+                "Removing a non-existing connecting %s %s", self.name, address
+            )
+            return
+        self._connect_in_progress[address] -= 1
+        if not self._connect_in_progress[address]:
+            del self._connect_in_progress[address]
+
+    def _clear_connect_failure(self, address: str) -> None:
+        """Clear a connect failure."""
+        self._connect_failures.pop(address, None)
+
+    def _score_connection_paths(
+        self, rssi_diff: _int, scanner_device: BluetoothScannerDevice
+    ) -> float:
+        """Score the connection paths."""
+        address = scanner_device.ble_device.address
+        score = scanner_device.advertisement.rssi or NO_RSSI_VALUE
+        scanner_connections_in_progress = len(self._connect_in_progress)
+        previous_failures = self._connect_failures.get(address, 0)
+        if scanner_connections_in_progress:
+            # Very large penalty for multiple connections in progress
+            # to avoid overloading the adapter
+            score -= rssi_diff * scanner_connections_in_progress * 1.01
+        if previous_failures:
+            score -= rssi_diff * previous_failures * 0.51
+        return score
+
+    def _connections_in_progress(self) -> int:
+        """Return if the connection is in progress."""
+        in_progress = 0
+        for count in self._connect_in_progress.values():
+            in_progress += count
+        return in_progress
+
+    def _connection_failures(self, address: str) -> int:
+        """Return the number of failures."""
+        return self._connect_failures.get(address, 0)
 
     def time_since_last_detection(self) -> float:
         """Return the time since the last detection."""

src/habluetooth/manager.pxd

@@ -34,38 +34,6 @@ cdef class BleakCallback:
     cdef public object callback
     cdef public dict filters
 
-cdef class ConnectionHistory:
-
-    cdef public dict _failures
-    cdef public dict _connecting
-
-    cpdef void clear(self, BaseHaScanner scanner) except *
-
-    cpdef void finished_connecting(self, BaseHaScanner scanner, str address, bint connected) except *
-
-    cdef void _increase_ref_count(self, dict target, str address) except *
-
-    cdef void _add_connect_failure(self, BaseHaScanner scanner, str address) except *
-
-    cpdef void add_connecting(self, BaseHaScanner scanner, str address) except *
-
-    cdef void _remove_connecting(self, BaseHaScanner scanner, str address) except *
-
-    cdef void _clear_connect_failure(self, BaseHaScanner scanner, str address) except *
-
-    @cython.locals(
-        in_progress=Py_ssize_t
-    )
-    cpdef in_progress(self, BaseHaScanner scanner)
-
-    cpdef failures(self, BaseHaScanner scanner, str address)
-
-    @cython.locals(
-        score=double,
-        scanner_connections_in_progress=Py_ssize_t,
-        previous_failures=Py_ssize_t
-    )
-    cpdef score_connection_paths(self, int rssi_diff, object scanner_device)
 
 cdef class BluetoothManager:
 
@@ -84,7 +52,6 @@ cdef class BluetoothManager:
     cdef public dict _sources
     cdef public object _bluetooth_adapters
     cdef public object slot_manager
-    cdef public ConnectionHistory _connection_history
     cdef public bint _debug
     cdef public bint shutdown
     cdef public object _loop

src/habluetooth/manager.py

@@ -100,100 +100,6 @@ def __init__(
         self.filters = filters
 
 
-class ConnectionHistory:
-    """Connection history."""
-
-    __slots__ = ("_connecting", "_failures")
-
-    def __init__(self) -> None:
-        """Init connection history."""
-        self._failures: dict[BaseHaScanner, dict[str, int]] = {}
-        self._connecting: dict[BaseHaScanner, dict[str, int]] = {}
-
-    def clear(self, scanner: BaseHaScanner) -> None:
-        """Clear the connection history for a scanner."""
-        self._failures.pop(scanner, None)
-        self._connecting.pop(scanner, None)
-
-    def finished_connecting(
-        self, scanner: BaseHaScanner, address: str, connected: bool
-    ) -> None:
-        """Finished connecting."""
-        self._remove_connecting(scanner, address)
-        if connected:
-            self._clear_connect_failure(scanner, address)
-        else:
-            self._add_connect_failure(scanner, address)
-
-    def _increase_ref_count(self, target: dict[str, int], address: str) -> None:
-        """Increase the reference count."""
-        if address in target:
-            target[address] += 1
-        else:
-            target[address] = 1
-
-    def _add_connect_failure(self, scanner: BaseHaScanner, address: str) -> None:
-        """Add a connect failure."""
-        self._increase_ref_count(self._failures.setdefault(scanner, {}), address)
-
-    def add_connecting(self, scanner: BaseHaScanner, address: str) -> None:
-        """Add a connecting."""
-        self._increase_ref_count(self._connecting.setdefault(scanner, {}), address)
-
-    def _remove_connecting(self, scanner: BaseHaScanner, address: str) -> None:
-        """Remove a connecting."""
-        if scanner not in self._connecting or address not in self._connecting[scanner]:
-            _LOGGER.warning(
-                "Removing a non-existing connecting %s %s", scanner, address
-            )
-            return
-        self._connecting[scanner][address] -= 1
-        if not self._connecting[scanner][address]:
-            del self._connecting[scanner][address]
-        if not self._connecting[scanner]:
-            del self._connecting[scanner]
-
-    def _clear_connect_failure(self, scanner: BaseHaScanner, address: str) -> None:
-        """Clear a connect failure."""
-        if scanner not in self._failures or address not in self._failures[scanner]:
-            return
-        del self._failures[scanner][address]
-        if not self._failures[scanner]:
-            del self._failures[scanner]
-
-    def score_connection_paths(
-        self, rssi_diff: _int, scanner_device: BluetoothScannerDevice
-    ) -> float:
-        """Score the connection paths."""
-        scanner = scanner_device.scanner
-        address = scanner_device.ble_device.address
-        score = scanner_device.advertisement.rssi or NO_RSSI_VALUE
-        scanner_connections_in_progress = len(self._connecting.get(scanner, ()))
-        previous_failures = self._failures.get(scanner, {}).get(address, 0)
-        if scanner_connections_in_progress:
-            # Very large penalty for multiple connections in progress
-            # to avoid overloading the adapter
-            score -= rssi_diff * scanner_connections_in_progress * 1.01
-        if previous_failures:
-            score -= rssi_diff * previous_failures * 0.51
-        return score
-
-    def in_progress(self, scanner: BaseHaScanner) -> int:
-        """Return if the connection is in progress."""
-        if scanner not in self._connecting:
-            return 0
-        in_progress = 0
-        for count in self._connecting[scanner].values():
-            in_progress += count
-        return in_progress
-
-    def failures(self, scanner: BaseHaScanner, address: str) -> int:
-        """Return the number of failures."""
-        if scanner not in self._failures or address not in self._failures[scanner]:
-            return 0
-        return self._failures[scanner][address]
-
-
 class BluetoothManager:
     """Manage Bluetooth."""
 
@@ -258,7 +164,6 @@ def __init__(
         self._sources: dict[str, BaseHaScanner] = {}
         self._bluetooth_adapters = bluetooth_adapters or get_adapters()
         self.slot_manager = slot_manager or BleakSlotManager()
-        self._connection_history = ConnectionHistory()
         self._cancel_allocation_callbacks = (
             self.slot_manager.register_allocation_callback(
                 self._async_slot_manager_changed
@@ -843,7 +748,7 @@ def _async_unregister_scanner_internal(
         _LOGGER.debug("Unregistering scanner %s", scanner.name)
         self._advertisement_tracker.async_remove_source(scanner.source)
         scanners.remove(scanner)
-        self._connection_history.clear(scanner)
+        scanner._clear_connection_history()
         del self._sources[scanner.source]
         del self._adapter_sources[scanner.adapter]
         self._allocations.pop(scanner.source, None)
@@ -866,7 +771,7 @@ def async_register_scanner(
                 source=scanner.source, slots=0, free=0, allocated=[]
             )
         scanners.add(scanner)
-        self._connection_history.clear(scanner)
+        scanner._clear_connection_history()
         self._sources[scanner.source] = scanner
         self._adapter_sources[scanner.adapter] = scanner.source
         if connection_slots:

src/habluetooth/scanner_device.py

@@ -19,3 +19,7 @@ class BluetoothScannerDevice:
     scanner: BaseHaScanner
     ble_device: BLEDevice
     advertisement: AdvertisementData
+
+    def score_connection_path(self, rssi_diff: int) -> float:
+        """Return a score for the connection path to this device."""
+        return self.scanner._score_connection_paths(rssi_diff, self)