mlrun 1.3.2rc1__py3-none-any.whl → 1.3.2rc2__py3-none-any.whl

mlrun/serving/routers.py

@@ -24,7 +24,6 @@ import numpy
 import numpy as np
 
 import mlrun
-import mlrun.model_monitoring
 import mlrun.utils.model_monitoring
 from mlrun.utils import logger, now_date, parse_versioned_object_uri
 
@@ -33,8 +32,10 @@ from ..api.schemas import (
     ModelEndpointMetadata,
     ModelEndpointSpec,
     ModelEndpointStatus,
+    ModelMonitoringMode,
 )
 from ..config import config
+from ..utils.model_monitoring import EndpointType
 from .server import GraphServer
 from .utils import RouterToDict, _extract_input_data, _update_result_body
 from .v2_serving import _ModelLogPusher
@@ -401,14 +402,12 @@ class ParallelRun(BaseModelRouter):
                     step._parent = None
                     if step._object:
                         step._object.context = None
-                        if hasattr(step._object, "_kwargs"):
-                            step._object._kwargs["graph_step"] = None
                     routes[key] = step
                 executor_class = concurrent.futures.ProcessPoolExecutor
                 self._pool = executor_class(
                     max_workers=len(self.routes),
                     initializer=ParallelRun.init_pool,
-                    initargs=(server, routes),
+                    initargs=(server, routes, id(self)),
                 )
             elif self.executor_type == ParallelRunnerModes.thread:
                 executor_class = concurrent.futures.ThreadPoolExecutor
@@ -423,7 +422,7 @@ class ParallelRun(BaseModelRouter):
         if self._pool is not None:
             if self.executor_type == ParallelRunnerModes.process:
                 global local_routes
-                del local_routes
+                local_routes.pop(id(self))
             self._pool.shutdown()
             self._pool = None
 
@@ -447,7 +446,7 @@ class ParallelRun(BaseModelRouter):
         for route in self.routes.keys():
             if self.executor_type == ParallelRunnerModes.process:
                 future = executor.submit(
-                    ParallelRun._wrap_step, route, copy.copy(event)
+                    ParallelRun._wrap_step, route, id(self), copy.copy(event)
                 )
             elif self.executor_type == ParallelRunnerModes.thread:
                 step = self.routes[route]
@@ -471,22 +470,25 @@ class ParallelRun(BaseModelRouter):
         return results
 
     @staticmethod
-    def init_pool(server_spec, routes):
+    def init_pool(server_spec, routes, object_id):
         server = mlrun.serving.GraphServer.from_dict(server_spec)
         server.init_states(None, None)
         global local_routes
+        if object_id in local_routes:
+            return
         for route in routes.values():
             route.context = server.context
             if route._object:
                 route._object.context = server.context
-        local_routes = routes
+        local_routes[object_id] = routes
 
     @staticmethod
-    def _wrap_step(route, event):
+    def _wrap_step(route, object_id, event):
         global local_routes
-        if local_routes is None:
+        routes = local_routes.get(object_id, None).copy()
+        if routes is None:
             return None, None
-        return route, local_routes[route].run(event)
+        return route, routes[route].run(event)
 
     @staticmethod
     def _wrap_method(route, handler, event):
@@ -1041,7 +1043,7 @@ def _init_endpoint_record(
         versioned_model_name = f"{voting_ensemble.name}:latest"
 
     # Generating model endpoint ID based on function uri and model version
-    endpoint_uid = mlrun.model_monitoring.create_model_endpoint_uid(
+    endpoint_uid = mlrun.utils.model_monitoring.create_model_endpoint_id(
         function_uri=graph_server.function_uri, versioned_model=versioned_model_name
     ).uid
 
@@ -1059,33 +1061,33 @@ def _init_endpoint_record(
                 if hasattr(c, "endpoint_uid"):
                     children_uids.append(c.endpoint_uid)
 
-            model_endpoint = ModelEndpoint(
-                metadata=ModelEndpointMetadata(project=project, uid=endpoint_uid),
-                spec=ModelEndpointSpec(
-                    function_uri=graph_server.function_uri,
-                    model=versioned_model_name,
-                    model_class=voting_ensemble.__class__.__name__,
-                    stream_path=config.model_endpoint_monitoring.store_prefixes.default.format(
-                        project=project, kind="stream"
+                model_endpoint = ModelEndpoint(
+                    metadata=ModelEndpointMetadata(project=project, uid=endpoint_uid),
+                    spec=ModelEndpointSpec(
+                        function_uri=graph_server.function_uri,
+                        model=versioned_model_name,
+                        model_class=voting_ensemble.__class__.__name__,
+                        stream_path=config.model_endpoint_monitoring.store_prefixes.default.format(
+                            project=project, kind="stream"
+                        ),
+                        active=True,
+                        monitoring_mode=ModelMonitoringMode.enabled
+                        if voting_ensemble.context.server.track_models
+                        else ModelMonitoringMode.disabled,
                     ),
-                    active=True,
-                    monitoring_mode=mlrun.model_monitoring.ModelMonitoringMode.enabled
-                    if voting_ensemble.context.server.track_models
-                    else mlrun.model_monitoring.ModelMonitoringMode.disabled,
-                ),
-                status=ModelEndpointStatus(
-                    children=list(voting_ensemble.routes.keys()),
-                    endpoint_type=mlrun.model_monitoring.EndpointType.ROUTER,
-                    children_uids=children_uids,
-                ),
-            )
+                    status=ModelEndpointStatus(
+                        children=list(voting_ensemble.routes.keys()),
+                        endpoint_type=EndpointType.ROUTER,
+                        children_uids=children_uids,
+                    ),
+                )
 
             db = mlrun.get_run_db()
 
             db.create_model_endpoint(
                 project=project,
                 endpoint_id=model_endpoint.metadata.uid,
-                model_endpoint=model_endpoint.dict(),
+                model_endpoint=model_endpoint,
             )
 
             # Update model endpoint children type
@@ -1093,9 +1095,7 @@ def _init_endpoint_record(
                 current_endpoint = db.get_model_endpoint(
                     project=project, endpoint_id=model_endpoint
                 )
-                current_endpoint.status.endpoint_type = (
-                    mlrun.model_monitoring.EndpointType.LEAF_EP
-                )
+                current_endpoint.status.endpoint_type = EndpointType.LEAF_EP
                 db.create_model_endpoint(
                     project=project,
                     endpoint_id=model_endpoint,

mlrun/serving/server.py

@@ -18,22 +18,21 @@ import asyncio
 import json
 import os
 import socket
+import sys
 import traceback
 import uuid
 from typing import Optional, Union
 
 import mlrun
-import mlrun.utils.model_monitoring
 from mlrun.config import config
 from mlrun.errors import err_to_str
-from mlrun.model_monitoring import FileTargetKind
 from mlrun.secrets import SecretsStore
 
 from ..datastore import get_stream_pusher
 from ..datastore.store_resources import ResourceCache
 from ..errors import MLRunInvalidArgumentError
 from ..model import ModelObj
-from ..utils import get_caller_globals, parse_versioned_object_uri
+from ..utils import create_logger, get_caller_globals, parse_versioned_object_uri
 from .states import RootFlowStep, RouterStep, get_function, graph_root_setter
 from .utils import (
     event_id_key,
@@ -44,41 +43,32 @@ from .utils import (
 
 
 class _StreamContext:
-    """Handles the stream context for the events stream process. Includes the configuration for the output stream
-    that will be used for pushing the events from the nuclio model serving function"""
-
-    def __init__(self, enabled: bool, parameters: dict, function_uri: str):
-
-        """
-        Initialize _StreamContext object.
-        :param enabled:      A boolean indication for applying the stream context
-        :param parameters:   Dictionary of optional parameters, such as `log_stream` and `stream_args`. Note that these
-                             parameters might be relevant to the output source such as `kafka_bootstrap_servers` if
-                             the output source is from type Kafka.
-        :param function_uri: Full value of the function uri, usually it's <project-name>/<function-name>
-        """
-
+    def __init__(self, enabled, parameters, function_uri):
         self.enabled = False
         self.hostname = socket.gethostname()
         self.function_uri = function_uri
         self.output_stream = None
         self.stream_uri = None
-        log_stream = parameters.get(FileTargetKind.LOG_STREAM, "")
 
-        if (enabled or log_stream) and function_uri:
+        log_stream = parameters.get("log_stream", "")
+        stream_uri = config.model_endpoint_monitoring.store_prefixes.default
+
+        if ((enabled and stream_uri) or log_stream) and function_uri:
             self.enabled = True
+
             project, _, _, _ = parse_versioned_object_uri(
                 function_uri, config.default_project
             )
 
-            stream_uri = mlrun.utils.model_monitoring.get_stream_path(project=project)
+            stream_uri = stream_uri.format(project=project, kind="stream")
 
             if log_stream:
-                # Update the stream path to the log stream value
                 stream_uri = log_stream.format(project=project)
 
             stream_args = parameters.get("stream_args", {})
 
+            self.stream_uri = stream_uri
+
             self.output_stream = get_stream_pusher(stream_uri, **stream_args)
 
 
@@ -468,7 +458,7 @@ class GraphContext:
             self.Response = nuclio_context.Response
             self.worker_id = nuclio_context.worker_id
         elif not logger:
-            self.logger = mlrun.utils.helpers.logger
+            self.logger = create_logger(level, "human", "flow", sys.stdout)
 
         self._server = server
         self.current_function = None

mlrun/serving/states.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__all__ = ["TaskStep", "RouterStep", "RootFlowStep", "ErrorStep"]
+__all__ = ["TaskStep", "RouterStep", "RootFlowStep"]
 
 import os
 import pathlib
@@ -49,7 +49,6 @@ class StepKinds:
     queue = "queue"
     choice = "choice"
     root = "root"
-    error_step = "error_step"
 
 
 _task_step_fields = [
@@ -135,82 +134,11 @@ class BaseStep(ModelObj):
                 self.after.append(name)
         return self
 
-    def error_handler(
-        self,
-        name: str = None,
-        class_name=None,
-        handler=None,
-        before=None,
-        function=None,
-        full_event: bool = None,
-        input_path: str = None,
-        result_path: str = None,
-        **class_args,
-    ):
-        """set error handler on a step or the entire graph (to be executed on failure/raise)
-
-        When setting the error_handler on the graph object, the graph completes after the error handler execution.
-
-        example:
-            in the below example, an 'error_catcher' step is set as the error_handler of the 'raise' step:
-            in case of error/raise in 'raise' step, the handle_error will be run. after that,
-            the 'echo' step will be run.
-            graph = function.set_topology('flow', engine='async')
-            graph.to(name='raise', handler='raising_step')\
-                .error_handler(name='error_catcher', handler='handle_error', full_event=True, before='echo')
-            graph.add_step(name="echo", handler='echo', after="raise").respond()
-
-        :param name:        unique name (and path) for the error handler step, default is class name
-        :param class_name:  class name or step object to build the step from
-                            the error handler step is derived from task step (ie no router/queue functionally)
-        :param handler:     class/function handler to invoke on run/event
-        :param before:      string or list of next step(s) names that will run after this step.
-                            the `before` param must not specify upstream steps as it will cause a loop.
-                            if `before` is not specified, the graph will complete after the error handler execution.
-        :param function:    function this step should run in
-        :param full_event:  this step accepts the full event (not just the body)
-        :param input_path:  selects the key/path in the event to use as input to the step
-                            this requires that the event body will behave like a dict, for example:
-                            event: {"data": {"a": 5, "b": 7}}, input_path="data.b" means the step will
-                            receive 7 as input
-        :param result_path: selects the key/path in the event to write the results to
-                            this requires that the event body will behave like a dict, for example:
-                            event: {"x": 5} , result_path="y" means the output of the step will be written
-                            to event["y"] resulting in {"x": 5, "y": <result>}
-        :param class_args:  class init arguments
-
-        """
-        if not (class_name or handler):
-            raise MLRunInvalidArgumentError("class_name or handler must be provided")
-        if isinstance(self, RootFlowStep) and before:
-            raise MLRunInvalidArgumentError(
-                "`before` arg can't be specified for graph error handler"
-            )
-
-        name = get_name(name, class_name)
-        step = ErrorStep(
-            class_name,
-            class_args,
-            handler,
-            name=name,
-            function=function,
-            full_event=full_event,
-            input_path=input_path,
-            result_path=result_path,
-        )
-        self.on_error = name
-        before = [before] if isinstance(before, str) else before
-        step.before = before or []
-        step.base_step = self.name
-        if hasattr(self, "_parent") and self._parent:
-            # when self is a step
-            step = self._parent._steps.update(name, step)
-            step.set_parent(self._parent)
-        else:
-            # when self is the graph
-            step = self._steps.update(name, step)
-            step.set_parent(self)
-
+    def error_handler(self, step_name: str = None):
+        """set error handler step (on failure/raise of this step)"""
+        if not step_name:
+            raise MLRunInvalidArgumentError("Must specify step_name")
+        self.on_error = step_name
         return self
 
     def init_object(self, context, namespace, mode="sync", reset=False, **extra_kwargs):
@@ -258,11 +186,10 @@ class BaseStep(ModelObj):
 
     def _call_error_handler(self, event, err, **kwargs):
         """call the error handler if exist"""
-        if not event.error:
-            event.error = {}
-        event.error[self.name] = err_to_str(err)
-        event.origin_state = self.fullname
-        return self._on_error_handler(event)
+        if self._on_error_handler:
+            event.error = err_to_str(err)
+            event.origin_state = self.fullname
+            return self._on_error_handler(event)
 
     def path_to_step(self, path: str):
         """return step object from step relative/fullname"""
@@ -400,7 +327,6 @@ class TaskStep(BaseStep):
             args = signature(self._handler).parameters
             if args and "context" in list(args.keys()):
                 self._inject_context = True
-            self._set_error_handler()
             return
 
         self._class_object, self.class_name = self.get_step_class_object(
@@ -538,23 +464,14 @@ class TaskStep(BaseStep):
             )
             event.body = _update_result_body(self.result_path, event.body, result)
         except Exception as exc:
-            if self._on_error_handler:
-                self._log_error(event, exc)
-                result = self._call_error_handler(event, exc)
-                event.body = _update_result_body(self.result_path, event.body, result)
-            else:
+            self._log_error(event, exc)
+            handled = self._call_error_handler(event, exc)
+            if not handled:
                 raise exc
+            event.terminated = True
         return event
 
 
-class ErrorStep(TaskStep):
-    """error execution step, runs a class or handler"""
-
-    kind = "error_step"
-    _dict_fields = _task_step_fields + ["before", "base_step"]
-    _default_class = ""
-
-
 class RouterStep(TaskStep):
     """router step, implement routing logic for running child routes"""
 
@@ -907,7 +824,6 @@ class FlowStep(BaseStep):
     def init_object(self, context, namespace, mode="sync", reset=False, **extra_kwargs):
         """initialize graph objects and classes"""
         self.context = context
-        self._insert_all_error_handlers()
         self.check_and_process_graph()
 
         for step in self._steps.values():
@@ -950,11 +866,7 @@ class FlowStep(BaseStep):
 
         responders = []
         for step in self._steps.values():
-            if (
-                hasattr(step, "responder")
-                and step.responder
-                and step.kind != "error_step"
-            ):
+            if hasattr(step, "responder") and step.responder:
                 responders.append(step.name)
             if step.on_error and step.on_error in start_steps:
                 start_steps.remove(step.on_error)
@@ -1067,10 +979,6 @@ class FlowStep(BaseStep):
                 # never set a step as its own error handler
                 if step != error_step:
                     step.async_object.set_recovery_step(error_step.async_object)
-                    for next_step in error_step.next or []:
-                        next_state = self[next_step]
-                        if next_state.async_object and error_step.async_object:
-                            error_step.async_object.to(next_state.async_object)
 
         self._controller = source.run()
 
@@ -1151,22 +1059,15 @@ class FlowStep(BaseStep):
             try:
                 event = next_obj.run(event, *args, **kwargs)
             except Exception as exc:
-                if self._on_error_handler:
-                    self._log_error(event, exc, failed_step=next_obj.name)
-                    event.body = self._call_error_handler(event, exc)
-                    event.terminated = True
-                    return event
-                else:
+                self._log_error(event, exc, failed_step=next_obj.name)
+                handled = self._call_error_handler(event, exc)
+                if not handled:
                     raise exc
+                event.terminated = True
+                return event
 
             if hasattr(event, "terminated") and event.terminated:
                 return event
-            if (
-                hasattr(event, "error")
-                and isinstance(event.error, dict)
-                and next_obj.name in event.error
-            ):
-                next_obj = self._steps[next_obj.on_error]
             next = next_obj.next
             if next and len(next) > 1:
                 raise GraphError(
@@ -1202,33 +1103,6 @@ class FlowStep(BaseStep):
             **kw,
         )
 
-    def _insert_all_error_handlers(self):
-        """
-        insert all error steps to the graph
-        run after deployment
-        """
-        for name, step in self._steps.items():
-            if step.kind == "error_step":
-                self._insert_error_step(name, step)
-
-    def _insert_error_step(self, name, step):
-        """
-        insert error step to the graph
-        run after deployment
-        """
-        if not step.before and not any(
-            [step.name in other_step.after for other_step in self._steps.values()]
-        ):
-            step.responder = True
-            return
-
-        for step_name in step.before:
-            if step_name not in self._steps.keys():
-                raise MLRunInvalidArgumentError(
-                    f"cant set before, there is no step named {step_name}"
-                )
-            self[step_name].after_step(name)
-
 
 class RootFlowStep(FlowStep):
     """root flow step"""
@@ -1242,7 +1116,6 @@ classes_map = {
     "router": RouterStep,
     "flow": FlowStep,
     "queue": QueueStep,
-    "error_step": ErrorStep,
 }
 
 
@@ -1282,8 +1155,15 @@ def _add_graphviz_flow(
                 _add_graphviz_router(sg, child)
         else:
             graph.node(child.fullname, label=child.name, shape=child.get_shape())
-        _add_edges(child.after or [], step, graph, child)
-        _add_edges(getattr(child, "before", []), step, graph, child, after=False)
+        after = child.after or []
+        for item in after:
+            previous_object = step[item]
+            kw = (
+                {"ltail": "cluster_" + previous_object.fullname}
+                if previous_object.kind == StepKinds.router
+                else {}
+            )
+            graph.edge(previous_object.fullname, child.fullname, **kw)
         if child.on_error:
             graph.edge(child.fullname, child.on_error, style="dashed")
 
@@ -1303,18 +1183,6 @@ def _add_graphviz_flow(
                 graph.edge(last_step, target.fullname)
 
 
-def _add_edges(items, step, graph, child, after=True):
-    for item in items:
-        next_or_prev_object = step[item]
-        kw = {}
-        if next_or_prev_object.kind == StepKinds.router:
-            kw["ltail"] = f"cluster_{next_or_prev_object.fullname}"
-        if after:
-            graph.edge(next_or_prev_object.fullname, child.fullname, **kw)
-        else:
-            graph.edge(child.fullname, next_or_prev_object.fullname, **kw)
-
-
 def _generate_graphviz(
     step,
     renderer,
@@ -1487,7 +1355,7 @@ def _init_async_objects(context, steps):
                             endpoint, stream_path = parse_path(step.path)
                             stream_path = stream_path.strip("/")
                         step._async_object = storey.StreamTarget(
-                            storey.V3ioDriver(endpoint or config.v3io_api),
+                            storey.V3ioDriver(endpoint),
                             stream_path,
                             context=context,
                             **options,

mlrun/serving/v2_serving.py

@@ -17,16 +17,17 @@ import traceback
 from typing import Dict, Union
 
 import mlrun
-import mlrun.model_monitoring
 from mlrun.api.schemas import (
     ModelEndpoint,
     ModelEndpointMetadata,
     ModelEndpointSpec,
     ModelEndpointStatus,
+    ModelMonitoringMode,
 )
 from mlrun.artifacts import ModelArtifact  # noqa: F401
 from mlrun.config import config
 from mlrun.utils import logger, now_date, parse_versioned_object_uri
+from mlrun.utils.model_monitoring import EndpointType
 
 from .server import GraphServer
 from .utils import StepToDict, _extract_input_data, _update_result_body
@@ -403,12 +404,11 @@ class _ModelLogPusher:
         return base_data
 
     def push(self, start, request, resp=None, op=None, error=None):
-        start_str = start.isoformat(sep=" ", timespec="microseconds")
         if error:
             data = self.base_data()
             data["request"] = request
             data["op"] = op
-            data["when"] = start_str
+            data["when"] = str(start)
             message = str(error)
             if self.verbose:
                 message = f"{message}\n{traceback.format_exc()}"
@@ -445,7 +445,7 @@ class _ModelLogPusher:
                 data["request"] = request
                 data["op"] = op
                 data["resp"] = resp
-                data["when"] = start_str
+                data["when"] = str(start)
                 data["microsec"] = microsec
                 if getattr(self.model, "metrics", None):
                     data["metrics"] = self.model.metrics
@@ -486,7 +486,7 @@ def _init_endpoint_record(
         versioned_model_name = f"{model.name}:latest"
 
     # Generating model endpoint ID based on function uri and model version
-    uid = mlrun.model_monitoring.create_model_endpoint_uid(
+    uid = mlrun.utils.model_monitoring.create_model_endpoint_id(
         function_uri=graph_server.function_uri, versioned_model=versioned_model_name
     ).uid
 
@@ -511,21 +511,18 @@ def _init_endpoint_record(
                         project=project, kind="stream"
                     ),
                     active=True,
-                    monitoring_mode=mlrun.model_monitoring.ModelMonitoringMode.enabled
+                    monitoring_mode=ModelMonitoringMode.enabled
                     if model.context.server.track_models
-                    else mlrun.model_monitoring.ModelMonitoringMode.disabled,
-                ),
-                status=ModelEndpointStatus(
-                    endpoint_type=mlrun.model_monitoring.EndpointType.NODE_EP
+                    else ModelMonitoringMode.disabled,
                 ),
+                status=ModelEndpointStatus(endpoint_type=EndpointType.NODE_EP),
             )
 
             db = mlrun.get_run_db()
-
             db.create_model_endpoint(
                 project=project,
-                endpoint_id=uid,
-                model_endpoint=model_endpoint.dict(),
+                endpoint_id=model_endpoint.metadata.uid,
+                model_endpoint=model_endpoint,
             )
 
         except Exception as e:

mlrun/utils/clones.py

@@ -51,7 +51,7 @@ def get_git_username_password_from_token(token):
     # Github's access tokens have a known prefix according to their type. See
     # https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/about-authentication-to-github#githubs-token-formats
     # We distinguish new fine-grained access tokens (begin with "github_pat_" from classic tokens.
-    if token.startswith("github_pat_") or token.startswith("glpat"):
+    if token.startswith("github_pat_"):
         username = "oauth2"
         password = token
     else: