apache-airflow-providers-cncf-kubernetes 3.1.0__py3-none-any.whl → 10.10.0rc1__py3-none-any.whl

airflow/providers/cncf/kubernetes/__init__.py

@@ -1,4 +1,3 @@
-#
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
 # distributed with this work for additional information
@@ -15,30 +14,26 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-import sys
-
-if sys.version_info < (3, 7):
-    # This is needed because the Python Kubernetes client >= 12.0 contains a logging object, meaning that
-    # v1.Pod et al. are not pickleable on Python 3.6.
-
-    # Python 3.7 added this via https://bugs.python.org/issue30520 in 2017 -- but Python 3.6 doesn't have this
-    # method.
+#
+# NOTE! THIS FILE IS AUTOMATICALLY GENERATED AND WILL BE
+# OVERWRITTEN WHEN PREPARING DOCUMENTATION FOR THE PACKAGES.
+#
+# IF YOU WANT TO MODIFY THIS FILE, YOU SHOULD MODIFY THE TEMPLATE
+# `PROVIDER__INIT__PY_TEMPLATE.py.jinja2` IN the `dev/breeze/src/airflow_breeze/templates` DIRECTORY
+#
+from __future__ import annotations
 
-    # This is duplicated/backported from airflow.logging_config in 2.2, but by having it here as well it means
-    # that we can update the version used in this provider and have it work for older versions
-    import copyreg
-    import logging
+import packaging.version
 
-    def _reduce_Logger(logger):
-        if logging.getLogger(logger.name) is not logger:
-            import pickle
+from airflow import __version__ as airflow_version
 
-            raise pickle.PicklingError('logger cannot be pickled')
-        return logging.getLogger, (logger.name,)
+__all__ = ["__version__"]
 
-    def _reduce_RootLogger(logger):
-        return logging.getLogger, ()
+__version__ = "10.10.0"
 
-    if logging.Logger not in copyreg.dispatch_table:
-        copyreg.pickle(logging.Logger, _reduce_Logger)
-        copyreg.pickle(logging.RootLogger, _reduce_RootLogger)
+if packaging.version.parse(packaging.version.parse(airflow_version).base_version) < packaging.version.parse(
+    "2.10.0"
+):
+    raise RuntimeError(
+        f"The package `apache-airflow-providers-cncf-kubernetes:{__version__}` needs Apache Airflow 2.10.0+"
+    )

airflow/providers/cncf/kubernetes/backcompat/__init__.py

@@ -14,3 +14,20 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
+
+from __future__ import annotations
+
+
+def get_logical_date_key() -> str:
+    """
+    Get the key for execution/logical date for the appropriate Airflow version.
+
+    This is done by detecting the CLI argument name. There are various ways to
+    do this, but the CLI key name has a very small import footprint (especially
+    compared to importing ORM models).
+    """
+    from airflow.cli import cli_config
+
+    if hasattr(cli_config, "ARG_LOGICAL_DATE"):
+        return "logical_date"
+    return "execution_date"

airflow/providers/cncf/kubernetes/backcompat/backwards_compat_converters.py

@@ -14,9 +14,9 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-"""Executes task in a Kubernetes POD"""
+"""Executes task in a Kubernetes POD."""
 
-from typing import List
+from __future__ import annotations
 
 from kubernetes.client import ApiClient, models as k8s
 
@@ -27,123 +27,105 @@ def _convert_kube_model_object(obj, new_class):
     convert_op = getattr(obj, "to_k8s_client_obj", None)
     if callable(convert_op):
         return obj.to_k8s_client_obj()
-    elif isinstance(obj, new_class):
+    if isinstance(obj, new_class):
         return obj
-    else:
-        raise AirflowException(f"Expected {new_class}, got {type(obj)}")
+    raise AirflowException(f"Expected {new_class}, got {type(obj)}")
 
 
 def _convert_from_dict(obj, new_class):
     if isinstance(obj, new_class):
         return obj
