mlrun 1.4.0rc25__py3-none-any.whl → 1.5.0rc2__py3-none-any.whl

mlrun/runtimes/nuclio.py

@@ -16,7 +16,8 @@ import json
 import os
 import socket
 
-from ..db import get_or_set_dburl
+import mlrun.db
+
 from ..errors import err_to_str
 from ..execution import MLClientCtx
 from ..model import RunTemplate
@@ -60,7 +61,7 @@ def nuclio_jobs_handler(context, event):
             status_code=400,
         )
 
-    out = get_or_set_dburl()
+    out = mlrun.db.get_or_set_dburl()
     if out:
         context.logger.info(f"logging run results to: {out}")
 

mlrun/runtimes/pod.py

@@ -20,7 +20,6 @@ from enum import Enum
 import dotenv
 import kfp.dsl
 import kubernetes.client as k8s_client
-from deprecated import deprecated
 
 import mlrun.errors
 import mlrun.utils.regex
@@ -360,15 +359,25 @@ class KubeResourceSpec(FunctionSpec):
         patch: bool = False,
     ):
         """
-        set pod cpu/memory/gpu limits
-        by default it overrides the whole limits section, if you wish to patch specific resources use `patch=True`.
+        Set pod cpu/memory/gpu limits (max values)
+
+        :param mem:     set limit for memory e.g. '500M', '2G', etc.
+        :param cpu:     set limit for cpu e.g. '0.5', '2', etc.
+        :param gpus:    set limit for gpu
+        :param gpu_type:    set gpu type e.g. "nvidia.com/gpu"
+        :param patch:    by default it overrides the whole limits section,
+                        if you wish to patch specific resources use `patch=True`
         """
         self._verify_and_set_limits("resources", mem, cpu, gpus, gpu_type, patch=patch)
 
     def with_requests(self, mem: str = None, cpu: str = None, patch: bool = False):
         """
-        set requested (desired) pod cpu/memory resources
-        by default it overrides the whole requests section, if you wish to patch specific resources use `patch=True`.
+        Set requested (desired) pod cpu/memory resources
+
+        :param mem:     set request for memory e.g. '200M', '1G', etc.
+        :param cpu:     set request for cpu e.g. '0.1', '1', etc.
+        :param patch:   by default it overrides the whole requests section,
+                        if you wish to patch specific resources use `patch=True`
         """
         self._verify_and_set_requests("resources", mem, cpu, patch)
 
@@ -1004,15 +1013,6 @@ class KubeResource(BaseRuntime):
             self.set_env(name, value)
         return self
 
-    # TODO: Remove in 1.5.0
-    @deprecated(
-        version="1.3.0",
-        reason="'Job gpus' will be removed in 1.5.0, use 'with_limits' instead",
-        category=FutureWarning,
-    )
-    def gpus(self, gpus, gpu_type="nvidia.com/gpu"):
-        update_in(self.spec.resources, ["limits", gpu_type], gpus)
-
     def set_image_pull_configuration(
         self, image_pull_policy: str = None, image_pull_secret_name: str = None
     ):
@@ -1041,15 +1041,25 @@ class KubeResource(BaseRuntime):
         patch: bool = False,
     ):
         """
-        set pod cpu/memory/gpu limits
-        by default it overrides the whole limits section, if you wish to patch specific resources use `patch=True`.
+        Set pod cpu/memory/gpu limits (max values)
+
+        :param mem:     set limit for memory e.g. '500M', '2G', etc.
+        :param cpu:     set limit for cpu e.g. '0.5', '2', etc.
+        :param gpus:    set limit for gpu
+        :param gpu_type:    set gpu type e.g. "nvidia.com/gpu"
+        :param patch:    by default it overrides the whole limits section,
+                        if you wish to patch specific resources use `patch=True`
         """
         self.spec.with_limits(mem, cpu, gpus, gpu_type, patch=patch)
 
     def with_requests(self, mem: str = None, cpu: str = None, patch: bool = False):
         """
-        set requested (desired) pod cpu/memory resources
-        by default it overrides the whole requests section, if you wish to patch specific resources use `patch=True`.
+        Set requested (desired) pod cpu/memory resources
+
+        :param mem:     set request for memory e.g. '200M', '1G', etc.
+        :param cpu:     set request for cpu e.g. '0.1', '1', etc.
+        :param patch:   by default it overrides the whole requests section,
+                        if you wish to patch specific resources use `patch=True`
         """
         self.spec.with_requests(mem, cpu, patch=patch)
 

