Refactor backend and remove redundant code

Author: chrisdoherty4

AGENTS.md

@@ -27,3 +27,5 @@ tasks.
 - Include adequate debug/info logs and honor configurable log levels (`info`/`debug`).
 - Consult https://developers.home-assistant.io/ for information on developing Home Assistant integrations.
 - Provide type hints for all function parameters and returns.
+- Avoid packages/modules named common, utils, const etc. Instead, prefer placing constants an interfaces near the consumer where possible.
+- Prioritize readable, maintainable code.

custom_components/maint/__init__.py

@@ -3,23 +3,32 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from homeassistant.const import Platform
 from homeassistant.helpers import config_validation as cv
 
-from .const import (
-    DEFAULT_TITLE,
-    DOMAIN,
-)
+from .config_flow import DEFAULT_TITLE
+from .domain import DOMAIN
 from .models import MaintConfigEntry, MaintRuntimeData, MaintTaskStore
 from .panel import async_register_panel, async_unregister_panel
 from .websocket import async_register_websocket_handlers
 
+# We only support setup from the UI so we need to load a config entry only schema.
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
+
+# Define the platforms we use.
 PLATFORMS: list[Platform] = [Platform.BINARY_SENSOR, Platform.SENSOR]
+
+# Define a key for storing and retrieving the task store in hass.data
+DATA_KEY_TASK_STORE = "task_store"
+
+# Define a key for indicating whether or not websockets have been registered.
+DATA_KEY_WS_REGISTERED = "ws_registered"
+
 _LOGGER = logging.getLogger(__name__)
 
+
 if TYPE_CHECKING:
     from homeassistant.config_entries import ConfigEntry
     from homeassistant.core import HomeAssistant
@@ -28,13 +37,13 @@
 
 async def async_setup(hass: HomeAssistant, _config: ConfigType) -> bool:
     """Set up Maint."""
-    data = hass.data.setdefault(DOMAIN, {})
+    data: dict[str, Any] = hass.data.setdefault(DOMAIN, {})
     _LOGGER.info("Setting up Maint integration")
     await _async_get_task_store(hass)
     await async_register_panel(hass)
-    if not data.get("ws_registered"):
+    if not data.get(DATA_KEY_WS_REGISTERED):
         async_register_websocket_handlers(hass)
-        data["ws_registered"] = True
+        data[DATA_KEY_WS_REGISTERED] = True
         _LOGGER.debug("Registered Maint websocket handlers")
     return True
 
@@ -83,12 +92,12 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
 async def _async_get_task_store(hass: HomeAssistant) -> MaintTaskStore:
     """Return the shared Maint task store."""
-    data = hass.data.setdefault(DOMAIN, {})
-    if (store := data.get("task_store")) is None:
+    data: dict[str, Any] = hass.data.setdefault(DOMAIN, {})
+    if (store := data.get(DATA_KEY_TASK_STORE)) is None:
         _LOGGER.debug("Creating Maint task store")
         store = MaintTaskStore(hass)
         await store.async_load()
-        data["task_store"] = store
+        data[DATA_KEY_TASK_STORE] = store
     else:
         _LOGGER.debug("Reusing existing Maint task store")
     return store

custom_components/maint/binary_sensor.py

@@ -10,20 +10,16 @@
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.util import slugify
 
-from .const import (
-    DOMAIN,
-    EVENT_TASK_DUE,
-    SIGNAL_TASK_CREATED,
-    SIGNAL_TASK_DELETED,
-    SIGNAL_TASK_UPDATED,
-)
+from .domain import DOMAIN
+from .models import SIGNAL_TASK_CREATED, SIGNAL_TASK_DELETED, SIGNAL_TASK_UPDATED
 
 if TYPE_CHECKING:
     from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
     from .models import MaintConfigEntry, MaintTask
 
 _LOGGER = logging.getLogger(__name__)
