mlrun 1.8.0rc5__py3-none-any.whl → 1.8.0rc9__py3-none-any.whl

mlrun/serving/routers.py

@@ -28,10 +28,9 @@ import numpy as np
 import mlrun
 import mlrun.common.model_monitoring
 import mlrun.common.schemas.model_monitoring
-from mlrun.errors import err_to_str
 from mlrun.utils import logger, now_date
 
-from ..common.helpers import parse_versioned_object_uri
+from ..common.schemas.model_monitoring import ModelEndpointSchema
 from .server import GraphServer
 from .utils import RouterToDict, _extract_input_data, _update_result_body
 from .v2_serving import _ModelLogPusher
@@ -814,7 +813,8 @@ class VotingEnsemble(ParallelRun):
         return self.logic(flattened_predictions, np.array(weights))
 
     def do_event(self, event, *args, **kwargs):
-        """Handles incoming requests.
+        """
+        Handles incoming requests.
 
         Parameters
         ----------
@@ -1016,116 +1016,124 @@ def _init_endpoint_record(
     """
 
     logger.info("Initializing endpoint records")
-
-    # Generate required values for the model endpoint record
-    try:
-        # Getting project name from the function uri
-        project, uri, tag, hash_key = parse_versioned_object_uri(
-            graph_server.function_uri
-        )
-    except Exception as e:
-        logger.error("Failed to parse function URI", exc=err_to_str(e))
-        return None
-
-    # Generating version model value based on the model name and model version
-    if voting_ensemble.version:
-        versioned_model_name = f"{voting_ensemble.name}:{voting_ensemble.version}"
-    else:
-        versioned_model_name = f"{voting_ensemble.name}:latest"
-
-    # Generating model endpoint ID based on function uri and model version
-    endpoint_uid = mlrun.common.model_monitoring.create_model_endpoint_uid(
-        function_uri=graph_server.function_uri, versioned_model=versioned_model_name
-    ).uid
-
     try:
-        model_ep = mlrun.get_run_db().get_model_endpoint(
-            project=project, endpoint_id=endpoint_uid
+        model_endpoint = mlrun.get_run_db().get_model_endpoint(
+            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_ep = None
+        model_endpoint = None
     except mlrun.errors.MLRunBadRequestError as err:
-        logger.debug(
-            f"Cant reach to model endpoints store, due to  : {err}",
+        logger.info(
+            "Cannot get the model endpoints store", err=mlrun.errors.err_to_str(err)
         )
         return
 
-    if voting_ensemble.context.server.track_models and not model_ep:
-        logger.info("Creating a new model endpoint record", endpoint_id=endpoint_uid)
-        # Get the children model endpoints ids
-        children_uids = []
-        for _, c in voting_ensemble.routes.items():
-            if hasattr(c, "endpoint_uid"):
-                children_uids.append(c.endpoint_uid)
+    function = mlrun.get_run_db().get_function(
+        name=graph_server.function_name,
+        project=graph_server.project,
+        tag=graph_server.function_tag or "latest",
+    )
+    function_uid = function.get("metadata", {}).get("uid")
+    # Get the children model endpoints ids
+    children_uids = []
+    children_names = []
+    for _, c in voting_ensemble.routes.items():
+        if hasattr(c, "endpoint_uid"):
+            children_uids.append(c.endpoint_uid)
+            children_names.append(c.name)
+    if not model_endpoint and voting_ensemble.context.server.track_models:
+        logger.info(
+            "Creating a new model 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__,
+        )
         model_endpoint = mlrun.common.schemas.ModelEndpoint(
             metadata=mlrun.common.schemas.ModelEndpointMetadata(
-                project=project, uid=endpoint_uid
+                project=graph_server.project,
+                name=voting_ensemble.name,
+                endpoint_type=mlrun.common.schemas.model_monitoring.EndpointType.ROUTER,
             ),
             spec=mlrun.common.schemas.ModelEndpointSpec(
-                function_uri=graph_server.function_uri,
-                model=versioned_model_name,
+                function_name=graph_server.function_name,
+                function_uid=function_uid,
+                function_tag=graph_server.function_tag or "latest",
                 model_class=voting_ensemble.__class__.__name__,
-                stream_path=voting_ensemble.context.stream.stream_uri,
-                active=True,
-                monitoring_mode=mlrun.common.schemas.model_monitoring.ModelMonitoringMode.enabled,
+                children_uids=list(voting_ensemble.routes.keys()),
             ),
             status=mlrun.common.schemas.ModelEndpointStatus(
-                children=list(voting_ensemble.routes.keys()),
-                endpoint_type=mlrun.common.schemas.model_monitoring.EndpointType.ROUTER,
-                children_uids=children_uids,
+                monitoring_mode=mlrun.common.schemas.model_monitoring.ModelMonitoringMode.enabled
+                if voting_ensemble.context.server.track_models
+                else mlrun.common.schemas.model_monitoring.ModelMonitoringMode.disabled,
             ),
         )
-
         db = mlrun.get_run_db()
-
-        db.create_model_endpoint(
-            project=project,
-            endpoint_id=model_endpoint.metadata.uid,
-            model_endpoint=model_endpoint.dict(),
-        )
-
-        # Update model endpoint children type
-        for model_endpoint in children_uids:
-            current_endpoint = db.get_model_endpoint(
-                project=project, endpoint_id=model_endpoint
+        db.create_model_endpoint(model_endpoint=model_endpoint)
+
+    elif model_endpoint:
+        attributes = {}
+        if function_uid != model_endpoint.spec.function_uid:
+            attributes[ModelEndpointSchema.FUNCTION_UID] = function_uid
+        if children_uids != model_endpoint.spec.children_uids:
+            attributes[ModelEndpointSchema.CHILDREN_UIDS] = children_uids
+        if (
+            model_endpoint.status.monitoring_mode
+            == mlrun.common.schemas.model_monitoring.ModelMonitoringMode.enabled
+        ) != voting_ensemble.context.server.track_models:
+            attributes[ModelEndpointSchema.MONITORING_MODE] = (
+                mlrun.common.schemas.model_monitoring.ModelMonitoringMode.enabled
+                if voting_ensemble.context.server.track_models
+                else mlrun.common.schemas.model_monitoring.ModelMonitoringMode.disabled
             )
-            current_endpoint.status.endpoint_type = (
-                mlrun.common.schemas.model_monitoring.EndpointType.LEAF_EP
+        if attributes:
+            db = mlrun.get_run_db()
+            logger.info(
+                "Updating model endpoint attributes",
+                attributes=attributes,
+                project=model_endpoint.metadata.project,
+                name=model_endpoint.metadata.name,
+                function_name=model_endpoint.spec.function_name,
             )
-            db.create_model_endpoint(
-                project=project,
-                endpoint_id=model_endpoint,
-                model_endpoint=current_endpoint,
+            model_endpoint = db.patch_model_endpoint(
+                project=model_endpoint.metadata.project,
+                name=model_endpoint.metadata.name,
+                endpoint_id=model_endpoint.metadata.uid,
+                attributes=attributes,
             )
-    elif (
-        model_ep
-        and (
-            model_ep.spec.monitoring_mode
-            == mlrun.common.schemas.model_monitoring.ModelMonitoringMode.enabled
-        )
-        != voting_ensemble.context.server.track_models
-    ):
-        monitoring_mode = (
-            mlrun.common.schemas.model_monitoring.ModelMonitoringMode.enabled
-            if voting_ensemble.context.server.track_models
-            else mlrun.common.schemas.model_monitoring.ModelMonitoringMode.disabled
-        )
-        db = mlrun.get_run_db()
-        db.patch_model_endpoint(
-            project=project,
-            endpoint_id=endpoint_uid,
-            attributes={"monitoring_mode": monitoring_mode},
-        )
-        logger.debug(
-            f"Updating model endpoint monitoring_mode to {monitoring_mode}",
-            endpoint_id=endpoint_uid,
+    else:
+        logger.info(
+            "Did not create a new model endpoint record, monitoring is disabled"
         )
+        return None
 
-    return endpoint_uid
+    # Update model endpoint children type
+    logger.info(
+        "Updating children model endpoint type",
+        children_uids=children_uids,
+        children_names=children_names,
+    )
+    for uid, name in zip(children_uids, children_names):
+        mlrun.get_run_db().patch_model_endpoint(
+            name=name,
+            project=graph_server.project,
+            endpoint_id=uid,
+            attributes={
+                ModelEndpointSchema.ENDPOINT_TYPE: mlrun.common.schemas.model_monitoring.EndpointType.LEAF_EP
+            },
+        )
+    return model_endpoint.metadata.uid
 
 
 class EnrichmentModelRouter(ModelRouter):
-    """model router with feature enrichment and imputing"""
+    """
+    Model router with feature enrichment and imputing
+    """
 
     def __init__(
         self,
@@ -1139,7 +1147,8 @@ class EnrichmentModelRouter(ModelRouter):
         impute_policy: typing.Optional[dict] = None,
         **kwargs,
     ):
-        """Model router with feature enrichment (from the feature store)
+        """
+        Model router with feature enrichment (from the feature store)
 
         The `EnrichmentModelRouter` class enrich the incoming event with real-time features
         read from a feature vector (in MLRun feature store) and forwards the enriched event to the child models
@@ -1147,27 +1156,25 @@ class EnrichmentModelRouter(ModelRouter):
         The feature vector is specified using the `feature_vector_uri`, in addition an imputing policy
         can be specified to substitute None/NaN values with pre defines constant or stats.
 
-        :param feature_vector_uri :  feature vector uri in the form: [project/]name[:tag]
-        :param impute_policy : value imputing (substitute NaN/Inf values with statistical or constant value),
-                              you can set the `impute_policy` parameter with the imputing policy, and specify which
-                              constant or statistical value will be used instead of NaN/Inf value, this can be defined
-                              per column or for all the columns ("*"). the replaced value can be fixed number for
-                              constants or $mean, $max, $min, $std, $count for statistical values.
-                              “*” is used to specify the default for all features, example:
-                              impute_policy={"*": "$mean", "age": 33}
+        :param feature_vector_uri:  feature vector uri in the form: [project/]name[:tag]
+        :param impute_policy: value imputing (substitute NaN/Inf values with statistical or constant value),
+            you can set the `impute_policy` parameter with the imputing policy, and specify which constant or
+            statistical value will be used instead of NaN/Inf value, this can be defined per column or
+            for all the columns ("*"). The replaced value can be fixed number for constants or $mean, $max, $min, $std,
+            $count for statistical values.
+            “*” is used to specify the default for all features, example: impute_policy={"*": "$mean", "age": 33}
         :param context:       for internal use (passed in init)
         :param name:          step name
         :param routes:        for internal use (routes passed in init)
         :param protocol:      serving API protocol (default "v2")
         :param url_prefix:    url prefix for the router (default /v2/models)
         :param health_prefix: health api url prefix (default /v2/health)
-        :param input_path:    when specified selects the key/path in the event to use as body
-                              this require that the event body will behave like a dict, example:
-                              event: {"data": {"a": 5, "b": 7}}, input_path="data.b" means request body will be 7
-        :param result_path:   selects the key/path in the event to write the results to
-                              this require that the event body will behave like a dict, example:
-                              event: {"x": 5} , result_path="resp" means the returned response will be written
-                              to event["y"] resulting in {"x": 5, "resp": <result>}
+        :param input_path:    when specified selects the key/path in the event to use as body this require that the
+            event body will behave like a dict, example: event: {"data": {"a": 5, "b": 7}}, input_path="data.b"
+            means request body will be 7.
+        :param result_path:   selects the key/path in the event to write the results to this require that the event body
+            will behave like a dict, example: event: {"x": 5} , result_path="resp" means the returned response will be
+            written to event["y"] resulting in {"x": 5, "resp": <result>}
         :param kwargs:        extra arguments
         """
         super().__init__(
@@ -1206,7 +1213,9 @@ class EnrichmentModelRouter(ModelRouter):
 
 
 class EnrichmentVotingEnsemble(VotingEnsemble):
-    """Voting Ensemble with feature enrichment (from the feature store)"""
+    """
+    Voting Ensemble with feature enrichment (from the feature store)
+    """
 
     def __init__(
         self,
@@ -1223,16 +1232,18 @@ class EnrichmentVotingEnsemble(VotingEnsemble):
         impute_policy: typing.Optional[dict] = None,
         **kwargs,
     ):
-        """Voting Ensemble with feature enrichment (from the feature store)
+        """
+        Voting Ensemble with feature enrichment (from the feature store)
 
         The `EnrichmentVotingEnsemble` class enables to enrich the incoming event with real-time features
         read from a feature vector (in MLRun feature store) and apply prediction logic on top of
         the different added models.
 
         You can use it by calling:
-        - <prefix>/<model>[/versions/<ver>]/operation
+
+        - `<prefix>/<model>[/versions/<ver>]/operation`
             Sends the event to the specific <model>[/versions/<ver>]
-        - <prefix>/operation
+        - `<prefix>/operation`
             Sends the event to all models and applies `vote(self, event)`
 
         The `VotingEnsemble` applies the following logic:
@@ -1243,7 +1254,7 @@ class EnrichmentVotingEnsemble(VotingEnsemble):
         The feature vector is specified using the `feature_vector_uri`, in addition an imputing policy
         can be specified to substitute None/NaN values with pre defines constant or stats.
 
-        * When enabling model tracking via `set_tracking()` the ensemble logic
+        When enabling model tracking via `set_tracking()` the ensemble logic
         predictions will appear with model name as the given VotingEnsemble name
         or "VotingEnsemble" by default.
 
@@ -1251,17 +1262,20 @@ class EnrichmentVotingEnsemble(VotingEnsemble):
 
             # Define a serving function
             # Note: You can point the function to a file containing you own Router or Classifier Model class
-            #       this basic class supports sklearn based models (with `<model>.predict()` api)
-            fn = mlrun.code_to_function(name='ensemble',
-                                        kind='serving',
-                                        filename='model-server.py'
-                                        image='mlrun/mlrun')
+            # this basic class supports sklearn based models (with `<model>.predict()` api)
+            fn = mlrun.code_to_function(
+                name='ensemble',
+                kind='serving',
+                filename='model-server.py',
+                image='mlrun/mlrun')
+
 
             # Set the router class
             # You can set your own classes by simply changing the `class_name`
-            fn.set_topology(class_name='mlrun.serving.routers.EnrichmentVotingEnsemble',
-                            feature_vector_uri="transactions-fraud",
-                            impute_policy={"*": "$mean"})
+            fn.set_topology(
+                class_name='mlrun.serving.routers.EnrichmentVotingEnsemble',
+                feature_vector_uri="transactions-fraud",
+                impute_policy={"*": "$mean"})
 
             # Add models
             fn.add_model(<model_name>, <model_path>, <model_class_name>)
@@ -1283,35 +1297,32 @@ class EnrichmentVotingEnsemble(VotingEnsemble):
         :param context:       for internal use (passed in init)
         :param name:          step name
         :param routes:        for internal use (routes passed in init)
-        :param protocol:      serving API protocol (default "v2")
-        :param url_prefix:    url prefix for the router (default /v2/models)
-        :param health_prefix: health api url prefix (default /v2/health)
-        :param feature_vector_uri :  feature vector uri in the form: [project/]name[:tag]
-        :param impute_policy : value imputing (substitute NaN/Inf values with statistical or constant value),
-                              you can set the `impute_policy` parameter with the imputing policy, and specify which
-                              constant or statistical value will be used instead of NaN/Inf value, this can be defined
-                              per column or for all the columns ("*").
-                              the replaced value can be fixed number for constants or $mean, $max, $min, $std, $count
-                              for statistical values. “*” is used to specify the default for all features, example:
-                              impute_policy={"*": "$mean", "age": 33}
-        :param input_path:    when specified selects the key/path in the event to use as body
-                              this require that the event body will behave like a dict, example:
-                              event: {"data": {"a": 5, "b": 7}}, input_path="data.b" means request body will be 7
-        :param result_path:   selects the key/path in the event to write the results to
-                              this require that the event body will behave like a dict, example:
-                              event: {"x": 5} , result_path="resp" means the returned response will be written
-                              to event["y"] resulting in {"x": 5, "resp": <result>}
-        :param vote_type:     Voting type to be used (from `VotingTypes`).
-                              by default will try to self-deduct upon the first event:
-                                - float prediction type: regression
-                                - int prediction type: classification
+        :param protocol:      serving API protocol (default `v2`)
+        :param url_prefix:    url prefix for the router (default `/v2/models`)
+        :param health_prefix: health api url prefix (default `/v2/health`)
+        :param feature_vector_uri:  feature vector uri in the form `[project/]name[:tag]`
+        :param impute_policy: value imputing (substitute NaN/Inf values with statistical or constant value),
+            you can set the `impute_policy` parameter with the imputing policy, and specify which constant or
+            statistical value will be used instead of NaN/Inf value, this can be defined per column or for all
+            the columns ("*"). The replaced value can be fixed number for constants or $mean, $max, $min, $std, $count
+            for statistical values. “*” is used to specify the default for all features,
+            example: impute_policy={"*": "$mean", "age": 33}
+        :param input_path:    when specified selects the key/path in the event to use as body this require that
+            the event body will behave like a dict, example: event: {"data": {"a": 5, "b": 7}}, input_path="data.b"
+            means request body will be 7.
+        :param result_path:   selects the key/path in the event to write the results to this require that the event body
+            will behave like a dict, example: event: {"x": 5} , result_path="resp" means the returned response will be
+            written to event["y"] resulting in {"x": 5, "resp": <result>}.
+        :param vote_type: Voting type to be used (from `VotingTypes`). by default will try to self-deduct upon the
+                    first event:
+                    * float prediction type: regression
+                    * int prediction type: classification
         :param executor_type: Parallelism mechanism, out of `ParallelRunnerModes`, by default `threads`
         :param prediction_col_name: The dict key for the predictions column in the model's responses output.
-                              Example: If the model returns
-                                       {id: <id>, model_name: <name>, outputs: {..., prediction: [<predictions>], ...}}
-                                       the prediction_col_name should be `prediction`.
-                              by default, `prediction`
-        :param kwargs:        extra arguments
+            Example:
+            If the model returns `{id: <id>, model_name: <name>, outputs: {..., prediction: [<predictions>], ...}}`,
+            the prediction_col_name should be `prediction`. By default, `prediction`.
+        :param kwargs:  extra arguments
         """
         super().__init__(
             context=context,
@@ -1342,7 +1353,9 @@ class EnrichmentVotingEnsemble(VotingEnsemble):
         )
 
     def preprocess(self, event):
-        """Turn an entity identifier (source) to a Feature Vector"""
+        """
+        Turn an entity identifier (source) to a Feature Vector
+        """
         if isinstance(event.body, (str, bytes)):
             event.body = json.loads(event.body)
         event.body["inputs"] = self._feature_service.get(

mlrun/serving/server.py

@@ -101,6 +101,9 @@ class GraphServer(ModelObj):
         tracking_policy=None,
         secret_sources=None,
         default_content_type=None,
+        function_name=None,
+        function_tag=None,
+        project=None,
     ):
         self._graph = None
         self.graph: Union[RouterStep, RootFlowStep] = graph
@@ -123,6 +126,9 @@ class GraphServer(ModelObj):
         self.resource_cache = None
         self.default_content_type = default_content_type
         self.http_trigger = True
+        self.function_name = function_name
+        self.function_tag = function_tag
+        self.project = project
 
     def set_current_function(self, function):
         """set which child function this server is currently running on"""

mlrun/serving/states.py

@@ -557,6 +557,8 @@ class TaskStep(BaseStep):
             self._object.post_init(mode)
             if hasattr(self._object, "model_endpoint_uid"):
                 self.endpoint_uid = self._object.model_endpoint_uid
+            if hasattr(self._object, "name"):
+                self.endpoint_name = self._object.name
 
     def respond(self):
         """mark this step as the responder.
@@ -1287,11 +1289,19 @@ class FlowStep(BaseStep):
         if self._controller:
             # async flow (using storey)
             event._awaitable_result = None
-            resp = self._controller.emit(
-                event, return_awaitable_result=self._wait_for_result
-            )
-            if self._wait_for_result and resp:
-                return resp.await_result()
+            if self.context.is_mock:
+                resp = self._controller.emit(
+                    event, return_awaitable_result=self._wait_for_result
+                )
+                if self._wait_for_result and resp:
+                    return resp.await_result()
+            else:
+                resp_awaitable = self._controller.emit(
+                    event, await_result=self._wait_for_result
+                )
+                if self._wait_for_result:
+                    return resp_awaitable
+                return self._await_and_return_id(resp_awaitable, event)
             event = copy(event)
             event.body = {"id": event.id}
             return event
@@ -1708,8 +1718,12 @@ def _init_async_objects(context, steps):
         is_explicit_ack_supported(context) and mlrun.mlconf.is_explicit_ack_enabled()
     )
 
-    # TODO: Change to AsyncEmitSource once we can drop support for nuclio<1.12.10
-    default_source = storey.SyncEmitSource(
+    if context.is_mock:
+        source_class = storey.SyncEmitSource
+    else:
+        source_class = storey.AsyncEmitSource
+
+    default_source = source_class(
         context=context,
         explicit_ack=explicit_ack,
         **source_args,