mlrun/runtimes/remotesparkjob.py

@@ -21,8 +21,7 @@ from mlrun.config import config
 
 from ..model import RunObject
 from ..platforms.iguazio import mount_v3io, mount_v3iod
-from .base import RuntimeClassMode
-from .kubejob import KubejobRuntime, KubeRuntimeHandler
+from .kubejob import KubejobRuntime
 from .pod import KubeResourceSpec
 
 
@@ -210,18 +209,5 @@ class RemoteSparkRuntime(KubejobRuntime):
         )
 
 
-class RemoteSparkRuntimeHandler(KubeRuntimeHandler):
-    kind = "remote-spark"
-    class_modes = {RuntimeClassMode.run: "remote-spark"}
-
-    @staticmethod
-    def _are_resources_coupled_to_run_object() -> bool:
-        return True
-
-    @staticmethod
-    def _get_object_label_selector(object_id: str) -> str:
-        return f"mlrun/uid={object_id}"
-
-
 def igz_spark_pre_hook():
     run(["/bin/bash", "/etc/config/v3io/spark-job-init.sh"])

mlrun/runtimes/serving.py

@@ -22,6 +22,7 @@ from nuclio import KafkaTrigger
 
 import mlrun
 import mlrun.common.schemas
+from mlrun.model_monitoring.tracking_policy import TrackingPolicy
 
 from ..datastore import parse_kafka_url
 from ..model import ObjectList
@@ -36,7 +37,7 @@ from ..serving.states import (
     new_remote_endpoint,
     params_to_step,
 )
-from ..utils import get_caller_globals, logger, model_monitoring, set_paths
+from ..utils import get_caller_globals, logger, set_paths
 from .function import NuclioSpec, RemoteRuntime
 from .function_reference import FunctionReference
 
@@ -146,7 +147,6 @@ class ServingSpec(NuclioSpec):
         add_templated_ingress_host_mode=None,
         clone_target_dir=None,
     ):
-
         super().__init__(
             command=command,
             args=args,
@@ -304,7 +304,7 @@ class ServingRuntime(RemoteRuntime):
         batch: int = None,
         sample: int = None,
         stream_args: dict = None,
-        tracking_policy: Union[model_monitoring.TrackingPolicy, dict] = None,
+        tracking_policy: Union[TrackingPolicy, dict] = None,
     ):
         """set tracking parameters:
 
@@ -334,9 +334,7 @@ class ServingRuntime(RemoteRuntime):
         if tracking_policy:
             if isinstance(tracking_policy, dict):
                 # Convert tracking policy dictionary into `model_monitoring.TrackingPolicy` object
-                self.spec.tracking_policy = model_monitoring.TrackingPolicy.from_dict(
-                    tracking_policy
-                )
+                self.spec.tracking_policy = TrackingPolicy.from_dict(tracking_policy)
             else:
                 # Tracking_policy is already a `model_monitoring.TrackingPolicy` object
                 self.spec.tracking_policy = tracking_policy
@@ -476,6 +474,16 @@ class ServingRuntime(RemoteRuntime):
                 child_function = self._spec.function_refs[function_name]
                 trigger_args = stream.trigger_args or {}
 
+                if mlrun.mlconf.is_explicit_ack():
+                    trigger_args["explicit_ack_mode"] = trigger_args.get(
+                        "explicit_ack_mode", "explicitOnly"
+                    )
+                    extra_attributes = trigger_args.get("extra_attributes", {})
+                    trigger_args["extra_attributes"] = extra_attributes
+                    extra_attributes["workerAllocationMode"] = extra_attributes.get(
+                        "workerAllocationMode", "static"
+                    )
+
                 if (
                     stream.path.startswith("kafka://")
                     or "kafka_bootstrap_servers" in stream.options

mlrun/runtimes/sparkjob/__init__.py

@@ -14,5 +14,4 @@
 
 # flake8: noqa  - this is until we take care of the F401 violations with respect to __all__ & sphinx
 
-from .abstract import SparkRuntimeHandler
 from .spark3job import Spark3Runtime

mlrun/runtimes/sparkjob/abstract.py

@@ -14,21 +14,15 @@
 import os.path
 import typing
 from copy import deepcopy
-from datetime import datetime
-from typing import Dict, Optional, Tuple
 
 from kubernetes import client
 from kubernetes.client.rest import ApiException
-from sqlalchemy.orm import Session
 
+import mlrun.db
 import mlrun.errors
 import mlrun.utils.regex
-from mlrun.api.db.base import DBInterface
 from mlrun.config import config
-from mlrun.db import get_run_db
 from mlrun.errors import err_to_str
-from mlrun.runtimes.base import BaseRuntimeHandler
-from mlrun.runtimes.constants import RunStates, SparkApplicationStates
 
 from ...execution import MLClientCtx
 from ...model import RunObject
@@ -41,7 +35,7 @@ from ...utils import (
     verify_field_regex,
     verify_list_and_update_in,
 )
-from ..base import RunError, RuntimeClassMode
+from ..base import RunError
 from ..kubejob import KubejobRuntime
 from ..pod import KubeResourceSpec
 from ..utils import get_item_name, get_k8s
@@ -242,7 +236,7 @@ class AbstractSparkRuntime(KubejobRuntime):
         sj.with_driver_requests(cpu=1, mem="512m")
 
         sj.deploy()
-        get_run_db().delete_function(name=sj.metadata.name)
+        mlrun.db.get_run_db().delete_function(name=sj.metadata.name)
 
     def _is_using_gpu(self):
         driver_limits = self.spec.driver_resources.get("limits")
@@ -292,7 +286,7 @@ class AbstractSparkRuntime(KubejobRuntime):
         :return True if the function is ready (deployed)
         """
         # connect will populate the config from the server config
