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

mlrun/utils/logger.py

@@ -11,9 +11,11 @@
 # 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 datetime
 import logging
 import os
+import string
+import sys
 import typing
 from enum import Enum
 from functools import cached_property
@@ -24,6 +26,7 @@ from typing import IO, Optional, Union
 import orjson
 import pydantic
 
+from mlrun import errors
 from mlrun.config import config
 
 
@@ -93,6 +96,98 @@ class HumanReadableFormatter(_BaseFormatter):
         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):
     _colors = {
         logging.NOTSET: "",
@@ -272,17 +367,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/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):
@@ -47,7 +57,7 @@ class NotificationBase:
             mlrun.common.schemas.NotificationSeverity, str
         ] = mlrun.common.schemas.NotificationSeverity.INFO,
         runs: typing.Union[mlrun.lists.RunList, list] = None,
-        custom_html: str = None,
+        custom_html: typing.Optional[str] = None,
         alert: mlrun.common.schemas.AlertConfig = None,
         event_data: mlrun.common.schemas.Event = None,
     ):
@@ -59,6 +69,15 @@ 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,
@@ -66,7 +85,7 @@ class NotificationBase:
             mlrun.common.schemas.NotificationSeverity, str
         ] = mlrun.common.schemas.NotificationSeverity.INFO,
         runs: typing.Union[mlrun.lists.RunList, list] = None,
-        custom_html: str = None,
+        custom_html: typing.Optional[str] = None,
         alert: mlrun.common.schemas.AlertConfig = None,
         event_data: mlrun.common.schemas.Event = None,
     ) -> str:

mlrun/utils/notifications/notification/console.py

@@ -35,7 +35,7 @@ class ConsoleNotification(NotificationBase):
             mlrun.common.schemas.NotificationSeverity, str
         ] = mlrun.common.schemas.NotificationSeverity.INFO,
         runs: typing.Union[mlrun.lists.RunList, list] = None,
-        custom_html: str = None,
+        custom_html: typing.Optional[str] = None,
         alert: mlrun.common.schemas.AlertConfig = None,
         event_data: mlrun.common.schemas.Event = None,
     ):

mlrun/utils/notifications/notification/git.py

@@ -58,7 +58,7 @@ class GitNotification(NotificationBase):
             mlrun.common.schemas.NotificationSeverity, str
         ] = mlrun.common.schemas.NotificationSeverity.INFO,
         runs: typing.Union[mlrun.lists.RunList, list] = None,
-        custom_html: str = None,
+        custom_html: typing.Optional[str] = None,
         alert: mlrun.common.schemas.AlertConfig = None,
         event_data: mlrun.common.schemas.Event = 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
@@ -52,7 +53,7 @@ class IPythonNotification(NotificationBase):
             mlrun.common.schemas.NotificationSeverity, str
         ] = mlrun.common.schemas.NotificationSeverity.INFO,
         runs: typing.Union[mlrun.lists.RunList, list] = None,
-        custom_html: str = None,
+        custom_html: typing.Optional[str] = None,
         alert: mlrun.common.schemas.AlertConfig = None,
         event_data: mlrun.common.schemas.Event = None,
     ):

mlrun/utils/notifications/notification/slack.py

@@ -50,7 +50,7 @@ class SlackNotification(NotificationBase):
             mlrun.common.schemas.NotificationSeverity, str
         ] = mlrun.common.schemas.NotificationSeverity.INFO,
         runs: typing.Union[mlrun.lists.RunList, list] = None,
-        custom_html: str = None,
+        custom_html: typing.Optional[str] = None,
         alert: mlrun.common.schemas.AlertConfig = None,
         event_data: mlrun.common.schemas.Event = None,
     ):

mlrun/utils/notifications/notification/webhook.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import re
 import typing
 
 import aiohttp
@@ -42,7 +41,7 @@ class WebhookNotification(NotificationBase):
             mlrun.common.schemas.NotificationSeverity, str
         ] = mlrun.common.schemas.NotificationSeverity.INFO,
         runs: typing.Union[mlrun.lists.RunList, list] = None,
