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

mlrun/runtimes/daskjob.py

@@ -15,33 +15,25 @@ import datetime
 import inspect
 import socket
 import time
-import typing
 from os import environ
-from typing import Dict, List, Optional, Union
-
-from deprecated import deprecated
-from kubernetes.client.rest import ApiException
-from sqlalchemy.orm import Session
 
 import mlrun.common.schemas
 import mlrun.errors
 import mlrun.k8s_utils
 import mlrun.utils
 import mlrun.utils.regex
-from mlrun.api.db.base import DBInterface
 from mlrun.errors import err_to_str
-from mlrun.runtimes.base import BaseRuntimeHandler
 
 from ..config import config
 from ..execution import MLClientCtx
 from ..model import RunObject
 from ..render import ipython_display
 from ..utils import logger, normalize_name, update_in
-from .base import FunctionStatus, RuntimeClassMode
+from .base import FunctionStatus
 from .kubejob import KubejobRuntime
 from .local import exec_from_params, load_module
 from .pod import KubeResourceSpec, kube_resource_spec_to_pod_spec
-from .utils import RunError, get_func_selector, get_k8s, get_resource_labels, log_std
+from .utils import RunError, get_func_selector, get_resource_labels, log_std
 
 
 def get_dask_resource():
@@ -406,16 +398,6 @@ class DaskCluster(KubejobRuntime):
             show_on_failure=show_on_failure,
         )
 
-    # TODO: Remove in 1.5.0
-    @deprecated(
-        version="1.3.0",
-        reason="'Dask gpus' will be removed in 1.5.0, use 'with_scheduler_limits' / 'with_worker_limits' instead",
-        category=FutureWarning,
-    )
-    def gpus(self, gpus, gpu_type="nvidia.com/gpu"):
-        update_in(self.spec.scheduler_resources, ["limits", gpu_type], gpus)
-        update_in(self.spec.worker_resources, ["limits", gpu_type], gpus)
-
     def with_limits(
         self,
         mem=None,
@@ -686,181 +668,3 @@ def get_obj_status(selector=None, namespace=None):
             f"found dask function {pod.metadata.name} in non ready state ({status})"
         )
     return status
