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

mlrun/common/constants.py

@@ -11,6 +11,7 @@
 # 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 mlrun.common.types
 
 IMAGE_NAME_ENRICH_REGISTRY_PREFIX = "."  # prefix for image name to enrich with registry
 MLRUN_SERVING_CONF = "serving-conf"
@@ -24,6 +25,7 @@ MYSQL_MEDIUMBLOB_SIZE_BYTES = 16 * 1024 * 1024
 MLRUN_LABEL_PREFIX = "mlrun/"
 DASK_LABEL_PREFIX = "dask.org/"
 NUCLIO_LABEL_PREFIX = "nuclio.io/"
+RESERVED_TAG_NAME_LATEST = "latest"
 
 
 class MLRunInternalLabels:
@@ -68,6 +70,7 @@ class MLRunInternalLabels:
     producer_type = f"{MLRUN_LABEL_PREFIX}producer-type"
     app_name = f"{MLRUN_LABEL_PREFIX}app-name"
     endpoint_id = f"{MLRUN_LABEL_PREFIX}endpoint-id"
+    endpoint_name = f"{MLRUN_LABEL_PREFIX}endpoint-name"
     host = "host"
     job_type = "job-type"
     kind = "kind"
@@ -86,3 +89,8 @@ class MLRunInternalLabels:
             for key, value in cls.__dict__.items()
             if not key.startswith("__") and isinstance(value, str)
         ]
+
+
+class DeployStatusTextKind(mlrun.common.types.StrEnum):
+    logs = "logs"
+    events = "events"

mlrun/common/formatters/__init__.py

@@ -19,3 +19,4 @@ from .pipeline import PipelineFormat  # noqa
 from .project import ProjectFormat  # noqa
 from .run import RunFormat  # noqa
 from .feature_set import FeatureSetFormat  # noqa
+from .model_endpoint import ModelEndpointFormat  # noqa

mlrun/common/formatters/feature_set.py

@@ -21,6 +21,7 @@ from .base import ObjectFormat
 
 
 class FeatureSetFormat(ObjectFormat, mlrun.common.types.StrEnum):
+    full = "full"
     minimal = "minimal"
 
     @staticmethod

mlrun/common/formatters/function.py

@@ -21,6 +21,7 @@ from .base import ObjectFormat
 
 
 class FunctionFormat(ObjectFormat, mlrun.common.types.StrEnum):
+    full = "full"
     minimal = "minimal"
 
     @staticmethod

mlrun/{model_monitoring/db/stores/base/__init__.py → common/formatters/model_endpoint.py}

@@ -11,5 +11,20 @@
 # 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 typing
+
+import mlrun.common.types
+
+from .base import ObjectFormat
+
+
+class ModelEndpointFormat(ObjectFormat, mlrun.common.types.StrEnum):
+    full = "full"
 
-from .store import StoreBase
+    @staticmethod
+    def format_method(_format: str) -> typing.Optional[typing.Callable]:
+        return {
+            ModelEndpointFormat.full: None,
+        }[_format]

mlrun/common/formatters/pipeline.py

@@ -15,11 +15,10 @@
 
 import typing
 
+import mlrun.common.types
 import mlrun_pipelines.common.ops
 import mlrun_pipelines.models
 
-import mlrun.common.types
-
 from .base import ObjectFormat
 
 

mlrun/common/formatters/project.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 #
 
+import datetime
 import typing
 
 import mlrun.common.schemas
@@ -30,11 +31,18 @@ class ProjectFormat(ObjectFormat, mlrun.common.types.StrEnum):
     # internal - allowed only in follower mode, only for the leader for upgrade purposes
     leader = "leader"
 
+    name_and_creation_time = "name_and_creation_time"
+
     @staticmethod
     def format_method(_format: str) -> typing.Optional[typing.Callable]:
         def _name_only(project: mlrun.common.schemas.Project) -> str:
             return project.metadata.name
 
+        def _name_and_creation_time(
+            project: mlrun.common.schemas.Project,
+        ) -> tuple[str, datetime.datetime]:
+            return project.metadata.name, project.metadata.created
+
         def _minimal(
             project: mlrun.common.schemas.Project,
         ) -> mlrun.common.schemas.Project:
@@ -48,4 +56,5 @@ class ProjectFormat(ObjectFormat, mlrun.common.types.StrEnum):
             ProjectFormat.name_only: _name_only,
             ProjectFormat.minimal: _minimal,
             ProjectFormat.leader: None,
+            ProjectFormat.name_and_creation_time: _name_and_creation_time,
         }[_format]

mlrun/common/model_monitoring/__init__.py

@@ -11,8 +11,3 @@
 # 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.
-#
-
-# flake8: noqa  - this is until we take care of the F401 violations with respect to __all__ & sphinx
-
-from .helpers import create_model_endpoint_uid

mlrun/common/model_monitoring/helpers.py

@@ -17,11 +17,6 @@ import typing
 
 import mlrun.common
 import mlrun.common.schemas.model_monitoring.constants as mm_constants
-from mlrun.common.schemas.model_monitoring import (
-    EndpointUID,
-    FunctionURI,
-    VersionedModel,
-)
 
 FeatureStats = typing.NewType("FeatureStats", dict[str, dict[str, typing.Any]])
 Histogram = typing.NewType("Histogram", list[list])
@@ -31,29 +26,6 @@ BinEdges = typing.NewType("BinEdges", list[float])
 _MAX_FLOAT = sys.float_info.max
 
 
-def create_model_endpoint_uid(function_uri: str, versioned_model: str):
-    function_uri = FunctionURI.from_string(function_uri)
-    versioned_model = VersionedModel.from_string(versioned_model)
-
-    if (
-        not function_uri.project
-        or not function_uri.function
-        or not versioned_model.model
-    ):
-        raise ValueError("Both function_uri and versioned_model have to be initialized")
-
-    uid = EndpointUID(
-        function_uri.project,
-        function_uri.function,
-        function_uri.tag,
-        function_uri.hash_key,
-        versioned_model.model,
-        versioned_model.version,
-    )
-
-    return uid
-
-
 def parse_model_endpoint_project_prefix(path: str, project_name: str):
     return path.split(project_name, 1)[0] + project_name
 
@@ -65,7 +37,7 @@ def parse_model_endpoint_store_prefix(store_prefix: str):
 
 
 def parse_monitoring_stream_path(
-    stream_uri: str, project: str, function_name: str = None
+    stream_uri: str, project: str, function_name: typing.Optional[str] = None
 ):
     if stream_uri.startswith("kafka://"):
         if "?topic" in stream_uri:

mlrun/common/runtimes/constants.py

@@ -15,9 +15,8 @@
 import enum
 import typing
 
-import mlrun_pipelines.common.models
-
 import mlrun.common.constants as mlrun_constants
+import mlrun_pipelines.common.models
 
 
 class PodPhases:

mlrun/common/schemas/__init__.py

@@ -11,10 +11,10 @@
 # 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.
