def _attr_updated(self, name, value):
super()._attr_updated(name, value)
# this will allow other people to listen to this event too
event = NameClientAttributeUpdated(self, name, value)
events.notify(event)
# reset client
self.__client = None
def _created(self, instance):
"""
called when an instance is created, will trigger `InstanceCreateEvent`
Args:
instance (Base)
"""
event = InstanceCreateEvent(instance=instance, factory=self)
events.notify(event)
def _deleted(self, name):
"""
called when an instance is deleted, will trigger `InstanceDeleteEvent`
Args:
name (name)
"""
event = InstanceDeleteEvent(name, factory=self)
events.notify(event)
def _attr_updated(self, name, value):
"""
called when an attribute value is updated
Args:
name (str): attribute/field name
value (any): value
"""
event = AttributeUpdateEvent(self, name, value)
events.notify(event)
def test_notify_handle_decorators(self):
notified = defaultdict(list)
@events.handle_any
def events_hunger_thirst_logger(ev):
m = ev.msg()
notified[ev.__class__].append(events_hunger_thirst_logger)
print(f"logging from any{m}")
@events.handle(UserHungryEvent)
def handle_hungry(ev):
m = ev.msg()
notified[ev.__class__].append(handle_hungry)
print(f"handling event with msg: {m}")
@events.handle(UserThirstyEvent)
def handle_thirsty(ev):
m = ev.msg()
notified[ev.__class__].append(handle_thirsty)
print(f"handling thirst with water :d ev with msg: {m}")
@events.handle_many(UserThirstyEvent, UserHungryEvent)
def handle_both(ev):
notified[ev.__class__].append(handle_both)
ev1 = UserHungryEvent("ahmed")
ev2 = UserThirstyEvent("dmdm")
events.notify(ev1)
events.notify(ev2)
# handler for any event
for key, value in notified.items():
self.assertIn(events_hunger_thirst_logger, value)
# handles for 1 event
self.assertIn(handle_hungry, notified.get(UserHungryEvent, []))
self.assertIn(handle_thirsty, notified.get(UserThirstyEvent, []))
# handler for multiple events
self.assertIn(handle_both, notified.get(UserHungryEvent, []))
self.assertIn(handle_both, notified.get(UserThirstyEvent, []))
def test_notify_handler(self):
notified = defaultdict(list)
class TestHandler(events.Handler):
def handle(self, ev):
notified[ev.__class__].append(self)
if isinstance(ev, (UserHungryEvent, UserThirstyEvent)):
print("logging from an event handler object, ", ev.msg())
handler = TestHandler()
events.add_listenter(handler, UserHungryEvent)
events.add_global_listener(handler)
ev1 = UserHungryEvent("ahmed")
ev2 = UserThirstyEvent("dmdm")
events.notify(ev1)
events.notify(ev2)
# single event
self.assertIn(handler, notified.get(UserHungryEvent, []))
# handler should be found for the other event too (any)
self.assertIn(handler, notified.get(UserThirstyEvent, []))
def _created(self, instance):
event = InstanceCreateEvent(instance=instance, factory=self)
events.notify(event)
def _deleted(self, name):
event = InstanceDeleteEvent(name, factory=self)
events.notify(event)
def _attr_updated(self, name, value):
event = AttributeUpdateEvent(self, name, value)
events.notify(event)