-
-
-class DaskRuntimeHandler(BaseRuntimeHandler):
-    kind = "dask"
-    class_modes = {RuntimeClassMode.run: "dask"}
-
-    # Dask runtime resources are per function (and not per run).
-    # It means that monitoring runtime resources state doesn't say anything about the run state.
-    # Therefore dask run monitoring is done completely by the SDK, so overriding the monitoring method with no logic
-    def monitor_runs(
-        self, db: DBInterface, db_session: Session, leader_session: Optional[str] = None
-    ):
-        return
-
-    @staticmethod
-    def _get_object_label_selector(object_id: str) -> str:
-        return f"mlrun/function={object_id}"
-
-    @staticmethod
-    def resolve_object_id(
-        run: dict,
-    ) -> typing.Optional[str]:
-        """
-        Resolves the object ID from the run object.
-        In dask runtime, the object ID is the function name.
-        :param run: run object
-        :return: function name
-        """
-
-        function = run.get("spec", {}).get("function", None)
-        if function:
-
-            # a dask run's function field is in the format <project-name>/<function-name>@<run-uid>
-            # we only want the function name
-            project_and_function = function.split("@")[0]
-            return project_and_function.split("/")[-1]
-
-        return None
-
-    def _enrich_list_resources_response(
-        self,
-        response: Union[
-            mlrun.common.schemas.RuntimeResources,
-            mlrun.common.schemas.GroupedByJobRuntimeResourcesOutput,
-            mlrun.common.schemas.GroupedByProjectRuntimeResourcesOutput,
-        ],
-        namespace: str,
-        label_selector: str = None,
-        group_by: Optional[
-            mlrun.common.schemas.ListRuntimeResourcesGroupByField
-        ] = None,
-    ) -> Union[
-        mlrun.common.schemas.RuntimeResources,
-        mlrun.common.schemas.GroupedByJobRuntimeResourcesOutput,
-        mlrun.common.schemas.GroupedByProjectRuntimeResourcesOutput,
-    ]:
-        """
-        Handling listing service resources
-        """
-        enrich_needed = self._validate_if_enrich_is_needed_by_group_by(group_by)
-        if not enrich_needed:
-            return response
-        services = get_k8s().v1api.list_namespaced_service(
-            namespace, label_selector=label_selector
-        )
-        service_resources = []
-        for service in services.items:
-            service_resources.append(
-                mlrun.common.schemas.RuntimeResource(
-                    name=service.metadata.name, labels=service.metadata.labels
-                )
-            )
-        return self._enrich_service_resources_in_response(
-            response, service_resources, group_by
-        )
-
-    def _build_output_from_runtime_resources(
-        self,
-        response: Union[
-            mlrun.common.schemas.RuntimeResources,
-            mlrun.common.schemas.GroupedByJobRuntimeResourcesOutput,
-            mlrun.common.schemas.GroupedByProjectRuntimeResourcesOutput,
-        ],
-        runtime_resources_list: List[mlrun.common.schemas.RuntimeResources],
-        group_by: Optional[
-            mlrun.common.schemas.ListRuntimeResourcesGroupByField
-        ] = None,
-    ):
-        enrich_needed = self._validate_if_enrich_is_needed_by_group_by(group_by)
-        if not enrich_needed:
-            return response
-        service_resources = []
-        for runtime_resources in runtime_resources_list:
-            if runtime_resources.service_resources:
-                service_resources += runtime_resources.service_resources
-        return self._enrich_service_resources_in_response(
-            response, service_resources, group_by
-        )
-
-    def _validate_if_enrich_is_needed_by_group_by(
-        self,
-        group_by: Optional[
-            mlrun.common.schemas.ListRuntimeResourcesGroupByField
-        ] = None,
-    ) -> bool:
-        # Dask runtime resources are per function (and not per job) therefore, when grouping by job we're simply
-        # omitting the dask runtime resources
-        if group_by == mlrun.common.schemas.ListRuntimeResourcesGroupByField.job:
-            return False
-        elif group_by == mlrun.common.schemas.ListRuntimeResourcesGroupByField.project:
-            return True
-        elif group_by is not None:
-            raise NotImplementedError(
-                f"Provided group by field is not supported. group_by={group_by}"
-            )
-        return True
-
-    def _enrich_service_resources_in_response(
-        self,
-        response: Union[
-            mlrun.common.schemas.RuntimeResources,
-            mlrun.common.schemas.GroupedByJobRuntimeResourcesOutput,
-            mlrun.common.schemas.GroupedByProjectRuntimeResourcesOutput,
-        ],
-        service_resources: List[mlrun.common.schemas.RuntimeResource],
-        group_by: Optional[
-            mlrun.common.schemas.ListRuntimeResourcesGroupByField
-        ] = None,
-    ):
-        if group_by == mlrun.common.schemas.ListRuntimeResourcesGroupByField.project:
-            for service_resource in service_resources:
-                self._add_resource_to_grouped_by_project_resources_response(
-                    response, "service_resources", service_resource
-                )
-        else:
-            response.service_resources = service_resources
-        return response
-
-    def _delete_extra_resources(
-        self,
-        db: DBInterface,
-        db_session: Session,
-        namespace: str,
-        deleted_resources: List[Dict],
-        label_selector: str = None,
-        force: bool = False,
-        grace_period: int = None,
-    ):
-        """
-        Handling services deletion
-        """
-        if grace_period is None:
-            grace_period = config.runtime_resources_deletion_grace_period
-        service_names = []
-        for pod_dict in deleted_resources:
-            dask_component = (
-                pod_dict["metadata"].get("labels", {}).get("dask.org/component")
-            )
-            cluster_name = (
-                pod_dict["metadata"].get("labels", {}).get("dask.org/cluster-name")
-            )
-            if dask_component == "scheduler" and cluster_name:
-                service_names.append(cluster_name)
-
-        services = get_k8s().v1api.list_namespaced_service(
-            namespace, label_selector=label_selector
-        )
-        for service in services.items:
-            try:
-                if force or service.metadata.name in service_names:
-                    get_k8s().v1api.delete_namespaced_service(
-                        service.metadata.name, namespace
-                    )
-                    logger.info(f"Deleted service: {service.metadata.name}")
-            except ApiException as exc:
-                # ignore error if service is already removed
-                if exc.status != 404:
-                    raise

