no-mistakes(lint): format repo with ruff; fix annotation drift in new code

Author: ngoviet

__init__.py

@@ -36,12 +36,14 @@
 
 PLATFORMS: list[Platform] = [Platform.SENSOR, Platform.BINARY_SENSOR]
 
+
 async def async_setup(hass: HomeAssistant, config: dict) -> bool:
     """Set up the Lumentree integration."""
     # Config flow is handled automatically by Home Assistant
     # when config_flow: true is set in manifest.json
     return True
 
+
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up Lumentree from a config entry."""
     _LOGGER.info(f"Setting up Lumentree: {entry.title} ({entry.entry_id})")
@@ -74,7 +76,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
             if "_error" in device_api_info:
                 _LOGGER.error(f"API error getting device info: {device_api_info['_error']}")
                 raise ConfigEntryNotReady(f"API error: {device_api_info['_error']}")
-            hass.data[DOMAIN][entry.entry_id]['device_api_info'] = device_api_info
+            hass.data[DOMAIN][entry.entry_id]["device_api_info"] = device_api_info
             _LOGGER.info(
                 f"Stored API info: Model={device_api_info.get('deviceType')}, "
                 f"ID={device_api_info.get('deviceId')}"
@@ -95,12 +97,14 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         monthly_coord = MonthlyStatsCoordinator(hass, aggregator, device_sn, entry.entry_id)
         yearly_coord = YearlyStatsCoordinator(hass, aggregator, device_sn, entry.entry_id)
         total_coord = TotalStatsCoordinator(hass, aggregator, device_sn, entry.entry_id)
-        hass.data[DOMAIN][entry.entry_id].update({
-            "daily_coordinator": daily_coord,
-            "monthly_coordinator": monthly_coord,
-            "yearly_coordinator": yearly_coord,
-            "total_coordinator": total_coord,
-        })
+        hass.data[DOMAIN][entry.entry_id].update(
+            {
+                "daily_coordinator": daily_coord,
+                "monthly_coordinator": monthly_coord,
+                "yearly_coordinator": yearly_coord,
+                "total_coordinator": total_coord,
+            }
+        )
         _LOGGER.info(f"Created total coordinator for {device_sn}")
 
         # Prime daily coordinator first (non-blocking), then stats coordinators after delay
@@ -205,7 +209,9 @@ async def _async_stop_mqtt(event: Event) -> None:
                 await client_to_stop.disconnect()
 
         entry.async_on_unload(_cancel_timer_on_unload)
-        entry.async_on_unload(hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, _async_stop_mqtt))
+        entry.async_on_unload(
+            hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, _async_stop_mqtt)
+        )
 
         # Services: backfill_now, recompute_month_year, purge_cache, backfill_all, backfill_gaps,
         #            mark_empty_dates, mark_coverage_range
@@ -218,9 +224,7 @@ def _required_year(call) -> int:
             """
             raw = call.data.get("year")
             if raw is None:
-                raise HomeAssistantError(
-                    "The 'year' field is required for this service."
-                )
+                raise HomeAssistantError("The 'year' field is required for this service.")
             try:
                 return int(raw)
             except (TypeError, ValueError) as err:
@@ -294,19 +298,25 @@ async def _svc_purge_and_backfill(call):
             max_years = int(max_years_val) if max_years_val is not None else 5
             optimize_cache = call.data.get("optimize_cache", True)
 
-            _LOGGER.warning(f"Purging ALL cache for device {device_id} and starting fresh smart backfill...")
+            _LOGGER.warning(
+                f"Purging ALL cache for device {device_id} and starting fresh smart backfill..."
+            )
             result = await hass.async_add_executor_job(cache_io.purge_device, device_id)
             _LOGGER.info(f"Purge result: {result}")
 
             _LOGGER.info(f"Starting smart backfill for {max_years} years...")
-            stats = await aggregator.smart_backfill(max_years=max_years, optimize_cache=optimize_cache)
+            stats = await aggregator.smart_backfill(
+                max_years=max_years, optimize_cache=optimize_cache
+            )
             _LOGGER.info(f"Purge and smart backfill completed: {stats}")
 
         async def _svc_smart_backfill(call):
             """Smart backfill using getYearData/getMonthData APIs."""
             max_years = int(call.data.get("max_years", 10))
             optimize_cache = call.data.get("optimize_cache", True)
