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

mlrun/runtimes/mpijob/v1alpha1.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/runtimes/nuclio.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/runtimes/pod.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,12 +24,12 @@ from deprecated import deprecated
 
 import mlrun.errors
 import mlrun.utils.regex
-
-from ..api.schemas import (
+from mlrun.common.schemas import (
     NodeSelectorOperator,
     PreemptionModes,
     SecurityContextEnrichmentModes,
 )
+
 from ..config import config as mlconf
 from ..k8s_utils import (
     generate_preemptible_node_selector_requirements,
@@ -44,6 +44,7 @@ from .utils import (
     apply_kfp,
     get_gpu_from_resource_requirement,
     get_item_name,
+    get_k8s,
     get_resource_labels,
     set_named_item,
     verify_limits,
@@ -135,6 +136,7 @@ class KubeResourceSpec(FunctionSpec):
         tolerations=None,
         preemption_mode=None,
         security_context=None,
+        clone_target_dir=None,
     ):
         super().__init__(
             command=command,
@@ -148,6 +150,7 @@ class KubeResourceSpec(FunctionSpec):
             default_handler=default_handler,
             pythonpath=pythonpath,
             disable_auto_mount=disable_auto_mount,
+            clone_target_dir=clone_target_dir,
         )
         self._volumes = {}
         self._volume_mounts = {}
@@ -357,15 +360,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)
 
@@ -989,12 +1002,14 @@ class KubeResource(BaseRuntime):
                 "must specify env_vars OR file_path"
             )
         if file_path:
-            env_vars = dotenv.dotenv_values(file_path)
-            if None in env_vars.values():
-                raise mlrun.errors.MLRunInvalidArgumentError(
-                    "env file lines must be in the form key=value"
-                )
-
+            if os.path.isfile(file_path):
+                env_vars = dotenv.dotenv_values(file_path)
+                if None in env_vars.values():
+                    raise mlrun.errors.MLRunInvalidArgumentError(
+                        "env file lines must be in the form key=value"
+                    )
+            else:
+                raise mlrun.errors.MLRunNotFoundError(f"{file_path} does not exist")
         for name, value in env_vars.items():
             self.set_env(name, value)
         return self
@@ -1036,15 +1051,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)
 
@@ -1113,7 +1138,7 @@ class KubeResource(BaseRuntime):
         The default preemption mode is configurable in mlrun.mlconf.function_defaults.preemption_mode,
         by default it's set to **prevent**
 
-        :param mode: allow | constrain | prevent | none defined in :py:class:`~mlrun.api.schemas.PreemptionModes`
+        :param mode: allow | constrain | prevent | none defined in :py:class:`~mlrun.common.schemas.PreemptionModes`
         """
         preemptible_mode = PreemptionModes(mode)
         self.spec.preemption_mode = preemptible_mode.value
@@ -1122,7 +1147,7 @@ class KubeResource(BaseRuntime):
         """
         Set security context for the pod.
         For Iguazio we handle security context internally -
-        see mlrun.api.schemas.function.SecurityContextEnrichmentModes
+        see mlrun.common.schemas.function.SecurityContextEnrichmentModes
 
         Example:
 
@@ -1155,7 +1180,7 @@ class KubeResource(BaseRuntime):
         return mlconf.default_function_priority_class_name
 
     def _get_meta(self, runobj, unique=False):
-        namespace = self._get_k8s().resolve_namespace()
+        namespace = get_k8s().resolve_namespace()
 
         labels = get_resource_labels(self, runobj, runobj.spec.scrape_metrics)
         new_meta = k8s_client.V1ObjectMeta(
@@ -1223,7 +1248,7 @@ class KubeResource(BaseRuntime):
             mlconf.secret_stores.kubernetes.global_function_env_secret_name
         )
         if mlrun.config.is_running_as_api() and global_secret_name:
-            global_secrets = self._get_k8s().get_secret_data(global_secret_name)
+            global_secrets = get_k8s().get_secret_data(global_secret_name)
             for key, value in global_secrets.items():
                 env_var_name = (
                     SecretsStore.k8s_env_variable_name_for_secret(key)
@@ -1245,10 +1270,10 @@ class KubeResource(BaseRuntime):
             logger.warning("No project provided. Cannot add k8s secrets")
             return
 
-        secret_name = self._get_k8s().get_project_secret_name(project_name)
+        secret_name = get_k8s().get_project_secret_name(project_name)
         # Not utilizing the same functionality from the Secrets crud object because this code also runs client-side
         # in the nuclio remote-dashboard flow, which causes dependency problems.
-        existing_secret_keys = self._get_k8s().get_project_secret_keys(
+        existing_secret_keys = get_k8s().get_project_secret_keys(
             project_name, filter_internal=True
         )
 
@@ -1282,7 +1307,7 @@ class KubeResource(BaseRuntime):
             )
         )
 
