class Manager(object):
""" Event manager."""
def __init__(self):
axes = (("event_type", TypeAxis()), )
self.registry = Registry(*axes)
def subscribe(self, handler, event_type):
""" Subscribe ``handler`` to specified ``event_type``."""
handler_set = self.registry.get_registration(event_type)
if not handler_set:
handler_set = self._register_handler_set(event_type)
handler_set.handlers.add(handler)
def unsubscribe(self, handler, event_type):
""" Unsubscribe ``handler`` from ``event_type``."""
handler_set = self.registry.get_registration(event_type)
if handler_set and handler in handler_set.handlers:
handler_set.handlers.remove(handler)
def fire(self, event):
""" Fire event instance."""
handler_set = self.registry.lookup(event)
for handler in handler_set.all_handlers:
handler(event)
def _register_handler_set(self, event_type):
""" Register new handler set for ``event_type``."""
# Collect handler sets for supertypes
parent_handler_sets = []
parents = event_type.__bases__
for parent in parents:
parent_handlers = self.registry.get_registration(parent)
if parent_handlers is None:
parent_handlers = self._register_handler_set(parent)
parent_handler_sets.append(parent_handlers)
handler_set = HandlerSet(parents=parent_handler_sets, handlers=set())
self.registry.register(handler_set, event_type)
return handler_set
def subscriber(self, event_type):
""" Decorator for subscribing decorated functions.
Works like this:
>>> @mymanager.subscriber(MyEvent)
... def mysubscriber(evt):
... # handle event
... return
>>> mymanager.fire(MyEvent())
"""
def registrator(func):
self.subscribe(func, event_type)
return func
return registrator
class Manager(object):
""" Event manager."""
def __init__(self):
axes = (("event_type", TypeAxis()),)
self.registry = Registry(*axes)
def subscribe(self, handler, event_type):
""" Subscribe ``handler`` to specified ``event_type``."""
handler_set = self.registry.get_registration(event_type)
if not handler_set:
handler_set = self._register_handler_set(event_type)
handler_set.handlers.add(handler)
def unsubscribe(self, handler, event_type):
""" Unsubscribe ``handler`` from ``event_type``."""
handler_set = self.registry.get_registration(event_type)
if handler_set and handler in handler_set.handlers:
handler_set.handlers.remove(handler)
def fire(self, event):
""" Fire event instance."""
handler_set = self.registry.lookup(event)
for handler in handler_set.all_handlers:
handler(event)
def _register_handler_set(self, event_type):
""" Register new handler set for ``event_type``."""
# Collect handler sets for supertypes
parent_handler_sets = []
parents = event_type.__bases__
for parent in parents:
parent_handlers = self.registry.get_registration(parent)
if parent_handlers is None:
parent_handlers = self._register_handler_set(parent)
parent_handler_sets.append(parent_handlers)
handler_set = HandlerSet(parents=parent_handler_sets, handlers=set())
self.registry.register(handler_set, event_type)
return handler_set
def subscriber(self, event_type):
""" Decorator for subscribing decorated functions.
Works like this:
>>> @mymanager.subscriber(MyEvent)
... def mysubscriber(evt):
... # handle event
... return
>>> mymanager.fire(MyEvent())
"""
def registrator(func):
self.subscribe(func, event_type)
return func
return registrator
def test_get_registration(self):
from generic.registry import Registry
from generic.registry import SimpleAxis
from generic.registry import TypeAxis
registry = Registry(('type', TypeAxis()), ('name', SimpleAxis()))
registry.register('one', object)
registry.register('two', DummyA, 'foo')
self.assertEqual(registry.get_registration(object), 'one')
self.assertEqual(registry.get_registration(DummyA, 'foo'), 'two')
self.assertEqual(registry.get_registration(object, 'foo'), None)
self.assertEqual(registry.get_registration(DummyA), None)
def test_get_registration(self):
from generic.registry import Registry
from generic.registry import SimpleAxis
from generic.registry import TypeAxis
registry = Registry(('type', TypeAxis()),
('name', SimpleAxis()))
registry.register('one', object)
registry.register('two', DummyA, 'foo')
self.assertEqual(registry.get_registration(object), 'one')
self.assertEqual(registry.get_registration(DummyA, 'foo'), 'two')
self.assertEqual(registry.get_registration(object, 'foo'), None)
self.assertEqual(registry.get_registration(DummyA), None)
class Manager(object):
""" Event manager
Provides API for subscribing for and firing events. There's also global
event manager instantiated at module level with functions
:func:`.subscribe`, :func:`.fire` and decorator :func:`.subscriber` aliased
to corresponding methods of class.
"""
def __init__(self):
axes = (("event_type", TypeAxis()),)
self.registry = Registry(*axes)
def subscribe(self, handler, event_type):
""" Subscribe ``handler`` to specified ``event_type``"""
handler_set = self.registry.get_registration(event_type)
if not handler_set:
handler_set = self._register_handler_set(event_type)
handler_set.handlers.add(handler)
def unsubscribe(self, handler, event_type):
""" Unsubscribe ``handler`` from ``event_type``"""
handler_set = self.registry.get_registration(event_type)
if handler_set and handler in handler_set.handlers:
handler_set.handlers.remove(handler)
def fire(self, event):
""" Fire ``event``
All subscribers will be executed with no determined order.
"""
handler_set = self.registry.lookup(event)
for handler in handler_set.all_handlers:
handler(event)
def _register_handler_set(self, event_type):
""" Register new handler set for ``event_type``."""
# Collect handler sets for supertypes
parent_handler_sets = []
parents = event_type.__bases__
for parent in parents:
parent_handlers = self.registry.get_registration(parent)
if parent_handlers is None:
parent_handlers = self._register_handler_set(parent)
parent_handler_sets.append(parent_handlers)
handler_set = HandlerSet(parents=parent_handler_sets, handlers=set())
self.registry.register(handler_set, event_type)
return handler_set
def subscriber(self, event_type):
""" Decorator for subscribing handlers
Works like this:
>>> @mymanager.subscriber(MyEvent)
... def mysubscriber(evt):
... # handle event
... return
>>> mymanager.fire(MyEvent())
"""
def registrator(func):
self.subscribe(func, event_type)
return func
return registrator
class Manager(object):
""" Event manager
Provides API for subscribing for and firing events. There's also global
event manager instantiated at module level with functions
:func:`.subscribe`, :func:`.fire` and decorator :func:`.subscriber` aliased
to corresponding methods of class.
"""
def __init__(self):
axes = (("event_type", TypeAxis()), )
self.registry = Registry(*axes)
def subscribe(self, handler, event_type):
""" Subscribe ``handler`` to specified ``event_type``"""
handler_set = self.registry.get_registration(event_type)
if not handler_set:
handler_set = self._register_handler_set(event_type)
handler_set.handlers.add(handler)
def unsubscribe(self, handler, event_type):
""" Unsubscribe ``handler`` from ``event_type``"""
handler_set = self.registry.get_registration(event_type)
if handler_set and handler in handler_set.handlers:
handler_set.handlers.remove(handler)
def fire(self, event):
""" Fire ``event``
All subscribers will be executed with no determined order.
"""
handler_set = self.registry.lookup(event)
for handler in handler_set.all_handlers:
handler(event)
def _register_handler_set(self, event_type):
""" Register new handler set for ``event_type``."""
# Collect handler sets for supertypes
parent_handler_sets = []
parents = event_type.__bases__
for parent in parents:
parent_handlers = self.registry.get_registration(parent)
if parent_handlers is None:
parent_handlers = self._register_handler_set(parent)
parent_handler_sets.append(parent_handlers)
handler_set = HandlerSet(parents=parent_handler_sets, handlers=set())
self.registry.register(handler_set, event_type)
return handler_set
def subscriber(self, event_type):
""" Decorator for subscribing handlers
Works like this:
>>> @mymanager.subscriber(MyEvent)
... def mysubscriber(evt):
... # handle event
... return
>>> mymanager.fire(MyEvent())
"""
def registrator(func):
self.subscribe(func, event_type)
return func
return registrator
class Manager:
""" Event manager
Provides API for subscribing for and firing events. There's also global
event manager instantiated at module level with functions
:func:`.subscribe`, :func:`.handle` and decorator :func:`.subscriber` aliased
to corresponding methods of class.
"""
registry: Registry[HandlerSet]
def __init__(self) -> None:
axes = (("event_type", TypeAxis()), )
self.registry = Registry(*axes)
def subscribe(self, handler: Handler, event_type: Type[Event]) -> None:
""" Subscribe ``handler`` to specified ``event_type``"""
handler_set = self.registry.get_registration(event_type)
if handler_set is None:
handler_set = self._register_handler_set(event_type)
handler_set.add(handler)
def unsubscribe(self, handler: Handler, event_type: Type[Event]) -> None:
""" Unsubscribe ``handler`` from ``event_type``"""
handler_set = self.registry.get_registration(event_type)
if handler_set and handler in handler_set:
handler_set.remove(handler)
def handle(self, event: Event) -> None:
""" Fire ``event``
All subscribers will be executed with no determined order.
"""
handler_sets = self.registry.query(event)
for handler_set in handler_sets:
if handler_set:
for handler in set(handler_set):
handler(event)
def _register_handler_set(self, event_type: Type[Event]) -> HandlerSet:
""" Register new handler set for ``event_type``.
"""
handler_set: HandlerSet = set()
self.registry.register(handler_set, event_type)
return handler_set
def subscriber(self,
event_type: Type[Event]) -> Callable[[Handler], Handler]:
""" Decorator for subscribing handlers
Works like this:
>>> mymanager = Manager()
>>> class MyEvent():
... pass
>>> @mymanager.subscriber(MyEvent)
... def mysubscriber(evt):
... # handle event
... return
>>> mymanager.handle(MyEvent())
"""
def registrator(func: Handler) -> Handler:
self.subscribe(func, event_type)
return func
return registrator