-        custom_html: str = None,
+        custom_html: typing.Optional[str] = None,
         alert: mlrun.common.schemas.AlertConfig = None,
         event_data: mlrun.common.schemas.Event = None,
     ):
@@ -94,6 +93,7 @@ class WebhookNotification(NotificationBase):
 
     @staticmethod
     def _serialize_runs_in_request_body(override_body, runs):
+        str_parsed_runs = ""
         runs = runs or []
 
         def parse_runs():
@@ -105,26 +105,22 @@ class WebhookNotification(NotificationBase):
                     parsed_run = {
                         "project": run["metadata"]["project"],
                         "name": run["metadata"]["name"],
+                        "host": run["metadata"]["labels"]["host"],
                         "status": {"state": run["status"]["state"]},
                     }
-                    if host := run["metadata"].get("labels", {}).get("host", ""):
-                        parsed_run["host"] = host
-                    if error := run["status"].get("error"):
-                        parsed_run["status"]["error"] = error
-                    elif results := run["status"].get("results"):
-                        parsed_run["status"]["results"] = results
+                    if run["status"].get("error", None):
+                        parsed_run["status"]["error"] = run["status"]["error"]
+                    elif run["status"].get("results", None):
+                        parsed_run["status"]["results"] = run["status"]["results"]
                     parsed_runs.append(parsed_run)
             return str(parsed_runs)
 
         if isinstance(override_body, dict):
             for key, value in override_body.items():
-                if not isinstance(value, str):
-                    # If the value is not a string, we don't want to parse it
-                    continue
-                if re.search(r"{{\s*runs\s*}}", value):
-                    str_parsed_runs = parse_runs()
-                    override_body[key] = re.sub(
-                        r"{{\s*runs\s*}}", str_parsed_runs, value
-                    )
-
+                if "{{ runs }}" or "{{runs}}" in value:
+                    if not str_parsed_runs:
+                        str_parsed_runs = parse_runs()
+                    override_body[key] = value.replace(
+                        "{{ runs }}", str_parsed_runs
+                    ).replace("{{runs}}", str_parsed_runs)
         return override_body

mlrun/utils/notifications/notification_pusher.py

@@ -20,10 +20,6 @@ import traceback
 import typing
 from concurrent.futures import ThreadPoolExecutor
 
-import mlrun_pipelines.common.ops
-import mlrun_pipelines.models
-import mlrun_pipelines.utils
-
 import mlrun.common.constants as mlrun_constants
 import mlrun.common.runtimes.constants
 import mlrun.common.schemas
@@ -33,6 +29,9 @@ import mlrun.errors
 import mlrun.lists
 import mlrun.model
 import mlrun.utils.helpers
+import mlrun_pipelines.common.ops
+import mlrun_pipelines.models
+import mlrun_pipelines.utils
 from mlrun.utils import logger
 from mlrun.utils.condition_evaluator import evaluate_condition_in_separate_process
 
@@ -100,8 +99,13 @@ class NotificationPusher(_NotificationPusherBase):
         "aborted": "{resource} aborted",
     }
 
-    def __init__(self, runs: typing.Union[mlrun.lists.RunList, list]):
+    def __init__(
+        self,
+        runs: typing.Union[mlrun.lists.RunList, list],
+        default_params: typing.Optional[dict] = None,
+    ):
         self._runs = runs
+        self._default_params = default_params or {}
         self._sync_notifications: list[
             tuple[NotificationBase, mlrun.model.RunObject, mlrun.model.Notification]
         ] = []
