Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
61 changes: 44 additions & 17 deletions custom_components/vector/coordinator.py
Original file line number Diff line number Diff line change
Expand Up @@ -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
_SIGHTING_INTERVAL_SECONDS = 60
_INITIAL_REFRESH_TIMEOUT_SECONDS = 20.0
_INITIAL_REFRESH_RETRY_ATTEMPTS = 5
Expand Down Expand Up @@ -111,6 +112,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._face_seen_last: dict[str, float] = {}
self._cube_seen_last: dict[int, float] = {}
self._camera_stream_task: asyncio.Task[None] | None = None
Expand All @@ -128,9 +131,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,
Expand All @@ -139,28 +143,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
Expand All @@ -170,18 +180,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."""
Expand Down Expand Up @@ -252,9 +258,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:
Expand Down
104 changes: 104 additions & 0 deletions tests/test_coordinator.py
Original file line number Diff line number Diff line change
Expand Up @@ -35,6 +35,110 @@ 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:
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()))

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)
with patch("homeassistant.helpers.frame.report_usage"):
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_event_stream_publishes_and_throttles_sightings() -> None:
"""Publish eligible face and cube observations from one shared stream."""
light_cube_type = 2
Expand Down
Loading