WIP

Author: andrew-codechimp

custom_components/battery_notes/__init__.py

@@ -40,12 +40,13 @@
     DEFAULT_SCHEMA_URL,
     DOMAIN,
     MIN_HA_VERSION,
-    MY_KEY,
     PLATFORMS,
 )
 from .coordinator import (
+    MY_KEY,
     BatteryNotesConfigEntry,
     BatteryNotesCoordinator,
+    BatteryNotesData,
     BatteryNotesDomainConfig,
 )
 from .discovery import DiscoveryManager
@@ -104,9 +105,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
         _LOGGER.critical(msg)
         return False
 
-    library_updater = LibraryUpdater(hass)
-    await library_updater.copy_schema()
-    await library_updater.get_library_updates(dt_util.utcnow())
+    store = await async_get_registry(hass)
 
     domain_config = BatteryNotesDomainConfig(
         enable_autodiscovery=config.get(DOMAIN, {}).get(CONF_ENABLE_AUTODISCOVERY, True),
@@ -122,12 +121,16 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
         ),
         library_url=config.get(DOMAIN, {}).get(CONF_LIBRARY_URL, DEFAULT_LIBRARY_URL),
         schema_url=config.get(DOMAIN, {}).get(CONF_SCHEMA_URL, DEFAULT_SCHEMA_URL),
-        library_updater=library_updater,
         user_library=config.get(DOMAIN, {}).get(CONF_USER_LIBRARY, ""),
+        store=store,
     )
 
     hass.data[MY_KEY] = domain_config
 
+    library_updater = LibraryUpdater(hass)
+    await library_updater.copy_schema()
+    await library_updater.get_library_updates(dt_util.utcnow())
+
     if domain_config.enable_autodiscovery:
         discovery_manager = DiscoveryManager(hass, domain_config)
         await discovery_manager.start_discovery()
@@ -143,9 +146,14 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 async def async_setup_entry(hass: HomeAssistant, config_entry: BatteryNotesConfigEntry) -> bool:
     """Set up a config entry."""
 
-    config_entry.runtime_data.domain_config = hass.data[MY_KEY]
-    config_entry.runtime_data.store = await async_get_registry(hass, config_entry)
-    config_entry.runtime_data.coordinator = BatteryNotesCoordinator(hass, config_entry)
+    data = hass.data[MY_KEY]
+    config_entry.runtime_data = BatteryNotesData(
+        domain_config=data,
+        store=data.store,
+    )
+
+    coordinator = BatteryNotesCoordinator(hass, config_entry)
+    config_entry.runtime_data.coordinator = coordinator
 
     await hass.config_entries.async_forward_entry_setups(config_entry, PLATFORMS)
 

custom_components/battery_notes/binary_sensor.py

@@ -72,9 +72,9 @@
     ATTR_BATTERY_TYPE_AND_QUANTITY,
     CONF_SOURCE_ENTITY_ID,
     DOMAIN,
-    MY_KEY,
 )
 from .coordinator import (
+    MY_KEY,
     BatteryNotesConfigEntry,
     BatteryNotesCoordinator,
 )

custom_components/battery_notes/config_flow.py

@@ -162,15 +162,9 @@ async def async_step_device(
 
             device_id = user_input[CONF_DEVICE_ID]
 
-            if (
-                DOMAIN in self.hass.data
-                and DATA_LIBRARY_UPDATER in self.hass.data[DOMAIN]
-            ):
-                library_updater: LibraryUpdater = self.hass.data[DOMAIN][
-                    DATA_LIBRARY_UPDATER
-                ]
-                if await library_updater.time_to_update_library(1):
-                    await library_updater.get_library_updates(dt_util.utcnow())
+            library_updater = LibraryUpdater(self.hass)
+            if await library_updater.time_to_update_library(1):
+                await library_updater.get_library_updates(dt_util.utcnow())
 
             device_registry = dr.async_get(self.hass)
             device_entry = device_registry.async_get(device_id)

custom_components/battery_notes/const.py

@@ -1,18 +1,13 @@
 """Constants for battery_notes."""
 
 import json
-from dataclasses import dataclass
-from datetime import datetime
 from logging import Logger, getLogger
 from pathlib import Path
 from typing import Final
 
 import voluptuous as vol
 from homeassistant.const import Platform
 from homeassistant.helpers import config_validation as cv
-from homeassistant.util.hass_dict import HassKey
-
-from .library_updater import LibraryUpdater
 
 LOGGER: Logger = getLogger(__package__)
 
@@ -117,21 +112,3 @@
     Platform.SENSOR,
     Platform.BINARY_SENSOR,
 ]
-
-@dataclass
-class BatteryNotesDomainConfig:
-    """Class for sharing config data within the BatteryNotes integration."""
-    enable_autodiscovery: bool = True
-    show_all_devices: bool = False
-    enable_replaced: bool = True
-    hide_battery: bool = False
-    round_battery: bool = False
-    default_battery_low_threshold: int = DEFAULT_BATTERY_LOW_THRESHOLD
-    battery_increased_threshod: int = DEFAULT_BATTERY_INCREASE_THRESHOLD
-    library_url: str = DEFAULT_LIBRARY_URL
-    schema_url: str = DEFAULT_SCHEMA_URL
-    library_updater: LibraryUpdater | None
-    library_last_update: datetime | None = None
-    user_library: str = ""
-
-MY_KEY: HassKey[BatteryNotesDomainConfig] = HassKey(DOMAIN)

custom_components/battery_notes/coordinator.py

