mlrun 1.7.0rc32__py3-none-any.whl → 1.7.0rc34__py3-none-any.whl

mlrun/common/schemas/__init__.py

@@ -170,6 +170,7 @@ from .project import (
     Project,
     ProjectDesiredState,
     ProjectMetadata,
+    ProjectOut,
     ProjectOutput,
     ProjectOwner,
     ProjectsOutput,

mlrun/common/schemas/common.py

@@ -38,3 +38,6 @@ class ImageBuilder(pydantic.BaseModel):
     build_pod: typing.Optional[str] = None
     requirements: typing.Optional[list] = None
     source_code_target_dir: typing.Optional[str] = None
+
+    class Config:
+        extra = pydantic.Extra.allow

mlrun/common/schemas/function.py

@@ -119,6 +119,13 @@ class FunctionSpec(pydantic.BaseModel):
     service_account: typing.Optional[ServiceAccount]
     state_thresholds: typing.Optional[StateThresholds]
 
+    class Config:
+        extra = pydantic.Extra.allow
+
 
 class Function(pydantic.BaseModel):
     spec: typing.Optional[FunctionSpec]
+    application: typing.Optional[dict[str, typing.Any]]
+
+    class Config:
+        extra = pydantic.Extra.allow

mlrun/common/schemas/project.py

@@ -100,6 +100,29 @@ class ProjectSpec(pydantic.BaseModel):
         extra = pydantic.Extra.allow
 
 
+class ProjectSpecOut(pydantic.BaseModel):
+    description: typing.Optional[str] = None
+    owner: typing.Optional[str] = None
+    goals: typing.Optional[str] = None
+    params: typing.Optional[dict] = {}
+    functions: typing.Optional[list] = []
+    workflows: typing.Optional[list] = []
+    artifacts: typing.Optional[list] = []
+    artifact_path: typing.Optional[str] = None
+    conda: typing.Optional[str] = None
+    source: typing.Optional[str] = None
+    subpath: typing.Optional[str] = None
+    origin_url: typing.Optional[str] = None
+    desired_state: typing.Optional[ProjectDesiredState] = ProjectDesiredState.online
+    custom_packagers: typing.Optional[list[tuple[str, bool]]] = None
+    default_image: typing.Optional[str] = None
+    build: typing.Any = None
+    default_function_node_selector: typing.Optional[dict] = {}
+
+    class Config:
+        extra = pydantic.Extra.allow
+
+
 class Project(pydantic.BaseModel):
     kind: ObjectKind = pydantic.Field(ObjectKind.project, const=True)
     metadata: ProjectMetadata
@@ -107,6 +130,15 @@ class Project(pydantic.BaseModel):
     status: ObjectStatus = ObjectStatus()
 
 
+# The reason we have a different schema for the response model is that we don't want to validate project.spec.build in
+# the response as the validation was added late and there may be corrupted values in the DB.
+class ProjectOut(pydantic.BaseModel):
+    kind: ObjectKind = pydantic.Field(ObjectKind.project, const=True)
+    metadata: ProjectMetadata
+    spec: ProjectSpecOut = ProjectSpecOut()
+    status: ObjectStatus = ObjectStatus()
+
+
 class ProjectOwner(pydantic.BaseModel):
     username: str
     access_key: str
@@ -134,16 +166,16 @@ class IguazioProject(pydantic.BaseModel):
 
 
 # The format query param controls the project type used:
-# full - Project
+# full - ProjectOut
 # name_only - str
 # summary - ProjectSummary
 # leader - currently only IguazioProject supported
 # The way pydantic handles typing.Union is that it takes the object and tries to coerce it to be the types of the
-# union by the definition order. Therefore we can't currently add generic dict for all leader formats, but we need
+# union by the definition order. Therefore, we can't currently add generic dict for all leader formats, but we need
 # to add a specific classes for them. it's frustrating but couldn't find other workaround, see:
 # https://github.com/samuelcolvin/pydantic/issues/1423, https://github.com/samuelcolvin/pydantic/issues/619
 ProjectOutput = typing.TypeVar(
-    "ProjectOutput", Project, str, ProjectSummary, IguazioProject
+    "ProjectOutput", ProjectOut, str, ProjectSummary, IguazioProject
 )
 
 

mlrun/config.py

@@ -252,7 +252,7 @@ default_config = {
         },
         "application": {
             "default_sidecar_internal_port": 8050,
-            "default_authentication_mode": "accessKey",
+            "default_authentication_mode": mlrun.common.schemas.APIGatewayAuthenticationMode.none,
         },
     },
     # TODO: function defaults should be moved to the function spec config above
@@ -1055,6 +1055,14 @@ class Config:
             resource_requirement.pop(gpu)
         return resource_requirement
 
+    def force_api_gateway_ssl_redirect(self):
+        """
+        Get the default value for the ssl_redirect configuration.
+        In Iguazio we always want to redirect to HTTPS, in other cases we don't.
+        :return: True if we should redirect to HTTPS, False otherwise.
+        """
+        return self.is_running_on_iguazio()
+
     def to_dict(self):
         return copy.deepcopy(self._cfg)
 

mlrun/datastore/base.py

@@ -215,7 +215,11 @@ class DataStore:
                 raise mlrun.errors.MLRunInvalidArgumentError(
                     "When providing start_time or end_time, must provide time_column"
                 )
-            if start_time and end_time and start_time.tzinfo != end_time.tzinfo:
+            if (
+                start_time
+                and end_time
+                and start_time.utcoffset() != end_time.utcoffset()
+            ):
                 raise mlrun.errors.MLRunInvalidArgumentError(
                     "start_time and end_time must have the same time zone"
                 )

mlrun/db/base.py

@@ -175,7 +175,9 @@ class RunDBInterface(ABC):
         pass
 
     @abstractmethod
-    def list_functions(self, name=None, project="", tag="", labels=None):
+    def list_functions(
+        self, name=None, project="", tag="", labels=None, since=None, until=None
+    ):
         pass
 
     @abstractmethod
@@ -688,8 +690,11 @@ class RunDBInterface(ABC):
     @abstractmethod
     def store_api_gateway(
         self,
-        api_gateway: mlrun.common.schemas.APIGateway,
-        project: str = None,
+        api_gateway: Union[
+            mlrun.common.schemas.APIGateway,
+            "mlrun.runtimes.nuclio.api_gateway.APIGateway",
+        ],
+        project: Optional[str] = None,
     ):
         pass
 

mlrun/db/httpdb.py

@@ -1015,7 +1015,7 @@ class HTTPRunDB(RunDBInterface):
             "format": format_,
             "tag": tag,
             "tree": tree,
-            "uid": uid,
+            "object_uid": uid,
         }
         if iter is not None:
             params["iter"] = str(iter)
@@ -1051,7 +1051,7 @@ class HTTPRunDB(RunDBInterface):
             "key": key,
             "tag": tag,
             "tree": tree,
-            "uid": uid,
+            "object_uid": uid,
             "iter": iter,
             "deletion_strategy": deletion_strategy,
         }
@@ -1071,8 +1071,8 @@ class HTTPRunDB(RunDBInterface):
         project=None,
         tag=None,
         labels: Optional[Union[dict[str, str], list[str]]] = None,
-        since=None,
-        until=None,
+        since: Optional[datetime] = None,
+        until: Optional[datetime] = None,
         iter: int = None,
         best_iteration: bool = False,
         kind: str = None,
@@ -1102,8 +1102,8 @@ class HTTPRunDB(RunDBInterface):
         :param tag: Return artifacts assigned this tag.
         :param labels: Return artifacts that have these labels. Labels can either be a dictionary {"label": "value"} or
             a list of "label=value" (match label key and value) or "label" (match just label key) strings.
