mlrun 1.10.0rc21__tar.gz → 1.10.0rc23__tar.gz

{mlrun-1.10.0rc21 → mlrun-1.10.0rc23}/Makefile

@@ -290,6 +290,7 @@ print-docker-images: ## Print all docker images
 	@for image in $(DEFAULT_IMAGES); do \
 		echo $$image ; \
 	done
+	@make -C server/go print-docker-images
 
 
 MLRUN_IMAGE_NAME := $(MLRUN_DOCKER_IMAGE_PREFIX)/mlrun
@@ -311,6 +312,7 @@ mlrun: common-image update-version-file ## Build mlrun docker image
 		--build-arg MLRUN_PIP_VERSION=$(MLRUN_PIP_VERSION) \
 		--build-arg MLRUN_UV_IMAGE=$(MLRUN_UV_IMAGE) \
 		--build-arg DOCKER_DEFAULT_PLATFORM=$(DOCKER_DEFAULT_PLATFORM) \
+		--platform $(DOCKER_DEFAULT_PLATFORM) \
 		$(MLRUN_IMAGE_DOCKER_CACHE_FROM_FLAG) \
 		$(MLRUN_DOCKER_NO_CACHE_FLAG) \
 		--tag $(MLRUN_IMAGE_NAME_TAGGED) .
@@ -344,6 +346,7 @@ mlrun-kfp: common-image-3.9 update-version-file ## Build mlrun docker image with
 		--build-arg MLRUN_VERSION=$(MLRUN_VERSION) \
 		--build-arg MLRUN_PIP_VERSION=$(MLRUN_PIP_VERSION) \
 		--build-arg DOCKER_DEFAULT_PLATFORM=$(DOCKER_DEFAULT_PLATFORM) \
+		--platform $(DOCKER_DEFAULT_PLATFORM) \
 		$(MLRUN_KFP_IMAGE_DOCKER_CACHE_FROM_FLAG) \
 		$(MLRUN_DOCKER_NO_CACHE_FLAG) \
 		--tag $(MLRUN_KFP_IMAGE_NAME):$(MLRUN_DOCKER_TAG)$(MLRUN_PYTHON_VERSION_SUFFIX) .
@@ -386,6 +389,7 @@ mlrun-gpu: update-version-file ## Build mlrun gpu docker image
 		--build-arg MLRUN_GPU_BASE_IMAGE=$(MLRUN_GPU_BASE_IMAGE) \
 		--build-arg MLRUN_UV_IMAGE=$(MLRUN_UV_IMAGE) \
 		--build-arg MLRUN_PIP_VERSION=$(MLRUN_PIP_VERSION) \
+		--platform $(DOCKER_DEFAULT_PLATFORM) \
 		$(MLRUN_GPU_IMAGE_DOCKER_CACHE_FROM_FLAG) \
 		$(MLRUN_DOCKER_NO_CACHE_FLAG) \
 		--tag $(MLRUN_GPU_IMAGE_NAME_TAGGED) \
@@ -407,6 +411,7 @@ prebake-mlrun-gpu: ## Build prebake mlrun GPU based docker image
 		--build-arg CUDA_VER=$(MLRUN_GPU_CUDA_VERSION) \
 		--build-arg MLRUN_ANACONDA_PYTHON_DISTRIBUTION=$(MLRUN_ANACONDA_PYTHON_DISTRIBUTION) \
 		--build-arg MLRUN_PIP_VERSION=$(MLRUN_PIP_VERSION) \
+		--platform $(DOCKER_DEFAULT_PLATFORM) \
 		--tag $(MLRUN_GPU_PREBAKED_IMAGE_NAME_TAGGED) \
 		.
 
@@ -432,6 +437,7 @@ jupyter: update-version-file ## Build mlrun jupyter docker image
 		--build-arg MLRUN_CACHE_DATE=$(MLRUN_CACHE_DATE) \
 		--build-arg MLRUN_PYTHON_VERSION=$(MLRUN_PYTHON_VERSION) \
 		--build-arg MLRUN_UV_IMAGE=$(MLRUN_UV_IMAGE) \
