mlrun 1.7.2rc4__py3-none-any.whl → 1.8.0__py3-none-any.whl

mlrun/utils/logger.py

@@ -11,9 +11,12 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
+import contextvars
+import datetime
 import logging
 import os
+import string
+import sys
 import typing
 from enum import Enum
 from functools import cached_property
@@ -22,15 +25,18 @@ from traceback import format_exception
 from typing import IO, Optional, Union
 
 import orjson
-import pydantic
+import pydantic.v1
 
+from mlrun import errors
 from mlrun.config import config
 
+context_id_var = contextvars.ContextVar("context_id", default=None)
+
 
 class _BaseFormatter(logging.Formatter):
     def _json_dump(self, json_object):
         def default(obj):
-            if isinstance(obj, pydantic.BaseModel):
+            if isinstance(obj, pydantic.v1.BaseModel):
                 return obj.dict()
 
             # EAFP all the way.
@@ -50,16 +56,24 @@ class _BaseFormatter(logging.Formatter):
             json_object,
             option=orjson.OPT_NAIVE_UTC
             | orjson.OPT_SERIALIZE_NUMPY
+            | orjson.OPT_NON_STR_KEYS
             | orjson.OPT_SORT_KEYS,
             default=default,
         ).decode()
 
-
-class JSONFormatter(_BaseFormatter):
-    def format(self, record) -> str:
+    def _record_with(self, record):
         record_with = getattr(record, "with", {})
         if record.exc_info:
             record_with.update(exc_info=format_exception(*record.exc_info))
+        if "ctx" not in record_with:
+            if (ctx_id := context_id_var.get()) is not None:
+                record_with["ctx"] = ctx_id
+        return record_with
+
+
+class JSONFormatter(_BaseFormatter):
+    def format(self, record) -> str:
+        record_with = self._record_with(record)
         record_fields = {
             "datetime": self.formatTime(record, self.datefmt),
             "level": record.levelname.lower(),
@@ -86,11 +100,97 @@ class HumanReadableFormatter(_BaseFormatter):
         more = f": {record_with_encoded}" if record_with_encoded else ""
         return more
 
-    def _record_with(self, record):
-        record_with = getattr(record, "with", {})
-        if record.exc_info:
-            record_with.update(exc_info=format_exception(*record.exc_info))
-        return record_with
+
+class CustomFormatter(HumanReadableFormatter):
+    """
+    To enable custom logger formatter, configure MLRun with the following env variables:
+    1. "MLRUN_LOG_FORMATTER" = "custom" - change the default log formatter.
+    2. "MLRUN_LOG_FORMAT_OVERRIDE" = "> {timestamp} [{level}] Running module: {module} {message} {more}" - logger format
+        * Note that your custom format must include those 4 fields - timestamp, level, message and more
+    If the custom format is not configured properly , MLRun will use the default logger (human format).
+    """
+
+    # This attribute is used to solve an issue
+    # that causes the warning to be written numerous times(for any log generation).
+    # We want to print the errors just once, not for each logger generation.
+    fail_on_format_configuration = False  # for issues that relates to unrecognized keys
+    fail_on_missing_default_keys_key = (
+        False  # for issues that relates to missing default keys
+    )
+
+    def format(self, record) -> str:
+        more = self._resolve_more(record)
+        custom_format = config.log_format_override
+        _custom_format = None
+        current_time = datetime.datetime.now()
+        formatted_time = current_time.strftime("%Y-%m-%d %H:%M:%S,%f")[:-3]
+        try:
+            if custom_format:
+                default_keys = ["timestamp", "level", "message", "more"]
+                formatter = string.Formatter()
+                custom_format_keys = [
+                    key
+                    for _, key, _, _ in formatter.parse(custom_format)
+                    if key is not None
+                ]
+                missing_default_flags = list(
+                    set(default_keys) - set(custom_format_keys)
+                )
+
+                if (
+                    missing_default_flags
+                    and not CustomFormatter.fail_on_missing_default_keys_key
+                ):
+                    print(
+                        f'> {formatted_time} [warning] Custom loggers must '
+                        f'include those keys within the logger format, {", ".join(default_keys)} '
+                        f'your format is missing: {", ".join(missing_default_flags)}',
+                        file=sys.stderr,
+                    )
+                    CustomFormatter.fail_on_missing_default_keys_key = True
+                record_dict = record.__dict__
+                missing_format_configuraiton_keys = list(
+                    set(custom_format_keys)
+                    - set(default_keys)
+                    - set(record_dict.keys())
+                )
+                if missing_format_configuraiton_keys:
+                    if not CustomFormatter.fail_on_format_configuration:
+                        print(
+                            f"> {formatted_time} [warning] Failed to create custom logger due "
+                            f'to missing format key in the log record: {", ".join(missing_format_configuraiton_keys)}',
+                            file=sys.stderr,
+                        )
+                        CustomFormatter.fail_on_format_configuration = True
+                    _format = (
+                        f"> {self.formatTime(record, self.datefmt)} "
+                        f"[{record.levelname.lower()}] "
+                        f"{record.getMessage().rstrip()}"
+                        f"{more}"
+                    )
+                _custom_format = custom_format.format(
+                    timestamp=self.formatTime(record, self.datefmt),
+                    level=record.levelname.lower(),
+                    message=record.getMessage().rstrip(),
+                    more=more or "",
+                    **record_dict,
+                )
+                CustomFormatter.fail_on_format_configuration = True
+        except Exception as e:
+            if not CustomFormatter.fail_on_format_configuration:
+                print(
+                    f"> {formatted_time} [warning] Failed to create custom logger, "
+                    f"see Exception: {errors.err_to_str(e)}",
+                    file=sys.stderr,
+                )
+                CustomFormatter.fail_on_format_configuration = True
+        _format = _custom_format or (
+            f"> {self.formatTime(record, self.datefmt)} "
+            f"[{record.levelname.lower()}] "
+            f"{record.getMessage().rstrip()}"
+            f"{more}"
+        )
+        return _format
 
 
 class HumanReadableExtendedFormatter(HumanReadableFormatter):
@@ -258,7 +358,6 @@ class Logger:
         self, level, message, *args, exc_info=None, **kw_args
     ):
         kw_args.update(self._bound_variables)
