Fix timeline retention

Author: valentinfrlch

custom_components/llmvision/timeline.py

@@ -496,6 +496,69 @@ def _ensure_datetime(self, dt):
             dt = dt.replace(tzinfo=datetime.timezone.utc)
         return dt
 
+    def _get_retention_days(self) -> int | None:
+        """Return the configured retention window in days (None disables cleanup)."""
+        raw_value = self._config_entry.options.get(CONF_RETENTION_TIME)
+        if raw_value is None:
+            raw_value = self.retention_time
+
+        if raw_value in (None, ""):
+            return None
+
+        try:
+            days = int(raw_value)
+        except (TypeError, ValueError):
+            _LOGGER.warning(
+                "Invalid retention_time=%s. Skipping automatic event purge.",
+                raw_value,
+            )
+            return None
+
+        if days <= 0:
+            return None
+
+        return days
+
+    async def _purge_expired_events(self) -> None:
+        """Remove events older than now - retention_time days."""
+        if getattr(self, "_migrating", False):
+            return
+
+        retention_days = self._get_retention_days()
+        if retention_days is None:
+            return
+
+        cutoff = dt_util.utcnow() - datetime.timedelta(days=retention_days)
+        cutoff_local = dt_util.as_local(self._ensure_datetime(cutoff)).isoformat()
+
+        try:
+            async with aiosqlite.connect(self._db_path) as db:
+                async with db.execute(
+                    """
+                    SELECT uid, key_frame FROM events
+                    WHERE start IS NOT NULL AND start < ?
+                """,
+                    (cutoff_local,),
+                ) as cursor:
+                    stale_rows = list(await cursor.fetchall())
+
+                if not stale_rows:
+                    return
+
+                await db.executemany(
+                    "DELETE FROM events WHERE uid = ?",
+                    [(row[0],) for row in stale_rows],
+                )
+                await db.commit()
+
+                _LOGGER.info(
+                    "Purged %s expired timeline event(s) older than %s day(s)",
+                    len(stale_rows),
+                    retention_days,
+                )
+        except aiosqlite.Error as e:
+            _LOGGER.error(f"Error purging expired timeline events: {e}")
+
     async def _get_category_from_label(self, label: str) -> str:
         """Returns the category for a given label using the language regex template."""
         return (await _get_category_and_label(self.hass, self._config_entry, label))[0]
@@ -511,6 +574,7 @@ async def get_linked_images(self):
 
     async def load_events(self):
         """Loads events from the database into memory"""
+        await self._purge_expired_events()
         self.events = []
         try:
             async with aiosqlite.connect(self._db_path) as db:
@@ -585,6 +649,7 @@ async def get_events_json(
         Supports filtering by camera, start/end range and sorting by start (newest first).
         category are ignored for now.
         """
+        await self._purge_expired_events()
         events: list[dict] = []
 
         # Normalize start/end inputs to timezone-aware datetimes (or None)

tests/test_timeline.py

@@ -1,8 +1,16 @@
 """Unit tests for timeline.py module."""
-import pytest
-from unittest.mock import Mock, patch, AsyncMock, MagicMock
+
 import datetime
+import os
+import uuid
 from dataclasses import dataclass
+from unittest.mock import AsyncMock, Mock
+
+import aiosqlite
+import pytest
+
+from custom_components.llmvision.timeline import Timeline
+from homeassistant.util import dt as dt_util
 
 
 @dataclass
@@ -30,19 +38,58 @@ def mock_hass(self):
         hass.config.path = Mock(return_value="/mock/path")
         hass.loop = Mock()
         hass.loop.run_in_executor = AsyncMock()
+        hass.async_add_executor_job = AsyncMock()
+        hass.async_create_task = lambda coro: None
         return hass
 
     @pytest.fixture
     def mock_config_entry(self):
         """Create a mock config entry."""
         entry = Mock()
         entry.entry_id = "test_entry"
-        entry.data = {
-            "provider": "Settings",
-            "retention_time": 7
-        }
+        entry.data = {"provider": "Settings", "retention_time": 7}
+        entry.options = {}
         return entry
 
+    @pytest.fixture
+    def timeline_factory(self, tmp_path, monkeypatch):
+        """Factory that builds isolated Timeline instances for retention tests."""
+
+        base_path = tmp_path / "config"
+        base_path.mkdir()
+
+        real_makedirs = os.makedirs
+
+        def safe_makedirs(path, exist_ok=False):
+            if str(path).startswith("/media/llmvision"):
+                return
+            return real_makedirs(path, exist_ok=exist_ok)
+
+        monkeypatch.setattr(
+            "custom_components.llmvision.timeline.os.makedirs", safe_makedirs
+        )
+
+        def _build(retention=2, options=None):
+            hass = Mock()
+            hass.data = {}
+            hass.config = Mock()
+            hass.config.path = lambda *parts: str(base_path.joinpath(*parts))
+            hass.loop = Mock()
+            hass.loop.run_in_executor = AsyncMock()
+            hass.async_add_executor_job = AsyncMock()
+            hass.async_create_task = lambda coro: None
+
+            entry = Mock()
+            entry.entry_id = "timeline-entry"
+            entry.data = {"provider": "Settings", "retention_time": retention}
+            entry.options = options or {}
+
+            timeline = Timeline(hass, entry)
+            timeline._migrating = False
+            return timeline
+
+        return _build
+
     def test_retention_time_from_config(self, mock_hass, mock_config_entry):
         """Test retention time is read from config."""
         assert mock_config_entry.data["retention_time"] == 7
@@ -56,7 +103,87 @@ def test_mock_event_creation(self):
             end=datetime.datetime.now(),
             description="Test desc"
         )
-        
+
         assert event.uid == "test-uid"
         assert event.title == "Test"
         assert event.key_frame == ""
+
+    async def _insert_rows(
+        self,
+        db_path: str,
+        rows: list[tuple[str, str, str, str, str, str, str, str, str]],
+    ):
+        async with aiosqlite.connect(db_path) as db:
+            for row in rows:
+                await db.execute(
+                    """
+                    INSERT INTO events (
+                        uid, title, start, end, description,
+                        key_frame, camera_name, category, label
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                    """,
+                    row,
+                )
+            await db.commit()
+
+    def _build_row(
+        self, title: str, age_days: float
+    ) -> tuple[str, str, str, str, str, str, str, str, str]:
+        base = datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(
+            days=age_days
+        )
+        start = dt_util.as_local(base).isoformat()
+        end = dt_util.as_local(base + datetime.timedelta(minutes=1)).isoformat()
+        return (
+            str(uuid.uuid4()),
+            title,
+            start,
+            end,
+            "",
+            "",
+            "",
+            "",
+            "",
+        )
+
+    async def _fetch_titles(self, db_path: str) -> list[str]:
+        async with aiosqlite.connect(db_path) as db:
+            async with db.execute("SELECT title FROM events ORDER BY title") as cursor:
+                rows = await cursor.fetchall()
+        return [row[0] for row in rows]
+
+    @pytest.mark.asyncio
+    async def test_retention_purges_old_events(self, timeline_factory):
+        """Events older than retention_time days are purged when loading."""
+
+        timeline = timeline_factory(retention=2)
+        await timeline._initialize_db()
+
+        rows = [
+            self._build_row("expired", age_days=5),
+            self._build_row("recent", age_days=0.1),
+        ]
+        await self._insert_rows(timeline._db_path, rows)
+
+        await timeline.load_events()
+
+        titles = await self._fetch_titles(timeline._db_path)
+        assert titles == ["recent"]
+
+    @pytest.mark.asyncio
+    async def test_zero_retention_disables_purge(self, timeline_factory):
+        """Setting retention_time to 0 leaves old events untouched."""
+
+        timeline = timeline_factory(retention=0)
+        await timeline._initialize_db()
+
+        rows = [
+            self._build_row("expired", age_days=10),
+            self._build_row("recent", age_days=0.5),
+        ]
+        await self._insert_rows(timeline._db_path, rows)
+
+        await timeline.load_events()
+
+        titles = await self._fetch_titles(timeline._db_path)
+        assert titles == ["expired", "recent"]