-    elif isinstance(obj, dict):
+    if isinstance(obj, dict):
         api_client = ApiClient()
         return api_client._ApiClient__deserialize_model(obj, new_class)
-    else:
-        raise AirflowException(f"Expected dict or {new_class}, got {type(obj)}")
+    raise AirflowException(f"Expected dict or {new_class}, got {type(obj)}")
 
 
 def convert_volume(volume) -> k8s.V1Volume:
     """
-    Converts an airflow Volume object into a k8s.V1Volume
+    Convert an airflow Volume object into a k8s.V1Volume.
 
     :param volume:
-    :return: k8s.V1Volume
     """
     return _convert_kube_model_object(volume, k8s.V1Volume)
 
 
 def convert_volume_mount(volume_mount) -> k8s.V1VolumeMount:
     """
-    Converts an airflow VolumeMount object into a k8s.V1VolumeMount
+    Convert an airflow VolumeMount object into a k8s.V1VolumeMount.
 
     :param volume_mount:
-    :return: k8s.V1VolumeMount
     """
     return _convert_kube_model_object(volume_mount, k8s.V1VolumeMount)
 
 
-def convert_resources(resources) -> k8s.V1ResourceRequirements:
+def convert_port(port) -> k8s.V1ContainerPort:
     """
-    Converts an airflow Resources object into a k8s.V1ResourceRequirements
+    Convert an airflow Port object into a k8s.V1ContainerPort.
 
-    :param resources:
-    :return: k8s.V1ResourceRequirements
+    :param port:
     """
-    if isinstance(resources, dict):
-        from airflow.providers.cncf.kubernetes.backcompat.pod import Resources
-
-        resources = Resources(**resources)
-    return _convert_kube_model_object(resources, k8s.V1ResourceRequirements)
+    return _convert_kube_model_object(port, k8s.V1ContainerPort)
 
 
-def convert_port(port) -> k8s.V1ContainerPort:
+def convert_env_vars(env_vars: list[k8s.V1EnvVar] | dict[str, str]) -> list[k8s.V1EnvVar]:
     """
-    Converts an airflow Port object into a k8s.V1ContainerPort
+    Coerce env var collection for kubernetes.
 
-    :param port:
-    :return: k8s.V1ContainerPort
+    If the collection is a str-str dict, convert it into a list of ``V1EnvVar`` variables.
     """
-    return _convert_kube_model_object(port, k8s.V1ContainerPort)
+    if isinstance(env_vars, dict):
+        return [k8s.V1EnvVar(name=k, value=v) for k, v in env_vars.items()]
+    return env_vars
 
 
-def convert_env_vars(env_vars) -> List[k8s.V1EnvVar]:
+def convert_env_vars_or_raise_error(env_vars: list[k8s.V1EnvVar] | dict[str, str]) -> list[k8s.V1EnvVar]:
     """
-    Converts a dictionary into a list of env_vars
+    Separate function to convert env var collection for kubernetes and then raise an error if it is still the wrong type.
 
-    :param env_vars:
-    :return:
+    This is used after the template strings have been rendered.
     """
-    if isinstance(env_vars, dict):
-        res = []
-        for k, v in env_vars.items():
-            res.append(k8s.V1EnvVar(name=k, value=v))
-        return res
-    elif isinstance(env_vars, list):
+    env_vars = convert_env_vars(env_vars)
+    if isinstance(env_vars, list):
         return env_vars
-    else:
-        raise AirflowException(f"Expected dict or list, got {type(env_vars)}")
+    raise AirflowException(f"Expected dict or list, got {type(env_vars)}")
 
 
 def convert_pod_runtime_info_env(pod_runtime_info_envs) -> k8s.V1EnvVar:
     """
-    Converts a PodRuntimeInfoEnv into an k8s.V1EnvVar
+    Convert a PodRuntimeInfoEnv into an k8s.V1EnvVar.
 
     :param pod_runtime_info_envs:
-    :return:
     """
     return _convert_kube_model_object(pod_runtime_info_envs, k8s.V1EnvVar)
 
 