-
         if kw_args:
             self._logger.log(
                 level, message, *args, exc_info=exc_info, extra={"with": kw_args}
@@ -272,17 +371,24 @@ class FormatterKinds(Enum):
     HUMAN = "human"
     HUMAN_EXTENDED = "human_extended"
     JSON = "json"
+    CUSTOM = "custom"
 
 
 def resolve_formatter_by_kind(
     formatter_kind: FormatterKinds,
 ) -> type[
-    typing.Union[HumanReadableFormatter, HumanReadableExtendedFormatter, JSONFormatter]
+    typing.Union[
+        HumanReadableFormatter,
+        HumanReadableExtendedFormatter,
+        JSONFormatter,
+        CustomFormatter,
+    ]
 ]:
     return {
         FormatterKinds.HUMAN: HumanReadableFormatter,
         FormatterKinds.HUMAN_EXTENDED: HumanReadableExtendedFormatter,
         FormatterKinds.JSON: JSONFormatter,
+        FormatterKinds.CUSTOM: CustomFormatter,
     }[formatter_kind]
 
 

mlrun/utils/notifications/notification/__init__.py

@@ -14,30 +14,32 @@
 
 import enum
 
-from mlrun.common.schemas.notification import NotificationKind
-
-from .base import NotificationBase
-from .console import ConsoleNotification
-from .git import GitNotification
-from .ipython import IPythonNotification
-from .slack import SlackNotification
-from .webhook import WebhookNotification
+import mlrun.common.schemas.notification as notifications
+import mlrun.utils.notifications.notification.base as base
+import mlrun.utils.notifications.notification.console as console
+import mlrun.utils.notifications.notification.git as git
+import mlrun.utils.notifications.notification.ipython as ipython
+import mlrun.utils.notifications.notification.mail as mail
+import mlrun.utils.notifications.notification.slack as slack
+import mlrun.utils.notifications.notification.webhook as webhook
 
 
 class NotificationTypes(str, enum.Enum):
-    console = NotificationKind.console.value
-    git = NotificationKind.git.value
-    ipython = NotificationKind.ipython.value
-    slack = NotificationKind.slack.value
-    webhook = NotificationKind.webhook.value
+    console = notifications.NotificationKind.console.value
+    git = notifications.NotificationKind.git.value
+    ipython = notifications.NotificationKind.ipython.value
+    slack = notifications.NotificationKind.slack.value
+    mail = notifications.NotificationKind.mail.value
+    webhook = notifications.NotificationKind.webhook.value
 
-    def get_notification(self) -> type[NotificationBase]:
+    def get_notification(self) -> type[base.NotificationBase]:
         return {
-            self.console: ConsoleNotification,
-            self.git: GitNotification,
-            self.ipython: IPythonNotification,
-            self.slack: SlackNotification,
-            self.webhook: WebhookNotification,
+            self.console: console.ConsoleNotification,
+            self.git: git.GitNotification,
+            self.ipython: ipython.IPythonNotification,
+            self.slack: slack.SlackNotification,
+            self.mail: mail.MailNotification,
+            self.webhook: webhook.WebhookNotification,
         }.get(self)
 
     def inverse_dependencies(self) -> list[str]:
@@ -64,5 +66,6 @@ class NotificationTypes(str, enum.Enum):
             cls.git,
             cls.ipython,
             cls.slack,
+            cls.mail,
             cls.webhook,
         ]