-        project_vault_secret_name = self._get_k8s().get_project_vault_secret_name(
+        project_vault_secret_name = get_k8s().get_project_vault_secret_name(
             project_name, service_account_name
         )
         if project_vault_secret_name is None:
@@ -1453,7 +1478,7 @@ def get_sanitized_attribute(spec, attribute_name: str):
     if isinstance(attribute, dict):
         if attribute_config["not_sanitized_class"] != dict:
             raise mlrun.errors.MLRunInvalidArgumentTypeError(
-                f"expected to to be of type {attribute_config.get('not_sanitized_class')} but got dict"
+                f"expected to be of type {attribute_config.get('not_sanitized_class')} but got dict"
             )
         if _resolve_if_type_sanitized(attribute_name, attribute):
             return attribute
@@ -1463,7 +1488,7 @@ def get_sanitized_attribute(spec, attribute_name: str):
     ):
         if attribute_config["not_sanitized_class"] != list:
             raise mlrun.errors.MLRunInvalidArgumentTypeError(
-                f"expected to to be of type {attribute_config.get('not_sanitized_class')} but got list"
+                f"expected to be of type {attribute_config.get('not_sanitized_class')} but got list"
             )
         if _resolve_if_type_sanitized(attribute_name, attribute[0]):
             return attribute

mlrun/runtimes/remotesparkjob.py

@@ -1,4 +1,4 @@
-# Copyright 2021 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.
@@ -58,6 +58,7 @@ class RemoteSparkSpec(KubeResourceSpec):
         tolerations=None,
         preemption_mode=None,
         security_context=None,
+        clone_target_dir=None,
     ):
         super().__init__(
             command=command,
@@ -86,6 +87,7 @@ class RemoteSparkSpec(KubeResourceSpec):
             tolerations=tolerations,
             preemption_mode=preemption_mode,
             security_context=security_context,
+            clone_target_dir=clone_target_dir,
         )
         self.provider = provider
 

mlrun/runtimes/serving.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,7 +21,7 @@ import nuclio
 from nuclio import KafkaTrigger
 
 import mlrun
-import mlrun.api.schemas
+import mlrun.common.schemas
 
 from ..datastore import parse_kafka_url
 from ..model import ObjectList
@@ -116,6 +116,7 @@ class ServingSpec(NuclioSpec):
         function_kind=None,
         service_account=None,
         readiness_timeout=None,
+        readiness_timeout_before_failure=None,
         models=None,
         graph=None,
         parameters=None,
@@ -141,6 +142,9 @@ class ServingSpec(NuclioSpec):
         tolerations=None,
         preemption_mode=None,
         security_context=None,
+        service_type=None,
+        add_templated_ingress_host_mode=None,
+        clone_target_dir=None,
     ):
 
         super().__init__(
@@ -165,6 +169,7 @@ class ServingSpec(NuclioSpec):
             function_kind=serving_subkind,
             service_account=service_account,
             readiness_timeout=readiness_timeout,
+            readiness_timeout_before_failure=readiness_timeout_before_failure,
             build=build,
             node_name=node_name,
             node_selector=node_selector,
@@ -178,6 +183,9 @@ class ServingSpec(NuclioSpec):
             tolerations=tolerations,
             preemption_mode=preemption_mode,
             security_context=security_context,
+            service_type=service_type,
+            add_templated_ingress_host_mode=add_templated_ingress_host_mode,
+            clone_target_dir=clone_target_dir,
         )
 
         self.models = models or {}
@@ -313,7 +321,7 @@ class ServingRuntime(RemoteRuntime):
                                 example::
 
                                     # initialize a new serving function
-                                    serving_fn = mlrun.import_function("hub://v2_model_server", new_name="serving")
+                                    serving_fn = mlrun.import_function("hub://v2-model-server", new_name="serving")
                                     # apply model monitoring and set monitoring batch job to run every 3 hours
                                     tracking_policy = {'default_batch_intervals':"0 */3 * * *"}
                                     serving_fn.set_tracking(tracking_policy=tracking_policy)
@@ -579,7 +587,7 @@ class ServingRuntime(RemoteRuntime):
         project="",
         tag="",
         verbose=False,