+EVENT_TASK_DUE = "maint_task_due"
 
 
 async def async_setup_entry(
@@ -37,38 +33,38 @@ async def async_setup_entry(
     tasks = await store.async_list_tasks(entry.entry_id)
 
     entities: dict[str, MaintTaskBinarySensor] = {}
-    async_add_entities(
-        [
-            entities.setdefault(
-                task.task_id, MaintTaskBinarySensor(entry=entry, task=task)
-            )
-            for task in tasks
-        ]
-    )
+    initial_entities = []
+    for task in tasks:
+        entity = MaintTaskBinarySensor(entry=entry, task=task)
+        entities[task.task_id] = entity
+        initial_entities.append(entity)
+    async_add_entities(initial_entities)
+
+    def _upsert_entity(task: MaintTask) -> MaintTaskBinarySensor | None:
+        """Create or update an entity for a task and return it if newly added."""
+        if existing := entities.get(task.task_id):
+            existing.handle_task_update(task)
+            return None
+
+        entity = MaintTaskBinarySensor(entry=entry, task=task)
+        entities[task.task_id] = entity
+        return entity
 
     @callback
     def handle_task_created(entry_id: str, task: MaintTask) -> None:
         """Create a sensor when a new task is added."""
         if entry_id != entry.entry_id:
             return
-        if task.task_id in entities:
-            entities[task.task_id].handle_task_update(task)
-            return
-        entity = MaintTaskBinarySensor(entry=entry, task=task)
-        entities[task.task_id] = entity
-        async_add_entities([entity])
+        if entity := _upsert_entity(task):
+            async_add_entities([entity])
 
     @callback
     def handle_task_updated(entry_id: str, task: MaintTask) -> None:
         """Update an existing sensor when a task is modified."""
         if entry_id != entry.entry_id:
             return
-        if entity := entities.get(task.task_id):
-            entity.handle_task_update(task)
-            return
-        entity = MaintTaskBinarySensor(entry=entry, task=task)
-        entities[task.task_id] = entity
-        async_add_entities([entity])
+        if entity := _upsert_entity(task):
+            async_add_entities([entity])
 
     @callback
     def handle_task_deleted(entry_id: str, task: MaintTask) -> None:

custom_components/maint/config_flow.py

@@ -6,14 +6,13 @@
 
 from homeassistant import config_entries
 
-from .const import (
-    DEFAULT_TITLE,
-    DOMAIN,
-)
+from .domain import DOMAIN
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
 
+DEFAULT_TITLE = "Maint"
+
 
 class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Maint."""

custom_components/maint/const.py

@@ -0,0 +1,3 @@
+"""Domain for the Maint integration."""
+
+DOMAIN = "maint"

custom_components/maint/domain.py

@@ -13,18 +13,18 @@
 from homeassistant.helpers.storage import Store
 from homeassistant.util import dt as dt_util
 
-from .const import (
-    SIGNAL_TASK_CREATED,
-    SIGNAL_TASK_DELETED,
-    SIGNAL_TASK_UPDATED,
-)
+from .domain import DOMAIN
 
 if TYPE_CHECKING:
-    from homeassistant.config_entries import ConfigEntry
     from homeassistant.core import HomeAssistant
 
-STORAGE_KEY = "maint.tasks"
+SIGNAL_TASK_CREATED = "maint_task_created"
+SIGNAL_TASK_UPDATED = "maint_task_updated"
+SIGNAL_TASK_DELETED = "maint_task_deleted"
+
+STORAGE_KEY = f"{DOMAIN}.store"
 STORAGE_VERSION = 1
+
 FREQUENCY_UNIT_DAYS: Literal["days"] = "days"
 FREQUENCY_UNIT_WEEKS: Literal["weeks"] = "weeks"
 FREQUENCY_UNIT_MONTHS: Literal["months"] = "months"
@@ -35,12 +35,6 @@
 )
 FrequencyUnit = Literal["days", "weeks", "months"]
 
-
-class _UnsetType:
-    """Sentinel type for unset optional values."""
-
-
-UNSET = _UnsetType()
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -140,29 +134,25 @@ async def async_load(self) -> None:
             return
         _LOGGER.debug("Loading Maint tasks from storage")
         data = await self._store.async_load()
-        if not data:
-            self._tasks = {}
-        else:
-            entries = data.get("entries", {})
-            tasks_by_entry: dict[str, dict[str, MaintTask]] = {}
-            for entry_id, tasks in entries.items():
-                entry_tasks: dict[str, MaintTask] = {}
-                for task_data in tasks:
-                    entry_tasks[task_data["task_id"]] = MaintTask.from_dict(task_data)
-                tasks_by_entry[entry_id] = entry_tasks
-            self._tasks = tasks_by_entry
-        total_tasks = sum(len(tasks) for tasks in self._tasks.values())
+        entries = data.get("entries", {}) if data else {}
+        self._tasks = {
+            entry_id: {
+                task_data["task_id"]: MaintTask.from_dict(task_data)
+                for task_data in tasks
+            }
+            for entry_id, tasks in entries.items()
+        }
+        entries_count, tasks_count = self._counts()
         _LOGGER.debug(
             "Loaded Maint task store: %s entries, %s tasks",
-            len(self._tasks),
-            total_tasks,
+            entries_count,
+            tasks_count,
         )
         self._loaded = True
 
     async def _async_save(self) -> None:
         """Persist tasks to disk."""
-        entries_count = len(self._tasks)
-        tasks_count = sum(len(tasks) for tasks in self._tasks.values())
+        entries_count, tasks_count = self._counts()
         await self._store.async_save(
             {
                 "entries": {
@@ -177,6 +167,10 @@ async def _async_save(self) -> None:
             tasks_count,
         )
 
+    def _counts(self) -> tuple[int, int]:
+        """Return counts of entries and tasks for logging."""
+        return len(self._tasks), sum(len(tasks) for tasks in self._tasks.values())
+
     async def _async_get_entry_tasks(self, entry_id: str) -> dict[str, MaintTask]:
         """Return the task mapping for an entry."""
         await self.async_load()
@@ -314,8 +308,8 @@ def validate(  # noqa: PLR0913
             message = "description cannot be empty"
             raise ValueError(message)
 
-        if last_completed is not None and last_completed == "":
-            message = "last_completed cannot be empty"
+        if last_completed is not None and not isinstance(last_completed, date):
+            message = "last_completed must be a date"
             raise ValueError(message)
 
         if frequency is not None and frequency <= 0:

custom_components/maint/models.py

@@ -9,7 +9,7 @@
 from homeassistant.components import frontend, panel_custom
 from homeassistant.components.http import StaticPathConfig
 
-from .const import DOMAIN
+from .domain import DOMAIN
 
 if TYPE_CHECKING:
     from homeassistant.core import HomeAssistant

custom_components/maint/panel.py

@@ -10,12 +10,8 @@
 from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 
-from .const import (
-    DOMAIN,
-    SIGNAL_TASK_CREATED,
-    SIGNAL_TASK_DELETED,
-    SIGNAL_TASK_UPDATED,
-)
+from .domain import DOMAIN
+from .models import SIGNAL_TASK_CREATED, SIGNAL_TASK_DELETED, SIGNAL_TASK_UPDATED
 
 if TYPE_CHECKING:
     from homeassistant.helpers.entity_platform import AddEntitiesCallback