mlrun 1.7.1rc10__py3-none-any.whl → 1.8.0rc11__py3-none-any.whl

mlrun/model_monitoring/helpers.py

@@ -13,26 +13,32 @@
 # limitations under the License.
 
 import datetime
+import os
 import typing
 
 import numpy as np
 import pandas as pd
 
 if typing.TYPE_CHECKING:
+    from mlrun.datastore import DataItem
     from mlrun.db.base import RunDBInterface
     from mlrun.projects import MlrunProject
 
+from fnmatch import fnmatchcase
+from typing import Optional
+
 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.model_monitoring
+import mlrun.utils.helpers
+from mlrun.common.schemas import ModelEndpoint
 from mlrun.common.schemas.model_monitoring.model_endpoints import (
     ModelEndpointMonitoringMetric,
     _compose_full_name,
 )
-from mlrun.model_monitoring.model_endpoint import ModelEndpoint
 from mlrun.utils import logger
 
 
@@ -42,6 +48,70 @@ class _BatchDict(typing.TypedDict):
     days: int
 
 
+def _is_results_regex_match(
+    existing_result_name: Optional[str],
+    result_name_filters: Optional[list[str]],
+) -> bool:
+    if existing_result_name.count(".") != 3 or any(
+        part == "" for part in existing_result_name.split(".")
+    ):
+        logger.warning(
+            f"_is_results_regex_match: existing_result_name illegal, will be ignored."
+            f" existing_result_name: {existing_result_name}"
+        )
+        return False
+    existing_result_name = ".".join(existing_result_name.split(".")[i] for i in [1, 3])
+    for result_name_filter in result_name_filters:
+        if fnmatchcase(existing_result_name, result_name_filter):
+            return True
+    return False
+
+
+def filter_results_by_regex(
+    existing_result_names: Optional[list[str]] = None,
+    result_name_filters: Optional[list[str]] = None,
+) -> list[str]:
+    """
+    Filter a list of existing result names by a list of filters.
+
+    This function returns only the results that match the filters provided. If no filters are given,
+    it returns all results. Invalid inputs are ignored.
+
+    :param existing_result_names: List of existing results' fully qualified names (FQNs)
+                                  in the format: endpoint_id.app_name.type.name.
+                                  Example: mep1.app1.result.metric1
+    :param result_name_filters:   List of filters in the format: app.result_name.
+                                  Wildcards can be used, such as app.result* or *.result
+
+    :return: List of FQNs of the matching results
+    """
+
+    if not result_name_filters:
+        return existing_result_names
+
+    if not existing_result_names:
+        return []
+
+    #  filters validations
+    validated_filters = []
+    for result_name_filter in result_name_filters:
+        if result_name_filter.count(".") != 1:
+            logger.warning(
+                f"filter_results_by_regex: result_name_filter illegal, will be ignored."
+                f"Filter: {result_name_filter}"
+            )
+        else:
+            validated_filters.append(result_name_filter)
+    filtered_metrics_names = []
+    for existing_result_name in existing_result_names:
+        if _is_results_regex_match(
+            existing_result_name=existing_result_name,
+            result_name_filters=validated_filters,
+        ):
+            filtered_metrics_names.append(existing_result_name)
+    return filtered_metrics_names
+
+
 def get_stream_path(
     project: str,
     function_name: str = mm_constants.MonitoringFunctionNames.STREAM,
@@ -98,19 +168,64 @@ def get_monitoring_parquet_path(
     return parquet_path
 
 
-def get_connection_string(secret_provider: typing.Callable[[str], str] = None) -> str:
-    """Get endpoint store connection string from the project secret. If wasn't set, take it from the system
-    configurations.
+def get_monitoring_stats_directory_path(
+    project: str,
+    kind: str = mm_constants.FileTargetKind.STATS,
+) -> str:
+    """
+    Get model monitoring stats target for the current project and kind. The stats target path is based on the
+    project artifact path. If project artifact path is not defined, the stats target path will be based on MLRun
+    artifact path.
+    :param project:     Project object.
+    :param kind:        indicate the kind of the stats path
+    :return:            Monitoring stats target path.
+    """
+    stats_path = mlrun.mlconf.get_model_monitoring_file_target_path(
+        project=project,
+        kind=kind,
+    )
+    return stats_path
 
-    :param secret_provider: An optional secret provider to get the connection string secret.
 
-    :return:                Valid SQL connection string.
+def _get_monitoring_current_stats_file_path(project: str, endpoint_id: str) -> str:
+    return os.path.join(
+        get_monitoring_stats_directory_path(project),
+        f"{endpoint_id}_current_stats.json",
+    )
+
 
+def _get_monitoring_drift_measures_file_path(project: str, endpoint_id: str) -> str:
+    return os.path.join(
+        get_monitoring_stats_directory_path(project),
+        f"{endpoint_id}_drift_measures.json",
+    )
+
+
+def get_monitoring_current_stats_data(project: str, endpoint_id: str) -> "DataItem":
+    """
+    getter for data item of current stats for project and endpoint
+    :param project: project name str
+    :param endpoint_id: endpoint id str
+    :return: DataItem
     """
+    return mlrun.datastore.store_manager.object(
+        _get_monitoring_current_stats_file_path(
+            project=project, endpoint_id=endpoint_id
+        )
+    )
 
-    return mlrun.get_secret_or_env(
-        key=mm_constants.ProjectSecretKeys.ENDPOINT_STORE_CONNECTION,
-        secret_provider=secret_provider,
+
+def get_monitoring_drift_measures_data(project: str, endpoint_id: str) -> "DataItem":
+    """
+    getter for data item of drift measures for project and endpoint
+    :param project: project name str
+    :param endpoint_id: endpoint id str
+    :return: DataItem
+    """
+    return mlrun.datastore.store_manager.object(
+        _get_monitoring_drift_measures_file_path(
+            project=project, endpoint_id=endpoint_id
+        )
     )
 
 
@@ -186,19 +301,23 @@ def update_model_endpoint_last_request(
     :param current_request: current request time
     :param db:              DB interface.
     """
-    is_model_server_endpoint = model_endpoint.spec.stream_path != ""
-    if is_model_server_endpoint:
-        current_request = current_request.isoformat()
+    is_batch_endpoint = (
+        model_endpoint.metadata.endpoint_type == mm_constants.EndpointType.BATCH_EP
+    )
+    if not is_batch_endpoint:
         logger.info(
             "Update model endpoint last request time (EP with serving)",
             project=project,
             endpoint_id=model_endpoint.metadata.uid,
+            name=model_endpoint.metadata.name,
+            function_name=model_endpoint.spec.function_name,
             last_request=model_endpoint.status.last_request,
             current_request=current_request,
         )
         db.patch_model_endpoint(
             project=project,
             endpoint_id=model_endpoint.metadata.uid,
+            name=model_endpoint.metadata.name,
             attributes={mm_constants.EventFieldType.LAST_REQUEST: current_request},
         )
     else:  # model endpoint without any serving function - close the window "manually"
@@ -217,7 +336,7 @@ def update_model_endpoint_last_request(
             + datetime.timedelta(
                 seconds=mlrun.mlconf.model_endpoint_monitoring.parquet_batching_timeout_secs
             )
-        ).isoformat()
+        )
         logger.info(
             "Bumping model endpoint last request time (EP without serving)",
             project=project,
@@ -229,6 +348,8 @@ def update_model_endpoint_last_request(
         db.patch_model_endpoint(
             project=project,
             endpoint_id=model_endpoint.metadata.uid,
+            name=model_endpoint.metadata.name,
+            function_name=model_endpoint.spec.function_name,
             attributes={mm_constants.EventFieldType.LAST_REQUEST: bumped_last_request},
         )
 
@@ -270,17 +391,6 @@ def calculate_inputs_statistics(
     return inputs_statistics
 
 
-def get_endpoint_record(
-    project: str,
-    endpoint_id: str,
-    secret_provider: typing.Optional[typing.Callable[[str], str]] = None,
-) -> dict[str, typing.Any]:
-    model_endpoint_store = mlrun.model_monitoring.get_store_object(
-        project=project, secret_provider=secret_provider
-    )
-    return model_endpoint_store.get_model_endpoint(endpoint_id=endpoint_id)
-
-
 def get_result_instance_fqn(
     model_endpoint_id: str, app_name: str, result_name: str
 ) -> str:
@@ -320,33 +430,25 @@ def get_invocations_metric(project: str) -> ModelEndpointMonitoringMetric:
     )
 
 
-def enrich_model_endpoint_with_model_uri(
-    model_endpoint: ModelEndpoint,
-    model_obj: mlrun.artifacts.ModelArtifact,
-):
-    """
-    Enrich the model endpoint object with the model uri from the model object. We will use a unique reference
-    to the model object that includes the project, db_key, iter, and tree.
-    In addition, we verify that the model object is of type `ModelArtifact`.
+def _get_monitoring_schedules_folder_path(project: str) -> str:
+    return typing.cast(
+        str,
+        mlrun.mlconf.get_model_monitoring_file_target_path(
+            project=project, kind=mm_constants.FileTargetKind.MONITORING_SCHEDULES
+        ),
+    )
 
-    :param model_endpoint:    An object representing the model endpoint that will be enriched with the model uri.
-    :param model_obj:         An object representing the model artifact.
 
-    :raise: `MLRunInvalidArgumentError` if the model object is not of type `ModelArtifact`.
-    """
-    mlrun.utils.helpers.verify_field_of_type(
-        field_name="model_endpoint.spec.model_uri",
-        field_value=model_obj,
-        expected_type=mlrun.artifacts.ModelArtifact,
+def _get_monitoring_schedules_file_path(*, project: str, endpoint_id: str) -> str:
+    return os.path.join(
+        _get_monitoring_schedules_folder_path(project), f"{endpoint_id}.json"
     )
 
-    # Update model_uri with a unique reference to handle future changes
-    model_artifact_uri = mlrun.utils.helpers.generate_artifact_uri(
-        project=model_endpoint.metadata.project,
-        key=model_obj.db_key,
-        iter=model_obj.iter,
-        tree=model_obj.tree,
-    )
-    model_endpoint.spec.model_uri = mlrun.datastore.get_store_uri(
-        kind=mlrun.utils.helpers.StorePrefix.Model, uri=model_artifact_uri
+
+def get_monitoring_schedules_data(*, project: str, endpoint_id: str) -> "DataItem":
+    """
+    Get the model monitoring schedules' data item of the project's model endpoint.
+    """
+    return mlrun.datastore.store_manager.object(
+        _get_monitoring_schedules_file_path(project=project, endpoint_id=endpoint_id)
     )