fixed default off_duration

button.py

@@ -5,12 +5,10 @@ from appdaemon.plugins.mqtt.mqttapi import Mqtt
 from room_control import RoomController
 
 
-class ButtonController(Mqtt):
+class Button(Mqtt):
-    def initialize(self):
+    async def initialize(self):
-        task = self.get_app(self.args['app'])
+        self.app: RoomController = await self.get_app(self.args['app'])
-        self.app: RoomController = asyncio.get_event_loop().run_until_complete(task)
         self.setup_buttons(self.args['button'])
-        # self.log(f'Done')
 
     def setup_buttons(self, buttons):
         if isinstance(buttons, list):
@@ -26,29 +24,27 @@ class ButtonController(Mqtt):
         self.log(f'"{topic}" controls app {self.app.name}')
 
     async def handle_button(self, event_name, data, kwargs):
-        topic = data['topic']
-        self.log(f'Button event for: {topic}')
         try:
             payload = json.loads(data['payload'])
             action = payload['action']
-            button = kwargs['button']
         except json.JSONDecodeError:
             self.log(f'Error decoding JSON from {data["payload"]}', level='ERROR')
         except KeyError as e:
             return
         else:
-            self.log(f'{button}: {action}')
+            if action != '':
-            await self.handle_action(action)
+                await self.handle_action(action)
 
     async def handle_action(self, action: str):
-        if action == '':
+        if action == 'single':
-            return
+            self.log(f' {action.upper()} '.center(50, '='))
-        elif action == 'single':
+            state = await self.get_state(self.args['ref_entity'])
-            cause = 'button single click'
+            kwargs = {
-            state = await self.get_state(entity_id=self.args['ref_entity'])
+                'kwargs': {'cause': f'button single click: toggle while {state}'}
+            }
             if state == 'on':
-                self.app.deactivate(cause=cause)
+                self.app.deactivate(**kwargs)
             else:
-                await self.app.activate(cause=cause)
+                await self.app.activate(**kwargs)
         else:
             pass

door.py

@@ -4,8 +4,5 @@ from room_control import RoomController
 
 class Door(Hass):
     async def initialize(self):
-        await self.listen_state(self.door_open, entity_id=self.args['door'], new='on')
-    
-    async def door_open(self, entity, attribute, old, new, kwargs):
         app: RoomController = await self.get_app(self.args['app'])
-        await app.activate_all_off()
+        await self.listen_state(app.activate_all_off, entity_id=self.args['door'], new='on', cause='door open')

motion.py

@@ -1,28 +1,12 @@
-import asyncio
-from datetime import timedelta
 import re
+from datetime import timedelta
 
 from appdaemon.entity import Entity
 from appdaemon.plugins.hass.hassapi import Hass
 from room_control import RoomController
 
+from appdaemon import utils
 
-class CustomEventLoopPolicy(asyncio.DefaultEventLoopPolicy):
-    def get_event_loop(self):
-        try:
-            # Try to get the current event loop
-            loop = super().get_event_loop()
-        except RuntimeError as ex:
-            if "There is no current event loop" in str(ex):
-                # If there's no current loop, create a new one and set it
-                loop = self.new_event_loop()
-                self.set_event_loop(loop)
-            else:
-                raise
-        return loop
-
-# Set the custom event loop policy
-asyncio.set_event_loop_policy(CustomEventLoopPolicy())
 
 class Motion(Hass):
     @property
@@ -38,50 +22,39 @@ class Motion(Hass):
         return self.get_entity(self.args['ref_entity'])
 
     @property
-    def ref_entity_state(self) -> bool:
+    async def ref_entity_state(self) -> bool:
-        return self.ref_entity.get_state() == 'on'
+        return (await self.ref_entity.get_state()) == 'on'
 
-    def initialize(self):
+    async def initialize(self):
-        try:
+        self.app: RoomController = await self.get_app(self.args['app'])
-            loop = asyncio.get_event_loop()
-        except RuntimeError:
-            loop = asyncio.new_event_loop()
-
-        self.app: RoomController = loop.run_until_complete(self.get_app(self.args['app']))
         self.log(f'Connected to app {self.app.name}')
 
