mlrun 1.3.3__py3-none-any.whl → 1.4.0__py3-none-any.whl

mlrun/runtimes/utils.py

@@ -1,4 +1,4 @@
-# Copyright 2018 Iguazio
+# 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.
@@ -24,17 +24,18 @@ import pandas as pd
 from kubernetes import client
 
 import mlrun
-import mlrun.builder
+import mlrun.api.utils.builder
+import mlrun.common.constants
+import mlrun.common.schemas
 import mlrun.utils.regex
 from mlrun.api.utils.clients import nuclio
-from mlrun.db import get_run_db
 from mlrun.errors import err_to_str
 from mlrun.frameworks.parallel_coordinates import gen_pcp_plot
-from mlrun.k8s_utils import get_k8s_helper
 from mlrun.runtimes.constants import MPIJobCRDVersions
 
 from ..artifacts import TableArtifact
-from ..config import config
+from ..config import config, is_running_as_api
+from ..k8s_utils import is_running_inside_kubernetes_cluster
 from ..utils import get_in, helpers, logger, verify_field_regex
 from .generators import selector
 
@@ -69,19 +70,21 @@ cached_nuclio_version = None
 # if not specified, try resolving it according to the mpi-operator, otherwise set to default
 # since this is a heavy operation (sending requests to k8s/API), and it's unlikely that the crd version
 # will change in any context - cache it
-def resolve_mpijob_crd_version(api_context=False):
+def resolve_mpijob_crd_version():
     global cached_mpijob_crd_version
     if not cached_mpijob_crd_version:
 
         # config override everything
+        # on client side, expecting it to get enriched from the API through the client-spec
         mpijob_crd_version = config.mpijob_crd_version
 
         if not mpijob_crd_version:
-            in_k8s_cluster = get_k8s_helper(
-                silent=True
-            ).is_running_inside_kubernetes_cluster()
-            if in_k8s_cluster:
-                k8s_helper = get_k8s_helper()
+            in_k8s_cluster = is_running_inside_kubernetes_cluster()
+
+            if in_k8s_cluster and is_running_as_api():
+                import mlrun.api.utils.singletons.k8s
+
+                k8s_helper = mlrun.api.utils.singletons.k8s.get_k8s_helper()
                 namespace = k8s_helper.resolve_namespace()
 
                 # try resolving according to mpi-operator that's running
@@ -93,13 +96,8 @@ def resolve_mpijob_crd_version(api_context=False):
                     mpijob_crd_version = mpi_operator_pod.metadata.labels.get(
                         "crd-version"
                     )
-            elif not in_k8s_cluster and not api_context:
-                # connect will populate the config from the server config
-                # TODO: something nicer
-                get_run_db()
-                mpijob_crd_version = config.mpijob_crd_version
 
-            # If resolution failed simply use default
+            # backoff to use default if wasn't resolved in API
             if not mpijob_crd_version:
                 mpijob_crd_version = MPIJobCRDVersions.default()
 
@@ -182,22 +180,6 @@ def log_std(db, runobj, out, err="", skip=False, show=True, silent=False):
             raise RunError(err)
 
 
-class AsyncLogWriter:
-    def __init__(self, db, runobj):
-        self.db = db
-        self.uid = runobj.metadata.uid
-        self.project = runobj.metadata.project or ""
-        self.iter = runobj.metadata.iteration
-
-    def write(self, data):
-        if self.db:
-            self.db.store_log(self.uid, self.project, data, append=True)
-
-    def flush(self):
-        # todo: verify writes are large enough, if not cache and use flush
-        pass
-
-
 def add_code_metadata(path=""):
     if path:
         if "://" in path:
@@ -227,8 +209,31 @@ def add_code_metadata(path=""):
         ]
         if len(remotes) > 0:
             return f"{remotes[0]}#{repo.head.commit.hexsha}"
-    except (GitCommandNotFound, InvalidGitRepositoryError, NoSuchPathError, ValueError):
-        pass
+
+    except (
+        GitCommandNotFound,
+        InvalidGitRepositoryError,
+        NoSuchPathError,
+        ValueError,
+    ) as exc:
+        logger.warning(
+            "Failed to add git metadata, ignore if path is not part of a git repo.",
+            path=path,
+            error=err_to_str(exc),
+        )
+    return None
+
+
+def get_k8s():
+    """
+    Get the k8s helper object
+    :return: k8s helper object or None if not running as API
+    """
+    if is_running_as_api():
+        import mlrun.api.utils.singletons.k8s
+
+        return mlrun.api.utils.singletons.k8s.get_k8s_helper()
+
     return None
 
 
@@ -348,7 +353,11 @@ def generate_function_image_name(project: str, name: str, tag: str) -> str:
     _, repository = helpers.get_parsed_docker_registry()
     repository = helpers.get_docker_repository_or_default(repository)
     return fill_function_image_name_template(
-        mlrun.builder.IMAGE_NAME_ENRICH_REGISTRY_PREFIX, repository, project, name, tag
+        mlrun.common.constants.IMAGE_NAME_ENRICH_REGISTRY_PREFIX,
+        repository,
+        project,
+        name,
+        tag,
     )
 
 
@@ -373,7 +382,7 @@ def resolve_function_target_image_registries_to_enforce_prefix():
     registry, repository = helpers.get_parsed_docker_registry()
     repository = helpers.get_docker_repository_or_default(repository)
     return [
-        f"{mlrun.builder.IMAGE_NAME_ENRICH_REGISTRY_PREFIX}{repository}/",
+        f"{mlrun.common.constants.IMAGE_NAME_ENRICH_REGISTRY_PREFIX}{repository}/",
         f"{registry}/{repository}/",
     ]
 
@@ -476,20 +485,26 @@ def verify_limits(
         verify_field_regex(
             f"function.spec.{resources_field_name}.limits.memory",
             mem,
-            mlrun.utils.regex.k8s_resource_quantity_regex,
+            mlrun.utils.regex.k8s_resource_quantity_regex
+            + mlrun.utils.regex.pipeline_param,
+            mode=mlrun.common.schemas.RegexMatchModes.any,
         )
     if cpu:
         verify_field_regex(
             f"function.spec.{resources_field_name}.limits.cpu",
             cpu,
-            mlrun.utils.regex.k8s_resource_quantity_regex,
+            mlrun.utils.regex.k8s_resource_quantity_regex
+            + mlrun.utils.regex.pipeline_param,
+            mode=mlrun.common.schemas.RegexMatchModes.any,
         )
     # https://kubernetes.io/docs/tasks/manage-gpus/scheduling-gpus/
     if gpus:
         verify_field_regex(
             f"function.spec.{resources_field_name}.limits.gpus",
             gpus,
-            mlrun.utils.regex.k8s_resource_quantity_regex,
+            mlrun.utils.regex.k8s_resource_quantity_regex
+            + mlrun.utils.regex.pipeline_param,
+            mode=mlrun.common.schemas.RegexMatchModes.any,
         )
     return generate_resources(mem=mem, cpu=cpu, gpus=gpus, gpu_type=gpu_type)
 
@@ -503,13 +518,17 @@ def verify_requests(
         verify_field_regex(
             f"function.spec.{resources_field_name}.requests.memory",
             mem,
-            mlrun.utils.regex.k8s_resource_quantity_regex,
+            mlrun.utils.regex.k8s_resource_quantity_regex
+            + mlrun.utils.regex.pipeline_param,
+            mode=mlrun.common.schemas.RegexMatchModes.any,
         )
     if cpu:
         verify_field_regex(
             f"function.spec.{resources_field_name}.requests.cpu",
             cpu,
-            mlrun.utils.regex.k8s_resource_quantity_regex,
+            mlrun.utils.regex.k8s_resource_quantity_regex
+            + mlrun.utils.regex.pipeline_param,
+            mode=mlrun.common.schemas.RegexMatchModes.any,
         )
     return generate_resources(mem=mem, cpu=cpu)
 

mlrun/secrets.py

@@ -1,4 +1,4 @@
-# Copyright 2018 Iguazio
+# 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.
@@ -16,7 +16,7 @@ from ast import literal_eval
 from os import environ, getenv
 from typing import Callable, Dict, Optional, Union
 
-from .utils import AzureVaultStore, VaultStore, list2dict
+from .utils import AzureVaultStore, list2dict
 
 
 class SecretsStore:
@@ -26,7 +26,6 @@ class SecretsStore:
         # for example from Vault, and when adding their source they will be retrieved from the external source.
         self._hidden_sources = []
         self._hidden_secrets = {}
-        self.vault = VaultStore()
 
     @classmethod
     def from_list(cls, src_list: list):
@@ -60,21 +59,20 @@ class SecretsStore:
             for key in source.split(","):
                 k = key.strip()
                 self._secrets[prefix + k] = environ.get(k)
-
-        elif kind == "vault":
-            if isinstance(source, str):
-                source = literal_eval(source)
-            if not isinstance(source, dict):
-                raise ValueError("vault secrets must be of type dict")
-
-            for key, value in self.vault.get_secrets(
-                source["secrets"],
-                user=source.get("user"),
-                project=source.get("project"),
-            ).items():
-                self._hidden_secrets[prefix + key] = value
-            self._hidden_sources.append({"kind": kind, "source": source})
-
+        # TODO: Vault: uncomment when vault returns to be relevant
+        # elif kind == "vault":
+        #     if isinstance(source, str):
+        #         source = literal_eval(source)
+        #     if not isinstance(source, dict):
+        #         raise ValueError("vault secrets must be of type dict")
+        #
+        #     for key, value in self.vault.get_secrets(
+        #         source["secrets"],
+        #         user=source.get("user"),
+        #         project=source.get("project"),
+        #     ).items():
+        #         self._hidden_secrets[prefix + key] = value
+        #     self._hidden_sources.append({"kind": kind, "source": source})
         elif kind == "azure_vault":
             if isinstance(source, str):
                 source = literal_eval(source)

mlrun/serving/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2018 Iguazio
+# 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.
@@ -21,10 +21,11 @@ __all__ = [
     "TaskStep",
     "RouterStep",
     "QueueStep",
+    "ErrorStep",
 ]
 
 from .routers import ModelRouter, VotingEnsemble  # noqa
 from .server import GraphContext, GraphServer, create_graph_server  # noqa
-from .states import QueueStep, RouterStep, TaskStep  # noqa
+from .states import ErrorStep, QueueStep, RouterStep, TaskStep  # noqa
 from .v1_serving import MLModelServer, new_v1_model_server  # noqa
 from .v2_serving import V2ModelServer  # noqa

mlrun/serving/merger.py

@@ -1,4 +1,4 @@
-# Copyright 2018 Iguazio
+# 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.

mlrun/serving/remote.py

@@ -1,4 +1,4 @@
-# Copyright 2018 Iguazio
+# 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.

mlrun/serving/routers.py

@@ -1,4 +1,4 @@
-# Copyright 2018 Iguazio
+# 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.
@@ -24,18 +24,12 @@ import numpy
 import numpy as np
 
 import mlrun
+import mlrun.common.model_monitoring
+import mlrun.common.schemas
 import mlrun.utils.model_monitoring
 from mlrun.utils import logger, now_date, parse_versioned_object_uri
 
-from ..api.schemas import (
-    ModelEndpoint,
-    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
@@ -402,12 +396,14 @@ 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, id(self)),
+                    initargs=(server, routes),
                 )
             elif self.executor_type == ParallelRunnerModes.thread:
                 executor_class = concurrent.futures.ThreadPoolExecutor
@@ -422,7 +418,7 @@ class ParallelRun(BaseModelRouter):
         if self._pool is not None:
             if self.executor_type == ParallelRunnerModes.process:
                 global local_routes
-                local_routes.pop(id(self))
+                del local_routes
             self._pool.shutdown()
             self._pool = None
 
@@ -446,7 +442,7 @@ class ParallelRun(BaseModelRouter):
         for route in self.routes.keys():
             if self.executor_type == ParallelRunnerModes.process:
                 future = executor.submit(
-                    ParallelRun._wrap_step, route, id(self), copy.copy(event)
+                    ParallelRun._wrap_step, route, copy.copy(event)
                 )
             elif self.executor_type == ParallelRunnerModes.thread:
                 step = self.routes[route]
@@ -470,25 +466,22 @@ class ParallelRun(BaseModelRouter):
         return results
 
     @staticmethod
-    def init_pool(server_spec, routes, object_id):
+    def init_pool(server_spec, routes):
         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[object_id] = routes
+        local_routes = routes
 
     @staticmethod
-    def _wrap_step(route, object_id, event):
+    def _wrap_step(route, event):
         global local_routes
-        routes = local_routes.get(object_id, None).copy()
-        if routes is None:
+        if local_routes is None:
             return None, None
-        return route, routes[route].run(event)
+        return route, local_routes[route].run(event)
 
     @staticmethod
     def _wrap_method(route, handler, event):
@@ -1043,7 +1036,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.utils.model_monitoring.create_model_endpoint_id(
+    endpoint_uid = mlrun.common.model_monitoring.create_model_endpoint_uid(
         function_uri=graph_server.function_uri, versioned_model=versioned_model_name
     ).uid
 
@@ -1061,33 +1054,35 @@ 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"
-                        ),
-                        active=True,
-                        monitoring_mode=ModelMonitoringMode.enabled
-                        if voting_ensemble.context.server.track_models
-                        else ModelMonitoringMode.disabled,
-                    ),
-                    status=ModelEndpointStatus(
-                        children=list(voting_ensemble.routes.keys()),
-                        endpoint_type=EndpointType.ROUTER,
-                        children_uids=children_uids,
+            model_endpoint = mlrun.common.schemas.ModelEndpoint(
+                metadata=mlrun.common.schemas.ModelEndpointMetadata(
+                    project=project, uid=endpoint_uid
+                ),
+                spec=mlrun.common.schemas.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=mlrun.common.model_monitoring.ModelMonitoringMode.enabled
+                    if voting_ensemble.context.server.track_models
+                    else mlrun.common.model_monitoring.ModelMonitoringMode.disabled,
+                ),
+                status=mlrun.common.schemas.ModelEndpointStatus(
+                    children=list(voting_ensemble.routes.keys()),
+                    endpoint_type=mlrun.common.model_monitoring.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,
+                model_endpoint=model_endpoint.dict(),
             )
 
             # Update model endpoint children type
@@ -1095,7 +1090,9 @@ def _init_endpoint_record(
                 current_endpoint = db.get_model_endpoint(
                     project=project, endpoint_id=model_endpoint
                 )
-                current_endpoint.status.endpoint_type = EndpointType.LEAF_EP
+                current_endpoint.status.endpoint_type = (
+                    mlrun.common.model_monitoring.EndpointType.LEAF_EP
+                )
                 db.create_model_endpoint(
                     project=project,
                     endpoint_id=model_endpoint,

mlrun/serving/server.py

@@ -1,4 +1,4 @@
-# Copyright 2018 Iguazio
+# 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.
@@ -18,12 +18,13 @@ 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.common.model_monitoring import FileTargetKind
 from mlrun.config import config
 from mlrun.errors import err_to_str
 from mlrun.secrets import SecretsStore
@@ -32,7 +33,7 @@ from ..datastore import get_stream_pusher
 from ..datastore.store_resources import ResourceCache
 from ..errors import MLRunInvalidArgumentError
 from ..model import ModelObj
-from ..utils import create_logger, get_caller_globals, parse_versioned_object_uri
+from ..utils import get_caller_globals, parse_versioned_object_uri
 from .states import RootFlowStep, RouterStep, get_function, graph_root_setter
 from .utils import (
     event_id_key,
@@ -43,32 +44,41 @@ from .utils import (
 
 
 class _StreamContext:
-    def __init__(self, enabled, parameters, function_uri):
+    """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>
+        """
+
         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, "")
 
-        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:
+        if (enabled or log_stream) and function_uri:
             self.enabled = True
-
             project, _, _, _ = parse_versioned_object_uri(
                 function_uri, config.default_project
             )
 
-            stream_uri = stream_uri.format(project=project, kind="stream")
+            stream_uri = mlrun.utils.model_monitoring.get_stream_path(project=project)
 
             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)
 
 
@@ -458,7 +468,7 @@ class GraphContext:
             self.Response = nuclio_context.Response
             self.worker_id = nuclio_context.worker_id
         elif not logger:
-            self.logger = create_logger(level, "human", "flow", sys.stdout)
+            self.logger = mlrun.utils.helpers.logger
 
         self._server = server
         self.current_function = None

mlrun/serving/serving_wrapper.py

@@ -1,4 +1,4 @@
-# Copyright 2018 Iguazio
+# 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.