mlrun 1.5.0rc12__py3-none-any.whl → 1.5.0rc13__py3-none-any.whl

mlrun/model_monitoring/helpers.py

@@ -20,20 +20,56 @@ import mlrun.common.model_monitoring.helpers
 import mlrun.common.schemas
 
 
-def get_stream_path(project: str = None):
-    """Get stream path from the project secret. If wasn't set, take it from the system configurations"""
+def get_stream_path(project: str = None, application_name: str = None):
+    """
+    Get stream path from the project secret. If wasn't set, take it from the system configurations
+
+    :param project:             Project name.
+    :param application_name:    Application name, None for model_monitoring_stream.
+
+    :return:                    Monitoring stream path to the relevant application.
+    """
 
     stream_uri = mlrun.get_secret_or_env(
         mlrun.common.schemas.model_monitoring.ProjectSecretKeys.STREAM_PATH
+        if application_name is None
+        else ""
     ) or mlrun.mlconf.get_model_monitoring_file_target_path(
         project=project,
         kind=mlrun.common.schemas.model_monitoring.FileTargetKind.STREAM,
         target="online",
+        application_name=application_name,
     )
 
     return mlrun.common.model_monitoring.helpers.parse_monitoring_stream_path(
-        stream_uri=stream_uri, project=project
+        stream_uri=stream_uri, project=project, application_name=application_name
+    )
+
+
+def get_monitoring_parquet_path(
+    project: str,
+    kind: str = mlrun.common.schemas.model_monitoring.FileTargetKind.PARQUET,
+) -> str:
+    """Get model monitoring parquet target for the current project and kind. The parquet target path is based on the
+    project artifact path. If project artifact path is not defined, the parquet target path will be based on MLRun
+    artifact path.
+
+    :param project:     Project name.
+    :param kind:        indicate the kind of the parquet path, can be either stream_parquet or stream_controller_parquet
+
+    :return:           Monitoring parquet target path.
+    """
+
+    project_obj = mlrun.get_or_create_project(name=project)
+    artifact_path = project_obj.spec.artifact_path
+    # Generate monitoring parquet path value
+    parquet_path = mlrun.mlconf.get_model_monitoring_file_target_path(
+        project=project,
+        kind=kind,
+        target="offline",
+        artifact_path=artifact_path,
     )
+    return parquet_path
 
 
 def get_connection_string(secret_provider: typing.Callable = None) -> str:

mlrun/model_monitoring/stores/kv_model_endpoint_store.py

@@ -27,6 +27,12 @@ from mlrun.utils import logger
 
 from .model_endpoint_store import ModelEndpointStore
 
+# Fields to encode before storing in the KV table or to decode after retrieving
+fields_to_encode_decode = [
+    mlrun.common.schemas.model_monitoring.EventFieldType.FEATURE_STATS,
+    mlrun.common.schemas.model_monitoring.EventFieldType.CURRENT_STATS,
+]
+
 
 class KVModelEndpointStore(ModelEndpointStore):
     """
@@ -51,6 +57,11 @@ class KVModelEndpointStore(ModelEndpointStore):
         :param endpoint: model endpoint dictionary that will be written into the DB.
         """
 