+		--platform $(DOCKER_DEFAULT_PLATFORM) \
 		$(MLRUN_JUPYTER_IMAGE_DOCKER_CACHE_FROM_FLAG) \
 		$(MLRUN_DOCKER_NO_CACHE_FLAG) \
 		--tag $(MLRUN_JUPYTER_IMAGE_NAME_TAGGED) \
@@ -505,6 +511,7 @@ $(COMMON_STAMP): $(COMMON_DOCKERFILE)
 	docker build \
 	--build-arg MLRUN_PYTHON_VERSION=$(MLRUN_PYTHON_VERSION) \
 	--build-arg DOCKER_DEFAULT_PLATFORM=$(DOCKER_DEFAULT_PLATFORM) \
+	--platform $(DOCKER_DEFAULT_PLATFORM) \
 	-f $(COMMON_DOCKERFILE) \
 	-t $(COMMON_IMAGE_NAME) . \
 	 && mkdir -p $(dir $@) && touch $@
@@ -515,6 +522,7 @@ common-image:
 	  --no-cache $(COMMON_DOCKER_ARGS) \
  	  --build-arg MLRUN_PYTHON_VERSION=$(MLRUN_PYTHON_VERSION) \
  	  --build-arg DOCKER_DEFAULT_PLATFORM=$(DOCKER_DEFAULT_PLATFORM) \
+	  --platform $(DOCKER_DEFAULT_PLATFORM) \
  	  -f $(COMMON_DOCKERFILE) \
 	  -t $(COMMON_IMAGE_NAME) .
 endif
@@ -546,6 +554,7 @@ api: common-image-3.11	 compile-schemas update-version-file ## Build mlrun-api d
 		--build-arg MLRUN_PYTHON_VERSION=$(MLRUN_PYTHON_VERSION) \
 		--build-arg MLRUN_UV_IMAGE=$(MLRUN_UV_IMAGE) \
 		--build-arg DOCKER_DEFAULT_PLATFORM=$(DOCKER_DEFAULT_PLATFORM) \
+		--platform $(DOCKER_DEFAULT_PLATFORM) \
 		$(MLRUN_API_IMAGE_DOCKER_CACHE_FROM_FLAG) \
 		$(MLRUN_DOCKER_NO_CACHE_FLAG) \
 		--tag $(MLRUN_API_IMAGE_NAME_TAGGED) .
@@ -578,6 +587,7 @@ build-test: common-image compile-schemas update-version-file ## Build test docke
 		--build-arg MLRUN_PIPELINES_KFP_VERSION=$(MLRUN_PIPELINES_KFP_VERSION) \
 		--build-arg MLRUN_UV_VERSION=$(MLRUN_UV_VERSION) \
 		--build-arg DOCKER_DEFAULT_PLATFORM=$(DOCKER_DEFAULT_PLATFORM) \
+		--platform $(DOCKER_DEFAULT_PLATFORM) \
 		$(MLRUN_TEST_IMAGE_DOCKER_CACHE_FROM_FLAG) \
 		$(MLRUN_DOCKER_NO_CACHE_FLAG) \
 		--tag $(MLRUN_TEST_IMAGE_NAME_TAGGED) .
@@ -597,6 +607,7 @@ build-test-system: common-image compile-schemas update-version-file ## Build sys
 		--build-arg MLRUN_PIP_VERSION=$(MLRUN_PIP_VERSION) \
 		--build-arg MLRUN_UV_VERSION=$(MLRUN_UV_VERSION) \
 		--build-arg DOCKER_DEFAULT_PLATFORM=$(DOCKER_DEFAULT_PLATFORM) \
+		--platform $(DOCKER_DEFAULT_PLATFORM) \
 		$(MLRUN_DOCKER_NO_CACHE_FLAG) \
 		--tag $(MLRUN_SYSTEM_TEST_IMAGE_NAME) .
 