@@ -25,6 +25,7 @@
 from homeassistant.helpers.entity_registry import RegistryEntry
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 from homeassistant.util import dt as dt_util
+from homeassistant.util.hass_dict import HassKey
 
 from .common import validate_is_float
 from .const import (
@@ -57,14 +58,30 @@
     LAST_REPLACED,
     LAST_REPORTED,
     LAST_REPORTED_LEVEL,
-    BatteryNotesDomainConfig,
 )
 from .filters import LowOutlierFilter
-from .library_updater import LibraryUpdater
 from .store import BatteryNotesStorage
 
 _LOGGER = logging.getLogger(__name__)
 
+@dataclass
+class BatteryNotesDomainConfig:
+    """Class for sharing config data within the BatteryNotes integration."""
+    enable_autodiscovery: bool = True
+    show_all_devices: bool = False
+    enable_replaced: bool = True
+    hide_battery: bool = False
+    round_battery: bool = False
+    default_battery_low_threshold: int = DEFAULT_BATTERY_LOW_THRESHOLD
+    battery_increased_threshod: int = DEFAULT_BATTERY_INCREASE_THRESHOLD
+    library_url: str = DEFAULT_LIBRARY_URL
+    schema_url: str = DEFAULT_SCHEMA_URL
+    library_last_update: datetime | None = None
+    user_library: str = ""
+    store: BatteryNotesStorage | None = None
+
+MY_KEY: HassKey[BatteryNotesDomainConfig] = HassKey(DOMAIN)
+
 type BatteryNotesConfigEntry = ConfigEntry[BatteryNotesData]
 
 @dataclass
@@ -73,7 +90,7 @@ class BatteryNotesData:
 
     domain_config: BatteryNotesDomainConfig
     store: BatteryNotesStorage
-    coordinator: BatteryNotesCoordinator
+    coordinator: BatteryNotesCoordinator | None = None
 
 
 class BatteryNotesCoordinator(DataUpdateCoordinator[None]):

custom_components/battery_notes/discovery.py

@@ -87,7 +87,8 @@ async def start_discovery(self) -> None:
         _LOGGER.debug("Start auto discovering devices")
         device_registry = dr.async_get(self.hass)
 
-        library = await Library.factory(self.hass)
+        library = Library(self.hass)
+        await library.load_libraries()
 
         if library.loaded():
             for device_entry in list(device_registry.devices.values()):

custom_components/battery_notes/library.py

@@ -13,8 +13,8 @@
 from .const import (
     DATA_LIBRARY,
     DOMAIN,
-    MY_KEY,
 )
+from .coordinator import MY_KEY
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -105,15 +105,13 @@ def _load_library_json(library_file: str) -> dict[str, Any]:
     async def factory(hass: HomeAssistant) -> Library:
         """Return the library or create."""
 
-        if DOMAIN not in hass.data:
-            hass.data[DOMAIN] = {}
-
-        if DATA_LIBRARY in hass.data[DOMAIN]:
-            return hass.data[DOMAIN][DATA_LIBRARY]  # type: ignore
+        domain_config = hass.data[MY_KEY]
+        if domain_config.library:
+            return domain_config.library
 
         library = Library(hass)
         await library.load_libraries()
-        hass.data[DOMAIN][DATA_LIBRARY] = library
+        domain_config.library = library
         return library
 
     async def get_device_battery_details(

custom_components/battery_notes/library_updater.py

@@ -18,9 +18,7 @@
 from homeassistant.helpers.event import async_track_utc_time_change
 from homeassistant.helpers.storage import STORAGE_DIR
 
-from .const import (
-    MY_KEY,
-)
+from .coordinator import MY_KEY
 from .discovery import DiscoveryManager
 
 _LOGGER = logging.getLogger(__name__)

custom_components/battery_notes/sensor.py

@@ -71,10 +71,9 @@
     CONF_SOURCE_ENTITY_ID,
     DOMAIN,
     LAST_REPLACED,
-    MY_KEY,
     PLATFORMS,
 )
-from .coordinator import BatteryNotesConfigEntry, BatteryNotesCoordinator
+from .coordinator import MY_KEY, BatteryNotesConfigEntry, BatteryNotesCoordinator
 from .entity import (
     BatteryNotesEntityDescription,
 )
@@ -781,38 +780,21 @@ async def async_added_to_hass(self) -> None:
 
     def _set_native_value(self, log_on_error=True):
         # pylint: disable=unused-argument
-        if self._source_entity_id:
-            entry = self.coordinator.store.async_get_entity(self._source_entity_id)
-        else:
-            entry = self.coordinator.store.async_get_device(self._device_id)
 
-        if entry:
-            if LAST_REPLACED in entry and entry[LAST_REPLACED] is not None:
-                last_replaced_date = datetime.fromisoformat(
-                    str(entry[LAST_REPLACED]) + "+00:00"
-                )
-                self._native_value = last_replaced_date
+        if last_replaced := self.coordinator.last_replaced:
+            self._native_value = last_replaced
 
-                return True
+            return True
         return False
 
     @callback
     def _handle_coordinator_update(self) -> None:
         """Handle updated data from the coordinator."""
 
-        if self.coordinator.source_entity_id:
-            entry = self.coordinator.store.async_get_entity(self._source_entity_id)
-        else:
-            entry = self.coordinator.store.async_get_device(self._device_id)
-
-        if entry:
-            if LAST_REPLACED in entry and entry[LAST_REPLACED] is not None:
-                last_replaced_date = datetime.fromisoformat(
-                    str(entry[LAST_REPLACED]) + "+00:00"
-                )
-                self._native_value = last_replaced_date
+        if last_replaced := self.coordinator.last_replaced:
+            self._native_value = last_replaced
 
-                self.async_write_ha_state()
+            self.async_write_ha_state()
 
     @property
     def native_value(self) -> datetime | None: