mlrun 1.8.0rc4__py3-none-any.whl → 1.8.0rc7__py3-none-any.whl

mlrun/serving/v2_serving.py

@@ -21,10 +21,9 @@ import mlrun.artifacts
 import mlrun.common.model_monitoring.helpers
 import mlrun.common.schemas.model_monitoring
 import mlrun.model_monitoring
-from mlrun.errors import err_to_str
 from mlrun.utils import logger, now_date
 
-from ..common.helpers import parse_versioned_object_uri
+from ..common.schemas.model_monitoring import ModelEndpointSchema
 from .server import GraphServer
 from .utils import StepToDict, _extract_input_data, _update_result_body
 
@@ -110,12 +109,6 @@ class V2ModelServer(StepToDict):
         self._result_path = result_path
         self._kwargs = kwargs  # for to_dict()
         self._params = kwargs
-        self._model_logger = (
-            _ModelLogPusher(self, context)
-            if context and context.stream.enabled
-            else None
-        )
-
         self.metrics = {}
         self.labels = {}
         self.model = None
@@ -125,6 +118,7 @@ class V2ModelServer(StepToDict):
         self._versioned_model_name = None
         self.model_endpoint_uid = None
         self.shard_by_endpoint = shard_by_endpoint
+        self._model_logger = None
 
     def _load_and_update_state(self):
         try:
@@ -157,6 +151,11 @@ class V2ModelServer(StepToDict):
             self.model_endpoint_uid = _init_endpoint_record(
                 graph_server=server, model=self
             )
+        self._model_logger = (
+            _ModelLogPusher(self, self.context)
+            if self.context and self.context.stream.enabled
+            else None
+        )
 
     def get_param(self, key: str, default=None):
         """get param by key (specified in the model or the function)"""
@@ -474,7 +473,7 @@ class V2ModelServer(StepToDict):
 
 
 class _ModelLogPusher:
-    def __init__(self, model, context, output_stream=None):
+    def __init__(self, model: V2ModelServer, context, output_stream=None):
         self.model = model
         self.verbose = context.verbose
         self.hostname = context.stream.hostname
@@ -496,6 +495,7 @@ class _ModelLogPusher:
             "version": self.model.version,
             "host": self.hostname,
             "function_uri": self.function_uri,
+            "endpoint_id": self.model.model_endpoint_uid,
         }
         if getattr(self.model, "labels", None):
             base_data["labels"] = self.model.labels
