Develop a Custom Alerter

Learning how to develop a custom alerter.

Before diving into the specifics of this component type, it is beneficial to familiarize yourself with our general guide to writing custom component flavors in ZenML. This guide provides an essential understanding of ZenML's component flavor concepts.

Base Abstraction

The base abstraction for alerters is very basic, as it only defines two abstract methods that subclasses should implement:

  • post() takes a string, posts it to the desired chat service, and returns True if the operation succeeded, else False.

  • ask() does the same as post(), but after sending the message, it waits until someone approves or rejects the operation from within the chat service (e.g., by sending "approve" / "reject" to the bot as a response). ask() then only returns True if the operation succeeded and was approved, else False.

Then base abstraction looks something like this:

class BaseAlerter(StackComponent, ABC):
    """Base class for all ZenML alerters."""

    def post(
            self, message: str, params: Optional[BaseAlerterStepParameters]
    ) -> bool:
        """Post a message to a chat service."""
        return True

    def ask(
            self, question: str, params: Optional[BaseAlerterStepParameters]
    ) -> bool:
        """Post a message to a chat service and wait for approval."""
        return True

This is a slimmed-down version of the base implementation. To see the full docstrings and imports, please check the source code on GitHub.

Building your own custom alerter

Creating your own custom alerter can be done in three steps:

  1. Create a class that inherits from the BaseAlerter and implement the post() and ask() methods.

    from typing import Optional
    
    from zenml.alerter import BaseAlerter, BaseAlerterStepParameters
    
    
    class MyAlerter(BaseAlerter):
        """My alerter class."""
    
        def post(
            self, message: str, config: Optional[BaseAlerterStepParameters]
        ) -> bool:
            """Post a message to a chat service."""
            ...
            return "Hey, I implemented an alerter."
    
        def ask(
            self, question: str, config: Optional[BaseAlerterStepParameters]
        ) -> bool:
            """Post a message to a chat service and wait for approval."""
            ...
            return True
  2. If you need to configure your custom alerter, you can also implement a config object.

    from zenml.alerter.base_alerter import BaseAlerterConfig
    
    
    class MyAlerterConfig(BaseAlerterConfig):
        my_param: str 
  3. Finally, you can bring the implementation and the configuration together in a new flavor object.

    from typing import Type, TYPE_CHECKING
    
    from zenml.alerter import BaseAlerterFlavor
    
    if TYPE_CHECKING:
        from zenml.stack import StackComponent, StackComponentConfig
    
    
    class MyAlerterFlavor(BaseAlerterFlavor):
        @property
        def name(self) -> str:
            return "my_alerter"
    
        @property
        def config_class(self) -> Type[StackComponentConfig]:
            from my_alerter_config import MyAlerterConfig
    
            return MyAlerterConfig
    
        @property
        def implementation_class(self) -> Type[StackComponent]:
            from my_alerter import MyAlerter
    
            return MyAlerter
    

Once you are done with the implementation, you can register your new flavor through the CLI. Please ensure you point to the flavor class via dot notation:

zenml alerter flavor register <path.to.MyAlerterFlavor>

For example, if your flavor class MyAlerterFlavor is defined in flavors/my_flavor.py, you'd register it by doing:

zenml alerter flavor register flavors.my_flavor.MyAlerterFlavor

Afterward, you should see the new custom alerter flavor in the list of available alerter flavors:

zenml alerter flavor list
ZenML Scarf

Last updated

Was this helpful?