mlrun/utils/notifications/notification/base.py

@@ -14,6 +14,7 @@
 
 import asyncio
 import typing
+from copy import deepcopy
 
 import mlrun.common.schemas
 import mlrun.lists
@@ -22,11 +23,20 @@ import mlrun.lists
 class NotificationBase:
     def __init__(
         self,
-        name: str = None,
-        params: dict[str, str] = None,
+        name: typing.Optional[str] = None,
+        params: typing.Optional[dict[str, str]] = None,
+        default_params: typing.Optional[dict[str, str]] = None,
     ):
+        """
+        NotificationBase is the base class for all notification types.
+
+        :param name: The name of the notification.
+        :param params: The parameters of the notification.
+        :param default_params: The default parameters of the notification. Used for server-side enrichment purposes.
+        """
         self.name = name
         self.params = params or {}
+        self.params = self.enrich_default_params(self.params, default_params)
 
     @classmethod
     def validate_params(cls, params):
@@ -43,13 +53,13 @@ class NotificationBase:
     def push(
         self,
         message: str,
-        severity: typing.Union[
-            mlrun.common.schemas.NotificationSeverity, str
+        severity: typing.Optional[
+            typing.Union[mlrun.common.schemas.NotificationSeverity, str]
         ] = mlrun.common.schemas.NotificationSeverity.INFO,
-        runs: typing.Union[mlrun.lists.RunList, list] = None,
-        custom_html: str = None,
-        alert: mlrun.common.schemas.AlertConfig = None,
-        event_data: mlrun.common.schemas.Event = None,
+        runs: typing.Optional[typing.Union[mlrun.lists.RunList, list]] = None,
+        custom_html: typing.Optional[str] = None,
+        alert: typing.Optional[mlrun.common.schemas.AlertConfig] = None,
+        event_data: typing.Optional[mlrun.common.schemas.Event] = None,
     ):
         raise NotImplementedError()
 
@@ -59,16 +69,25 @@ class NotificationBase:
     ) -> None:
         self.params = params or {}
 
+    @classmethod
+    def enrich_default_params(
+        cls, params: dict, default_params: typing.Optional[dict] = None
+    ) -> dict:
+        default_params = default_params or {}
+        returned_params = deepcopy(default_params)
+        returned_params.update(params)
+        return returned_params
+
     def _get_html(
         self,
         message: str,
-        severity: typing.Union[
-            mlrun.common.schemas.NotificationSeverity, str
+        severity: typing.Optional[
+            typing.Union[mlrun.common.schemas.NotificationSeverity, str]
         ] = mlrun.common.schemas.NotificationSeverity.INFO,
-        runs: typing.Union[mlrun.lists.RunList, list] = None,
-        custom_html: str = None,
-        alert: mlrun.common.schemas.AlertConfig = None,
-        event_data: mlrun.common.schemas.Event = None,
+        runs: typing.Optional[typing.Union[mlrun.lists.RunList, list]] = None,
+        custom_html: typing.Optional[typing.Optional[str]] = None,
+        alert: typing.Optional[mlrun.common.schemas.AlertConfig] = None,
+        event_data: typing.Optional[mlrun.common.schemas.Event] = None,
     ) -> str:
         if custom_html:
             return custom_html
@@ -115,7 +134,12 @@ class NotificationBase:
             event_data.entity.kind == mlrun.common.schemas.alert.EventEntityKind.JOB
         ):  # JOB entity
             uid = event_data.value_dict.get("uid")
