mlrun 1.10.0rc6__py3-none-any.whl → 1.10.0rc7__py3-none-any.whl

mlrun/model_monitoring/applications/base.py

@@ -12,9 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import json
 import socket
 from abc import ABC, abstractmethod
+from collections import defaultdict
 from collections.abc import Iterator
+from contextlib import contextmanager
 from datetime import datetime, timedelta
 from typing import Any, Optional, Union, cast
 
@@ -23,14 +26,58 @@ import pandas as pd
 import mlrun
 import mlrun.common.constants as mlrun_constants
 import mlrun.common.schemas.model_monitoring.constants as mm_constants
+import mlrun.datastore.datastore_profile as ds_profile
 import mlrun.errors
 import mlrun.model_monitoring.api as mm_api
 import mlrun.model_monitoring.applications.context as mm_context
 import mlrun.model_monitoring.applications.results as mm_results
+import mlrun.model_monitoring.helpers as mm_helpers
 from mlrun.serving.utils import MonitoringApplicationToDict
 from mlrun.utils import logger
 
 
+def _serialize_context_and_result(
+    *,
+    context: mm_context.MonitoringApplicationContext,
+    result: Union[
+        mm_results.ModelMonitoringApplicationResult,
+        mm_results.ModelMonitoringApplicationMetric,
+        mm_results._ModelMonitoringApplicationStats,
+    ],
+) -> dict[mm_constants.WriterEvent, str]:
+    """
+    Serialize the returned result from a model monitoring application and its context
+    for the writer.
+    """
+    writer_event = {
+        mm_constants.WriterEvent.ENDPOINT_NAME: context.endpoint_name,
+        mm_constants.WriterEvent.APPLICATION_NAME: context.application_name,
+        mm_constants.WriterEvent.ENDPOINT_ID: context.endpoint_id,
+        mm_constants.WriterEvent.START_INFER_TIME: context.start_infer_time.isoformat(
+            sep=" ", timespec="microseconds"
+        ),
+        mm_constants.WriterEvent.END_INFER_TIME: context.end_infer_time.isoformat(
+            sep=" ", timespec="microseconds"
+        ),
+    }
+
+    if isinstance(result, mm_results.ModelMonitoringApplicationResult):
+        writer_event[mm_constants.WriterEvent.EVENT_KIND] = (
+            mm_constants.WriterEventKind.RESULT
+        )
+    elif isinstance(result, mm_results._ModelMonitoringApplicationStats):
+        writer_event[mm_constants.WriterEvent.EVENT_KIND] = (
+            mm_constants.WriterEventKind.STATS
+        )
+    else:
+        writer_event[mm_constants.WriterEvent.EVENT_KIND] = (
+            mm_constants.WriterEventKind.METRIC
+        )
+    writer_event[mm_constants.WriterEvent.DATA] = json.dumps(result.to_dict())
+
+    return writer_event
+
+
 class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
     """
     The base class for a model monitoring application.
@@ -118,6 +165,43 @@ class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
             ]
         return result
 
+    @staticmethod
+    @contextmanager
+    def _push_to_writer(
+        *,
+        write_output: bool,
+        stream_profile: Optional[ds_profile.DatastoreProfile],
+    ) -> Iterator[dict[str, list[tuple]]]:
+        endpoints_output: dict[str, list[tuple]] = defaultdict(list)
+        try:
+            yield endpoints_output
+        finally:
+            if write_output:
+                logger.debug(
+                    "Pushing model monitoring application job data to the writer stream",
+                    passed_stream_profile=str(stream_profile),
+                )
+                project_name = (
+                    mlrun.mlconf.active_project or mlrun.get_current_project().name
+                )
+                writer_stream = mm_helpers.get_output_stream(
+                    project=project_name,
+                    function_name=mm_constants.MonitoringFunctionNames.WRITER,
+                    profile=stream_profile,
+                )
+                for endpoint_id, outputs in endpoints_output.items():
+                    writer_stream.push(
+                        [
+                            _serialize_context_and_result(context=ctx, result=res)
+                            for ctx, res in outputs
+                        ],
+                        partition_key=endpoint_id,
+                    )
+                logger.debug(
+                    "Pushed the data to all the relevant model endpoints successfully",
+                    endpoints_output=endpoints_output,
+                )
+
     def _handler(
         self,
         context: "mlrun.MLClientCtx",
@@ -127,6 +211,8 @@ class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
         start: Optional[str] = None,
         end: Optional[str] = None,
         base_period: Optional[int] = None,
+        write_output: bool = False,
+        stream_profile: Optional[ds_profile.DatastoreProfile] = None,
     ):
         """
         A custom handler that wraps the application's logic implemented in