mlrun/runtimes/funcdoc.py

@@ -15,7 +15,6 @@
 import ast
 import inspect
 import re
-import sys
 
 from mlrun.model import FunctionEntrypoint
 
@@ -251,14 +250,6 @@ def iter_elems(ann):
     if not hasattr(ann, "slice"):
         return [ann.value]
 
-    # From python 3.9, slice is an expr and we should evaluate it recursively. Left this for backward compatibility.
-    # TODO: Remove this in 1.5.0 when we drop support for python 3.7
-    if sys.version_info < (3, 9):
-        if hasattr(ann.slice, "elts"):
-            return ann.slice.elts
-        elif hasattr(ann.slice, "value"):
-            return [ann.slice.value]
-
     return [ann]
 
 

mlrun/runtimes/function.py

@@ -28,11 +28,12 @@ from kubernetes import client
 from nuclio.deploy import find_dashboard_url, get_deploy_status
 from nuclio.triggers import V3IOStreamTrigger
 
+import mlrun.db
 import mlrun.errors
 import mlrun.k8s_utils
 import mlrun.utils
+import mlrun.utils.helpers
 from mlrun.common.schemas import AuthInfo
-from mlrun.db import RunDBError
 
 from ..config import config as mlconf
 from ..errors import err_to_str
@@ -86,26 +87,6 @@ def validate_nuclio_version_compatibility(*min_versions):
     return False
 
 
-def is_nuclio_version_in_range(min_version: str, max_version: str) -> bool:
-    """
-    Return whether the Nuclio version is in the range, inclusive for min, exclusive for max - [min, max)
-    """
-    try:
-        parsed_min_version = semver.VersionInfo.parse(min_version)
-        parsed_max_version = semver.VersionInfo.parse(max_version)
-        nuclio_version = mlrun.runtimes.utils.resolve_nuclio_version()
-        parsed_current_version = semver.VersionInfo.parse(nuclio_version)
-    except ValueError:
-        logger.warning(
-            "Unable to parse nuclio version, assuming in range",
-            nuclio_version=nuclio_version,
-            min_version=min_version,
-            max_version=max_version,
-        )
-        return True
-    return parsed_min_version <= parsed_current_version < parsed_max_version
-
-
 def min_nuclio_versions(*versions):
     def decorator(function):
         def wrapper(*args, **kwargs):
@@ -508,6 +489,16 @@ class RemoteRuntime(KubeResource):
         endpoint = None
         if "://" in stream_path:
             endpoint, stream_path = parse_path(stream_path, suffix="")
+
+        # verify v3io stream trigger name is valid
+        mlrun.utils.helpers.validate_v3io_stream_consumer_group(group)
+
+        consumer_group = kwargs.pop("consumerGroup", None)
+        if consumer_group:
+            logger.warning(
+                "consumerGroup kwargs value is ignored. use group argument instead"
+            )
+
         container, path = split_path(stream_path)
         shards = shards or 1
         extra_attributes = extra_attributes or {}
@@ -623,7 +614,7 @@ class RemoteRuntime(KubeResource):
                 text, last_log_timestamp = db.get_builder_status(
                     self, last_log_timestamp=last_log_timestamp, verbose=verbose
                 )
-            except RunDBError:
+            except mlrun.db.RunDBError:
                 raise ValueError("function or deploy process not found")
             state = self.status.state
             if text:
@@ -734,7 +725,7 @@ class RemoteRuntime(KubeResource):
             text, last_log_timestamp = self._get_db().get_builder_status(
                 self, last_log_timestamp=last_log_timestamp, verbose=verbose
             )
-        except RunDBError:
+        except mlrun.db.RunDBError:
             if raise_on_exception:
                 return "", "", None
             raise ValueError("function or deploy process not found")
@@ -745,8 +736,8 @@ class RemoteRuntime(KubeResource):
         runtime_env = {
             "MLRUN_DEFAULT_PROJECT": self.metadata.project or mlconf.default_project,
         }
