mlrun 1.7.2rc3__py3-none-any.whl → 1.8.0rc2__py3-none-any.whl

mlrun/common/schemas/function.py

@@ -14,7 +14,7 @@
 #
 import typing
 
-import pydantic
+import pydantic.v1
 
 import mlrun.common.types
 
@@ -90,42 +90,42 @@ class SecurityContextEnrichmentModes(mlrun.common.types.StrEnum):
     disabled = "disabled"
 
 
-class ImagePullSecret(pydantic.BaseModel):
+class ImagePullSecret(pydantic.v1.BaseModel):
     default: typing.Optional[str]
 
 
-class Pipelines(pydantic.BaseModel):
+class Pipelines(pydantic.v1.BaseModel):
     kfp_pod_user_unix_id: typing.Optional[int]
 
 
-class SecurityContext(pydantic.BaseModel):
+class SecurityContext(pydantic.v1.BaseModel):
     default: typing.Optional[str]
     enrichment_mode: typing.Optional[SecurityContextEnrichmentModes]
     enrichment_group_id: typing.Optional[int]
     pipelines: typing.Optional[Pipelines]
 
 
-class ServiceAccount(pydantic.BaseModel):
+class ServiceAccount(pydantic.v1.BaseModel):
     default: typing.Optional[str]
 
 
-class StateThresholds(pydantic.BaseModel):
+class StateThresholds(pydantic.v1.BaseModel):
     default: typing.Optional[dict[str, str]]
 
 
-class FunctionSpec(pydantic.BaseModel):
+class FunctionSpec(pydantic.v1.BaseModel):
     image_pull_secret: typing.Optional[ImagePullSecret]
     security_context: typing.Optional[SecurityContext]
     service_account: typing.Optional[ServiceAccount]
     state_thresholds: typing.Optional[StateThresholds]
 
     class Config:
-        extra = pydantic.Extra.allow
+        extra = pydantic.v1.Extra.allow
 
 
-class Function(pydantic.BaseModel):
+class Function(pydantic.v1.BaseModel):
     spec: typing.Optional[FunctionSpec]
     application: typing.Optional[dict[str, typing.Any]]
 
     class Config:
-        extra = pydantic.Extra.allow
+        extra = pydantic.v1.Extra.allow

mlrun/common/schemas/hub.py

@@ -15,7 +15,7 @@
 from datetime import datetime, timezone
 from typing import Optional
 
-from pydantic import BaseModel, Extra, Field
+from pydantic.v1 import BaseModel, Extra, Field
 
 import mlrun.common.types
 import mlrun.config

mlrun/common/schemas/k8s.py

@@ -14,18 +14,18 @@
 #
 import typing
 
-import pydantic
+import pydantic.v1
 
 import mlrun.common.types
 
 
-class ResourceSpec(pydantic.BaseModel):
+class ResourceSpec(pydantic.v1.BaseModel):
     cpu: typing.Optional[str]
     memory: typing.Optional[str]
     gpu: typing.Optional[str]
 
 
-class Resources(pydantic.BaseModel):
+class Resources(pydantic.v1.BaseModel):
     requests: ResourceSpec = ResourceSpec()
     limits: ResourceSpec = ResourceSpec()
 

mlrun/common/schemas/memory_reports.py

@@ -15,14 +15,14 @@
 
 import typing
 
-import pydantic
+import pydantic.v1
 
 
-class MostCommonObjectTypesReport(pydantic.BaseModel):
+class MostCommonObjectTypesReport(pydantic.v1.BaseModel):
     object_types: list[tuple[str, int]]
 
 
-class ObjectTypeReport(pydantic.BaseModel):
+class ObjectTypeReport(pydantic.v1.BaseModel):
     object_type: str
     sample_size: int
     start_index: typing.Optional[int]

mlrun/common/schemas/model_monitoring/__init__.py

