mlrun 1.6.4rc7__py3-none-any.whl → 1.7.0__py3-none-any.whl

mlrun/model.py

@@ -22,18 +22,19 @@ from collections import OrderedDict
 from copy import deepcopy
 from datetime import datetime
 from os import environ
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Optional, Union
 
 import pydantic.error_wrappers
 
 import mlrun
+import mlrun.common.constants as mlrun_constants
 import mlrun.common.schemas.notification
+import mlrun.utils.regex
 
 from .utils import (
     dict_to_json,
     dict_to_yaml,
     get_artifact_target,
-    is_legacy_artifact,
     logger,
     template_artifact_path,
 )
@@ -44,6 +45,15 @@ RUN_ID_PLACE_HOLDER = "{run_id}"  # IMPORTANT: shouldn't be changed.
 
 class ModelObj:
     _dict_fields = []
+    # Bellow attributes are used in to_dict method
+    # Fields to strip from the object by default if strip=True
+    _default_fields_to_strip = []
+    # Fields that will be serialized by the object's _serialize_field method
+    _fields_to_serialize = []
+    # Fields that will be enriched by the object's _enrich_field method
+    _fields_to_enrich = []
+    # Fields that will be ignored by the object's _is_valid_field_value_for_serialization method
+    _fields_to_skip_validation = []
 
     @staticmethod
     def _verify_list(param, name):
@@ -63,26 +73,145 @@ class ModelObj:
         return param
 
     @mlrun.utils.filter_warnings("ignore", FutureWarning)
-    def to_dict(self, fields=None, exclude=None):
-        """convert the object to a python dictionary
+    def to_dict(
+        self, fields: list = None, exclude: list = None, strip: bool = False
+    ) -> dict:
+        """
+        Convert the object to a dict
+
+        :param fields:  A list of fields to include in the dictionary. If not provided, the default value is taken
+            from `self._dict_fields` or from the object __init__ params.
+        :param exclude: A list of fields to exclude from the dictionary.
+        :param strip:  If True, the object's `_default_fields_to_strip` attribute is appended to the exclude list.
+            Strip purpose is to remove fields that are context / environment specific and not required for actually
+            define the object.
 