-        if self.spec.rundb or mlconf.httpdb.api_url:
-            runtime_env["MLRUN_DBPATH"] = self.spec.rundb or mlconf.httpdb.api_url
+        if mlconf.httpdb.api_url:
+            runtime_env["MLRUN_DBPATH"] = mlconf.httpdb.api_url
         if mlconf.namespace:
             runtime_env["MLRUN_NAMESPACE"] = mlconf.namespace
         if self.metadata.credentials.access_key:
@@ -844,6 +835,7 @@ class RemoteRuntime(KubeResource):
         force_external_address: bool = False,
         auth_info: AuthInfo = None,
         mock: bool = None,
+        **http_client_kwargs,
     ):
         """Invoke the remote (live) function and return the results
 
@@ -859,6 +851,9 @@ class RemoteRuntime(KubeResource):
         :param force_external_address:   use the external ingress URL
         :param auth_info: service AuthInfo
         :param mock:     use mock server vs a real Nuclio function (for local simulations)
+        :param http_client_kwargs:   allow the user to pass any parameter supported in requests.request method
+                                     see this link for more information:
+                                     https://requests.readthedocs.io/en/latest/api/#requests.request
         """
         if not method:
             method = "POST" if body else "GET"
@@ -890,15 +885,16 @@ class RemoteRuntime(KubeResource):
             self.metadata.name, self.metadata.project, self.metadata.tag
         )
         headers.setdefault("x-nuclio-target", full_function_name)
-        kwargs = {}
+        if not http_client_kwargs:
+            http_client_kwargs = {}
         if body:
             if isinstance(body, (str, bytes)):
-                kwargs["data"] = body
+                http_client_kwargs["data"] = body
             else:
-                kwargs["json"] = body
+                http_client_kwargs["json"] = body
         try:
             logger.info("invoking function", method=method, path=path)
-            resp = requests.request(method, path, headers=headers, **kwargs)
+            resp = requests.request(method, path, headers=headers, **http_client_kwargs)
         except OSError as err:
             raise OSError(
                 f"error: cannot run function at url {path}, {err_to_str(err)}"

mlrun/runtimes/kubejob.py

@@ -20,15 +20,14 @@ from kubernetes import client
 from kubernetes.client.rest import ApiException
 
 import mlrun.common.schemas
+import mlrun.db
 import mlrun.errors
-from mlrun.runtimes.base import BaseRuntimeHandler
 
-from ..db import RunDBError
 from ..errors import err_to_str
 from ..kfpops import build_op
 from ..model import RunObject
 from ..utils import get_in, logger
-from .base import RunError, RuntimeClassMode
+from .base import RunError
 from .pod import KubeResource, kube_resource_spec_to_pod_spec
 from .utils import get_k8s
 
@@ -257,7 +256,7 @@ class KubejobRuntime(KubeResource):
         offset = 0
         try:
             text, _ = db.get_builder_status(self, 0, logs=logs)
-        except RunDBError:
+        except mlrun.db.RunDBError:
             raise ValueError("function or build process not found")
 
         def print_log(text):
@@ -360,10 +359,8 @@ class KubejobRuntime(KubeResource):
 
         if self.spec.clone_target_dir:
             workdir = workdir or ""
-            if workdir.startswith("./"):
-                # TODO: use 'removeprefix' when we drop python 3.7 support
-                # workdir.removeprefix("./")
-                workdir = workdir[2:]
+            workdir = workdir.removeprefix("./")
+
             return os.path.join(self.spec.clone_target_dir, workdir)
 
         return workdir
@@ -390,24 +387,3 @@ def func_to_pod(image, runtime, extra_env, command, args, workdir):
         ]
 
     return pod_spec
-
-
-class KubeRuntimeHandler(BaseRuntimeHandler):
-    kind = "job"
-    class_modes = {RuntimeClassMode.run: "job", RuntimeClassMode.build: "build"}
-
-    @staticmethod
-    def _expect_pods_without_uid() -> bool:
-        """
-        builder pods are handled as part of this runtime handler - they are not coupled to run object, therefore they
-        don't have the uid in their labels
-        """
-        return True
-
-    @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}"

mlrun/runtimes/local.py

@@ -420,7 +420,7 @@ def exec_from_params(handler, runobj: RunObject, context: MLClientCtx, cwd=None)
     if runobj.spec.verbose:
         logger.set_logger_level("DEBUG")
 
