openshift-python-wrapper 10.0.100__tar.gz → 10.0.102__tar.gz

{openshift_python_wrapper-10.0.100 → openshift_python_wrapper-10.0.102}/.pre-commit-config.yaml

@@ -39,23 +39,23 @@ repos:
           ]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.7.0
+    rev: v0.7.1
     hooks:
       - id: ruff
       - id: ruff-format
 
   - repo: https://github.com/renovatebot/pre-commit-hooks
-    rev: 38.128.6
+    rev: 38.133.1
     hooks:
       - id: renovate-config-validator
 
   - repo: https://github.com/gitleaks/gitleaks
-    rev: v8.21.1
+    rev: v8.21.2
     hooks:
       - id: gitleaks
 
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.12.1
+    rev: v1.13.0
     hooks:
       - id: mypy
         exclude: ^(tests/|examples/|docs/)

{openshift_python_wrapper-10.0.100 → openshift_python_wrapper-10.0.102}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openshift-python-wrapper
-Version: 10.0.100
+Version: 10.0.102
 Summary: Wrapper around https://github.com/kubernetes-client/python
 Project-URL: homepage, https://github.com/RedHatQE/openshift-python-wrapper
 Project-URL: documentation, https://openshift-python-wrapper.readthedocs.io/en/latest/

openshift_python_wrapper-10.0.102/ocp_resources/authorino.py