+        for field in fields_to_encode_decode:
+            if field in endpoint:
+                # Encode to binary data
+                endpoint[field] = self._encode_field(endpoint[field])
+
         self.client.kv.put(
             container=self.container,
             table_path=self.path,
@@ -70,6 +81,11 @@ class KVModelEndpointStore(ModelEndpointStore):
 
         """
 
+        for field in fields_to_encode_decode:
+            if field in attributes:
+                # Encode to binary data
+                attributes[field] = self._encode_field(attributes[field])
+
         self.client.kv.update(
             container=self.container,
             table_path=self.path,
@@ -117,6 +133,11 @@ class KVModelEndpointStore(ModelEndpointStore):
         )
         endpoint = endpoint.output.item
 
+        for field in fields_to_encode_decode:
+            if field in endpoint:
+                # Decode binary data
+                endpoint[field] = self._decode_field(endpoint[field])
+
         if not endpoint:
             raise mlrun.errors.MLRunNotFoundError(f"Endpoint {endpoint_id} not found")
 
@@ -512,3 +533,19 @@ class KVModelEndpointStore(ModelEndpointStore):
             ] = endpoint[
                 mlrun.common.schemas.model_monitoring.EventFieldType.ENDPOINT_ID
             ]
+
+    @staticmethod
+    def _encode_field(field: typing.Union[str, bytes]) -> bytes:
+        """Encode a provided field. Mainly used when storing data in the KV table."""
+
+        if isinstance(field, str):
+            return field.encode("ascii")
+        return field
+
+    @staticmethod
+    def _decode_field(field: typing.Union[str, bytes]) -> str:
+        """Decode a provided field. Mainly used when retrieving data from the KV table."""
+
+        if isinstance(field, bytes):
+            return field.decode()
+        return field

mlrun/model_monitoring/tracking_policy.py

@@ -26,10 +26,7 @@ class TrackingPolicy(mlrun.model.ModelObj):
     model monitoring stream.
     """
 
-    _dict_fields = [
-        "default_batch_image",
-        "stream_image",
-    ]
+    _dict_fields = ["default_batch_image", "stream_image", "application_batch"]
 
     def __init__(
         self,
@@ -38,6 +35,7 @@ class TrackingPolicy(mlrun.model.ModelObj):
         ] = mlrun.common.schemas.schedule.ScheduleCronTrigger(minute="0", hour="*/1"),
         default_batch_image: str = "mlrun/mlrun",
         stream_image: str = "mlrun/mlrun",
+        application_batch: bool = False,
     ):
         """
         Initialize TrackingPolicy object.
@@ -50,6 +48,7 @@ class TrackingPolicy(mlrun.model.ModelObj):
                                             is mlrun/mlrun.
         :param stream_image:                The image of the model monitoring stream real-time function. By default,
                                             the image is mlrun/mlrun.
+        :param application_batch
         """
         if isinstance(default_batch_intervals, str):
             default_batch_intervals = (
@@ -60,6 +59,7 @@ class TrackingPolicy(mlrun.model.ModelObj):
         self.default_batch_intervals = default_batch_intervals
         self.default_batch_image = default_batch_image
         self.stream_image = stream_image
+        self.application_batch = application_batch
 
     @classmethod
     def from_dict(cls, struct=None, fields=None, deprecated_fields: dict = None):

mlrun/model_monitoring/writer.py

@@ -0,0 +1,37 @@
+# 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 mlrun.common.schemas
+from mlrun.serving.utils import StepToDict
+
+
+class ModelMonitoringWriter(StepToDict):
+    """DEMO WRITER TODO"""
+
+    kind = "monitoring_application_stream_pusher"
+
+    def __init__(self, name: str = None):
+        self.name = name or "king"
+
+    def do(self, event):
+
+        print(
+            f"endpoint_uid ={event[mlrun.common.schemas.model_monitoring.constants.WriterEvent.ENDPOINT_ID]}, \n"
+            f"app_name = {event[mlrun.common.schemas.model_monitoring.constants.WriterEvent.APPLICATION_NAME]}, \n"
+            f"schedule_time = {event[mlrun.common.schemas.model_monitoring.constants.WriterEvent.SCHEDULE_TIME]}, \n"
+            f"result_name ={event[mlrun.common.schemas.model_monitoring.constants.WriterEvent.RESULT_NAME]}, \n"
+            f"result_value ={event[mlrun.common.schemas.model_monitoring.constants.WriterEvent.RESULT_VALUE]}, \n"
+            f"my_name = {self.name}."
+        )
+        return event

mlrun/projects/pipelines.py

@@ -19,6 +19,7 @@ import tempfile
 import traceback
 import typing
 import uuid
+import warnings
 
 import kfp.compiler
 from kfp import dsl
@@ -76,18 +77,28 @@ class WorkflowSpec(mlrun.model.ModelObj):
         args=None,
         name=None,
         handler=None,
+        # TODO: deprecated, remove in 1.6.0
+        ttl=None,
         args_schema: dict = None,
         schedule: typing.Union[str, mlrun.common.schemas.ScheduleCronTrigger] = None,
         cleanup_ttl: int = None,
         image: str = None,
     ):