@@ -168,11 +172,6 @@ class NotificationPusher(_NotificationPusherBase):
                     logger.warning(
                         "Failed to push notification async",
                         error=mlrun.errors.err_to_str(result),
-                        traceback=traceback.format_exception(
-                            etype=type(result),
-                            value=result,
-                            tb=result.__traceback__,
-                        ),
                     )
 
         logger.debug(
@@ -225,7 +224,10 @@ class NotificationPusher(_NotificationPusherBase):
         params = {}
         params.update(notification_object.secret_params)
         params.update(notification_object.params)
-        notification = notification_type.get_notification()(name, params)
+        default_params = self._default_params.get(notification_type.value, {})
+        notification = notification_type.get_notification()(
+            name, params, default_params
+        )
         if notification.is_async:
             self._async_notifications.append((notification, run, notification_object))
         else:
@@ -366,7 +368,7 @@ class NotificationPusher(_NotificationPusherBase):
         run_uid: str,
         project: str,
         notification: mlrun.model.Notification,
-        status: str = None,
+        status: typing.Optional[str] = None,
         sent_time: typing.Optional[datetime.datetime] = None,
         reason: typing.Optional[str] = None,
     ):
@@ -521,7 +523,7 @@ class NotificationPusher(_NotificationPusherBase):
 
 
 class CustomNotificationPusher(_NotificationPusherBase):
-    def __init__(self, notification_types: list[str] = None):
+    def __init__(self, notification_types: typing.Optional[list[str]] = None):
         notifications = {
             notification_type: NotificationTypes(notification_type).get_notification()()
             for notification_type in notification_types
@@ -550,7 +552,7 @@ class CustomNotificationPusher(_NotificationPusherBase):
             mlrun.common.schemas.NotificationSeverity, str
         ] = mlrun.common.schemas.NotificationSeverity.INFO,
         runs: typing.Union[mlrun.lists.RunList, list] = None,
-        custom_html: str = None,
+        custom_html: typing.Optional[str] = None,
     ):
         def sync_push():
             for notification_type, notification in self._sync_notifications.items():
@@ -572,7 +574,7 @@ class CustomNotificationPusher(_NotificationPusherBase):
     def add_notification(
         self,
         notification_type: str,
-        params: dict[str, str] = None,
+        params: typing.Optional[dict[str, str]] = None,
     ):
         if notification_type in self._async_notifications:
             self._async_notifications[notification_type].load_notification(params)
@@ -597,7 +599,9 @@ class CustomNotificationPusher(_NotificationPusherBase):
         else:
             logger.warning(f"No notification of type {notification_type} in project")
 
-    def edit_notification(self, notification_type: str, params: dict[str, str] = None):
+    def edit_notification(
+        self, notification_type: str, params: typing.Optional[dict[str, str]] = None
+    ):
         self.remove_notification(notification_type)
         self.add_notification(notification_type, params)
 
@@ -627,8 +631,8 @@ class CustomNotificationPusher(_NotificationPusherBase):
     def push_pipeline_start_message(
         self,
         project: str,
-        commit_id: str = None,
-        pipeline_id: str = None,
+        commit_id: typing.Optional[str] = None,
+        pipeline_id: typing.Optional[str] = None,
         has_workflow_url: bool = False,
     ):
         message = f"Workflow started in project {project}"
@@ -656,7 +660,7 @@ class CustomNotificationPusher(_NotificationPusherBase):
         self,
         runs: typing.Union[mlrun.lists.RunList, list],
         push_all: bool = False,
-        state: str = None,
+        state: typing.Optional[str] = None,
     ):
         """
         push a structured table with run results to notification targets

mlrun/utils/regex.py

@@ -86,7 +86,7 @@ tag_name = label_value
 
 secret_key = k8s_secret_and_config_map_key
 
-artifact_key = [r"[^\/\\]+$"]
+artifact_key = [r"^[A-Za-z0-9]([-A-Za-z0-9_.]*[A-Za-z0-9])?$"]
 
 # must not start with _
 # must be alphanumeric or _

mlrun/utils/version/version.json

@@ -1,4 +1,4 @@
 {
-  "git_commit": "bb224abaed1b5d221269586c9497124a526615e8",
-  "version": "1.7.2"
+  "git_commit": "f2e5312ff81bf956d90d45964ee2cbbe02c4323f",
+  "version": "1.8.0-rc1"
 }