mlrun 1.8.0rc7__py3-none-any.whl → 1.8.0rc10__py3-none-any.whl

mlrun/db/nopdb.py

@@ -582,8 +582,9 @@ class NopDB(RunDBInterface):
         self,
         name: str,
         project: str,
-        function_name: str,
-        endpoint_id: str,
+        function_name: Optional[str] = None,
+        function_tag: Optional[str] = None,
+        endpoint_id: Optional[str] = None,
     ):
         pass
 
@@ -592,6 +593,7 @@ class NopDB(RunDBInterface):
         project: str,
         name: Optional[str] = None,
         function_name: Optional[str] = None,
+        function_tag: Optional[str] = None,
         model_name: Optional[str] = None,
         labels: Optional[Union[str, dict[str, Optional[str]], list[str]]] = None,
         start: Optional[datetime.datetime] = None,
@@ -608,6 +610,7 @@ class NopDB(RunDBInterface):
         name: str,
         project: str,
         function_name: Optional[str] = None,
+        function_tag: Optional[str] = None,
         endpoint_id: Optional[str] = None,
         tsdb_metrics: bool = True,
         feature_analysis: bool = False,
@@ -620,6 +623,7 @@ class NopDB(RunDBInterface):
         project: str,
         attributes: dict,
         function_name: Optional[str] = None,
+        function_tag: Optional[str] = None,
         endpoint_id: Optional[str] = None,
     ) -> mlrun.common.schemas.ModelEndpoint:
         pass

mlrun/model_monitoring/api.py

@@ -375,8 +375,10 @@ def _generate_model_endpoint(
         ),
         spec=mlrun.common.schemas.ModelEndpointSpec(
             function_name=function_name,
-            model_name=model_obj.metadata.key if model_path else None,
-            model_uid=model_obj.metadata.uid if model_path else None,
+            model_name=model_obj.metadata.key if model_obj else None,
+            model_uid=model_obj.metadata.uid if model_obj else None,
+            model_tag=model_obj.metadata.tag if model_obj else None,
+            model_db_key=model_obj.spec.db_key if model_obj else None,
             model_class="drift-analysis",
         ),
         status=mlrun.common.schemas.ModelEndpointStatus(
@@ -622,4 +624,13 @@ def _create_model_monitoring_function_base(
         project=project,
         writer_application_name=mm_constants.MonitoringFunctionNames.WRITER,
     )
+
+    def block_to_mock_server(*args, **kwargs) -> typing.NoReturn:
+        raise NotImplementedError(
+            "Model monitoring serving functions do not support `.to_mock_server`. "
+            "You may call your model monitoring application object logic via the `.evaluate` method."
+        )
+
+    func_obj.to_mock_server = block_to_mock_server  # Until ML-7643 is implemented
+
     return func_obj

mlrun/model_monitoring/helpers.py

@@ -318,7 +318,6 @@ def update_model_endpoint_last_request(
             project=project,
             endpoint_id=model_endpoint.metadata.uid,
             name=model_endpoint.metadata.name,
-            function_name=model_endpoint.spec.function_name,
             attributes={mm_constants.EventFieldType.LAST_REQUEST: current_request},
         )
     else:  # model endpoint without any serving function - close the window "manually"

mlrun/model_monitoring/stream_processing.py

@@ -339,8 +339,8 @@ class ProcessEndpointEvent(mlrun.feature_store.steps.MapClass):
 
         # In case this process fails, resume state from existing record
         self.resume_state(
-            endpoint_id,
-            full_event.body.get(EventFieldType.MODEL),
+            endpoint_id=endpoint_id,
+            endpoint_name=full_event.body.get(EventFieldType.MODEL),
         )
 
         # Validate event fields

mlrun/projects/project.py

@@ -1870,13 +1870,13 @@ class MlrunProject(ModelObj):
 
     def get_vector_store_collection(
         self,
-        collection_name: str,
         vector_store: "VectorStore",  # noqa: F821
+        collection_name: Optional[str] = None,
     ) -> VectorStoreCollection:
         return VectorStoreCollection(
             self,
-            collection_name,
             vector_store,
+            collection_name,
         )
 
     def log_document(
@@ -2117,10 +2117,9 @@ class MlrunProject(ModelObj):
 
     def set_model_monitoring_function(
         self,
-        func: typing.Union[str, mlrun.runtimes.BaseRuntime, None] = None,
+        func: typing.Union[str, mlrun.runtimes.RemoteRuntime, None] = None,
         application_class: typing.Union[
-            str,
-            mm_app.ModelMonitoringApplicationBase,
+            str, mm_app.ModelMonitoringApplicationBase, None
         ] = None,
         name: Optional[str] = None,
         image: Optional[str] = None,
@@ -2130,7 +2129,7 @@ class MlrunProject(ModelObj):
         requirements: Optional[typing.Union[str, list[str]]] = None,
         requirements_file: str = "",
         **application_kwargs,
-    ) -> mlrun.runtimes.BaseRuntime:
+    ) -> mlrun.runtimes.RemoteRuntime:
         """
         Update or add a monitoring function to the project.
         Note: to deploy the function after linking it to the project,
@@ -2142,7 +2141,8 @@ class MlrunProject(ModelObj):
                 name="myApp", application_class="MyApp", image="mlrun/mlrun"
             )
 
-        :param func:                    Function object or spec/code url, None refers to current Notebook
+        :param func:                    Remote function object or spec/code URL. :code:`None` refers to the current
+                                        notebook.
         :param name:                    Name of the function (under the project), can be specified with a tag to support
                                         versions (e.g. myfunc:v1)
                                         Default: job
@@ -2158,6 +2158,7 @@ class MlrunProject(ModelObj):
         :param application_class:       Name or an Instance of a class that implements the monitoring application.
         :param application_kwargs:      Additional keyword arguments to be passed to the
                                         monitoring application's constructor.
+        :returns:                       The model monitoring remote function object.
         """
         (
             resolved_function_name,
@@ -2195,7 +2196,7 @@ class MlrunProject(ModelObj):
         requirements: Optional[typing.Union[str, list[str]]] = None,
         requirements_file: str = "",
         **application_kwargs,
-    ) -> mlrun.runtimes.BaseRuntime:
+    ) -> mlrun.runtimes.RemoteRuntime:
         """
         Create a monitoring function object without setting it to the project
 
@@ -2205,7 +2206,7 @@ class MlrunProject(ModelObj):
                 application_class_name="MyApp", image="mlrun/mlrun", name="myApp"
             )
 
-        :param func:                    Code url, None refers to current Notebook
+        :param func:                    The function's code URL. :code:`None` refers to the current notebook.
         :param name:                    Name of the function, can be specified with a tag to support
                                         versions (e.g. myfunc:v1)
                                         Default: job
@@ -2221,6 +2222,7 @@ class MlrunProject(ModelObj):
         :param application_class:       Name or an Instance of a class that implementing the monitoring application.
         :param application_kwargs:      Additional keyword arguments to be passed to the
                                         monitoring application's constructor.
+        :returns:                       The model monitoring remote function object.
         """
 
         _, function_object, _ = self._instantiate_model_monitoring_function(
@@ -2253,7 +2255,7 @@ class MlrunProject(ModelObj):
         requirements: typing.Union[str, list[str], None] = None,
         requirements_file: str = "",
         **application_kwargs,
-    ) -> tuple[str, mlrun.runtimes.BaseRuntime, dict]:
+    ) -> tuple[str, mlrun.runtimes.RemoteRuntime, dict]:
         import mlrun.model_monitoring.api
 
         kind = None
@@ -3550,11 +3552,13 @@ class MlrunProject(ModelObj):
         name: Optional[str] = None,
         model_name: Optional[str] = None,
         function_name: Optional[str] = None,
+        function_tag: Optional[str] = None,
         labels: Optional[list[str]] = None,
         start: Optional[datetime.datetime] = None,
         end: Optional[datetime.datetime] = None,
         top_level: bool = False,
         uids: Optional[list[str]] = None,
