mlrun 1.7.1rc10__py3-none-any.whl → 1.8.0rc8__py3-none-any.whl

mlrun/utils/helpers.py

@@ -40,7 +40,6 @@ import pandas
 import semver
 import yaml
 from dateutil import parser
-from mlrun_pipelines.models import PipelineRun
 from pandas import Timedelta, Timestamp
 from yaml.representer import RepresenterError
 
@@ -52,6 +51,7 @@ import mlrun.utils.regex
 import mlrun.utils.version.version
 from mlrun.common.constants import MYSQL_MEDIUMBLOB_SIZE_BYTES
 from mlrun.config import config
+from mlrun_pipelines.models import PipelineRun
 
 from .logger import create_logger
 from .retryer import (  # noqa: F401
@@ -167,6 +167,7 @@ class RunKeys:
     inputs = "inputs"
     returns = "returns"
     artifacts = "artifacts"
+    artifact_uris = "artifact_uris"
     outputs = "outputs"
     data_stores = "data_stores"
     secrets = "secret_sources"
@@ -220,7 +221,7 @@ def verify_field_regex(
 
 
 def validate_builder_source(
-    source: str, pull_at_runtime: bool = False, workdir: str = None
+    source: str, pull_at_runtime: bool = False, workdir: Optional[str] = None
 ):
     if pull_at_runtime or not source:
         return
@@ -268,12 +269,14 @@ def validate_tag_name(
 def validate_artifact_key_name(
     artifact_key: str, field_name: str, raise_on_failure: bool = True
 ) -> bool:
+    field_type = "key" if field_name == "artifact.key" else "db_key"
     return mlrun.utils.helpers.verify_field_regex(
         field_name,
         artifact_key,
         mlrun.utils.regex.artifact_key,
         raise_on_failure=raise_on_failure,
-        log_message="Slashes are not permitted in the artifact key (both \\ and /)",
+        log_message=f"Artifact {field_type} must start and end with an alphanumeric character, and may only contain "
+        "letters, numbers, hyphens, underscores, and dots.",
     )
 
 
@@ -354,8 +357,8 @@ def verify_field_list_of_type(
 def verify_dict_items_type(
     name: str,
     dictionary: dict,
-    expected_keys_types: list = None,
-    expected_values_types: list = None,
+    expected_keys_types: Optional[list] = None,
+    expected_values_types: Optional[list] = None,
 ):
     if dictionary:
         if not isinstance(dictionary, dict):
@@ -372,7 +375,7 @@ def verify_dict_items_type(
             ) from exc
 
 
-def verify_list_items_type(list_, expected_types: list = None):
+def verify_list_items_type(list_, expected_types: Optional[list] = None):
     if list_ and expected_types:
         list_items_types = set(map(type, list_))
         expected_types = set(expected_types)
@@ -396,6 +399,10 @@ def now_date(tz: timezone = timezone.utc) -> datetime:
     return datetime.now(tz=tz)
 
 
+def datetime_min(tz: timezone = timezone.utc) -> datetime:
+    return datetime(1970, 1, 1, tzinfo=tz)
+
+
 datetime_now = now_date
 
 
@@ -816,7 +823,9 @@ def _convert_python_package_version_to_image_tag(version: typing.Optional[str]):
 
 
 def enrich_image_url(
-    image_url: str, client_version: str = None, client_python_version: str = None
+    image_url: str,
+    client_version: Optional[str] = None,
+    client_python_version: Optional[str] = None,
 ) -> str:
     client_version = _convert_python_package_version_to_image_tag(client_version)
     server_version = _convert_python_package_version_to_image_tag(
@@ -856,7 +865,7 @@ def enrich_image_url(
 
 
 def resolve_image_tag_suffix(
-    mlrun_version: str = None, python_version: str = None
+    mlrun_version: Optional[str] = None, python_version: Optional[str] = None
 ) -> str:
     """
     resolves what suffix should be appended to the image tag
@@ -1175,7 +1184,7 @@ def get_function(function, namespaces, reload_modules: bool = False):
 def get_handler_extended(
     handler_path: str,
     context=None,
-    class_args: dict = None,
+    class_args: Optional[dict] = None,
     namespaces=None,
     reload_modules: bool = False,
 ):
@@ -1694,17 +1703,22 @@ def merge_dicts_with_precedence(*dicts: dict) -> dict:
 
 
 def validate_component_version_compatibility(
-    component_name: typing.Literal["iguazio", "nuclio"], *min_versions: str
+    component_name: typing.Literal["iguazio", "nuclio", "mlrun-client"],
+    *min_versions: str,
+    mlrun_client_version: Optional[str] = None,
 ):
     """
     :param component_name: Name of the component to validate compatibility for.
     :param min_versions: Valid minimum version(s) required, assuming no 2 versions has equal major and minor.
+    :param mlrun_client_version: Client version to validate when component_name is "mlrun-client".
     """
     parsed_min_versions = [
         semver.VersionInfo.parse(min_version) for min_version in min_versions
     ]
     parsed_current_version = None
     component_current_version = None
+    # For mlrun client we don't assume compatability if we fail to parse the client version
+    assume_compatible = component_name not in ["mlrun-client"]
     try:
         if component_name == "iguazio":
             component_current_version = mlrun.mlconf.igz_version
@@ -1721,18 +1735,29 @@ def validate_component_version_compatibility(
             parsed_current_version = semver.VersionInfo.parse(
                 mlrun.mlconf.nuclio_version
             )
+        if component_name == "mlrun-client":
+            # dev version, assume compatible
+            if mlrun_client_version and (
+                mlrun_client_version.startswith("0.0.0+")
+                or "unstable" in mlrun_client_version
+            ):
+                return True
+
+            component_current_version = mlrun_client_version
+            parsed_current_version = semver.Version.parse(mlrun_client_version)
         if not parsed_current_version:
-            return True
+            return assume_compatible
     except ValueError:
         # only log when version is set but invalid
         if component_current_version:
             logger.warning(
-                "Unable to parse current version, assuming compatibility",
+                "Unable to parse current version",
                 component_name=component_name,
                 current_version=component_current_version,
                 min_versions=min_versions,
+                assume_compatible=assume_compatible,
             )
-        return True
+        return assume_compatible
 
     # Feature might have been back-ported e.g. nuclio node selection is supported from
     # 1.5.20 and 1.6.10 but not in 1.6.9 - therefore we reverse sort to validate against 1.6.x 1st and
@@ -1797,9 +1822,8 @@ def _reload(module, max_recursion_depth):
 def run_with_retry(
     retry_count: int,
     func: typing.Callable,
-    retry_on_exceptions: typing.Union[
-        type[Exception],
-        tuple[type[Exception]],
+    retry_on_exceptions: Optional[
+        typing.Union[type[Exception], tuple[type[Exception]]]
     ] = None,
     *args,
     **kwargs,
@@ -1832,3 +1856,17 @@ def run_with_retry(
             if attempt == retry_count:
                 raise
     raise last_exception
+
+
+def join_urls(base_url: Optional[str], path: Optional[str]) -> str:
+    """
+    Joins a base URL with a path, ensuring proper handling of slashes.
+
+    :param base_url: The base URL (e.g., "http://example.com").
+    :param path: The path to append to the base URL (e.g., "/path/to/resource").
+
+    :return: A unified URL with exactly one slash between base_url and path.
+    """
+    if base_url is None:
+        base_url = ""
+    return f"{base_url.rstrip('/')}/{path.lstrip('/')}" if path else base_url

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
@@ -22,15 +24,16 @@ 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
 
 
 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.
@@ -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/__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[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

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(