openshift-python-wrapper 4.15.73__tar.gz → 4.16.1__tar.gz

{openshift_python_wrapper-4.15.73 → openshift_python_wrapper-4.16.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openshift-python-wrapper
-Version: 4.15.73
+Version: 4.16.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 (<30.1.1)
+Requires-Dist: kubernetes (>=30.0.0,<31.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)

openshift_python_wrapper-4.16.1/ocp_resources/application_aware_applied_cluster_resource_quota.py

@@ -0,0 +1,12 @@
+# API reference: https://github.com/kubevirt/application-aware-quota/tree/main/staging/src/kubevirt.io/application-aware-quota-api/pkg/apis/core/v1alpha1
+# TODO: update API reference when OCP doc is available
+
+from ocp_resources.resource import NamespacedResource
+
+
+class ApplicationAwareAppliedClusterResourceQuota(NamespacedResource):
+    """
+    ApplicationAwareAppliedClusterResourceQuota object.
+    """
+
+    api_group = NamespacedResource.ApiGroup.AAQ_KUBEVIRT_IO

openshift_python_wrapper-4.16.1/ocp_resources/application_aware_cluster_resource_quota.py

@@ -0,0 +1,41 @@
+# API reference: https://github.com/kubevirt/application-aware-quota/tree/main/staging/src/kubevirt.io/application-aware-quota-api/pkg/apis/core/v1alpha1
+# TODO: update API reference when OCP doc is available
+from __future__ import annotations
+from typing import Dict, Any
+
+from ocp_resources.resource import MissingRequiredArgumentError, Resource
+
+
+class ApplicationAwareClusterResourceQuota(Resource):
+    api_group = Resource.ApiGroup.AAQ_KUBEVIRT_IO
+
+    def __init__(
+        self,
+        quota: Dict[str, Any] | None = None,
+        selector: Dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Create ApplicationAwareClusterResourceQuota object.
+
+        Args:
+            quota (dict): defines the desired quota
+                example: {"hard": {"pod": 3, "requests.cpu": "500m"}}
+            selector (dict): Dict of Namespace labels/annotations to match
+                example: {"annotations": {"acrq-annotation": "true"}, "labels": {"matchLabels": {"acrq-label": "true"}}}
+        """
+        super().__init__(**kwargs)
+        self.quota = quota
+        self.selector = selector
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            if not (self.quota or self.selector):
+                raise MissingRequiredArgumentError(argument="'quota' or 'selector'")
+
+            self.res["spec"] = {}
+            _spec = self.res["spec"]
+
+            _spec["quota"] = self.quota
+            _spec["selector"] = self.selector

openshift_python_wrapper-4.16.1/ocp_resources/application_aware_resource_quota.py

@@ -0,0 +1,50 @@
+# API reference: https://github.com/kubevirt/application-aware-quota/tree/main/staging/src/kubevirt.io/application-aware-quota-api/pkg/apis/core/v1alpha1
+# TODO: update API reference when OCP doc is available
+from __future__ import annotations
+from typing import Dict, Any, List
+
+from ocp_resources.resource import MissingRequiredArgumentError, NamespacedResource
+
+
+class ApplicationAwareResourceQuota(NamespacedResource):
+    api_group = NamespacedResource.ApiGroup.AAQ_KUBEVIRT_IO
+
+    def __init__(
+        self,
+        hard: Dict[str, Any] | None = None,
+        scope_selector: Dict[str, Any] | None = None,
+        scopes: List[str] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Create ApplicationAwareResourceQuota object.
+
+        Args:
+            hard (dict): set of desired hard limits
+                example: {"pod": 3, "requests.cpu": "500m", "requests.memory/vmi": "4Gi", "requests.instances/vmi": 2}
+            scope_selector (dict, optional): collection of filters
+                example: {"matchExpressions": [{"operator": "In", "scopeName": "PriorityClass", "values": ["low"]}]}
+            scopes (list, optional): collection of filters
+                example: ["Terminating", "PriorityClass"]
+        """
+        super().__init__(**kwargs)
+        self.hard = hard
+        self.scope_selector = scope_selector
+        self.scopes = scopes
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            if not self.hard:
+                raise MissingRequiredArgumentError(argument="hard")
+
+            self.res["spec"] = {}
+            _spec = self.res["spec"]
+
+            _spec["hard"] = self.hard
+
+            if self.scope_selector:
+                _spec["scopeSelector"] = self.scope_selector
+
+            if self.scopes:
+                _spec["scopes"] = self.scopes

{openshift_python_wrapper-4.15.73 → openshift_python_wrapper-4.16.1}/ocp_resources/backup.py

@@ -1,4 +1,6 @@
 # -*- coding: utf-8 -*-
+from __future__ import annotations
+from typing import Any, List
 
 from ocp_resources.resource import NamespacedResource
 
@@ -13,11 +15,11 @@ class Backup(NamespacedResource):
 
     def __init__(
         self,
-        included_namespaces=None,
-        excluded_resources=None,
-        snapshot_move_data=False,
-        storage_location=None,
-        **kwargs,
+        included_namespaces: List[str] | None = None,
+        excluded_resources: List[str] | None = None,
+        snapshot_move_data: bool = False,
+        storage_location: str = "",
+        **kwargs: Any,
     ):
         """
         Args:
@@ -35,17 +37,21 @@ class Backup(NamespacedResource):
         self.snapshot_move_data = snapshot_move_data
         self.storage_location = storage_location
 
-    def to_dict(self):
+    def to_dict(self) -> None:
         super().to_dict()
+
         if not self.yaml_file:
-            spec_dict = {}
+            self.res["spec"] = {}
+            spec_dict = self.res["spec"]
+
             if self.included_namespaces:
-                spec_dict.update({"includedNamespaces": self.included_namespaces})
+                spec_dict["includedNamespaces"] = self.included_namespaces
+
             if self.excluded_resources:
-                spec_dict.update({"excludedResources": self.excluded_resources})
+                spec_dict["excludedResources"] = self.excluded_resources
+
             if self.snapshot_move_data:
-                spec_dict.update({"snapshotMoveData": self.snapshot_move_data})
+                spec_dict["snapshotMoveData"] = self.snapshot_move_data
+
             if self.storage_location:
-                spec_dict.update({"storageLocation": self.storage_location})
-            if spec_dict:
-                self.res.update({"spec": spec_dict})
+                spec_dict["storageLocation"] = self.storage_location

{openshift_python_wrapper-4.15.73 → openshift_python_wrapper-4.16.1}/ocp_resources/catalog_source.py

@@ -1,4 +1,4 @@
-from ocp_resources.resource import NamespacedResource
+from ocp_resources.resource import MissingRequiredArgumentError, NamespacedResource
 
 
 class CatalogSource(NamespacedResource):
@@ -33,31 +33,24 @@ class CatalogSource(NamespacedResource):
         self.publisher = publisher
         self.update_strategy_registry_poll_interval = update_strategy_registry_poll_interval
 
-    def to_dict(self):
+    def to_dict(self) -> None:
         super().to_dict()
         if not self.yaml_file:
             if not all([self.source_type, self.image, self.display_name, self.publisher]):
-                raise ValueError(
-                    "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,
-                    }
+                raise MissingRequiredArgumentError(argument="'source_type', 'image', 'display_name' and '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-4.16.1/ocp_resources/cluster_claim.py

@@ -0,0 +1,28 @@
+from typing import Any
+
+from ocp_resources.resource import NamespacedResource
+
+
+class ClusterClaim(NamespacedResource):
+    """
+    https://github.com/openshift/hive/blob/master/docs/clusterpools.md#sample-cluster-claim
+    """
+
+    api_group: str = NamespacedResource.ApiGroup.HIVE_OPENSHIFT_IO
+
+    def __init__(
+        self,
+        cluster_pool_name: str = "",
+        **kwargs: Any,
+    ) -> None:
+        """
+        Args:
+            cluster_pool_name (str): ClusterPool name to claim the cluster from
+        """
+        super().__init__(**kwargs)
+        self.cluster_pool_name = cluster_pool_name
+
+    def to_dict(self) -> None:
+        super().to_dict()
+        if not self.yaml_file and self.cluster_pool_name:
+            self.res.setdefault("spec", {})["clusterPoolName"] = self.cluster_pool_name

openshift_python_wrapper-4.16.1/ocp_resources/cluster_deployment.py

@@ -0,0 +1,55 @@
+from typing import Any, Dict
+from ocp_resources.resource import NamespacedResource
+
+
+class ClusterDeployment(NamespacedResource):
+    """
+    https://github.com/openshift/hive/blob/master/docs/using-hive.md#clusterdeployment
+    """
+
+    api_group: str = NamespacedResource.ApiGroup.HIVE_OPENSHIFT_IO
+
+    def __init__(
+        self,
+        base_domain: str = "",
+        cluster_name: str = "",
+        platform: Dict[str, Any] | None = None,
+        provisioning: Dict[str, Any] | None = None,
+        pull_secret_ref_name: str = "",
+        **kwargs: Any,
+    ) -> None:
+        """
+        Args:
+            base_domain (str): ClusterDeployment base domain
+            cluster_name (str): ClusterDeployment cluster name
+            platform (dict): ClusterDeployment platform
+            provisioning (dict): ClusterDeployment provisioning
+            pull_secret_ref_name (str): ClusterDeployment pull secret name
+        """
+        super().__init__(**kwargs)
+        self.base_domain = base_domain
+        self.cluster_name = cluster_name
+        self.platform = platform
+        self.provisioning = provisioning
+        self.pull_secret_ref_name = pull_secret_ref_name
+
+    def to_dict(self) -> None:
+        super().to_dict()
+        if not self.yaml_file:
+            self.res["spec"] = {}
+            _spec = self.res["spec"]
+
+            if self.base_domain:
+                _spec["baseDomain"] = self.base_domain
+
+            if self.cluster_name:
+                _spec["clusterName"] = self.cluster_name
+
+            if self.platform:
+                _spec["platform"] = self.platform
+
+            if self.provisioning:
+                _spec["provisioning"] = self.provisioning
+
+            if self.pull_secret_ref_name:
+                _spec["pullSecretRef"] = {"name": self.pull_secret_ref_name}

openshift_python_wrapper-4.16.1/ocp_resources/cluster_pool.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+from typing import Any, Dict
+from ocp_resources.resource import NamespacedResource
+
+
+class ClusterPool(NamespacedResource):
+    """
+    https://github.com/openshift/hive/blob/master/docs/clusterpools.md#supported-cloud-platforms
+    """
+
+    api_group: str = NamespacedResource.ApiGroup.HIVE_OPENSHIFT_IO
+
+    def __init__(
+        self,
+        base_domain: str = "",
+        image_set_ref_name: str = "",
+        platform: Dict[str, Any] | None = None,
+        pull_secret_ref_name: str = "",
+        running_count: int | None = None,
+        size: int | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Args:
+            base_domain (str): ClusterPool base domain
+            image_set_ref_name (str): ClusterPool image set name
+            platform (dict): ClusterPool platform
+            pull_secret_ref_name (str): ClusterPool pull secret name
+            running_count (int): ClusterPool running count
+            size (int): ClusterPool size
+        """
+        super().__init__(**kwargs)
+        self.base_domain = base_domain
+        self.image_set_ref_name = image_set_ref_name
+        self.platform = platform
+        self.pull_secret_ref_name = pull_secret_ref_name
+        self.running_count = running_count
+        self.size = size
+
+    def to_dict(self) -> None:
+        super().to_dict()
+        if not self.yaml_file:
+            self.res["spec"] = {}
+            _spec = self.res["spec"]
+            if self.base_domain:
+                _spec["baseDomain"] = self.base_domain
+
+            if self.image_set_ref_name:
+                _spec["imageSetRef"] = {"name": self.image_set_ref_name}
+
+            if self.platform:
+                _spec["platform"] = self.platform
+
+            if self.pull_secret_ref_name:
+                _spec["pullSecretRef"] = {"name": self.pull_secret_ref_name}
+
+            if self.running_count:
+                _spec["runningCount"] = self.running_count
+
+            if self.size:
+                _spec["size"] = self.size

{openshift_python_wrapper-4.15.73 → openshift_python_wrapper-4.16.1}/ocp_resources/cluster_role.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-from ocp_resources.resource import Resource
+from ocp_resources.resource import MissingRequiredArgumentError, Resource
 
 
 class ClusterRole(Resource):
@@ -20,9 +20,9 @@ class ClusterRole(Resource):
         super().__init__(**kwargs)
         self.rules = rules
 
-    def to_dict(self):
+    def to_dict(self) -> None:
         super().to_dict()
         if not self.yaml_file:
             if not self.rules:
-                raise ValueError("must send rules or yaml_file")
+                raise MissingRequiredArgumentError(argument="rules")
             self.res["rules"] = self.rules

{openshift_python_wrapper-4.15.73 → openshift_python_wrapper-4.16.1}/ocp_resources/cluster_role_binding.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 from ocp_resources.cluster_role import ClusterRole
-from ocp_resources.resource import Resource
+from ocp_resources.resource import MissingRequiredArgumentError, Resource
 
 
 class ClusterRoleBinding(Resource):
@@ -26,11 +26,12 @@ class ClusterRoleBinding(Resource):
         self.cluster_role = cluster_role
         self.subjects = subjects
 
-    def to_dict(self):
+    def to_dict(self) -> None:
         super().to_dict()
         if not self.yaml_file:
             if not self.cluster_role:
-                raise ValueError("Passing yaml_file or parameter 'cluster_role' is required.")
+                raise MissingRequiredArgumentError(argument="cluster_role")
+
             self.res.setdefault("roleRef", {})
             self.res["roleRef"] = {
                 "apiGroup": self.api_group,

{openshift_python_wrapper-4.15.73 → openshift_python_wrapper-4.16.1}/ocp_resources/configmap.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+from typing import Any, Dict
+
 from ocp_resources.resource import NamespacedResource
 
 
@@ -10,17 +13,19 @@ class ConfigMap(NamespacedResource):
 
     def __init__(
         self,
-        data=None,
-        **kwargs,
+        data: Dict[str, Any] | None = None,
+        **kwargs: Any,
     ):
         """
         Args:
             data (dict, optional): key-value configuration pairs.
         """
         super().__init__(**kwargs)
+
         self.data = data
 
-    def to_dict(self):
+    def to_dict(self) -> None:
         super().to_dict()
+
         if not self.yaml_file and self.data:
-            self.res.setdefault("data", {}).update(self.data)
+            self.res["data"] = self.data

{openshift_python_wrapper-4.15.73 → openshift_python_wrapper-4.16.1}/ocp_resources/constants.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+from typing import Dict, List
 from kubernetes.dynamic.exceptions import (
     ForbiddenError,
     InternalServerError,
@@ -6,7 +9,7 @@ from kubernetes.dynamic.exceptions import (
 )
 from urllib3.exceptions import MaxRetryError, ProtocolError
 
-DEFAULT_CLUSTER_RETRY_EXCEPTIONS = {
+DEFAULT_CLUSTER_RETRY_EXCEPTIONS: Dict[type[Exception], List[str]] = {
     MaxRetryError: [],
     ConnectionAbortedError: [],
     ConnectionResetError: [],
@@ -19,11 +22,11 @@ DEFAULT_CLUSTER_RETRY_EXCEPTIONS = {
     ServerTimeoutError: [],
     ForbiddenError: ["context deadline exceeded"],
 }
-PROTOCOL_ERROR_EXCEPTION_DICT = {ProtocolError: []}
-NOT_FOUND_ERROR_EXCEPTION_DICT = {NotFoundError: []}
+PROTOCOL_ERROR_EXCEPTION_DICT: Dict[type[Exception], List[str]] = {ProtocolError: []}
+NOT_FOUND_ERROR_EXCEPTION_DICT: Dict[type[Exception], List[str]] = {NotFoundError: []}
 
-TIMEOUT_10SEC = 10
-TIMEOUT_1MINUTE = 60
-TIMEOUT_2MINUTES = 2 * 60
-TIMEOUT_4MINUTES = 4 * 60
-TIMEOUT_10MINUTES = 10 * 60
+TIMEOUT_10SEC: int = 10
+TIMEOUT_1MINUTE: int = 60
+TIMEOUT_2MINUTES: int = 2 * 60
+TIMEOUT_4MINUTES: int = 4 * 60
+TIMEOUT_10MINUTES: int = 10 * 60

openshift_python_wrapper-4.16.1/ocp_resources/controller_revision.py

@@ -0,0 +1,39 @@
+from ocp_resources.resource import MissingRequiredArgumentError, 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) -> None:
+        super().to_dict()
+        if not self.yaml_file:
+            if not self.revision:
+                raise MissingRequiredArgumentError(argument="revision")
+            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.73 → openshift_python_wrapper-4.16.1}/ocp_resources/cron_job.py

@@ -1,4 +1,4 @@
-from ocp_resources.resource import NamespacedResource
+from ocp_resources.resource import MissingRequiredArgumentError, NamespacedResource
 
 
 class CronJob(NamespacedResource):
@@ -44,19 +44,17 @@ class CronJob(NamespacedResource):
         self.failed_jobs_history_limit = failed_jobs_history_limit
         self.starting_deadline_seconds = starting_deadline_seconds
 
-    def to_dict(self):
+    def to_dict(self) -> None:
         super().to_dict()
         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,
-                    }
+                raise MissingRequiredArgumentError(argument="'job_template' and '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.73 → openshift_python_wrapper-4.16.1}/ocp_resources/csi_storage_capacity.py

@@ -1,10 +1,8 @@
-from ocp_resources.constants import TIMEOUT_4MINUTES
-from ocp_resources.resource import NamespacedResource
+from ocp_resources.resource import MissingRequiredArgumentError, 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,36 +25,21 @@ 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
         self.maximum_volume_size = maximum_volume_size
 
-    def to_dict(self):
+    def to_dict(self) -> None:
         super().to_dict()
         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,
-                }
-            )
+                raise MissingRequiredArgumentError(argument="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: