mlrun 1.7.0rc16__py3-none-any.whl → 1.7.0rc17__py3-none-any.whl

mlrun/alerts/alert.py

@@ -15,8 +15,7 @@
 from typing import Union
 
 import mlrun
-import mlrun.common.schemas.alert as alert_constants
-from mlrun.common.schemas.notification import Notification
+import mlrun.common.schemas.alert as alert_objects
 from mlrun.model import ModelObj
 
 
@@ -36,17 +35,17 @@ class AlertConfig(ModelObj):
         self,
         project: str = None,
         name: str = None,
-        template: Union[alert_constants.AlertTemplate, str] = None,
+        template: Union[alert_objects.AlertTemplate, str] = None,
         description: str = None,
         summary: str = None,
-        severity: alert_constants.AlertSeverity = None,
-        trigger: alert_constants.AlertTrigger = None,
-        criteria: alert_constants.AlertCriteria = None,
-        reset_policy: alert_constants.ResetPolicy = None,
-        notifications: list[Notification] = None,
-        entities: alert_constants.EventEntities = None,
+        severity: alert_objects.AlertSeverity = None,
+        trigger: alert_objects.AlertTrigger = None,
+        criteria: alert_objects.AlertCriteria = None,
+        reset_policy: alert_objects.ResetPolicy = None,
+        notifications: list[alert_objects.AlertNotification] = None,
+        entities: alert_objects.EventEntities = None,
         id: int = None,
-        state: alert_constants.AlertActiveState = None,
+        state: alert_objects.AlertActiveState = None,
         created: str = None,
         count: int = None,
     ):