-            url = mlrun.utils.helpers.get_ui_url(alert.project, uid)
+            name = event_data.entity.ids[0]
+            url = mlrun.utils.helpers.get_run_url(
+                alert.project,
+                uid=uid,
+                name=name,
+            )
             overview_type = "Job overview"
         else:  # MODEL entity
             model_name = event_data.value_dict.get("model")

mlrun/utils/notifications/notification/console.py

@@ -31,13 +31,13 @@ class ConsoleNotification(NotificationBase):
     def push(
         self,
         message: str,
-        severity: typing.Union[
-            mlrun.common.schemas.NotificationSeverity, str
+        severity: typing.Optional[
+            typing.Union[mlrun.common.schemas.NotificationSeverity, str]
         ] = mlrun.common.schemas.NotificationSeverity.INFO,
-        runs: typing.Union[mlrun.lists.RunList, list] = None,
-        custom_html: str = None,
-        alert: mlrun.common.schemas.AlertConfig = None,
-        event_data: mlrun.common.schemas.Event = None,
+        runs: typing.Optional[typing.Union[mlrun.lists.RunList, list]] = None,
+        custom_html: typing.Optional[typing.Optional[str]] = None,
+        alert: typing.Optional[mlrun.common.schemas.AlertConfig] = None,
+        event_data: typing.Optional[mlrun.common.schemas.Event] = None,
     ):
         severity = self._resolve_severity(severity)
         print(f"[{severity}] {message}")

mlrun/utils/notifications/notification/git.py

@@ -54,13 +54,13 @@ class GitNotification(NotificationBase):
     async def push(
         self,
         message: str,
-        severity: typing.Union[
-            mlrun.common.schemas.NotificationSeverity, str
+        severity: typing.Optional[
+            typing.Union[mlrun.common.schemas.NotificationSeverity, str]
         ] = mlrun.common.schemas.NotificationSeverity.INFO,
-        runs: typing.Union[mlrun.lists.RunList, list] = None,
-        custom_html: str = None,
-        alert: mlrun.common.schemas.AlertConfig = None,
-        event_data: mlrun.common.schemas.Event = None,
+        runs: typing.Optional[typing.Union[mlrun.lists.RunList, list]] = None,
+        custom_html: typing.Optional[typing.Optional[str]] = None,
+        alert: typing.Optional[mlrun.common.schemas.AlertConfig] = None,
+        event_data: typing.Optional[mlrun.common.schemas.Event] = None,
     ):
         git_repo = self.params.get("repo", None)
         git_issue = self.params.get("issue", None)
@@ -85,11 +85,11 @@ class GitNotification(NotificationBase):
     @staticmethod
     async def _pr_comment(
         message: str,
-        repo: str = None,
-        issue: int = None,
-        merge_request: int = None,
-        token: str = None,
-        server: str = None,
+        repo: typing.Optional[str] = None,
+        issue: typing.Optional[int] = None,
+        merge_request: typing.Optional[int] = None,
+        token: typing.Optional[str] = None,
+        server: typing.Optional[str] = None,
         gitlab: bool = False,
     ) -> str:
         """push comment message to Git system PR/issue

mlrun/utils/notifications/notification/ipython.py

@@ -28,10 +28,11 @@ class IPythonNotification(NotificationBase):
 
     def __init__(
         self,
-        name: str = None,
-        params: dict[str, str] = None,
+        name: typing.Optional[str] = None,
+        params: typing.Optional[dict[str, str]] = None,
+        default_params: typing.Optional[dict[str, str]] = None,
     ):
-        super().__init__(name, params)
+        super().__init__(name, params, default_params)
         self._ipython = None
         try:
             import IPython
@@ -48,13 +49,13 @@ class IPythonNotification(NotificationBase):
     def push(
         self,
         message: str,
-        severity: typing.Union[
-            mlrun.common.schemas.NotificationSeverity, str
+        severity: typing.Optional[
+            typing.Union[mlrun.common.schemas.NotificationSeverity, str]
         ] = mlrun.common.schemas.NotificationSeverity.INFO,
-        runs: typing.Union[mlrun.lists.RunList, list] = None,
-        custom_html: str = None,
-        alert: mlrun.common.schemas.AlertConfig = None,
-        event_data: mlrun.common.schemas.Event = None,
+        runs: typing.Optional[typing.Union[mlrun.lists.RunList, list]] = None,
+        custom_html: typing.Optional[typing.Optional[str]] = None,
+        alert: typing.Optional[mlrun.common.schemas.AlertConfig] = None,
+        event_data: typing.Optional[mlrun.common.schemas.Event] = None,
     ):
         if not self._ipython:
             mlrun.utils.helpers.logger.debug(

mlrun/utils/notifications/notification/mail.py

@@ -0,0 +1,176 @@
+# Copyright 2023 Iguazio
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import re
+import typing
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+
+import aiosmtplib
+
+import mlrun.common.schemas
+import mlrun.lists
+import mlrun.utils.helpers
+import mlrun.utils.notifications.notification.base as base
+import mlrun.utils.regex
+
+DEFAULT_SMTP_PORT = 587
+
+
+class MailNotification(base.NotificationBase):
+    """
+    API/Client notification for sending run statuses as a mail message
+    """
+
+    boolean_params = ["use_tls", "start_tls", "validate_certs"]
+
+    required_params = [
+        "server_host",
+        "server_port",
+        "sender_address",
+        "username",
+        "password",
+        "email_addresses",
+    ] + boolean_params
+
+    @classmethod
+    def validate_params(cls, params):
+        for required_param in cls.required_params:
+            if required_param not in params:
+                raise ValueError(
+                    f"Parameter '{required_param}' is required for MailNotification"
+                )
+
+        for boolean_param in cls.boolean_params:
+            if not isinstance(params.get(boolean_param, None), bool):
+                raise ValueError(
+                    f"Parameter '{boolean_param}' must be a boolean for MailNotification"
+                )
+
+        cls._validate_emails(params)
+
+    async def push(
+        self,
+        message: str,
+        severity: typing.Optional[
+            typing.Union[mlrun.common.schemas.NotificationSeverity, str]
+        ] = mlrun.common.schemas.NotificationSeverity.INFO,
+        runs: typing.Optional[typing.Union[mlrun.lists.RunList, list]] = None,
+        custom_html: typing.Optional[typing.Optional[str]] = None,
+        alert: typing.Optional[mlrun.common.schemas.AlertConfig] = None,
+        event_data: typing.Optional[mlrun.common.schemas.Event] = None,
+    ):
+        self.params["subject"] = f"[{severity}] {message}"
+        message_body_override = self.params.get("message_body_override", None)
+
+        runs_html = self._get_html(
+            message, severity, runs, custom_html, alert, event_data
+        )
+        self.params["body"] = runs_html
+
+        if message_body_override:
+            self.params["body"] = message_body_override.replace(
+                "{{ runs }}", runs_html
+            ).replace("{{runs}}", runs_html)
+
+        await self._send_email(**self.params)
+
+    @classmethod
+    def enrich_default_params(
+        cls, params: dict, default_params: typing.Optional[dict] = None
+    ) -> dict:
+        params = super().enrich_default_params(params, default_params)
+        params.setdefault("use_tls", True)
+        params.setdefault("start_tls", False)
+        params.setdefault("validate_certs", True)
+        params.setdefault("server_port", DEFAULT_SMTP_PORT)
+
+        default_mail_address = params.pop("default_email_addresses", "")
+        params["email_addresses"] = cls._merge_mail_addresses(
+            default_mail_address, params.get("email_addresses", "")
+        )
+
+        return params
+
+    @classmethod
+    def _merge_mail_addresses(
+        cls,
+        default_mail_address: typing.Union[str, list],
+        email_addresses: typing.Union[str, list],
+    ) -> str:
+        if isinstance(default_mail_address, str):
+            default_mail_address = (
+                default_mail_address.split(",") if default_mail_address else []
+            )
+        if isinstance(email_addresses, str):
+            email_addresses = email_addresses.split(",") if email_addresses else []
+        email_addresses.extend(default_mail_address)
+        email_addresses_str = ",".join(email_addresses)
+        return email_addresses_str
+
+    @classmethod
+    def _validate_emails(cls, params):
+        cls._validate_email_address(params["sender_address"])
+
+        if not isinstance(params["email_addresses"], (str, list)):
+            raise ValueError(
+                "Parameter 'email_addresses' must be a string or a list of strings"
+            )
+
+        email_addresses = params["email_addresses"]
+        if isinstance(email_addresses, str):
+            email_addresses = email_addresses.split(",")
+        for email_address in email_addresses:
+            cls._validate_email_address(email_address)
+
+    @classmethod
+    def _validate_email_address(cls, email_address):
+        if not isinstance(email_address, str):
+            raise ValueError(f"Email address '{email_address}' must be a string")
+
+        if not re.match(mlrun.utils.regex.mail_regex, email_address):
+            raise ValueError(f"Invalid email address '{email_address}'")
+
+    @staticmethod
+    async def _send_email(
+        email_addresses: str,
+        sender_address: str,
+        server_host: str,
+        server_port: int,
+        username: str,
+        password: str,
+        use_tls: bool,
+        start_tls: bool,
+        validate_certs: bool,
+        subject: str,
+        body: str,
+        **kwargs,
+    ):
+        # Create the email message
+        message = MIMEMultipart("alternative")
+        message["From"] = sender_address
+        message["To"] = email_addresses
+        message["Subject"] = subject
+        message.attach(MIMEText(body, "html"))
+
+        # Send the email
+        await aiosmtplib.send(
+            message,
+            hostname=server_host,
+            port=server_port,
+            username=username,
+            password=password,
+            use_tls=use_tls,
+            validate_certs=validate_certs,
+            start_tls=start_tls,
+        )

mlrun/utils/notifications/notification/slack.py

@@ -16,6 +16,7 @@ import typing
 
 import aiohttp
 
+import mlrun.common.runtimes.constants as runtimes_constants
 import mlrun.common.schemas
 import mlrun.lists
 import mlrun.utils.helpers
@@ -46,13 +47,13 @@ class SlackNotification(NotificationBase):
     async def push(
         self,
         message: str,
-        severity: typing.Union[
-            mlrun.common.schemas.NotificationSeverity, str
+        severity: typing.Optional[
+            typing.Union[mlrun.common.schemas.NotificationSeverity, str]
         ] = mlrun.common.schemas.NotificationSeverity.INFO,
-        runs: typing.Union[mlrun.lists.RunList, list] = None,
-        custom_html: str = None,
-        alert: mlrun.common.schemas.AlertConfig = None,
-        event_data: mlrun.common.schemas.Event = None,
+        runs: typing.Optional[typing.Union[mlrun.lists.RunList, list]] = None,
+        custom_html: typing.Optional[typing.Optional[str]] = None,
+        alert: typing.Optional[mlrun.common.schemas.AlertConfig] = None,
+        event_data: typing.Optional[mlrun.common.schemas.Event] = None,
     ):
         webhook = self.params.get("webhook", None) or mlrun.get_secret_or_env(
             "SLACK_WEBHOOK"
@@ -168,12 +169,19 @@ class SlackNotification(NotificationBase):
 
     def _get_run_line(self, run: dict) -> dict:
         meta = run["metadata"]
-        url = mlrun.utils.helpers.get_ui_url(meta.get("project"), meta.get("uid"))
+        url = mlrun.utils.helpers.get_run_url(
+            meta.get("project"),
+            uid=meta.get("uid"),
+            name=meta.get("name"),
+        )
 
         # Only show the URL if the run is not a function (serving or mlrun function)
         kind = run.get("step_kind")
         state = run["status"].get("state", "")
-        if state != "skipped" and (url and not kind or kind == "run"):
+
+        if state != runtimes_constants.RunStates.skipped and (
+            url and not kind or kind == "run"
+        ):
             line = f'<{url}|*{meta.get("name")}*>'
         else:
             line = meta.get("name")