-def convert_image_pull_secrets(image_pull_secrets) -> List[k8s.V1LocalObjectReference]:
+def convert_image_pull_secrets(image_pull_secrets) -> list[k8s.V1LocalObjectReference]:
     """
-    Converts a PodRuntimeInfoEnv into an k8s.V1EnvVar
+    Convert a PodRuntimeInfoEnv into an k8s.V1EnvVar.
 
     :param image_pull_secrets:
-    :return:
     """
     if isinstance(image_pull_secrets, str):
         secrets = image_pull_secrets.split(",")
         return [k8s.V1LocalObjectReference(name=secret) for secret in secrets]
-    else:
-        return image_pull_secrets
+    return image_pull_secrets
 
 
 def convert_configmap(configmaps) -> k8s.V1EnvFromSource:
     """
-    Converts a str into an k8s.V1EnvFromSource
+    Convert a str into an k8s.V1EnvFromSource.
 
     :param configmaps:
-    :return:
     """
     return k8s.V1EnvFromSource(config_map_ref=k8s.V1ConfigMapEnvSource(name=configmaps))
 
 
 def convert_affinity(affinity) -> k8s.V1Affinity:
-    """Converts a dict into an k8s.V1Affinity"""
+    """Convert a dict into an k8s.V1Affinity."""
     return _convert_from_dict(affinity, k8s.V1Affinity)
 
 
 def convert_toleration(toleration) -> k8s.V1Toleration:
-    """Converts a dict into an k8s.V1Toleration"""
+    """Convert a dict into an k8s.V1Toleration."""
     return _convert_from_dict(toleration, k8s.V1Toleration)

airflow/providers/cncf/kubernetes/callbacks.py

