mlrun 1.10.0rc1__py3-none-any.whl → 1.10.0rc3__py3-none-any.whl

mlrun/errors.py

@@ -11,7 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
+import copy
 import typing
 from http import HTTPStatus
 
@@ -230,6 +230,13 @@ class MLRunTSDBConnectionFailureError(MLRunHTTPStatusError, ValueError):
     error_status_code = HTTPStatus.BAD_REQUEST.value
 
 
+class MLRunMissingProjectError(MLRunBadRequestError):
+    default_message = "Project must be provided"
+
+    def __init__(self, message=None):
+        super().__init__(message or self.default_message)
+
+
 class MLRunRetryExhaustedError(Exception):
     pass
 
@@ -256,6 +263,27 @@ class MLRunFatalFailureError(Exception):
         self.original_exception = original_exception
 
 
+class ModelRunnerError(MLRunBaseError):
+    def __init__(self, models_errors: dict[str:str], *args) -> None:
+        self.models_errors = models_errors
+        super().__init__(self.__repr__(), *args)
+
+    def __repr__(self):
+        return f"ModelRunnerError: {repr(self.models_errors)}"
+
+    def __copy__(self):
+        return type(self)(models_errors=self.models_errors)
+
+    def __deepcopy__(self, memo):
+        return type(self)(copy.deepcopy(self.models_errors, memo))
+
+    def get_errors(self):
+        return self.models_errors
+
+    def get_model_error(self, model: str):
+        return self.models_errors.get(model)
+
+
 STATUS_ERRORS = {
     HTTPStatus.BAD_REQUEST.value: MLRunBadRequestError,
     HTTPStatus.UNAUTHORIZED.value: MLRunUnauthorizedError,

mlrun/execution.py

@@ -15,6 +15,7 @@
 import logging
 import os
 import uuid
+import warnings
 from copy import deepcopy
 from typing import Optional, Union, cast
 
@@ -991,6 +992,14 @@ class MLClientCtx:
         self._update_run()
         return item
 
+    def get_cached_artifact(self, key):
+        """Return a logged artifact from cache (for potential updates)"""
+        warnings.warn(
+            "get_cached_artifact is deprecated in 1.8.0 and will be removed in 1.11.0. Use get_artifact instead.",
+            FutureWarning,
+        )
+        return self.get_artifact(key)
+
     def get_artifact(
         self, key, tag=None, iter=None, tree=None, uid=None
     ) -> Optional[Artifact]:

mlrun/feature_store/common.py

@@ -63,7 +63,7 @@ def parse_project_name_from_feature_string(feature):
 
 def parse_feature_set_uri(uri, project=None):
     """get feature set object from db by uri"""
-    default_project = project or config.default_project
+    active_project = project or config.active_project
 
     # parse store://.. uri
     if mlrun.datastore.is_store_uri(uri):
@@ -74,7 +74,7 @@ def parse_feature_set_uri(uri, project=None):
             )
         uri = new_uri
 
-    return parse_versioned_object_uri(uri, default_project)
+    return parse_versioned_object_uri(uri, active_project)
 
 
 def get_feature_set_by_uri(uri, project=None):
@@ -98,7 +98,7 @@ def get_feature_set_by_uri(uri, project=None):
 def get_feature_vector_by_uri(uri, project=None, update=True):
     """get feature vector object from db by uri"""
     db = mlrun.get_run_db()
-    default_project = project or config.default_project
+    active_project = project or config.active_project
 
     # parse store://.. uri
     if mlrun.datastore.is_store_uri(uri):
@@ -109,7 +109,7 @@ def get_feature_vector_by_uri(uri, project=None, update=True):
             )
         uri = new_uri
 