-        get_run_db()
+        mlrun.db.get_run_db()
         if not self.spec.build.base_image:
             self.spec.build.base_image = self._default_image
         return super().deploy(
@@ -841,124 +835,3 @@ with ctx:
     @spec.setter
     def spec(self, spec):
         raise NotImplementedError()
-
-
-class SparkRuntimeHandler(BaseRuntimeHandler):
-    kind = "spark"
-    class_modes = {
-        RuntimeClassMode.run: "spark",
-    }
-
-    def _resolve_crd_object_status_info(
-        self, db: DBInterface, db_session: Session, crd_object
-    ) -> Tuple[bool, Optional[datetime], Optional[str]]:
-        state = crd_object.get("status", {}).get("applicationState", {}).get("state")
-        in_terminal_state = state in SparkApplicationStates.terminal_states()
-        desired_run_state = SparkApplicationStates.spark_application_state_to_run_state(
-            state
-        )
-        completion_time = None
-        if in_terminal_state:
-            if crd_object.get("status", {}).get("terminationTime"):
-                completion_time = datetime.fromisoformat(
-                    crd_object.get("status", {})
-                    .get("terminationTime")
-                    .replace("Z", "+00:00")
-                )
-            else:
-                last_submission_attempt_time = crd_object.get("status", {}).get(
-                    "lastSubmissionAttemptTime"
-                )
-                if last_submission_attempt_time:
-                    last_submission_attempt_time = last_submission_attempt_time.replace(
-                        "Z", "+00:00"
-                    )
-                    completion_time = datetime.fromisoformat(
-                        last_submission_attempt_time
-                    )
-        return in_terminal_state, completion_time, desired_run_state
-
-    def _update_ui_url(
-        self,
-        db: DBInterface,
-        db_session: Session,
-        project: str,
-        uid: str,
-        crd_object,
-        run: Dict = None,
-    ):
-        app_state = (
-            crd_object.get("status", {}).get("applicationState", {}).get("state")
-        )
-        state = SparkApplicationStates.spark_application_state_to_run_state(app_state)
-        ui_url = None
-        if state == RunStates.running:
-            ui_url = (
-                crd_object.get("status", {})
-                .get("driverInfo", {})
-                .get("webUIIngressAddress")
-            )
-        db_ui_url = run.get("status", {}).get("ui_url")
-        if db_ui_url == ui_url:
-            return
-        run.setdefault("status", {})["ui_url"] = ui_url
-        db.store_run(db_session, run, uid, project)
-
-    @staticmethod
-    def _are_resources_coupled_to_run_object() -> bool:
-        return True
-
-    @staticmethod
-    def _get_object_label_selector(object_id: str) -> str:
-        return f"mlrun/uid={object_id}"
-
-    @staticmethod
-    def _get_main_runtime_resource_label_selector() -> str:
-        """
-        There are some runtimes which might have multiple k8s resources attached to a one runtime, in this case
-        we don't want to pull logs from all but rather only for the "driver"/"launcher" etc
-        :return: the label selector
-        """
-        return "spark-role=driver"
-
-    @staticmethod
-    def _get_crd_info() -> Tuple[str, str, str]:
-        return (
-            AbstractSparkRuntime.group,
-            AbstractSparkRuntime.version,
-            AbstractSparkRuntime.plural,
-        )
-
-    def _delete_extra_resources(
-        self,
-        db: DBInterface,
-        db_session: Session,
-        namespace: str,
-        deleted_resources: typing.List[Dict],
-        label_selector: str = None,
-        force: bool = False,
-        grace_period: int = None,
-    ):
-        """
-        Handling config maps deletion
-        """
-        uids = []
-        for crd_dict in deleted_resources:
-            uid = crd_dict["metadata"].get("labels", {}).get("mlrun/uid", None)
-            uids.append(uid)
-
-        config_maps = get_k8s().v1api.list_namespaced_config_map(
-            namespace, label_selector=label_selector
-        )
-        for config_map in config_maps.items:
-            try:
-                uid = config_map.metadata.labels.get("mlrun/uid", None)
-                if force or uid in uids:
-                    get_k8s().v1api.delete_namespaced_config_map(
-                        config_map.metadata.name, namespace
-                    )
-                    logger.info(f"Deleted config map: {config_map.metadata.name}")
-            except ApiException as exc:
-                # ignore error if config map is already removed
-                if exc.status != 404:
-                    raise

mlrun/runtimes/utils.py

@@ -24,11 +24,9 @@ import pandas as pd
 from kubernetes import client
 
 import mlrun
-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.errors import err_to_str
 from mlrun.frameworks.parallel_coordinates import gen_pcp_plot
 from mlrun.runtimes.constants import MPIJobCRDVersions
@@ -62,7 +60,6 @@ global_context = _ContextStore()
 
 
 cached_mpijob_crd_version = None
-cached_nuclio_version = None
 
 
 # resolve mpijob runtime according to the mpi-operator's supported crd-version
@@ -119,29 +116,6 @@ def resolve_spark_operator_version():
         raise ValueError("Failed to resolve spark operator's version")
 
 
-# if nuclio version specified on mlrun config set it likewise,
-# if not specified, get it from nuclio api client
-# since this is a heavy operation (sending requests to API), and it's unlikely that the version
-# will change - cache it (this means if we upgrade nuclio, we need to restart mlrun to re-fetch the new version)
-def resolve_nuclio_version():
-    global cached_nuclio_version
-
-    if not cached_nuclio_version:
-
-        # config override everything
-        nuclio_version = config.nuclio_version
-        if not nuclio_version and config.nuclio_dashboard_url:
-            try:
-                nuclio_client = nuclio.Client()
-                nuclio_version = nuclio_client.get_dashboard_version()
-            except Exception as exc:
-                logger.warning("Failed to resolve nuclio version", exc=err_to_str(exc))
-
-        cached_nuclio_version = nuclio_version
-
-    return cached_nuclio_version
-
-
 def calc_hash(func, tag=""):
     # remove tag, hash, date from calculation
     tag = tag or func.metadata.tag

mlrun/serving/routers.py

@@ -25,10 +25,10 @@ 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
+import mlrun.common.schemas.model_monitoring
+from mlrun.utils import logger, now_date
 
+from ..common.helpers import parse_versioned_object_uri
 from ..config import config
 from .server import GraphServer
 from .utils import RouterToDict, _extract_input_data, _update_result_body
@@ -1066,13 +1066,13 @@ def _init_endpoint_record(
                         project=project, kind="stream"
                     ),
                     active=True,
-                    monitoring_mode=mlrun.common.model_monitoring.ModelMonitoringMode.enabled
+                    monitoring_mode=mlrun.common.schemas.model_monitoring.ModelMonitoringMode.enabled
                     if voting_ensemble.context.server.track_models
-                    else mlrun.common.model_monitoring.ModelMonitoringMode.disabled,
+                    else mlrun.common.schemas.model_monitoring.ModelMonitoringMode.disabled,
                 ),
                 status=mlrun.common.schemas.ModelEndpointStatus(
                     children=list(voting_ensemble.routes.keys()),
-                    endpoint_type=mlrun.common.model_monitoring.EndpointType.ROUTER,
+                    endpoint_type=mlrun.common.schemas.model_monitoring.EndpointType.ROUTER,
                     children_uids=children_uids,
                 ),
             )