-        self.listen_state(self.callback_light_on, self.ref_entity.entity_id, new='on')
+        base_kwargs = dict(
-        self.listen_state(self.callback_light_off, self.ref_entity.entity_id, new='off')
+            entity_id=self.ref_entity.entity_id,
-
+            immediate=True, # avoids needing to sync the state
-        loop.run_until_complete(self.sync_state())
+        )
-
+        # don't need to await these because they'll already get turned into a task by the utils.sync_wrapper decorator
-    async def sync_state(self):
+        self.listen_state(**base_kwargs, attribute='brightness', callback=self.callback_light_on)
-        """Synchronizes the callbacks with the state of the light.
+        self.listen_state(**base_kwargs, new='off', callback=self.callback_light_off)
-
-        Essentially mimics the `state_change` callback based on the current state of the light.
-        """
-        if self.ref_entity_state:
-            await self.callback_light_on()
-        else:
-            await self.callback_light_off()
 
     async def listen_motion_on(self):
         """Sets up the motion on callback to activate the room
         """
-        self.log(f'Waiting for motion on {self.sensor.friendly_name}')
+        await self.cancel_motion_callback()
-        self.motion_on_handle = await self.listen_state(
+        await self.listen_state(
             callback=self.app.activate_all_off,
             entity_id=self.sensor.entity_id,
             new='on',
             oneshot=True,
             cause='motion on'
         )
+        self.log(f'Waiting for motion on {self.sensor.friendly_name}')
 
     async def listen_motion_off(self, duration: timedelta):
         """Sets up the motion off callback to deactivate the room
         """
-        self.log(f'Waiting for motion to stop on {self.sensor.friendly_name}')
+        await self.cancel_motion_callback()
-        self.motion_off_handle = await self.listen_state(
+        await self.listen_state(
             callback=self.app.deactivate,
             entity_id=self.sensor.entity_id,
             new='off',
@@ -89,19 +62,22 @@ class Motion(Hass):
             oneshot=True,
             cause='motion off'
         )
+        self.log(f'Waiting for motion to stop on {self.sensor.friendly_name} for {duration}')
 
+    @utils.sync_wrapper
     async def callback_light_on(self, entity=None, attribute=None, old=None, new=None, kwargs=None):
         """Called when the light turns on
         """
-        self.log('Light on callback')
+        if new is not None:
-        await self.cancel_motion_callback(new='on')
+            self.log(f'{entity} turned on')
-        await self.listen_motion_off(await self.app.off_duration())
+            duration = await self.app.off_duration()
+            await self.listen_motion_off(duration)
 
+    @utils.sync_wrapper
     async def callback_light_off(self, entity=None, attribute=None, old=None, new=None, kwargs=None):
         """Called when the light turns off
         """
-        self.log('Light off callback')
+        self.log(f'{entity} turned off')
-        await self.cancel_motion_callback(new='off')
         await self.listen_motion_on()
 
     async def get_app_callbacks(self, name: str = None):
@@ -123,13 +99,13 @@ class Motion(Hass):
             if info['entity'] == self.sensor.entity_id
         }
 
-    async def cancel_motion_callback(self, new: str):
+    async def cancel_motion_callback(self):
         callbacks = await self.get_sensor_callbacks()
-        # self.log(f'Found {len(callbacks)}')
+        # self.log(f'Found {len(callbacks)} callbacks for {self.sensor.entity_id}')
         for handle, info in callbacks.items():
             entity = info["entity"]
-            new_match = re.match('new=(?P<new>.*?)\s', info['kwargs'])
+            kwargs = info['kwargs']
-            # self.log(f'{handle}: {info["entity"]}: {info["kwargs"]}')
+            if (m := re.match('new=(?P<new>.*?)\s', kwargs)) is not None:
-            if new_match is not None and new_match.group("new") == new:
+                new = m.group('new')
                 await self.cancel_listen_state(handle)
-                self.log(f'cancelled: {await self.friendly_name(entity)}: {new}')
+                self.log(f'cancelled callback for sensor {entity} turning {new}')

room_control.py

@@ -1,13 +1,123 @@
-import asyncio
 from copy import deepcopy
-from datetime import time, timedelta
+from dataclasses import dataclass, field
-from typing import List
+from datetime import datetime, time, timedelta
+from pathlib import Path
+from typing import Dict, List
 
 import appdaemon.utils as utils
-import astral
+import yaml
 from appdaemon.entity import Entity
 from appdaemon.plugins.hass.hassapi import Hass
 from appdaemon.plugins.mqtt.mqttapi import Mqtt
+from astral import SunDirection
+
+
+def str_to_timedelta(input_str: str) -> timedelta:
+    try:
+        hours, minutes, seconds = map(int, input_str.split(':'))
+        return timedelta(hours=hours, minutes=minutes, seconds=seconds)
+    except Exception:
+        return timedelta()
+
+@dataclass
+class RoomState:
+    scene: Dict[str, Dict[str, str | int]]
+    off_duration: timedelta = None
+    time: time = None
+    time_fmt: List[str] = field(default_factory=lambda : ['%H:%M:%S', '%I:%M:%S %p'], repr=False)
+    elevation: int | float = None
+    direction: SunDirection = None
+
+    def __post_init__(self):
+        if isinstance(self.time, str):
+            for fmt in self.time_fmt:
+                try:
+                    self.time = datetime.strptime(self.time, fmt).time()
+                except:
+                    continue
+                else:
+                    break
+        
+        if self.elevation is not None:
+            assert self.direction is not None, f'Elevation setting requires a direction'
+            if self.direction.lower() == 'setting':
+                self.direction = SunDirection.SETTING
+            elif self.direction.lower() == 'rising':
+                self.direction = SunDirection.RISING
+            else:
+                raise ValueError(f'Invalid sun direction: {self.direction}')
+
+            if isinstance(self.elevation, str):
+                self.elevation = float(self.elevation)
+
+        if isinstance(self.off_duration, str):
+            self.off_duration = str_to_timedelta(self.off_duration)
+
+    @classmethod
+    def from_json(cls, json_input):
+        return cls(**json_input)
+
+
+@dataclass
+class RoomConfig:
+    states: List[RoomState]
+    off_duration: timedelta = None
+
+    def __post_init__(self):
+        if isinstance(self.off_duration, str):
+            self.off_duration = str_to_timedelta(self.off_duration)
+
+    @classmethod
+    def from_app_config(cls, app_cfg: Dict[str, Dict]):
+        if 'off_duration' in app_cfg:
+            kwargs = {'off_duration': app_cfg['off_duration']}
+        else:
+            kwargs = {}
+
+        self = cls(
+            states=[RoomState.from_json(s) for s in app_cfg['states']],
+            **kwargs
+        )
+
+        return self
+    
+    @classmethod
+    def from_yaml(cls, yaml_path: Path, app_name: str):
+        with yaml_path.open('r') as f:
+            cfg: Dict = yaml.load(f, Loader=yaml.SafeLoader)[app_name]
+        return cls.from_app_config(cfg)
+    
+    def sort_states(self):
+        """Should only be called after all the times have been resolved
+        """
+        assert all(isinstance(state.time, time) for state in self.states), 'Times have not all been resolved yet'
+        self.states = sorted(self.states, key=lambda s: s.time, reverse=True)
+
+    def current_state(self, now: time) -> RoomState:
+        time_fmt = "%I:%M:%S %p"
+        print(now.strftime(time_fmt))
+
+        self.sort_states()
+        for state in self.states:
+            if state.time <= now:
+                return state
+        else:
+            # self.log(f'Defaulting to first state')
+            return self.states[0]
+    
+    def current_scene(self, now: time) -> Dict:
+        state = self.current_state(now)
+        return state.scene
+
+    def current_off_duration(self, now: time) -> timedelta:
+        state = self.current_state(now)
+        if state.off_duration is None:
+            if self.off_duration is None:
+                raise ValueError(f'Need an off duration')
+            else:
+                return self.off_duration
+        else:
+            return state.off_duration
 
 
 class RoomController(Hass, Mqtt):
@@ -20,16 +130,21 @@ class RoomController(Hass, Mqtt):
     - When the light comes on, check if it's attributes match what they should, given the time.
     """
 
+    @property
+    def states(self) -> List[RoomState]:
+        return self._room_config.states
+    
+    @states.setter
+    def states(self, new: List[RoomState]):
+        assert all(isinstance(s, RoomState) for s in new), f'Invalid: {new}'
+        self._room_config.states = new
+
     async def initialize(self):
         self.app_entities = await self.gather_app_entities()
-        self.log(f'entities: {self.app_entities}')
+        # self.log(f'entities: {self.app_entities}')
         await self.refresh_state_times()
         await self.run_daily(callback=self.refresh_state_times, start='00:00:00')
 
-        # if (ha_button := self.args.get('ha_button')):
-        #     self.log(f'Setting up input button: {self.friendly_name(ha_button)}')
-        #     self.listen_state(callback=self.activate_any_on, entity_id=ha_button)
-
     async def gather_app_entities(self) -> List[str]:
         """Returns a list of all the entities involved in any of the states
         """
@@ -55,90 +170,90 @@ class RoomController(Hass, Mqtt):
     async def refresh_state_times(self, *args, **kwargs):
         """Resets the `self.states` attribute to a newly parsed version of the states.
 
-        Parsed states have an absolute time for a certain day. 
+        Parsed states have an absolute time for the current day. 
         """
         # re-parse the state strings into times for the current day
-        self.states = await self.parse_states()
+        self._room_config = RoomConfig.from_app_config(self.args)
+        self.log(f'{len(self._room_config.states)} states in the RoomConfig')
+
+        for state in self._room_config.states:
+            if state.time is None and state.elevation is not None:
+                state.time = self.AD.sched.location.time_at_elevation(
+                        elevation=state.elevation,
+                        direction=state.direction
+                    ).time()
+            elif isinstance(state.time, str):
+                state.time = await self.parse_time(state.time)
+
+            assert isinstance(state.time, time), f'Invalid time: {state.time}'
+        
+        for state in self.states:
+            self.log(f'State: {state.time.strftime("%I:%M:%S %p")} {state.scene}')
+
+        self.states = sorted(self.states, key=lambda s: s.time, reverse=True)
 
         # schedule the transitions
-        for state in self.states:
+        for state in self.states[::-1]:
-            dt = str(state['time'])[:8]
+            # t: time = state['time']
-            self.log(f'Scheduling transition at: {dt}')
+            t: time = state.time
             try:
-                await self.run_at(callback=self.activate_any_on, start=dt)
+                await self.run_at(
+                    callback=self.activate_any_on,
+                    start=t.strftime('%H:%M:%S'),
+                    cause='scheduled transition'
+                )
             except ValueError:
                 # happens when the callback time is in the past
                 pass
             except Exception as e:
                 self.log(f'Failed with {type(e)}: {e}')
 
-    async def parse_states(self):
+    async def current_state(self, now: time = None) -> RoomState:
-        async def gen():
+        if (await self.sleep_bool()):
-            for state in deepcopy(self.args['states']):
+            self.log(f'sleep: active')
-                if (time := state.get('time')):
+            if (state := self.args.get('sleep_state')):
-                    state['time'] = await self.parse_time(time)
+                return RoomState.from_json(state)
+            else:
+                return RoomState(scene={})
+        else:
+            now = now or (await self.get_now()).time()
+            self.log(f'Getting state for {now}', level='DEBUG')
 
-                elif isinstance((elevation := state.get('elevation')), (int, float)):
+            state = self._room_config.current_state(now)
-                    assert 'direction' in state, f'State needs a direction if it has an elevation'
+            self.log(f'Current state: {state}', level='DEBUG')
 
-                    if state['direction'] == 'rising':
+            return state
-                        dir = astral.SunDirection.RISING
-                    elif state['direction'] == 'setting':
-                        dir = astral.SunDirection.SETTING
-                    else:
-                        raise ValueError(f'Invalid sun direction: {state["direction"]}')
 
-                    state['time'] = self.AD.sched.location.time_at_elevation(
+    async def current_scene(self, now: time = None) -> Dict[str, Dict[str, str | int]]:
-                        elevation=elevation, direction=dir
+        state = await self.current_state(now)
-                    ).time()
+        assert isinstance(state, RoomState)
+        self.log(f'Current scene: {state}')
+        return state.scene
 
-                else:
+    async def app_entity_states(self) -> Dict[str, str]:
-                    raise ValueError(f'Missing time')
+        states = {
-
+            entity: (await self.get_state(entity))
-                yield state
+            for entity in self.app_entities
-
+        }
-        states = [s async for s in gen()]
-        states = sorted(states, key=lambda s: s['time'])
         return states
 
-    async def current_state(self, time: time = None):
+    async def all_off(self) -> bool:
-        if (await self.sleep_bool()):
-            if (state := self.args.get('sleep_state')):
-                return state
-            else:
-                return {}
-        else:
-            now = await self.get_now()
-            self.log(f'Getting state for datetime: {now}')
-            time = time or (await self.get_now()).time()
-            for state in self.states[::-1]:
-                if state['time'] <= time:
-                    self.log(f'Selected state from {state["time"]}')
-                    return state
-            else:
-                return self.states[-1]
-
-    async def current_scene(self, time: time = None):
-        if (state := (await self.current_state(time=time))) is not None:
-            return state['scene']
-
-    @property
-    def all_off(self) -> bool:
         """"All off" is the logic opposite of "any on"
 
         Returns:
             bool: Whether all the lights associated with the app are off
         """
-        return all(self.get_state(entity) != 'on' for entity in self.app_entities)
+        states = await self.app_entity_states()
+        return all(state != 'on' for entity, state in states.items())
 
-    @property
+    async def any_on(self) -> bool:
-    def any_on(self) -> bool:
         """"Any on" is the logic opposite of "all off"
 
         Returns:
             bool: Whether any of the lights associated with the app are on
         """
-        return any(self.get_state(entity) == 'on' for entity in self.app_entities)
+        states = await self.app_entity_states()
+        return any(state == 'on' for entity, state in states.items())
 
     async def sleep_bool(self) -> bool:
         if (sleep_var := self.args.get('sleep')):
@@ -156,7 +271,7 @@ class RoomController(Hass, Mqtt):
     #     else:
     #         raise ValueError('Sleep variable is undefined')
 
-    async def off_duration(self) -> timedelta:
+    async def off_duration(self, now: time = None) -> timedelta:
         """Determines the time that the motion sensor has to be clear before deactivating
 
         Priority:
@@ -166,19 +281,21 @@ class RoomController(Hass, Mqtt):
             - Sleep - 0
 
         """
-        current_state = await self.current_state()
+        sleep_mode_active = await self.sleep_bool()
-        duration_str = current_state.get(
+        if sleep_mode_active:
-            'off_duration',
+            self.log(f'Sleeping mode active: {sleep_mode_active}')
-            self.args.get('off_duration', '00:00:00')
-        )
-
-        try:
-            hours, minutes, seconds = map(int, duration_str.split(':'))
-            return timedelta(hours=hours, minutes=minutes, seconds=seconds)
-        except Exception:
             return timedelta()
+        else:
+            now = now or (await self.get_now()).time()
+            return self._room_config.current_off_duration(now)
+
+    @utils.sync_wrapper
+    async def activate(self, entity = None, attribute = None, old = None, new = None, kwargs = None):
+        if kwargs is not None:
+            cause = kwargs.get('cause', 'unknown')
+        else:
+            cause = 'unknown'
             
-    async def activate(self, *args, cause: str = 'unknown', **kwargs):
         self.log(f'Activating: {cause}')
         scene = await self.current_scene()
 
@@ -202,26 +319,27 @@ class RoomController(Hass, Mqtt):
         else:
             self.log(f'ERROR: unknown scene: {scene}')
 
+    @utils.sync_wrapper
     async def activate_all_off(self, *args, **kwargs):
-        """Activate if all of the entities are off
+        """Activate if all of the entities are off. Args and kwargs are passed directly to self.activate()
         """
-        if self.all_off:
+        if (await self.all_off()):
-            self.log(f'Activate all off kwargs: {kwargs}')
+            self.activate(*args, **kwargs)
-            await self.activate(*args, **kwargs)
         else:
             self.log(f'Skipped activating - everything is not off')
 
+    @utils.sync_wrapper
     async def activate_any_on(self, *args, **kwargs):
-        """Activate if any of the entities are on
+        """Activate if any of the entities are on. Args and kwargs are passed directly to self.activate()
         """
-        if self.any_on:
+        if (await self.any_on()):
-            await self.activate(*args, **kwargs)
+            self.activate(*args, **kwargs)
         else:
             self.log(f'Skipped activating - everything is off')
 
-    def deactivate(self, *args, cause: str = 'unknown', **kwargs):
+    def deactivate(self, entity = None, attribute = None, old = None, new = None, kwargs = None):
+        cause = kwargs.get('cause', 'unknown')
         self.log(f'Deactivating: {cause}')
-        for entity in self.app_entities:
+        for e in self.app_entities:
-            self.turn_off(entity)
+            self.turn_off(e)
-            self.log(f'Turned off {entity}')
+            self.log(f'Turned off {e}')
-