-    # Prepare the inputs type hints (user may pass type hints as part of the inputs keys):
+    # Prepare the inputs type hints (user may pass type hints as part of the input keys):
     runobj.spec.extract_type_hints_from_inputs()
     # Read the keyword arguments to pass to the function (combining params and inputs from the run spec):
     kwargs = get_func_arg(handler, runobj, context)

mlrun/runtimes/mpijob/__init__.py

@@ -14,5 +14,5 @@
 
 # flake8: noqa  - this is until we take care of the F401 violations with respect to __all__ & sphinx
 
-from .v1 import MpiRuntimeV1, MpiV1RuntimeHandler
-from .v1alpha1 import MpiRuntimeV1Alpha1, MpiV1Alpha1RuntimeHandler
+from .v1 import MpiRuntimeV1
+from .v1alpha1 import MpiRuntimeV1Alpha1

mlrun/runtimes/mpijob/abstract.py

@@ -25,7 +25,7 @@ from mlrun.model import RunObject
 from mlrun.runtimes.kubejob import KubejobRuntime
 from mlrun.runtimes.pod import KubeResourceSpec
 from mlrun.runtimes.utils import RunError, get_k8s
-from mlrun.utils import get_in, logger
+from mlrun.utils import get_in, logger, update_in
 
 
 class MPIResourceSpec(KubeResourceSpec):
@@ -138,6 +138,15 @@ class AbstractMPIJobRuntime(KubejobRuntime, abc.ABC):
     def _get_crd_info() -> typing.Tuple[str, str, str]:
         pass
 
+    @staticmethod
+    def _get_run_completion_updates(run: dict) -> dict:
+
+        # TODO: add a 'workers' section in run objects state, each worker will update its state while
+        #  the run state will be resolved by the server.
+        # update the run object state if empty so that it won't default to 'created' state
+        update_in(run, "status.state", "running", append=False, replace=False)
+        return {}
+
     def _pretty_print_jobs(self, items: typing.List):
         print(f"{'status':10} {'name':20} {'start':21} end")
         for i in items:

mlrun/runtimes/mpijob/v1.py

@@ -13,17 +13,13 @@
 # limitations under the License.
 import typing
 from copy import deepcopy
-from datetime import datetime
 
 from kubernetes import client
-from sqlalchemy.orm import Session
 
 import mlrun.runtimes.pod
-from mlrun.api.db.base import DBInterface
 from mlrun.config import config as mlconf
 from mlrun.execution import MLClientCtx
 from mlrun.model import RunObject
-from mlrun.runtimes.base import BaseRuntimeHandler, RunStates, RuntimeClassMode
 from mlrun.runtimes.constants import MPIJobCRDVersions, MPIJobV1CleanPodPolicies
 from mlrun.runtimes.mpijob.abstract import AbstractMPIJobRuntime, MPIResourceSpec
 from mlrun.utils import get_in, update_in
@@ -318,75 +314,3 @@ class MpiRuntimeV1(AbstractMPIJobRuntime):
             MpiRuntimeV1.crd_version,
             MpiRuntimeV1.crd_plural,
         )
-
-
-class MpiV1RuntimeHandler(BaseRuntimeHandler):
-    kind = "mpijob"
-    class_modes = {
-        RuntimeClassMode.run: "mpijob",
-    }
-
-    def _resolve_crd_object_status_info(
-        self, db: DBInterface, db_session: Session, crd_object
-    ) -> typing.Tuple[bool, typing.Optional[datetime], typing.Optional[str]]:
-        """
-        https://github.com/kubeflow/mpi-operator/blob/master/pkg/apis/kubeflow/v1/types.go#L29
-        https://github.com/kubeflow/common/blob/master/pkg/apis/common/v1/types.go#L55
-        """
-        launcher_status = (
-            crd_object.get("status", {}).get("replicaStatuses", {}).get("Launcher", {})
-        )
-        # the launcher status also has running property, but it's empty for
-        # short period after the creation, so we're
-        # checking terminal state by the completion time existence
-        in_terminal_state = (
-            crd_object.get("status", {}).get("completionTime", None) is not None
-        )
-        desired_run_state = RunStates.running
-        completion_time = None
-        if in_terminal_state:
-            completion_time = datetime.fromisoformat(
-                crd_object.get("status", {})
-                .get("completionTime")
-                .replace("Z", "+00:00")
-            )
-            desired_run_state = (
-                RunStates.error
-                if launcher_status.get("failed", 0) > 0
-                else RunStates.completed
-            )
-        return in_terminal_state, completion_time, desired_run_state
-
-    @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 "mpi-job-role=launcher"
-
-    @staticmethod
-    def _get_run_completion_updates(run: dict) -> dict:
-
-        # TODO: add a 'workers' section in run objects state, each worker will update its state while
-        #  the run state will be resolved by the server.
-        # update the run object state if empty so that it won't default to 'created' state
-        update_in(run, "status.state", "running", append=False, replace=False)
-        return {}
-
-    @staticmethod
-    def _get_crd_info() -> typing.Tuple[str, str, str]:
-        return (
-            MpiRuntimeV1.crd_group,
-            MpiRuntimeV1.crd_version,
-            MpiRuntimeV1.crd_plural,
-        )