-        :param since: Not in use in :py:class:`HTTPRunDB`.
-        :param until: Not in use in :py:class:`HTTPRunDB`.
+        :param since: Return artifacts updated after this date (as datetime object).
+        :param until: Return artifacts updated before this date (as datetime object).
         :param iter: Return artifacts from a specific iteration (where ``iter=0`` means the root iteration). If
             ``None`` (default) return artifacts from all iterations.
         :param best_iteration: Returns the artifact which belongs to the best iteration of a given run, in the case of
@@ -1137,6 +1137,8 @@ class HTTPRunDB(RunDBInterface):
             "format": format_,
             "producer_uri": producer_uri,
             "limit": limit,
+            "since": datetime_to_iso(since),
+            "until": datetime_to_iso(until),
         }
         error = "list artifacts"
         endpoint_path = f"projects/{project}/artifacts"
@@ -1260,7 +1262,7 @@ class HTTPRunDB(RunDBInterface):
 
         :param name: Return only functions with a specific name.
         :param project: Return functions belonging to this project. If not specified, the default project is used.
-        :param tag: Return function versions with specific tags.
+        :param tag: Return function versions with specific tags. To return only tagged functions, set tag to ``"*"``.
         :param labels: Return functions that have specific labels assigned to them.
         :param since: Return functions updated after this date (as datetime object).
         :param until: Return functions updated before this date (as datetime object).
@@ -1684,7 +1686,7 @@ class HTTPRunDB(RunDBInterface):
             last_log_timestamp = float(
                 resp.headers.get("x-mlrun-last-timestamp", "0.0")
             )
-            if func.kind in mlrun.runtimes.RuntimeKinds.nuclio_runtimes():
+            if func.kind in mlrun.runtimes.RuntimeKinds.pure_nuclio_deployed_runtimes():
                 mlrun.runtimes.nuclio.function.enrich_nuclio_function_from_headers(
                     func, resp.headers
                 )

mlrun/db/nopdb.py

@@ -178,7 +178,9 @@ class NopDB(RunDBInterface):
     def delete_function(self, name: str, project: str = ""):
         pass
 
-    def list_functions(self, name=None, project="", tag="", labels=None):
+    def list_functions(
+        self, name=None, project="", tag="", labels=None, since=None, until=None
+    ):
         pass
 
     def tag_objects(

mlrun/execution.py

@@ -78,7 +78,6 @@ class MLClientCtx:
         self._tmpfile = tmp
         self._logger = log_stream or logger
         self._log_level = "info"
-        self._matrics_db = None
         self._autocommit = autocommit
         self._notifications = []
         self._state_thresholds = {}
@@ -103,8 +102,7 @@ class MLClientCtx:
         self._error = None
         self._commit = ""
         self._host = None
-        self._start_time = now_date()
-        self._last_update = now_date()
+        self._start_time = self._last_update = now_date()
         self._iteration_results = None
         self._children = []
         self._parent = None

mlrun/model.py

@@ -1490,14 +1490,37 @@ class RunObject(RunTemplate):
             )
         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
