openshift-python-wrapper 4.15.20__tar.gz → 10.0.1__tar.gz

{openshift_python_wrapper-4.15.20 → openshift_python_wrapper-10.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openshift-python-wrapper
-Version: 4.15.20
+Version: 10.0.1
 Summary: Wrapper around https://github.com/kubernetes-client/python
 Home-page: https://github.com/RedHatQE/openshift-python-wrapper
 License: Apache-2.0
@@ -18,7 +18,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: colorlog (>=6.7.0,<7.0.0)
 Requires-Dist: jinja2 (>=3.1.2,<4.0.0)
-Requires-Dist: kubernetes (>=28.0.0,<29.0.0)
+Requires-Dist: kubernetes (>=29.0.0,<30.0.0)
 Requires-Dist: packaging (>=23.1,<24.0)
 Requires-Dist: python-benedict (>=0.33.0,<0.34.0)
 Requires-Dist: python-simple-logger (>=1.0.6,<2.0.0)

{openshift_python_wrapper-4.15.20 → openshift_python_wrapper-10.0.1}/ocp_resources/catalog_source.py

@@ -41,23 +41,19 @@ class CatalogSource(NamespacedResource):
                     "Passing yaml_file or all parameters 'source_type', 'image',"
                     " 'display_name' and 'publisher' is required."
                 )