mlrun/runtimes/mpijob/v1alpha1.py

@@ -13,18 +13,14 @@
 # limitations under the License.
 import typing
 from copy import deepcopy
-from datetime import datetime
 
 from kubernetes import client
-from sqlalchemy.orm import Session
 
 import mlrun.runtimes.pod
-from mlrun.api.db.base import DBInterface
 from mlrun.config import config as mlconf
 from mlrun.execution import MLClientCtx
 from mlrun.model import RunObject
-from mlrun.runtimes.base import BaseRuntimeHandler, RunStates, RuntimeClassMode
-from mlrun.runtimes.constants import MPIJobCRDVersions, MPIJobV1Alpha1States
+from mlrun.runtimes.constants import MPIJobCRDVersions
 from mlrun.runtimes.mpijob.abstract import AbstractMPIJobRuntime
 from mlrun.utils import get_in, update_in
 
@@ -156,72 +152,3 @@ class MpiRuntimeV1Alpha1(AbstractMPIJobRuntime):
             MpiRuntimeV1Alpha1.crd_version,
             MpiRuntimeV1Alpha1.crd_plural,
         )
-
-
-class MpiV1Alpha1RuntimeHandler(BaseRuntimeHandler):
-    kind = "mpijob"
-    class_modes = {
-        RuntimeClassMode.run: "mpijob",
-    }
-
-    def _resolve_crd_object_status_info(
-        self, db: DBInterface, db_session: Session, crd_object
-    ) -> typing.Tuple[bool, typing.Optional[datetime], typing.Optional[str]]:
-        """
-        https://github.com/kubeflow/mpi-operator/blob/master/pkg/apis/kubeflow/v1alpha1/types.go#L115
-        """
-        launcher_status = crd_object.get("status", {}).get("launcherStatus", "")
-        in_terminal_state = launcher_status in MPIJobV1Alpha1States.terminal_states()
-        desired_run_state = MPIJobV1Alpha1States.mpijob_state_to_run_state(
-            launcher_status
-        )
-        completion_time = None
-        if in_terminal_state:
-            completion_time = datetime.fromisoformat(
-                crd_object.get("status", {})
-                .get("completionTime")
-                .replace("Z", "+00:00")
-            )
-            desired_run_state = {
-                "Succeeded": RunStates.completed,
-                "Failed": RunStates.error,
-            }[launcher_status]
-        return in_terminal_state, completion_time, desired_run_state
-
-    @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 "mpi_role_type=launcher"
-
-    @staticmethod
-    def _get_run_completion_updates(run: dict) -> dict:
-
-        # TODO: add a 'workers' section in run objects state, each worker will update its state while
-        #  the run state will be resolved by the server.
-        # update the run object state if empty so that it won't default to 'created' state
-        update_in(run, "status.state", "running", append=False, replace=False)
-        return {}
-
-    @staticmethod
-    def _get_crd_info() -> typing.Tuple[str, str, str]:
-        return (
-            MpiRuntimeV1Alpha1.crd_group,
-            MpiRuntimeV1Alpha1.crd_version,
-            MpiRuntimeV1Alpha1.crd_plural,
-        )
-
-    @staticmethod
-    def _get_crd_object_status(crd_object) -> str:
-        return crd_object.get("status", {}).get("launcherStatus", "")