stateengine plugin: improve action scheduler

Author: onkelandy

stateengine/StateEngineActionScheduler.py

@@ -35,19 +35,20 @@ def __init__(self, smarthome, se_plugin, logger):
         self._next_wakeup = None
 
     # ---------- API für Items ----------
-    def add(self, abitem, name, action, value, next_run):
+    def add(self, abitem, name, action, value, next_run, overwrite, callback=None):
         self._queue.put((
             'add',
             abitem,
             name,
             {
                 'action': action,
                 'value': value or {},
-                'next': next_run
-            }
+                'next': next_run,
+                'overwrite': overwrite
+            },
+            callback
         ))
         self._mark_dirty()
-        self._schedule_wakeup(next_run)
 
     def remove(self, abitem, name, callback=None):
         self._queue.put(('remove', abitem, name, callback))
@@ -62,14 +63,6 @@ def _mark_dirty(self):
             self._dirty = True
             self._se_plugin.scheduler_trigger('actionscheduler')
 
-    def _schedule_wakeup(self, next_run):
-        if next_run is None:
-            return
-
-        if self._next_wakeup is None or next_run < self._next_wakeup:
-            self._next_wakeup = next_run
-            self._se_plugin.scheduler_trigger('actionscheduler', dt=next_run)
-
     # ---------- Scheduler Loop ----------
     def run(self):
         self._dirty = False
@@ -80,9 +73,22 @@ def run(self):
             cmd = self._queue.get()
 
             if cmd[0] == 'add':
-                _, abitem, name, entry = cmd
+                _, abitem, name, entry, callback = cmd
+                key = (abitem, name)
                 with self._lock:
-                    self._scheduled[(abitem, name)] = entry
+                    if key in self._scheduled and entry.get('overwrite', True) is False:
+                        new_next = self._scheduled[key]['next']
+                        added = False
+                    else:
+                        self._scheduled[key] = entry
+                        new_next = entry.get('next')
+                        added = True
+
+                if callback:
+                    try:
+                        callback(added, new_next)
+                    except Exception as e:
+                        self.logger.debug(f"Add callback failed for '{name}': {e}")
 
             elif cmd[0] == 'remove':
                 _, abitem, name, callback = cmd
@@ -92,7 +98,7 @@ def run(self):
                     try:
                         callback(removed)
                     except Exception as e:
-                        self.logger.debug(f"Remove callback failed: {e}")
+                        self.logger.debug(f"Remove callback failed for '{name}': {e}")
 
             elif cmd[0] == 'remove_all':
                 _, abitem, callback = cmd
@@ -125,6 +131,12 @@ def run(self):
                     self.logger.debug(f"Scheduled action '{name}' executing")
                 '''
                 action.delayed_execute(**vals)
+        next_times = []
+
         with self._lock:
             for entry in self._scheduled.values():
-                self._schedule_wakeup(entry['next'])
+                next_times.append(entry['next'])
+
+        if next_times:
+            next_wakeup = min(next_times)
+            self._se_plugin.scheduler_trigger('actionscheduler', dt=next_wakeup)

stateengine/StateEngineItem.py

@@ -215,6 +215,7 @@ def __init__(self, smarthome, item, se_plugin):
         self.__cache = {}
         self.__last_run = {}
         self.__pass_repeat = {}
+        self._delayedactions_text = []
         self.__default_instant_leaveaction = StateEngineValue.SeValue(self, "Default Instant Leave Action", False, "bool")
         self.__instant_leaveaction = StateEngineValue.SeValue(self, "Instant Leave Action", False, "num")
         try:
@@ -488,9 +489,14 @@ def updatetemplates(self, template, value):
         else:
             self.__templates[template] = value
 
-    def scheduler_add(self, name, action, value=None, next=None):
-        self.__logger.debug("Scheduling action {} with name {} at {}", action, name, next)
-        self.__se_plugin._action_scheduler.add(self, name, action, value, next)
+    def scheduler_add(self, name, action, value=None, next=None, overwrite=True):
+        def _log_result(added, new_next):
+            if added:
+                self._delayedactions_text.append(f"Scheduling action {action} with name '{name}' at {next}.")
+            else:
+                self._delayedactions_text.append(f"Scheduled action '{name}' already exists, overwrite is set to {overwrite}. Will run at {new_next}")
+
+        self.__se_plugin._action_scheduler.add(self, name, action, value, next, overwrite=overwrite, callback=_log_result)
 
     def scheduler_remove(self, name):
         def _log_result(removed):
@@ -767,11 +773,14 @@ def update_current_to_empty(d):
                             text = "No matching state found, staying at {0} ('{1}') based on conditionset {2} ('{3}')"
                             self.__logger.info(text, last_state.id, last_state.name, _last_conditionset_id,
                                                _last_conditionset_name)
-                        last_state.run_stay(self.__repeat_actions.get())
-                    if self.update_lock.locked():
-                        self.update_lock.release()
+                        last_state.run_stay(self.__repeat_actions.get())                
                     self.__logger.decrease_indent(50)
                     self.__logger.debug("State evaluation finished")
+                    for entry in self._delayedactions_text:
+                        self.__logger.debug("{}", entry)
+                    self._delayedactions_text = []
+                    if self.update_lock.locked():
+                        self.update_lock.release()
                     self.__logger.info("State evaluation queue empty.")
                     self.__handle_releasedby(new_state, last_state, _instant_leaveaction)