-            self.res.update(
-                {
-                    "spec": {
-                        "sourceType": self.source_type,
-                        "image": self.image,
-                        "displayName": self.display_name,
-                        "publisher": self.publisher,
-                    }
+            self.res.update({
+                "spec": {
+                    "sourceType": self.source_type,
+                    "image": self.image,
+                    "displayName": self.display_name,
+                    "publisher": self.publisher,
                 }
-            )
+            })
             if self.update_strategy_registry_poll_interval:
-                self.res["spec"].update(
-                    {
-                        "updateStrategy": {
-                            "registryPoll": {
-                                "interval": self.update_strategy_registry_poll_interval,
-                            },
+                self.res["spec"].update({
+                    "updateStrategy": {
+                        "registryPoll": {
+                            "interval": self.update_strategy_registry_poll_interval,
                         },
-                    }
-                )
+                    },
+                })

openshift_python_wrapper-10.0.1/ocp_resources/controller_revision.py

@@ -0,0 +1,39 @@
+from ocp_resources.resource import NamespacedResource
+
+
+class ControllerRevision(NamespacedResource):
+    """
+    https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/controller-revision-v1/
+    """
+
+    api_group = NamespacedResource.ApiGroup.APPS
+
+    def __init__(
+        self,
+        owner_references=None,
+        revision_object=None,
+        revision=None,
+        **kwargs,
+    ):
+        """
+        Args:
+            owner_references (list, optional): List of objects depended on this object.
+            revision_object (object, optional): the Data Object representing the state.
+            revision (int64): indicates the revision of the state represented by Data.
+        """
+        super().__init__(**kwargs)
+        self.owner_references = owner_references
+        self.revision_object = revision_object
+        self.revision = revision
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            if not self.revision:
+                raise ValueError("Passing yaml_file or parameter 'revision' is required.")
+            self.res.update({"revision": self.revision})
+
+            if self.owner_references:
+                self.res.setdefault("metadata", {}).update({"ownerReference": self.owner_references})
+            if self.revision_object:
+                self.res.update({"data": self.revision_object.res})

{openshift_python_wrapper-4.15.20 → openshift_python_wrapper-10.0.1}/ocp_resources/cron_job.py

@@ -49,14 +49,12 @@ class CronJob(NamespacedResource):
         if not self.yaml_file:
             if not (self.job_template and self.schedule):
                 raise ValueError("yaml_file or parameters 'job_template' and 'schedule' are" " required.")
-            self.res.update(
-                {
-                    "spec": {
-                        "jobTemplate": self.job_template,
-                        "schedule": self.schedule,
-                    }
+            self.res.update({
+                "spec": {
+                    "jobTemplate": self.job_template,
+                    "schedule": self.schedule,
                 }
-            )
+            })
             if self.timezone:
                 self.res["spec"]["timezone"] = self.timezone
             if self.suspend:

{openshift_python_wrapper-4.15.20 → openshift_python_wrapper-10.0.1}/ocp_resources/csi_storage_capacity.py

@@ -1,10 +1,8 @@
-from ocp_resources.constants import TIMEOUT_4MINUTES
 from ocp_resources.resource import NamespacedResource
 
 
 class CSIStorageCapacity(NamespacedResource):
     """
-    CSIStorageCapacity object. API reference:
     https://kubernetes.io/docs/reference/kubernetes-api/config-and-storage-resources/csi-storage-capacity-v1/#CSIStorageCapacity
     """
 
@@ -12,24 +10,14 @@ class CSIStorageCapacity(NamespacedResource):
 
     def __init__(
         self,
-        name=None,
-        namespace=None,
-        client=None,
         capacity=None,
         maximum_volume_size=None,
         node_topology=None,
         storage_class_name=None,
-        teardown=True,
-        privileged_client=None,
-        yaml_file=None,
-        delete_timeout=TIMEOUT_4MINUTES,
         **kwargs,
     ):
         """
         Args:
-            name (str): Name of the CSIStorageCapacity resource
-            namespace (str): Namespace of CSIStorageCapacity resource
-            client: (DynamicClient): DynamicClient for api calls
             capacity (str, optional): value reported by the csi driver
             maximum_volume_size (str, optional): maximum volume size reported by csi driver
             storage_class_name (str): storage class name
@@ -37,21 +25,8 @@ class CSIStorageCapacity(NamespacedResource):
             was reported
                 Example:
                     node_topology: {'matchLabels': {'topology.hostpath.csi/node': 'c01-dbn-413-4c48b-worker-0-pmtv8'}}
-            teardown (bool): Indicates if the resource should be torn down at the end
-            privileged_client (DynamicClient): Privileged client for api calls
-            yaml_file (str): yaml file for the resource.
-            delete_timeout (int): timeout associated with delete action
         """
-        super().__init__(
-            name=name,
-            namespace=namespace,
-            client=client,
-            teardown=teardown,
-            privileged_client=privileged_client,
-            yaml_file=yaml_file,
-            delete_timeout=delete_timeout,
-            **kwargs,
-        )
+        super().__init__(**kwargs)
         self.capacity = capacity
         self.node_topology = node_topology
         self.storage_class_name = storage_class_name
@@ -62,11 +37,9 @@ class CSIStorageCapacity(NamespacedResource):
         if not self.yaml_file:
             if not self.storage_class_name:
                 raise ValueError("yaml_file or parameter 'storage_class_name' is required.")
-            self.res.update(
-                {
-                    "storageClassName": self.storage_class_name,
-                }
-            )
+            self.res.update({
+                "storageClassName": self.storage_class_name,
+            })
             if self.maximum_volume_size:
                 self.res["maximumVolumeSize"] = self.maximum_volume_size
             if self.node_topology:

openshift_python_wrapper-10.0.1/ocp_resources/data_import_cron.py

@@ -0,0 +1,95 @@
+from ocp_resources.resource import NamespacedResource
+
+
+class DataImportCron(NamespacedResource):
+    """
+    https://kubevirt.io/cdi-api-reference/main/definitions.html#_v1beta1_dataimportcron
+    """
+
+    api_group = NamespacedResource.ApiGroup.CDI_KUBEVIRT_IO
+
+    def __init__(
+        self,
+        image_stream=None,
+        url=None,
+        cert_configmap=None,
+        pull_method=None,
+        storage_class=None,
+        size=None,
+        schedule=None,
+        garbage_collect=None,
+        managed_data_source=None,
+        imports_to_keep=None,
+        bind_immediate_annotation=None,
+        **kwargs,
+    ):
+        """
+        Args:
+            garbage_collect (str, optional): whether old PVCs should be cleaned up after a new PVC is imported.
+                Options are "Outdated"/"Never".
+            imports_to_keep (int, optional): number of import PVCs to keep when garbage collecting.
+            managed_data_source(str, optional): specifies the name of the corresponding DataSource to manage.
+                DataSource has to be in the same namespace.
+            schedule (str, optional): specifies in cron format when and how often to look for new imports.
+            storage_class (str, optional): Name of the StorageClass required by the claim.
+            size (str): Size of the resources claim quantity. Format is size+size unit, for example: "5Gi".
+            url (str, optional): URL is the url of the registry source (starting with the scheme: docker, oci-archive).
+            cert_configmap (str, optional): CertConfigMap provides a reference to the Registry certs
+            image_stream (str, optional): ImageStream is the name of image stream for import
+            bind_immediate_annotation (bool, optional): when WaitForFirstConsumer is set in StorageClass and the
+                DataSource should be bound immediately.
+            pull_method (str): can be either "pod" or "node" (node docker cache based import)
+        """
+        super().__init__(**kwargs)
+        self.image_stream = image_stream
+        self.url = url
+        self.cert_configmap = cert_configmap
+        self.pull_method = pull_method
+        self.storage_class = storage_class
+        self.size = size
+        self.schedule = schedule
+        self.garbage_collect = garbage_collect
+        self.managed_data_source = managed_data_source
+        self.imports_to_keep = imports_to_keep
+        self.bind_immediate_annotation = bind_immediate_annotation
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            if self.image_stream and self.url:
+                raise ValueError("imageStream and url cannot coexist")
+            if not self.pull_method:
+                raise ValueError("Passing yaml_file or parameter 'pull_method' is required")
+            self.res.update({
+                "spec": {
+                    "template": {"spec": {"source": {"registry": {"pullMethod": self.pull_method}}}},
+                }
+            })
+            spec = self.res["spec"]["template"]["spec"]
+
+            if self.bind_immediate_annotation:
+                self.res["metadata"].setdefault("annotations", {}).update({
+                    f"{NamespacedResource.ApiGroup.CDI_KUBEVIRT_IO}/storage.bind.immediate.requested": ("true")
+                })
+            if self.image_stream:
+                spec["source"]["registry"]["imageStream"] = self.image_stream
+            if self.url:
+                spec["source"]["registry"]["url"] = self.url
+            if self.cert_configmap:
+                spec["source"]["registry"]["certConfigMap"] = self.cert_configmap
+            if self.schedule:
+                self.res["spec"]["schedule"] = self.schedule
+            if self.garbage_collect:
+                self.res["spec"]["garbageCollect"] = self.garbage_collect
+            if self.managed_data_source:
+                self.res["spec"]["managedDataSource"] = self.managed_data_source
+            if self.imports_to_keep:
+                self.res["spec"]["importsToKeep"] = self.imports_to_keep
+
+            storage = {}
+            if self.size:
+                storage["resources"] = {"requests": {"storage": self.size}}
+            if self.storage_class:
+                storage["storageClassName"] = self.storage_class
+            if storage:
+                spec["storage"] = storage

{openshift_python_wrapper-4.15.20 → openshift_python_wrapper-10.0.1}/ocp_resources/data_source.py

@@ -33,13 +33,11 @@ class DataSource(NamespacedResource):
     def to_dict(self):
         super().to_dict()
         if not self.yaml_file:
-            self.res.update(
-                {
-                    "spec": {
-                        "source": self.source,
-                    },
-                }
-            )
+            self.res.update({
+                "spec": {
+                    "source": self.source,
+                },
+            })
 
     @property
     def pvc(self):

{openshift_python_wrapper-4.15.20 → openshift_python_wrapper-10.0.1}/ocp_resources/datavolume.py

@@ -156,16 +156,14 @@ class DataVolume(NamespacedResource):
     def to_dict(self):
         super().to_dict()
         if not self.yaml_file:
-            self.res.update(
-                {
-                    "spec": {
-                        "source": {self.source: {"url": self.url}},
-                        self.api_name: {
-                            "resources": {"requests": {"storage": self.size}},
-                        },
-                    }
+            self.res.update({
+                "spec": {
+                    "source": {self.source: {"url": self.url}},
+                    self.api_name: {
+                        "resources": {"requests": {"storage": self.size}},
+                    },
                 }
-            )
+            })
             if self.access_modes:
                 self.res["spec"][self.api_name]["accessModes"] = [self.access_modes]
             if self.content_type:
@@ -183,17 +181,17 @@ class DataVolume(NamespacedResource):
             if self.source == "upload" or self.source == "blank":
                 self.res["spec"]["source"][self.source] = {}
             if self.hostpath_node:
-                self.res["metadata"].setdefault("annotations", {}).update(
-                    {f"{NamespacedResource.ApiGroup.KUBEVIRT_IO}/provisionOnNode": (self.hostpath_node)}
-                )
+                self.res["metadata"].setdefault("annotations", {}).update({
+                    f"{NamespacedResource.ApiGroup.KUBEVIRT_IO}/provisionOnNode": (self.hostpath_node)
+                })
             if self.multus_annotation:
-                self.res["metadata"].setdefault("annotations", {}).update(
-                    {f"{NamespacedResource.ApiGroup.K8S_V1_CNI_CNCF_IO}/networks": (self.multus_annotation)}
-                )
+                self.res["metadata"].setdefault("annotations", {}).update({
+                    f"{NamespacedResource.ApiGroup.K8S_V1_CNI_CNCF_IO}/networks": (self.multus_annotation)
+                })
             if self.bind_immediate_annotation:
-                self.res["metadata"].setdefault("annotations", {}).update(
-                    {f"{self.api_group}/storage.bind.immediate.requested": "true"}
-                )
+                self.res["metadata"].setdefault("annotations", {}).update({
+                    f"{self.api_group}/storage.bind.immediate.requested": "true"
+                })
             if self.source == "pvc":
                 self.res["spec"]["source"]["pvc"] = {
                     "name": self.source_pvc or "dv-source",
@@ -202,9 +200,9 @@ class DataVolume(NamespacedResource):
             if self.preallocation is not None:
                 self.res["spec"]["preallocation"] = self.preallocation
             if self.delete_after_completion:
-                self.res["metadata"].setdefault("annotations", {}).update(
-                    {f"{self.api_group}/storage.deleteAfterCompletion": (self.delete_after_completion)}
-                )
+                self.res["metadata"].setdefault("annotations", {}).update({
+                    f"{self.api_group}/storage.deleteAfterCompletion": (self.delete_after_completion)
+                })
 
     def wait_deleted(self, timeout=TIMEOUT_4MINUTES):
         """

{openshift_python_wrapper-4.15.20 → openshift_python_wrapper-10.0.1}/ocp_resources/endpoint_slice.py

@@ -56,11 +56,9 @@ class EndpointSlice(NamespacedResource):
         if not self.yaml_file:
             if not (self.address_type and self.endpoints):
                 raise ValueError("yaml_file or parameters 'address_type' and 'endpoints' are" " required.")
-            self.res.update(
-                {
-                    "addressTypes": self.address_type,
-                    "endpoints": self.endpoints,
-                }
-            )
+            self.res.update({
+                "addressTypes": self.address_type,
+                "endpoints": self.endpoints,
+            })
             if self.ports:
                 self.res["ports"] = self.ports

{openshift_python_wrapper-4.15.20 → openshift_python_wrapper-10.0.1}/ocp_resources/endpoints.py

@@ -53,11 +53,9 @@ class Endpoints(NamespacedResource):
         if not self.yaml_file:
             if not (self.addresses and self.ports):
                 raise ValueError("yaml_file or parameters 'addresses' and 'ports' are required.")
-            self.res.update(
-                {
-                    "subsets": {
-                        "addresses": self.addresses,
-                        "ports": self.ports,
-                    }
+            self.res.update({
+                "subsets": {
+                    "addresses": self.addresses,
+                    "ports": self.ports,
                 }
-            )
+            })

{openshift_python_wrapper-4.15.20 → openshift_python_wrapper-10.0.1}/ocp_resources/hook.py

@@ -42,11 +42,9 @@ class Hook(NamespacedResource, MTV):
     def to_dict(self):
         super().to_dict()
         if not self.yaml_file:
-            self.res.update(
-                {
-                    "spec": {
-                        "image": self.image,
-                        "playbook": self.playbook,
-                    },
-                }
-            )
+            self.res.update({
+                "spec": {
+                    "image": self.image,
+                    "playbook": self.playbook,
+                },
+            })

{openshift_python_wrapper-4.15.20 → openshift_python_wrapper-10.0.1}/ocp_resources/host.py

@@ -46,19 +46,17 @@ class Host(NamespacedResource, MTV):
     def to_dict(self):
         super().to_dict()
         if not self.yaml_file:
-            self.res.update(
-                {
-                    "spec": {
-                        "id": self.host_id,
-                        "ipAddress": self.ip_address,
-                        "secret": {
-                            "name": self.secret_name,
-                            "namespace": self.secret_namespace,
-                        },
-                        "provider": {
-                            "name": self.provider_name,
-                            "namespace": self.provider_namespace,
-                        },
-                    }
+            self.res.update({
+                "spec": {
+                    "id": self.host_id,
+                    "ipAddress": self.ip_address,
+                    "secret": {
+                        "name": self.secret_name,
+                        "namespace": self.secret_namespace,
+                    },
+                    "provider": {
+                        "name": self.provider_name,
+                        "namespace": self.provider_namespace,
+                    },
                 }
-            )
+            })

{openshift_python_wrapper-4.15.20 → openshift_python_wrapper-10.0.1}/ocp_resources/image_stream.py

@@ -39,11 +39,9 @@ class ImageStream(NamespacedResource):
     def to_dict(self):
         super().to_dict()
         if not self.yaml_file:
-            self.res.update(
-                {
-                    "spec": {
-                        "lookupPolicy": {"local": self.lookup_policy},
-                        "tags": self.tags,
-                    }
+            self.res.update({
+                "spec": {
+                    "lookupPolicy": {"local": self.lookup_policy},
+                    "tags": self.tags,
                 }
-            )
+            })

{openshift_python_wrapper-4.15.20 → openshift_python_wrapper-10.0.1}/ocp_resources/kube_descheduler.py

@@ -51,15 +51,13 @@ class KubeDescheduler(NamespacedResource):
     def to_dict(self):
         super().to_dict()
         if not self.yaml_file:
-            self.res.update(
-                {
-                    "spec": {
-                        "deschedulingIntervalSeconds": self.descheduling_interval,
-                        "logLevel": self.log_level,
-                        "managementState": self.management_state,
-                        "mode": self.mode,
-                        "operatorLogLevel": self.operator_log_level,
-                        "profiles": self.profiles,
-                    }
+            self.res.update({
+                "spec": {
+                    "deschedulingIntervalSeconds": self.descheduling_interval,
+                    "logLevel": self.log_level,
+                    "managementState": self.management_state,
+                    "mode": self.mode,
+                    "operatorLogLevel": self.operator_log_level,
+                    "profiles": self.profiles,
                 }
-            )
+            })

{openshift_python_wrapper-4.15.20 → openshift_python_wrapper-10.0.1}/ocp_resources/machine_set.py

@@ -178,7 +178,7 @@ class MachineSet(NamespacedResource):
         super().to_dict()
         self.res.update({"spec": {"replicas": replicas}})
 
-        self.logger.info(f"Scale machine-set from {self.desired_replicas} replicas to {replicas} replicas")
+        self.logger.info(f"Scale machine-set from {self.desired_replicas} replicas to" f" {replicas} replicas")
         self.update(resource_dict=self.res)
         if wait:
             return self.wait_for_replicas(timeout=wait_timeout, sleep=sleep)

{openshift_python_wrapper-4.15.20 → openshift_python_wrapper-10.0.1}/ocp_resources/migration.py

@@ -46,16 +46,14 @@ class Migration(NamespacedResource, MTV):
     def to_dict(self):
         super().to_dict()
         if not self.yaml_file:
-            self.res.update(
-                {
-                    "spec": {
-                        "plan": {
-                            "name": self.plan_name,
-                            "namespace": self.plan_namespace,
-                        }
+            self.res.update({
+                "spec": {
+                    "plan": {
+                        "name": self.plan_name,
+                        "namespace": self.plan_namespace,
                     }
                 }
-            )
+            })
 
             if self.cut_over:
                 self.res["spec"]["cutover"] = self.cut_over.strftime(format="%Y-%m-%dT%H:%M:%SZ")

{openshift_python_wrapper-4.15.20 → openshift_python_wrapper-10.0.1}/ocp_resources/mtv.py

@@ -112,7 +112,7 @@ class MTV:
                         return
 
         except TimeoutExpiredError:
-            self.logger.error(msg=(f"Last Status Condition of {self.kind} {self.name} was: {last_condition}"))
+            self.logger.error(msg=(f"Last Status Condition of {self.kind} {self.name} was:" f" {last_condition}"))
             raise
 
     def wait_for_condition_ready(self, wait_timeout=360):

openshift_python_wrapper-10.0.1/ocp_resources/node_health_check.py

@@ -0,0 +1,75 @@
+from ocp_resources.resource import Resource
+
+
+class NodeHealthCheck(Resource):
+    """
+    NodeHealthCheck object.
+    Reference : https://github.com/medik8s/node-healthcheck-operator
+    """
+
+    api_group = Resource.ApiGroup.REMEDIATION_MEDIK8S_IO
+
+    def __init__(
+        self,
+        selector_match_expressions=None,
+        selector_match_labels=None,
+        min_unhealthy=None,
+        unhealthy_conditions=None,
+        escalating_remediation=None,
+        remediation_template=None,
+        **kwargs,
+    ):
+        """
+        Create NodeHealthCheck object.
+
+        Args:
+            selector_match_expressions (dict, Optional if `selector_match_labels` exist): Belongs to selector object.
+                This helps in matching nodes.
+            selector_match_labels (dict, Optional if `selector_match_expressions` exist): Belongs to selector object.
+                This is a map of {key,value} pairs.
+            min_unhealthy (int, Optional): Remediation is allowed if at least "MinHealthy" nodes selected by "selector"
+            unhealthy_conditions (list, Optional): UnhealthyConditions contains a list of the conditions that determine
+                whether a node is considered unhealthy.
+            remediation_template (dict, mandatory if `escalating_remediation` is not provided) : remediation template
+                provided by an infrastructure provider.
+            escalating_remediation (list, mandatory if `remediation_template` is not provided): EscalatingRemediations
+                contain a list of ordered remediation templates with a timeout.
+                example: [{'remediationTemplate': {'apiVersion': 'self-node-remediation.medik8s.io/v1alpha1', 'kind':
+                'SelfNodeRemediationTemplate', 'namespace': 'openshift-operators',
+                'name': 'self-node-remediation-resource-deletion-template'}, 'order': 1, 'timeout': '70s'}]
+        """
+        super().__init__(
+            **kwargs,
+        )
+        self.selector_match_expressions = selector_match_expressions
+        self.selector_match_labels = selector_match_labels
+        self.min_unhealthy = min_unhealthy
+        self.unhealthy_conditions = unhealthy_conditions
+        self.escalating_remediation = escalating_remediation
+        self.remediation_template = remediation_template
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            if not (self.selector_match_expressions or self.selector_match_labels):
+                raise ValueError(
+                    "Mandatory to have Selector either selector_match_expressions or selector_match_labels"
+                )
+            if not (self.escalating_remediation or self.remediation_template):
+                raise ValueError("Mandatory to have either remediation_template or escalating_remediation")
+            if self.escalating_remediation and self.remediation_template:
+                raise ValueError("remediation_template and escalating_remediation  usage is mutual exclusive")
+            spec = self.res.setdefault("spec", {})
+            if self.escalating_remediation:
+                spec["escalatingRemediations"] = self.escalating_remediation
+            if self.remediation_template:
+                spec["remediationTemplate"] = self.remediation_template
+            if self.min_unhealthy:
+                spec["minHealthy"] = self.min_unhealthy
+            if self.unhealthy_conditions:
+                spec["unhealthyConditions"] = self.unhealthy_conditions
+            spec.setdefault("selector", {})
+            if self.selector_match_expressions:
+                spec["selector"]["matchExpressions"] = self.selector_match_expressions
+            if self.selector_match_labels:
+                spec["selector"]["matchLabels"] = self.selector_match_labels

{openshift_python_wrapper-4.15.20 → openshift_python_wrapper-10.0.1}/ocp_resources/node_network_configuration_policy.py

@@ -114,9 +114,9 @@ class NodeNetworkConfigurationPolicy(Resource):
         if self.node_selector:
             return list(Node.get(dyn_client=self.client, name=self.node_selector))
         if self.node_selector_labels:
-            node_labels = ",".join(
-                [f"{label_key}={label_value}" for label_key, label_value in self.node_selector_labels.items()]
-            )
+            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))
 
     def set_interface(self, interface):