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)
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