+        if ttl:
+            warnings.warn(
+                "'ttl' is deprecated, use 'cleanup_ttl' instead. "
+                "This will be removed in 1.6.0",
+                # TODO: Remove this in 1.6.0
+                FutureWarning,
+            )
         self.engine = engine
         self.code = code
         self.path = path
         self.args = args
         self.name = name
         self.handler = handler
-        self.cleanup_ttl = cleanup_ttl
+        self.ttl = cleanup_ttl or ttl
+        self.cleanup_ttl = cleanup_ttl or ttl
         self.args_schema = args_schema
         self.run_local = False
         self._tmp_path = None
@@ -550,7 +561,7 @@ class _KFPRunner(_PipelineRunner):
 
         conf = new_pipe_metadata(
             artifact_path=artifact_path,
-            cleanup_ttl=workflow_spec.cleanup_ttl,
+            cleanup_ttl=workflow_spec.cleanup_ttl or workflow_spec.ttl,
         )
         compiler.Compiler().compile(pipeline, target, pipeline_conf=conf)
         workflow_spec.clear_tmp()
@@ -583,7 +594,7 @@ class _KFPRunner(_PipelineRunner):
             experiment=name or workflow_spec.name,
             namespace=namespace,
             artifact_path=artifact_path,
-            cleanup_ttl=workflow_spec.cleanup_ttl,
+            cleanup_ttl=workflow_spec.cleanup_ttl or workflow_spec.ttl,
         )
         project.notifiers.push_pipeline_start_message(
             project.metadata.name,
@@ -764,6 +775,13 @@ class _RemoteRunner(_PipelineRunner):
         inner_engine = get_workflow_engine(workflow_spec.engine)
         run_db = mlrun.get_run_db()
         try:
+            logger.info(
+                "Submitting remote workflow",
+                workflow_engine=workflow_spec.engine,
+                schedule=workflow_spec.schedule,
+                project_name=project.name,
+            )
+
             workflow_response = run_db.submit_workflow(
                 project=project.name,
                 name=workflow_name,
@@ -776,6 +794,10 @@ class _RemoteRunner(_PipelineRunner):
                 namespace=namespace,
             )
             if workflow_spec.schedule:
+                logger.info(
+                    "Workflow scheduled successfully",
+                    workflow_response=workflow_response,
+                )
                 return
 
             # Getting workflow id from run:
@@ -883,6 +905,8 @@ def load_and_run(
     namespace: str = None,
     sync: bool = False,
     dirty: bool = False,
+    # TODO: deprecated, remove in 1.6.0
+    ttl: int = None,
     engine: str = None,
     local: bool = None,
     schedule: typing.Union[str, mlrun.common.schemas.ScheduleCronTrigger] = None,
@@ -910,6 +934,8 @@ def load_and_run(
     :param namespace:           kubernetes namespace if other than default
     :param sync:                force functions sync before run
     :param dirty:               allow running the workflow when the git repo is dirty
+    :param ttl:                 pipeline cleanup ttl in secs (time to wait after workflow completion, at which point the
+                                workflow and all its resources are deleted) (deprecated, use cleanup_ttl instead)
     :param engine:              workflow engine running the workflow.
                                 supported values are 'kfp' (default) or 'local'
     :param local:               run local pipeline with local functions (set local=True in function.run())
@@ -918,6 +944,14 @@ def load_and_run(
                                 workflow and all its resources are deleted)
     :param load_only:           for just loading the project, inner use.
     """
+    if ttl:
+        warnings.warn(
+            "'ttl' is deprecated, use 'cleanup_ttl' instead. "
+            "This will be removed in 1.6.0",
+            # TODO: Remove this in 1.6.0
+            FutureWarning,
+        )
+
     try:
         project = mlrun.load_project(
             context=f"./{project_name}",
@@ -969,7 +1003,7 @@ def load_and_run(
         sync=sync,
         watch=False,  # Required for fetching the workflow_id
         dirty=dirty,
-        cleanup_ttl=cleanup_ttl,
+        cleanup_ttl=cleanup_ttl or ttl,
         engine=engine,
         local=local,
     )