-        :param fields:  list of fields to include in the dict
-        :param exclude: list of fields to exclude from the dict
+        :return: A dictionary representation of the object.
         """
         struct = {}
-        fields = fields or self._dict_fields
-        if not fields:
-            fields = list(inspect.signature(self.__init__).parameters.keys())
-        for t in fields:
-            if not exclude or t not in exclude:
-                val = getattr(self, t, None)
-                if val is not None and not (isinstance(val, dict) and not val):
-                    if hasattr(val, "to_dict"):
-                        val = val.to_dict()
-                        if val:
-                            struct[t] = val
-                    else:
-                        struct[t] = val
+
+        fields = self._resolve_initial_to_dict_fields(fields)
+        fields_to_exclude = exclude or []
+        if strip:
+            fields_to_exclude += self._default_fields_to_strip
+
+        # fields_to_save is built from the fields list minus the fields to exclude minus the fields that requires
+        # serialization and enrichment (because they will be added later to the struct)
+        fields_to_save = (
+            set(fields)
+            - set(fields_to_exclude)
+            - set(self._fields_to_serialize)
+            - set(self._fields_to_enrich)
+        )
+
+        # Iterating over the fields to save and adding them to the struct
+        for field_name in fields_to_save:
+            field_value = getattr(self, field_name, None)
+            if self._is_valid_field_value_for_serialization(
+                field_name, field_value, strip
+            ):
+                # If the field value has attribute to_dict, we call it.
+                # If one of the attributes is a third party object that has to_dict method (such as k8s objects), then
+                # add it to the object's _fields_to_serialize attribute and handle it in the _serialize_field method.
+                if hasattr(field_value, "to_dict"):
+                    field_value = field_value.to_dict(strip=strip)
+                    if self._is_valid_field_value_for_serialization(
+                        field_name, field_value, strip
+                    ):
+                        struct[field_name] = field_value
+                else:
+                    struct[field_name] = field_value
+
+        # Subtracting the fields_to_exclude from the fields_to_serialize because if we want to exclude a field there
+        # is no need to serialize it.
+        fields_to_serialize = list(
+            set(self._fields_to_serialize) - set(fields_to_exclude)
+        )
+        self._resolve_field_value_by_method(
+            struct, self._serialize_field, fields_to_serialize, strip
+        )
+
+        # Subtracting the fields_to_exclude from the fields_to_enrich because if we want to exclude a field there
+        # is no need to enrich it.
+        fields_to_enrich = list(set(self._fields_to_enrich) - set(fields_to_exclude))
+        self._resolve_field_value_by_method(
+            struct, self._enrich_field, fields_to_enrich, strip
+        )
+
+        self._apply_enrichment_before_to_dict_completion(struct, strip=strip)
+        return struct
+
+    def _resolve_initial_to_dict_fields(self, fields: list = None) -> list:
+        """
+        Resolve fields to be used in to_dict method.
+        If fields is None, use `_dict_fields` attribute of the object.
+        If fields is None and `_dict_fields` is empty, use the object's __init__ parameters.
+        :param fields: List of fields to iterate over.
+
+        :return: List of fields to iterate over.
+        """
+        return (
+            fields
+            or self._dict_fields
+            or list(inspect.signature(self.__init__).parameters.keys())
+        )
+
+    def _is_valid_field_value_for_serialization(
+        self, field_name: str, field_value: str, strip: bool = False
+    ) -> bool:
+        """
+        Check if the field value is valid for serialization.
+        If field name is in `_fields_to_skip_validation` attribute, skip validation and return True.
+        If strip is False skip validation and return True.
+        If field value is None or empty dict/list, then no need to store it.
+        :param field_name:  Field name.
+        :param field_value: Field value.
+
+        :return: True if the field value is valid for serialization, False otherwise.
+        """
+        if field_name in self._fields_to_skip_validation:
+            return True
+        # TODO: remove when Runtime initialization will be refactored and enrichment will be moved to BE
+        # if not strip:
+        #     return True
+
+        return field_value is not None and not (
+            (isinstance(field_value, dict) or isinstance(field_value, list))
+            and not field_value
+        )
+
+    def _resolve_field_value_by_method(
+        self,
+        struct: dict,
+        method: typing.Callable,
+        fields: typing.Union[list, set] = None,
+        strip: bool = False,
+    ) -> dict:
+        for field_name in fields:
+            field_value = method(struct=struct, field_name=field_name, strip=strip)
+            if self._is_valid_field_value_for_serialization(
+                field_name, field_value, strip
+            ):
+                struct[field_name] = field_value
+        return struct
+
+    def _serialize_field(
+        self, struct: dict, field_name: str = None, strip: bool = False
+    ) -> typing.Any:
+        # We pull the field from self and not from struct because it was excluded from the struct when looping over
+        # the fields to save.
+        return getattr(self, field_name, None)
+
+    def _enrich_field(
+        self, struct: dict, field_name: str = None, strip: bool = False
+    ) -> typing.Any:
+        # We first try to pull from struct because the field might have been already serialized and if not,
+        # we pull from self
+        return struct.get(field_name, None) or getattr(self, field_name, None)
+
+    def _apply_enrichment_before_to_dict_completion(
+        self, struct: dict, strip: bool = False
+    ) -> dict:
         return struct
 
     @classmethod
@@ -111,19 +240,21 @@ class ModelObj:
 
         return new_obj
 
-    def to_yaml(self, exclude=None) -> str:
+    def to_yaml(self, exclude=None, strip: bool = False) -> str:
         """convert the object to yaml
 
         :param exclude: list of fields to exclude from the yaml
+        :param strip:   if True, strip fields that are not required for actually define the object
         """
-        return dict_to_yaml(self.to_dict(exclude=exclude))
+        return dict_to_yaml(self.to_dict(exclude=exclude, strip=strip))
 
-    def to_json(self, exclude=None):
+    def to_json(self, exclude=None, strip: bool = False):
         """convert the object to json
 
         :param exclude: list of fields to exclude from the json
+        :param strip:   if True, strip fields that are not required for actually define the object
         """
-        return dict_to_json(self.to_dict(exclude=exclude))
+        return dict_to_json(self.to_dict(exclude=exclude, strip=strip))
 
     def to_str(self):
         """convert the object to string (with dict layout)"""
@@ -175,8 +306,8 @@ class ObjectDict:
         self._children[key] = child
         return child
 
-    def to_dict(self):
-        return {k: v.to_dict() for k, v in self._children.items()}
+    def to_dict(self, strip: bool = False):
+        return {k: v.to_dict(strip=strip) for k, v in self._children.items()}
 
     @classmethod
     def from_dict(cls, classes_map: dict, children=None, default_kind=""):
@@ -258,9 +389,9 @@ class ObjectList:
     def __delitem__(self, key):
         del self._children[key]
 
-    def to_dict(self):
+    def to_dict(self, strip: bool = False):
         # method used by ModelObj class to serialize the object to nested dict
-        return [t.to_dict() for t in self._children.values()]
+        return [t.to_dict(strip=strip) for t in self._children.values()]
 
     @classmethod
     def from_list(cls, child_class, children=None):
@@ -305,6 +436,18 @@ class Credentials(ModelObj):
 
 
 class BaseMetadata(ModelObj):
+    _default_fields_to_strip = ModelObj._default_fields_to_strip + [
+        "hash",
+        # Below are environment specific fields, no need to keep when stripping
+        "namespace",
+        "project",
+        "labels",
+        "annotations",
+        "credentials",
+        # Below are state fields, no need to keep when stripping
+        "updated",
+    ]
+
     def __init__(
         self,
         name=None,
@@ -344,7 +487,7 @@ class ImageBuilder(ModelObj):
 
     def __init__(
         self,
-        functionSourceCode=None,
+        functionSourceCode=None,  # noqa: N803 - should be "snake_case", kept for BC
         source=None,
         image=None,
         base_image=None,
@@ -449,7 +592,7 @@ class ImageBuilder(ModelObj):
 
     def with_commands(
         self,
-        commands: List[str],
+        commands: list[str],
         overwrite: bool = False,
     ):
         """add commands to build spec.
@@ -476,7 +619,7 @@ class ImageBuilder(ModelObj):
 
     def with_requirements(
         self,
-        requirements: Optional[List[str]] = None,
+        requirements: Optional[list[str]] = None,
         requirements_file: str = "",
         overwrite: bool = False,
     ):
@@ -509,7 +652,7 @@ class ImageBuilder(ModelObj):
 
         # handle the requirements_file argument
         if requirements_file:
-            with open(requirements_file, "r") as fp:
+            with open(requirements_file) as fp:
                 requirements_to_resolve.extend(fp.read().splitlines())
 
         # handle the requirements argument
@@ -536,14 +679,36 @@ class ImageBuilder(ModelObj):
 
 
 class Notification(ModelObj):
-    """Notification specification"""
+    """Notification object
+
+    :param kind: notification implementation kind - slack, webhook, etc. See
+        :py:class:`mlrun.common.schemas.notification.NotificationKind`
+    :param name: for logging and identification
+    :param message: message content in the notification
+    :param severity: severity to display in the notification
+    :param when: list of statuses to trigger the notification: 'running', 'completed', 'error'
+    :param condition: optional condition to trigger the notification, a jinja2 expression that can use run data
+                      to evaluate if the notification should be sent in addition to the 'when' statuses.
+                      e.g.: '{{ run["status"]["results"]["accuracy"] < 0.9}}'
+    :param params: Implementation specific parameters for the notification implementation (e.g. slack webhook url,
+                   git repository details, etc.)
+    :param secret_params: secret parameters for the notification implementation, same as params but will be stored
+                          in a k8s secret and passed as a secret reference to the implementation.
+    :param status: notification status - pending, sent, error
+    :param sent_time: time the notification was sent
+    :param reason: failure reason if the notification failed to send
+    """
 
     def __init__(
         self,
-        kind=None,
+        kind: mlrun.common.schemas.notification.NotificationKind = (
+            mlrun.common.schemas.notification.NotificationKind.slack
+        ),
         name=None,
         message=None,
-        severity=None,
+        severity: mlrun.common.schemas.notification.NotificationSeverity = (
+            mlrun.common.schemas.notification.NotificationSeverity.INFO
+        ),
         when=None,
         condition=None,
         secret_params=None,
@@ -552,12 +717,10 @@ class Notification(ModelObj):
         sent_time=None,
         reason=None,
     ):
-        self.kind = kind or mlrun.common.schemas.notification.NotificationKind.slack
+        self.kind = kind
         self.name = name or ""
         self.message = message or ""
-        self.severity = (
-            severity or mlrun.common.schemas.notification.NotificationSeverity.INFO
-        )
+        self.severity = severity
         self.when = when or ["completed"]
         self.condition = condition or ""
         self.secret_params = secret_params or {}
@@ -587,8 +750,49 @@ class Notification(ModelObj):
                 "Notification params size exceeds max size of 1 MB"
             )
 
