mlrun 1.6.0rc35__py3-none-any.whl → 1.7.0rc2__py3-none-any.whl

mlrun/model_monitoring/api.py

@@ -45,7 +45,7 @@ def get_or_create_model_endpoint(
     endpoint_id: str = "",
     function_name: str = "",
     context: mlrun.MLClientCtx = None,
-    sample_set_statistics: typing.Dict[str, typing.Any] = None,
+    sample_set_statistics: dict[str, typing.Any] = None,
     drift_threshold: float = None,
     possible_drift_threshold: float = None,
     monitoring_mode: ModelMonitoringMode = ModelMonitoringMode.disabled,
@@ -82,7 +82,7 @@ def get_or_create_model_endpoint(
     if not endpoint_id:
         # Generate a new model endpoint id based on the project name and model name
         endpoint_id = hashlib.sha1(
-            f"{project}_{model_endpoint_name}".encode("utf-8")
+            f"{project}_{model_endpoint_name}".encode()
         ).hexdigest()
 
     if not db_session:
@@ -239,7 +239,7 @@ def record_results(
 def _model_endpoint_validations(
     model_endpoint: ModelEndpoint,
     model_path: str = "",
-    sample_set_statistics: typing.Dict[str, typing.Any] = None,
+    sample_set_statistics: dict[str, typing.Any] = None,
     drift_threshold: float = None,
     possible_drift_threshold: float = None,
 ):
@@ -307,7 +307,7 @@ def get_drift_thresholds_if_not_none(
     model_endpoint: ModelEndpoint,
     drift_threshold: float = None,
     possible_drift_threshold: float = None,
-) -> typing.Tuple[float, float]:
+) -> tuple[float, float]:
     """
     Get drift and possible drift thresholds. If one of the thresholds is missing, will try to retrieve
     it from the `ModelEndpoint` object. If not defined under the `ModelEndpoint` as well, will retrieve it from
@@ -386,7 +386,7 @@ def _generate_model_endpoint(
     model_endpoint_name: str,
     function_name: str,
     context: mlrun.MLClientCtx,
-    sample_set_statistics: typing.Dict[str, typing.Any],
+    sample_set_statistics: dict[str, typing.Any],
     drift_threshold: float,
     possible_drift_threshold: float,
     monitoring_mode: ModelMonitoringMode = ModelMonitoringMode.disabled,
@@ -452,8 +452,8 @@ def _generate_model_endpoint(
 def trigger_drift_batch_job(
     project: str,
     default_batch_image="mlrun/mlrun",
-    model_endpoints_ids: typing.List[str] = None,
-    batch_intervals_dict: typing.Dict[str, float] = None,
+    model_endpoints_ids: list[str] = None,
+    batch_intervals_dict: dict[str, float] = None,
     db_session=None,
 ):
     """
@@ -476,9 +476,7 @@ def trigger_drift_batch_job(
         db_session = mlrun.get_run_db()
 
     # Register the monitoring batch job (do nothing if already exist) and get the job function as a dictionary
-    batch_function_dict: typing.Dict[
-        str, typing.Any
-    ] = db_session.deploy_monitoring_batch_job(
+    batch_function_dict: dict[str, typing.Any] = db_session.deploy_monitoring_batch_job(
         project=project,
         default_batch_image=default_batch_image,
     )
@@ -495,8 +493,8 @@ def trigger_drift_batch_job(
 
 
 def _generate_job_params(
-    model_endpoints_ids: typing.List[str],
-    batch_intervals_dict: typing.Dict[str, float] = None,
+    model_endpoints_ids: list[str],
+    batch_intervals_dict: dict[str, float] = None,
 ):
     """
     Generate the required params for the model monitoring batch job function.
@@ -519,9 +517,9 @@ def _generate_job_params(
 def get_sample_set_statistics(
     sample_set: DatasetType = None,
     model_artifact_feature_stats: dict = None,
-    sample_set_columns: typing.Optional[typing.List] = None,
-    sample_set_drop_columns: typing.Optional[typing.List] = None,
-    sample_set_label_columns: typing.Optional[typing.List] = None,
+    sample_set_columns: typing.Optional[list] = None,
+    sample_set_drop_columns: typing.Optional[list] = None,
+    sample_set_label_columns: typing.Optional[list] = None,
 ) -> dict:
     """
     Get the sample set statistics either from the given sample set or the statistics logged with the model while
@@ -576,10 +574,10 @@ def get_sample_set_statistics(
 
 def read_dataset_as_dataframe(
     dataset: DatasetType,
-    feature_columns: typing.Union[str, typing.List[str]] = None,
-    label_columns: typing.Union[str, typing.List[str]] = None,
-    drop_columns: typing.Union[str, typing.List[str], int, typing.List[int]] = None,
-) -> typing.Tuple[pd.DataFrame, typing.List[str]]:
+    feature_columns: typing.Union[str, list[str]] = None,
+    label_columns: typing.Union[str, list[str]] = None,
+    drop_columns: typing.Union[str, list[str], int, list[int]] = None,
+) -> tuple[pd.DataFrame, list[str]]:
     """
     Parse the given dataset into a DataFrame and drop the columns accordingly. In addition, the label columns will be
     parsed and validated as well.
@@ -670,7 +668,7 @@ def perform_drift_analysis(
     possible_drift_threshold: float,
     artifacts_tag: str = "",
     db_session=None,
-):
+) -> None:
     """
     Calculate drift per feature and produce the drift table artifact for logging post prediction. Note that most of
     the calculations were already made through the monitoring batch job.
@@ -696,7 +694,7 @@ def perform_drift_analysis(
     metrics = model_endpoint.status.drift_measures
     inputs_statistics = model_endpoint.status.current_stats
 
-    inputs_statistics.pop("timestamp", None)
+    inputs_statistics.pop(EventFieldType.TIMESTAMP, None)
 
     # Calculate drift for each feature
     virtual_drift = VirtualDrift()
@@ -708,7 +706,6 @@ def perform_drift_analysis(
 
     # Drift table plot
     html_plot = FeaturesDriftTablePlot().produce(
-        features=list(inputs_statistics.keys()),
         sample_set_statistics=sample_set_statistics,
         inputs_statistics=inputs_statistics,
         metrics=metrics,
@@ -746,7 +743,7 @@ def perform_drift_analysis(
 def _log_drift_artifacts(
     context: mlrun.MLClientCtx,
     html_plot: str,
-    metrics_per_feature: typing.Dict[str, float],
+    metrics_per_feature: dict[str, float],
     drift_status: bool,
     drift_metric: float,
     artifacts_tag: str,
@@ -789,7 +786,7 @@ def _get_drift_result(
     tvd: float,
     hellinger: float,
     threshold: float,
-) -> typing.Tuple[bool, float]:
+) -> tuple[bool, float]:
     """
     Calculate the drift result by the following equation: (tvd + hellinger) / 2
 

mlrun/model_monitoring/application.py

@@ -16,7 +16,7 @@ import dataclasses
 import json
 import re
 from abc import ABC, abstractmethod
-from typing import Any, Optional, Tuple, Union
+from typing import Any, Optional, Union
 
 import numpy as np
 import pandas as pd
@@ -108,7 +108,7 @@ class ModelMonitoringApplicationBase(StepToDict, ABC):
 
     def do(
         self, event: dict[str, Any]
-    ) -> Tuple[list[ModelMonitoringApplicationResult], dict]:
+    ) -> tuple[list[ModelMonitoringApplicationResult], dict]:
         """
         Process the monitoring event and return application results.
 
@@ -165,7 +165,7 @@ class ModelMonitoringApplicationBase(StepToDict, ABC):
     def _resolve_event(
         cls,
         event: dict[str, Any],
-    ) -> Tuple[
+    ) -> tuple[
         str,
         pd.DataFrame,
         pd.DataFrame,
@@ -272,7 +272,7 @@ class PushToMonitoringWriter(StepToDict):
         self.output_stream = None
         self.name = name or "PushToMonitoringWriter"
 
-    def do(self, event: Tuple[list[ModelMonitoringApplicationResult], dict]) -> None:
+    def do(self, event: tuple[list[ModelMonitoringApplicationResult], dict]) -> None:
         """
         Push application results to the monitoring writer stream.
 

mlrun/model_monitoring/batch.py

@@ -19,7 +19,7 @@ import datetime
 import json
 import os
 import re
-from typing import Any, ClassVar, Dict, List, Optional, Tuple, Type, Union
+from typing import Any, ClassVar, Optional, Union
 
 import numpy as np
 import pandas as pd
@@ -38,7 +38,7 @@ import mlrun.utils.v3io_clients
 from mlrun.utils import logger
 
 # A type for representing a drift result, a tuple of the status and the drift mean:
-DriftResultType = Tuple[mlrun.common.schemas.model_monitoring.DriftStatus, float]
+DriftResultType = tuple[mlrun.common.schemas.model_monitoring.DriftStatus, float]
 
 
 @dataclasses.dataclass
@@ -157,7 +157,7 @@ class VirtualDrift:
         self,
         prediction_col: Optional[str] = None,
         label_col: Optional[str] = None,
-        feature_weights: Optional[List[float]] = None,
+        feature_weights: Optional[list[float]] = None,
         inf_capping: Optional[float] = 10,
     ):
         """
@@ -179,7 +179,7 @@ class VirtualDrift:
         self.capping = inf_capping
 
         # Initialize objects of the current metrics
-        self.metrics: Dict[str, Type[HistogramDistanceMetric]] = {
+        self.metrics: dict[str, type[HistogramDistanceMetric]] = {
             metric_class.NAME: metric_class
             for metric_class in (
                 TotalVarianceDistance,
@@ -189,7 +189,7 @@ class VirtualDrift:
         }
 
     @staticmethod
-    def dict_to_histogram(histogram_dict: Dict[str, Dict[str, Any]]) -> pd.DataFrame:
+    def dict_to_histogram(histogram_dict: dict[str, dict[str, Any]]) -> pd.DataFrame:
         """
         Convert histogram dictionary to pandas DataFrame with feature histograms as columns
 
@@ -212,9 +212,9 @@ class VirtualDrift:
 
     def compute_metrics_over_df(
         self,
-        base_histogram: Dict[str, Dict[str, Any]],
-        latest_histogram: Dict[str, Dict[str, Any]],
-    ) -> Dict[str, Dict[str, Any]]:
+        base_histogram: dict[str, dict[str, Any]],
+        latest_histogram: dict[str, dict[str, Any]],
+    ) -> dict[str, dict[str, Any]]:
         """
         Calculate metrics values for each feature.
 
@@ -243,9 +243,9 @@ class VirtualDrift:
 
     def compute_drift_from_histograms(
         self,
-        feature_stats: Dict[str, Dict[str, Any]],
-        current_stats: Dict[str, Dict[str, Any]],
-    ) -> Dict[str, Dict[str, Any]]:
+        feature_stats: dict[str, dict[str, Any]],
+        current_stats: dict[str, dict[str, Any]],
+    ) -> dict[str, dict[str, Any]]:
         """
         Compare the distributions of both the original features data and the latest input data
         :param feature_stats: Histogram dictionary of the original feature dataset that was used in the model training.
@@ -335,10 +335,10 @@ class VirtualDrift:
 
     @staticmethod
     def check_for_drift_per_feature(
-        metrics_results_dictionary: Dict[str, Union[float, dict]],
+        metrics_results_dictionary: dict[str, Union[float, dict]],
         possible_drift_threshold: float = 0.5,
         drift_detected_threshold: float = 0.7,
-    ) -> Dict[str, DriftResultType]:
+    ) -> dict[str, DriftResultType]:
         """
         Check for drift based on the defined decision rule and the calculated results of the statistical metrics per
         feature.
@@ -389,7 +389,7 @@ class VirtualDrift:
 
     @staticmethod
     def check_for_drift(
-        metrics_results_dictionary: Dict[str, Union[float, dict]],
+        metrics_results_dictionary: dict[str, Union[float, dict]],
         possible_drift_threshold: float = 0.5,
         drift_detected_threshold: float = 0.7,
     ) -> DriftResultType:
@@ -880,7 +880,7 @@ class BatchProcessor:
             ],
         )
 
-    def _get_interval_range(self) -> Tuple[datetime.datetime, datetime.datetime]:
+    def _get_interval_range(self) -> tuple[datetime.datetime, datetime.datetime]:
         """Getting batch interval time range"""
         minutes, hours, days = (
             self.batch_dict[
@@ -912,7 +912,7 @@ class BatchProcessor:
         endpoint_id: str,
         drift_status: mlrun.common.schemas.model_monitoring.DriftStatus,
         drift_measure: float,
-        drift_result: Dict[str, Dict[str, Any]],
+        drift_result: dict[str, dict[str, Any]],
         timestamp: pd.Timestamp,
     ):
         """Update drift results in input stream.
@@ -978,7 +978,7 @@ class BatchProcessor:
         self,
         endpoint_id: str,
         drift_status: mlrun.common.schemas.model_monitoring.DriftStatus,
-        drift_result: Dict[str, Dict[str, Any]],
+        drift_result: dict[str, dict[str, Any]],
     ):
         """Push drift metrics to Prometheus registry. Please note that the metrics are being pushed through HTTP
         to the monitoring stream pod that writes them into a local registry. Afterwards, Prometheus wil scrape these

mlrun/model_monitoring/controller.py

@@ -17,7 +17,8 @@ import datetime
 import json
 import os
 import re
-from typing import Any, Iterator, NamedTuple, Optional, Union, cast
+from collections.abc import Iterator
+from typing import Any, NamedTuple, Optional, Union, cast
 
 from v3io.dataplane.response import HttpResponseError
 

mlrun/model_monitoring/features_drift_table.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-from typing import Dict, List, Tuple, Union
+from typing import Union
 
 import numpy as np
 import plotly.graph_objects as go
@@ -21,7 +21,7 @@ from plotly.subplots import make_subplots
 import mlrun.common.schemas.model_monitoring
 
 # A type for representing a drift result, a tuple of the status and the drift mean:
-DriftResultType = Tuple[mlrun.common.schemas.model_monitoring.DriftStatus, float]
+DriftResultType = tuple[mlrun.common.schemas.model_monitoring.DriftStatus, float]
 
 
 class FeaturesDriftTablePlot:
@@ -93,17 +93,14 @@ class FeaturesDriftTablePlot:
 
     def produce(
         self,
-        features: List[str],
         sample_set_statistics: dict,
         inputs_statistics: dict,
-        metrics: Dict[str, Union[dict, float]],
-        drift_results: Dict[str, DriftResultType],
+        metrics: dict[str, Union[dict, float]],
+        drift_results: dict[str, DriftResultType],
     ) -> str:
         """
         Produce the html code of the table plot with the given information and the stored configurations in the class.
 
-        :param features:              List of all the features names to include in the table. These names expected to be
-                                      in the statistics and metrics dictionaries.
         :param sample_set_statistics: The sample set calculated statistics dictionary.
         :param inputs_statistics:     The inputs calculated statistics dictionary.
         :param metrics:               The drift detection metrics calculated on the sample set and inputs.
@@ -113,7 +110,7 @@ class FeaturesDriftTablePlot:
         """
         # Plot the drift table:
         figure = self._plot(
-            features=features,
+            features=list(inputs_statistics.keys()),
             sample_set_statistics=sample_set_statistics,
             inputs_statistics=inputs_statistics,
             metrics=metrics,
@@ -165,7 +162,7 @@ class FeaturesDriftTablePlot:
             self._metrics_columns
         )
 
-    def _plot_headers_tables(self) -> Tuple[go.Table, go.Table]:
+    def _plot_headers_tables(self) -> tuple[go.Table, go.Table]:
         """
         Plot the headers of the table:
 
@@ -232,7 +229,7 @@ class FeaturesDriftTablePlot:
 
         return header_table, sub_header_table
 
-    def _separate_feature_name(self, feature_name: str) -> List[str]:
+    def _separate_feature_name(self, feature_name: str) -> list[str]:
         """
         Separate the given feature name by the maximum length configured in the class. Used for calculating the amount
         of lines required to represent the longest feature name in the table, so the row heights will fit accordingly.
@@ -293,15 +290,22 @@ class FeaturesDriftTablePlot:
         :return: The feature row - `Table` trace.
         """
         # Add '\n' to the feature name in order to make it fit into its cell:
-        feature_name = "<br>".join(self._separate_feature_name(feature_name))
+        html_feature_name = "<br>".join(self._separate_feature_name(feature_name))
 
         # Initialize the cells values list with the bold feature name as the first value:
-        cells_values = [f"<b>{feature_name}</b>"]
+        cells_values = [f"<b>{html_feature_name}</b>"]
 
         # Add the statistics columns:
         for column in self._statistics_columns:
             cells_values.append(sample_statistics[column])
-            cells_values.append(input_statistics[column])
+            try:
+                cells_values.append(input_statistics[column])
+            except KeyError:
+                raise ValueError(
+                    f"The `input_statistics['{feature_name}']` dictionary "
+                    f"does not include the expected key '{column}'. "
+                    "Please check the current data."
+                )
 
         # Add the metrics columns:
         for column in self._metrics_columns:
@@ -329,8 +333,8 @@ class FeaturesDriftTablePlot:
         return feature_row_table
 
     def _plot_histogram_scatters(
-        self, sample_hist: Tuple[list, list], input_hist: Tuple[list, list]
-    ) -> Tuple[go.Scatter, go.Scatter]:
+        self, sample_hist: tuple[list, list], input_hist: tuple[list, list]
+    ) -> tuple[go.Scatter, go.Scatter]:
         """
         Plot the feature's histograms to include in the "histograms" column. Both histograms are returned to later be
         added in the same figure, so they will be on top of each other and not separated. Both histograms are rescaled
@@ -375,7 +379,7 @@ class FeaturesDriftTablePlot:
 
         return scatters[0], scatters[1]
 
-    def _calculate_row_height(self, features: List[str]) -> int:
+    def _calculate_row_height(self, features: list[str]) -> int:
         """
         Calculate the feature row height according to the given features. The longest feature will set the height to all
         the rows. The height depends on the separations amount of the longest feature name - more '\n' means more pixels
@@ -450,11 +454,11 @@ class FeaturesDriftTablePlot:
 
     def _plot(
         self,
-        features: List[str],
+        features: list[str],
         sample_set_statistics: dict,
         inputs_statistics: dict,
-        metrics: Dict[str, Union[dict, float]],
-        drift_results: Dict[str, DriftResultType],
+        metrics: dict[str, Union[dict, float]],
+        drift_results: dict[str, DriftResultType],
     ) -> go.Figure:
         """
         Plot the drift table using the given data and stored configurations of the class.
@@ -517,18 +521,27 @@ class FeaturesDriftTablePlot:
         # Start going over the features and plot each row, histogram and notification:
         row = 3  # We are currently at row 3 counting the headers.
         for feature in features:
-            # Add the feature values:
-            main_figure.add_trace(
-                self._plot_feature_row_table(
-                    feature_name=feature,
-                    sample_statistics=sample_set_statistics[feature],
-                    input_statistics=inputs_statistics[feature],
-                    metrics=metrics[feature],
-                    row_height=row_height,
-                ),
-                row=row,
-                col=1,
-            )
+            try:
+                # Add the feature values:
+                main_figure.add_trace(
+                    self._plot_feature_row_table(
+                        feature_name=feature,
+                        sample_statistics=sample_set_statistics[feature],
+                        input_statistics=inputs_statistics[feature],
+                        metrics=metrics[feature],
+                        row_height=row_height,
+                    ),
+                    row=row,
+                    col=1,
+                )
+            except KeyError:
+                raise ValueError(
+                    "`sample_set_statistics` does not contain the expected "
+                    f"key '{feature}' from `inputs_statistics`. Please verify "
+                    "the data integrity.\n"
+                    f"{sample_set_statistics.keys() = }\n"
+                    f"{inputs_statistics.keys() = }\n"
+                )
             # Add the histograms (both traces are added to the same subplot figure):
             sample_hist, input_hist = self._plot_histogram_scatters(
                 sample_hist=sample_set_statistics[feature]["hist"],

mlrun/model_monitoring/prometheus.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-import typing
 
 import prometheus_client
 
@@ -134,9 +133,7 @@ def write_predictions_and_latency_metrics(
 
 
 @_write_registry
-def write_income_features(
-    project: str, endpoint_id: str, features: typing.Dict[str, float]
-):
+def write_income_features(project: str, endpoint_id: str, features: dict[str, float]):
     """Update a sample of features.
 
     :param project:     Project name.

mlrun/model_monitoring/stores/kv_model_endpoint_store.py

@@ -50,7 +50,7 @@ class KVModelEndpointStore(ModelEndpointStore):
         # Get the KV table path and container
         self.path, self.container = self._get_path_and_container()
 
-    def write_model_endpoint(self, endpoint: typing.Dict[str, typing.Any]):
+    def write_model_endpoint(self, endpoint: dict[str, typing.Any]):
         """
         Create a new endpoint record in the KV table.
 
@@ -72,7 +72,7 @@ class KVModelEndpointStore(ModelEndpointStore):
         self._infer_kv_schema()
 
     def update_model_endpoint(
-        self, endpoint_id: str, attributes: typing.Dict[str, typing.Any]
+        self, endpoint_id: str, attributes: dict[str, typing.Any]
     ):
         """
         Update a model endpoint record with a given attributes.
@@ -114,7 +114,7 @@ class KVModelEndpointStore(ModelEndpointStore):
     def get_model_endpoint(
         self,
         endpoint_id: str,
-    ) -> typing.Dict[str, typing.Any]:
+    ) -> dict[str, typing.Any]:
         """
         Get a single model endpoint record.
 
@@ -167,10 +167,10 @@ class KVModelEndpointStore(ModelEndpointStore):
         self,
         model: str = None,
         function: str = None,
-        labels: typing.List[str] = None,
+        labels: list[str] = None,
         top_level: bool = None,
-        uids: typing.List = None,
-    ) -> typing.List[typing.Dict[str, typing.Any]]:
+        uids: list = 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
@@ -239,9 +239,7 @@ class KVModelEndpointStore(ModelEndpointStore):
 
         return endpoint_list
 
-    def delete_model_endpoints_resources(
-        self, endpoints: typing.List[typing.Dict[str, typing.Any]]
-    ):
+    def delete_model_endpoints_resources(self, endpoints: list[dict[str, typing.Any]]):
         """
         Delete all model endpoints resources in both KV and the time series DB.
 
@@ -310,11 +308,11 @@ class KVModelEndpointStore(ModelEndpointStore):
     def get_endpoint_real_time_metrics(
         self,
         endpoint_id: str,
-        metrics: typing.List[str],
+        metrics: list[str],
         start: str = "now-1h",
         end: str = "now",
         access_key: str = None,
-    ) -> typing.Dict[str, typing.List[typing.Tuple[str, float]]]:
+    ) -> dict[str, list[tuple[str, float]]]:
         """
         Getting metrics from the time series DB. There are pre-defined metrics for model endpoints such as
         `predictions_per_second` and `latency_avg_5m` but also custom metrics defined by the user.
@@ -396,7 +394,7 @@ class KVModelEndpointStore(ModelEndpointStore):
 
         return metrics_mapping
 
-    def _generate_tsdb_paths(self) -> typing.Tuple[str, str]:
+    def _generate_tsdb_paths(self) -> tuple[str, str]:
         """Generate a short path to the TSDB resources and a filtered path for the frames object
         :return: A tuple of:
              [0] = Short path to the TSDB resources
@@ -455,7 +453,7 @@ class KVModelEndpointStore(ModelEndpointStore):
         project: str,
         function: str = None,
         model: str = None,
-        labels: typing.List[str] = None,
+        labels: list[str] = None,
         top_level: bool = False,
     ) -> str:
         """

mlrun/model_monitoring/stores/model_endpoint_store.py

@@ -31,7 +31,7 @@ class ModelEndpointStore(ABC):
         self.project = project
 
     @abstractmethod
-    def write_model_endpoint(self, endpoint: typing.Dict[str, typing.Any]):
+    def write_model_endpoint(self, endpoint: dict[str, typing.Any]):
         """
         Create a new endpoint record in the DB table.
 
@@ -41,7 +41,7 @@ class ModelEndpointStore(ABC):
 
     @abstractmethod
     def update_model_endpoint(
-        self, endpoint_id: str, attributes: typing.Dict[str, typing.Any]
+        self, endpoint_id: str, attributes: dict[str, typing.Any]
     ):
         """
         Update a model endpoint record with a given attributes.
@@ -63,9 +63,7 @@ class ModelEndpointStore(ABC):
         pass
 
     @abstractmethod
-    def delete_model_endpoints_resources(
-        self, endpoints: typing.List[typing.Dict[str, typing.Any]]
-    ):
+    def delete_model_endpoints_resources(self, endpoints: list[dict[str, typing.Any]]):
         """
         Delete all model endpoints resources.
 
@@ -78,7 +76,7 @@ class ModelEndpointStore(ABC):
     def get_model_endpoint(
         self,
         endpoint_id: str,
-    ) -> typing.Dict[str, typing.Any]:
+    ) -> dict[str, typing.Any]:
         """
         Get a single model endpoint record.
 
@@ -93,10 +91,10 @@ class ModelEndpointStore(ABC):
         self,
         model: str = None,
         function: str = None,
-        labels: typing.List[str] = None,
+        labels: list[str] = None,
         top_level: bool = None,
-        uids: typing.List = None,
-    ) -> typing.List[typing.Dict[str, typing.Any]]:
+        uids: list = 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
@@ -118,11 +116,11 @@ class ModelEndpointStore(ABC):
     def get_endpoint_real_time_metrics(
         self,
         endpoint_id: str,
-        metrics: typing.List[str],
+        metrics: list[str],
         start: str = "now-1h",
         end: str = "now",
         access_key: str = None,
-    ) -> typing.Dict[str, typing.List[typing.Tuple[str, float]]]:
+    ) -> dict[str, list[tuple[str, float]]]:
         """
         Getting metrics from the time series DB. There are pre-defined metrics for model endpoints such as
         `predictions_per_second` and `latency_avg_5m` but also custom metrics defined by the user.

mlrun/model_monitoring/stores/models/__init__.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Optional, Type, Union
+from typing import Optional, Union
 
 from .mysql import ModelEndpointsTable as MySQLModelEndpointsTable
 from .sqlite import ModelEndpointsTable as SQLiteModelEndpointsTable
@@ -20,7 +20,7 @@ from .sqlite import ModelEndpointsTable as SQLiteModelEndpointsTable
 
 def get_model_endpoints_table(
     connection_string: Optional[str] = None,
-) -> Union[Type[MySQLModelEndpointsTable], Type[SQLiteModelEndpointsTable]]:
+) -> Union[type[MySQLModelEndpointsTable], type[SQLiteModelEndpointsTable]]:
     """Return ModelEndpointsTable based on the provided connection string"""
     if connection_string and "mysql:" in connection_string:
         return MySQLModelEndpointsTable