@@ -0,0 +1,200 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, 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.
+from __future__ import annotations
+
+from enum import Enum
+from typing import TYPE_CHECKING, TypeAlias
+
+import kubernetes.client as k8s
+import kubernetes_asyncio.client as async_k8s
+
+if TYPE_CHECKING:
+    from airflow.providers.cncf.kubernetes.operators.pod import KubernetesPodOperator
+    from airflow.utils.context import Context
+
+client_type: TypeAlias = k8s.CoreV1Api | async_k8s.CoreV1Api
+
+
+class ExecutionMode(str, Enum):
+    """Enum class for execution mode."""
+
+    SYNC = "sync"
+    ASYNC = "async"
+
+
+class KubernetesPodOperatorCallback:
+    """
+    `KubernetesPodOperator` callbacks methods.
+
+    Currently, the callbacks methods are not called in the async mode, this support will be added
+    in the future.
+    """
+
+    @staticmethod
+    def on_sync_client_creation(*, client: k8s.CoreV1Api, operator: KubernetesPodOperator, **kwargs) -> None:
+        """
+        Invoke this callback after creating the sync client.
+
+        :param client: the created `kubernetes.client.CoreV1Api` client.
+        """
+        pass
+
+    @staticmethod
+    def on_pod_manifest_created(
+        *,
+        pod_request: k8s.V1Pod,
+        client: client_type,
+        mode: str,
+        operator: KubernetesPodOperator,
+        context: Context,
+        **kwargs,
+    ) -> None:
+        """
+        Invoke this callback after KPO creates the V1Pod manifest but before the pod is created.
+
+        :param pod_request: the kubernetes pod manifest
+        :param client: the Kubernetes client that can be used in the callback.
+        :param mode: the current execution mode, it's one of (`sync`, `async`).
+        """
+        pass
+
+    @staticmethod
+    def on_pod_creation(
+        *,
+        pod: k8s.V1Pod,
+        client: client_type,
+        mode: str,
+        operator: KubernetesPodOperator,
+        context: Context,
+        **kwargs,
+    ) -> None:
+        """
+        Invoke this callback after creating the pod.
+
+        :param pod: the created pod.
+        :param client: the Kubernetes client that can be used in the callback.
+        :param mode: the current execution mode, it's one of (`sync`, `async`).
+        """
+        pass
+
+    @staticmethod
+    def on_pod_starting(
+        *,
+        pod: k8s.V1Pod,
+        client: client_type,
+        mode: str,
+        operator: KubernetesPodOperator,
+        context: Context,
+        **kwargs,
+    ) -> None:
+        """
+        Invoke this callback when the pod starts.
+
+        :param pod: the started pod.
+        :param client: the Kubernetes client that can be used in the callback.
+        :param mode: the current execution mode, it's one of (`sync`, `async`).
+        """
+        pass
+
+    @staticmethod
+    def on_pod_completion(
+        *,
+        pod: k8s.V1Pod,
+        client: client_type,
+        mode: str,
+        operator: KubernetesPodOperator,
+        context: Context,
+        **kwargs,
+    ) -> None:
+        """
+        Invoke this callback when the pod completes.
+
+        :param pod: the completed pod.
+        :param client: the Kubernetes client that can be used in the callback.
+        :param mode: the current execution mode, it's one of (`sync`, `async`).
+        """
+        pass
+
+    @staticmethod
+    def on_pod_teardown(
+        *,
+        pod: k8s.V1Pod,
+        client: client_type,
+        mode: str,
+        operator: KubernetesPodOperator,
+        context: Context,
+        **kwargs,
+    ) -> None:
+        """
+        Invoke this callback after all pod completion callbacks but before the pod is deleted.
+
+        :param pod: the completed pod.
+        :param client: the Kubernetes client that can be used in the callback.
+        :param mode: the current execution mode, it's one of (`sync`, `async`).
+        """
+        pass
+
+    @staticmethod
+    def on_pod_cleanup(
+        *,
+        pod: k8s.V1Pod,
+        client: client_type,
+        mode: str,
+        operator: KubernetesPodOperator,
+        context: Context,
+        **kwargs,
+    ):
+        """
+        Invoke this callback after cleaning/deleting the pod.
+
+        :param pod: the completed pod.
+        :param client: the Kubernetes client that can be used in the callback.
+        :param mode: the current execution mode, it's one of (`sync`, `async`).
+        """
+        pass
+
+    @staticmethod
+    def on_operator_resuming(
+        *,
+        pod: k8s.V1Pod,
+        event: dict,
+        client: client_type,
+        mode: str,
+        operator: KubernetesPodOperator,
+        context: Context,
+        **kwargs,
+    ) -> None:
+        """
+        Invoke this callback when resuming the `KubernetesPodOperator` from deferred state.
+
+        :param pod: the current state of the pod.
+        :param event: the returned event from the Trigger.
+        :param client: the Kubernetes client that can be used in the callback.
+        :param mode: the current execution mode, it's one of (`sync`, `async`).
+        """
+        pass
+
+    @staticmethod
+    def progress_callback(*, line: str, client: client_type, mode: str, **kwargs) -> None:
+        """
+        Invoke this callback to process pod container logs.
+
+        :param line: the read line of log.
+        :param client: the Kubernetes client that can be used in the callback.
+        :param mode: the current execution mode, it's one of (`sync`, `async`).
+        """
+        pass

airflow/providers/cncf/kubernetes/cli/__init__.py

@@ -0,0 +1,16 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, 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.

airflow/providers/cncf/kubernetes/cli/kubernetes_command.py