-#
-# flake8: noqa  - this is until we take care of the F401 violations with respect to __all__ & sphinx
 
 from .alert import (
+    AlertActivation,
+    AlertActivations,
     AlertActiveState,
     AlertConfig,
     AlertNotification,
@@ -63,6 +63,7 @@ from .clusterization_spec import (
 from .common import ImageBuilder
 from .constants import (
     APIStates,
+    ArtifactPartitionByField,
     ClusterizationRole,
     DeletionStrategy,
     FeatureStorePartitionByField,
@@ -159,11 +160,14 @@ from .notification import (
     Notification,
     NotificationKind,
     NotificationSeverity,
+    NotificationState,
     NotificationStatus,
+    NotificationSummary,
     SetNotificationRequest,
 )
 from .object import ObjectKind, ObjectMetadata, ObjectSpec, ObjectStatus
 from .pagination import PaginationInfo
+from .partition import PartitionInterval
 from .pipeline import PipelinesOutput, PipelinesPagination
 from .project import (
     IguazioProject,

mlrun/common/schemas/alert.py

@@ -12,12 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+from collections import defaultdict
+from collections.abc import Iterator
 from datetime import datetime
-from typing import Annotated, Optional, Union
+from typing import Annotated, Any, Callable, Optional, Union
 
-import pydantic
+import pydantic.v1
 
-from mlrun.common.schemas.notification import Notification
+import mlrun.common.schemas.notification as notification_objects
 from mlrun.common.types import StrEnum
 
 
@@ -27,10 +29,10 @@ class EventEntityKind(StrEnum):
     JOB = "job"
 
 
-class EventEntities(pydantic.BaseModel):
+class EventEntities(pydantic.v1.BaseModel):
     kind: EventEntityKind
     project: str
-    ids: pydantic.conlist(str, min_items=1, max_items=1)
+    ids: pydantic.v1.conlist(str, min_items=1, max_items=1)
 
 
 class EventKind(StrEnum):
@@ -64,11 +66,11 @@ _event_kind_entity_map = {
 }
 
 
-class Event(pydantic.BaseModel):
+class Event(pydantic.v1.BaseModel):
     kind: EventKind
     timestamp: Union[str, datetime] = None  # occurrence time
     entity: EventEntities
-    value_dict: Optional[dict] = pydantic.Field(default_factory=dict)
+    value_dict: Optional[dict] = pydantic.v1.Field(default_factory=dict)
 
     def is_valid(self):
         return self.entity.kind in _event_kind_entity_map[self.kind]
@@ -86,7 +88,7 @@ class AlertSeverity(StrEnum):
 
 
 # what should trigger the alert. must be either event (at least 1), or prometheus query
-class AlertTrigger(pydantic.BaseModel):
+class AlertTrigger(pydantic.v1.BaseModel):
     events: list[EventKind] = []
     prometheus_alert: str = None
 
@@ -97,16 +99,16 @@ class AlertTrigger(pydantic.BaseModel):
         )
 
 
-class AlertCriteria(pydantic.BaseModel):
+class AlertCriteria(pydantic.v1.BaseModel):
     count: Annotated[
         int,
-        pydantic.Field(
+        pydantic.v1.Field(
             description="Number of events to wait until notification is sent"
         ),
     ] = 1
     period: Annotated[
         str,
-        pydantic.Field(
+        pydantic.v1.Field(
             description="Time period during which event occurred. e.g. 1d, 3h, 5m, 15s"
         ),
     ] = None
@@ -120,11 +122,11 @@ class ResetPolicy(StrEnum):
     AUTO = "auto"
 
 
-class AlertNotification(pydantic.BaseModel):
-    notification: Notification
+class AlertNotification(pydantic.v1.BaseModel):
+    notification: notification_objects.Notification
     cooldown_period: Annotated[
         str,
-        pydantic.Field(
+        pydantic.v1.Field(
             description="Period during which notifications "
             "will not be sent after initial send. The format of this would be in time."
             " e.g. 1d, 3h, 5m, 15s"
@@ -132,14 +134,14 @@ class AlertNotification(pydantic.BaseModel):
     ] = None
 
 
-class AlertConfig(pydantic.BaseModel):
+class AlertConfig(pydantic.v1.BaseModel):
     project: str
     id: int = None
     name: str
     description: Optional[str] = ""
     summary: Annotated[
         str,
-        pydantic.Field(
+        pydantic.v1.Field(
             description=(
                 "String to be sent in the notifications generated."
                 "e.g. 'Model {{project}}/{{entity}} is drifting.'"
@@ -153,11 +155,12 @@ class AlertConfig(pydantic.BaseModel):
     trigger: AlertTrigger
     criteria: Optional[AlertCriteria]
     reset_policy: ResetPolicy = ResetPolicy.AUTO
-    notifications: pydantic.conlist(AlertNotification, min_items=1)
+    notifications: pydantic.v1.conlist(AlertNotification, min_items=1)
     state: AlertActiveState = AlertActiveState.INACTIVE
     count: Optional[int] = 0
+    updated: datetime = None
 
-    def get_raw_notifications(self) -> list[Notification]:
+    def get_raw_notifications(self) -> list[notification_objects.Notification]:
         return [
             alert_notification.notification for alert_notification in self.notifications
         ]
@@ -169,7 +172,7 @@ class AlertsModes(StrEnum):
 
 
 class AlertTemplate(
-    pydantic.BaseModel
+    pydantic.v1.BaseModel
 ):  # Template fields that are not shared with created configs
     template_id: int = None
     template_name: str
@@ -200,3 +203,92 @@ class AlertTemplate(
             or self.reset_policy != other.reset_policy
             or self.criteria != other.criteria
         )
+
+
+class AlertActivation(pydantic.v1.BaseModel):
+    id: int
+    name: str
+    project: str
+    severity: AlertSeverity
+    activation_time: datetime
+    entity_id: str
+    entity_kind: EventEntityKind
+    criteria: AlertCriteria
+    event_kind: EventKind
+    number_of_events: int
+    notifications: list[notification_objects.NotificationState]
+    reset_time: Optional[datetime] = None
+
+    def group_key(self, attributes: list[str]) -> Union[Any, tuple]:
+        """
+        Dynamically create a key for grouping based on the provided attributes.
+        - If there's only one attribute, return the value directly (not a single-element tuple).
+        - If there are multiple attributes, return them as a tuple for grouping.
+
+        This ensures grouping behaves intuitively without redundant tuple representations.
+        """
+        if len(attributes) == 1:
+            # Avoid single-element tuple like (high,) when only one grouping attribute is used
+            return getattr(self, attributes[0])
+        # Otherwise, return a tuple of all specified attributes
+        return tuple(getattr(self, attr) for attr in attributes)
+
+
+class AlertActivations(pydantic.v1.BaseModel):
+    activations: list[AlertActivation]
+    pagination: Optional[dict]
+
+    def __iter__(self) -> Iterator[AlertActivation]:
+        return iter(self.activations)
+
+    def __getitem__(self, index: int) -> AlertActivation:
+        return self.activations[index]
+
+    def __len__(self) -> int:
+        return len(self.activations)
+
+    def group_by(self, *attributes: str) -> dict:
+        """
+        Group alert activations by specified attributes.
+
+        Args:
+        :param attributes: Attributes to group by.
+
+        :returns: A dictionary where keys are tuples of attribute values and values are lists of
+            AlertActivation objects.
+
+        Example:
+            # Group by project and severity
+            grouped = activations.group_by("project", "severity")
+        """
+        grouped = defaultdict(list)
+        for activation in self.activations:
+            key = activation.group_key(attributes)
+            grouped[key].append(activation)
+        return dict(grouped)
+
+    def aggregate_by(
+        self,
+        group_by_attrs: list[str],
+        aggregation_function: Callable[[list[AlertActivation]], Any],
+    ) -> dict:
+        """
+        Aggregate alert activations by specified attributes using a given aggregation function.
+
+        Args:
+        :param group_by_attrs: Attributes to group by.
+        :param aggregation_function: Function to aggregate grouped activations.
+
+        :returns: A dictionary where keys are tuples of attribute values and values are the result
+            of the aggregation function.
+
+        Example:
+            # Aggregate by name and entity_id and count number of activations in each group
+            activations.aggregate_by(["name", "entity_id"], lambda activations: len(activations))
+        """
+        grouped = self.group_by(*group_by_attrs)
+        aggregated = {
+            key: aggregation_function(activations)
+            for key, activations in grouped.items()
+        }
+        return aggregated

mlrun/common/schemas/api_gateway.py

@@ -15,7 +15,7 @@
 import typing
 from typing import Optional
 
-import pydantic
+import pydantic.v1
 
 import mlrun.common.constants as mlrun_constants
 import mlrun.common.types
@@ -49,9 +49,9 @@ class APIGatewayState(mlrun.common.types.StrEnum):
     waiting_for_provisioning = "waitingForProvisioning"
 
 
-class _APIGatewayBaseModel(pydantic.BaseModel):
+class _APIGatewayBaseModel(pydantic.v1.BaseModel):
     class Config:
-        extra = pydantic.Extra.allow
+        extra = pydantic.v1.Extra.allow
 
 
 class APIGatewayMetadata(_APIGatewayBaseModel):

mlrun/common/schemas/artifact.py

@@ -14,7 +14,7 @@
 #
 import typing
 
-import pydantic
+import pydantic.v1
 from deprecated import deprecated
 
 import mlrun.common.types
@@ -25,6 +25,7 @@ from .object import ObjectStatus
 class ArtifactCategories(mlrun.common.types.StrEnum):
     model = "model"
     dataset = "dataset"
+    document = "document"
     other = "other"
 
     # we define the link as a category to prevent import cycles, but it's not a real category
@@ -38,17 +39,20 @@ class ArtifactCategories(mlrun.common.types.StrEnum):
             return [ArtifactCategories.model.value, link_kind], False
         if self.value == ArtifactCategories.dataset.value:
             return [ArtifactCategories.dataset.value, link_kind], False
+        if self.value == ArtifactCategories.document.value:
+            return [ArtifactCategories.document.value, link_kind], False
         if self.value == ArtifactCategories.other.value:
             return (
                 [
                     ArtifactCategories.model.value,
                     ArtifactCategories.dataset.value,
+                    ArtifactCategories.document.value,
                 ],
                 True,
             )
 
 
-class ArtifactIdentifier(pydantic.BaseModel):
+class ArtifactIdentifier(pydantic.v1.BaseModel):
     # artifact kind
     kind: typing.Optional[str]
     key: typing.Optional[str]
@@ -69,7 +73,7 @@ class ArtifactsFormat(mlrun.common.types.StrEnum):
     full = "full"
 
 
-class ArtifactMetadata(pydantic.BaseModel):
+class ArtifactMetadata(pydantic.v1.BaseModel):
     key: str
     project: str
     iter: typing.Optional[int]
@@ -77,10 +81,10 @@ class ArtifactMetadata(pydantic.BaseModel):
     tag: typing.Optional[str]
 
     class Config:
-        extra = pydantic.Extra.allow
+        extra = pydantic.v1.Extra.allow
 
 
-class ArtifactSpec(pydantic.BaseModel):
+class ArtifactSpec(pydantic.v1.BaseModel):
     src_path: typing.Optional[str]
     target_path: typing.Optional[str]
     viewer: typing.Optional[str]
@@ -91,10 +95,10 @@ class ArtifactSpec(pydantic.BaseModel):
     unpackaging_instructions: typing.Optional[dict[str, typing.Any]]
 
     class Config:
-        extra = pydantic.Extra.allow
+        extra = pydantic.v1.Extra.allow
 
 
-class Artifact(pydantic.BaseModel):
+class Artifact(pydantic.v1.BaseModel):
     kind: str
     metadata: ArtifactMetadata
     spec: ArtifactSpec

mlrun/common/schemas/auth.py

@@ -14,7 +14,7 @@
 #
 import typing
 
-import pydantic
+import pydantic.v1
 from nuclio.auth import AuthInfo as NuclioAuthInfo
 from nuclio.auth import AuthKinds as NuclioAuthKinds
 
@@ -59,6 +59,7 @@ class AuthorizationResourceTypes(mlrun.common.types.StrEnum):
     hub_source = "hub-source"
     workflow = "workflow"
     alert = "alert"
+    alert_activations = "alert-activations"
     alert_templates = "alert-templates"
     event = "event"
     datastore_profile = "datastore-profile"
@@ -90,6 +91,7 @@ class AuthorizationResourceTypes(mlrun.common.types.StrEnum):
             AuthorizationResourceTypes.run: "/projects/{project_name}/runs/{resource_name}",
             AuthorizationResourceTypes.event: "/projects/{project_name}/events/{resource_name}",
             AuthorizationResourceTypes.alert: "/projects/{project_name}/alerts/{resource_name}",
+            AuthorizationResourceTypes.alert_activations: "/projects/{project_name}/alerts/{resource_name}/activations",
             AuthorizationResourceTypes.alert_templates: "/alert-templates/{resource_name}",
             # runtime resource doesn't have an identifier, we don't need any auth granularity behind project level
             AuthorizationResourceTypes.runtime_resource: "/projects/{project_name}/runtime-resources",
@@ -106,12 +108,12 @@ class AuthorizationResourceTypes(mlrun.common.types.StrEnum):
         }[self].format(project_name=project_name, resource_name=resource_name)
 
 
-class AuthorizationVerificationInput(pydantic.BaseModel):
+class AuthorizationVerificationInput(pydantic.v1.BaseModel):
     resource: str
     action: AuthorizationAction
 
 
-class AuthInfo(pydantic.BaseModel):
+class AuthInfo(pydantic.v1.BaseModel):
     # Basic + Iguazio auth
     username: typing.Optional[str] = None
     # Basic auth
@@ -145,5 +147,5 @@ class AuthInfo(pydantic.BaseModel):
         return self.data_session or self.session
 
 
-class Credentials(pydantic.BaseModel):
+class Credentials(pydantic.v1.BaseModel):
     access_key: typing.Optional[str]

mlrun/common/schemas/background_task.py

@@ -15,7 +15,7 @@
 import datetime
 import typing
 
-import pydantic
+import pydantic.v1
 
 import mlrun.common.types
 
@@ -35,7 +35,7 @@ class BackgroundTaskState(mlrun.common.types.StrEnum):
         ]
 
 
-class BackgroundTaskMetadata(pydantic.BaseModel):
+class BackgroundTaskMetadata(pydantic.v1.BaseModel):
     name: str
     kind: typing.Optional[str]
     project: typing.Optional[str]
@@ -44,21 +44,21 @@ class BackgroundTaskMetadata(pydantic.BaseModel):
     timeout: typing.Optional[int]
 
 
-class BackgroundTaskSpec(pydantic.BaseModel):
+class BackgroundTaskSpec(pydantic.v1.BaseModel):
     pass
 
 
-class BackgroundTaskStatus(pydantic.BaseModel):
+class BackgroundTaskStatus(pydantic.v1.BaseModel):
     state: BackgroundTaskState
     error: typing.Optional[str]
 
 
-class BackgroundTask(pydantic.BaseModel):
-    kind: ObjectKind = pydantic.Field(ObjectKind.background_task, const=True)
+class BackgroundTask(pydantic.v1.BaseModel):
+    kind: ObjectKind = pydantic.v1.Field(ObjectKind.background_task, const=True)
     metadata: BackgroundTaskMetadata
     spec: BackgroundTaskSpec
     status: BackgroundTaskStatus
 
 
-class BackgroundTaskList(pydantic.BaseModel):
+class BackgroundTaskList(pydantic.v1.BaseModel):
     background_tasks: list[BackgroundTask]

mlrun/common/schemas/client_spec.py

@@ -14,13 +14,13 @@
 #
 import typing
 
-import pydantic
+import pydantic.v1
 
 from .function import Function
 from .k8s import Resources
 
 
-class ClientSpec(pydantic.BaseModel):
+class ClientSpec(pydantic.v1.BaseModel):
     version: typing.Optional[str]
     namespace: typing.Optional[str]
     docker_registry: typing.Optional[str]
@@ -57,7 +57,6 @@ class ClientSpec(pydantic.BaseModel):
     redis_url: typing.Optional[str]
     redis_type: typing.Optional[str]
     sql_url: typing.Optional[str]
-    model_endpoint_monitoring_endpoint_store_connection: typing.Optional[str]
     model_monitoring_tsdb_connection: typing.Optional[str]
     ce: typing.Optional[dict]
     # not passing them as one object as it possible client user would like to override only one of the params

mlrun/common/schemas/clusterization_spec.py

@@ -14,12 +14,12 @@
 #
 import typing
 
-import pydantic
+import pydantic.v1
 
 import mlrun.common.types
 
 
-class ClusterizationSpec(pydantic.BaseModel):
+class ClusterizationSpec(pydantic.v1.BaseModel):
     chief_api_state: typing.Optional[str]
     chief_version: typing.Optional[str]