Merge pull request #10 from soldierkam/fix_ha_integration

Fix HA integration

Author: neffs

cometblue_lite/cometblue.py

@@ -5,36 +5,30 @@
 Parts were taken from the cometblue module by im-0
 Port to bleak/asyncio is based on pySwitchbot
 """
+from __future__ import annotations
+
+import asyncio
 import logging
 import struct
-import time
-from contextlib import contextmanager
 
-import asyncio
-from bleak import BleakError, BleakScanner
+from bleak import BleakError
+from bleak import BleakClient
 from bleak.backends.device import BLEDevice
-from bleak.backends.service import BleakGATTCharacteristic, BleakGATTServiceCollection
-from bleak_retry_connector import (
-    BleakClientWithServiceCache,
-    BleakNotFoundError,
-    ble_device_has_changed,
-    establish_connection,
-)
+from bleak_retry_connector import establish_connection
 
 _LOGGER = logging.getLogger(__name__)
 
-
 PASSWORD_CHAR = "47e9ee30-47e9-11e4-8939-164230d1df67"
 TEMPERATURE_CHAR = "47e9ee2b-47e9-11e4-8939-164230d1df67"
 BATTERY_CHAR = "47e9ee2c-47e9-11e4-8939-164230d1df67"
 STATUS_CHAR = "47e9ee2a-47e9-11e4-8939-164230d1df67"
 DATETIME_CHAR = "47e9ee01-47e9-11e4-8939-164230d1df67"
-SOFTWARE_REV = "00002a28-0000-1000-8000-00805f9b34fb"       # software_revision (0.0.6-sygonix1)
-MODEL_CHAR = "00002a24-0000-1000-8000-00805f9b34fb"         # model_number (Comet Blue)
+SOFTWARE_REV = "00002a28-0000-1000-8000-00805f9b34fb"  # software_revision (0.0.6-sygonix1)
+MODEL_CHAR = "00002a24-0000-1000-8000-00805f9b34fb"  # model_number (Comet Blue)
 MANUFACTURER_CHAR = "00002a29-0000-1000-8000-00805f9b34fb"  # manufacturer_name (EUROtronic GmbH)
-#FIRMWARE_CHAR = "00002a26-0000-1000-8000-00805f9b34fb"
+# FIRMWARE_CHAR = "00002a26-0000-1000-8000-00805f9b34fb"
 
-FIRMWARE_CHAR = "47e9ee2d-47e9-11e4-8939-164230d1df67"      # firmware_revision2 (COBL0126)
+FIRMWARE_CHAR = "47e9ee2d-47e9-11e4-8939-164230d1df67"  # firmware_revision2 (COBL0126)
 _PIN_STRUCT_PACKING = '<I'
 _DATETIME_STRUCT_PACKING = '<BBBBB'
 _DAY_STRUCT_PACKING = '<BBBBBBBB'
@@ -55,7 +49,7 @@ def _encode_datetime(dt):
 
 class CometBlueStates:
     """CometBlue Thermostat States"""
-    TEMPERATURE_OFF = 7.5   # special temperature, valve fully closed
+    TEMPERATURE_OFF = 7.5  # special temperature, valve fully closed
     _TEMPERATURES_STRUCT_PACKING = '<bbbbbbb'
     _STATUS_STRUCT_PACKING = '<BBB'
 
@@ -82,7 +76,12 @@ def __init__(self):
         self._status = dict()
         self._battery_level = None
         self._current_temp = None
-        self.clear_temperatures()
+        self.target_temperature = None
+        self.target_temp_l = None
+        self.target_temp_h = None
+        self.offset_temperature = None
+        self.window_open_detection = None
+        self.window_open_minutes = None
 
     def clear_temperatures(self):
         self.target_temperature = None
@@ -170,7 +169,6 @@ def encode_status(value):
     @status_code.setter
     def status_code(self, val):
         def decode_status(value):
-            state_bytes = struct.unpack(CometBlueStates._STATUS_STRUCT_PACKING, value)
             state_dword = struct.unpack('<I', value + b'\x00')[0]
 
             report = {}
@@ -245,18 +243,17 @@ def temperatures(self, value):
     @property
     def all_temperatures_none(self):
         """True if any of the temperature properties is not None"""
-        values = set((self.target_temperature, self.target_temp_l, self.target_temp_h, self.offset_temperature, self.window_open_detection, self.window_open_minutes))
+        values = {self.target_temperature, self.target_temp_l, self.target_temp_h, self.offset_temperature, self.window_open_detection,
+                  self.window_open_minutes}
         values.remove(None)
         return len(values) == 0
 
 
-
 class CometBlue:
     """CometBlue Thermostat """
 
-    def __init__(self, address, pin):
+    def __init__(self, pin):
         super(CometBlue, self).__init__()
-        self._address = address
         self._device: BLEDevice | None = None
         self._pin = pin
         self.available = False
@@ -265,20 +262,18 @@ def __init__(self, address, pin):
         self._target = CometBlueStates()
         self._connect_lock = asyncio.Lock()
         self._operation_lock = asyncio.Lock()
-        self._client: BleakClientWithServiceCache | None = None
-        self._cached_services: BleakGATTServiceCollection | None = None
-        self._read_char: BleakGATTCharacteristic | None = None
-        self._write_char: BleakGATTCharacteristic | None = None
+        self._client: BleakClient | None = None
         self._disconnect_timer: asyncio.TimerHandle | None = None
         self._expected_disconnect = False
-        self.loop = asyncio.get_event_loop()
+        self._loop = asyncio.get_event_loop()
         # btle.Debugging = True
-    async def _ensure_connected(self):
+
+    async def _ensure_connected(self, device: BLEDevice):
         """Ensure connection to device is established."""
         if self._connect_lock.locked():
             _LOGGER.debug(
                 "%s: Connection already in progress, waiting for it to complete;",
-                self._address,
+                device.address,
             )
         if self._client and self._client.is_connected:
             self._reset_disconnect_timer()
@@ -288,54 +283,44 @@ async def _ensure_connected(self):
             if self._client and self._client.is_connected:
                 self._reset_disconnect_timer()
                 return
-            _LOGGER.debug("%s: Connecting; ", self._address)
-            if self._device is None: 
-                self._device = await BleakScanner.find_device_by_address(self._address, 60.0)
-                if self._device is None:
-                    self._device = await BleakScanner.find_device_by_address(self._address, 60.0)
-                    if self._device is None:
-                        raise Exception("could not discover device")
-
-            client = await establish_connection(
-                BleakClientWithServiceCache,
+            _LOGGER.debug("%s: Connecting; ", device.address)
+            self._device = device
+            self._client = await establish_connection(
+                BleakClient,
                 self._device,
-                self._address,
-                self._disconnected,
-                cached_services=self._cached_services,
+                self._device.address,
+                self._disconnected
             )
-            self._cached_services = client.services
-            _LOGGER.debug("%s: Connected", self._address)
-            services = client.services
-            self._client = client
+            _LOGGER.debug("%s: Connected", self._device.address)
             # authenticate with PIN and initialize static values
             self._reset_disconnect_timer()
 
         data = struct.pack(_PIN_STRUCT_PACKING, self._pin)
         try:
             await self._client.write_gatt_char(PASSWORD_CHAR, data, response=True)
         except BleakError:
-            _LOGGER.error("provided pin was not accepted by device %s" % client.address)
+            _LOGGER.error("provided pin was not accepted by device %s" % self._client.address)
 
-        _LOGGER.debug("Connected and authenticated with device %s", self._address)
+        _LOGGER.debug("Connected and authenticated with device %s", self._device.address)
 
-
-    def _disconnected(self, client: BleakClientWithServiceCache) -> None:
+    def _disconnected(self, _: BleakClient) -> None:
         """Disconnected callback."""
         if self._expected_disconnect:
             _LOGGER.debug(
-                "%s: Disconnected from device;", self._address
+                "%s: Disconnected from device;", self._device.address
             )
             return
         _LOGGER.warning(
             "%s: Device unexpectedly disconnected",
-            self._address
+            self._device.address
         )
+
     def _reset_disconnect_timer(self):
         """Reset disconnect timer."""
         if self._disconnect_timer:
             self._disconnect_timer.cancel()
         self._expected_disconnect = False
-        self._disconnect_timer = self.loop.call_later(
+        self._disconnect_timer = self._loop.call_later(
             DISCONNECT_DELAY, self._disconnect
         )
 
@@ -355,7 +340,6 @@ async def _execute_disconnect(self):
             if client and client.is_connected:
                 await client.disconnect()
 
-    
     def should_update(self):
         """
         Signal necessity to call update() on next cycle because values need
