Merge pull request #6 from gensyn/copilot/feature-expose-additional-configuration-services

Add input helper overrides for active state, task interval, and todo offset

Author: gensyn

README.md

@@ -71,14 +71,19 @@ Access task settings through the cog icon ⚙️ on the integration page.
 | Option | Description                                                                               |
 |--------|-------------------------------------------------------------------------------------------|
 | **Active** | Pause tasks when disabled (sensor shows `inactive` state)                                 |
+| **Active Override** | Select an `input_boolean` helper to override the Active setting at runtime               |
 | **Task Interval & Unit** | Modify how often the task repeats                                                         |
+| **Task Interval Override** | Select an `input_number` helper (value in days) to override the Task Interval at runtime |
 | **Material Design Icon** | Choose an icon for the sensor (available as attribute for notifications)                  |
 | **Tags** | Add keywords for filtering in automations/templates (e.g., assignees, notification times) |
-| **Todo Lists** | Select Local Todo lists for automatic task addition when due                              |
+| **Todo Lists** | Select Todo lists for automatic task addition when due                                    |
 | **Todo List Offset** | Add task to lists `n` days before due date                                                |
+| **Todo List Offset Override** | Select an `input_number` helper (value in days) to override the Todo List Offset at runtime |
 | **Notification Interval** | Reference value for automation/template notification timing                               |
 
-> **Note:** Tags and notification intervals require you to implement filtering logic in your own automations. 
+> **Note:** Tags and notification intervals require you to implement filtering logic in your own automations.
+>
+> **Override fields:** When an override helper is selected, its current value takes precedence over the configured option. If the helper is `unavailable` or `unknown`, the configured value is used as a fallback. Override values react to helper state changes in real time, allowing non-admin users to adjust task behaviour through dashboard tiles or scripts without needing access to integration settings.
 
 ---
 

__init__.py

@@ -13,7 +13,8 @@
 from homeassistant.helpers.typing import ConfigType
 from .const import DOMAIN, CONF_TASK_INTERVAL_VALUE, CONF_DAY, CONF_TASK_INTERVAL_TYPE, CONF_NOTIFICATION_INTERVAL, \
     CONF_TODO_OFFSET_DAYS, CONF_TAGS, CONF_ACTIVE, CONF_TODO_LISTS, SERVICE_MARK_AS_DONE, \
-    SERVICE_MARK_AS_DONE_SCHEMA, SERVICE_SET_LAST_DONE_DATE, SERVICE_SET_LAST_DONE_DATE_SCHEMA, CONF_DATE
+    SERVICE_MARK_AS_DONE_SCHEMA, SERVICE_SET_LAST_DONE_DATE, SERVICE_SET_LAST_DONE_DATE_SCHEMA, CONF_DATE, \
+    CONF_ACTIVE_OVERRIDE, CONF_TASK_INTERVAL_OVERRIDE, CONF_TODO_OFFSET_OVERRIDE
 from .frontend import TaskTrackerCardRegistration
 from .sensor import TaskTrackerSensor
 

assets/3_options.png

@@ -13,6 +13,9 @@
 CONF_DROPDOWN = "dropdown"
 CONF_TAGS = "tags"
 CONF_ACTIVE = "active"
+CONF_ACTIVE_OVERRIDE = "active_override"
+CONF_TASK_INTERVAL_OVERRIDE = "task_interval_override"
+CONF_TODO_OFFSET_OVERRIDE = "todo_offset_override"
 CONF_SELECT = "select"
 CONF_DAY = "day"
 CONF_WEEK = "week"

const.py

@@ -2,27 +2,28 @@
 
 import voluptuous as vol
 
-from homeassistant.components.local_todo.const import DOMAIN as LOCAL_TODO_DOMAIN
 from homeassistant.config_entries import OptionsFlowWithReload, ConfigFlowResult
 from homeassistant.const import CONF_ICON, CONF_OPTIONS, CONF_MODE
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import entity_registry
 from homeassistant.helpers.selector import selector
 from .const import CONF_TASK_INTERVAL_VALUE, CONF_NOTIFICATION_INTERVAL, CONF_TAGS, CONF_ACTIVE, \
     CONF_TASK_INTERVAL_TYPE, CONF_TODO_OFFSET_DAYS, CONF_SELECT, CONF_DAY, CONF_WEEK, CONF_MONTH, CONF_YEAR, \