-        auth_info: mlrun.api.schemas.AuthInfo = None,
+        auth_info: mlrun.common.schemas.AuthInfo = None,
         builder_env: dict = None,
     ):
         """deploy model serving function to a local/remote cluster

mlrun/runtimes/sparkjob/__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.
@@ -15,5 +15,4 @@
 # flake8: noqa  - this is until we take care of the F401 violations with respect to __all__ & sphinx
 
 from .abstract import SparkRuntimeHandler
-from .spark2job import Spark2Runtime
 from .spark3job import Spark3Runtime

mlrun/runtimes/sparkjob/abstract.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.
@@ -11,7 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
+import os.path
 import typing
 from copy import deepcopy
 from datetime import datetime
@@ -31,7 +31,6 @@ from mlrun.runtimes.base import BaseRuntimeHandler
 from mlrun.runtimes.constants import RunStates, SparkApplicationStates
 
 from ...execution import MLClientCtx
-from ...k8s_utils import get_k8s_helper
 from ...model import RunObject
 from ...platforms.iguazio import mount_v3io, mount_v3iod
 from ...utils import (
@@ -45,7 +44,7 @@ from ...utils import (
 from ..base import RunError, RuntimeClassMode
 from ..kubejob import KubejobRuntime
 from ..pod import KubeResourceSpec
-from ..utils import get_item_name
+from ..utils import get_item_name, get_k8s
 
 _service_account = "sparkapp"
 _sparkjob_template = {
@@ -143,6 +142,7 @@ class AbstractSparkJobSpec(KubeResourceSpec):
         tolerations=None,
         preemption_mode=None,
         security_context=None,
+        clone_target_dir=None,
     ):
 
         super().__init__(
@@ -172,6 +172,7 @@ class AbstractSparkJobSpec(KubeResourceSpec):
             tolerations=tolerations,
             preemption_mode=preemption_mode,
             security_context=security_context,
+            clone_target_dir=clone_target_dir,
         )
 
         self._driver_resources = self.enrich_resources_with_default_pod_resources(
@@ -363,6 +364,15 @@ class AbstractSparkRuntime(KubejobRuntime):
     def _get_igz_deps(self):
         raise NotImplementedError()
 
+    def _pre_run(self, runobj: RunObject, execution: MLClientCtx):
+        if self.spec.build.source and self.spec.build.load_source_on_run:
+            raise mlrun.errors.MLRunPreconditionFailedError(
+                "Sparkjob does not support loading source code on run, "
+                "use func.with_source_archive(pull_at_runtime=False)"
+            )
+
+        super()._pre_run(runobj, execution)
+
     def _run(self, runobj: RunObject, execution: MLClientCtx):
         self._validate(runobj)
 
@@ -559,7 +569,11 @@ with ctx:
 
         if self.spec.command:
             if "://" not in self.spec.command:
-                self.spec.command = "local://" + self.spec.command
+                workdir = self._resolve_workdir()
+                self.spec.command = "local://" + os.path.join(
+                    workdir or "",
+                    self.spec.command,
+                )
             update_in(job, "spec.mainApplicationFile", self.spec.command)
 
         verify_list_and_update_in(job, "spec.arguments", self.spec.args or [], str)
@@ -577,7 +591,7 @@ with ctx:
         code=None,
     ):
         namespace = meta.namespace
-        k8s = self._get_k8s()
+        k8s = get_k8s()
         namespace = k8s.resolve_namespace(namespace)
         if code:
             k8s_config_map = client.V1ConfigMap()
@@ -621,7 +635,7 @@ with ctx:
             raise RunError("Exception when creating SparkJob") from exc
 
     def get_job(self, name, namespace=None):
-        k8s = self._get_k8s()
+        k8s = get_k8s()
         namespace = k8s.resolve_namespace(namespace)
         try:
             resp = k8s.crdapi.get_namespaced_custom_object(
@@ -789,25 +803,27 @@ with ctx:
             submission_retry_interval,
         )
 
-    def get_pods(self, name=None, namespace=None, driver=False):
-        k8s = self._get_k8s()
-        namespace = k8s.resolve_namespace(namespace)
-        selector = "mlrun/class=spark"
-        if name:
-            selector += f",sparkoperator.k8s.io/app-name={name}"
-        if driver:
-            selector += ",spark-role=driver"
-        pods = k8s.list_pods(selector=selector, namespace=namespace)
-        if pods:
-            return {p.metadata.name: p.status.phase for p in pods}
-
-    def _get_driver(self, name, namespace=None):
-        pods = self.get_pods(name, namespace, driver=True)
-        if not pods:
-            logger.error("no pod matches that job name")
-            return
-        _ = self._get_k8s()
-        return list(pods.items())[0]
+    def with_source_archive(
+        self, source, workdir=None, handler=None, pull_at_runtime=True, target_dir=None
+    ):
+        """load the code from git/tar/zip archive at runtime or build
+
+        :param source:          valid path to git, zip, or tar file, e.g.
+                                git://github.com/mlrun/something.git
+                                http://some/url/file.zip
+        :param handler:         default function handler
+        :param workdir:         working dir relative to the archive root (e.g. './subdir') or absolute to the image root
+        :param pull_at_runtime: not supported for spark runtime, must be False
+        :param target_dir:      target dir on runtime pod for repo clone / archive extraction
+        """
+        if pull_at_runtime:
+            raise mlrun.errors.MLRunInvalidArgumentError(
+                "pull_at_runtime is not supported for spark runtime, use pull_at_runtime=False"
+            )
+
+        super().with_source_archive(
+            source, workdir, handler, pull_at_runtime, target_dir
+        )
 
     def is_deployed(self):
         if (
@@ -926,22 +942,19 @@ class SparkRuntimeHandler(BaseRuntimeHandler):
         """
         Handling config maps deletion
         """
-        if grace_period is None:
-            grace_period = config.runtime_resources_deletion_grace_period
         uids = []
         for crd_dict in deleted_resources:
             uid = crd_dict["metadata"].get("labels", {}).get("mlrun/uid", None)
             uids.append(uid)
 
-        k8s_helper = get_k8s_helper()
-        config_maps = k8s_helper.v1api.list_namespaced_config_map(
+        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:
-                    k8s_helper.v1api.delete_namespaced_config_map(
+                    get_k8s().v1api.delete_namespaced_config_map(
                         config_map.metadata.name, namespace
                     )
                     logger.info(f"Deleted config map: {config_map.metadata.name}")

mlrun/runtimes/sparkjob/spark3job.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 @@ import typing
 
 import kubernetes.client
 
-import mlrun.api.schemas.function
+import mlrun.common.schemas.function
 import mlrun.errors
 import mlrun.runtimes.pod
 
@@ -100,6 +100,7 @@ class Spark3JobSpec(AbstractSparkJobSpec):
         driver_cores=None,
         executor_cores=None,
         security_context=None,
+        clone_target_dir=None,
     ):
 
         super().__init__(
@@ -129,6 +130,7 @@ class Spark3JobSpec(AbstractSparkJobSpec):
             tolerations=tolerations,
             preemption_mode=preemption_mode,
             security_context=security_context,
+            clone_target_dir=clone_target_dir,
         )
 
         self.driver_resources = driver_resources or {}
@@ -518,7 +520,7 @@ class Spark3Runtime(AbstractSparkRuntime):
             self.spec.executor_tolerations = tolerations
 
     def with_preemption_mode(
-        self, mode: typing.Union[mlrun.api.schemas.function.PreemptionModes, str]
+        self, mode: typing.Union[mlrun.common.schemas.function.PreemptionModes, str]
     ):
         """
         Use with_driver_preemption_mode / with_executor_preemption_mode to setup preemption_mode for spark operator
