mlrun 1.10.0rc10__py3-none-any.whl → 1.10.0rc11__py3-none-any.whl

mlrun/model_monitoring/applications/base.py

@@ -19,7 +19,7 @@ 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
+from typing import Any, Literal, Optional, Union, cast
 
 import pandas as pd
 
@@ -223,7 +223,9 @@ class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
         context: "mlrun.MLClientCtx",
         sample_data: Optional[pd.DataFrame] = None,
         reference_data: Optional[pd.DataFrame] = None,
-        endpoints: Optional[Union[list[tuple[str, str]], list[str], str]] = None,
+        endpoints: Union[
+            list[tuple[str, str]], list[list[str]], list[str], Literal["all"], None
+        ] = None,
         start: Optional[str] = None,
         end: Optional[str] = None,
         base_period: Optional[int] = None,
@@ -280,10 +282,13 @@ class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
                 return result
 
             if endpoints is not None:
+                resolved_endpoints = self._handle_endpoints_type_evaluate(
+                    project=project, endpoints=endpoints
+                )
                 for window_start, window_end in self._window_generator(
                     start, end, base_period
                 ):
-                    for endpoint_name, endpoint_id in endpoints:
+                    for endpoint_name, endpoint_id in resolved_endpoints:
                         result = call_do_tracking(
                             event={
                                 mm_constants.ApplicationEvent.ENDPOINT_NAME: endpoint_name,
@@ -306,52 +311,63 @@ class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
 
     @staticmethod
     def _handle_endpoints_type_evaluate(
-        project: str,
-        endpoints: Union[list[tuple[str, str]], list[str], str, None],
-    ) -> list[tuple[str, str]]:
-        if endpoints:
-            if isinstance(endpoints, str) or (
-                isinstance(endpoints, list) and isinstance(endpoints[0], str)
-            ):
-                endpoints_list = (
-                    mlrun.get_run_db()
-                    .list_model_endpoints(
-                        project,
-                        names=endpoints,
-                        latest_only=True,
+        project: "mlrun.MlrunProject",
+        endpoints: Union[
+            list[tuple[str, str]], list[list[str]], list[str], Literal["all"]
+        ],
+    ) -> Union[list[tuple[str, str]], list[list[str]]]:
+        if not endpoints:
+            raise mlrun.errors.MLRunValueError(
+                "The endpoints list cannot be empty. If you want to run on all the endpoints, "
+                'use `endpoints="all"`.'
+            )
+
+        if isinstance(endpoints, list) and isinstance(endpoints[0], (tuple, list)):
+            return endpoints
+
+        if not (isinstance(endpoints, list) and isinstance(endpoints[0], str)):
+            if isinstance(endpoints, str):
+                if endpoints != "all":
+                    raise mlrun.errors.MLRunValueError(
+                        'A string input for `endpoints` can only be "all" for all the model endpoints in '
+                        "the project. If you want to select a single model endpoint with the given name, "
+                        f'use a list: `endpoints=["{endpoints}"]`.'
                     )
-                    .endpoints
+            else:
+                raise mlrun.errors.MLRunValueError(
+                    f"Could not resolve endpoints as list of [(name, uid)], {endpoints=}"
                 )
-                if endpoints_list:
-                    list_endpoints_result = [
-                        (endpoint.metadata.name, endpoint.metadata.uid)
-                        for endpoint in endpoints_list
-                    ]
-                    retrieve_ep_names = list(
-                        map(lambda endpoint: endpoint[0], list_endpoints_result)
-                    )
-                    missing = set(
-                        [endpoints] if isinstance(endpoints, str) else endpoints
-                    ) - set(retrieve_ep_names)
-                    if missing:
-                        logger.warning(
-                            "Could not list all the required endpoints.",
-                            missing_endpoint=missing,
-                            endpoints=list_endpoints_result,
-                        )
-                    endpoints = list_endpoints_result
-                else:
-                    raise mlrun.errors.MLRunNotFoundError(
-                        f"Did not find any model_endpoint named ' {endpoints}'"
-                    )
 
-            if not (
-                isinstance(endpoints, list) and isinstance(endpoints[0], (list, tuple))
-            ):
-                raise mlrun.errors.MLRunInvalidArgumentError(
-                    "Could not resolve endpoints as list of [(name, uid)]"
-                )
-        return endpoints
+        if endpoints == "all":
+            endpoint_names = None
+        else:
+            endpoint_names = endpoints
+
+        endpoints_list = project.list_model_endpoints(
+            names=endpoint_names, latest_only=True
+        ).endpoints
+        if endpoints_list:
+            list_endpoints_result = [
+                (endpoint.metadata.name, endpoint.metadata.uid)
+                for endpoint in endpoints_list
+            ]
+            if endpoints != "all":
+                missing = set(endpoints) - {
+                    endpoint[0] for endpoint in list_endpoints_result
+                }
+                if missing:
+                    logger.warning(
+                        "Could not list all the required endpoints",
+                        missing_endpoint=missing,
+                        endpoints=list_endpoints_result,
+                    )
+            return list_endpoints_result
+        else:
+            if endpoints != "all":
+                err_msg_suffix = f" named '{endpoints}'"
+            raise mlrun.errors.MLRunNotFoundError(
+                f"Did not find any model endpoints {err_msg_suffix}"
+            )
 
     @staticmethod
     def _window_generator(
@@ -546,7 +562,7 @@ class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
         class_handler: Optional[str] = None,
         requirements: Optional[Union[str, list[str]]] = None,
         requirements_file: str = "",
-        endpoints: Optional[Union[list[tuple[str, str]], list[str], str]] = None,
+        endpoints: Union[list[tuple[str, str]], list[str], Literal["all"], None] = None,
         start: Optional[datetime] = None,
         end: Optional[datetime] = None,
         base_period: Optional[int] = None,
@@ -577,10 +593,16 @@ class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
         :param class_handler:     The relative path to the class, useful when using Git sources or code from images.
         :param requirements:      List of Python requirements to be installed in the image.
         :param requirements_file: Path to a Python requirements file to be installed in the image.
-        :param endpoints:         A list of tuples of the model endpoint (name, uid) to get the data from.
-                                  allow providing a list of model_endpoint names or name for a single model_endpoint.
-                                  Note: provide names retrieves the model all the active model endpoints using those
-                                  names (cross function model endpoints)
+        :param endpoints:         The model endpoints to get the data from. The options are:
+
+                                  - a list of tuples of the model endpoints ``[(name, uid), ...]``
+                                  - a list of model endpoint names ``[name, ...]``
+                                  - ``"all"`` for all the project's model endpoints
+
+                                  Note: a model endpoint name retrieves all the active model endpoints using this
+                                  name, which may be more than one per name when the same name is used across
+                                  multiple serving functions.
+
                                   If provided, and ``sample_data`` is not ``None``, you have to provide also the
                                   ``start`` and ``end`` times of the data to analyze from the model endpoints.
         :param start:             The start time of the endpoint's data, not included.
@@ -629,12 +651,8 @@ class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
             project=project,
         )
 
-        params: dict[str, Union[list[tuple[str, str]], str, int, None]] = {}
+        params: dict[str, Union[list, str, int, None, ds_profile.DatastoreProfile]] = {}
         if endpoints:
-            endpoints = cls._handle_endpoints_type_evaluate(
-                project=project.name,
-                endpoints=endpoints,
-            )
             params["endpoints"] = endpoints
             if sample_data is None:
                 if start is None or end is None:

mlrun/model_monitoring/db/tsdb/base.py

@@ -358,6 +358,58 @@ class TSDBConnector(ABC):
                  }
         """
 
+    @abstractmethod
+    def count_processed_model_endpoints(
+        self,
+        start: Optional[Union[datetime, str]] = None,
+        end: Optional[Union[datetime, str]] = None,
+        application_names: Optional[Union[str, list[str]]] = None,
+    ) -> dict[str, int]:
+        """
+        Count the number of processed model endpoints within a given time range for specific applications.
+        :param start:              The start time of the query. Last 24 hours is used by default.
+        :param end:                The end time of the query. The current time is used by default.
+        :param application_names:  A list of application names to filter the results by. If not provided, all
+                                   applications are included.
+        :return:                   The count of processed model endpoints.
+        """
+
+    @abstractmethod
+    def calculate_latest_metrics(
+        self,
+        start: Optional[Union[datetime, str]] = None,
+        end: Optional[Union[datetime, str]] = None,
+        application_names: Optional[Union[str, list[str]]] = None,
+    ) -> list[
+        Union[mm_schemas.ApplicationResultRecord, mm_schemas.ApplicationMetricRecord]
+    ]:
+        """
+        Calculate the latest metrics and results across applications.
+        :param start:              The start time of the query. Last 24 hours is used by default.
+        :param end:                The end time of the query. The current time is used by default.
+        :param application_names:  A list of application names to filter the results by. If not provided, all
+                                   applications are included.
+        :return:                   A list containing the latest metrics and results for each application.
+                                   example::
+                                   [
+                                       {
+                                           "type": "metric",
+                                           "time": "2025-06-29 13:36:37 +00:00",
+                                           "metric_name": "hellinger_mean",
+                                           "value": 0.123456,
+                                       },
+                                        {
+                                             "type": "result",
+                                             "time": "2025-06-29 13:36:37 +00:00",
+                                             "result_name": "drift_status",
+                                             "kind": "2",
+                                             "status": 0,
+                                             "value": 15.4,
+                                        },
+                                       ...
+                                   ]
+        """
+
     async def add_basic_metrics(
         self,
         model_endpoint_objects: list[mlrun.common.schemas.ModelEndpoint],
@@ -651,22 +703,3 @@ class TSDBConnector(ABC):
                 )
             )
         return {dict_key: metrics}
-
-    @staticmethod
-    def _get_start_end(
-        start: Union[datetime, None],
-        end: Union[datetime, None],
-    ) -> tuple[datetime, datetime]:
-        """
-        static utils function for tsdb start end format
-        :param start:       Either None or datetime, None is handled as datetime.min(tz=timezone.utc)
-        :param end:         Either None or datetime, None is handled as datetime.now(tz=timezone.utc)
-        :return:            start datetime, end datetime
-        """
-        start = start or mlrun.utils.datetime_min()
-        end = end or mlrun.utils.datetime_now()
-        if not (isinstance(start, datetime) and isinstance(end, datetime)):
-            raise mlrun.errors.MLRunInvalidArgumentError(
-                "Both start and end must be datetime objects"
-            )
-        return start, end

mlrun/model_monitoring/db/tsdb/tdengine/tdengine_connector.py

@@ -29,7 +29,7 @@ from mlrun.model_monitoring.db.tsdb.tdengine.tdengine_connection import (
     Statement,
     TDEngineConnection,
 )
-from mlrun.model_monitoring.helpers import get_invocations_fqn
+from mlrun.model_monitoring.helpers import get_invocations_fqn, get_start_end
 from mlrun.utils import logger
 
 # Thread-local storage for connections
@@ -689,7 +689,7 @@ class TDEngineConnector(TSDBConnector):
             filter_column=mm_schemas.EventFieldType.ENDPOINT_ID,
             filter_values=endpoint_ids,
         )
-        start, end = self._get_start_end(start, end)
+        start, end = get_start_end(start, end)
         df = self._get_records(
             table=self.tables[mm_schemas.TDEngineSuperTables.PREDICTIONS].super_table,
             start=start,
@@ -734,7 +734,7 @@ class TDEngineConnector(TSDBConnector):
             filter_values=endpoint_ids,
         )
         start = start or (mlrun.utils.datetime_now() - timedelta(hours=24))
-        start, end = self._get_start_end(start, end)
+        start, end = get_start_end(start, end)
         df = self._get_records(
             table=self.tables[mm_schemas.TDEngineSuperTables.APP_RESULTS].super_table,
             start=start,
@@ -768,9 +768,9 @@ class TDEngineConnector(TSDBConnector):
         result_status_list: Optional[list[int]] = None,
     ) -> dict[tuple[str, int], int]:
         filter_query = ""
-        now = mlrun.utils.datetime_now()
-        start = start or (now - timedelta(hours=24))
-        end = end or now
+
+        start, end = get_start_end(start=start, end=end, delta=timedelta(hours=24))
+
         if endpoint_ids:
             filter_query = self._generate_filter_query(
                 filter_column=mm_schemas.EventFieldType.ENDPOINT_ID,
@@ -825,13 +825,182 @@ class TDEngineConnector(TSDBConnector):
             for _, row in df.iterrows()
         }
 
+    def count_processed_model_endpoints(
+        self,
+        start: Optional[Union[datetime, str]] = None,
+        end: Optional[Union[datetime, str]] = None,
+        application_names: Optional[Union[str, list[str]]] = None,
+    ) -> dict:
+        filter_query = ""
+        start, end = get_start_end(start=start, end=end, delta=timedelta(hours=24))
+
+        if application_names:
+            filter_query = self._generate_filter_query(
+                filter_column=mm_schemas.WriterEvent.APPLICATION_NAME,
+                filter_values=application_names,
+            )
+
+        def get_application_endpoints_records(super_table: str) -> pd.DataFrame:
+            return self._get_records(
+                table=super_table,
+                start=start,
+                end=end,
+                timestamp_column=mm_schemas.WriterEvent.END_INFER_TIME,
+                columns=[
+                    mm_schemas.WriterEvent.APPLICATION_NAME,
+                    mm_schemas.EventFieldType.ENDPOINT_ID,
+                ],
+                filter_query=filter_query,
+                group_by=[
+                    mm_schemas.WriterEvent.APPLICATION_NAME,
+                    mm_schemas.EventFieldType.ENDPOINT_ID,
+                ],
+                preform_agg_columns=[mm_schemas.ResultData.RESULT_VALUE],
+                agg_funcs=["last"],
+            )
+
+        df_results = get_application_endpoints_records(
+            super_table=self.tables[
+                mm_schemas.TDEngineSuperTables.APP_RESULTS
+            ].super_table
+        )
+        df_metrics = get_application_endpoints_records(
+            super_table=self.tables[mm_schemas.TDEngineSuperTables.METRICS].super_table
+        )
+
+        combined_df = pd.concat([df_results, df_metrics]).drop_duplicates()
+
+        if combined_df.empty:
+            return {}
+        grouped_df = combined_df.groupby(
+            mm_schemas.WriterEvent.APPLICATION_NAME
+        ).count()
+
+        # Convert DataFrame to a dictionary
+        return grouped_df[mm_schemas.WriterEvent.ENDPOINT_ID].to_dict()
+
+    def calculate_latest_metrics(
+        self,
+        start: Optional[Union[datetime, str]] = None,
+        end: Optional[Union[datetime, str]] = None,
+        application_names: Optional[Union[str, list[str]]] = None,
+    ) -> list[
+        Union[mm_schemas.ApplicationResultRecord, mm_schemas.ApplicationMetricRecord]
+    ]:
+        metric_list = []
+        filter_query = ""
+        start, end = get_start_end(start=start, end=end, delta=timedelta(hours=24))
+
+        if application_names:
+            filter_query = self._generate_filter_query(
+                filter_column=mm_schemas.WriterEvent.APPLICATION_NAME,
+                filter_values=application_names,
+            )
+
+        def get_latest_metrics_records(
+            record_type: Literal["metrics", "results"],
+        ) -> pd.DataFrame:
+            columns = [
+                mm_schemas.WriterEvent.END_INFER_TIME,
+                mm_schemas.WriterEvent.APPLICATION_NAME,
+            ]
+            if record_type == "results":
+                table = self.tables[
+                    mm_schemas.TDEngineSuperTables.APP_RESULTS
+                ].super_table
+                columns += [
+                    mm_schemas.ResultData.RESULT_NAME,
+                    mm_schemas.ResultData.RESULT_VALUE,
+                    mm_schemas.ResultData.RESULT_STATUS,
+                    mm_schemas.ResultData.RESULT_KIND,
+                ]
+                agg_column = mm_schemas.ResultData.RESULT_VALUE
+            else:
+                table = self.tables[mm_schemas.TDEngineSuperTables.METRICS].super_table
+                columns += [
+                    mm_schemas.MetricData.METRIC_NAME,
+                    mm_schemas.MetricData.METRIC_VALUE,
+                ]
+                agg_column = mm_schemas.MetricData.METRIC_VALUE
+
+            return self._get_records(
+                table=table,
+                start=start,
+                end=end,
+                columns=columns,
+                filter_query=filter_query,
+                timestamp_column=mm_schemas.WriterEvent.END_INFER_TIME,
+                # Aggregate per application/metric pair regardless of timestamp
+                group_by=columns[1:],
+                preform_agg_columns=[agg_column],
+                agg_funcs=["last"],
+            )
+
+        df_results = get_latest_metrics_records(record_type="results")
+        df_metrics = get_latest_metrics_records(record_type="metrics")
+
+        if df_results.empty and df_metrics.empty:
+            return metric_list
+
+        def build_metric_objects() -> (
+            list[
+                Union[
+                    mm_schemas.ApplicationResultRecord,
+                    mm_schemas.ApplicationMetricRecord,
+                ]
+            ]
+        ):
+            metric_objects = []
+
+            if not df_results.empty:
+                df_results.rename(
+                    columns={
+                        f"last({mm_schemas.ResultData.RESULT_VALUE})": mm_schemas.ResultData.RESULT_VALUE,
+                    },
+                    inplace=True,
+                )
+                for _, row in df_results.iterrows():
+                    metric_objects.append(
+                        mm_schemas.ApplicationResultRecord(
+                            time=datetime.fromisoformat(
+                                row[mm_schemas.WriterEvent.END_INFER_TIME]
+                            ),
+                            result_name=row[mm_schemas.ResultData.RESULT_NAME],
+                            kind=row[mm_schemas.ResultData.RESULT_KIND],
+                            status=row[mm_schemas.ResultData.RESULT_STATUS],
+                            value=row[mm_schemas.ResultData.RESULT_VALUE],
+                        )
+                    )
+
+            if not df_metrics.empty:
+                df_metrics.rename(
+                    columns={
+                        f"last({mm_schemas.MetricData.METRIC_VALUE})": mm_schemas.MetricData.METRIC_VALUE,
+                    },
+                    inplace=True,
+                )
+                for _, row in df_metrics.iterrows():
+                    metric_objects.append(
+                        mm_schemas.ApplicationMetricRecord(
+                            time=datetime.fromisoformat(
+                                row[mm_schemas.WriterEvent.END_INFER_TIME]
+                            ),
+                            metric_name=row[mm_schemas.MetricData.METRIC_NAME],
+                            value=row[mm_schemas.MetricData.METRIC_VALUE],
+                        )
+                    )
+
+            return metric_objects
+
+        return build_metric_objects()
+
     def get_metrics_metadata(
         self,
         endpoint_id: Union[str, list[str]],
         start: Optional[datetime] = None,
         end: Optional[datetime] = None,
     ) -> pd.DataFrame:
-        start, end = self._get_start_end(start, end)
+        start, end = get_start_end(start, end)
         df = self._get_records(
             table=self.tables[mm_schemas.TDEngineSuperTables.METRICS].super_table,
             start=start,
@@ -871,7 +1040,7 @@ class TDEngineConnector(TSDBConnector):
         start: Optional[datetime] = None,
         end: Optional[datetime] = None,
     ) -> pd.DataFrame:
-        start, end = self._get_start_end(start, end)
+        start, end = get_start_end(start, end)
         df = self._get_records(
             table=self.tables[mm_schemas.TDEngineSuperTables.APP_RESULTS].super_table,
             start=start,
@@ -919,7 +1088,7 @@ class TDEngineConnector(TSDBConnector):
             filter_values=endpoint_ids,
         )
         filter_query += f"AND {mm_schemas.EventFieldType.ERROR_TYPE} = '{mm_schemas.EventFieldType.INFER_ERROR}'"
-        start, end = self._get_start_end(start, end)
+        start, end = get_start_end(start, end)
         df = self._get_records(
             table=self.tables[mm_schemas.TDEngineSuperTables.ERRORS].super_table,
             start=start,
@@ -951,8 +1120,7 @@ class TDEngineConnector(TSDBConnector):
         endpoint_ids = (
             endpoint_ids if isinstance(endpoint_ids, list) else [endpoint_ids]
         )
-        start = start or (mlrun.utils.datetime_now() - timedelta(hours=24))
-        start, end = self._get_start_end(start, end)
+        start, end = get_start_end(start, end, delta=timedelta(hours=24))
         df = self._get_records(
             table=self.tables[mm_schemas.TDEngineSuperTables.PREDICTIONS].super_table,
             start=start,

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

@@ -26,7 +26,7 @@ import mlrun.feature_store.steps
 import mlrun.utils.v3io_clients
 from mlrun.common.schemas import EventFieldType
 from mlrun.model_monitoring.db import TSDBConnector
-from mlrun.model_monitoring.helpers import get_invocations_fqn
+from mlrun.model_monitoring.helpers import get_invocations_fqn, get_start_end
 from mlrun.utils import logger
 
 _TSDB_BE = "tsdb"
@@ -522,7 +522,7 @@ class V3IOTSDBConnector(TSDBConnector):
             try:
                 self.v3io_client.kv.delete(
                     container=self.container,
-                    table=self.last_request_table,
+                    table_path=self.last_request_table,
                     key=endpoint_id,
                 )
             except Exception as e:
@@ -956,8 +956,7 @@ class V3IOTSDBConnector(TSDBConnector):
             filter_values=endpoint_ids,
         )
 
-        start = start or (mlrun.utils.datetime_now() - timedelta(hours=24))
-        start, end = self._get_start_end(start, end)
+        start, end = get_start_end(start, end, delta=timedelta(hours=24))
         res = self._get_records(
             table=mm_schemas.V3IOTSDBTables.APP_RESULTS,
             start=start,
@@ -984,7 +983,7 @@ class V3IOTSDBConnector(TSDBConnector):
         start: Optional[datetime] = None,
         end: Optional[datetime] = None,
     ) -> pd.DataFrame:
-        start, end = self._get_start_end(start, end)
+        start, end = get_start_end(start, end)
         filter_query = self._generate_filter_query(
             filter_key=mm_schemas.ApplicationEvent.ENDPOINT_ID,
             filter_values=endpoint_id,
@@ -1009,7 +1008,7 @@ class V3IOTSDBConnector(TSDBConnector):
         start: Optional[datetime] = None,
         end: Optional[datetime] = None,
     ) -> pd.DataFrame:
-        start, end = self._get_start_end(start, end)
+        start, end = get_start_end(start, end)
         filter_query = self._generate_filter_query(
             filter_key=mm_schemas.ApplicationEvent.ENDPOINT_ID,
             filter_values=endpoint_id,
@@ -1048,7 +1047,7 @@ class V3IOTSDBConnector(TSDBConnector):
             filter_query += f"AND {mm_schemas.EventFieldType.ERROR_TYPE} == '{mm_schemas.EventFieldType.INFER_ERROR}'"
         else:
             filter_query = f"{mm_schemas.EventFieldType.ERROR_TYPE} == '{mm_schemas.EventFieldType.INFER_ERROR}' z"
-        start, end = self._get_start_end(start, end)
+        start, end = get_start_end(start, end)
         res = self._get_records(
             table=mm_schemas.FileTargetKind.ERRORS,
             start=start,
@@ -1085,7 +1084,7 @@ class V3IOTSDBConnector(TSDBConnector):
             filter_values=endpoint_ids,
         )
         start = start or (mlrun.utils.datetime_now() - timedelta(hours=24))
-        start, end = self._get_start_end(start, end)
+        start, end = get_start_end(start, end)
         res = self._get_records(
             table=mm_schemas.V3IOTSDBTables.PREDICTIONS,
             start=start,
@@ -1207,9 +1206,7 @@ class V3IOTSDBConnector(TSDBConnector):
         application_names: Optional[Union[str, list[str]]] = None,
         result_status_list: Optional[list[int]] = None,
     ) -> dict[tuple[str, int], int]:
-        now = mlrun.utils.datetime_now()
-        start = start or (now - timedelta(hours=24))
-        end = end or now
+        start, end = get_start_end(start=start, end=end, delta=timedelta(hours=24))
         filter_query = ""
         if endpoint_ids:
             filter_query = self._generate_filter_query(
@@ -1268,3 +1265,21 @@ class V3IOTSDBConnector(TSDBConnector):
             )
 
             return df[mm_schemas.ResultData.RESULT_VALUE].to_dict()
+
+    def count_processed_model_endpoints(
+        self,
+        start: Optional[Union[datetime, str]] = None,
+        end: Optional[Union[datetime, str]] = None,
+        application_names: Optional[Union[str, list[str]]] = None,
+    ) -> dict[str, int]:
+        raise NotImplementedError
+
+    def calculate_latest_metrics(
+        self,
+        start: Optional[Union[datetime, str]] = None,
+        end: Optional[Union[datetime, str]] = None,
+        application_names: Optional[Union[str, list[str]]] = None,
+    ) -> list[
+        Union[mm_schemas.ApplicationResultRecord, mm_schemas.ApplicationMetricRecord]
+    ]:
+        raise NotImplementedError

mlrun/model_monitoring/helpers.py

@@ -589,3 +589,51 @@ def _get_monitoring_schedules_file_chief_path(
     return os.path.join(
         _get_monitoring_schedules_folder_path(project), f"{project}.json"
     )
+
+
+def get_start_end(
+    start: Union[datetime.datetime, None],
+    end: Union[datetime.datetime, None],
+    delta: Optional[datetime.timedelta] = None,
+) -> tuple[datetime.datetime, datetime.datetime]:
+    """
+    static utils function for tsdb start end format
+    :param start:       Either None or datetime, None is handled as datetime.min(tz=timezone.utc) unless `delta`
+                        is provided.
+    :param end:         Either None or datetime, None is handled as datetime.now(tz=timezone.utc)
+    :param delta:       Optional timedelta to define a time span.
+                        - If both `start` and `end` are provided, `delta` is ignored.
+                        - If only one of `start` or `end` is provided, the other will be
+                          calculated using `delta`.
+                        - If neither `start` nor `end` is provided, `end` defaults to now,
+                          and `start` is calculated as `end - delta`.
+    :return:            start datetime, end datetime
+    """
+
+    if delta and start and end:
+        # If both start and end are provided, delta is ignored
+        pass
+    elif delta:
+        if start and not end:
+            end = start + delta
+        else:
+            end = end or mlrun.utils.datetime_now()
+            start = end - delta
+    else:
+        start = start or mlrun.utils.datetime_min()
+        end = end or mlrun.utils.datetime_now()
+
+    if not (
+        isinstance(start, datetime.datetime) and isinstance(end, datetime.datetime)
+    ):
+        raise mlrun.errors.MLRunInvalidArgumentError(
+            "Both start and end must be datetime objects"
+        )
+
+    if start > end:
+        raise mlrun.errors.MLRunInvalidArgumentError(
+            "The start time must be before the end time. Note that if end time is not provided, "
+            "the current time is used by default"
+        )
+
+    return start, end