john/room_control
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

dataclasses and bugfixes

Browse Source
This commit is contained in:
John Lancaster
2024-01-23 21:03:30 -06:00
parent a00f10a967
commit 9bb4df069e
4 changed files with 269 additions and 188 deletions
Download Patch File Download Diff File Expand all files Collapse all files

102
motion.py
View File

@@ -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
@@ -42,46 +26,35 @@ class Motion(Hass):
return self.ref_entity.get_state() == 'on'
def initialize(self):
try:
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.app: RoomController = 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')
self.listen_state(self.callback_light_off, self.ref_entity.entity_id, new='off')
base_kwargs = dict(
entity_id=self.ref_entity.entity_id,
immediate=True, # avoids needing to sync the state
)
# don't need to await these because they'll already get turned into a task by the utils.sync_wrapper decorator
self.listen_state(**base_kwargs, attribute='brightness', callback=self.callback_light_on)
self.listen_state(**base_kwargs, new='off', callback=self.callback_light_off)
loop.run_until_complete(self.sync_state())
async def sync_state(self):
"""Synchronizes the callbacks with the state of the light.
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):
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}')
self.motion_on_handle = await self.listen_state(
self.cancel_motion_callback()
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):
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}')
self.motion_off_handle = await self.listen_state(
self.cancel_motion_callback()
self.listen_state(
callback=self.app.deactivate,
entity_id=self.sensor.entity_id,
new='off',
@@ -89,47 +62,48 @@ class Motion(Hass):
oneshot=True,
cause='motion off'
)
self.log(f'Waiting for motion to stop on {self.sensor.friendly_name} for {duration}')
async def callback_light_on(self, entity=None, attribute=None, old=None, new=None, kwargs=None):
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')
await self.cancel_motion_callback(new='on')
await self.listen_motion_off(await self.app.off_duration())
if new is not None:
self.log(f'{entity} turned on')
duration = self.app.off_duration()
self.listen_motion_off(duration)
async def callback_light_off(self, entity=None, attribute=None, old=None, new=None, kwargs=None):
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')
await self.cancel_motion_callback(new='off')
await self.listen_motion_on()
self.log(f'{entity} turned off')
self.listen_motion_on()
async def get_app_callbacks(self, name: str = None):
def get_app_callbacks(self, name: str = None):
"""Gets all the callbacks associated with the app
"""
name = name or self.name
callbacks = {
handle: info
for app_name, callbacks in (await self.get_callback_entries()).items()
for app_name, callbacks in self.get_callback_entries().items()
for handle, info in callbacks.items()
if app_name == name
}
return callbacks
async def get_sensor_callbacks(self):
def get_sensor_callbacks(self):
return {
handle: info
for handle, info in (await self.get_app_callbacks()).items()
for handle, info in self.get_app_callbacks().items()
if info['entity'] == self.sensor.entity_id
}
async def cancel_motion_callback(self, new: str):
callbacks = await self.get_sensor_callbacks()
# self.log(f'Found {len(callbacks)}')
def cancel_motion_callback(self):
callbacks = self.get_sensor_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'])
# self.log(f'{handle}: {info["entity"]}: {info["kwargs"]}')
if new_match is not None and new_match.group("new") == new:
await self.cancel_listen_state(handle)
self.log(f'cancelled: {await self.friendly_name(entity)}: {new}')
kwargs = info['kwargs']
if (m := re.match('new=(?P<new>.*?)\s', kwargs)) is not None:
new = m.group('new')
self.cancel_listen_state(handle)
self.log(f'cancelled callback for sensor {entity} turning {new}')