@@ -480,13 +464,13 @@ def window_open(self):
         """Return True if device detected opened window"""
         return self._current.window_open
 
-    async def update(self):
+    async def update(self, device: BLEDevice):
         """Communicate with device, first try to write new values, then read from device"""
         current = self._current
         target = self._target
 
-        #with self.btle_connection() as conn:
-        await self._ensure_connected()
+        # with self.btle_connection() as conn:
+        await self._ensure_connected(device)
 
         conn = self._client
         device_infos = [
@@ -496,30 +480,29 @@ async def update(self):
             current.software_rev
         ]
         if None in device_infos:
-            _LOGGER.debug("Fetching hardware information for device %s", self._address)
+            _LOGGER.debug("Fetching hardware information for device %s", self._device.address)
             current.model = (await conn.read_gatt_char(MODEL_CHAR)).decode()
             current.firmware_rev = (await conn.read_gatt_char(FIRMWARE_CHAR)).decode()
             current.manufacturer = (await conn.read_gatt_char(MANUFACTURER_CHAR)).decode()
-            current.software_rev = (await  conn.read_gatt_char(SOFTWARE_REV)).decode()
+            current.software_rev = (await conn.read_gatt_char(SOFTWARE_REV)).decode()
             _LOGGER.debug("Sucessfully fetched hardware information")
 
         if not target.all_temperatures_none:
             await conn.write_gatt_char(TEMPERATURE_CHAR,
-                                        target.temperatures,
-                                        response=True)
+                                       target.temperatures,
+                                       response=True)
             target.clear_temperatures()
-            _LOGGER.debug("Successfully updated Temperatures for device %s", self._address)
+            _LOGGER.debug("Successfully updated Temperatures for device %s", self._device.address)
 
         if target.status_code is not None:
             await conn.write_gatt_char(STATUS_CHAR,
-                                        target.status_code,
-                                        response=True)
+                                       target.status_code,
+                                       response=True)
             target.status_code = None
-            _LOGGER.debug("Successfully updated status for device %s", self._address)
+            _LOGGER.debug("Successfully updated status for device %s", self._device.address)
 
         current.temperatures = await conn.read_gatt_char(TEMPERATURE_CHAR)
         current.status_code = await conn.read_gatt_char(STATUS_CHAR)
         current.battery_level = await conn.read_gatt_char(BATTERY_CHAR)
-        _LOGGER.debug("Successfully fetched new readings for device %s", self._address)
+        _LOGGER.debug("Successfully fetched new readings for device %s", self._device.address)
         self.available = True
-