+    def validate_notification_params(self):
+        notification_class = mlrun.utils.notifications.NotificationTypes(
+            self.kind
+        ).get_notification()
+
+        secret_params = self.secret_params or {}
+        params = self.params or {}
+
+        # if the secret_params are already masked - no need to validate
+        params_secret = secret_params.get("secret", "")
+        if params_secret:
+            if len(secret_params) > 1:
+                raise mlrun.errors.MLRunInvalidArgumentError(
+                    "When the 'secret' key is present, 'secret_params' should not contain any other keys."
+                )
+            return
+
+        if not secret_params and not params:
+            raise mlrun.errors.MLRunInvalidArgumentError(
+                "Both 'secret_params' and 'params' are empty, at least one must be defined."
+            )
+
+        notification_class.validate_params(secret_params | params)
+
+    def enrich_unmasked_secret_params_from_project_secret(self):
+        """
+        Fill the notification secret params from the project secret.
+        We are using this function instead of unmask_secret_params_from_project_secret when we run inside the
+        workflow runner pod that doesn't have access to the k8s secrets (but have access to the project secret)
+        """
+        secret = self.secret_params.get("secret")
+        if secret:
+            secret_value = mlrun.get_secret_or_env(secret)
+            if secret_value:
+                try:
+                    self.secret_params = json.loads(secret_value)
+                except ValueError as exc:
+                    raise mlrun.errors.MLRunValueError(
+                        "Failed to parse secret value"
+                    ) from exc
+
     @staticmethod
-    def validate_notification_uniqueness(notifications: List["Notification"]):
+    def validate_notification_uniqueness(notifications: list["Notification"]):
         """Validate that all notifications in the list are unique by name"""
         names = [notification.name for notification in notifications]
         if len(names) != len(set(names)):
@@ -627,7 +831,10 @@ class RunMetadata(ModelObj):
     def is_workflow_runner(self):
         if not self.labels:
             return False
-        return self.labels.get("job-type", "") == "workflow-runner"
+        return (
+            self.labels.get(mlrun_constants.MLRunInternalLabels.job_type, "")
+            == "workflow-runner"
+        )
 
 
 class HyperParamStrategies:
@@ -697,6 +904,10 @@ class HyperParamOptions(ModelObj):
 class RunSpec(ModelObj):
     """Run specification"""
 
+    _fields_to_serialize = ModelObj._fields_to_serialize + [
+        "handler",
+    ]
+
     def __init__(
         self,
         parameters=None,
@@ -720,6 +931,8 @@ class RunSpec(ModelObj):
         returns=None,
         notifications=None,
         state_thresholds=None,
+        reset_on_run=None,
+        node_selector=None,
     ):
         # A dictionary of parsing configurations that will be read from the inputs the user set. The keys are the inputs
         # keys (parameter names) and the values are the type hint given in the input keys after the colon.
@@ -756,19 +969,25 @@ class RunSpec(ModelObj):
         self.allow_empty_resources = allow_empty_resources
         self._notifications = notifications or []
         self.state_thresholds = state_thresholds or {}
-
-    def to_dict(self, fields=None, exclude=None):
-        struct = super().to_dict(fields, exclude=["handler"])
-        if self.handler and isinstance(self.handler, str):
-            struct["handler"] = self.handler
-        return struct
+        self.reset_on_run = reset_on_run
+        self.node_selector = node_selector or {}
+
+    def _serialize_field(
+        self, struct: dict, field_name: str = None, strip: bool = False
+    ) -> Optional[str]:
+        # We pull the field from self and not from struct because it was excluded from the struct
+        if field_name == "handler":
+            if self.handler and isinstance(self.handler, str):
+                return self.handler
+            return None
+        return super()._serialize_field(struct, field_name, strip)
 
     def is_hyper_job(self):
         param_file = self.param_file or self.hyper_param_options.param_file
         return param_file or self.hyperparams
 
     @property
-    def inputs(self) -> Dict[str, str]:
+    def inputs(self) -> dict[str, str]:
         """
         Get the inputs dictionary. A dictionary of parameter names as keys and paths as values.
 
@@ -777,7 +996,7 @@ class RunSpec(ModelObj):
         return self._inputs
 
     @inputs.setter
-    def inputs(self, inputs: Dict[str, str]):
+    def inputs(self, inputs: dict[str, str]):
         """
         Set the given inputs in the spec. Inputs can include a type hint string in their keys following a colon, meaning
         following this structure: "<input key : type hint>".
@@ -786,7 +1005,7 @@ class RunSpec(ModelObj):
 
         >>> run_spec.inputs = {
         ...     "my_input": "...",
-        ...     "my_hinted_input : pandas.DataFrame": "..."
+        ...     "my_hinted_input : pandas.DataFrame": "...",
         ... }
 
         :param inputs: The inputs to set.
@@ -800,7 +1019,7 @@ class RunSpec(ModelObj):
         self._inputs = self._verify_dict(inputs, "inputs")
 
     @property