+        latest_only: bool = False,
     ) -> mlrun.common.schemas.ModelEndpointList:
         """
         Returns a list of `ModelEndpoint` objects. Each `ModelEndpoint` object represents the current state of a
@@ -3562,10 +3566,11 @@ class MlrunProject(ModelObj):
         1) name
         2) model_name
         3) function_name
-        4) labels
-        5) top level
-        6) uids
-        7) start and end time, corresponding to the `created` field.
+        4) function_tag
+        5) labels
+        6) top level
+        7) uids
+        8) start and end time, corresponding to the `created` field.
         By default, when no filters are applied, all available endpoints for the given project will be listed.
 
         In addition, this functions provides a facade for listing endpoint related metrics. This facade is time-based
@@ -3574,6 +3579,7 @@ class MlrunProject(ModelObj):
         :param name: The name of the model to filter by
         :param model_name: The name of the model to filter by
         :param function_name: The name of the function to filter by
+        :param function_tag: The tag of the function to filter by
         :param labels: Filter model endpoints by label key-value pairs or key existence. This can be provided as:
             - A dictionary in the format `{"label": "value"}` to match specific label key-value pairs,
             or `{"label": None}` to check for key existence.
@@ -3594,11 +3600,13 @@ class MlrunProject(ModelObj):
             name=name,
             model_name=model_name,
             function_name=function_name,
+            function_tag=function_tag,
             labels=labels,
             start=start,
             end=end,
             top_level=top_level,
             uids=uids,
+            latest_only=latest_only,
         )
 
     def run_function(
@@ -3984,18 +3992,21 @@ class MlrunProject(ModelObj):
             mock=mock,
         )
 
-    def get_artifact(self, key, tag=None, iter=None, tree=None):
+    def get_artifact(
+        self, key, tag=None, iter=None, tree=None, uid=None
+    ) -> typing.Optional[Artifact]:
         """Return an artifact object
 
-        :param key: artifact key
-        :param tag: version tag
-        :param iter: iteration number (for hyper-param tasks)
-        :param tree: the producer id (tree)
+        :param key: Artifact key
+        :param tag: Version tag
+        :param iter: Iteration number (for hyper-param tasks)
+        :param tree: The producer id (tree)
+        :param uid: The artifact uid
         :return: Artifact object
         """
         db = mlrun.db.get_run_db(secrets=self._secrets)
         artifact = db.read_artifact(
-            key, tag, iter=iter, project=self.metadata.name, tree=tree
+            key, tag, iter=iter, project=self.metadata.name, tree=tree, uid=uid
         )
 
         # in tests, if an artifact is not found, the db returns None

mlrun/runtimes/nuclio/serving.py

@@ -421,8 +421,6 @@ class ServingRuntime(RemoteRuntime):
                 class_name.model_path = model_path
             key, state = params_to_step(class_name, key)
         else:
-            if not model_path and not model_url:
-                raise ValueError("model_path or model_url must be provided")
             class_name = class_name or self.spec.default_class
             if class_name and not isinstance(class_name, str):
                 raise ValueError(

mlrun/serving/routers.py

@@ -1021,6 +1021,7 @@ def _init_endpoint_record(
             project=graph_server.project,
             name=voting_ensemble.name,
             function_name=graph_server.function_name,
+            function_tag=graph_server.function_tag or "latest",
         )
     except mlrun.errors.MLRunNotFoundError:
         model_endpoint = None
@@ -1049,6 +1050,7 @@ def _init_endpoint_record(
             name=voting_ensemble.name,
             project=graph_server.project,
             function_name=graph_server.function_name,
+            function_tag=graph_server.function_tag or "latest",
             function_uid=function_uid,
             model_class=voting_ensemble.__class__.__name__,
         )
@@ -1101,7 +1103,6 @@ def _init_endpoint_record(
             model_endpoint = db.patch_model_endpoint(
                 project=model_endpoint.metadata.project,
                 name=model_endpoint.metadata.name,
-                function_name=model_endpoint.spec.function_name,
                 endpoint_id=model_endpoint.metadata.uid,
                 attributes=attributes,
             )
@@ -1121,7 +1122,6 @@ def _init_endpoint_record(
         mlrun.get_run_db().patch_model_endpoint(
             name=name,
             project=graph_server.project,
-            function_name=graph_server.function_name,
             endpoint_id=uid,
             attributes={
                 ModelEndpointSchema.ENDPOINT_TYPE: mlrun.common.schemas.model_monitoring.EndpointType.LEAF_EP

mlrun/serving/v2_serving.py

@@ -197,13 +197,15 @@ class V2ModelServer(StepToDict):
             extra dataitems dictionary
 
         """
-        model_file, self.model_spec, extra_dataitems = mlrun.artifacts.get_model(
-            self.model_path, suffix
-        )
-        if self.model_spec and self.model_spec.parameters:
-            for key, value in self.model_spec.parameters.items():
-                self._params[key] = value
-        return model_file, extra_dataitems
+        if self.model_path:
+            model_file, self.model_spec, extra_dataitems = mlrun.artifacts.get_model(
+                self.model_path, suffix
+            )
+            if self.model_spec and self.model_spec.parameters:
+                for key, value in self.model_spec.parameters.items():
+                    self._params[key] = value
+            return model_file, extra_dataitems
+        return None, None
 
     def load(self):
         """model loading function, see also .get_model() method"""
@@ -569,11 +571,24 @@ def _init_endpoint_record(
     logger.info("Initializing endpoint records")
     if not model.model_spec:
         model.get_model()
+    if model.model_spec:
+        model_name = model.model_spec.metadata.key
+        model_db_key = model.model_spec.spec.db_key
+        model_uid = model.model_spec.metadata.uid
+        model_tag = model.model_spec.tag
+        model_labels = model.model_spec.labels  # todo : check if we still need this
+    else:
+        model_name = None
+        model_db_key = None
+        model_uid = None
+        model_tag = None
+        model_labels = {}
     try:
         model_ep = mlrun.get_run_db().get_model_endpoint(
             project=graph_server.project,
             name=model.name,
             function_name=graph_server.function_name,
+            function_tag=graph_server.function_tag or "latest",
         )
     except mlrun.errors.MLRunNotFoundError:
         model_ep = None
@@ -595,16 +610,18 @@ def _init_endpoint_record(
             name=model.name,
             project=graph_server.project,
             function_name=graph_server.function_name,
+            function_tag=graph_server.function_tag or "latest",
             function_uid=function_uid,
-            model_name=model.model_spec.metadata.key,
-            model_uid=model.model_spec.metadata.uid,
+            model_name=model_name,
+            model_tag=model_tag,
+            model_db_key=model_db_key,
+            model_uid=model_uid,
             model_class=model.__class__.__name__,
-            model_tag=model.model_spec.tag,
         )
         model_ep = mlrun.common.schemas.ModelEndpoint(
             metadata=mlrun.common.schemas.ModelEndpointMetadata(
                 project=graph_server.project,
-                labels=model.model_spec.labels,
+                labels=model_labels,
                 name=model.name,
                 endpoint_type=mlrun.common.schemas.model_monitoring.EndpointType.NODE_EP,
             ),
@@ -612,9 +629,11 @@ def _init_endpoint_record(
                 function_name=graph_server.function_name,
                 function_uid=function_uid,
                 function_tag=graph_server.function_tag or "latest",
-                model_name=model.model_spec.metadata.key,
-                model_uid=model.model_spec.metadata.uid,
+                model_name=model_name,
+                model_db_key=model_db_key,
+                model_uid=model_uid,
                 model_class=model.__class__.__name__,
+                model_tag=model_tag,
             ),
             status=mlrun.common.schemas.ModelEndpointStatus(
                 monitoring_mode=mlrun.common.schemas.model_monitoring.ModelMonitoringMode.enabled
@@ -623,16 +642,22 @@ def _init_endpoint_record(
             ),
         )
         db = mlrun.get_run_db()
-        db.create_model_endpoint(model_endpoint=model_ep)
+        model_ep = db.create_model_endpoint(model_endpoint=model_ep)
 
     elif model_ep:
         attributes = {}
         if function_uid != model_ep.spec.function_uid:
             attributes[ModelEndpointSchema.FUNCTION_UID] = function_uid
-        if model.model_spec.metadata.key != model_ep.spec.model_name:
-            attributes[ModelEndpointSchema.MODEL_NAME] = model.model_spec.metadata.key
-        if model.model_spec.metadata.uid != model_ep.spec.model_uid:
-            attributes[ModelEndpointSchema.MODEL_UID] = model.model_spec.metadata.uid
+        if model_name != model_ep.spec.model_name:
+            attributes[ModelEndpointSchema.MODEL_NAME] = model_name
+        if model_uid != model_ep.spec.model_uid:
+            attributes[ModelEndpointSchema.MODEL_UID] = model_uid
+        if model_tag != model_ep.spec.model_tag:
+            attributes[ModelEndpointSchema.MODEL_TAG] = model_tag
+        if model_db_key != model_ep.spec.model_db_key:
+            attributes[ModelEndpointSchema.MODEL_DB_KEY] = model_db_key
+        if model_labels != model_ep.metadata.labels:
+            attributes[ModelEndpointSchema.LABELS] = model_labels
         if model.__class__.__name__ != model_ep.spec.model_class:
             attributes[ModelEndpointSchema.MODEL_CLASS] = model.__class__.__name__
         if (
@@ -656,7 +681,6 @@ def _init_endpoint_record(
             model_ep = db.patch_model_endpoint(
                 project=model_ep.metadata.project,
                 name=model_ep.metadata.name,
-                function_name=model_ep.spec.function_name,
                 endpoint_id=model_ep.metadata.uid,
                 attributes=attributes,
             )

mlrun/utils/helpers.py

@@ -670,8 +670,8 @@ def dict_to_json(struct):
 
 def parse_artifact_uri(uri, default_project=""):
     """
-    Parse artifact URI into project, key, tag, iter, tree
-    URI format: [<project>/]<key>[#<iter>][:<tag>][@<tree>]
+    Parse artifact URI into project, key, tag, iter, tree, uid
+    URI format: [<project>/]<key>[#<iter>][:<tag>][@<tree>][^<uid>]
 
     :param uri:            uri to parse
     :param default_project: default project name if not in URI
@@ -681,6 +681,7 @@ def parse_artifact_uri(uri, default_project=""):
         [2] = iteration
         [3] = tag
         [4] = tree
+        [5] = uid
     """
     uri_pattern = mlrun.utils.regex.artifact_uri_pattern
     match = re.match(uri_pattern, uri)
@@ -705,6 +706,7 @@ def parse_artifact_uri(uri, default_project=""):
         iteration,
         group_dict["tag"],
         group_dict["tree"],
+        group_dict["uid"],
     )
 
 
@@ -719,7 +721,9 @@ def generate_object_uri(project, name, tag=None, hash_key=None):
     return uri
 
 
-def generate_artifact_uri(project, key, tag=None, iter=None, tree=None):
+def generate_artifact_uri(
+    project, key, tag=None, iter=None, tree=None, uid=None
+) -> str:
     artifact_uri = f"{project}/{key}"
     if iter is not None:
         artifact_uri = f"{artifact_uri}#{iter}"
@@ -727,6 +731,8 @@ def generate_artifact_uri(project, key, tag=None, iter=None, tree=None):
         artifact_uri = f"{artifact_uri}:{tag}"
     if tree is not None:
         artifact_uri = f"{artifact_uri}@{tree}"
+    if uid is not None:
+        artifact_uri = f"{artifact_uri}^{uid}"
     return artifact_uri
 
 

mlrun/utils/regex.py

@@ -96,7 +96,14 @@ v3io_stream_consumer_group = [r"^(?!_)[a-zA-Z0-9_]{1,256}$"]
 # URI patterns
 run_uri_pattern = r"^(?P<project>.*)@(?P<uid>.*)\#(?P<iteration>.*?)(:(?P<tag>.*))?$"
 
-artifact_uri_pattern = r"^((?P<project>.*)/)?(?P<key>.*?)(\#(?P<iteration>.*?))?(:(?P<tag>.*?))?(@(?P<tree>.*))?$"
+artifact_uri_pattern = (
+    r"^((?P<project>.*)/)?"  # Optional project
+    r"(?P<key>.*?)"  # Key
+    r"(\#(?P<iteration>.*?))?"  # Optional iteration
+    r"(:(?P<tag>.*?))?"  # Optional tag
+    r"(@(?P<tree>.*?))?"  # Optional tree
+    r"(\^(?P<uid>.*))?$"  # Optional uid
+)
 
 artifact_producer_uri_pattern = (
     r"^((?P<project>.*)/)?(?P<uid>.*?)(\-(?P<iteration>.*?))?$"

mlrun/utils/version/version.json

@@ -1,4 +1,4 @@
 {
-  "git_commit": "052529570e5bbae67e99d98a89713d70c6751607",
-  "version": "1.8.0-rc7"
+  "git_commit": "9e2d1e195daed90072d1cd33a5eee339577dc35a",
+  "version": "1.8.0-rc10"
 }

{mlrun-1.8.0rc7.dist-info → mlrun-1.8.0rc10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mlrun
-Version: 1.8.0rc7
+Version: 1.8.0rc10
 Summary: Tracking and config of machine learning runs
 Home-page: https://github.com/mlrun/mlrun
 Author: Yaron Haviv