@@ -81,8 +80,10 @@ class AlertConfig(ModelObj):
             else self.entities
         )
         data["notifications"] = [
-            notification.dict() if not isinstance(notification, dict) else notification
-            for notification in self.notifications
+            notification_data.dict()
+            if not isinstance(notification_data, dict)
+            else notification_data
+            for notification_data in self.notifications
         ]
         data["trigger"] = (
             self.trigger.dict() if not isinstance(self.trigger, dict) else self.trigger
@@ -95,35 +96,37 @@ class AlertConfig(ModelObj):
 
         entity_data = struct.get("entities")
         if entity_data:
-            entity_obj = alert_constants.EventEntities.parse_obj(entity_data)
+            entity_obj = alert_objects.EventEntities.parse_obj(entity_data)
             new_obj.entities = entity_obj
 
         notifications_data = struct.get("notifications")
         if notifications_data:
             notifications_objs = [
-                Notification.parse_obj(notification_data)
-                for notification_data in notifications_data
+                alert_objects.AlertNotification.parse_obj(notification)
+                for notification in notifications_data
             ]
             new_obj.notifications = notifications_objs
 
         trigger_data = struct.get("trigger")
         if trigger_data:
-            trigger_obj = alert_constants.AlertTrigger.parse_obj(trigger_data)
+            trigger_obj = alert_objects.AlertTrigger.parse_obj(trigger_data)
             new_obj.trigger = trigger_obj
 
         return new_obj
 
-    def with_notifications(self, notifications: list[Notification]):
+    def with_notifications(self, notifications: list[alert_objects.AlertNotification]):
         if not isinstance(notifications, list) or not all(
-            isinstance(item, Notification) for item in notifications
+            isinstance(item, alert_objects.AlertNotification) for item in notifications
         ):
-            raise ValueError("Notifications parameter must be a list of notifications")
-        for notification in notifications:
-            self.notifications.append(notification)
+            raise ValueError(
+                "Notifications parameter must be a list of AlertNotification"
+            )
+        for notification_data in notifications:
+            self.notifications.append(notification_data)
         return self
 
-    def with_entities(self, entities: alert_constants.EventEntities):
-        if not isinstance(entities, alert_constants.EventEntities):
+    def with_entities(self, entities: alert_objects.EventEntities):
+        if not isinstance(entities, alert_objects.EventEntities):
             raise ValueError("Entities parameter must be of type: EventEntities")
         self.entities = entities
         return self

mlrun/artifacts/model.py

@@ -509,7 +509,7 @@ def _get_extra(target, extra_data, is_dir=False):
 def _remove_tag_from_spec_yaml(model_spec):
     spec_dict = model_spec.to_dict()
     spec_dict["metadata"].pop("tag", None)
-    return yaml.dump(spec_dict)
+    return yaml.safe_dump(spec_dict)
 
 
 def update_model(

mlrun/common/schemas/__init__.py

@@ -14,7 +14,13 @@
 #
 # flake8: noqa  - this is until we take care of the F401 violations with respect to __all__ & sphinx
 
-from .alert import AlertActiveState, AlertConfig, AlertTemplate, Event
+from .alert import (
+    AlertActiveState,
+    AlertConfig,
+    AlertNotification,
+    AlertTemplate,
+    Event,
+)
 from .api_gateway import (
     APIGateway,
     APIGatewayAuthenticationMode,

mlrun/common/schemas/alert.py

@@ -101,6 +101,18 @@ class ResetPolicy(StrEnum):
     AUTO = "auto"
 
 
+class AlertNotification(pydantic.BaseModel):
+    notification: Notification
+    cooldown_period: Annotated[
+        str,
+        pydantic.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"
+        ),
+    ] = None
+
+
 class AlertConfig(pydantic.BaseModel):
     project: str
     id: int = None
@@ -121,10 +133,15 @@ class AlertConfig(pydantic.BaseModel):
     trigger: AlertTrigger
     criteria: Optional[AlertCriteria]
     reset_policy: ResetPolicy = ResetPolicy.MANUAL
-    notifications: pydantic.conlist(Notification, min_items=1)
+    notifications: pydantic.conlist(AlertNotification, min_items=1)
     state: AlertActiveState = AlertActiveState.INACTIVE
     count: Optional[int] = 0
 
+    def get_raw_notifications(self) -> list[Notification]:
+        return [
+            alert_notification.notification for alert_notification in self.notifications
+        ]
+
 
 class AlertsModes(StrEnum):
     enabled = "enabled"

mlrun/common/schemas/model_monitoring/constants.py

@@ -188,6 +188,7 @@ class SchedulingKeys:
 class FileTargetKind:
     ENDPOINTS = "endpoints"
     EVENTS = "events"
+    PREDICTIONS = "predictions"
     STREAM = "stream"
     PARQUET = "parquet"
     APPS_PARQUET = "apps_parquet"

mlrun/common/schemas/project.py

@@ -113,7 +113,9 @@ class ProjectSummary(pydantic.BaseModel):
     runs_completed_recent_count: int
     runs_failed_recent_count: int
     runs_running_count: int
-    schedules_count: int
+    distinct_schedules_count: int
+    distinct_scheduled_jobs_pending_count: int
+    distinct_scheduled_pipelines_pending_count: int
     pipelines_completed_recent_count: typing.Optional[int] = None
     pipelines_failed_recent_count: typing.Optional[int] = None
     pipelines_running_count: typing.Optional[int] = None

mlrun/config.py

@@ -232,6 +232,10 @@ default_config = {
         "databricks": {
             "artifact_directory_path": "/mlrun_databricks_runtime/artifacts_dictionaries"
         },
+        "application": {
+            "default_sidecar_internal_port": 8050,
+            "default_authentication_mode": "accessKey",
+        },
     },
     # TODO: function defaults should be moved to the function spec config above
     "function_defaults": {
@@ -1402,14 +1406,14 @@ def read_env(env=None, prefix=env_prefix):
     if log_formatter_name := config.get("log_formatter"):
         import mlrun.utils.logger
 
-        log_formatter = mlrun.utils.create_formatter_instance(
+        log_formatter = mlrun.utils.resolve_formatter_by_kind(
             mlrun.utils.FormatterKinds(log_formatter_name)
         )
         current_handler = mlrun.utils.logger.get_handler("default")
         current_formatter_name = current_handler.formatter.__class__.__name__
-        desired_formatter_name = log_formatter.__class__.__name__
+        desired_formatter_name = log_formatter.__name__
         if current_formatter_name != desired_formatter_name:
-            current_handler.setFormatter(log_formatter)
+            current_handler.setFormatter(log_formatter())
 
     # The default function pod resource values are of type str; however, when reading from environment variable numbers,
     # it converts them to type int if contains only number, so we want to convert them to str.

mlrun/db/base.py

@@ -629,8 +629,8 @@ class RunDBInterface(ABC):
     @abstractmethod
     def store_api_gateway(
         self,
-        project: str,
         api_gateway: mlrun.common.schemas.APIGateway,
+        project: str = None,
     ):
         pass
 

mlrun/db/nopdb.py

@@ -520,8 +520,11 @@ class NopDB(RunDBInterface):
 
     def store_api_gateway(
         self,
-        project: str,
-        api_gateway: mlrun.runtimes.nuclio.APIGateway,
+        api_gateway: Union[
+            mlrun.common.schemas.APIGateway,
+            mlrun.runtimes.nuclio.api_gateway.APIGateway,
+        ],
+        project: str = None,
     ) -> mlrun.common.schemas.APIGateway:
         pass
 

mlrun/lists.py

@@ -29,6 +29,7 @@ list_header = [
     "iter",
     "start",
     "state",
+    "kind",
     "name",
     "labels",
     "inputs",
@@ -57,6 +58,7 @@ class RunList(list):
                 get_in(run, "metadata.iteration", ""),
                 get_in(run, "status.start_time", ""),
                 get_in(run, "status.state", ""),
+                get_in(run, "step_kind", get_in(run, "kind", "")),
                 get_in(run, "metadata.name", ""),
                 get_in(run, "metadata.labels", ""),
                 get_in(run, "spec.inputs", ""),

mlrun/model.py

@@ -681,10 +681,14 @@ class Notification(ModelObj):
 
     def __init__(
         self,
-        kind=None,
+        kind: mlrun.common.schemas.notification.NotificationKind = (
+            mlrun.common.schemas.notification.NotificationKind.slack
+        ),
         name=None,
         message=None,
-        severity=None,
+        severity: mlrun.common.schemas.notification.NotificationSeverity = (
+            mlrun.common.schemas.notification.NotificationSeverity.INFO
+        ),
         when=None,
         condition=None,
         secret_params=None,
@@ -693,12 +697,10 @@ class Notification(ModelObj):
         sent_time=None,
         reason=None,
     ):
-        self.kind = kind or mlrun.common.schemas.notification.NotificationKind.slack
+        self.kind = kind
         self.name = name or ""
         self.message = message or ""
-        self.severity = (
-            severity or mlrun.common.schemas.notification.NotificationSeverity.INFO
-        )
+        self.severity = severity
         self.when = when or ["completed"]
         self.condition = condition or ""
         self.secret_params = secret_params or {}

mlrun/model_monitoring/db/tsdb/v3io/v3io_connector.py

@@ -99,6 +99,23 @@ class V3IOTSDBConnector(TSDBConnector):
             monitoring_application_path + mm_constants.MonitoringTSDBTables.METRICS
         )
 
+        monitoring_predictions_full_path = (
+            mlrun.mlconf.get_model_monitoring_file_target_path(
+                project=self.project,
+                kind=mm_constants.FileTargetKind.PREDICTIONS,
+            )
+        )
+        (
+            _,
+            _,
+            monitoring_predictions_path,
+        ) = mlrun.common.model_monitoring.helpers.parse_model_endpoint_store_prefix(
+            monitoring_predictions_full_path
+        )
+        self.tables[mm_constants.FileTargetKind.PREDICTIONS] = (
+            monitoring_predictions_path
+        )
+
     def create_tsdb_application_tables(self):
         """
         Create the application tables using the TSDB connector. At the moment we support 2 types of application tables:
@@ -134,6 +151,27 @@ class V3IOTSDBConnector(TSDBConnector):
         - custom_metrics (user-defined metrics)
         """
 
+        # Write latency per prediction, labeled by endpoint ID only
+        graph.add_step(
+            "storey.TSDBTarget",
+            name="tsdb_predictions",
+            after="MapFeatureNames",
+            path=f"{self.container}/{self.tables[mm_constants.FileTargetKind.PREDICTIONS]}",
+            rate="1/s",
+            time_col=mm_constants.EventFieldType.TIMESTAMP,
+            container=self.container,
+            v3io_frames=self.v3io_framesd,
+            columns=["latency"],
+            index_cols=[
+                mm_constants.EventFieldType.ENDPOINT_ID,
+            ],
+            aggr="count,avg",
+            aggr_granularity="1m",
+            max_events=tsdb_batching_max_events,
+            flush_after_seconds=tsdb_batching_timeout_secs,
+            key=mm_constants.EventFieldType.ENDPOINT_ID,
+        )
+
         # Before writing data to TSDB, create dictionary of 2-3 dictionaries that contains
         # stats and details about the events
 

mlrun/model_monitoring/writer.py

@@ -17,7 +17,7 @@ from typing import Any, NewType
 
 import mlrun.common.model_monitoring
 import mlrun.common.schemas
-import mlrun.common.schemas.alert as alert_constants
+import mlrun.common.schemas.alert as alert_objects
 import mlrun.model_monitoring
 from mlrun.common.schemas.model_monitoring.constants import (
     EventFieldType,
@@ -123,14 +123,14 @@ class ModelMonitoringWriter(StepToDict):
     ) -> None:
         logger.info("Sending an alert")
         entity = mlrun.common.schemas.alert.EventEntities(
-            kind=alert_constants.EventEntityKind.MODEL,
+            kind=alert_objects.EventEntityKind.MODEL,
             project=project_name,
             ids=[model_endpoint],
         )
         event_kind = (
-            alert_constants.EventKind.DRIFT_DETECTED
+            alert_objects.EventKind.DRIFT_DETECTED
             if drift_status == ResultStatusApp.detected.value
-            else alert_constants.EventKind.DRIFT_SUSPECTED
+            else alert_objects.EventKind.DRIFT_SUSPECTED
         )
         event_data = mlrun.common.schemas.Event(
             kind=event_kind, entity=entity, value_dict=event_value

mlrun/projects/project.py

@@ -2962,8 +2962,12 @@ class MlrunProject(ModelObj):
             engine = "remote"
         # The default engine is kfp if not given:
         workflow_engine = get_workflow_engine(engine or workflow_spec.engine, local)
-        if not inner_engine and engine == "remote":
-            inner_engine = get_workflow_engine(workflow_spec.engine, local).engine
+        if not inner_engine and workflow_engine.engine == "remote":
+            # if inner engine is set to remote, assume kfp as the default inner engine with remote as the runner
+            engine_kind = (
+                workflow_spec.engine if workflow_spec.engine != "remote" else "kfp"
+            )
+            inner_engine = get_workflow_engine(engine_kind, local).engine
         workflow_spec.engine = inner_engine or workflow_engine.engine
 
         run = workflow_engine.run(
@@ -2991,7 +2995,7 @@ class MlrunProject(ModelObj):
             # run's engine gets replaced with inner engine if engine is remote,
             # so in that case we need to get the status from the remote engine manually
             # TODO: support watch for remote:local
-            if engine == "remote" and status_engine.engine != "local":
+            if workflow_engine.engine == "remote" and status_engine.engine != "local":
                 status_engine = _RemoteRunner
 
             status_engine.get_run_status(project=self, run=run, timeout=timeout)

mlrun/runtimes/__init__.py

@@ -43,6 +43,7 @@ from .nuclio import (
     new_v2_model_server,
     nuclio_init_hook,
 )
+from .nuclio.api_gateway import APIGateway
 from .nuclio.application import ApplicationRuntime
 from .nuclio.serving import serving_subkind
 from .remotesparkjob import RemoteSparkRuntime