@@ -529,7 +531,7 @@ class Spark3Runtime(AbstractSparkRuntime):
         )
 
     def with_driver_preemption_mode(
-        self, mode: typing.Union[mlrun.api.schemas.function.PreemptionModes, str]
+        self, mode: typing.Union[mlrun.common.schemas.function.PreemptionModes, str]
     ):
         """
         Preemption mode controls whether the spark driver can be scheduled on preemptible nodes.
@@ -545,13 +547,13 @@ class Spark3Runtime(AbstractSparkRuntime):
         The default preemption mode is configurable in mlrun.mlconf.function_defaults.preemption_mode,
         by default it's set to **prevent**
 
-        :param mode: allow | constrain | prevent | none defined in :py:class:`~mlrun.api.schemas.PreemptionModes`
+        :param mode: allow | constrain | prevent | none defined in :py:class:`~mlrun.common.schemas.PreemptionModes`
         """
-        preemption_mode = mlrun.api.schemas.function.PreemptionModes(mode)
+        preemption_mode = mlrun.common.schemas.function.PreemptionModes(mode)
         self.spec.driver_preemption_mode = preemption_mode.value
 
     def with_executor_preemption_mode(
-        self, mode: typing.Union[mlrun.api.schemas.function.PreemptionModes, str]
+        self, mode: typing.Union[mlrun.common.schemas.function.PreemptionModes, str]
     ):
         """
         Preemption mode controls whether the spark executor can be scheduled on preemptible nodes.
@@ -567,9 +569,9 @@ class Spark3Runtime(AbstractSparkRuntime):
         The default preemption mode is configurable in mlrun.mlconf.function_defaults.preemption_mode,
         by default it's set to **prevent**
 
-        :param mode: allow | constrain | prevent | none defined in :py:class:`~mlrun.api.schemas.PreemptionModes`
+        :param mode: allow | constrain | prevent | none defined in :py:class:`~mlrun.common.schemas.PreemptionModes`
         """
-        preemption_mode = mlrun.api.schemas.function.PreemptionModes(mode)
+        preemption_mode = mlrun.common.schemas.function.PreemptionModes(mode)
         self.spec.executor_preemption_mode = preemption_mode.value
 
     def with_security_context(