feat: client will be mandatory in next major release; update code to support the change (#2623)

* add deprecation warning for client being mandatory

* use FutureWarning

* add client to get and add todos

* move to prepare client over dyn_client and add client in places where dyn_client is used

* update example and remove wrong return from docstring

Author: rnetser

examples/pods.py

@@ -5,7 +5,7 @@
 
 # Query to get Pods (resource) in the connected cluster with label of ``label_example=example``.
 # Returns a ``generator`` of the resource - ``pod``
-for pod in Pod.get(dyn_client=client, label_selector="label_example=example"):
+for pod in Pod.get(client=client, label_selector="label_example=example"):
     # We can also get the Node that the ``pod`` is running on:
     node = pod.node  # Return instance of Node()
     # Get pod logs

mcp_server/server.py

@@ -232,7 +232,7 @@ def list_resources(
             kwargs["limit"] = limit
 
         resources = []
-        for resource in resource_class.get(dyn_client=client, **kwargs):
+        for resource in resource_class.get(client=client, **kwargs):
             resources.append(format_resource_info(resource))
 
         return {

ocp_resources/event.py

@@ -1,3 +1,8 @@
+import warnings
+from collections.abc import Generator
+from typing import Any
+
+from kubernetes.dynamic import DynamicClient
 from simple_logger.logger import get_logger
 
 LOGGER = get_logger(name=__name__)
@@ -10,21 +15,41 @@ class Event:
 
     api_version = "v1"
 
+    # TODO: remove once `client` is mandatory
+    @staticmethod
+    def _resolve_client(
+        client: DynamicClient | None,
+        dyn_client: DynamicClient | None,
+    ) -> DynamicClient:
+        """Resolve client from new or deprecated parameter with deprecation warning."""
+        if client is None and dyn_client is not None:
+            warnings.warn(
+                "`dyn_client` arg will be renamed to `client` and will be mandatory in the next major release.",
+                FutureWarning,
+                stacklevel=3,  # Adjusted for helper function call
+            )
+
+        resolved = client or dyn_client
+        assert resolved is not None, "Either 'client' or 'dyn_client' must be provided"
+        return resolved
+
     @classmethod
     def get(
         cls,
-        dyn_client,
-        namespace=None,
-        name=None,
-        label_selector=None,
-        field_selector=None,
-        resource_version=None,
-        timeout=None,
-    ):
+        client: DynamicClient | None = None,  # TODO: make mandatory in the next major release
+        dyn_client: DynamicClient | None = None,  # TODO: remove in the next major release
+        namespace: str | None = None,
+        name: str | None = None,
+        label_selector: str | None = None,
+        field_selector: str | None = None,
+        resource_version: str | None = None,
+        timeout: int | None = None,
+    ) -> Generator[Any, None, None]:
         """
         get - retrieves K8s events.
 
         Args:
+            client (DynamicClient): K8s client
             dyn_client (DynamicClient): K8s client
             namespace (str): event namespace
             name (str): event name
@@ -46,6 +71,7 @@ def get(
               ):
                 print(event.object)
         """
+        _client = cls._resolve_client(client, dyn_client)
 
         LOGGER.info("Reading events")
         LOGGER.debug(
@@ -54,7 +80,7 @@ def get(
             f" resource_version={resource_version}, timeout={timeout}"
         )
 
-        event_listener = dyn_client.resources.get(api_version=cls.api_version, kind=cls.__name__)
+        event_listener = _client.resources.get(api_version=cls.api_version, kind=cls.__name__)
         yield from event_listener.watch(
             namespace=namespace,
             name=name,
@@ -67,19 +93,21 @@ def get(
     @classmethod
     def delete_events(
         cls,
-        dyn_client,
-        namespace=None,
-        name=None,
-        label_selector=None,
-        field_selector=None,
-        resource_version=None,
-        timeout=None,
-    ):
+        client: DynamicClient | None = None,  # TODO: make mandatory in the next major release
+        dyn_client: DynamicClient | None = None,  # TODO: remove in the next major release
+        namespace: str | None = None,
+        name: str | None = None,
+        label_selector: str | None = None,
+        field_selector: str | None = None,
+        resource_version: str | None = None,
+        timeout: int | None = None,
+    ) -> None:
         """
         delete_events - delete K8s events. For example, to cleanup events before test, in order to not get old
             events in the test, in order to prevent false positive test.
 
         Args:
+            client (DynamicClient): K8s client
             dyn_client (DynamicClient): K8s client
             namespace (str): event namespace
             name (str): event name
@@ -89,21 +117,20 @@ def delete_events(
             resource_version (str): filter events by their resource's version
             timeout (int): timeout in seconds
 
-        Returns
-            list: event objects
-
-        example: deleting all the event with a reason of "AnEventReason", from "my-namespace" namespace
-
-        def delete_events_before_test(default_client):
-          Event.delete_events(default_client, namespace=my-namespace, field_selector="reason=AnEventReason")
+        example: deleting all the events with a reason of "AnEventReason", from "my-namespace" namespace
+            def delete_events_before_test(client):
+                Event.delete_events(client=client, namespace="my-namespace", field_selector="reason=AnEventReason")
         """
+        _client = cls._resolve_client(client, dyn_client)
+
         LOGGER.info("Deleting events")
         LOGGER.debug(
             f"delete_events parameters: namespace={namespace}, name={name},"
             f" label_selector={label_selector}, field_selector='{field_selector}',"
             f" resource_version={resource_version}, timeout={timeout}"
         )
-        dyn_client.resources.get(api_version=cls.api_version, kind=cls.__name__).delete(
+
+        _client.resources.get(api_version=cls.api_version, kind=cls.__name__).delete(
             namespace=namespace,
             name=name,
             label_selector=label_selector,

ocp_resources/node_network_configuration_policy.py

@@ -111,13 +111,13 @@ def __init__(
     def _nodes(self):
         if self.node_selector:
             return list(
-                Node.get(dyn_client=self.client, name=self.node_selector[f"{self.ApiGroup.KUBERNETES_IO}/hostname"])
+                Node.get(client=self.client, name=self.node_selector[f"{self.ApiGroup.KUBERNETES_IO}/hostname"])
             )
         if self.node_selector_labels:
             node_labels = ",".join([
                 f"{label_key}={label_value}" for label_key, label_value in self.node_selector_labels.items()
             ])
-            return list(Node.get(dyn_client=self.client, label_selector=node_labels))
+            return list(Node.get(client=self.client, label_selector=node_labels))
 
     def set_interface(self, interface):
         if not self.res:
@@ -441,7 +441,7 @@ def wait_for_status_success(self):
     @property
     def nnces(self):
         nnces = []
-        for nnce in NodeNetworkConfigurationEnactment.get(dyn_client=self.client):
+        for nnce in NodeNetworkConfigurationEnactment.get(client=self.client):
             if nnce.name.endswith(f".{self.name}"):
                 nnces.append(nnce)
         return nnces