@@ -1510,26 +1533,50 @@ class RunObject(RunTemplate):
 
     @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["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,
@@ -1547,12 +1594,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"""

mlrun/model_monitoring/applications/context.py

@@ -56,7 +56,7 @@ class MonitoringApplicationContext(MLClientCtx):
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
 
-    def __post_init__(self):
+    def _enrich_data(self):
         self.application_name: typing.Optional[str] = None
         self.start_infer_time: typing.Optional[pd.Timestamp] = None
         self.end_infer_time: typing.Optional[pd.Timestamp] = None
@@ -87,39 +87,37 @@ class MonitoringApplicationContext(MLClientCtx):
         """
 
         if not context:
-            self = (
+            ctx = (
                 super().from_dict(
                     attrs=attrs.get(mm_constants.ApplicationEvent.MLRUN_CONTEXT, {}),
                     **kwargs,
                 ),
             )
         else:
-            self = context
-            self.__post_init__()
+            ctx = context
+            cls._enrich_data(ctx)
 
-        self.start_infer_time = pd.Timestamp(
+        ctx.start_infer_time = pd.Timestamp(
             attrs.get(mm_constants.ApplicationEvent.START_INFER_TIME)
         )
-        self.end_infer_time = pd.Timestamp(
+        ctx.end_infer_time = pd.Timestamp(
             attrs.get(mm_constants.ApplicationEvent.END_INFER_TIME)
         )
-        self.latest_request = pd.Timestamp(
+        ctx.latest_request = pd.Timestamp(
             attrs.get(mm_constants.ApplicationEvent.LAST_REQUEST)
         )
-        self.application_name = attrs.get(
-            mm_constants.ApplicationEvent.APPLICATION_NAME
-        )
-        self._feature_stats = json.loads(
+        ctx.application_name = attrs.get(mm_constants.ApplicationEvent.APPLICATION_NAME)
+        ctx._feature_stats = json.loads(
             attrs.get(mm_constants.ApplicationEvent.FEATURE_STATS, "{}")
         )
-        self._sample_df_stats = json.loads(
+        ctx._sample_df_stats = json.loads(
             attrs.get(mm_constants.ApplicationEvent.CURRENT_STATS, "{}")
         )
 
-        self.endpoint_id = attrs.get(mm_constants.ApplicationEvent.ENDPOINT_ID)
-        self._model_endpoint = model_endpoint_dict.get(self.endpoint_id)
+        ctx.endpoint_id = attrs.get(mm_constants.ApplicationEvent.ENDPOINT_ID)
+        ctx._model_endpoint = model_endpoint_dict.get(ctx.endpoint_id)
 
-        return self
+        return ctx
 
     @property
     def sample_df(self) -> pd.DataFrame:

mlrun/model_monitoring/controller.py

@@ -328,7 +328,7 @@ class MonitoringApplicationController:
         logger.info("Start running monitoring controller")
         try:
             applications_names = []
-            endpoints = self.db.list_model_endpoints()
+            endpoints = self.db.list_model_endpoints(include_stats=True)
             if not endpoints:
                 logger.info("No model endpoints found", project=self.project)
                 return

mlrun/model_monitoring/db/stores/base/store.py

@@ -94,6 +94,7 @@ class StoreBase(ABC):
         labels: list[str] = None,
         top_level: bool = None,
         uids: list = None,
+        include_stats: bool = None,
     ) -> list[dict[str, typing.Any]]:
         """
         Returns a list of model endpoint dictionaries, supports filtering by model, function, labels or top level.
@@ -107,6 +108,7 @@ class StoreBase(ABC):
                                 key (i.e. "key").
         :param top_level:       If True will return only routers and endpoint that are NOT children of any router.
         :param uids:             List of model endpoint unique ids to include in the result.
+        :param include_stats:   If True, will include model endpoint statistics in the result.
 
         :return: A list of model endpoint dictionaries.
         """

mlrun/model_monitoring/db/stores/sqldb/sql_store.py

@@ -266,22 +266,8 @@ class SQLStoreBase(StoreBase):
         labels: list[str] = None,
         top_level: bool = None,
         uids: list = None,
+        include_stats: bool = None,
     ) -> list[dict[str, typing.Any]]:
-        """
-        Returns a list of model endpoint dictionaries, supports filtering by model, function, labels or top level.
-        By default, when no filters are applied, all available model endpoints for the given project will
-        be listed.
-
-        :param model:           The name of the model to filter by.
-        :param function:        The name of the function to filter by.
-        :param labels:          A list of labels to filter by. Label filters work by either filtering a specific value
-                                of a label (i.e. list("key=value")) or by looking for the existence of a given
-                                key (i.e. "key").
-        :param top_level:       If True will return only routers and endpoint that are NOT children of any router.
-        :param uids:             List of model endpoint unique ids to include in the result.
-
-        :return: A list of model endpoint dictionaries.
-        """
         # Generate an empty model endpoints that will be filled afterwards with model endpoint dictionaries
         endpoint_list = []
 
@@ -291,14 +277,8 @@ class SQLStoreBase(StoreBase):
         # Get the model endpoints records using sqlalchemy ORM
         with create_session(dsn=self._sql_connection_string) as session:
             # Generate the list query
-            query = (
-                session.query(self.model_endpoints_table)
-                .options(
-                    # Exclude these fields when listing model endpoints to avoid returning too much data (ML-6594)
-                    sqlalchemy.orm.defer(mm_schemas.EventFieldType.FEATURE_STATS),
-                    sqlalchemy.orm.defer(mm_schemas.EventFieldType.CURRENT_STATS),
-                )
-                .filter_by(project=self.project)
+            query = session.query(self.model_endpoints_table).filter_by(
+                project=self.project
             )
 
             # Apply filters
@@ -347,6 +327,12 @@ class SQLStoreBase(StoreBase):
                 ):
                     continue
 
+                if not include_stats:
+                    # Exclude these fields when listing model endpoints to avoid returning too much data (ML-6594)
+                    # TODO: Remove stats from table schema (ML-7196)
+                    endpoint_dict.pop(mm_schemas.EventFieldType.FEATURE_STATS)
+                    endpoint_dict.pop(mm_schemas.EventFieldType.CURRENT_STATS)
+
                 endpoint_list.append(endpoint_dict)
 
         return endpoint_list

mlrun/model_monitoring/db/stores/v3io_kv/kv_store.py

@@ -226,24 +226,8 @@ class KVStoreBase(StoreBase):
         labels: list[str] = None,
         top_level: bool = None,
         uids: list = None,
+        include_stats: bool = None,
     ) -> list[dict[str, typing.Any]]:
-        """
-        Returns a list of model endpoint dictionaries, supports filtering by model, function, labels or top level.
-        By default, when no filters are applied, all available model endpoints for the given project will
-        be listed.
-
-        :param model:           The name of the model to filter by.
-        :param function:        The name of the function to filter by.
-        :param labels:          A list of labels to filter by. Label filters work by either filtering a specific value
-                                of a label (i.e. list("key=value")) or by looking for the existence of a given
-                                key (i.e. "key").
-        :param top_level:       If True will return only routers and endpoint that are NOT children of any router.
-        :param uids:            List of model endpoint unique ids to include in the result.
-
-
-        :return: A list of model endpoint dictionaries.
-        """
-
         # # Initialize an empty model endpoints list
         endpoint_list = []
 
@@ -283,9 +267,10 @@ class KVStoreBase(StoreBase):
             endpoint_dict = self.get_model_endpoint(
                 endpoint_id=endpoint_id,
             )
-            # Exclude these fields when listing model endpoints to avoid returning too much data (ML-6594)
-            endpoint_dict.pop(mm_schemas.EventFieldType.FEATURE_STATS)
-            endpoint_dict.pop(mm_schemas.EventFieldType.CURRENT_STATS)
+            if not include_stats:
+                # Exclude these fields when listing model endpoints to avoid returning too much data (ML-6594)
+                endpoint_dict.pop(mm_schemas.EventFieldType.FEATURE_STATS)
+                endpoint_dict.pop(mm_schemas.EventFieldType.CURRENT_STATS)
 
             if labels and not self._validate_labels(
                 endpoint_dict=endpoint_dict, labels=labels

mlrun/model_monitoring/stream_processing.py

@@ -773,6 +773,12 @@ class MapFeatureNames(mlrun.feature_store.steps.MapClass):
 
         feature_values = event[EventFieldType.FEATURES]
         label_values = event[EventFieldType.PREDICTION]
+
+        for index in range(len(feature_values)):
+            feature_value = feature_values[index]
+            if isinstance(feature_value, int):
+                feature_values[index] = float(feature_value)
+
         # Get feature names and label columns
         if endpoint_id not in self.feature_names:
             endpoint_record = mlrun.model_monitoring.helpers.get_endpoint_record(