-    def inputs_type_hints(self) -> Dict[str, str]:
+    def inputs_type_hints(self) -> dict[str, str]:
         """
         Get the input type hints. A dictionary of parameter names as keys and their type hints as values.
 
@@ -809,7 +1028,7 @@ class RunSpec(ModelObj):
         return self._inputs_type_hints
 
     @inputs_type_hints.setter
-    def inputs_type_hints(self, inputs_type_hints: Dict[str, str]):
+    def inputs_type_hints(self, inputs_type_hints: dict[str, str]):
         """
         Set the inputs type hints to parse during a run.
 
@@ -830,7 +1049,7 @@ class RunSpec(ModelObj):
         return self._returns
 
     @returns.setter
-    def returns(self, returns: List[Union[str, Dict[str, str]]]):
+    def returns(self, returns: list[Union[str, dict[str, str]]]):
         """
         Set the returns list to log the returning values at the end of a run.
 
@@ -864,7 +1083,7 @@ class RunSpec(ModelObj):
         )
 
     @property
-    def outputs(self) -> List[str]:
+    def outputs(self) -> list[str]:
         """
         Get the expected outputs. The list is constructed from keys of both the `outputs` and `returns` properties.
 
@@ -929,7 +1148,7 @@ class RunSpec(ModelObj):
         return self._state_thresholds
 
     @state_thresholds.setter
-    def state_thresholds(self, state_thresholds: Dict[str, str]):
+    def state_thresholds(self, state_thresholds: dict[str, str]):
         """
         Set the dictionary of k8s resource states to thresholds time strings.
         The state will be matched against the pod's status. The threshold should be a time string that conforms
@@ -981,8 +1200,8 @@ class RunSpec(ModelObj):
 
     @staticmethod
     def join_outputs_and_returns(
-        outputs: List[str], returns: List[Union[str, Dict[str, str]]]
-    ) -> List[str]:
+        outputs: list[str], returns: list[Union[str, dict[str, str]]]
+    ) -> list[str]:
         """
         Get the outputs set in the spec. The outputs are constructed from both the 'outputs' and 'returns' properties
         that were set by the user.
@@ -1013,7 +1232,7 @@ class RunSpec(ModelObj):
         return outputs
 
     @staticmethod
-    def _separate_type_hint_from_input_key(input_key: str) -> Tuple[str, str]:
+    def _separate_type_hint_from_input_key(input_key: str) -> tuple[str, str]:
         """
         An input key in the `inputs` dictionary parameter of a task (or `Runtime.run` method) or the docs setting of a
         `Runtime` handler can be provided with a colon to specify its type hint in the following structure:
@@ -1057,7 +1276,7 @@ class RunStatus(ModelObj):
         iterations=None,
         ui_url=None,
         reason: str = None,
-        notifications: Dict[str, Notification] = None,
+        notifications: dict[str, Notification] = None,
         artifact_uris: dict[str, str] = None,
     ):
         self.state = state or "created"
@@ -1127,7 +1346,7 @@ class RunTemplate(ModelObj):
 
             task.with_input("data", "/file-dir/path/to/file")
             task.with_input("data", "s3://<bucket>/path/to/file")
-            task.with_input("data", "v3io://[<remote-host>]/<data-container>/path/to/file")
+            task.with_input("data", "v3io://<data-container>/path/to/file")
         """
         if not self.spec.inputs:
             self.spec.inputs = {}
@@ -1146,7 +1365,7 @@ class RunTemplate(ModelObj):
 
         example::
 