{mlrun-1.10.0rc21/mlrun.egg-info → mlrun-1.10.0rc23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mlrun
-Version: 1.10.0rc21
+Version: 1.10.0rc23
 Summary: Tracking and config of machine learning runs
 Home-page: https://github.com/mlrun/mlrun
 Author: Yaron Haviv
@@ -39,13 +39,13 @@ Requires-Dist: tabulate~=0.8.6
 Requires-Dist: v3io~=0.7.0
 Requires-Dist: pydantic>=1.10.15
 Requires-Dist: mergedeep~=1.3
-Requires-Dist: v3io-frames~=0.10.14; python_version < "3.11"
+Requires-Dist: v3io-frames~=0.10.15; python_version < "3.11"
 Requires-Dist: v3io-frames>=0.13.0; python_version >= "3.11"
 Requires-Dist: semver~=3.0
 Requires-Dist: dependency-injector~=4.41
 Requires-Dist: fsspec<2024.7,>=2023.9.2
 Requires-Dist: v3iofs~=0.1.17
-Requires-Dist: storey~=1.10.10
+Requires-Dist: storey~=1.10.11
 Requires-Dist: inflection~=0.5.0
 Requires-Dist: python-dotenv~=1.0
 Requires-Dist: setuptools>=75.2

{mlrun-1.10.0rc21 → mlrun-1.10.0rc23}/mlrun/artifacts/llm_prompt.py

@@ -83,19 +83,20 @@ class LLMPromptArtifactSpec(ArtifactSpec):
             raise mlrun.errors.MLRunInvalidArgumentError(
                 "Expected prompt_template to be a list of dicts"
             )
-        keys_to_pop = []
         for message in prompt_template:
+            if set(key.lower() for key in message.keys()) != set(
+                self.PROMPT_TEMPLATE_KEYS
+            ):
+                raise mlrun.errors.MLRunInvalidArgumentError(
+                    f"Expected prompt_template to contain dicts with keys "
+                    f"{self.PROMPT_TEMPLATE_KEYS}, got {message.keys()}"
+                )
+            keys_to_pop = []
             for key in message.keys():
                 if isinstance(key, str):
-                    if key.lower() not in self.PROMPT_TEMPLATE_KEYS:
-                        raise mlrun.errors.MLRunInvalidArgumentError(
-                            f"Expected prompt_template to contain dict that "
-                            f"only has keys from {self.PROMPT_TEMPLATE_KEYS}"
-                        )
-                    else:
-                        if not key.islower():
-                            message[key.lower()] = message[key]
-                            keys_to_pop.append(key)
+                    if not key.islower():
+                        message[key.lower()] = message[key]
+                        keys_to_pop.append(key)
                 else:
                     raise mlrun.errors.MLRunInvalidArgumentError(
                         f"Expected prompt_template to contain dict that only"

{mlrun-1.10.0rc21 → mlrun-1.10.0rc23}/mlrun/artifacts/model.py

@@ -190,10 +190,10 @@ class ModelArtifact(Artifact):
         """
         super().__init__(key, body, format=format, target_path=target_path, **kwargs)
         model_file = str(model_file or "")
-        if model_file and model_url:
+        if (model_file or model_dir or body) and model_url:
             raise mlrun.errors.MLRunInvalidArgumentError(
-                "Arguments 'model_file' and 'model_dir' cannot be"
-                " used together with 'model_url'."
+                "Arguments 'model_file' and 'model_url' cannot be"
+                " used together with 'model_file', 'model_dir' or 'body'."
             )
         if model_file and "/" in model_file:
             if model_dir:

{mlrun-1.10.0rc21 → mlrun-1.10.0rc23}/mlrun/common/schemas/auth.py

@@ -55,6 +55,7 @@ class AuthorizationResourceTypes(mlrun.common.types.StrEnum):
     secret = "secret"
     run = "run"
     model_endpoint = "model-endpoint"
+    model_monitoring = "model-monitoring"
     pipeline = "pipeline"
     hub_source = "hub-source"
     workflow = "workflow"
@@ -96,6 +97,7 @@ class AuthorizationResourceTypes(mlrun.common.types.StrEnum):
             # runtime resource doesn't have an identifier, we don't need any auth granularity behind project level
             AuthorizationResourceTypes.runtime_resource: "/projects/{project_name}/runtime-resources",
             AuthorizationResourceTypes.model_endpoint: "/projects/{project_name}/model-endpoints/{resource_name}",
+            AuthorizationResourceTypes.model_monitoring: "/projects/{project_name}/model-monitoring/{resource_name}",
             AuthorizationResourceTypes.pipeline: "/projects/{project_name}/pipelines/{resource_name}",
             AuthorizationResourceTypes.datastore_profile: "/projects/{project_name}/datastore_profiles",
             # Hub sources are not project-scoped, and auth is globally on the sources endpoint.

{mlrun-1.10.0rc21 → mlrun-1.10.0rc23}/mlrun/common/schemas/model_monitoring/functions.py

@@ -54,12 +54,21 @@ class FunctionSummary(BaseModel):
 
         return cls(
             type=func_type,
-            name=func_dict["metadata"]["name"],
+            name=func_dict["metadata"]["name"]
+            if func_type != FunctionsType.APPLICATION
+            else func_dict["spec"]
+            .get("graph", {})
+            .get("steps", {})
+            .get("PrepareMonitoringEvent", {})
+            .get("class_args", {})
+            .get("application_name"),
             application_class=""
             if func_type != FunctionsType.APPLICATION
-            else func_dict["spec"]["graph"]["steps"]["PushToMonitoringWriter"]["after"][
-                0
-            ],
+            else func_dict["spec"]
+            .get("graph", {})
+            .get("steps", {})
+            .get("PushToMonitoringWriter", {})
+            .get("after", [None])[0],
             project_name=func_dict["metadata"]["project"],
             updated_time=func_dict["metadata"].get("updated"),
             status=func_dict["status"].get("state"),

{mlrun-1.10.0rc21 → mlrun-1.10.0rc23}/mlrun/datastore/datastore.py

@@ -39,6 +39,7 @@ from .base import DataItem, DataStore, HttpStore
 from .filestore import FileStore
 from .inmem import InMemoryStore
 from .model_provider.huggingface_provider import HuggingFaceProvider
+from .model_provider.mock_model_provider import MockModelProvider
 from .model_provider.openai_provider import OpenAIProvider
 from .store_resources import get_store_resource, is_store_uri
 from .v3io import V3ioStore
@@ -103,7 +104,11 @@ def schema_to_store(schema) -> DataStore.__subclasses__():
 def schema_to_model_provider(
     schema: str, raise_missing_schema_exception=True
 ) -> type[ModelProvider]:
-    schema_dict = {"openai": OpenAIProvider, "huggingface": HuggingFaceProvider}
+    schema_dict = {
+        "openai": OpenAIProvider,
+        "huggingface": HuggingFaceProvider,
+        "mock": MockModelProvider,
+    }
     provider_class = schema_dict.get(schema, None)
     if not provider_class:
         if raise_missing_schema_exception:

mlrun-1.10.0rc23/mlrun/datastore/model_provider/mock_model_provider.py

@@ -0,0 +1,87 @@
+# Copyright 2023 Iguazio
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+
+from typing import Any, Optional, Union
+
+import mlrun
+from mlrun.datastore.model_provider.model_provider import (
+    InvokeResponseFormat,
+    ModelProvider,
+    UsageResponseKeys,
+)
+
+
+class MockModelProvider(ModelProvider):
+    support_async = False
+
+    def __init__(
+        self,
+        parent,
+        kind,
+        name,
+        endpoint="",
+        secrets: Optional[dict] = None,
+        default_invoke_kwargs: Optional[dict] = None,
+    ):
+        super().__init__(
+            parent=parent, name=name, kind=kind, endpoint=endpoint, secrets=secrets
+        )
+        self.default_invoke_kwargs = default_invoke_kwargs or {}
+        self._client = None
+        self._async_client = None
+
+    @staticmethod
+    def _extract_string_output(response: Any) -> str:
+        """
+        Extracts string response from response object
+        """
+        pass
+
+    def load_client(self) -> None:
+        """
+        Initializes the SDK client for the model provider with the given keyword arguments
+        and assigns it to an instance attribute (e.g., self._client).
+
+        Subclasses should override this method to:
+        - Create and configure the provider-specific client instance.
+        - Assign the client instance to self._client.
+        """
+
+        pass
+
+    def invoke(
+        self,
+        messages: Union[list[dict], Any],
+        invoke_response_format: InvokeResponseFormat = InvokeResponseFormat.FULL,
+        **invoke_kwargs,
+    ) -> Union[str, dict[str, Any], Any]:
+        if invoke_response_format == InvokeResponseFormat.STRING:
+            return (
+                "You are using a mock model provider, no actual inference is performed."
+            )
+        elif invoke_response_format == InvokeResponseFormat.FULL:
+            return {
+                UsageResponseKeys.USAGE: {"prompt_tokens": 0, "completion_tokens": 0},
+                UsageResponseKeys.ANSWER: "You are using a mock model provider, no actual inference is performed.",
+                "extra": {},
+            }
+        elif invoke_response_format == InvokeResponseFormat.USAGE:
+            return {
+                UsageResponseKeys.ANSWER: "You are using a mock model provider, no actual inference is performed.",
+                UsageResponseKeys.USAGE: {"prompt_tokens": 0, "completion_tokens": 0},
+            }
+        else:
+            raise mlrun.errors.MLRunInvalidArgumentError(
+                f"Unsupported invoke response format: {invoke_response_format}"
+            )

{mlrun-1.10.0rc21 → mlrun-1.10.0rc23}/mlrun/db/base.py

@@ -1111,6 +1111,15 @@ class RunDBInterface(ABC):
     ) -> None:
         pass
 
+    @abstractmethod
+    def delete_model_monitoring_metrics(
+        self,
+        project: str,
+        application_name: str,
+        endpoint_ids: Optional[list[str]] = None,
+    ) -> None:
+        pass
+
     @abstractmethod
     def get_monitoring_function_summaries(
         self,

{mlrun-1.10.0rc21 → mlrun-1.10.0rc23}/mlrun/db/httpdb.py

@@ -3580,7 +3580,7 @@ class HTTPRunDB(RunDBInterface):
                                 intersection {"intersect_metrics":[], "intersect_results":[]}
         :return: A dictionary of application metrics and/or results for the model endpoints formatted by events_format.
         """
-        path = f"projects/{project}/model-endpoints/metrics"
+        path = f"projects/{project}/model-monitoring/metrics"
         params = {
             "type": type,
             "endpoint-id": endpoint_ids,
@@ -4121,6 +4121,26 @@ class HTTPRunDB(RunDBInterface):
             params={**credentials, "replace_creds": replace_creds},
         )
 
+    def delete_model_monitoring_metrics(
+        self,
+        project: str,
+        application_name: str,
+        endpoint_ids: Optional[list[str]] = None,
+    ) -> None:
+        """
+        Delete model endpoints metrics values.
+
+        :param project:           The name of the project.
+        :param application_name:  The name of the application.
+        :param endpoint_ids:      The unique IDs of the model endpoints to delete metrics values from. If none is
+                                  provided, the metrics values will be deleted from all project's model endpoints.
+        """
+        self.api_call(
+            method=mlrun.common.types.HTTPMethod.DELETE,
+            path=f"projects/{project}/model-monitoring/metrics",
+            params={"endpoint-id": endpoint_ids, "application-name": application_name},
+        )
+
     def get_monitoring_function_summaries(
         self,
         project: str,

{mlrun-1.10.0rc21 → mlrun-1.10.0rc23}/mlrun/db/nopdb.py

@@ -885,6 +885,14 @@ class NopDB(RunDBInterface):
     ) -> None:
         pass
 
+    def delete_model_monitoring_metrics(
+        self,
+        project: str,
+        application_name: str,
+        endpoint_ids: Optional[list[str]] = None,
+    ) -> None:
+        pass
+
     def get_monitoring_function_summaries(
         self,
         project: str,

{mlrun-1.10.0rc21 → mlrun-1.10.0rc23}/mlrun/execution.py

@@ -934,14 +934,51 @@ class MLClientCtx:
 
         Examples::
 
-            # Log an inline prompt
+            # Log directly with an inline prompt template
             context.log_llm_prompt(
-                key="qa-prompt",
-                prompt_template=[{"role: "user", "content": "question with {place_holder}"}],
+                key="customer_support_prompt",
+                prompt_template=[
+                    {
+                        "role": "system",
+                        "content": "You are a helpful customer support assistant.",
+                    },
+                    {
+                        "role": "user",
+                        "content": "The customer reports: {issue_description}",
+                    },
+                ],
+                prompt_legend={
+                    "issue_description": {
+                        "field": "user_issue",
+                        "description": "Detailed description of the customer's issue",
+                    },
+                    "solution": {
+                        "field": "proposed_solution",
+                        "description": "Suggested fix for the customer's issue",
+                    },
+                },
                 model_artifact=model,
-                prompt_legend={"question": "user_input"},
-                model_configuration={"temperature": 0.7, "max_tokens": 128},
-                tag="latest",
+                model_configuration={"temperature": 0.5, "max_tokens": 200},
+                description="Prompt for handling customer support queries",
+                tag="support-v1",
+                labels={"domain": "support"},
+            )
+
+            # Log a prompt from file
+            context.log_llm_prompt(
+                key="qa_prompt",
+                prompt_path="prompts/template.json",
+                prompt_legend={
+                    "question": {
+                        "field": "user_question",
+                        "description": "The actual question asked by the user",
+                    }
+                },
+                model_artifact=model,
+                model_configuration={"temperature": 0.7, "max_tokens": 256},
+                description="Q&A prompt template with user-provided question",
+                tag="v2",
+                labels={"task": "qa", "stage": "experiment"},
             )
 
         :param key: Unique name of the artifact.
@@ -950,7 +987,10 @@ class MLClientCtx:
          "role": "user", "content": "I need your help with {profession}"]. only "role" and "content" keys allow in any
          str format (upper/lower case), keys will be modified to lower case.
          Cannot be used with `prompt_path`.
-        :param prompt_path: Path to a file containing the prompt content. Cannot be used with `prompt_string`.
+        :param prompt_path: Path to a JSON file containing the prompt template.
+                    Cannot be used together with `prompt_template`.
+                    The file should define a list of dictionaries in the same format
+                    supported by `prompt_template`.
         :param prompt_legend: A dictionary where each key is a placeholder in the prompt (e.g., ``{user_name}``)
                and the value is a dictionary holding two keys, "field", "description". "field" points to the field in
                the event where the value of the place-holder inside the event, if None or not exist will be replaced
@@ -958,9 +998,11 @@ class MLClientCtx:
                Useful for documenting and clarifying dynamic parts of the prompt.
         :param model_artifact: Reference to the parent model (either `ModelArtifact` or model URI string).
         :param model_configuration: Dictionary of generation parameters (e.g., temperature, max_tokens).
-        :param description: Optional description of the prompt.
-        :param target_path: Path to write the artifact locally.
-        :param artifact_path: Path in the artifact store (defaults to project artifact path).
+        :param description:   Optional description of the prompt.
+        :param target_path:   Absolute target path (instead of using artifact_path + local_path)
+        :param artifact_path: Target artifact path (when not using the default)
+                              To define a subpath under the default location use:
+                              `artifact_path=context.artifact_subpath('data')`
         :param tag: Tag/version to assign to the prompt artifact.
         :param labels: Labels to tag the artifact (e.g., list or dict of key-value pairs).
         :param upload: Whether to upload the artifact to the store (defaults to True).

{mlrun-1.10.0rc21 → mlrun-1.10.0rc23}/mlrun/k8s_utils.py

@@ -26,6 +26,10 @@ from .config import config as mlconfig
 
 _running_inside_kubernetes_cluster = None
 
+K8sObj = typing.Union[kubernetes.client.V1Affinity, kubernetes.client.V1Toleration]
+SanitizedK8sObj = dict[str, typing.Any]
+K8sObjList = typing.Union[list[K8sObj], list[SanitizedK8sObj]]
+
 
 def is_running_inside_kubernetes_cluster():
     global _running_inside_kubernetes_cluster
@@ -232,6 +236,54 @@ def validate_node_selectors(
     return True
 
 
+def sanitize_k8s_objects(
+    k8s_objects: typing.Union[None, K8sObjList, SanitizedK8sObj, K8sObj],
+) -> typing.Union[list[SanitizedK8sObj], SanitizedK8sObj]:
+    """Convert K8s objects to dicts. Handles single objects or lists."""
+    api_client = kubernetes.client.ApiClient()
+    if not k8s_objects:
+        return k8s_objects
+
+    def _sanitize_k8s_object(k8s_obj):
+        return (
+            api_client.sanitize_for_serialization(k8s_obj)
+            if hasattr(k8s_obj, "to_dict")
+            else k8s_obj
+        )
+
+    return (
+        [_sanitize_k8s_object(k8s_obj) for k8s_obj in k8s_objects]
+        if isinstance(k8s_objects, list)
+        else _sanitize_k8s_object(k8s_objects)
+    )
+
+
+def sanitize_scheduling_configuration(
+    tolerations: typing.Optional[list[kubernetes.client.V1Toleration]] = None,
+    affinity: typing.Optional[kubernetes.client.V1Affinity] = None,
+) -> tuple[
+    typing.Optional[list[dict]],
+    typing.Optional[dict],
+]:
+    """
+    Sanitizes pod scheduling configuration for serialization.
+
+    Takes affinity and tolerations and converts them to
+    JSON-serializable dictionaries using the Kubernetes API client's
+    sanitization method.
+
+    Args:
+        affinity: Pod affinity/anti-affinity rules
+        tolerations: List of toleration rules
+
+    Returns:
+        Tuple of (sanitized_affinity, sanitized_tolerations)
+        - affinity: Sanitized dict representation or None
+        - tolerations: List of sanitized dict representations or None
+    """
+    return sanitize_k8s_objects(tolerations), sanitize_k8s_objects(affinity)
+
+
 def enrich_preemption_mode(
     preemption_mode: typing.Optional[str],
     node_selector: dict[str, str],
@@ -269,8 +321,8 @@ def enrich_preemption_mode(
         )
 
     enriched_node_selector = copy.deepcopy(node_selector or {})
-    enriched_tolerations = copy.deepcopy(tolerations or [])
-    enriched_affinity = copy.deepcopy(affinity)
+    enriched_tolerations = _safe_copy_tolerations(tolerations or [])
+    enriched_affinity = _safe_copy_affinity(affinity)
     preemptible_tolerations = generate_preemptible_tolerations()
 
     if handler := _get_mode_handler(preemption_mode):
@@ -288,6 +340,57 @@ def enrich_preemption_mode(
     )
 
 
+def _safe_copy_tolerations(
+    tolerations: list[kubernetes.client.V1Toleration],
+) -> list[kubernetes.client.V1Toleration]:
+    """
+    Safely copy a list of V1Toleration objects without mutating the originals.
+
+    Explicitly reconstructs V1Toleration objects instead of using deepcopy() to avoid
+    serialization errors with K8s client objects that contain threading primitives
+    and non-copyable elements like RLock objects.
+
+    Args:
+        tolerations: List of V1Toleration objects to copy
+
+    Returns:
+        New list containing copied V1Toleration objects with identical field values"""
+    return [
+        kubernetes.client.V1Toleration(
+            effect=toleration.effect,
+            key=toleration.key,
+            value=toleration.value,
+            operator=toleration.operator,
+            toleration_seconds=toleration.toleration_seconds,
+        )
+        for toleration in tolerations
+    ]
+
+
+def _safe_copy_affinity(
+    affinity: kubernetes.client.V1Affinity,
+) -> kubernetes.client.V1Affinity:
+    """
+    Safely create a deep copy of a V1Affinity object.
+
+    Uses K8s API client serialization/deserialization instead of deepcopy() to avoid
+    errors with threading primitives and complex internal structures in K8s objects.
+    Serializes to dict then deserializes back to a clean V1Affinity object.
+
+    Args:
+        affinity: V1Affinity object to copy, or None
+
+    Returns:
+        New V1Affinity object with identical field values, or None if input was None
+    """
+    if not affinity:
+        return None
+    api_client = kubernetes.client.ApiClient()
+    # Convert to dict then back to object properly
+    affinity_dict = api_client.sanitize_for_serialization(affinity)
+    return api_client._ApiClient__deserialize(affinity_dict, "V1Affinity")
+
+
 def _get_mode_handler(mode: str):
     return {
         mlrun.common.schemas.PreemptionModes.prevent: _handle_prevent_mode,

{mlrun-1.10.0rc21 → mlrun-1.10.0rc23}/mlrun/model_monitoring/applications/__init__.py

@@ -12,6 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .base import ModelMonitoringApplicationBase
+from .base import ExistingDataHandling, ModelMonitoringApplicationBase
 from .context import MonitoringApplicationContext
 from .results import ModelMonitoringApplicationMetric, ModelMonitoringApplicationResult