def check(self, now):
if self.is_canceled:
return None
try:
item = Items.get_item(self.name)
except Items.ItemNotFoundException:
return None
timestamp = item._last_change if self.__watch_only_changes else item._last_update
duration = now - timestamp
if duration < self.duration_const:
self.executed = False
return None
if self.executed:
return None
EventBus.post_event(
self.name,
(ValueNoChangeEvent if self.__watch_only_changes else ValueNoUpdateEvent)(
self.name, item.value, int(duration.total_seconds())
)
)
self.executed = True
def on_sse_event(event_dict: dict):
try:
# Lookup corresponding OpenHAB event
event = get_event(event_dict)
# Update item in registry BEFORE posting to the event bus
# so the items have the correct state when we process the event in a rule
try:
if isinstance(event, ValueUpdateEvent):
__item = Items.get_item(
event.name
) # type: HABApp.core.items.base_item.BaseValueItem
__item.set_value(event.value)
EventBus.post_event(event.name, event)
return None
if isinstance(event, ThingStatusInfoEvent):
__thing = Items.get_item(
event.name) # type: HABApp.openhab.items.Thing
__thing.process_event(event)
EventBus.post_event(event.name, event)
return None
# Workaround because there is no GroupItemStateEvent
if isinstance(event, GroupItemStateChangedEvent):
__item = Items.get_item(
event.name) # type: HABApp.openhab.items.GroupItem
__item.set_value(event.value)
EventBus.post_event(event.name, event)
return None
except ItemNotFoundException:
log_warning(
log,
f'Received {event.__class__.__name__} for {event.name} but item does not exist!'
)
# Post the event anyway
EventBus.post_event(event.name, event)
return None
if isinstance(event, ItemRemovedEvent):
remove_from_registry(event.name)
EventBus.post_event(event.name, event)
return None
# These events require that we query openhab because of the metadata so we have to do it in a task
# They also change the item registry
if isinstance(event, (ItemAddedEvent, ItemUpdatedEvent)):
create_task(item_event(event))
return None
HABApp.core.EventBus.post_event(event.name, event)
except Exception as e:
process_exception(func=on_sse_event, e=e)
return None
def test_event_bus(self):
listener = EventBusListener(
'test', wrappedfunction.WrappedFunction(self.event_cb))
EventBus.add_listener(listener)
self.assertIs(self.last_event, None)
for _ in range(10):
event = TestEvent
EventBus.post_event('test', event)
self.assertIs(self.last_event, event)
EventBus.remove_listener(listener)
def test_str_event(clean_event_bus: EventBus, sync_worker):
event_history = []
def append_event(event):
event_history.append(event)
func = wrappedfunction.WrappedFunction(append_event)
listener = EventBusListener('str_test', func)
EventBus.add_listener(listener)
EventBus.post_event('str_test', 'str_event')
assert event_history == ['str_event']
def test_str_event(event_bus: EventBus):
event_history = []
def set(event):
event_history.append(event)
listener = EventBusListener('str_test',
wrappedfunction.WrappedFunction(set))
EventBus.add_listener(listener)
with SyncWorker():
EventBus.post_event('str_test', 'str_event')
assert event_history == ['str_event']
def test_event_filter(clean_event_bus: EventBus, sync_worker):
events_all, events_filtered1, events_filtered2 , events_filtered3 = [], [], [], []
def append_all(event):
events_all.append(event)
def append_filter1(event):
events_filtered1.append(event)
def append_filter2(event):
events_filtered2.append(event)
def append_filter3(event):
events_filtered3.append(event)
name = 'test_filter'
func1 = wrappedfunction.WrappedFunction(append_filter1)
func2 = wrappedfunction.WrappedFunction(append_filter2)
func3 = wrappedfunction.WrappedFunction(append_filter3)
# listener to all events
EventBus.add_listener(
EventBusListener(name, wrappedfunction.WrappedFunction(append_all)))
listener = EventBusListener(name, func1, ValueUpdateEvent, 'value',
'test_value')
EventBus.add_listener(listener)
listener = EventBusListener(name, func2, ValueUpdateEvent, None, None,
'value', 1)
EventBus.add_listener(listener)
listener = EventBusListener(name, func3, ValueChangeEvent, 'old_value',
None, 'value', 1)
EventBus.add_listener(listener)
event0 = ValueUpdateEvent(name, None)
event1 = ValueUpdateEvent(name, 'test_value')
event2 = ValueUpdateEvent(name, 1)
event3 = ValueChangeEvent(name, 1, None)
EventBus.post_event(name, event0)
EventBus.post_event(name, event1)
EventBus.post_event(name, event2)
EventBus.post_event(name, event3)
assert len(events_all) == 4
assert vars(events_all[0]) == vars(event0)
assert vars(events_all[1]) == vars(event1)
assert vars(events_all[2]) == vars(event2)
assert vars(events_all[3]) == vars(event3)
assert len(events_filtered1) == 1
assert vars(events_filtered1[0]) == vars(event1)
assert len(events_filtered2) == 1
assert vars(events_filtered2[0]) == vars(event2)
assert len(events_filtered3) == 1
assert vars(events_filtered3[0]) == vars(event3)
def test_multiple_events(event_bus: EventBus):
event_history = []
target = ['str_event', TestEvent(), 'str_event2']
def set(event):
event_history.append(event)
listener = EventBusListener('test', wrappedfunction.WrappedFunction(set),
(str, TestEvent))
EventBus.add_listener(listener)
with SyncWorker():
for k in target:
EventBus.post_event('test', k)
assert event_history == target
def test_multiple_events(clean_event_bus: EventBus, sync_worker):
event_history = []
target = ['str_event', TestEvent(), 'str_event2']
def append_event(event):
event_history.append(event)
listener = EventBusListener('test',
wrappedfunction.WrappedFunction(append_event),
(str, TestEvent))
EventBus.add_listener(listener)
for k in target:
EventBus.post_event('test', k)
assert event_history == target