@@ -567,26 +567,13 @@ def _init_endpoint_record(
     """
 
     logger.info("Initializing endpoint records")
-
-    # Generate required values for the model endpoint record
-    try:
-        # Getting project name from the function uri
-        project, uri, tag, hash_key = parse_versioned_object_uri(
-            graph_server.function_uri
-        )
-    except Exception as e:
-        logger.error("Failed to parse function URI", exc=err_to_str(e))
-        return None
-
-    # Generating model endpoint ID based on function uri and model version
-    uid = mlrun.common.model_monitoring.create_model_endpoint_uid(
-        function_uri=graph_server.function_uri,
-        versioned_model=model.versioned_model_name,
-    ).uid
-
+    if not model.model_spec:
+        model.get_model()
     try:
         model_ep = mlrun.get_run_db().get_model_endpoint(
-            project=project, endpoint_id=uid
+            project=graph_server.project,
+            name=model.name,
+            function_name=graph_server.function_name,
         )
     except mlrun.errors.MLRunNotFoundError:
         model_ep = None
@@ -596,62 +583,84 @@ def _init_endpoint_record(
         )
         return
 
-    if model.context.server.track_models and not model_ep:
-        logger.info("Creating a new model endpoint record", endpoint_id=uid)
-        model_endpoint = mlrun.common.schemas.ModelEndpoint(
+    function = mlrun.get_run_db().get_function(
+        name=graph_server.function_name,
+        project=graph_server.project,
+        tag=graph_server.function_tag or "latest",
+    )
+    function_uid = function.get("metadata", {}).get("uid")
+    if not model_ep and model.context.server.track_models:
+        logger.info(
+            "Creating a new model endpoint record",
+            name=model.name,
+            project=graph_server.project,
+            function_name=graph_server.function_name,
+            function_uid=function_uid,
+            model_name=model.model_spec.metadata.key,
+            model_uid=model.model_spec.metadata.uid,
+            model_class=model.__class__.__name__,
+            model_tag=model.model_spec.tag,
+        )
+        model_ep = mlrun.common.schemas.ModelEndpoint(
             metadata=mlrun.common.schemas.ModelEndpointMetadata(
-                project=project, labels=model.labels, uid=uid
+                project=graph_server.project,
+                labels=model.model_spec.labels,
+                name=model.name,
+                endpoint_type=mlrun.common.schemas.model_monitoring.EndpointType.NODE_EP,
             ),
             spec=mlrun.common.schemas.ModelEndpointSpec(
-                function_uri=graph_server.function_uri,
-                model=model.versioned_model_name,
+                function_name=graph_server.function_name,
+                function_uid=function_uid,
+                function_tag=graph_server.function_tag or "latest",
+                model_name=model.model_spec.metadata.key,
+                model_uid=model.model_spec.metadata.uid,
                 model_class=model.__class__.__name__,
-                model_uri=model.model_path,
-                stream_path=model.context.stream.stream_uri,
-                active=True,
-                monitoring_mode=mlrun.common.schemas.model_monitoring.ModelMonitoringMode.enabled,
             ),
             status=mlrun.common.schemas.ModelEndpointStatus(
-                endpoint_type=mlrun.common.schemas.model_monitoring.EndpointType.NODE_EP
+                monitoring_mode=mlrun.common.schemas.model_monitoring.ModelMonitoringMode.enabled
+                if model.context.server.track_models
+                else mlrun.common.schemas.model_monitoring.ModelMonitoringMode.disabled,
             ),
         )
-
         db = mlrun.get_run_db()
-        db.create_model_endpoint(
-            project=project,
-            endpoint_id=uid,
-            model_endpoint=model_endpoint.dict(),
-        )
+        db.create_model_endpoint(model_endpoint=model_ep)
 
     elif model_ep:
         attributes = {}
-        old_model_uri = model_ep.spec.model_uri
-        mlrun.model_monitoring.helpers.enrich_model_endpoint_with_model_uri(
-            model_endpoint=model_ep,
-            model_obj=model.model_spec,
-        )
-        if model_ep.spec.model_uri != old_model_uri:
-            attributes["model_uri"] = model_ep.spec.model_uri
+        if function_uid != model_ep.spec.function_uid:
+            attributes[ModelEndpointSchema.FUNCTION_UID] = function_uid
+        if model.model_spec.metadata.key != model_ep.spec.model_name:
+            attributes[ModelEndpointSchema.MODEL_NAME] = model.model_spec.metadata.key
+        if model.model_spec.metadata.uid != model_ep.spec.model_uid:
+            attributes[ModelEndpointSchema.MODEL_UID] = model.model_spec.metadata.uid
+        if model.__class__.__name__ != model_ep.spec.model_class:
+            attributes[ModelEndpointSchema.MODEL_CLASS] = model.__class__.__name__
         if (
-            model_ep.spec.monitoring_mode
+            model_ep.status.monitoring_mode
             == mlrun.common.schemas.model_monitoring.ModelMonitoringMode.enabled
         ) != model.context.server.track_models:
-            attributes["monitoring_mode"] = (
+            attributes[ModelEndpointSchema.MONITORING_MODE] = (
                 mlrun.common.schemas.model_monitoring.ModelMonitoringMode.enabled
                 if model.context.server.track_models
                 else mlrun.common.schemas.model_monitoring.ModelMonitoringMode.disabled
             )
         if attributes:
-            db = mlrun.get_run_db()
-            db.patch_model_endpoint(
-                project=project,
-                endpoint_id=uid,
-                attributes=attributes,
-            )
             logger.info(
                 "Updating model endpoint attributes",
                 attributes=attributes,
-                endpoint_id=uid,
+                project=model_ep.metadata.project,
+                name=model_ep.metadata.name,
+                function_name=model_ep.spec.function_name,
+            )
+            db = mlrun.get_run_db()
+            model_ep = db.patch_model_endpoint(
+                project=model_ep.metadata.project,
+                name=model_ep.metadata.name,
+                function_name=model_ep.spec.function_name,
+                endpoint_id=model_ep.metadata.uid,
+                attributes=attributes,
             )
+    else:
+        return None
 
-    return uid
+    return model_ep.metadata.uid

mlrun/utils/helpers.py

@@ -956,36 +956,6 @@ def fill_function_hash(function_dict, tag=""):
     return fill_object_hash(function_dict, "hash", tag)
 
 
-def fill_model_endpoint_hash(
-    model_endpoint: mlrun.common.schemas.ModelEndpointV2,
-    created_time: typing.Union[str, datetime],
-) -> str:
-    """
-    Fill the model endpoint uid field in the model endpoint object and returns it.
-    The uid is generated by hashing the following model endpoint fields:
-    - name
-    - model_tag
-    - function_name
-    - project
-    - created_time
-    """
-
-    name = model_endpoint.metadata.name
-    model_tag = model_endpoint.spec.model_tag
-    function_name = model_endpoint.spec.function_name
-    project = model_endpoint.metadata.project
-    created_time = (
-        created_time
-        if isinstance(created_time, str)
-        else created_time.isoformat(sep=" ", timespec="microseconds")
-    )
-
-    unique_string = f"{name}_{model_tag}_{function_name}_{project}_{created_time}"
-    uid = hashlib.sha1(unique_string.encode("utf-8")).hexdigest()
-    model_endpoint.metadata.uid = uid
-    return uid
-
-
 def retry_until_successful(
     backoff: int, timeout: int, logger, verbose: bool, _function, *args, **kwargs
 ):
@@ -1886,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/notifications/notification/mail.py

@@ -13,7 +13,8 @@
 # limitations under the License.
 import re
 import typing
-from email.message import EmailMessage
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
 
 import aiosmtplib
 
@@ -69,8 +70,19 @@ class MailNotification(base.NotificationBase):
         alert: typing.Optional[mlrun.common.schemas.AlertConfig] = None,
         event_data: typing.Optional[mlrun.common.schemas.Event] = None,
     ):
-        self.params.setdefault("subject", f"[{severity}] {message}")
-        self.params.setdefault("body", message)
+        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
@@ -84,13 +96,28 @@ class MailNotification(base.NotificationBase):
         params.setdefault("server_port", DEFAULT_SMTP_PORT)
 
         default_mail_address = params.pop("default_email_addresses", "")
-        email_addresses = params.get("email_addresses", default_mail_address)
-        if isinstance(email_addresses, list):
-            email_addresses = ",".join(email_addresses)
-        params["email_addresses"] = 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"])
@@ -130,11 +157,11 @@ class MailNotification(base.NotificationBase):
         **kwargs,
     ):
         # Create the email message
-        message = EmailMessage()
+        message = MIMEMultipart("alternative")
         message["From"] = sender_address
         message["To"] = email_addresses
         message["Subject"] = subject
-        message.set_content(body)
+        message.attach(MIMEText(body, "html"))
 
         # Send the email
         await aiosmtplib.send(

mlrun/utils/notifications/notification_pusher.py

@@ -21,7 +21,7 @@ import typing
 from concurrent.futures import ThreadPoolExecutor
 
 import mlrun.common.constants as mlrun_constants
-import mlrun.common.runtimes.constants
+import mlrun.common.runtimes.constants as runtimes_constants
 import mlrun.common.schemas
 import mlrun.config
 import mlrun.db.base
@@ -118,21 +118,37 @@ class NotificationPusher(_NotificationPusherBase):
         ] = []
 
         for run in self._runs:
-            if isinstance(run, dict):
-                run = mlrun.model.RunObject.from_dict(run)
+            try:
+                self._process_run(run)
+            except Exception as exc:
+                logger.warning(
+                    "Failed to process run",
+                    run_uid=run.metadata.uid,
+                    error=mlrun.errors.err_to_str(exc),
+                )
 
-            for notification in run.spec.notifications:
-                try:
-                    notification.status = run.status.notifications.get(
-                        notification.name
-                    ).get("status", mlrun.common.schemas.NotificationStatus.PENDING)
-                except (AttributeError, KeyError):
-                    notification.status = (
-                        mlrun.common.schemas.NotificationStatus.PENDING
-                    )
+    def _process_run(self, run):
+        if isinstance(run, dict):
+            run = mlrun.model.RunObject.from_dict(run)
 
-                if self._should_notify(run, notification):
-                    self._load_notification(run, notification)
+        for notification in run.spec.notifications:
+            try:
+                self._process_notification(notification, run)
+            except Exception as exc:
+                logger.warning(
+                    "Failed to process notification",
+                    run_uid=run.metadata.uid,
+                    notification=notification,
+                    error=mlrun.errors.err_to_str(exc),
+                )
+
+    def _process_notification(self, notification, run):
+        notification.status = run.status.notifications.get(notification.name, {}).get(
+            "status",
+            mlrun.common.schemas.NotificationStatus.PENDING,
+        )
+        if self._should_notify(run, notification):
+            self._load_notification(run, notification)
 
     def push(self):
         """
@@ -176,6 +192,11 @@ 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(
@@ -205,7 +226,7 @@ class NotificationPusher(_NotificationPusherBase):
         for when_state in when_states:
             if when_state == run_state:
                 if (
-                    run_state == "completed"
+                    run_state == runtimes_constants.RunStates.completed
                     and evaluate_condition_in_separate_process(
                         notification.condition,
                         context={
@@ -213,7 +234,11 @@ class NotificationPusher(_NotificationPusherBase):
                             "notification": notification.to_dict(),
                         },
                     )
-                ) or run_state in ["error", "aborted"]:
+                ) or run_state in [
+                    runtimes_constants.RunStates.error,
+                    runtimes_constants.RunStates.aborted,
+                    runtimes_constants.RunStates.running,
+                ]:
                     return True
 
         return False
@@ -420,7 +445,7 @@ class NotificationPusher(_NotificationPusherBase):
             _run["step_kind"] = _step.step_type
             if _step.skipped:
                 _run.setdefault("status", {})["state"] = (
-                    mlrun.common.runtimes.constants.RunStates.skipped
+                    runtimes_constants.RunStates.skipped
                 )
             steps.append(_run)
 
@@ -447,7 +472,7 @@ class NotificationPusher(_NotificationPusherBase):
                 if _step.skipped:
                     state = mlrun.common.schemas.FunctionState.skipped
                 else:
-                    state = mlrun.common.runtimes.constants.PodPhases.pod_phase_to_run_state(
+                    state = runtimes_constants.PodPhases.pod_phase_to_run_state(
                         pod_phase
                     )
                 function["status"] = {"state": state}

mlrun/utils/version/version.json

@@ -1,4 +1,4 @@
 {
-  "git_commit": "ae4d3819d9263a61389338d8d2c57c4ea3d65b6b",
-  "version": "1.8.0-rc4"
+  "git_commit": "052529570e5bbae67e99d98a89713d70c6751607",
+  "version": "1.8.0-rc7"
 }

{mlrun-1.8.0rc4.dist-info → mlrun-1.8.0rc7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mlrun
-Version: 1.8.0rc4
+Version: 1.8.0rc7
 Summary: Tracking and config of machine learning runs
 Home-page: https://github.com/mlrun/mlrun
 Author: Yaron Haviv
@@ -32,13 +32,14 @@ Requires-Dist: nuclio-jupyter~=0.11.1
 Requires-Dist: numpy<1.27.0,>=1.26.4
 Requires-Dist: pandas<2.2,>=1.2
 Requires-Dist: pyarrow<18,>=10.0
-Requires-Dist: pyyaml<7,>=5.4.1
+Requires-Dist: pyyaml<7,>=6.0.2
 Requires-Dist: requests~=2.32
 Requires-Dist: tabulate~=0.8.6
 Requires-Dist: v3io~=0.6.9
 Requires-Dist: pydantic>=1.10.15
 Requires-Dist: mergedeep~=1.3
-Requires-Dist: v3io-frames~=0.10.14
+Requires-Dist: v3io-frames~=0.10.14; python_version < "3.11"
+Requires-Dist: v3io-frames!=0.11.*,!=0.12.*,>=0.10.14; python_version >= "3.11"
 Requires-Dist: semver~=3.0
 Requires-Dist: dependency-injector~=4.41
 Requires-Dist: fsspec<2024.7,>=2023.9.2
@@ -51,7 +52,7 @@ Requires-Dist: deprecated~=1.2
 Requires-Dist: jinja2>=3.1.3,~=3.1
 Requires-Dist: orjson<4,>=3.9.15
 Requires-Dist: mlrun-pipelines-kfp-common~=0.2.3
-Requires-Dist: mlrun-pipelines-kfp-v1-8~=0.2.2
+Requires-Dist: mlrun-pipelines-kfp-v1-8~=0.2.3; python_version < "3.11"
 Requires-Dist: docstring_parser~=0.16
 Requires-Dist: aiosmtplib~=3.0
 Provides-Extra: s3