def unregister(self, event, block): """Unregister a code block from an event. :except NotEventError: Trying to unregister code blocks with something that is not an instance of :class:`Event`. :except NotCallableError: Trying to unregister something that is not a callable. :except UnknownCallableError: The callable provided was not known to the event handler. """ if not isinstance(event, Event): raise _errors.NotEventError( "Not possible to unregister with non-event") if not callable(block): raise _errors.NotCallableError( "Not possible to unregister a non-callable") _LOGGER.debug("Unregistering %s from event %s", block, event) try: self.__blocks_for[event].remove(block) if self.__blocks_for[event]: del self.__blocks_for[event] except KeyError: raise _errors.UnknownCallableError( "Not possible to unregister a non-existing block")
def is_registered(self, event, block): """Check if a callable is registered with an event. Note that the exact callable instance is checked for, so you have to pass the instance that you want to check for. :param event: Event to check if callable is registered with. :param block: Callable to look for. :type block: callable :return: ``True`` if the callable instance is registered with the event, ``False`` otherwise. :rtype: Boolean. """ if not isinstance(event, Event): raise _errors.NotEventError( "Not possible to check registration for non-event") if not callable(block): raise _errors.NotCallableError( "Not possible to check for non-callable") try: return block in self.__blocks_for[event] except KeyError: return False
def register(self, event, blocks): """Register code blocks with an event in the event handler. This method register the code blocks supplied under the event. Each code block is represented as a callable (which means either a function or a class supporting the ``__call__`` method). If the event was not previously registered, a new entry will be created for it. This involves both registering the name of the event (if it has a name) and the event instance. :param event: Event to register code blocks for. :param blocks: Callable to register for event. :type blocks: Callable or sequence of callables :except NotEventError: Trying to register code blocks with something that is not an instance of :class:`Event`. :except NotCallableError: Trying to register something that is not a callable with an event. """ if not isinstance(event, Event): raise _errors.NotEventError( "Not possible to register with non-event") if callable(blocks): blocks = [blocks] # Check that all provided blocks are callables. try: for block in blocks: if not callable(block): raise _errors.NotCallableError( "Not possible to register non-callables") except TypeError: raise _errors.NotCallableError("Expected an iterable") _LOGGER.debug("Registering blocks %s for event %s under name %s", blocks, event, event.name) # Register the name if not registered if event.name is not None and event.name not in self.__instance_for: self.__instance_for[event.name] = event # Register the callables self.__blocks_for.setdefault(event, set()).update(blocks)