-    CONF_DROPDOWN, CONF_TODO_LISTS
+    CONF_DROPDOWN, CONF_TODO_LISTS, CONF_ACTIVE_OVERRIDE, CONF_TASK_INTERVAL_OVERRIDE, CONF_TODO_OFFSET_OVERRIDE
 
 
 class TaskTrackerOptionsFlow(OptionsFlowWithReload):
     async def async_step_init(
             self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Manage the options."""
-        todo_lists = await get_todo_lists(self.hass)
 
         STEP_INIT_SCHEMA = vol.Schema(
             {
                 vol.Optional(CONF_ACTIVE): bool,
+                vol.Optional(CONF_ACTIVE_OVERRIDE): selector({
+                    "entity": {
+                        "domain": "input_boolean",
+                    }
+                }),
                 vol.Required(CONF_TASK_INTERVAL_VALUE, default=7): int,
                 vol.Required(CONF_TASK_INTERVAL_TYPE): selector({
                     CONF_SELECT: {
@@ -31,17 +32,25 @@ async def async_step_init(
                         "translation_key": "task_interval",
                     }
                 }),
+                vol.Optional(CONF_TASK_INTERVAL_OVERRIDE): selector({
+                    "entity": {
+                        "domain": "input_number",
+                    }
+                }),
                 vol.Optional(CONF_ICON, default="mdi:calendar-question"): str,
                 vol.Optional(CONF_TAGS): str,
                 vol.Optional(CONF_TODO_LISTS): selector({
-                    CONF_SELECT: {
-                        CONF_OPTIONS: [{"value": todo[0], "label": todo[1]} for todo in todo_lists],
-                        CONF_MODE: CONF_DROPDOWN,
-                        "translation_key": "task_interval",
+                    "entity": {
+                        "domain": "todo",
                         "multiple": True,
                     }
                 }),
                 vol.Optional(CONF_TODO_OFFSET_DAYS, default=0): int,
+                vol.Optional(CONF_TODO_OFFSET_OVERRIDE): selector({
+                    "entity": {
+                        "domain": "input_number",
+                    }
+                }),
                 vol.Optional(CONF_NOTIFICATION_INTERVAL, default=1): int,
             }
         )
@@ -59,14 +68,6 @@ async def async_step_init(
         return self.async_create_entry(data=options)
 
 
-async def get_todo_lists(hass: HomeAssistant) -> list[tuple[str, str]]:
-    """Return entity_ids and friendly names for all todo lists of the domain Local Todo."""
-    registry = entity_registry.async_get(hass)
-    return [(entry.entity_id, hass.states.get(entry.entity_id).attributes.get("friendly_name", entry.entity_id)) for
-            entry in registry.entities.values() if
-            entry.platform == LOCAL_TODO_DOMAIN and entry.entity_id.startswith("todo.")]
-
-
 async def validate_options(user_input: dict[str, Any]) -> dict[str, Any]:
     if user_input.get(CONF_ACTIVE) is None:
         user_input[CONF_ACTIVE] = True
@@ -97,11 +98,14 @@ async def validate_options(user_input: dict[str, Any]) -> dict[str, Any]:
 
     return {
         CONF_ACTIVE: user_input[CONF_ACTIVE],
+        CONF_ACTIVE_OVERRIDE: user_input.get(CONF_ACTIVE_OVERRIDE) or None,
         CONF_TASK_INTERVAL_VALUE: user_input[CONF_TASK_INTERVAL_VALUE],
         CONF_TASK_INTERVAL_TYPE: user_input[CONF_TASK_INTERVAL_TYPE],
+        CONF_TASK_INTERVAL_OVERRIDE: user_input.get(CONF_TASK_INTERVAL_OVERRIDE) or None,
         CONF_ICON: user_input[CONF_ICON],
         CONF_TAGS: user_input[CONF_TAGS],
         CONF_TODO_LISTS: user_input[CONF_TODO_LISTS],
         CONF_TODO_OFFSET_DAYS: user_input[CONF_TODO_OFFSET_DAYS],
+        CONF_TODO_OFFSET_OVERRIDE: user_input.get(CONF_TODO_OFFSET_OVERRIDE) or None,
         CONF_NOTIFICATION_INTERVAL: user_input[CONF_NOTIFICATION_INTERVAL],
     }

options_flow.py

@@ -24,7 +24,7 @@
 from homeassistant.util.dt import UTC
 from .const import DOMAIN, CONF_TASK_INTERVAL_VALUE, CONF_NOTIFICATION_INTERVAL, CONF_TAGS, CONF_ACTIVE, CONF_WEEK, \
     CONF_MONTH, CONF_YEAR, CONST_DUE, CONST_INACTIVE, CONST_DONE, CONF_TASK_INTERVAL_TYPE, CONF_TODO_OFFSET_DAYS, \
-    CONF_TODO_LISTS, CONF_DAY
+    CONF_TODO_LISTS, CONF_DAY, CONF_ACTIVE_OVERRIDE, CONF_TASK_INTERVAL_OVERRIDE, CONF_TODO_OFFSET_OVERRIDE
 
 LOGGER = getLogger(__name__)
 
@@ -41,7 +41,10 @@ async def async_setup_entry(
         [TaskTrackerSensor(data[CONF_NAME], options[CONF_TASK_INTERVAL_VALUE], options[CONF_TASK_INTERVAL_TYPE],
                            options[CONF_NOTIFICATION_INTERVAL], options[CONF_TODO_LISTS],
                            options[CONF_TODO_OFFSET_DAYS], options[CONF_TAGS],
-                           options[CONF_ACTIVE], options[CONF_ICON], entry.entry_id, hass)])
+                           options[CONF_ACTIVE], options[CONF_ICON], entry.entry_id, hass,
+                           options.get(CONF_ACTIVE_OVERRIDE),
+                           options.get(CONF_TASK_INTERVAL_OVERRIDE),
+                           options.get(CONF_TODO_OFFSET_OVERRIDE))])
 
 
 class TaskTrackerSensor(RestoreSensor, SensorEntity):
@@ -53,7 +56,10 @@ class TaskTrackerSensor(RestoreSensor, SensorEntity):
 
     def __init__(self, entry_name: str, task_interval_value: int, task_interval_type: str,
                  notification_interval: int, todo_lists: list[str], todo_offset_days: int, tags: str, active: bool,
-                 icon: str, entry_id: str, hass: HomeAssistant) -> None:
+                 icon: str, entry_id: str, hass: HomeAssistant,
+                 active_override: str | None = None,
+                 task_interval_override: str | None = None,
+                 todo_offset_override: str | None = None) -> None:
         """Initialize the sensor with a service name."""
         self.task_interval_value: int = task_interval_value
         self.task_interval_type: str = task_interval_type
@@ -70,6 +76,12 @@ def __init__(self, entry_name: str, task_interval_value: int, task_interval_type
         self.due_date: date = date(1970, 1, 1)
         self.due_in: int = 0
         self.mark_as_done_scheduled: Callable[[], None] | None = None
+        self.active_override: str | None = active_override
+        self.task_interval_override: str | None = task_interval_override
+        self.todo_offset_override: str | None = todo_offset_override
+        # Effective values after applying overrides; initialised to configured values
+        self._effective_active: bool = active
+        self._effective_todo_offset_days: int = todo_offset_days
 
         device_id = f"{DOMAIN}_{self.entry_id}"
         self._attr_name = None
@@ -107,6 +119,16 @@ async def async_added_to_hass(self) -> None:
             )
         )
 
+        # Subscribe to override entity state changes
+        if any([self.active_override, self.task_interval_override, self.todo_offset_override]):
+            self.async_on_remove(
+                self.hass.bus.async_listen(
+                    EVENT_STATE_CHANGED,
+                    self.async_update,
+                    self._filter_override_changes,
+                )
+            )
+
         if self.hass.state == CoreState.running:
             await self.async_update()
         else:
@@ -118,34 +140,63 @@ async def async_added_to_hass(self) -> None:
     async def async_update(self, _=None) -> None:
         self._attr_native_value = CONST_DONE
 
-        if self.task_interval_type == CONF_WEEK:
-            self.due_date = self.last_done + relativedelta(weeks=self.task_interval_value)
-        elif self.task_interval_type == CONF_MONTH:
-            self.due_date = self.last_done + relativedelta(months=self.task_interval_value)
-        elif self.task_interval_type == CONF_YEAR:
-            self.due_date = self.last_done + relativedelta(years=self.task_interval_value)
+        effective_active = self.active
+        if self.active_override:
+            override_state = self.hass.states.get(self.active_override)
+            if override_state is not None and override_state.state not in ("unavailable", "unknown"):
+                effective_active = override_state.state == "on"
+
+        effective_task_interval_value = self.task_interval_value
+        effective_task_interval_type = self.task_interval_type
+        if self.task_interval_override:
+            override_state = self.hass.states.get(self.task_interval_override)
+            if override_state is not None and override_state.state not in ("unavailable", "unknown"):
+                try:
+                    effective_task_interval_value = max(1, int(float(override_state.state)))
+                    effective_task_interval_type = CONF_DAY
+                except (ValueError, TypeError):
+                    pass
+
+        effective_todo_offset_days = self.todo_offset_days
+        if self.todo_offset_override:
+            override_state = self.hass.states.get(self.todo_offset_override)
+            if override_state is not None and override_state.state not in ("unavailable", "unknown"):
+                try:
+                    effective_todo_offset_days = max(0, int(float(override_state.state)))
+                except (ValueError, TypeError):
+                    pass
+
+        if effective_task_interval_type == CONF_WEEK:
+            self.due_date = self.last_done + relativedelta(weeks=effective_task_interval_value)
+        elif effective_task_interval_type == CONF_MONTH:
+            self.due_date = self.last_done + relativedelta(months=effective_task_interval_value)
+        elif effective_task_interval_type == CONF_YEAR:
+            self.due_date = self.last_done + relativedelta(years=effective_task_interval_value)
         else:
-            self.due_date = self.last_done + relativedelta(days=self.task_interval_value)
+            self.due_date = self.last_done + relativedelta(days=effective_task_interval_value)
 
         self.due_in: int = (self.due_date - date.today()).days if self.due_date > date.today() else 0
         overdue_by: int = (date.today() - self.due_date).days if self.due_date < date.today() else 0
 
-        if not self.active:
+        if not effective_active:
             self._attr_native_value = CONST_INACTIVE
         elif self.due_in == 0:
             self._attr_native_value = CONST_DUE
 
+        self._effective_active: bool = effective_active
+        self._effective_todo_offset_days: int = effective_todo_offset_days
+
         self._attr_extra_state_attributes: dict[str, str | int | list] = {
             "last_done": str(self.last_done),
             "due_date": str(self.due_date),
             "due_in": self.due_in,
             "overdue_by": overdue_by,
-            "task_interval_value": self.task_interval_value,
-            "task_interval_type": self.task_interval_type,
+            "task_interval_value": effective_task_interval_value,
+            "task_interval_type": effective_task_interval_type,
             "icon": self.icon,
             "tags": self.tags,
             "todo_lists": self.todo_lists,
-            "todo_offset_days": self.todo_offset_days,
+            "todo_offset_days": effective_todo_offset_days,
             "notification_interval": self.notification_interval,
         }
         self.async_write_ha_state()
@@ -159,6 +210,13 @@ def _filter_state_changes(self, event_data: EventStateChangedData) -> bool:
         return event_data["entity_id"] in self.todo_lists and event_data.get("old_state") and event_data.get(
             "new_state") and event_data["new_state"].state < event_data["old_state"].state
 
+    @callback
+    def _filter_override_changes(self, event_data: EventStateChangedData) -> bool:
+        """Listen only for state changes in override entities."""
+        override_entities = {e for e in
+                             [self.active_override, self.task_interval_override, self.todo_offset_override] if e}
+        return event_data["entity_id"] in override_entities
+
     async def async_todo_list_changed(self, event: Any) -> None:
         if self.mark_as_done_scheduled:
             self.mark_as_done_scheduled()
@@ -185,7 +243,7 @@ async def async_todo_list_changed_deferred(self, event: Any, _) -> None:
     async def async_sync_todo_list(self, todo_list: str) -> None:
         existing_item: dict | None = await self.async_get_item_from_todo_list(todo_list)
 
-        if self.active and self.due_in <= self.todo_offset_days:
+        if self._effective_active and self.due_in <= self._effective_todo_offset_days:
             # there is supposed to be an item in the todo list
             if existing_item is None:
                 # The item does not exist, so we need to add it

sensor.py

@@ -36,22 +36,28 @@
                 "data": {
                     "task_interval_value": "Task Interval",
                     "task_interval_type": "Task Interval Unit",
+                    "task_interval_override": "Task Interval Override",
                     "notification_interval": "Notification Interval (days)",
                     "todo_lists": "Todo-Lists",
                     "todo_offset_days": "Todo-List Offset (days)",
+                    "todo_offset_override": "Todo-List Offset Override (days)",
                     "tags": "Tags",
                     "icon": "Icon",
-                    "active": "Active"
+                    "active": "Active",
+                    "active_override": "Active Override"
                 },
                 "data_description": {
                     "task_interval_value": "Time after which the task becomes due again.",
                     "task_interval_type": "The unit of time for the task interval.",
+                    "task_interval_override": "Select an input_number (value in days) to override the Task Interval.",
                     "notification_interval": "The time in days after which notifications are sent again.",
                     "todo_lists": "Todo-Lists, to which this task will be added.",
                     "todo_offset_days": "The number of days before the task is due, to add the task to the Todo-List(s).",
+                    "todo_offset_override": "Select an input_number (value in days) to override the Todo-List Offset.",
                     "tags": "Tags to categorize the task, separated by commas.",
                     "icon": "Icon to represent the task.",
-                    "active": "Enable or disable the task."
+                    "active": "Enable or disable the task.",
+                    "active_override": "Select an input_boolean to override the Active setting."
                 }
             }
         }