@@ -0,0 +1,195 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, 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.
+"""Kubernetes sub-commands."""
+
+from __future__ import annotations
+
+import os
+import sys
+from datetime import datetime, timedelta
+
+from kubernetes import client
+from kubernetes.client.api_client import ApiClient
+from kubernetes.client.rest import ApiException
+
+from airflow.models import DagModel, DagRun, TaskInstance
+from airflow.providers.cncf.kubernetes import pod_generator
+from airflow.providers.cncf.kubernetes.executors.kubernetes_executor import KubeConfig
+from airflow.providers.cncf.kubernetes.kube_client import get_kube_client
+from airflow.providers.cncf.kubernetes.kubernetes_helper_functions import create_unique_id
+from airflow.providers.cncf.kubernetes.pod_generator import PodGenerator, generate_pod_command_args
+from airflow.providers.cncf.kubernetes.version_compat import AIRFLOW_V_3_0_PLUS, AIRFLOW_V_3_1_PLUS
+from airflow.utils import cli as cli_utils, yaml
+from airflow.utils.providers_configuration_loader import providers_configuration_loaded
+from airflow.utils.types import DagRunType
+
+if AIRFLOW_V_3_1_PLUS:
+    from airflow.utils.cli import get_bagged_dag
+else:
+    from airflow.utils.cli import get_dag as get_bagged_dag  # type: ignore[attr-defined,no-redef]
+
+
+@cli_utils.action_cli
+@providers_configuration_loaded
+def generate_pod_yaml(args):
+    """Generate yaml files for each task in the DAG. Used for testing output of KubernetesExecutor."""
+    logical_date = args.logical_date if AIRFLOW_V_3_0_PLUS else args.execution_date
+    if AIRFLOW_V_3_0_PLUS:
+        dag = get_bagged_dag(bundle_names=args.bundle_name, dag_id=args.dag_id)
+    else:
+        dag = get_bagged_dag(subdir=args.subdir, dag_id=args.dag_id)
+    yaml_output_path = args.output_path
+
+    dm = DagModel(dag_id=dag.dag_id)
+
+    if AIRFLOW_V_3_0_PLUS:
+        dr = DagRun(dag.dag_id, logical_date=logical_date)
+        dr.run_id = DagRun.generate_run_id(
+            run_type=DagRunType.MANUAL, logical_date=logical_date, run_after=logical_date
+        )
+        dm.bundle_name = args.bundle_name if args.bundle_name else "default"
+        dm.relative_fileloc = dag.relative_fileloc
+    else:
+        dr = DagRun(dag.dag_id, execution_date=logical_date)
+        dr.run_id = DagRun.generate_run_id(run_type=DagRunType.MANUAL, execution_date=logical_date)
+
+    kube_config = KubeConfig()
+
+    for task in dag.tasks:
+        if AIRFLOW_V_3_0_PLUS:
+            from uuid6 import uuid7
+
+            ti = TaskInstance(task, run_id=dr.run_id, dag_version_id=uuid7())
+        else:
+            ti = TaskInstance(task, run_id=dr.run_id)
+        ti.dag_run = dr
+        ti.dag_model = dm
+
+        command_args = generate_pod_command_args(ti)
+        pod = PodGenerator.construct_pod(
+            dag_id=args.dag_id,
+            task_id=ti.task_id,
+            pod_id=create_unique_id(args.dag_id, ti.task_id),
+            try_number=ti.try_number,
+            kube_image=kube_config.kube_image,
+            date=ti.logical_date if AIRFLOW_V_3_0_PLUS else ti.execution_date,
+            args=command_args,
+            pod_override_object=PodGenerator.from_obj(ti.executor_config),
+            scheduler_job_id="worker-config",
+            namespace=kube_config.executor_namespace,
+            base_worker_pod=PodGenerator.deserialize_model_file(kube_config.pod_template_file),
+            with_mutation_hook=True,
+        )
+        api_client = ApiClient()
+        date_string = pod_generator.datetime_to_label_safe_datestring(logical_date)
+        yaml_file_name = f"{args.dag_id}_{ti.task_id}_{date_string}.yml"
+        os.makedirs(os.path.dirname(yaml_output_path + "/airflow_yaml_output/"), exist_ok=True)
+        with open(yaml_output_path + "/airflow_yaml_output/" + yaml_file_name, "w") as output:
+            sanitized_pod = api_client.sanitize_for_serialization(pod)
+            output.write(yaml.dump(sanitized_pod))
+    print(f"YAML output can be found at {yaml_output_path}/airflow_yaml_output/")
+
+
+@cli_utils.action_cli(check_db=False)
+@providers_configuration_loaded
+def cleanup_pods(args):
+    """Clean up k8s pods in evicted/failed/succeeded/pending states."""
+    namespace = args.namespace
+
+    min_pending_minutes = args.min_pending_minutes
+    # protect newly created pods from deletion
+    if min_pending_minutes < 5:
+        min_pending_minutes = 5
+
+    # https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/
+    # All Containers in the Pod have terminated in success, and will not be restarted.
+    pod_succeeded = "succeeded"
+
+    # The Pod has been accepted by the Kubernetes cluster,
+    # but one or more of the containers has not been set up and made ready to run.
+    pod_pending = "pending"
+
+    # All Containers in the Pod have terminated, and at least one Container has terminated in failure.
+    # That is, the Container either exited with non-zero status or was terminated by the system.
+    pod_failed = "failed"
+
+    # https://kubernetes.io/docs/tasks/administer-cluster/out-of-resource/
+    pod_reason_evicted = "evicted"
+    # If pod is failed and restartPolicy is:
+    # * Always: Restart Container; Pod phase stays Running.
+    # * OnFailure: Restart Container; Pod phase stays Running.
+    # * Never: Pod phase becomes Failed.
+    pod_restart_policy_never = "never"
+
+    print("Loading Kubernetes configuration")
+    kube_client = get_kube_client()
+    print(f"Listing pods in namespace {namespace}")
+    airflow_pod_labels = [
+        "dag_id",
+        "task_id",
+        "try_number",
+        "airflow_version",
+    ]
+    list_kwargs = {"namespace": namespace, "limit": 500, "label_selector": ",".join(airflow_pod_labels)}
+
+    while True:
+        pod_list = kube_client.list_namespaced_pod(**list_kwargs)
+        for pod in pod_list.items:
+            pod_name = pod.metadata.name
+            print(f"Inspecting pod {pod_name}")
+            pod_phase = pod.status.phase.lower()
+            pod_reason = pod.status.reason.lower() if pod.status.reason else ""
+            pod_restart_policy = pod.spec.restart_policy.lower()
+            current_time = datetime.now(pod.metadata.creation_timestamp.tzinfo)
+
+            if (
+                pod_phase == pod_succeeded
+                or (pod_phase == pod_failed and pod_restart_policy == pod_restart_policy_never)
+                or (pod_reason == pod_reason_evicted)
+                or (
+                    pod_phase == pod_pending
+                    and current_time - pod.metadata.creation_timestamp
+                    > timedelta(minutes=min_pending_minutes)
+                )
+            ):
+                print(
+                    f'Deleting pod "{pod_name}" phase "{pod_phase}" and reason "{pod_reason}", '
+                    f'restart policy "{pod_restart_policy}"'
+                )
+                try:
+                    _delete_pod(pod.metadata.name, namespace)
+                except ApiException as e:
+                    print(f"Can't remove POD: {e}", file=sys.stderr)
+            else:
+                print(f"No action taken on pod {pod_name}")
+        continue_token = pod_list.metadata._continue
+        if not continue_token:
+            break
+        list_kwargs["_continue"] = continue_token
+
+
+def _delete_pod(name, namespace):
+    """
+    Delete a namespaced pod.
+
+    Helper Function for cleanup_pods.
+    """
+    kube_client = get_kube_client()
+    delete_options = client.V1DeleteOptions()
+    print(f'Deleting POD "{name}" from "{namespace}" namespace')
+    api_response = kube_client.delete_namespaced_pod(name=name, namespace=namespace, body=delete_options)
+    print(api_response)