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

mlrun/common/schemas/model_monitoring/model_endpoints.py

@@ -11,27 +11,22 @@
 # 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 enum
+import abc
 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, Field, constr
 
 # 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.
-import mlrun.common.model_monitoring
-
-from ..object import ObjectKind, ObjectSpec, ObjectStatus
+from ..object import ObjectKind, ObjectMetadata, ObjectSpec, ObjectStatus
+from . import ModelEndpointSchema
 from .constants import (
     FQN_REGEX,
     MODEL_ENDPOINT_ID_PATTERN,
     PROJECT_PATTERN,
     EndpointType,
-    EventFieldType,
-    EventKeyMetrics,
-    EventLiveStats,
     ModelEndpointMonitoringMetricType,
     ModelMonitoringMode,
     ResultKindApp,
@@ -41,83 +36,6 @@ from .constants import (
 Model = TypeVar("Model", bound=BaseModel)
 
 
-class ModelMonitoringStoreKinds:
-    # TODO: do changes in examples & demos In 1.5.0 remove
-    ENDPOINTS = "endpoints"
-    EVENTS = "events"
-
-
-class ModelEndpointMetadata(BaseModel):
-    project: constr(regex=PROJECT_PATTERN)
-    uid: constr(regex=MODEL_ENDPOINT_ID_PATTERN)
-    labels: Optional[dict] = {}
-
-    class Config:
-        extra = Extra.allow
-
-    @classmethod
-    def from_flat_dict(cls, endpoint_dict: dict, json_parse_values: 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 = [EventFieldType.LABELS]
-
-        return _mapping_attributes(
-            model_class=cls,
-            flattened_dictionary=endpoint_dict,
-            json_parse_values=json_parse_values,
-        )
-
-
-class ModelEndpointSpec(ObjectSpec):
-    function_uri: Optional[str] = ""  # <project_name>/<function_name>:<tag>
-    model: Optional[str] = ""  # <model_name>:<version>
-    model_class: Optional[str] = ""
-    model_uri: Optional[str] = ""
-    feature_names: Optional[list[str]] = []
-    label_names: Optional[list[str]] = []
-    stream_path: Optional[str] = ""
-    algorithm: Optional[str] = ""
-    monitor_configuration: Optional[dict] = {}
-    active: Optional[bool] = True
-    monitoring_mode: Optional[ModelMonitoringMode] = ModelMonitoringMode.disabled.value
-
-    @classmethod
-    def from_flat_dict(cls, endpoint_dict: dict, json_parse_values: list = None):
-        """Create a `ModelEndpointSpec` 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 = [
-                EventFieldType.FEATURE_NAMES,
-                EventFieldType.LABEL_NAMES,
-                EventFieldType.MONITOR_CONFIGURATION,
-            ]
-        return _mapping_attributes(
-            model_class=cls,
-            flattened_dictionary=endpoint_dict,
-            json_parse_values=json_parse_values,
-        )
-
-    @validator("model_uri")
-    @classmethod
-    def validate_model_uri(cls, model_uri):
-        """Validate that the model uri includes the required prefix"""
-        prefix, uri = mlrun.datastore.parse_store_uri(model_uri)
-        if prefix and prefix != mlrun.utils.helpers.StorePrefix.Model:
-            return mlrun.datastore.get_store_uri(
-                mlrun.utils.helpers.StorePrefix.Model, uri
-            )
-        return model_uri
-
-
 class Histogram(BaseModel):
     buckets: list[float]
     counts: list[int]
@@ -163,65 +81,117 @@ class Features(BaseModel):
         )
 
 
-class ModelEndpointStatus(ObjectStatus):
-    feature_stats: Optional[dict] = {}
-    current_stats: Optional[dict] = {}
-    first_request: Optional[str] = ""
-    last_request: Optional[str] = ""
-    error_count: Optional[int] = 0
-    drift_status: Optional[str] = ""
-    drift_measures: Optional[dict] = {}
-    metrics: Optional[dict[str, dict[str, Any]]] = {
-        EventKeyMetrics.GENERIC: {
-            EventLiveStats.LATENCY_AVG_1H: 0,
-            EventLiveStats.PREDICTIONS_PER_SECOND: 0,
-        }
-    }
-    features: Optional[list[Features]] = []
-    children: Optional[list[str]] = []
-    children_uids: Optional[list[str]] = []
-    endpoint_type: Optional[EndpointType] = EndpointType.NODE_EP
-    monitoring_feature_set_uri: Optional[str] = ""
-    state: Optional[str] = ""
-
-    class Config:
-        extra = Extra.allow
+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: list = None):
-        """Create a `ModelEndpointStatus` object from an endpoint dictionary
+    def from_flat_dict(
+        cls,
+        endpoint_dict: dict,
+        json_parse_values: Optional[list] = None,
+        validate: bool = True,
+    ) -> "ModelEndpointParser":
+        """Create a `ModelEndpointParser` 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().
+        :param validate:          Whether to validate the flattened dictionary.
+                                  Skip validation to optimize performance when it is safe to do so.
         """
         if json_parse_values is None:
-            json_parse_values = [
-                EventFieldType.FEATURE_STATS,
-                EventFieldType.CURRENT_STATS,
-                EventFieldType.DRIFT_MEASURES,
-                EventFieldType.METRICS,
-                EventFieldType.CHILDREN,
-                EventFieldType.CHILDREN_UIDS,
-                EventFieldType.ENDPOINT_TYPE,
-            ]
+            json_parse_values = cls.json_parse_values()
+
         return _mapping_attributes(
             model_class=cls,
             flattened_dictionary=endpoint_dict,
             json_parse_values=json_parse_values,
+            validate=validate,
         )
 
 
+class ModelEndpointMetadata(ObjectMetadata, ModelEndpointParser):
+    project: constr(regex=PROJECT_PATTERN)
+    endpoint_type: EndpointType = EndpointType.NODE_EP
+    uid: Optional[constr(regex=MODEL_ENDPOINT_ID_PATTERN)]
+
+    @classmethod
+    def mutable_fields(cls):
+        return ["labels"]
+
+
+class ModelEndpointSpec(ObjectSpec, ModelEndpointParser):
+    model_class: Optional[str] = ""
+    function_name: Optional[str] = ""
+    function_tag: Optional[str] = ""
+    model_path: Optional[str] = ""
+    model_name: Optional[str] = ""
+    model_tags: Optional[list[str]] = []
+    _model_id: Optional[int] = ""
+    feature_names: Optional[list[str]] = []
+    label_names: Optional[list[str]] = []
+    feature_stats: Optional[dict] = {}
+    function_uri: Optional[str] = ""  # <project_name>/<function_hash>
+    model_uri: Optional[str] = ""
+    children: Optional[list[str]] = []
+    children_uids: Optional[list[str]] = []
+    monitoring_feature_set_uri: Optional[str] = ""
+
+    @classmethod
+    def mutable_fields(cls):
+        return [
+            "model_path",
+            "model_class",
+            "feature_names",
+            "label_names",
+            "children",
+            "children_uids",
+        ]
+
+
+class ModelEndpointStatus(ObjectStatus, ModelEndpointParser):
+    state: Optional[str] = "unknown"  # will be updated according to the function state
+    first_request: Optional[datetime] = None
+    monitoring_mode: Optional[ModelMonitoringMode] = ModelMonitoringMode.disabled
+    sampling_percentage: Optional[float] = 100
+
+    # operative
+    last_request: Optional[datetime] = None
+    result_status: Optional[int] = -1
+    avg_latency: Optional[float] = None
+    error_count: Optional[int] = 0
+    current_stats: Optional[dict] = {}
+    current_stats_timestamp: Optional[datetime] = None
+    drift_measures: Optional[dict] = {}
+    drift_measures_timestamp: Optional[datetime] = None
+
+    @classmethod
+    def mutable_fields(cls):
+        return [
+            "monitoring_mode",
+            "first_request",
+            "last_request",
+            "sampling_percentage",
+        ]
+
+
 class ModelEndpoint(BaseModel):
     kind: ObjectKind = Field(ObjectKind.model_endpoint, const=True)
     metadata: ModelEndpointMetadata
-    spec: ModelEndpointSpec = ModelEndpointSpec()
-    status: ModelEndpointStatus = ModelEndpointStatus()
+    spec: ModelEndpointSpec
+    status: ModelEndpointStatus
 
-    class Config:
-        extra = Extra.allow
+    @classmethod
+    def mutable_fields(cls):
+        return (
+            ModelEndpointMetadata.mutable_fields()
+            + ModelEndpointSpec.mutable_fields()
+            + ModelEndpointStatus.mutable_fields()
+        )
 
-    def flat_dict(self):
+    def flat_dict(self) -> dict[str, Any]:
         """Generate a flattened `ModelEndpoint` dictionary. The flattened dictionary result is important for storing
         the model endpoint object in the database.
 
@@ -229,54 +199,60 @@ class ModelEndpoint(BaseModel):
         """
         # 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
-        model_endpoint_dictionary = self.dict(exclude={"kind"})
 
+        model_endpoint_dictionary = self.dict(exclude={"kind"})
+        exclude = {
+            "tag",
+            ModelEndpointSchema.FEATURE_STATS,
+            ModelEndpointSchema.CURRENT_STATS,
+            ModelEndpointSchema.DRIFT_MEASURES,
+            ModelEndpointSchema.FUNCTION_URI,
+        }
         # 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
-                current_value = model_endpoint_dictionary[k_object][key]
-
-                # If the value is not from type str or bool (e.g. dict), convert it into a JSON string
-                # for matching the database required format
-                if not isinstance(current_value, (str, bool, int)) or isinstance(
-                    current_value, enum.IntEnum
-                ):
-                    flatten_dict[key] = json.dumps(current_value)
-                else:
-                    flatten_dict[key] = current_value
-
-        if EventFieldType.METRICS not in flatten_dict:
-            # Initialize metrics dictionary
-            flatten_dict[EventFieldType.METRICS] = {
-                EventKeyMetrics.GENERIC: {
-                    EventLiveStats.LATENCY_AVG_1H: 0,
-                    EventLiveStats.PREDICTIONS_PER_SECOND: 0,
-                }
-            }
-
-        # Remove the features from the dictionary as this field will be filled only within the feature analysis process
-        flatten_dict.pop(EventFieldType.FEATURES, None)
+                if key not in exclude:
+                    # 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) -> "ModelEndpoint":
+    def from_flat_dict(
+        cls, endpoint_dict: dict, validate: bool = True
+    ) -> "ModelEndpoint":
         """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.
+        :param validate:          Whether to validate the flattened dictionary.
+                                  Skip validation to optimize performance when it is safe to do so.
         """
 
         return cls(
-            metadata=ModelEndpointMetadata.from_flat_dict(endpoint_dict=endpoint_dict),
-            spec=ModelEndpointSpec.from_flat_dict(endpoint_dict=endpoint_dict),
-            status=ModelEndpointStatus.from_flat_dict(endpoint_dict=endpoint_dict),
+            metadata=ModelEndpointMetadata.from_flat_dict(
+                endpoint_dict=endpoint_dict, validate=validate
+            ),
+            spec=ModelEndpointSpec.from_flat_dict(
+                endpoint_dict=endpoint_dict, validate=validate
+            ),
+            status=ModelEndpointStatus.from_flat_dict(
+                endpoint_dict=endpoint_dict, validate=validate
+            ),
+        )
+
+    def get(self, field, default=None):
+        return (
+            getattr(self.metadata, field, None)
+            or getattr(self.spec, field, None)
+            or getattr(self.status, field, None)
+            or default
         )
 
 
 class ModelEndpointList(BaseModel):
-    endpoints: list[ModelEndpoint] = []
+    endpoints: list[ModelEndpoint]
 
 
 class ModelEndpointMonitoringMetric(BaseModel):
@@ -284,10 +260,17 @@ 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(
+def compose_full_name(
     *,
     project: str,
     app: str,
@@ -315,6 +298,7 @@ class _ResultPoint(NamedTuple):
     timestamp: datetime
     value: float
     status: ResultStatusApp
+    extra_data: Optional[str] = ""
 
 
 class _ModelEndpointMonitoringMetricValuesBase(BaseModel):
@@ -343,7 +327,10 @@ class ModelEndpointMonitoringMetricNoData(_ModelEndpointMonitoringMetricValuesBa
 
 
 def _mapping_attributes(
-    model_class: type[Model], flattened_dictionary: dict, json_parse_values: list
+    model_class: type[Model],
+    flattened_dictionary: dict,
+    json_parse_values: list,
+    validate: bool = True,
 ) -> Model:
     """Generate a `BaseModel` object with the provided dictionary attributes.
 
@@ -351,8 +338,10 @@ def _mapping_attributes(
     :param flattened_dictionary: Flattened dictionary that contains the model endpoint attributes.
     :param json_parse_values:    List of dictionary keys with a JSON string value that will be parsed into a
                                  dictionary using json.loads().
+    :param validate:             Whether to validate the flattened dictionary.
+                                 Skip validation to optimize performance when it is safe to do so.
     """
-    # Get the fields of the provided base model object. These fields will be used to filter to relevent keys
+    # Get the fields of the provided base model object. These fields will be used to filter to relevant keys
     # from the flattened dictionary.
     wanted_keys = model_class.__fields__.keys()
 
@@ -365,10 +354,15 @@ 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
+
+    if validate:
+        return model_class.parse_obj(dict_to_parse)
 
-    return model_class.parse_obj(dict_to_parse)
+    return model_class.construct(**dict_to_parse)
 
 
 def _json_loads_if_not_none(field: Any) -> Any:

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,18 @@ class Notification(pydantic.BaseModel):
     reason: typing.Optional[str] = None
 
 
-class SetNotificationRequest(pydantic.BaseModel):
+class SetNotificationRequest(pydantic.v1.BaseModel):
     notifications: list[Notification] = None
+
+
+class NotificationSummary(pydantic.v1.BaseModel):
+    failed: int = 0
+    succeeded: int = 0
+
+
+class NotificationState(pydantic.v1.BaseModel):
+    kind: str
+    err: Optional[
+        str
+    ]  # empty error means that the notifications were sent successfully
+    summary: NotificationSummary

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")

mlrun/common/schemas/partition.py

@@ -0,0 +1,142 @@
+# Copyright 2024 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.
+#
+from datetime import datetime, timedelta
+
+from mlrun.common.types import StrEnum
+
+
+class PartitionInterval(StrEnum):
+    DAY = "DAY"
+    MONTH = "MONTH"
+    YEARWEEK = "YEARWEEK"
+
+    @classmethod
+    def is_valid(cls, value: str) -> bool:
+        return value in cls._value2member_map_
+
+    @classmethod
+    def valid_intervals(cls) -> list:
+        return list(cls._value2member_map_.keys())
+
+    def as_duration(self) -> timedelta:
+        """
+        Convert the partition interval to a duration-like timedelta.
+
+        Returns:
+            timedelta: A duration representing the partition interval.
+        """
+        if self == PartitionInterval.DAY:
+            return timedelta(days=1)
+        elif self == PartitionInterval.MONTH:
+            # Approximate a month as 30 days
+            return timedelta(days=30)
+        elif self == PartitionInterval.YEARWEEK:
+            return timedelta(weeks=1)
+
+    @classmethod
+    def from_expression(cls, partition_expression: str):
+        """
+        Returns the corresponding PartitionInterval for a given partition expression,
+        or None if the function is not mapped.
+
+        :param partition_expression: The partition expression to map to an interval.
+        :return: PartitionInterval corresponding to the expression, or `month` if no match is found.
+        """
+
+        # Match the provided function string to the correct interval
+        partition_expression = partition_expression.upper()
+        if "YEARWEEK" in partition_expression:
+            return cls.YEARWEEK
+        elif "DAYOFMONTH" in partition_expression:
+            return cls.DAY
+        else:
+            return cls.MONTH
+
+    def get_partition_info(
+        self,
+        start_datetime: datetime,
+        partition_number: int = 1,
+    ) -> list[tuple[str, str]]:
+        """
+        Generates partition details for a specified number of partitions starting from a given datetime.
+
+        :param start_datetime: The starting datetime used for generating partition details.
+        :param partition_number: The number of partitions to generate details for.
+
+        :return: A list of tuples:
+            - partition_name: The name for the partition.
+            - partition_value: The "LESS THAN" value for the next partition boundary.
+        """
+        partitioning_information_list = []
+        current_datetime = start_datetime
+
+        for _ in range(partition_number):
+            partition_name = self.get_partition_name(current_datetime)
+            partition_boundary_date = self.get_next_partition_time(current_datetime)
+            partition_value = self.get_partition_name(partition_boundary_date)
+            partitioning_information_list.append((partition_name, partition_value))
+
+            # Move to the next interval
+            current_datetime = partition_boundary_date
+
+        return partitioning_information_list
+
+    def get_next_partition_time(self, current_datetime: datetime) -> datetime:
+        """
+        Calculates the next partition boundary time based on the specified partition interval.
+        :param current_datetime: The current datetime from which the next interval is calculated.
+
+        :return: A datetime object representing the start of the next partition interval.
+            - If the interval is DAY, it advances by one day.
+            - If the interval is MONTH, it advances to the first day of the next month.
+            - If the interval is YEARWEEK, it advances by one week.
+        """
+        if self == PartitionInterval.DAY:
+            return current_datetime + timedelta(days=1)
+        elif self == PartitionInterval.MONTH:
+            return (current_datetime.replace(day=1) + timedelta(days=32)).replace(day=1)
+        elif self == PartitionInterval.YEARWEEK:
+            return current_datetime + timedelta(weeks=1)
+
+    def get_partition_name(self, current_datetime: datetime) -> str:
+        if self == PartitionInterval.DAY:
+            return current_datetime.strftime("%Y%m%d")
+        elif self == PartitionInterval.MONTH:
+            return current_datetime.strftime("%Y%m")
+        elif self == PartitionInterval.YEARWEEK:
+            year, week, _ = current_datetime.isocalendar()
+            return f"{year}{week:02d}"
+
+    def get_partition_expression(self, column_name: str):
+        if self == PartitionInterval.YEARWEEK:
+            return f"YEARWEEK({column_name}, 1)"
+        elif self == PartitionInterval.DAY:
+            # generates value in format %Y%m%d in mysql
+            # mysql query example: `select YEAR(NOW())*10000 + MONTH(NOW())*100 + DAY(NOW());`
+            return f"YEAR({column_name}) * 10000 + MONTH({column_name}) * 100 + DAY({column_name})"
+        elif self == PartitionInterval.MONTH:
+            # generates value in format %Y%m in mysql
+            # mysql query example: `select YEAR(NOW())*100 + MONTH(NOW());`
+            return f"YEAR({column_name}) * 100 + MONTH({column_name})"
+
+    def get_number_of_partitions(self, days: int) -> int:
+        # Calculate the number partitions based on given number of days
+        if self == PartitionInterval.DAY:
+            return days
+        elif self == PartitionInterval.MONTH:
+            # Average number days in a month is 30.44
+            return int(days / 30.44)
+        elif self == PartitionInterval.YEARWEEK:
+            return int(days / 7)

mlrun/common/schemas/pipeline.py

@@ -14,7 +14,7 @@
 #
 import typing
 
-import pydantic
+import pydantic.v1
 from deprecated import deprecated
 
 import mlrun.common.types
@@ -22,7 +22,7 @@ import mlrun.common.types
 
 @deprecated(
     version="1.7.0",
-    reason="mlrun.common.schemas.PipelinesFormat is deprecated and will be removed in 1.9.0. "
+    reason="mlrun.common.schemas.PipelinesFormat is deprecated and will be removed in 1.10.0. "
     "Use mlrun.common.formatters.PipelineFormat instead.",
     category=FutureWarning,
 )
@@ -39,7 +39,7 @@ class PipelinesPagination(str):
     max_page_size = 200
 
 
-class PipelinesOutput(pydantic.BaseModel):
+class PipelinesOutput(pydantic.v1.BaseModel):
     # use the format query param to control what is returned
     runs: list[typing.Union[dict, str]]
     total_size: int