-    project, name, tag, uid = parse_versioned_object_uri(uri, default_project)
+    project, name, tag, uid = parse_versioned_object_uri(uri, active_project)
 
     resource = mlrun.common.schemas.AuthorizationResourceTypes.feature_vector.to_resource_string(
         project, "feature-vector"
@@ -161,7 +161,7 @@ def verify_feature_set_exists(feature_set):
 def verify_feature_vector_permissions(
     feature_vector, action: mlrun.common.schemas.AuthorizationAction
 ):
-    project = feature_vector._metadata.project or config.default_project
+    project = feature_vector._metadata.project or config.active_project
 
     resource = mlrun.common.schemas.AuthorizationResourceTypes.feature_vector.to_resource_string(
         project, "feature-vector"

mlrun/feature_store/feature_set.py

@@ -413,11 +413,15 @@ class FeatureSet(ModelObj):
     @property
     def fullname(self) -> str:
         """full name in the form ``{project}/{name}[:{tag}]``"""
-        fullname = (
-            f"{self._metadata.project or mlconf.default_project}/{self._metadata.name}"
-        )
-        if self._metadata.tag:
-            fullname += ":" + self._metadata.tag
+        project = self._metadata.project or mlconf.active_project
+        name = self._metadata.name
+        tag = self._metadata.tag
+
+        fullname = name
+        if project:
+            fullname = f"{project}/{fullname}"
+        if tag:
+            fullname += f":{tag}"
         return fullname
 
     def _get_run_db(self):
@@ -971,7 +975,7 @@ class FeatureSet(ModelObj):
     def save(self, tag="", versioned=False):
         """save to mlrun db"""
         db = self._get_run_db()
-        self.metadata.project = self.metadata.project or mlconf.default_project
+        self.metadata.project = self.metadata.project or mlconf.active_project
         tag = tag or self.metadata.tag or "latest"
         as_dict = self.to_dict()
         as_dict["spec"]["features"] = as_dict["spec"].get(

mlrun/feature_store/feature_vector.py

@@ -333,12 +333,14 @@ class FeatureVector(ModelObj):
     @property
     def uri(self):
         """fully qualified feature vector uri"""
-        uri = (
-            f"{self._metadata.project or mlconf.default_project}/{self._metadata.name}"
-        )
-        uri = get_store_uri(StorePrefix.FeatureVector, uri)
+        project = self._metadata.project or mlconf.active_project
+        name = self._metadata.name
+
+        base = name if not project else f"{project}/{name}"
+        uri = get_store_uri(StorePrefix.FeatureVector, base)
+
         if self._metadata.tag:
-            uri += ":" + self._metadata.tag
+            uri += f":{self._metadata.tag}"
         return uri
 
     def link_analysis(self, name, uri):
@@ -385,7 +387,7 @@ class FeatureVector(ModelObj):
     def save(self, tag="", versioned=False):
         """save to mlrun db"""
         db = mlrun.get_run_db()
-        self.metadata.project = self.metadata.project or mlconf.default_project
+        self.metadata.project = self.metadata.project or mlconf.active_project
         tag = tag or self.metadata.tag
         as_dict = self.to_dict()
         db.store_feature_vector(as_dict, tag=tag, versioned=versioned)

mlrun/launcher/base.py

@@ -273,7 +273,7 @@ class BaseLauncher(abc.ABC):
             project_name
             or run.metadata.project
             or runtime.metadata.project
-            or mlrun.mlconf.default_project
+            or mlrun.mlconf.active_project
         )
         run.spec.parameters = params or run.spec.parameters
         run.spec.inputs = inputs or run.spec.inputs

mlrun/launcher/client.py

@@ -72,7 +72,7 @@ class ClientBaseLauncher(launcher.BaseLauncher, abc.ABC):
     ):
         run.metadata.labels[mlrun_constants.MLRunInternalLabels.kind] = runtime.kind
         mlrun.runtimes.utils.enrich_run_labels(
-            run.metadata.labels, [mlrun.common.runtimes.constants.RunLabels.owner]
+            run.metadata.labels, [mlrun_constants.MLRunInternalLabels.owner]
         )
         if run.spec.output_path:
             run.spec.output_path = run.spec.output_path.replace(

mlrun/lists.py

@@ -55,7 +55,7 @@ class RunList(list):
         for run in self:
             iterations = get_in(run, "status.iterations", "")
             row = [
-                get_in(run, "metadata.project", config.default_project),
+                get_in(run, "metadata.project", config.active_project),
                 get_in(run, "metadata.uid", ""),
                 get_in(run, "metadata.iteration", ""),
                 get_in(run, "status.start_time", ""),

mlrun/model_monitoring/__init__.py

@@ -16,4 +16,3 @@ from mlrun.common.schemas import ModelEndpoint, ModelEndpointList
 
 from .db import get_tsdb_connector
 from .helpers import get_stream_path
-from .tracking_policy import TrackingPolicy

mlrun/model_monitoring/api.py

@@ -14,7 +14,6 @@
 
 import hashlib
 import typing
-import warnings
 from datetime import datetime
 
 import numpy as np
@@ -136,12 +135,6 @@ def record_results(
     infer_results_df: typing.Optional[pd.DataFrame] = None,
     sample_set_statistics: typing.Optional[dict[str, typing.Any]] = None,
     monitoring_mode: mm_constants.ModelMonitoringMode = mm_constants.ModelMonitoringMode.enabled,
-    # Deprecated arguments:
-    drift_threshold: typing.Optional[float] = None,
-    possible_drift_threshold: typing.Optional[float] = None,
-    trigger_monitoring_job: bool = False,
-    artifacts_tag: str = "",
-    default_batch_image: str = "mlrun/mlrun",
 ) -> ModelEndpoint:
     """
     Write a provided inference dataset to model endpoint parquet target. If not exist, generate a new model endpoint
@@ -166,47 +159,10 @@ def record_results(
                                      the current model endpoint.
     :param monitoring_mode:          If enabled, apply model monitoring features on the provided endpoint id. Enabled
                                      by default.
-    :param drift_threshold:          (deprecated) The threshold of which to mark drifts.
-    :param possible_drift_threshold: (deprecated) The threshold of which to mark possible drifts.
-    :param trigger_monitoring_job:   (deprecated) If true, run the batch drift job. If not exists, the monitoring
-                                     batch function will be registered through MLRun API with the provided image.
-    :param artifacts_tag:            (deprecated) Tag to use for all the artifacts resulted from the function.
-                                     Will be relevant only if the monitoring batch job has been triggered.
-    :param default_batch_image:      (deprecated) The image that will be used when registering the model monitoring
-                                     batch job.
 
     :return: A ModelEndpoint object
     """
 
-    if drift_threshold is not None or possible_drift_threshold is not None:
-        warnings.warn(
-            "Custom drift threshold arguments are deprecated since version "
-            "1.7.0 and have no effect. They will be removed in version 1.9.0.\n"
-            "To enable the default histogram data drift application, run:\n"
-            "`project.enable_model_monitoring()`.",
-            FutureWarning,
-        )
-    if trigger_monitoring_job is not False:
-        warnings.warn(
-            "`trigger_monitoring_job` argument is deprecated since version "
-            "1.7.0 and has no effect. It will be removed in version 1.9.0.\n"
-            "To enable the default histogram data drift application, run:\n"
-            "`project.enable_model_monitoring()`.",
-            FutureWarning,
-        )
-    if artifacts_tag != "":
-        warnings.warn(
-            "`artifacts_tag` argument is deprecated since version "
-            "1.7.0 and has no effect. It will be removed in version 1.9.0.",
-            FutureWarning,
-        )
-    if default_batch_image != "mlrun/mlrun":
-        warnings.warn(
-            "`default_batch_image` argument is deprecated since version "
-            "1.7.0 and has no effect. It will be removed in version 1.9.0.",
-            FutureWarning,
-        )
-
     db = mlrun.get_run_db()
 
     model_endpoint = get_or_create_model_endpoint(

mlrun/model_monitoring/applications/evidently/base.py

@@ -12,21 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import json
-import posixpath
-import uuid
 import warnings
 from abc import ABC
+from tempfile import NamedTemporaryFile
+from typing import Optional
 
-import pandas as pd
 import semver
-from evidently.ui.storage.local.base import METADATA_PATH, FSLocation
 
 import mlrun.model_monitoring.applications.base as mm_base
 import mlrun.model_monitoring.applications.context as mm_context
-from mlrun.errors import MLRunIncompatibleVersionError
+from mlrun.errors import MLRunIncompatibleVersionError, MLRunValueError
 
-SUPPORTED_EVIDENTLY_VERSION = semver.Version.parse("0.6.0")
+SUPPORTED_EVIDENTLY_VERSION = semver.Version.parse("0.7.5")
 
 
 def _check_evidently_version(*, cur: semver.Version, ref: semver.Version) -> None:
@@ -60,75 +57,69 @@ except ModuleNotFoundError:
 
 
 if _HAS_EVIDENTLY:
-    from evidently.suite.base_suite import Display
-    from evidently.ui.type_aliases import STR_UUID
-    from evidently.ui.workspace import Workspace
-    from evidently.utils.dashboard import TemplateParams, file_html_template
+    from evidently.core.report import Snapshot
+    from evidently.ui.workspace import (
+        STR_UUID,
+        CloudWorkspace,
+        Project,
+        Workspace,
+        WorkspaceBase,
+    )
 
 
 class EvidentlyModelMonitoringApplicationBase(
     mm_base.ModelMonitoringApplicationBase, ABC
 ):
     def __init__(
-        self, evidently_workspace_path: str, evidently_project_id: "STR_UUID"
+        self,
+        evidently_project_id: "STR_UUID",
+        evidently_workspace_path: Optional[str] = None,
+        cloud_workspace: bool = False,
     ) -> None:
         """
-        A class for integrating Evidently for mlrun model monitoring within a monitoring application.
-        Note: evidently is not installed by default in the mlrun/mlrun image.
-        It must be installed separately to use this class.
+        A class for integrating Evidently for MLRun model monitoring within a monitoring application.
+
+        .. note::
+
+            The ``evidently`` package is not installed by default in the mlrun/mlrun image.
+            It must be installed separately to use this class.
 
-        :param evidently_workspace_path:    (str) The path to the Evidently workspace.
         :param evidently_project_id:        (str) The ID of the Evidently project.
+        :param evidently_workspace_path:    (str) The path to the Evidently workspace.
+        :param cloud_workspace:             (bool) Whether the workspace is an Evidently Cloud workspace.
         """
-
-        # TODO : more then one project (mep -> project)
         if not _HAS_EVIDENTLY:
             raise ModuleNotFoundError("Evidently is not installed - the app cannot run")
-        self._log_location(evidently_workspace_path)
-        self.evidently_workspace = Workspace.create(evidently_workspace_path)
+        self.evidently_workspace_path = evidently_workspace_path
+        if cloud_workspace:
+            self.get_workspace = self.get_cloud_workspace
+        self.evidently_workspace = self.get_workspace()
         self.evidently_project_id = evidently_project_id
-        self.evidently_project = self.evidently_workspace.get_project(
-            evidently_project_id
-        )
-
-    @staticmethod
-    def _log_location(evidently_workspace_path):
-        # TODO remove function + usage after solving issue ML-9530
-        location = FSLocation(base_path=evidently_workspace_path)
-        location.invalidate_cache("")
-        paths = [p for p in location.listdir("") if location.isdir(p)]
-
-        for path in paths:
-            metadata_path = posixpath.join(path, METADATA_PATH)
-            full_path = posixpath.join(location.path, metadata_path)
-            print(f"evidently json issue, working on path: {full_path}")
-            try:
-                with location.open(metadata_path) as f:
-                    content = json.load(f)
-                    print(
-                        f"evidently json issue, successful load path: {full_path}, content: {content}"
-                    )
-            except FileNotFoundError:
-                print(f"evidently json issue, path not found: {full_path}")
-                continue
-            except json.decoder.JSONDecodeError as json_error:
-                print(
-                    f"evidently json issue, path got json error, path:{full_path}, error: {json_error}"
-                )
-                print("evidently json issue, file content:")
-                with location.open(metadata_path) as f:
-                    print(f.read())
-                continue
-            except Exception as error:
-                print(
-                    f"evidently json issue, path got general error, path:{full_path}, error: {error}"
-                )
-                continue
+        self.evidently_project = self.load_project()
+
+    def load_project(self) -> "Project":
+        """Load the Evidently project."""
+        return self.evidently_workspace.get_project(self.evidently_project_id)
+
+    def get_workspace(self) -> "WorkspaceBase":
+        """Get the Evidently workspace. Override this method for customize access to the workspace."""
+        if self.evidently_workspace_path:
+            return Workspace.create(self.evidently_workspace_path)
+        else:
+            raise MLRunValueError(
+                "A local workspace could not be created as `evidently_workspace_path` is not set.\n"
+                "If you intend to use a cloud workspace, please use `cloud_workspace=True` and set the "
+                "`EVIDENTLY_API_KEY` environment variable. In other cases, override this method."
+            )
+
+    def get_cloud_workspace(self) -> "CloudWorkspace":
+        """Load the Evidently cloud workspace according to the `EVIDENTLY_API_KEY` environment variable."""
+        return CloudWorkspace()
 
     @staticmethod
     def log_evidently_object(
         monitoring_context: mm_context.MonitoringApplicationContext,
-        evidently_object: "Display",
+        evidently_object: "Snapshot",
         artifact_name: str,
         unique_per_endpoint: bool = True,
     ) -> None:
@@ -141,56 +132,15 @@ class EvidentlyModelMonitoringApplicationBase(
             This method should be called on special occasions only.
 
         :param monitoring_context:  (MonitoringApplicationContext) The monitoring context to process.
-        :param evidently_object:    (Display) The Evidently display to log, e.g. a report or a test suite object.
-        :param artifact_name:       (str) The name for the logged artifact.
-        :param unique_per_endpoint: by default ``True``, we will log different artifact for each model endpoint,
-                                    set to ``False`` without changing item key will cause artifact override.
-        """
-        evidently_object_html = evidently_object.get_html()
-        monitoring_context.log_artifact(
-            artifact_name,
-            body=evidently_object_html.encode("utf-8"),
-            format="html",
-            unique_per_endpoint=unique_per_endpoint,
-        )
-
-    def log_project_dashboard(
-        self,
-        monitoring_context: mm_context.MonitoringApplicationContext,
-        timestamp_start: pd.Timestamp,
-        timestamp_end: pd.Timestamp,
-        artifact_name: str = "dashboard",
-        unique_per_endpoint: bool = True,
-    ) -> None:
-        """
-        Logs an Evidently project dashboard.
-
-        .. caution::
-
-            Logging Evidently dashboards in every model monitoring window may cause scale issues.
-            This method should be called on special occasions only.
-
-        :param monitoring_context:  (MonitoringApplicationContext) The monitoring context to process.
-        :param timestamp_start:     (pd.Timestamp) The start timestamp for the dashboard data.
-        :param timestamp_end:       (pd.Timestamp) The end timestamp for the dashboard data.
+        :param evidently_object:    (Snapshot) The Evidently run to log, e.g. a report run.
         :param artifact_name:       (str) The name for the logged artifact.
         :param unique_per_endpoint: by default ``True``, we will log different artifact for each model endpoint,
                                     set to ``False`` without changing item key will cause artifact override.
         """
-
-        dashboard_info = self.evidently_project.build_dashboard_info(
-            timestamp_start, timestamp_end
-        )
-        template_params = TemplateParams(
-            dashboard_id="pd_" + str(uuid.uuid4()).replace("-", ""),
-            dashboard_info=dashboard_info,
-            additional_graphs={},
-        )
-
-        dashboard_html = file_html_template(params=template_params)
-        monitoring_context.log_artifact(
-            artifact_name,
-            body=dashboard_html.encode("utf-8"),
-            format="html",
-            unique_per_endpoint=unique_per_endpoint,
-        )
+        with NamedTemporaryFile(suffix=".html") as file:
+            evidently_object.save_html(filename=file.name)
+            monitoring_context.log_artifact(
+                artifact_name,
+                local_path=file.name,
+                unique_per_endpoint=unique_per_endpoint,
+            )

mlrun/model_monitoring/controller.py

@@ -25,6 +25,7 @@ from types import TracebackType
 from typing import Any, NamedTuple, Optional, Union, cast
 
 import nuclio_sdk
+import pandas as pd
 
 import mlrun
 import mlrun.common.schemas.model_monitoring.constants as mm_constants
@@ -250,7 +251,7 @@ class MonitoringApplicationController:
 
     def __init__(self) -> None:
         """Initialize Monitoring Application Controller"""
-        self.project = cast(str, mlrun.mlconf.default_project)
+        self.project = cast(str, mlrun.mlconf.active_project)
         self.project_obj = mlrun.get_run_db().get_project(name=self.project)
         logger.debug(f"Initializing {self.__class__.__name__}", project=self.project)
 
@@ -673,9 +674,15 @@ class MonitoringApplicationController:
         """
         logger.info("Starting monitoring controller chief")
         applications_names = []
-        endpoints = self.project_obj.list_model_endpoints(
-            metric_list=["last_request"]
-        ).endpoints
+        endpoints = self.project_obj.list_model_endpoints(tsdb_metrics=False).endpoints
+        last_request_dict = self.tsdb_connector.get_last_request(
+            endpoint_ids=[mep.metadata.uid for mep in endpoints]
+        )
+        if isinstance(last_request_dict, pd.DataFrame):
+            last_request_dict = last_request_dict.set_index(
+                mm_constants.EventFieldType.ENDPOINT_ID
+            )[mm_constants.ModelEndpointSchema.LAST_REQUEST].to_dict()
+
         if not endpoints:
             logger.info("No model endpoints found", project=self.project)
             return
@@ -721,16 +728,22 @@ class MonitoringApplicationController:
             with schedules.ModelMonitoringSchedulesFileChief(
                 self.project
             ) as schedule_file:
-                futures = {
-                    pool.submit(
-                        self.endpoint_to_regular_event,
-                        endpoint,
-                        policy,
-                        set(applications_names),
-                        schedule_file,
-                    ): endpoint
-                    for endpoint in endpoints
-                }
+                for endpoint in endpoints:
+                    last_request = last_request_dict.get(endpoint.metadata.uid, None)
+                    if isinstance(last_request, float):
+                        last_request = pd.to_datetime(last_request, unit="s", utc=True)
+                    endpoint.status.last_request = (
+                        last_request or endpoint.status.last_request
+                    )
+                    futures = {
+                        pool.submit(
+                            self.endpoint_to_regular_event,
+                            endpoint,
+                            policy,
+                            set(applications_names),
+                            schedule_file,
+                        ): endpoint
+                    }
                 for future in concurrent.futures.as_completed(futures):
                     if future.exception():
                         exception = future.exception()

mlrun/model_monitoring/db/tsdb/v3io/v3io_connector.py

@@ -455,12 +455,20 @@ class V3IOTSDBConnector(TSDBConnector):
             # Delete all tables
             tables = mm_schemas.V3IOTSDBTables.list()
         for table_to_delete in tables:
-            try:
-                self.frames_client.delete(backend=_TSDB_BE, table=table_to_delete)
-            except v3io_frames.DeleteError as e:
+            if table_to_delete in self.tables:
+                try:
+                    self.frames_client.delete(
+                        backend=_TSDB_BE, table=self.tables[table_to_delete]
+                    )
+                except v3io_frames.DeleteError as e:
+                    logger.warning(
+                        f"Failed to delete TSDB table '{table_to_delete}'",
+                        err=mlrun.errors.err_to_str(e),
+                    )
+            else:
                 logger.warning(
-                    f"Failed to delete TSDB table '{table}'",
-                    err=mlrun.errors.err_to_str(e),
+                    f"Skipping deletion: table '{table_to_delete}' is not among the initialized tables.",
+                    initialized_tables=list(self.tables.keys()),
                 )
 
         # Final cleanup of tsdb path

mlrun/model_monitoring/writer.py

@@ -129,10 +129,7 @@ class ModelMonitoringWriter(StepToDict):
             )
         kind = event.pop(WriterEvent.EVENT_KIND, WriterEventKind.RESULT)
         result_event = _AppResultEvent(json.loads(event.pop(WriterEvent.DATA, "{}")))
-        if not result_event:  # BC for < 1.7.0, can be removed in 1.9.0
-            result_event = _AppResultEvent(event)
-        else:
-            result_event.update(_AppResultEvent(event))
+        result_event.update(_AppResultEvent(event))
 
         expected_keys = list(
             set(WriterEvent.list()).difference(

mlrun/projects/operations.py

@@ -309,9 +309,9 @@ def build_function(
     :param force_build: Force building the image, even when no changes were made
     """
     if not overwrite_build_params:
-        # TODO: change overwrite_build_params default to True in 1.9.0
+        # TODO: change overwrite_build_params default to True in 1.10.0
         warnings.warn(
-            "The `overwrite_build_params` parameter default will change from 'False' to 'True' in 1.9.0.",
+            "The `overwrite_build_params` parameter default will change from 'False' to 'True' in 1.10.0.",
             mlrun.utils.OverwriteBuildParamsWarning,
         )
 
@@ -340,7 +340,7 @@ def build_function(
             skip_deployed=skip_deployed,
         )
     else:
-        # TODO: remove filter once overwrite_build_params default is changed to True in 1.9.0
+        # TODO: remove filter once overwrite_build_params default is changed to True in 1.10.0
         with warnings.catch_warnings():
             warnings.simplefilter(
                 "ignore", category=mlrun.utils.OverwriteBuildParamsWarning