-            stats = await aggregator.smart_backfill(max_years=max_years, optimize_cache=optimize_cache)
+            stats = await aggregator.smart_backfill(
+                max_years=max_years, optimize_cache=optimize_cache
+            )
             _LOGGER.info(f"Smart backfill completed: {stats}")
 
         async def _svc_backfill_all(call):
@@ -323,7 +333,9 @@ async def _svc_backfill_gaps(call):
         async def _svc_backfill_empty_dates(call):
             max_years = int(call.data.get("max_years", 5))
             max_days_per_run = int(call.data.get("max_days_per_run", 100))
-            result = await aggregator.backfill_empty_dates(max_years=max_years, max_days_per_run=max_days_per_run)
+            result = await aggregator.backfill_empty_dates(
+                max_years=max_years, max_days_per_run=max_days_per_run
+            )
             _LOGGER.info(
                 f"backfill_empty_dates service completed: "
                 f"recovered={result.get('recovered', 0)}, "
@@ -336,7 +348,9 @@ async def _svc_enable_purge_on_startup(call):
             new_options = entry.options.copy()
             new_options["purge_and_backfill_on_startup"] = True
             hass.config_entries.async_update_entry(entry, options=new_options)
-            _LOGGER.warning("purge_and_backfill_on_startup has been enabled. It will run on next restart and auto-disable after completion.")
+            _LOGGER.warning(
+                "purge_and_backfill_on_startup has been enabled. It will run on next restart and auto-disable after completion."
+            )
 
         async def _svc_disable_purge_on_startup(call):
             """Disable purge and backfill on startup."""
@@ -386,8 +400,12 @@ def _mark() -> None:
         hass.services.async_register(DOMAIN, "backfill_empty_dates", _svc_backfill_empty_dates)
         hass.services.async_register(DOMAIN, "mark_empty_dates", _svc_mark_empty_dates)
         hass.services.async_register(DOMAIN, "mark_coverage_range", _svc_mark_coverage_range)
-        hass.services.async_register(DOMAIN, "enable_purge_on_startup", _svc_enable_purge_on_startup)
-        hass.services.async_register(DOMAIN, "disable_purge_on_startup", _svc_disable_purge_on_startup)
+        hass.services.async_register(
+            DOMAIN, "enable_purge_on_startup", _svc_enable_purge_on_startup
+        )
+        hass.services.async_register(
+            DOMAIN, "disable_purge_on_startup", _svc_disable_purge_on_startup
+        )
 
         # Auto backfill: first-run (background) and nightly delta
         # Check if we need to purge and backfill on startup (from entry options or default False)
@@ -396,27 +414,35 @@ def _mark() -> None:
         async def _first_run_backfill() -> None:
             try:
                 if should_purge_on_startup:
-                    _LOGGER.warning("PURGE_AND_BACKFILL_ON_STARTUP is enabled - purging all cache...")
+                    _LOGGER.warning(
+                        "PURGE_AND_BACKFILL_ON_STARTUP is enabled - purging all cache..."
+                    )
                     result = await hass.async_add_executor_job(cache_io.purge_device, device_id)
                     _LOGGER.info(f"Purge result: {result}")
                     _LOGGER.warning("Starting smart backfill for 5 years...")
                     # Use smart backfill for faster performance
                     stats = await aggregator.smart_backfill(max_years=5, optimize_cache=True)
                     _LOGGER.info(f"Smart backfill completed: {stats}")
                 else:
-                    _LOGGER.info("Auto backfill: starting smart backfill for last 5 years (background)")
+                    _LOGGER.info(
+                        "Auto backfill: starting smart backfill for last 5 years (background)"
+                    )
                     # Use smart backfill - much faster than daily backfill
                     stats = await aggregator.smart_backfill(max_years=5, optimize_cache=True)
                     _LOGGER.info(f"Auto backfill: completed 5-year history - {stats}")
 
                 # Auto-disable purge_and_backfill_on_startup after successful backfill
                 if should_purge_on_startup:
-                    _LOGGER.info("Backfill completed successfully. Auto-disabling PURGE_AND_BACKFILL_ON_STARTUP...")
+                    _LOGGER.info(
+                        "Backfill completed successfully. Auto-disabling PURGE_AND_BACKFILL_ON_STARTUP..."
+                    )
                     # Update entry options to disable the flag
                     new_options = entry.options.copy()
                     new_options["purge_and_backfill_on_startup"] = False
                     hass.config_entries.async_update_entry(entry, options=new_options)
-                    _LOGGER.info("PURGE_AND_BACKFILL_ON_STARTUP has been automatically set to False")
+                    _LOGGER.info(
+                        "PURGE_AND_BACKFILL_ON_STARTUP has been automatically set to False"
+                    )
             except Exception as err:
                 _LOGGER.error(f"Auto backfill initial failed: {err}")
 
@@ -439,7 +465,9 @@ async def _nightly_delta(now=None):
         hass.async_create_task(_first_run_backfill())
 
         # Schedule nightly job every 24h — store before risky step so we can clean up on failure
-        remove_nightly = async_track_time_interval(hass, _nightly_delta, datetime.timedelta(hours=24))
+        remove_nightly = async_track_time_interval(
+            hass, _nightly_delta, datetime.timedelta(hours=24)
+        )
         hass.data[DOMAIN][entry.entry_id]["remove_nightly"] = remove_nightly
 
         await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
@@ -475,6 +503,7 @@ async def _nightly_delta(now=None):
             hass.data[DOMAIN].pop(entry.entry_id, None)
         return False
 
+
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
     device_sn = entry.data.get(CONF_DEVICE_SN, "unknown")
@@ -508,7 +537,12 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
                 _LOGGER.warning(f"Error cancelling nightly timer {device_sn}: {timer_err}")
 
         # Cleanup coordinators (they should be cleaned up by platform unload, but ensure cleanup)
-        for coord_key in ["daily_coordinator", "monthly_coordinator", "yearly_coordinator", "total_coordinator"]:
+        for coord_key in [
+            "daily_coordinator",
+            "monthly_coordinator",
+            "yearly_coordinator",
+            "total_coordinator",
+        ]:
             coord = entry_data.get(coord_key)
             if coord and hasattr(coord, "async_shutdown"):
                 try:

binary_sensor.py

@@ -1,4 +1,5 @@
 """
 Lumentree Binary Sensor Platform - Redirect to entities/binary_sensor.py
 """
+
 from .entities.binary_sensor import *  # noqa: F401, F403

config_flow.py

@@ -70,7 +70,9 @@ async def _get_api_client(self) -> LumentreeHttpApiClient:
 
             except Exception as session_exc:
                 _LOGGER.error(f"Failed to initialize API client: {session_exc}")
-                raise ApiException(f"API Client Initialization failed: {session_exc}") from session_exc
+                raise ApiException(
+                    f"API Client Initialization failed: {session_exc}"
+                ) from session_exc
         else:
             _LOGGER.debug(f"Reusing existing API client instance: {type(self._api_client)}")
 
@@ -112,7 +114,9 @@ async def async_step_user(self, user_input: dict[str, Any] | None = None) -> Con
                 self._http_token = token
 
                 masked_token = (token[:6] + "...") if token and len(token) > 6 else "***"
-                _LOGGER.info("Auth success for %s (token masked: %s)", self._device_id_input, masked_token)
+                _LOGGER.info(
+                    "Auth success for %s (token masked: %s)", self._device_id_input, masked_token
+                )
 
                 return await self.async_step_confirm_device()
 
@@ -126,10 +130,14 @@ async def async_step_user(self, user_input: dict[str, Any] | None = None) -> Con
                 _LOGGER.exception(f"Unexpected auth error {self._device_id_input}: {exc}")
                 errors["base"] = "unknown"
 
-        schema = vol.Schema({vol.Required(CONF_DEVICE_ID, default=self._device_id_input or ""): str})
+        schema = vol.Schema(
+            {vol.Required(CONF_DEVICE_ID, default=self._device_id_input or ""): str}
+        )
         return self.async_show_form(step_id="user", data_schema=schema, errors=errors)
 
-    async def async_step_confirm_device(self, user_input: dict[str, Any] | None = None) -> ConfigFlowResult:
+    async def async_step_confirm_device(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
         """Handle device confirmation step."""
         errors: dict[str, str] = {}
         api: LumentreeHttpApiClient | None = None
@@ -162,7 +170,9 @@ async def async_step_confirm_device(self, user_input: dict[str, Any] | None = No
                 if isinstance(device_info_api, dict) and "_error" in device_info_api:
                     api_error = device_info_api["_error"]
                     _LOGGER.error("API error when getting device info: %s", api_error)
-                    errors["base"] = "invalid_auth" if "Auth" in api_error else "cannot_connect_deviceinfo"
+                    errors["base"] = (
+                        "invalid_auth" if "Auth" in api_error else "cannot_connect_deviceinfo"
+                    )
                     return self.async_show_form(
                         step_id="confirm_device",
                         description_placeholders={"device_name": "Err", "device_sn": "Err"},
@@ -174,7 +184,9 @@ async def async_step_confirm_device(self, user_input: dict[str, Any] | None = No
                 )
 
                 if not self._device_sn_from_api:
-                    _LOGGER.warning("deviceId not found for %s. Using input ID.", self._device_id_input)
+                    _LOGGER.warning(
+                        "deviceId not found for %s. Using input ID.", self._device_id_input
+                    )
                     self._device_sn_from_api = self._device_id_input
                 elif self._device_sn_from_api != self._device_id_input:
                     _LOGGER.warning(
@@ -184,16 +196,28 @@ async def async_step_confirm_device(self, user_input: dict[str, Any] | None = No
                     )
 
                 self._device_name = (
-                    (device_info_api.get("remarkName") if isinstance(device_info_api, dict) else None)
-                    or (device_info_api.get("deviceType") if isinstance(device_info_api, dict) else None)
+                    (
+                        device_info_api.get("remarkName")
+                        if isinstance(device_info_api, dict)
+                        else None
+                    )
+                    or (
+                        device_info_api.get("deviceType")
+                        if isinstance(device_info_api, dict)
+                        else None
+                    )
                     or f"Lumentree {self._device_sn_from_api}"
                 )
 
                 _LOGGER.info(
                     "Device Info: ID/SN='%s', Name='%s', Type='%s'",
                     self._device_sn_from_api,
                     self._device_name,
-                    (device_info_api.get("deviceType") if isinstance(device_info_api, dict) else None),
+                    (
+                        device_info_api.get("deviceType")
+                        if isinstance(device_info_api, dict)
+                        else None
+                    ),
                 )
 
                 await self.async_set_unique_id(self._device_sn_from_api)
@@ -241,7 +265,9 @@ async def async_step_confirm_device(self, user_input: dict[str, Any] | None = No
         }
 
         if self._reauth_entry:
-            _LOGGER.info(f"Updating entry {self._reauth_entry.entry_id} for {self._device_sn_from_api} reauth")
+            _LOGGER.info(
+                f"Updating entry {self._reauth_entry.entry_id} for {self._device_sn_from_api} reauth"
+            )
             self.hass.config_entries.async_update_entry(self._reauth_entry, data=config_data)
             await self.hass.config_entries.async_reload(self._reauth_entry.entry_id)
             return self.async_abort(reason="reauth_successful")
@@ -266,7 +292,9 @@ async def async_step_reauth(self, user_input: dict[str, Any] | None = None) -> C
         self._api_client = None
         return await self.async_step_user(user_input={CONF_DEVICE_ID: self._device_id_input})
 
-    async def async_step_reconfigure(self, user_input: dict[str, Any] | None = None) -> ConfigFlowResult:
+    async def async_step_reconfigure(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
         """Handle reconfigure flow (HA 2024.3+)."""
         _LOGGER.info("Reconfigure flow started")
         reconfigure_entry = self.hass.config_entries.async_get_entry(self.context["entry_id"])