-            grid_params = {"p1": [2,4,1], "p2": [10,20]}
+            grid_params = {"p1": [2, 4, 1], "p2": [10, 20]}
             task = mlrun.new_task("grid-search")
             task.with_hyper_params(grid_params, selector="max.accuracy")
         """
@@ -1284,33 +1503,63 @@ class RunObject(RunTemplate):
     @property
     def error(self) -> str:
         """error string if failed"""
-        if self.status:
+        if (
+            self.status
+            and self.status.state
+            in mlrun.common.runtimes.constants.RunStates.error_and_abortion_states()
+        ):
             unknown_error = ""
             if (
                 self.status.state
-                in mlrun.runtimes.constants.RunStates.abortion_states()
+                in mlrun.common.runtimes.constants.RunStates.abortion_states()
             ):
                 unknown_error = "Run was aborted"
 
-            elif self.status.state in mlrun.runtimes.constants.RunStates.error_states():
+            elif (
+                self.status.state
+                in mlrun.common.runtimes.constants.RunStates.error_states()
+            ):
                 unknown_error = "Unknown error"
 
             return (
                 self.status.error
-                or self.status.reason
                 or self.status.status_text
+                or self.status.reason
                 or unknown_error
             )
         return ""
 
-    def output(self, key):
-        """return the value of a specific result or artifact by key"""
+    def output(self, key: str):
+        """
+        Return the value of a specific result or artifact by key.
+
+        This method waits for the outputs to complete and retrieves the value corresponding to the provided key.
+        If the key exists in the results, it returns the corresponding result value.
+        If not found in results, it attempts to fetch the artifact by key (cached in the run status).
+        If the artifact is not found, it tries to fetch the artifact URI by key.
+        If no artifact or result is found for the key, returns None.
+
+        :param key: The key of the result or artifact to retrieve.
+        :return: The value of the result or the artifact URI corresponding to the key, or None if not found.
+        """
         self._outputs_wait_for_completion()
+
+        # Check if the key exists in results and return the result value
         if self.status.results and key in self.status.results:
-            return self.status.results.get(key)
+            return self.status.results[key]
+
+        # Artifacts are usually cached in the run object under `status.artifacts`. However, the artifacts are not
+        # stored in the DB as part of the run. The server may enrich the run with the artifacts or provide
+        # `status.artifact_uris` instead. See mlrun.common.formatters.run.RunFormat.
+        # When running locally - `status.artifact_uri` does not exist in the run.
+        # When listing runs - `status.artifacts` does not exist in the run.
         artifact = self._artifact(key)
         if artifact:
             return get_artifact_target(artifact, self.metadata.project)
+
+        if self.status.artifact_uris and key in self.status.artifact_uris:
+            return self.status.artifact_uris[key]
+
         return None
 
     @property
@@ -1318,31 +1567,55 @@ class RunObject(RunTemplate):
         """UI URL (for relevant runtimes)"""
         self.refresh()
         if not self._status.ui_url:
-            print("UI currently not available (status={})".format(self._status.state))
+            print(f"UI currently not available (status={self._status.state})")
         return self._status.ui_url
 
     @property
     def outputs(self):
-        """return a dict of outputs, result values and artifact uris"""
-        outputs = {}
+        """
+        Return a dictionary of outputs, including result values and artifact URIs.
+
+        This method waits for the outputs to complete and combines result values
+        and artifact URIs into a single dictionary. If there are multiple artifacts
+        for the same key, only include the artifact that does not have the "latest" tag.
+        If there is no other tag, include the "latest" tag as a fallback.
+
+        :return: Dictionary containing result values and artifact URIs.
+        """
         self._outputs_wait_for_completion()
+        outputs = {}
+
+        # Add results if available
         if self.status.results:
-            outputs = {k: v for k, v in self.status.results.items()}
+            outputs.update(self.status.results)
+
+        # Artifacts are usually cached in the run object under `status.artifacts`. However, the artifacts are not
+        # stored in the DB as part of the run. The server may enrich the run with the artifacts or provide
+        # `status.artifact_uris` instead. See mlrun.common.formatters.run.RunFormat.
+        # When running locally - `status.artifact_uri` does not exist in the run.
+        # When listing runs - `status.artifacts` does not exist in the run.
         if self.status.artifacts:
-            for a in self.status.artifacts:
-                key = a["key"] if is_legacy_artifact(a) else a["metadata"]["key"]
-                outputs[key] = get_artifact_target(a, self.metadata.project)
+            outputs.update(self._process_artifacts(self.status.artifacts))
+        elif self.status.artifact_uris:
+            outputs.update(self.status.artifact_uris)
+
         return outputs
 
-    def artifact(self, key) -> "mlrun.DataItem":
-        """return artifact DataItem by key"""
+    def artifact(self, key: str) -> "mlrun.DataItem":
+        """Return artifact DataItem by key.
+
+        This method waits for the outputs to complete, searches for the artifact matching the given key,
+        and returns a DataItem if the artifact is found.
+
+        :param key: The key of the artifact to find.
+        :return: A DataItem corresponding to the artifact with the given key, or None if no such artifact is found.
+        """
         self._outputs_wait_for_completion()
         artifact = self._artifact(key)
-        if artifact:
-            uri = get_artifact_target(artifact, self.metadata.project)
-            if uri:
-                return mlrun.get_dataitem(uri)
-        return None
+        if not artifact:
+            return None
+        uri = get_artifact_target(artifact, self.metadata.project)
+        return mlrun.get_dataitem(uri) if uri else None
 
     def _outputs_wait_for_completion(
         self,
@@ -1360,12 +1633,85 @@ class RunObject(RunTemplate):
             )
 
     def _artifact(self, key):
-        """return artifact DataItem by key"""
-        if self.status.artifacts:
-            for a in self.status.artifacts:
-                if a["metadata"]["key"] == key:
-                    return a
-        return None
+        """
+        Return the last artifact DataItem that matches the given key.
+
+        If multiple artifacts with the same key exist, return the last one in the list.
+        If there are artifacts with different tags, the method will return the one with a tag other than 'latest'
+        if available.
+        If no artifact with the given key is found, return None.
+
+        :param key: The key of the artifact to retrieve.
+        :return: The last artifact DataItem with the given key, or None if no such artifact is found.
+        """
+        if not self.status.artifacts:
+            return None
+
+        # Collect artifacts that match the key
+        matching_artifacts = [
+            artifact
+            for artifact in self.status.artifacts
+            if artifact["metadata"].get("key") == key
+        ]
+
+        if not matching_artifacts:
+            return None
+
+        # Sort matching artifacts by creation date in ascending order.
+        # The last element in the list will be the one created most recently.
+        # In case the `created` field does not exist in the artifact, that artifact will appear first in the sorted list
+        matching_artifacts.sort(
+            key=lambda artifact: artifact["metadata"].get("created", datetime.min)
+        )
+
+        # Filter out artifacts with 'latest' tag
+        non_latest_artifacts = [
+            artifact
+            for artifact in matching_artifacts
+            if artifact["metadata"].get("tag") != "latest"
+        ]
+
+        # Return the last non-'latest' artifact if available, otherwise return the last artifact
+        # In the case of only one tag, `status.artifacts` includes [v1, latest]. In that case, we want to return v1.
+        # In the case of multiple tags, `status.artifacts` includes [v1, latest, v2, v3].
+        # In that case, we need to return the last one (v3).
+        return (non_latest_artifacts or matching_artifacts)[-1]
+
+    def _process_artifacts(self, artifacts):
+        artifacts_by_key = {}
+
+        # Organize artifacts by key
+        for artifact in artifacts:
+            key = artifact["metadata"]["key"]
+            if key not in artifacts_by_key:
+                artifacts_by_key[key] = []
+            artifacts_by_key[key].append(artifact)
+
+        outputs = {}
+        for key, artifacts in artifacts_by_key.items():
+            # Sort matching artifacts by creation date in ascending order.
+            # The last element in the list will be the one created most recently.
+            # In case the `created` field does not exist in the artifactthat artifact will appear
+            # first in the sorted list
+            artifacts.sort(
+                key=lambda artifact: artifact["metadata"].get("created", datetime.min)
+            )
+
+            # Filter out artifacts with 'latest' tag
+            non_latest_artifacts = [
+                artifact
+                for artifact in artifacts
+                if artifact["metadata"].get("tag") != "latest"
+            ]
+
+            # Save the last non-'latest' artifact if available, otherwise save the last artifact
+            # In the case of only one tag, `artifacts` includes [v1, latest], in that case, we want to save v1.
+            # In the case of multiple tags, `artifacts` includes [v1, latest, v2, v3].
+            # In that case, we need to save the last one (v3).
+            artifact_to_save = (non_latest_artifacts or artifacts)[-1]
+            outputs[key] = get_artifact_target(artifact_to_save, self.metadata.project)
+
+        return outputs
 
     def uid(self):
         """run unique id"""
@@ -1373,7 +1719,10 @@ class RunObject(RunTemplate):
 
     def state(self):
         """current run state"""
-        if self.status.state in mlrun.runtimes.constants.RunStates.terminal_states():
+        if (
+            self.status.state
+            in mlrun.common.runtimes.constants.RunStates.terminal_states()
+        ):
             return self.status.state
         self.refresh()
         return self.status.state or "unknown"
@@ -1437,7 +1786,7 @@ class RunObject(RunTemplate):
         last_pull_log_time = None
         logs_enabled = show_logs is not False
         state = self.state()
-        if state not in mlrun.runtimes.constants.RunStates.terminal_states():
+        if state not in mlrun.common.runtimes.constants.RunStates.terminal_states():
             logger.info(
                 f"run {self.metadata.name} is not completed yet, waiting for it to complete",
                 current_state=state,
@@ -1447,7 +1796,8 @@ class RunObject(RunTemplate):
             if (
                 logs_enabled
                 and logs_interval
-                and state not in mlrun.runtimes.constants.RunStates.terminal_states()
+                and state
+                not in mlrun.common.runtimes.constants.RunStates.terminal_states()
                 and (
                     last_pull_log_time is None
                     or (datetime.now() - last_pull_log_time).seconds > logs_interval
@@ -1456,7 +1806,7 @@ class RunObject(RunTemplate):
                 last_pull_log_time = datetime.now()
                 state, offset = self.logs(watch=False, offset=offset)
 
-            if state in mlrun.runtimes.constants.RunStates.terminal_states():
+            if state in mlrun.common.runtimes.constants.RunStates.terminal_states():
                 if logs_enabled and logs_interval:
                     self.logs(watch=False, offset=offset)
                 break
@@ -1468,13 +1818,21 @@ class RunObject(RunTemplate):
                 )
         if logs_enabled and not logs_interval:
             self.logs(watch=False)
-        if raise_on_failure and state != mlrun.runtimes.constants.RunStates.completed:
+        if (
+            raise_on_failure
+            and state != mlrun.common.runtimes.constants.RunStates.completed
+        ):
             raise mlrun.errors.MLRunRuntimeError(
                 f"Task {self.metadata.name} did not complete (state={state})"
             )
 
         return state
 
+    def abort(self):
+        """abort the run"""
+        db = mlrun.get_run_db()
+        db.abort_run(self.metadata.uid, self.metadata.project)
+
     @staticmethod
     def create_uri(project: str, uid: str, iteration: Union[int, str], tag: str = ""):
         if tag:
@@ -1483,10 +1841,13 @@ class RunObject(RunTemplate):
         return f"{project}@{uid}#{iteration}{tag}"
 
     @staticmethod
-    def parse_uri(uri: str) -> Tuple[str, str, str, str]:
-        uri_pattern = (
-            r"^(?P<project>.*)@(?P<uid>.*)\#(?P<iteration>.*?)(:(?P<tag>.*))?$"
-        )
+    def parse_uri(uri: str) -> tuple[str, str, str, str]:
+        """Parse the run's uri
+
+        :param uri: run uri in the format of <project>@<uid>#<iteration>[:tag]
+        :return: project, uid, iteration, tag
+        """
+        uri_pattern = mlrun.utils.regex.run_uri_pattern
         match = re.match(uri_pattern, uri)
         if not match:
             raise ValueError(
@@ -1700,11 +2061,13 @@ class DataSource(ModelObj):
     ]
     kind = None
 
+    _fields_to_serialize = ["start_time", "end_time"]
+
     def __init__(
         self,
         name: str = None,
         path: str = None,
-        attributes: Dict[str, object] = None,
+        attributes: dict[str, object] = None,
         key_field: str = None,
         time_field: str = None,
         schedule: str = None,
@@ -1728,6 +2091,16 @@ class DataSource(ModelObj):
     def set_secrets(self, secrets):
         self._secrets = secrets
 
+    def _serialize_field(
+        self, struct: dict, field_name: str = None, strip: bool = False
+    ) -> typing.Any:
+        value = super()._serialize_field(struct, field_name, strip)
+        # We pull the field from self and not from struct because it was excluded from the struct when looping over
+        # the fields to save.
+        if field_name in ("start_time", "end_time") and isinstance(value, datetime):
+            return value.isoformat()
+        return value
+
 
 class DataTargetBase(ModelObj):
     """data target spec, specify a destination for the feature set data"""
@@ -1770,16 +2143,16 @@ class DataTargetBase(ModelObj):
         kind: str = None,
         name: str = "",
         path=None,
-        attributes: Dict[str, str] = None,
+        attributes: dict[str, str] = None,
         after_step=None,
         partitioned: bool = False,
         key_bucketing_number: Optional[int] = None,
-        partition_cols: Optional[List[str]] = None,
+        partition_cols: Optional[list[str]] = None,
         time_partitioning_granularity: Optional[str] = None,
         max_events: Optional[int] = None,
         flush_after_seconds: Optional[int] = None,
-        storage_options: Dict[str, str] = None,
-        schema: Dict[str, Any] = None,
+        storage_options: dict[str, str] = None,
+        schema: dict[str, Any] = None,
         credentials_prefix=None,
     ):
         self.name = name
@@ -1818,6 +2191,7 @@ class DataTarget(DataTargetBase):
         "name",
         "kind",
         "path",
+        "attributes",
         "start_time",
         "online",
         "status",
@@ -1849,6 +2223,7 @@ class DataTarget(DataTargetBase):
         self.last_written = None
         self._producer = None
         self.producer = {}
+        self.attributes = {}
 
     @property
     def producer(self) -> FeatureSetProducer:
@@ -1866,8 +2241,8 @@ class VersionedObjMetadata(ModelObj):
         tag: str = None,
         uid: str = None,
         project: str = None,
-        labels: Dict[str, str] = None,
-        annotations: Dict[str, str] = None,
+        labels: dict[str, str] = None,
+        annotations: dict[str, str] = None,
         updated=None,
     ):
         self.name = name