@@ -0,0 +1,146 @@
+# Generated using https://github.com/RedHatQE/openshift-python-wrapper/blob/main/scripts/resource/README.md
+
+from typing import Any, Dict, Optional
+from ocp_resources.resource import NamespacedResource, MissingRequiredArgumentError
+
+
+class Authorino(NamespacedResource):
+    """
+    Authorino is the Schema for the authorinos API
+    """
+
+    api_group: str = NamespacedResource.ApiGroup.OPERATOR_AUTHORINO_KUADRANT_IO
+
+    def __init__(
+        self,
+        auth_config_label_selectors: Optional[str] = "",
+        cluster_wide: Optional[bool] = None,
+        evaluator_cache_size: Optional[int] = None,
+        healthz: Optional[Dict[str, Any]] = None,
+        image: Optional[str] = "",
+        image_pull_policy: Optional[str] = "",
+        listener: Optional[Dict[str, Any]] = None,
+        log_level: Optional[str] = "",
+        log_mode: Optional[str] = "",
+        metrics: Optional[Dict[str, Any]] = None,
+        oidc_server: Optional[Dict[str, Any]] = None,
+        replicas: Optional[int] = None,
+        secret_label_selectors: Optional[str] = "",
+        superseding_host_subsets: Optional[bool] = None,
+        tracing: Optional[Dict[str, Any]] = None,
+        volumes: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Args:
+            auth_config_label_selectors (str): No field description from API; please add description
+
+            cluster_wide (bool): No field description from API; please add description
+
+            evaluator_cache_size (int): No field description from API; please add description
+
+            healthz (Dict[str, Any]): No field description from API; please add description
+
+            image (str): No field description from API; please add description
+
+            image_pull_policy (str): PullPolicy describes a policy for if/when to pull a container image
+
+            listener (Dict[str, Any]): No field description from API; please add description
+
+            log_level (str): No field description from API; please add description
+
+            log_mode (str): No field description from API; please add description
+
+            metrics (Dict[str, Any]): No field description from API; please add description
+
+            oidc_server (Dict[str, Any]): No field description from API; please add description
+
+            replicas (int): No field description from API; please add description
+
+            secret_label_selectors (str): No field description from API; please add description
+
+            superseding_host_subsets (bool): No field description from API; please add description
+
+            tracing (Dict[str, Any]): No field description from API; please add description
+
+            volumes (Dict[str, Any]): No field description from API; please add description
+
+        """
+        super().__init__(**kwargs)
+
+        self.auth_config_label_selectors = auth_config_label_selectors
+        self.cluster_wide = cluster_wide
+        self.evaluator_cache_size = evaluator_cache_size
+        self.healthz = healthz
+        self.image = image
+        self.image_pull_policy = image_pull_policy
+        self.listener = listener
+        self.log_level = log_level
+        self.log_mode = log_mode
+        self.metrics = metrics
+        self.oidc_server = oidc_server
+        self.replicas = replicas
+        self.secret_label_selectors = secret_label_selectors
+        self.superseding_host_subsets = superseding_host_subsets
+        self.tracing = tracing
+        self.volumes = volumes
+
+    def to_dict(self) -> None:
+        super().to_dict()
+
+        if not self.kind_dict and not self.yaml_file:
+            if not self.listener:
+                raise MissingRequiredArgumentError(argument="self.listener")
+
+            if not self.oidc_server:
+                raise MissingRequiredArgumentError(argument="self.oidc_server")
+
+            self.res["spec"] = {}
+            _spec = self.res["spec"]
+
+            _spec["listener"] = self.listener
+            _spec["oidcServer"] = self.oidc_server
+
+            if self.auth_config_label_selectors:
+                _spec["authConfigLabelSelectors"] = self.auth_config_label_selectors
+
+            if self.cluster_wide is not None:
+                _spec["clusterWide"] = self.cluster_wide
+
+            if self.evaluator_cache_size:
+                _spec["evaluatorCacheSize"] = self.evaluator_cache_size
+
+            if self.healthz:
+                _spec["healthz"] = self.healthz
+
+            if self.image:
+                _spec["image"] = self.image
+
+            if self.image_pull_policy:
+                _spec["imagePullPolicy"] = self.image_pull_policy
+
+            if self.log_level:
+                _spec["logLevel"] = self.log_level
+
+            if self.log_mode:
+                _spec["logMode"] = self.log_mode
+
+            if self.metrics:
+                _spec["metrics"] = self.metrics
+
+            if self.replicas:
+                _spec["replicas"] = self.replicas
+
+            if self.secret_label_selectors:
+                _spec["secretLabelSelectors"] = self.secret_label_selectors
+
+            if self.superseding_host_subsets is not None:
+                _spec["supersedingHostSubsets"] = self.superseding_host_subsets
+
+            if self.tracing:
+                _spec["tracing"] = self.tracing
+
+            if self.volumes:
+                _spec["volumes"] = self.volumes
+
+    # End of generated code

{openshift_python_wrapper-10.0.100 → openshift_python_wrapper-10.0.102}/ocp_resources/exceptions.py

@@ -34,7 +34,7 @@ class ExecOnPodError(Exception):
         self.err = err
 
     def __str__(self):
-        return "Command execution failure: " f"{self.cmd}, " f"RC: {self.rc}, " f"OUT: {self.out}, " f"ERR: {self.err}"
+        return f"Command execution failure: {self.cmd}, RC: {self.rc}, OUT: {self.out}, ERR: {self.err}"
 
 
 class NNCPConfigurationFailed(Exception):

{openshift_python_wrapper-10.0.100 → openshift_python_wrapper-10.0.102}/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" f" {replicas} replicas")
+        self.logger.info(f"Scale machine-set from {self.desired_replicas} replicas to {replicas} replicas")
         self.update(resource_dict=self.res)
         if wait:
             return self.wait_for_replicas(timeout=wait_timeout, sleep=sleep)

{openshift_python_wrapper-10.0.100 → openshift_python_wrapper-10.0.102}/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:" f" {last_condition}"))
+            self.logger.error(msg=(f"Last Status Condition of {self.kind} {self.name} was: {last_condition}"))
             raise
 
     def wait_for_condition_ready(self, wait_timeout=360):

{openshift_python_wrapper-10.0.100 → openshift_python_wrapper-10.0.102}/ocp_resources/resource.py

@@ -325,6 +325,7 @@ class Resource:
         NODEMAINTENANCE_KUBEVIRT_IO: str = "nodemaintenance.kubevirt.io"
         OBSERVABILITY_OPEN_CLUSTER_MANAGEMENT_IO: str = "observability.open-cluster-management.io"
         OCS_OPENSHIFT_IO: str = "ocs.openshift.io"
+        OPERATOR_AUTHORINO_KUADRANT_IO: str = "operator.authorino.kuadrant.io"
         OPERATOR_OPEN_CLUSTER_MANAGEMENT_IO: str = "operator.open-cluster-management.io"
         OPERATOR_OPENSHIFT_IO: str = "operator.openshift.io"
         OPERATORS_COREOS_COM: str = "operators.coreos.com"
@@ -1006,7 +1007,7 @@ class Resource:
         Raises:
             TimeoutExpiredError: If Resource condition in not in desire status.
         """
-        self.logger.info(f"Wait for {self.kind}/{self.name}'s '{condition}' condition to be" f" '{status}'")
+        self.logger.info(f"Wait for {self.kind}/{self.name}'s '{condition}' condition to be '{status}'")
 
         timeout_watcher = TimeoutWatch(timeout=timeout)
         for sample in TimeoutSampler(
@@ -1413,7 +1414,7 @@ class ResourceEditor:
                         resource_to_patch.append(resource)
                         self._backups[resource] = backup
                     else:
-                        LOGGER.warning("ResourceEdit: no diff found in patch for " f"{resource.name} -- skipping")
+                        LOGGER.warning(f"ResourceEdit: no diff found in patch for {resource.name} -- skipping")
                 if not resource_to_patch:
                     return
         else:
@@ -1508,7 +1509,7 @@ class ResourceEditor:
         """
 
         for resource, patch in patches.items():
-            LOGGER.info(f"ResourceEdits: {action_text} data for " f"resource {resource.kind} {resource.name}")
+            LOGGER.info(f"ResourceEdits: {action_text} data for resource {resource.kind} {resource.name}")
 
             # add name to patch
             if "metadata" not in patch:

{openshift_python_wrapper-10.0.100 → openshift_python_wrapper-10.0.102}/ocp_resources/sriov_network_node_state.py

@@ -48,5 +48,5 @@ class SriovNetworkNodeState(NamespacedResource):
                 if sample == wanted_status:
                     return
         except TimeoutExpiredError:
-            self.logger.error(f"after {timeout} seconds, {self.name} status is" f" {self.instance.status.syncStatus}")
+            self.logger.error(f"after {timeout} seconds, {self.name} status is {self.instance.status.syncStatus}")
             raise

openshift_python_wrapper-10.0.102/ocp_resources/user_defined_network.py

@@ -0,0 +1,191 @@
+# Generated using https://github.com/RedHatQE/openshift-python-wrapper/blob/main/scripts/resource/README.md
+
+from typing import Any, Dict, Optional
+from ocp_resources.resource import NamespacedResource, MissingRequiredArgumentError
+from typing import List
+
+
+class UserDefinedNetwork(NamespacedResource):
+    """
+    UserDefinedNetwork describes network request for a Namespace.
+    """
+
+    api_group: str = NamespacedResource.ApiGroup.K8S_OVN_ORG
+
+    def __init__(
+        self,
+        layer2: Optional[Dict[str, Any]] = None,
+        layer3: Optional[Dict[str, Any]] = None,
+        local_net: Optional[Dict[str, Any]] = None,
+        topology: Optional[str] = "",
+        **kwargs: Any,
+    ) -> None:
+        """
+        Args:
+            layer2 (Dict[str, Any]): Layer2 is the Layer2 topology configuration.
+
+            layer3 (Dict[str, Any]): Layer3 is the Layer3 topology configuration.
+
+            local_net (Dict[str, Any]): LocalNet is the LocalNet topology configuration.
+
+            topology (str): Topology describes network configuration.   Allowed values are
+              "Layer3", "Layer2", "LocalNet". Layer3 topology creates a layer 2
+              segment per node, each with a different subnet. Layer 3 routing is
+              used to interconnect node subnets. Layer2 topology creates one
+              logical switch shared by all nodes. LocalNet topology creates a
+              cluster-wide logical switch connected to a physical network.
+
+        """
+        super().__init__(**kwargs)
+
+        self.layer2 = layer2
+        self.layer3 = layer3
+        self.local_net = local_net
+        self.topology = topology
+
+    def to_dict(self) -> None:
+        super().to_dict()
+
+        if not self.kind_dict and not self.yaml_file:
+            if not all([
+                self.topology,
+            ]):
+                raise MissingRequiredArgumentError(argument="topology")
+
+            self.res["spec"] = {}
+            _spec = self.res["spec"]
+
+            _spec["topology"] = self.topology
+
+            if self.layer2:
+                _spec["layer2"] = self.layer2
+
+            if self.layer3:
+                _spec["layer3"] = self.layer3
+
+            if self.local_net:
+                _spec["localNet"] = self.local_net
+
+    # End of generated code
+
+
+class Layer2UserDefinedNetwork(UserDefinedNetwork):
+    """
+    UserDefinedNetwork layer2 object.
+
+    API reference:
+    https://ovn-kubernetes.io/api-reference/userdefinednetwork-api-spec/#layer2config
+    """
+
+    LAYER2: str = "Layer2"
+
+    def __init__(
+        self,
+        role: Optional[str] = None,
+        mtu: Optional[int] = None,
+        subnets: Optional[List[str]] = None,
+        join_subnets: Optional[List[str]] = None,
+        ipam_lifecycle: Optional[str] = None,
+        **kwargs,
+    ):
+        """
+        Create and manage UserDefinedNetwork with layer2 configuration
+
+        Args:
+            role (Optional[str]): role describes the network role in the pod.
+            mtu (Optional[int]): mtu is the maximum transmission unit for a network.
+            subnets (Optional[List[str]]): subnets are used for the pod network across the cluster.
+            join_subnets (Optional[List[str]]): join_subnets are used inside the OVN network topology.
+            ipam_lifecycle (Optional[str]): ipam_lifecycle controls IP addresses management lifecycle.
+        """
+        super().__init__(
+            topology=self.LAYER2,
+            **kwargs,
+        )
+        self.role = role
+        self.mtu = mtu
+        self.subnets = subnets
+        self.join_subnets = join_subnets
+        self.ipam_lifecycle = ipam_lifecycle
+
+    def to_dict(self) -> None:
+        super().to_dict()
+        if not self.kind_dict and not self.yaml_file:
+            if not self.role:
+                raise MissingRequiredArgumentError(argument="role")
+
+            self.res["spec"][self.LAYER2.lower()] = {"role": self.role}
+            _layer2 = self.res["spec"][self.LAYER2.lower()]
+
+            if self.mtu:
+                _layer2["mtu"] = self.mtu
+
+            if self.subnets:
+                _layer2["subnets"] = self.subnets
+
+            if self.join_subnets:
+                _layer2["joinSubnets"] = self.join_subnets
+
+            if self.ipam_lifecycle:
+                _layer2["ipamLifecycle"] = self.ipam_lifecycle
+
+
+class Layer3UserDefinedNetwork(UserDefinedNetwork):
+    """
+    UserDefinedNetwork layer3 object.
+
+    API reference:
+    https://ovn-kubernetes.io/api-reference/userdefinednetwork-api-spec/#layer3config
+    """
+
+    LAYER3: str = "Layer3"
+
+    def __init__(
+        self,
+        role: Optional[str] = None,
+        mtu: Optional[int] = None,
+        subnets: Optional[List[Dict[str, Any]]] = None,
+        join_subnets: Optional[List[str]] = None,
+        **kwargs,
+    ):
+        """
+        Create and manage UserDefinedNetwork with layer3 configuration
+
+        Args:
+            role (Optional[str]): role describes the network role in the pod.
+            mtu (Optional[int]): mtu is the maximum transmission unit for a network.
+            subnets (Optional[List[Dict]]): subnets are used for the pod network across the cluster, each expecting:
+                - `cidr` (str): IP range in CIDR notation.
+                - `hostSubnet` (Optional[int]): Host-specific subnet.
+                API reference:
+                https://ovn-kubernetes.io/api-reference/userdefinednetwork-api-spec/#layer3subnet
+            join_subnets (Optional[List[str]]): join_subnets are used inside the OVN network topology.
+        """
+        super().__init__(
+            topology=self.LAYER3,
+            **kwargs,
+        )
+        self.role = role
+        self.mtu = mtu
+        self.subnets = subnets
+        self.join_subnets = join_subnets
+
+    def to_dict(self) -> None:
+        super().to_dict()
+        if not self.kind_dict and not self.yaml_file:
+            if not self.role:
+                raise MissingRequiredArgumentError(argument="role")
+            if not self.subnets:
+                raise MissingRequiredArgumentError(argument="subnets")
+
+            self.res["spec"][self.LAYER3.lower()] = {"role": self.role}
+            _layer3 = self.res["spec"][self.LAYER3.lower()]
+
+            if self.mtu:
+                _layer3["mtu"] = self.mtu
+
+            if self.join_subnets:
+                _layer3["joinSubnets"] = self.join_subnets
+
+            if self.subnets:
+                _layer3["subnets"] = self.subnets

{openshift_python_wrapper-10.0.100 → openshift_python_wrapper-10.0.102}/ocp_resources/virtual_machine_import.py

@@ -201,7 +201,7 @@ class VirtualMachineImport(NamespacedResource):
         cond_status=Condition.Status.TRUE,
         cond_type=Condition.SUCCEEDED,
     ):
-        self.logger.info(f"Wait for {self.kind} {self.name} {cond_reason} condition to be" f" {cond_status}")
+        self.logger.info(f"Wait for {self.kind} {self.name} {cond_reason} condition to be {cond_status}")
         samples = TimeoutSampler(
             wait_timeout=timeout,
             sleep=1,

{openshift_python_wrapper-10.0.100 → openshift_python_wrapper-10.0.102}/ocp_resources/virtual_machine_instance.py

@@ -194,7 +194,7 @@ class VirtualMachineInstance(NamespacedResource):
 
     def virsh_cmd(self, action):
         return shlex.split(
-            "virsh" f" {self.virt_launcher_pod_hypervisor_connection_uri} {action} {self.namespace}_{self.name}"
+            f"virsh {self.virt_launcher_pod_hypervisor_connection_uri} {action} {self.namespace}_{self.name}"
         )
 
     def get_xml(self):

{openshift_python_wrapper-10.0.100 → openshift_python_wrapper-10.0.102}/ocp_resources/virtual_machine_snapshot.py

@@ -56,7 +56,7 @@ class VirtualMachineSnapshot(NamespacedResource):
         Raises:
             TimeoutExpiredError: If timeout reached.
         """
-        self.logger.info(f"Wait for {self.kind} {self.name} status to be" f" {'' if status else 'not '}ready to use")
+        self.logger.info(f"Wait for {self.kind} {self.name} status to be {'' if status else 'not '}ready to use")
 
         timeout_watcher = TimeoutWatch(timeout=timeout)
         for sample in TimeoutSampler(

{openshift_python_wrapper-10.0.100 → openshift_python_wrapper-10.0.102}/pyproject.toml

@@ -27,7 +27,7 @@ dev-dependencies = [ "ipdb>=0.13.13", "ipython>=8.12.3" ]
 [project]
 requires-python = ">=3.8"
 name = "openshift-python-wrapper"
-version = "10.0.100"
+version = "10.0.102"
 description = "Wrapper around https://github.com/kubernetes-client/python"
 readme = "README.md"
 license = "Apache-2.0"

{openshift_python_wrapper-10.0.100 → openshift_python_wrapper-10.0.102}/renovate.json

@@ -1,5 +1,11 @@
 {
   "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    ":dependencyDashboard",
+    ":maintainLockFilesWeekly",
+    ":prHourlyLimitNone"
+  ],
+  "prConcurrentLimit": 0,
   "lockFileMaintenance": {
     "enabled": true
   },

{openshift_python_wrapper-10.0.100 → openshift_python_wrapper-10.0.102}/tests/test_api_group_order.py

@@ -29,6 +29,6 @@ def test_api_group_order():
             _err_diff = _diff.split(" ")[-1]
             errors.add(_err_diff)
 
-    assert (
-        not errors
-    ), f"ApiGroup class should be sorted alphabetically. Missed places ApiGroups: {'\n'.join(list(errors))}"
+    assert not errors, (
+        f"ApiGroup class should be sorted alphabetically. Missed places ApiGroups: {'\n'.join(list(errors))}"
+    )