mlrun 1.8.0rc5__py3-none-any.whl → 1.8.0rc9__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)"""
@@ -198,13 +197,15 @@ class V2ModelServer(StepToDict):
             extra dataitems dictionary
 
         """
-        model_file, self.model_spec, extra_dataitems = mlrun.artifacts.get_model(
-            self.model_path, suffix
-        )
-        if self.model_spec and self.model_spec.parameters:
-            for key, value in self.model_spec.parameters.items():
-                self._params[key] = value
-        return model_file, extra_dataitems
+        if self.model_path:
+            model_file, self.model_spec, extra_dataitems = mlrun.artifacts.get_model(
+                self.model_path, suffix
+            )
+            if self.model_spec and self.model_spec.parameters:
+                for key, value in self.model_spec.parameters.items():
+                    self._params[key] = value
+            return model_file, extra_dataitems
+        return None, None
 
     def load(self):
         """model loading function, see also .get_model() method"""
@@ -474,7 +475,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 +497,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 +569,24 @@ 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()
+    if model.model_spec:
+        model_name = model.model_spec.metadata.key
+        model_uid = model.model_spec.metadata.uid
+        model_tag = model.model_spec.tag
+        model_labels = model.model_spec.labels  # todo : check if we still need this
+    else:
+        model_name = None
+        model_uid = None
+        model_tag = None
+        model_labels = {}
     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,
+            function_tag=graph_server.function_tag or "latest",
         )
     except mlrun.errors.MLRunNotFoundError:
         model_ep = None
@@ -596,62 +596,88 @@ 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_tag=graph_server.function_tag or "latest",
+            function_uid=function_uid,
+            model_name=model_name,
+            model_uid=model_uid,
+            model_class=model.__class__.__name__,
+            model_tag=model_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_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_name,
+                model_uid=model_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(),
-        )
+        model_ep = 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_name != model_ep.spec.model_name:
+            attributes[ModelEndpointSchema.MODEL_NAME] = model_name
+        if model_uid != model_ep.spec.model_uid:
+            attributes[ModelEndpointSchema.MODEL_UID] = model_uid
+        if model_tag != model_ep.spec.model_tag:
+            attributes[ModelEndpointSchema.MODEL_TAG] = model_tag
+        if model_labels != model_ep.metadata.labels:
+            attributes[ModelEndpointSchema.LABELS] = model_labels
+        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,
+                endpoint_id=model_ep.metadata.uid,
+                attributes=attributes,
+            )
+    else:
+        return None
 
-    return uid
+    return model_ep.metadata.uid

mlrun/utils/helpers.py

@@ -670,8 +670,8 @@ def dict_to_json(struct):
 
 def parse_artifact_uri(uri, default_project=""):
     """
-    Parse artifact URI into project, key, tag, iter, tree
-    URI format: [<project>/]<key>[#<iter>][:<tag>][@<tree>]
+    Parse artifact URI into project, key, tag, iter, tree, uid
+    URI format: [<project>/]<key>[#<iter>][:<tag>][@<tree>][^<uid>]
 
     :param uri:            uri to parse
     :param default_project: default project name if not in URI
@@ -681,6 +681,7 @@ def parse_artifact_uri(uri, default_project=""):
         [2] = iteration
         [3] = tag
         [4] = tree
+        [5] = uid
     """
     uri_pattern = mlrun.utils.regex.artifact_uri_pattern
     match = re.match(uri_pattern, uri)
@@ -705,6 +706,7 @@ def parse_artifact_uri(uri, default_project=""):
         iteration,
         group_dict["tag"],
         group_dict["tree"],
+        group_dict["uid"],
     )
 
 
@@ -719,7 +721,9 @@ def generate_object_uri(project, name, tag=None, hash_key=None):
     return uri
 
 
-def generate_artifact_uri(project, key, tag=None, iter=None, tree=None):
+def generate_artifact_uri(
+    project, key, tag=None, iter=None, tree=None, uid=None
+) -> str:
     artifact_uri = f"{project}/{key}"
     if iter is not None:
         artifact_uri = f"{artifact_uri}#{iter}"
@@ -727,6 +731,8 @@ def generate_artifact_uri(project, key, tag=None, iter=None, tree=None):
         artifact_uri = f"{artifact_uri}:{tag}"
     if tree is not None:
         artifact_uri = f"{artifact_uri}@{tree}"
+    if uid is not None:
+        artifact_uri = f"{artifact_uri}^{uid}"
     return artifact_uri
 
 
@@ -956,36 +962,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 +1862,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,9 +70,19 @@ class MailNotification(base.NotificationBase):
         alert: typing.Optional[mlrun.common.schemas.AlertConfig] = None,
         event_data: typing.Optional[mlrun.common.schemas.Event] = None,
     ):
-        message = self.params.get("message", message)
-        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
@@ -146,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
@@ -226,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={
@@ -234,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
@@ -441,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)
 
@@ -468,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/regex.py

@@ -96,7 +96,14 @@ v3io_stream_consumer_group = [r"^(?!_)[a-zA-Z0-9_]{1,256}$"]
 # URI patterns
 run_uri_pattern = r"^(?P<project>.*)@(?P<uid>.*)\#(?P<iteration>.*?)(:(?P<tag>.*))?$"
 
-artifact_uri_pattern = r"^((?P<project>.*)/)?(?P<key>.*?)(\#(?P<iteration>.*?))?(:(?P<tag>.*?))?(@(?P<tree>.*))?$"
+artifact_uri_pattern = (
+    r"^((?P<project>.*)/)?"  # Optional project
+    r"(?P<key>.*?)"  # Key
+    r"(\#(?P<iteration>.*?))?"  # Optional iteration
+    r"(:(?P<tag>.*?))?"  # Optional tag
+    r"(@(?P<tree>.*?))?"  # Optional tree
+    r"(\^(?P<uid>.*))?$"  # Optional uid
+)
 
 artifact_producer_uri_pattern = (
     r"^((?P<project>.*)/)?(?P<uid>.*?)(\-(?P<iteration>.*?))?$"

mlrun/utils/version/version.json

@@ -1,4 +1,4 @@
 {
-  "git_commit": "cb94f845e0a3601e06c7e22381391d82bb386160",
-  "version": "1.8.0-rc5"
+  "git_commit": "5be219a3a066786e96ee697c208cd0f59ef63362",
+  "version": "1.8.0-rc9"
 }

{mlrun-1.8.0rc5.dist-info → mlrun-1.8.0rc9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mlrun
-Version: 1.8.0rc5
+Version: 1.8.0rc9
 Summary: Tracking and config of machine learning runs
 Home-page: https://github.com/mlrun/mlrun
 Author: Yaron Haviv
@@ -52,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; python_version < "3.11"
+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