@@ -14,6 +14,7 @@
 
 from .constants import (
     V3IO_MODEL_MONITORING_DB,
+    ApplicationEvent,
     ControllerPolicy,
     DriftStatus,
     EndpointType,
@@ -26,6 +27,7 @@ from .constants import (
     FunctionURI,
     MetricData,
     ModelEndpointMonitoringMetricType,
+    ModelEndpointSchema,
     ModelEndpointTarget,
     ModelEndpointTargetSchemas,
     ModelMonitoringMode,
@@ -36,7 +38,6 @@ from .constants import (
     ResultData,
     ResultKindApp,
     ResultStatusApp,
-    SchedulingKeys,
     SpecialApps,
     TDEngineSuperTables,
     TSDBTarget,
@@ -54,6 +55,12 @@ from .grafana import (
     GrafanaTable,
     GrafanaTimeSeriesTarget,
 )
+from .model_endpoint_v2 import (
+    ModelEndpointV2,
+    ModelEndpointV2Metadata,
+    ModelEndpointV2Spec,
+    ModelEndpointV2Status,
+)
 from .model_endpoints import (
     Features,
     FeatureValues,

mlrun/common/schemas/model_monitoring/constants.py

@@ -29,6 +29,46 @@ class MonitoringStrEnum(StrEnum):
         return list(map(lambda c: c.value, cls))
 
 
+class ModelEndpointSchema(MonitoringStrEnum):
+    # metadata
+    UID = "uid"
+    PROJECT = "project"
+    ENDPOINT_TYPE = "endpoint_type"
+    NAME = "name"
+    CREATED = "created"
+    UPDATED = "updated"
+    LABELS = "labels"
+
+    # spec
+    FUNCTION_NAME = "function_name"
+    FUNCTION_UID = "function_uid"
+    MODEL_NAME = "model_name"
+    MODEL_TAG = "model_tag"
+    MODEL_CLASS = "model_class"
+    MODEL_UID = "model_uid"
+    FEATURE_NAMES = "feature_names"
+    LABEL_NAMES = "label_names"
+
+    # status
+    STATE = "state"
+    MONITORING_MODE = "monitoring_mode"
+    MONITORING_FEATURE_SET_URI = "monitoring_feature_set_uri"
+    CHILDREN = "children"
+    CHILDREN_UIDS = "children_uids"
+    FIRST_REQUEST = "first_request"
+    FUNCTION_URI = "function_uri"
+    MODEL_URI = "model_uri"
+
+    # status - operative
+    LAST_REQUEST = "last_request"
+    DRIFT_STATUS = "drift_status"
+    AVG_LATENCY = "avg_latency"
+    ERROR_COUNT = "error_count"
+    FEATURE_STATS = "feature_stats"
+    CURRENT_STATS = "current_stats"
+    DRIFT_MEASURES = "drift_measures"
+
+
 class EventFieldType:
     FUNCTION_URI = "function_uri"
     FUNCTION = "function"
@@ -55,6 +95,8 @@ class EventFieldType:
     NAMED_PREDICTIONS = "named_predictions"
     ERROR_COUNT = "error_count"
     MODEL_ERROR = "model_error"
+    ERROR_TYPE = "error_type"
+    INFER_ERROR = "infer_error"
     ENTITIES = "entities"
     FIRST_REQUEST = "first_request"
     LAST_REQUEST = "last_request"
@@ -114,13 +156,14 @@ class WriterEvent(MonitoringStrEnum):
     ENDPOINT_ID = "endpoint_id"
     START_INFER_TIME = "start_infer_time"
     END_INFER_TIME = "end_infer_time"
-    EVENT_KIND = "event_kind"  # metric or result
+    EVENT_KIND = "event_kind"  # metric or result or stats
     DATA = "data"
 
 
 class WriterEventKind(MonitoringStrEnum):
     METRIC = "metric"
     RESULT = "result"
+    STATS = "stats"
 
 
 class MetricData(MonitoringStrEnum):
@@ -134,7 +177,17 @@ class ResultData(MonitoringStrEnum):
     RESULT_KIND = "result_kind"
     RESULT_STATUS = "result_status"
     RESULT_EXTRA_DATA = "result_extra_data"
+
+
+class StatsData(MonitoringStrEnum):
+    STATS_NAME = "stats_name"
+    STATS = "stats"
+    TIMESTAMP = "timestamp"
+
+
+class StatsKind(MonitoringStrEnum):
     CURRENT_STATS = "current_stats"
+    DRIFT_MEASURES = "drift_measures"
 
 
 class EventLiveStats:
@@ -194,13 +247,6 @@ class ModelMonitoringStoreKinds:
     EVENTS = "events"
 
 
-class SchedulingKeys:
-    LAST_ANALYZED = "last_analyzed"
-    ENDPOINT_ID = "endpoint_id"
-    APPLICATION_NAME = "application_name"
-    UID = "uid"
-
-
 class FileTargetKind:
     ENDPOINTS = "endpoints"
     EVENTS = "events"
@@ -209,14 +255,13 @@ class FileTargetKind:
     PARQUET = "parquet"
     APPS_PARQUET = "apps_parquet"
     LOG_STREAM = "log_stream"
-    APP_RESULTS = "app_results"
-    APP_METRICS = "app_metrics"
     MONITORING_SCHEDULES = "monitoring_schedules"
     MONITORING_APPLICATION = "monitoring_application"
     ERRORS = "errors"
+    STATS = "stats"
 
 
-class ModelMonitoringMode(str, Enum):
+class ModelMonitoringMode(StrEnum):
     enabled = "enabled"
     disabled = "disabled"
 
@@ -225,6 +270,11 @@ class EndpointType(IntEnum):
     NODE_EP = 1  # end point that is not a child of a router
     ROUTER = 2  # endpoint that is router
     LEAF_EP = 3  # end point that is a child of a router
+    BATCH_EP = 4  # endpoint that is representing an offline batch endpoint
+
+    @classmethod
+    def top_level_list(cls):
+        return [cls.NODE_EP, cls.ROUTER, cls.BATCH_EP]
 
 
 class MonitoringFunctionNames(MonitoringStrEnum):
@@ -244,6 +294,7 @@ class TDEngineSuperTables(MonitoringStrEnum):
     APP_RESULTS = "app_results"
     METRICS = "metrics"
     PREDICTIONS = "predictions"
+    ERRORS = "errors"
 
 
 @dataclass
@@ -364,7 +415,6 @@ class SpecialApps:
 
 _RESERVED_FUNCTION_NAMES = MonitoringFunctionNames.list() + [SpecialApps.MLRUN_INFRA]
 
-
 V3IO_MODEL_MONITORING_DB = "v3io"
 
 

mlrun/common/schemas/model_monitoring/grafana.py

@@ -14,7 +14,7 @@
 
 from typing import Optional, Union
 
-from pydantic import BaseModel
+from pydantic.v1 import BaseModel
 
 import mlrun.common.types
 

mlrun/common/schemas/model_monitoring/model_endpoint_v2.py

@@ -0,0 +1,149 @@
+# Copyright 2023 Iguazio
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+import abc
+from typing import Optional
+
+from pydantic.v1 import BaseModel, Field, constr
+
+from ..object import ObjectKind, ObjectMetadata, ObjectSpec, ObjectStatus
+from .constants import (
+    PROJECT_PATTERN,
+    EndpointType,
+    ModelMonitoringMode,
+)
+from .model_endpoints import _mapping_attributes
+
+# TODO : replace ModelEndpoint
+
+
+class ModelEndpointParser(abc.ABC, BaseModel):
+    @classmethod
+    def json_parse_values(cls) -> list[str]:
+        return []
+
+    @classmethod
+    def from_flat_dict(
+        cls, endpoint_dict: dict, json_parse_values: Optional[list] = None
+    ):
+        """Create a `ModelEndpointMetadata` object from an endpoint dictionary
+
+        :param endpoint_dict:     Model endpoint dictionary.
+        :param json_parse_values: List of dictionary keys with a JSON string value that will be parsed into a
+                                  dictionary using json.loads().
+        """
+        if json_parse_values is None:
+            json_parse_values = cls.json_parse_values()
+
+        return _mapping_attributes(
+            model_class=cls,
+            flattened_dictionary=endpoint_dict,
+            json_parse_values=json_parse_values,
+        )
+
+
+class ModelEndpointV2Metadata(ObjectMetadata, ModelEndpointParser):
+    project: constr(regex=PROJECT_PATTERN)
+    endpoint_type: Optional[EndpointType] = EndpointType.NODE_EP.value
+
+
+class ModelEndpointV2Spec(ObjectSpec, ModelEndpointParser):
+    model_uid: Optional[str] = ""
+    model_name: Optional[str] = ""
+    model_tag: Optional[str] = ""
+    model_class: Optional[str] = ""
+    function_name: Optional[str] = ""
+    function_uid: Optional[str] = ""
+    feature_names: Optional[list[str]] = []
+    label_names: Optional[list[str]] = []
+
+
+class ModelEndpointV2Status(ObjectStatus, ModelEndpointParser):
+    state: Optional[str] = "unknown"  # will be updated according to the function state
+    first_request: Optional[str] = ""
+    children: Optional[list[str]] = []
+    children_uids: Optional[list[str]] = []
+    monitoring_feature_set_uri: Optional[str] = ""
+    monitoring_mode: Optional[ModelMonitoringMode] = ModelMonitoringMode.disabled.value
+    function_uri: Optional[str] = ""  # <project_name>/<function_name>:<tag>
+    model_uri: Optional[str] = ""
+
+    # operative
+    last_request: Optional[str] = ""
+    drift_status: Optional[str] = ""
+    avg_latency: Optional[float] = None
+    error_count: Optional[int] = 0
+    feature_stats: Optional[dict] = {}
+    current_stats: Optional[dict] = {}
+    drift_measures: Optional[dict] = {}
+
+
+class ModelEndpointV2(BaseModel):
+    kind: ObjectKind = Field(ObjectKind.model_endpoint, const=True)
+    metadata: ModelEndpointV2Metadata
+    spec: ModelEndpointV2Spec
+    status: ModelEndpointV2Status
+
+    def flat_dict(self, exclude: Optional[set] = None):
+        """Generate a flattened `ModelEndpoint` dictionary. The flattened dictionary result is important for storing
+        the model endpoint object in the database.
+
+        :return: Flattened `ModelEndpoint` dictionary.
+        """
+        # Convert the ModelEndpoint object into a dictionary using BaseModel dict() function
+        # In addition, remove the BaseModel kind as it is not required by the DB schema
+        if exclude:
+            exclude = exclude | {"kind", "tag"}
+        else:
+            exclude = {"kind", "tag"}
+        model_endpoint_dictionary = self.dict(exclude=exclude)
+
+        # Initialize a flattened dictionary that will be filled with the model endpoint dictionary attributes
+        flatten_dict = {}
+        for k_object in model_endpoint_dictionary:
+            for key in model_endpoint_dictionary[k_object]:
+                # Extract the value of the current field
+                flatten_dict[key] = model_endpoint_dictionary[k_object][key]
+
+        return flatten_dict
+
+    @classmethod
+    def from_flat_dict(cls, endpoint_dict: dict) -> "ModelEndpointV2":
+        """Create a `ModelEndpoint` object from an endpoint flattened dictionary. Because the provided dictionary
+        is flattened, we pass it as is to the subclasses without splitting the keys into spec, metadata, and status.
+
+        :param endpoint_dict:     Model endpoint dictionary.
+        """
+
+        return cls(
+            metadata=ModelEndpointV2Metadata.from_flat_dict(
+                endpoint_dict=endpoint_dict
+            ),
+            spec=ModelEndpointV2Spec.from_flat_dict(endpoint_dict=endpoint_dict),
+            status=ModelEndpointV2Status.from_flat_dict(endpoint_dict=endpoint_dict),
+        )
+
+    @classmethod
+    def _operative_data(cls) -> set:
+        return {
+            "last_request",
+            "drift_status",
+            "avg_latency",
+            "error_count",
+            "feature_stats",
+            "current_stats",
+            "drift_measures",
+            "function_uri",
+            "model_uri",
+        }

mlrun/common/schemas/model_monitoring/model_endpoints.py

@@ -17,7 +17,7 @@ import json
 from datetime import datetime
 from typing import Any, NamedTuple, Optional, TypeVar
 
-from pydantic import BaseModel, Extra, Field, constr, validator
+from pydantic.v1 import BaseModel, Extra, Field, constr, validator
 
 # TODO: remove the unused import below after `mlrun.datastore` and `mlrun.utils` usage is removed.
 # At the moment `make lint` fails if this is removed.
@@ -56,7 +56,9 @@ class ModelEndpointMetadata(BaseModel):
         extra = Extra.allow
 
     @classmethod
-    def from_flat_dict(cls, endpoint_dict: dict, json_parse_values: list = None):
+    def from_flat_dict(
+        cls, endpoint_dict: dict, json_parse_values: Optional[list] = None
+    ):
         """Create a `ModelEndpointMetadata` object from an endpoint dictionary
 
         :param endpoint_dict:     Model endpoint dictionary.
@@ -87,7 +89,9 @@ class ModelEndpointSpec(ObjectSpec):
     monitoring_mode: Optional[ModelMonitoringMode] = ModelMonitoringMode.disabled.value
 
     @classmethod
-    def from_flat_dict(cls, endpoint_dict: dict, json_parse_values: list = None):
+    def from_flat_dict(
+        cls, endpoint_dict: dict, json_parse_values: Optional[list] = None
+    ):
         """Create a `ModelEndpointSpec` object from an endpoint dictionary
 
         :param endpoint_dict:     Model endpoint dictionary.
@@ -188,7 +192,9 @@ class ModelEndpointStatus(ObjectStatus):
         extra = Extra.allow
 
     @classmethod
-    def from_flat_dict(cls, endpoint_dict: dict, json_parse_values: list = None):
+    def from_flat_dict(
+        cls, endpoint_dict: dict, json_parse_values: Optional[list] = None
+    ):
         """Create a `ModelEndpointStatus` object from an endpoint dictionary
 
         :param endpoint_dict:     Model endpoint dictionary.
@@ -284,7 +290,14 @@ class ModelEndpointMonitoringMetric(BaseModel):
     app: str
     type: ModelEndpointMonitoringMetricType
     name: str
-    full_name: str
+    full_name: Optional[str] = None
+    kind: Optional[ResultKindApp] = None
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.full_name = _compose_full_name(
+            project=self.project, app=self.app, name=self.name, type=self.type
+        )
 
 
 def _compose_full_name(
@@ -315,6 +328,7 @@ class _ResultPoint(NamedTuple):
     timestamp: datetime
     value: float
     status: ResultStatusApp
+    extra_data: Optional[str] = ""
 
 
 class _ModelEndpointMonitoringMetricValuesBase(BaseModel):
@@ -365,8 +379,10 @@ def _mapping_attributes(
                 dict_to_parse[field_key] = _json_loads_if_not_none(
                     flattened_dictionary[field_key]
                 )
-            else:
+            elif flattened_dictionary[field_key] != "null":
                 dict_to_parse[field_key] = flattened_dictionary[field_key]
+            else:
+                dict_to_parse[field_key] = None
 
     return model_class.parse_obj(dict_to_parse)
 

mlrun/common/schemas/notification.py

@@ -15,8 +15,9 @@
 import datetime
 import enum
 import typing
+from typing import Optional
 
-import pydantic
+import pydantic.v1
 
 import mlrun.common.types
 
@@ -45,6 +46,13 @@ class NotificationKind(mlrun.common.types.StrEnum):
     slack: str = "slack"
     """**webhook** - The slack webhook to which to send the notification."""
 
+    mail: str = "mail"
+    """
+    **email_addresses** - The target mails\n
+    **subject** - The subject of the mail\n
+    **body** - The body of the mail\n
+    """
+
     webhook: str = "webhook"
     """
     **url** - The webhook url to which to send the notification.\n
@@ -86,7 +94,7 @@ class NotificationLimits(enum.Enum):
     )  # 900KB (k8s secret size limit is 1MB minus buffer for metadata)
 
 
-class Notification(pydantic.BaseModel):
+class Notification(pydantic.v1.BaseModel):
     """
     Notification object schema
 
@@ -120,5 +128,12 @@ class Notification(pydantic.BaseModel):
     reason: typing.Optional[str] = None
 
 
-class SetNotificationRequest(pydantic.BaseModel):
+class SetNotificationRequest(pydantic.v1.BaseModel):
     notifications: list[Notification] = None
+
+
+class NotificationState(pydantic.v1.BaseModel):
+    kind: str
+    err: Optional[
+        str
+    ]  # empty error means that the notifications were sent successfully

mlrun/common/schemas/object.py

@@ -15,7 +15,7 @@
 from datetime import datetime
 from typing import Optional
 
-from pydantic import BaseModel, Extra
+from pydantic.v1 import BaseModel, Extra
 
 import mlrun.common.types
 

mlrun/common/schemas/pagination.py

@@ -14,13 +14,13 @@
 
 import typing
 
-import pydantic
+import pydantic.v1
 
 
-class PaginationInfo(pydantic.BaseModel):
+class PaginationInfo(pydantic.v1.BaseModel):
     class Config:
         allow_population_by_field_name = True
 
     page: typing.Optional[int]
-    page_size: typing.Optional[int] = pydantic.Field(alias="page-size")
-    page_token: typing.Optional[str] = pydantic.Field(alias="page-token")
+    page_size: typing.Optional[int] = pydantic.v1.Field(alias="page-size")
+    page_token: typing.Optional[str] = pydantic.v1.Field(alias="page-token")