From c1cb64e55141d0d15964aa3f07a1823ce99ec2a9 Mon Sep 17 00:00:00 2001 From: Malene Trab Date: Wed, 18 Nov 2026 18:39:39 +0000 Subject: [PATCH 1/2] Refresh Vector battery and lifetime stats periodically --- custom_components/vector/coordinator.py | 61 ++++++++++---- tests/test_coordinator.py | 107 +++++++++++++++++++++++- 2 files changed, 150 insertions(+), 18 deletions(-) diff --git a/custom_components/vector/coordinator.py b/custom_components/vector/coordinator.py index 6484674..803480e 100644 --- a/custom_components/vector/coordinator.py +++ b/custom_components/vector/coordinator.py @@ -30,6 +30,7 @@ _MAX_EVENT_READS = 10 _STREAM_READ_TIMEOUT_SECONDS = 120.0 _STREAM_RECONNECT_DELAY_SECONDS = 3.0 +_TELEMETRY_POLL_INTERVAL_SECONDS = 300 _INITIAL_REFRESH_TIMEOUT_SECONDS = 20.0 _INITIAL_REFRESH_RETRY_ATTEMPTS = 5 _INITIAL_REFRESH_RETRY_DELAY_SECONDS = 3.0 @@ -110,6 +111,8 @@ def __init__(self, hass: HomeAssistant, entry: ConfigEntry) -> None: self._activity_tracker: Any | None = None self._telemetry_filter: Any | None = None self._event_listener_task: asyncio.Task[None] | None = None + self._telemetry_poll_task: asyncio.Task[None] | None = None + self._initial_refresh_complete = False self._camera_stream_task: asyncio.Task[None] | None = None self._nav_map_stream_task: asyncio.Task[None] | None = None self._wake_enable_stream_task: asyncio.Task[None] | None = None @@ -125,9 +128,10 @@ def __init__(self, hass: HomeAssistant, entry: ConfigEntry) -> None: self._auth_backoff_lock = asyncio.Lock() async def _async_update_data(self) -> None: - """Do initial one-shot load at setup.""" + """Refresh battery and lifetime stats, and load settings at startup.""" try: client, messaging = await self._async_get_client() + previous_robot_state = self._latest_robot_state ( battery_volts, battery_level, @@ -136,28 +140,34 @@ async def _async_update_data(self) -> None: client, messaging, ) - firmware_version = await self._async_read_firmware_version( - client, messaging - ) lifetime_stats = await self._async_read_lifetime_stats() - master_volume = await self._async_read_master_volume() - eye_color = await self._async_read_eye_color() - activity = self.current_activity + if not self._initial_refresh_complete: + await self._async_load_initial_settings(client, messaging) except Exception as err: - raise UpdateFailed(f"Failed to update Vector activity: {err}") from err + raise UpdateFailed( + "Failed to refresh Vector battery and lifetime stats" + ) from err self.battery_percent = _battery_percentage_from_wirepod_curve(battery_volts) self.battery_volts = battery_volts self.battery_level = battery_level - self.is_charging = is_charging - self.firmware_version = firmware_version + if self._latest_robot_state is previous_robot_state: + self.is_charging = is_charging if lifetime_stats is not None: self.days_alive = lifetime_stats.days_alive self.reacted_to_trigger_word = lifetime_stats.reacted_to_trigger_word self.utility_features_used = lifetime_stats.utility_features_used self.seconds_petted = lifetime_stats.seconds_petted self.distance_moved_cm = lifetime_stats.distance_moved_cm - self.master_volume = master_volume + self._auth_backoff_delay_seconds = _AUTH_BACKOFF_BASE_DELAY_SECONDS + + async def _async_load_initial_settings(self, client: Any, messaging: Any) -> None: + """Read firmware and settings during the first successful refresh.""" + self.firmware_version = await self._async_read_firmware_version( + client, messaging + ) + self.master_volume = await self._async_read_master_volume() + eye_color = await self._async_read_eye_color() if eye_color is not None: preset = str(getattr(eye_color, "preset", "")).strip().lower() self.eye_color_preset = preset or None @@ -167,18 +177,14 @@ async def _async_update_data(self) -> None: custom_hue = getattr(eye_color, "custom_hue", None) custom_saturation = getattr(eye_color, "custom_saturation", None) self.eye_color_custom_hue = ( - float(custom_hue) - if isinstance(custom_hue, (int, float)) - else None + float(custom_hue) if isinstance(custom_hue, (int, float)) else None ) self.eye_color_custom_saturation = ( float(custom_saturation) if isinstance(custom_saturation, (int, float)) else None ) - self.current_activity = activity - self._auth_backoff_delay_seconds = _AUTH_BACKOFF_BASE_DELAY_SECONDS - return None + self._initial_refresh_complete = True async def async_validate_connection(self) -> None: """Validate robot connectivity/auth for config entry setup.""" @@ -249,9 +255,30 @@ async def async_start_runtime(self) -> None: ) await self.async_start_event_listener() + if self._telemetry_poll_task is None: + self._telemetry_poll_task = self.hass.async_create_background_task( + self._async_poll_telemetry(), + name=f"vector_telemetry_poll_{self.entry.entry_id}", + ) + + async def _async_poll_telemetry(self) -> None: + """Refresh telemetry independently of event stream notifications.""" + while True: + await asyncio.sleep(_TELEMETRY_POLL_INTERVAL_SECONDS) + if not self.entry.pref_disable_polling: + await self.async_refresh() async def async_shutdown(self) -> None: """Disconnect active client resources.""" + await super().async_shutdown() + if self._telemetry_poll_task is not None: + self._telemetry_poll_task.cancel() + try: + await self._telemetry_poll_task + except asyncio.CancelledError: + pass + self._telemetry_poll_task = None + if self._event_listener_task is not None: self._event_listener_task.cancel() try: diff --git a/tests/test_coordinator.py b/tests/test_coordinator.py index ce39170..918057c 100644 --- a/tests/test_coordinator.py +++ b/tests/test_coordinator.py @@ -2,14 +2,17 @@ from __future__ import annotations +import asyncio from types import SimpleNamespace +from unittest.mock import AsyncMock, Mock +from custom_components.vector import coordinator from custom_components.vector.coordinator import ( VectorCoordinator, _battery_percentage_from_wirepod_curve, _derive_activity_from_robot_state, - _extract_robot_telemetry_snapshot, _extract_camera_frame_bytes, + _extract_robot_telemetry_snapshot, _is_unauthenticated_error, _normalize_activity_state, _normalize_battery_level_name, @@ -30,6 +33,108 @@ def _state(**kwargs): return SimpleNamespace(**defaults) +def test_telemetry_refresh_keeps_newer_push_charging_state() -> None: + """Keep charging changes received during a poll.""" + + async def run() -> None: + vector = VectorCoordinator(Mock(), SimpleNamespace(entry_id="vector-entry")) + battery_started = asyncio.Event() + finish_battery = asyncio.Event() + vector._async_get_client = AsyncMock(return_value=(object(), object())) + + async def read_battery(*_args): + battery_started.set() + await finish_battery.wait() + return 4.10, "nominal", False + + first_stats = SimpleNamespace( + days_alive=1, + reacted_to_trigger_word=2, + utility_features_used=3, + seconds_petted=4, + distance_moved_cm=5, + ) + vector._async_read_lifetime_stats = AsyncMock( + side_effect=[ + first_stats, + SimpleNamespace(**(vars(first_stats) | {"days_alive": 2})), + ] + ) + vector._async_read_firmware_version = AsyncMock(return_value="firmware") + vector._async_read_master_volume = AsyncMock(return_value="medium") + vector._async_read_eye_color = AsyncMock(return_value=None) + vector._async_read_battery_state = AsyncMock(return_value=(3.70, "low", False)) + await vector._async_update_data() + assert vector.battery_volts == 3.70 + assert vector.days_alive == 1 + + vector._async_read_battery_state.side_effect = read_battery + refresh = asyncio.create_task(vector._async_update_data()) + await battery_started.wait() + vector._latest_robot_state = object() + vector.is_charging = True + finish_battery.set() + await refresh + + assert vector.battery_percent == 100 + assert vector.is_charging is True + assert vector.days_alive == 2 + vector._async_read_firmware_version.assert_awaited_once() + vector._async_read_master_volume.assert_awaited_once() + vector._async_read_eye_color.assert_awaited_once() + + asyncio.run(run()) + + +def test_telemetry_poll_runs_independently_and_stops_on_shutdown(monkeypatch) -> None: + """Polling runs alongside push updates and is cancelled on unload.""" + + async def run() -> None: + hass = Mock() + hass.async_create_background_task.side_effect = asyncio.create_task + entry = SimpleNamespace(entry_id="vector-entry", pref_disable_polling=False) + vector = VectorCoordinator(hass, entry) + vector.battery_percent = 50 + vector.firmware_version = "firmware" + vector.async_refresh = AsyncMock() + vector.async_start_event_listener = AsyncMock() + tick = asyncio.Semaphore(0) + timer_started = asyncio.Event() + + async def sleep(delay): + assert delay == 300 + timer_started.set() + await tick.acquire() + + monkeypatch.setattr( + coordinator, + "asyncio", + SimpleNamespace( + sleep=sleep, + wait_for=asyncio.wait_for, + CancelledError=asyncio.CancelledError, + ), + ) + await vector.async_start_runtime() + task = vector._telemetry_poll_task + await timer_started.wait() + vector.async_set_updated_data(None) + tick.release() + await asyncio.sleep(0) + assert vector.async_refresh.await_count == 2 + + entry.pref_disable_polling = True + tick.release() + await asyncio.sleep(0) + assert vector.async_refresh.await_count == 2 + + await vector.async_shutdown() + assert task.cancelled() + assert vector._telemetry_poll_task is None + + asyncio.run(run()) + + def test_derive_activity_sleeping_from_calm_power_mode() -> None: """Robot in calm power mode should map to sleeping.""" robot_state = _state(status=0x400) From 0c6e5b79e0357664e76c0ce8aaae7a8b7675a88f Mon Sep 17 00:00:00 2001 From: Malene Trab Date: Wed, 18 Nov 2026 18:47:33 +0000 Subject: [PATCH 2/2] Initialize telemetry test coordinator with Home Assistant installed --- tests/test_coordinator.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/tests/test_coordinator.py b/tests/test_coordinator.py index 918057c..61d8e7b 100644 --- a/tests/test_coordinator.py +++ b/tests/test_coordinator.py @@ -4,7 +4,7 @@ import asyncio from types import SimpleNamespace -from unittest.mock import AsyncMock, Mock +from unittest.mock import AsyncMock, Mock, patch from custom_components.vector import coordinator from custom_components.vector.coordinator import ( @@ -37,7 +37,8 @@ def test_telemetry_refresh_keeps_newer_push_charging_state() -> None: """Keep charging changes received during a poll.""" async def run() -> None: - vector = VectorCoordinator(Mock(), SimpleNamespace(entry_id="vector-entry")) + with patch("homeassistant.helpers.frame.report_usage"): + vector = VectorCoordinator(Mock(), SimpleNamespace(entry_id="vector-entry")) battery_started = asyncio.Event() finish_battery = asyncio.Event() vector._async_get_client = AsyncMock(return_value=(object(), object())) @@ -93,7 +94,8 @@ async def run() -> None: hass = Mock() hass.async_create_background_task.side_effect = asyncio.create_task entry = SimpleNamespace(entry_id="vector-entry", pref_disable_polling=False) - vector = VectorCoordinator(hass, entry) + with patch("homeassistant.helpers.frame.report_usage"): + vector = VectorCoordinator(hass, entry) vector.battery_percent = 50 vector.firmware_version = "firmware" vector.async_refresh = AsyncMock()