@@ -1091,7 +1091,7 @@ def _init_endpoint_record(
                     project=project, endpoint_id=model_endpoint
                 )
                 current_endpoint.status.endpoint_type = (
-                    mlrun.common.model_monitoring.EndpointType.LEAF_EP
+                    mlrun.common.schemas.model_monitoring.EndpointType.LEAF_EP
                 )
                 db.create_model_endpoint(
                     project=project,

mlrun/serving/server.py

@@ -23,17 +23,19 @@ import uuid
 from typing import Optional, Union
 
 import mlrun
-import mlrun.utils.model_monitoring
-from mlrun.common.model_monitoring import FileTargetKind
+import mlrun.common.helpers
+import mlrun.model_monitoring
 from mlrun.config import config
 from mlrun.errors import err_to_str
 from mlrun.secrets import SecretsStore
 
+from ..common.helpers import parse_versioned_object_uri
+from ..common.schemas.model_monitoring.constants import FileTargetKind
 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 get_caller_globals
 from .states import RootFlowStep, RouterStep, get_function, graph_root_setter
 from .utils import (
     event_id_key,
@@ -48,7 +50,6 @@ class _StreamContext:
     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
@@ -71,7 +72,7 @@ class _StreamContext:
                 function_uri, config.default_project
             )
 
-            stream_uri = mlrun.utils.model_monitoring.get_stream_path(project=project)
+            stream_uri = mlrun.model_monitoring.get_stream_path(project=project)
 
             if log_stream:
                 # Update the stream path to the log stream value
@@ -467,6 +468,8 @@ class GraphContext:
             self.logger = nuclio_context.logger
             self.Response = nuclio_context.Response
             self.worker_id = nuclio_context.worker_id
+            if hasattr(nuclio_context, "platform"):
+                self.platform = nuclio_context.platform
         elif not logger:
             self.logger = mlrun.utils.helpers.logger
 
@@ -483,7 +486,7 @@ class GraphContext:
     @property
     def project(self):
         """current project name (for the current function)"""
-        project, _, _, _ = mlrun.utils.parse_versioned_object_uri(
+        project, _, _, _ = mlrun.common.helpers.parse_versioned_object_uri(
             self._server.function_uri
         )
         return project
@@ -521,13 +524,13 @@ class GraphContext:
         """
         if "://" in name:
             return name
-        project, uri, tag, _ = mlrun.utils.parse_versioned_object_uri(
+        project, uri, tag, _ = mlrun.common.helpers.parse_versioned_object_uri(
             self._server.function_uri
         )
         if name.startswith("."):
             name = f"{uri}-{name[1:]}"
         else:
-            project, name, tag, _ = mlrun.utils.parse_versioned_object_uri(
+            project, name, tag, _ = mlrun.common.helpers.parse_versioned_object_uri(
                 name, project
             )
         (

mlrun/serving/states.py

@@ -21,6 +21,8 @@ from copy import copy, deepcopy
 from inspect import getfullargspec, signature
 from typing import Union
 
+import mlrun
+
 from ..config import config
 from ..datastore import get_stream_pusher
 from ..datastore.utils import parse_kafka_url
@@ -1512,5 +1514,9 @@ def _init_async_objects(context, steps):
                 wait_for_result = True
 
     source_args = context.get_param("source_args", {})
-    default_source = storey.SyncEmitSource(context=context, **source_args)
+    default_source = storey.SyncEmitSource(
+        context=context,
+        explicit_ack=mlrun.mlconf.is_explicit_ack(),
+        **source_args,
+    )
     return default_source, wait_for_result

mlrun/serving/v2_serving.py

@@ -17,13 +17,13 @@ import time
 import traceback
 from typing import Dict, Union
 
-import mlrun
 import mlrun.common.model_monitoring
-import mlrun.common.schemas
+import mlrun.common.schemas.model_monitoring
 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 import logger, now_date
 
+from ..common.helpers import parse_versioned_object_uri
 from .server import GraphServer
 from .utils import StepToDict, _extract_input_data, _update_result_body
 
@@ -516,12 +516,12 @@ def _init_endpoint_record(
                         project=project, kind="stream"
                     ),
                     active=True,
-                    monitoring_mode=mlrun.common.model_monitoring.ModelMonitoringMode.enabled
+                    monitoring_mode=mlrun.common.schemas.model_monitoring.ModelMonitoringMode.enabled
                     if model.context.server.track_models
-                    else mlrun.common.model_monitoring.ModelMonitoringMode.disabled,
+                    else mlrun.common.schemas.model_monitoring.ModelMonitoringMode.disabled,
                 ),
                 status=mlrun.common.schemas.ModelEndpointStatus(
-                    endpoint_type=mlrun.common.model_monitoring.EndpointType.NODE_EP
+                    endpoint_type=mlrun.common.schemas.model_monitoring.EndpointType.NODE_EP
                 ),
             )