@@ -134,46 +220,69 @@ class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
         for an MLRun job.
         This method should not be called directly.
         """
+
+        if write_output and (
+            not endpoints or sample_data is not None or reference_data is not None
+        ):
+            raise mlrun.errors.MLRunValueError(
+                "Writing the results of an application to the TSDB is possible only when "
+                "working with endpoints, without any custom data-frame input"
+            )
+
         feature_stats = (
             mm_api.get_sample_set_statistics(reference_data)
             if reference_data is not None
             else None
         )
 
-        def call_do_tracking(event: Optional[dict] = None):
-            if event is None:
-                event = {}
-            monitoring_context = mm_context.MonitoringApplicationContext._from_ml_ctx(
-                event=event,
-                application_name=self.__class__.__name__,
-                context=context,
-                sample_df=sample_data,
-                feature_stats=feature_stats,
-            )
-            return self.do_tracking(monitoring_context)
-
-        if endpoints is not None:
-            for window_start, window_end in self._window_generator(
-                start, end, base_period
-            ):
-                for endpoint_name, endpoint_id in endpoints:
-                    result = call_do_tracking(
-                        event={
-                            mm_constants.ApplicationEvent.ENDPOINT_NAME: endpoint_name,
-                            mm_constants.ApplicationEvent.ENDPOINT_ID: endpoint_id,
-                            mm_constants.ApplicationEvent.START_INFER_TIME: window_start,
-                            mm_constants.ApplicationEvent.END_INFER_TIME: window_end,
-                        }
-                    )
-                    result_key = (
-                        f"{endpoint_name}-{endpoint_id}_{window_start.isoformat()}_{window_end.isoformat()}"
-                        if window_start and window_end
-                        else f"{endpoint_name}-{endpoint_id}"
+        with self._push_to_writer(
+            write_output=write_output, stream_profile=stream_profile
+        ) as endpoints_output:
+
+            def call_do_tracking(event: Optional[dict] = None):
+                nonlocal endpoints_output
+
+                if event is None:
+                    event = {}
+                monitoring_context = (
+                    mm_context.MonitoringApplicationContext._from_ml_ctx(
+                        event=event,
+                        application_name=self.__class__.__name__,
+                        context=context,
+                        sample_df=sample_data,
+                        feature_stats=feature_stats,
                     )
+                )
+                result = self.do_tracking(monitoring_context)
+                endpoints_output[monitoring_context.endpoint_id].append(
+                    (monitoring_context, result)
+                )
+                return result
+
+            if endpoints is not None:
+                for window_start, window_end in self._window_generator(
+                    start, end, base_period
+                ):
+                    for endpoint_name, endpoint_id in endpoints:
+                        result = call_do_tracking(
+                            event={
+                                mm_constants.ApplicationEvent.ENDPOINT_NAME: endpoint_name,
+                                mm_constants.ApplicationEvent.ENDPOINT_ID: endpoint_id,
+                                mm_constants.ApplicationEvent.START_INFER_TIME: window_start,
+                                mm_constants.ApplicationEvent.END_INFER_TIME: window_end,
+                            }
+                        )
+                        result_key = (
+                            f"{endpoint_name}-{endpoint_id}_{window_start.isoformat()}_{window_end.isoformat()}"
+                            if window_start and window_end
+                            else f"{endpoint_name}-{endpoint_id}"
+                        )
 
-                    context.log_result(result_key, self._flatten_data_result(result))
-        else:
-            return self._flatten_data_result(call_do_tracking())
+                        context.log_result(
+                            result_key, self._flatten_data_result(result)
+                        )
+            else:
+                return self._flatten_data_result(call_do_tracking())
 
     @staticmethod
     def _handle_endpoints_type_evaluate(
@@ -338,6 +447,7 @@ class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
         * ``start``, ``datetime``
         * ``end``, ``datetime``
         * ``base_period``, ``int``
+        * ``write_output``, ``bool``
 
         For Git sources, add the source archive to the returned job and change the handler:
 
@@ -420,6 +530,8 @@ class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
         start: Optional[datetime] = None,
         end: Optional[datetime] = None,
         base_period: Optional[int] = None,
+        write_output: bool = False,
+        stream_profile: Optional[ds_profile.DatastoreProfile] = None,
     ) -> "mlrun.RunObject":
         """
         Call this function to run the application's
@@ -470,6 +582,14 @@ class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
                                   ..., (\\operatorname{start} +
                                   m\\cdot\\operatorname{base\\_period}, \\operatorname{end}]`,
                                   where :math:`m` is some positive integer.
+        :param write_output:      Whether to write the results and metrics to the time-series DB. Can be ``True`` only
+                                  if ``endpoints`` are passed.
+                                  Note: the model monitoring infrastructure must be up for the writing to work.
+        :param stream_profile:    The stream datastore profile. It should be provided only when running locally and
+                                  writing the outputs to the database (i.e., when both ``run_local`` and
+                                  ``write_output`` are set to ``True``).
+                                  For more details on configuring the stream profile, see
+                                  :py:meth:`~mlrun.projects.MlrunProject.set_model_monitoring_credentials`.
 
         :returns: The output of the
                   :py:meth:`~mlrun.model_monitoring.applications.ModelMonitoringApplicationBase.do_tracking`
@@ -507,10 +627,25 @@ class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
                 )
                 params["end"] = end.isoformat() if isinstance(end, datetime) else end
                 params["base_period"] = base_period
+                params["write_output"] = write_output
+                if stream_profile:
+                    if not run_local:
+                        raise mlrun.errors.MLRunValueError(
+                            "Passing a `stream_profile` is relevant only when running locally"
+                        )
+                    if not write_output:
+                        raise mlrun.errors.MLRunValueError(
+                            "Passing a `stream_profile` is relevant only when writing the outputs"
+                        )
+                params["stream_profile"] = stream_profile
         elif start or end or base_period:
             raise mlrun.errors.MLRunValueError(
                 "Custom `start` and `end` times or base_period are supported only with endpoints data"
             )
+        elif write_output or stream_profile:
+            raise mlrun.errors.MLRunValueError(
+                "Writing the application output or passing `stream_profile` are supported only with endpoints data"
+            )
 
         inputs: dict[str, str] = {}
         for data, identifier in [

mlrun/model_monitoring/helpers.py

@@ -22,14 +22,11 @@ import numpy as np
 import pandas as pd
 
 import mlrun
-import mlrun.artifacts
 import mlrun.common.model_monitoring.helpers
 import mlrun.common.schemas.model_monitoring.constants as mm_constants
 import mlrun.data_types.infer
 import mlrun.datastore.datastore_profile
-import mlrun.model_monitoring
 import mlrun.platforms.iguazio
-import mlrun.utils.helpers
 from mlrun.common.schemas import ModelEndpoint
 from mlrun.common.schemas.model_monitoring.model_endpoints import (
     ModelEndpointMonitoringMetric,

mlrun/projects/operations.py

@@ -281,7 +281,7 @@ def build_function(
     mlrun_version_specifier=None,
     builder_env: Optional[dict] = None,
     project_object=None,
-    overwrite_build_params: bool = False,
+    overwrite_build_params: bool = True,
     extra_args: Optional[str] = None,
     force_build: bool = False,
 ) -> Union[BuildStatus, mlrun_pipelines.models.PipelineNodeWrapper]:
@@ -308,13 +308,6 @@ def build_function(
         e.g. extra_args="--skip-tls-verify --build-arg A=val"
     :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.10.0
-        warnings.warn(
-            "The `overwrite_build_params` parameter default will change from 'False' to 'True' in 1.10.0.",
-            mlrun.utils.OverwriteBuildParamsWarning,
-        )
-
     engine, function = _get_engine_and_function(function, project_object)
     if function.kind in mlrun.runtimes.RuntimeKinds.nuclio_runtimes():
         raise mlrun.errors.MLRunInvalidArgumentError(
@@ -340,22 +333,16 @@ def build_function(
             skip_deployed=skip_deployed,
         )
     else:
-        # 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
-            )
-
-            function.build_config(
-                image=image,
-                base_image=base_image,
-                commands=commands,
-                secret=secret_name,
-                requirements=requirements,
-                requirements_file=requirements_file,
-                overwrite=overwrite_build_params,
-                extra_args=extra_args,
-            )
+        function.build_config(
+            image=image,
+            base_image=base_image,
+            commands=commands,
+            secret=secret_name,
+            requirements=requirements,
+            requirements_file=requirements_file,
+            overwrite=overwrite_build_params,
+            extra_args=extra_args,
+        )
         ready = function.deploy(
             watch=True,
             with_mlrun=with_mlrun,

mlrun/projects/project.py

@@ -757,14 +757,7 @@ def _project_instance_from_struct(struct, name, allow_cross_project):
             "3. Use different project context dir."
         )
 
-        if allow_cross_project is None:
-            # TODO: Remove this warning in version 1.10.0 and also fix cli to support allow_cross_project
-            warnings.warn(
-                f"Project {name=} is different than specified on the context's project yaml. "
-                "This behavior is deprecated and will not be supported from version 1.10.0."
-            )
-            logger.warn(error_message)
-        elif allow_cross_project:
+        if allow_cross_project:
             logger.debug(
                 "Project name is different than specified on the context's project yaml. Overriding.",
                 existing_name=name_from_struct,
@@ -4111,7 +4104,7 @@ class MlrunProject(ModelObj):
         requirements: Optional[typing.Union[str, list[str]]] = None,
         mlrun_version_specifier: Optional[str] = None,
         builder_env: Optional[dict] = None,
-        overwrite_build_params: bool = False,
+        overwrite_build_params: bool = True,
         requirements_file: Optional[str] = None,
         extra_args: Optional[str] = None,
         force_build: bool = False,
@@ -4167,7 +4160,7 @@ class MlrunProject(ModelObj):
         commands: Optional[list] = None,
         secret_name: Optional[str] = None,
         requirements: Optional[typing.Union[str, list[str]]] = None,
-        overwrite_build_params: bool = False,
+        overwrite_build_params: bool = True,
         requirements_file: Optional[str] = None,
         builder_env: Optional[dict] = None,
         extra_args: Optional[str] = None,
@@ -4197,12 +4190,6 @@ class MlrunProject(ModelObj):
         :param source_code_target_dir: Path on the image where source code would be extracted
             (by default `/home/mlrun_code`)
         """
-        if not overwrite_build_params:
-            # 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.10.0.",
-                mlrun.utils.OverwriteBuildParamsWarning,
-            )
         default_image_name = mlrun.mlconf.default_project_image_name.format(
             name=self.name
         )
@@ -4236,7 +4223,7 @@ class MlrunProject(ModelObj):
         requirements: Optional[typing.Union[str, list[str]]] = None,
         mlrun_version_specifier: Optional[str] = None,
         builder_env: Optional[dict] = None,
-        overwrite_build_params: bool = False,
+        overwrite_build_params: bool = True,
         requirements_file: Optional[str] = None,
         extra_args: Optional[str] = None,
         target_dir: Optional[str] = None,
@@ -4276,60 +4263,47 @@ class MlrunProject(ModelObj):
                 base_image=base_image,
             )
 
-        if not overwrite_build_params:
-            # 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.10.0.",
-                mlrun.utils.OverwriteBuildParamsWarning,
-            )
+        self.build_config(
+            image=image,
+            set_as_default=set_as_default,
+            base_image=base_image,
+            commands=commands,
+            secret_name=secret_name,
+            with_mlrun=with_mlrun,
+            requirements=requirements,
+            requirements_file=requirements_file,
+            overwrite_build_params=overwrite_build_params,
+        )
 
-        # TODO: remove filter once overwrite_build_params default is changed to True in 1.8.0
-        with warnings.catch_warnings():
-            warnings.simplefilter(
-                "ignore", category=mlrun.utils.OverwriteBuildParamsWarning
-            )
+        function = mlrun.new_function("mlrun--project--image--builder", kind="job")
 
-            self.build_config(
-                image=image,
-                set_as_default=set_as_default,
-                base_image=base_image,
-                commands=commands,
-                secret_name=secret_name,
-                with_mlrun=with_mlrun,
-                requirements=requirements,
-                requirements_file=requirements_file,
-                overwrite_build_params=overwrite_build_params,
+        if self.spec.source and not self.spec.load_source_on_run:
+            function.with_source_archive(
+                source=self.spec.source,
+                target_dir=target_dir,
+                pull_at_runtime=False,
             )
 
-            function = mlrun.new_function("mlrun--project--image--builder", kind="job")
-
-            if self.spec.source and not self.spec.load_source_on_run:
-                function.with_source_archive(
-                    source=self.spec.source,
-                    target_dir=target_dir,
-                    pull_at_runtime=False,
-                )
-
-            build = self.spec.build
-            result = self.build_function(
-                function=function,
-                with_mlrun=build.with_mlrun,
-                image=build.image,
-                base_image=build.base_image,
-                commands=build.commands,
-                secret_name=build.secret,
-                requirements=build.requirements,
-                overwrite_build_params=overwrite_build_params,
-                mlrun_version_specifier=mlrun_version_specifier,
-                builder_env=builder_env,
-                extra_args=extra_args,
-                force_build=True,
-            )
+        build = self.spec.build
+        result = self.build_function(
+            function=function,
+            with_mlrun=build.with_mlrun,
+            image=build.image,
+            base_image=build.base_image,
+            commands=build.commands,
+            secret_name=build.secret,
+            requirements=build.requirements,
+            overwrite_build_params=overwrite_build_params,
+            mlrun_version_specifier=mlrun_version_specifier,
+            builder_env=builder_env,
+            extra_args=extra_args,
+            force_build=True,
+        )
 
-            # Get the enriched target dir from the function
-            self.spec.build.source_code_target_dir = (
-                function.spec.build.source_code_target_dir
-            )
+        # Get the enriched target dir from the function
+        self.spec.build.source_code_target_dir = (
+            function.spec.build.source_code_target_dir
+        )
 
         try:
             mlrun.db.get_run_db(secrets=self._secrets).delete_function(
@@ -5015,9 +4989,6 @@ class MlrunProject(ModelObj):
         name: Optional[str] = None,
         uid: Optional[Union[str, list[str]]] = None,
         labels: Optional[Union[str, dict[str, Optional[str]], list[str]]] = None,
-        state: Optional[
-            mlrun.common.runtimes.constants.RunStates
-        ] = None,  # Backward compatibility
         states: typing.Optional[list[mlrun.common.runtimes.constants.RunStates]] = None,
         sort: bool = True,
         iter: bool = False,
@@ -5061,7 +5032,6 @@ class MlrunProject(ModelObj):
                        - A comma-separated string formatted as `"label1=value1,label2"` to match entities with
                          the specified key-value pairs or key existence.
 
-        :param state: Deprecated - List only runs whose state is specified.
         :param states: List only runs whose state is one of the provided states.
         :param sort: Whether to sort the result according to their start time. Otherwise, results will be
             returned by their internal order in the DB (order will not be guaranteed).
@@ -5075,24 +5045,13 @@ class MlrunProject(ModelObj):
         :param end_time_from: Filter by run end time in ``[end_time_from, end_time_to]``.
         :param end_time_to: Filter by run end time in ``[end_time_from, end_time_to]``.
         """
-        if state:
-            # TODO: Remove this in 1.10.0
-            warnings.warn(
-                "'state' is deprecated in 1.7.0 and will be removed in 1.10.0. Use 'states' instead.",
-                FutureWarning,
-            )
-
         db = mlrun.db.get_run_db(secrets=self._secrets)
         return db.list_runs(
             name,
             uid,
             self.metadata.name,
             labels=labels,
-            states=(
-                mlrun.utils.helpers.as_list(state)
-                if state is not None
-                else states or None
-            ),
+            states=states or None,
             sort=sort,
             iter=iter,
             start_time_from=start_time_from,

mlrun/runtimes/daskjob.py

@@ -92,6 +92,7 @@ class DaskSpec(KubeResourceSpec):
         preemption_mode=None,
         security_context=None,
         state_thresholds=None,
+        serving_spec=None,
     ):
         super().__init__(
             command=command,
@@ -121,6 +122,7 @@ class DaskSpec(KubeResourceSpec):
             preemption_mode=preemption_mode,
             security_context=security_context,
             state_thresholds=state_thresholds,
+            serving_spec=serving_spec,
         )
         self.args = args
 

mlrun/runtimes/kubejob.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import typing
-import warnings
 
 import mlrun.common.schemas
 import mlrun.db
@@ -83,7 +82,7 @@ class KubejobRuntime(KubeResource):
         with_mlrun=None,
         auto_build=None,
         requirements=None,
-        overwrite=False,
+        overwrite=True,
         prepare_image_for_deploy=True,
         requirements_file=None,
         builder_env=None,
@@ -113,12 +112,6 @@ class KubejobRuntime(KubeResource):
         :param builder_env: Kaniko builder pod env vars dict (for config/credentials)
             e.g. builder_env={"GIT_TOKEN": token}
         """
-        if not overwrite:
-            # TODO: change overwrite default to True in 1.10.0
-            warnings.warn(
-                "The `overwrite` parameter default will change from 'False' to 'True' in 1.10.0.",
-                mlrun.utils.OverwriteBuildParamsWarning,
-            )
         image = mlrun.utils.helpers.remove_image_protocol_prefix(image)
         self.spec.build.build_config(
             image=image,
@@ -214,3 +207,7 @@ class KubejobRuntime(KubeResource):
         raise NotImplementedError(
             f"Running a {self.kind} function from the client is not supported. Use .run() to submit the job to the API."
         )
+
+    @property
+    def serving_spec(self):
+        return self.spec.serving_spec

mlrun/runtimes/mpijob/abstract.py

@@ -54,6 +54,7 @@ class MPIResourceSpec(KubeResourceSpec):
         preemption_mode=None,
         security_context=None,
         state_thresholds=None,
+        serving_spec=None,
     ):
         super().__init__(
             command=command,
@@ -83,6 +84,7 @@ class MPIResourceSpec(KubeResourceSpec):
             preemption_mode=preemption_mode,
             security_context=security_context,
             state_thresholds=state_thresholds,
+            serving_spec=serving_spec,
         )
         self.mpi_args = mpi_args or [
             "-x",

mlrun/runtimes/mpijob/v1.py

@@ -49,6 +49,7 @@ class MPIV1ResourceSpec(MPIResourceSpec):
         preemption_mode=None,
         security_context=None,
         state_thresholds=None,
+        serving_spec=None,
     ):
         super().__init__(
             command=command,
@@ -79,6 +80,7 @@ class MPIV1ResourceSpec(MPIResourceSpec):
             preemption_mode=preemption_mode,
             security_context=security_context,
             state_thresholds=state_thresholds,
+            serving_spec=serving_spec,
         )
         self.clean_pod_policy = clean_pod_policy or MPIJobV1CleanPodPolicies.default()
 

mlrun/runtimes/nuclio/function.py

@@ -154,6 +154,7 @@ class NuclioSpec(KubeResourceSpec):
         add_templated_ingress_host_mode=None,
         state_thresholds=None,
         disable_default_http_trigger=None,
+        serving_spec=None,
     ):
         super().__init__(
             command=command,
@@ -183,6 +184,7 @@ class NuclioSpec(KubeResourceSpec):
             preemption_mode=preemption_mode,
             security_context=security_context,
             state_thresholds=state_thresholds,
+            serving_spec=serving_spec,
         )
 
         self.base_spec = base_spec or {}