openshift-python-wrapper 11.0.138__tar.gz → 11.0.139__tar.gz

{openshift_python_wrapper-11.0.138 → openshift_python_wrapper-11.0.139}/.github/workflows/close-stale-issues.yml

@@ -7,7 +7,7 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v10
+      - uses: actions/stale@v11
         with:
           stale-issue-message: 'This issue is stale because it has been open 30 days with no activity. Remove stale label or comment or this will be closed in 7 days.'
           days-before-stale: 30

{openshift_python_wrapper-11.0.138 → openshift_python_wrapper-11.0.139}/.pre-commit-config.yaml

@@ -46,7 +46,7 @@ repos:
           ]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.15.22
+    rev: v0.16.0
     hooks:
       - id: ruff
       - id: ruff-format

{openshift_python_wrapper-11.0.138 → openshift_python_wrapper-11.0.139}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openshift-python-wrapper
-Version: 11.0.138
+Version: 11.0.139
 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-11.0.139/ocp_resources/hyperconverged.py

@@ -0,0 +1,147 @@
+# Generated using https://github.com/RedHatQE/openshift-python-wrapper/blob/main/class_generator/README.md
+
+
+from typing import Any
+
+from ocp_resources.resource import NamespacedResource
+
+
+class HyperConverged(NamespacedResource):
+    """
+    HyperConverged is the Schema for the hyperconvergeds API
+    """
+
+    api_group: str = NamespacedResource.ApiGroup.HCO_KUBEVIRT_IO
+
+    def __init__(
+        self,
+        deployment: dict[str, Any] | None = None,
+        feature_gates: list[Any] | None = None,
+        networking: dict[str, Any] | None = None,
+        security: dict[str, Any] | None = None,
+        storage: dict[str, Any] | None = None,
+        virtualization: dict[str, Any] | None = None,
+        workload_sources: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        r"""
+        Args:
+            deployment (dict[str, Any]): Deployment contains all the configurations related to deployment of
+              KubeVirt components
+
+            feature_gates (list[Any]): FeatureGates is a set of optional feature gates to enable or disable
+              new features that are not generally available yet. Add a new
+              FeatureGate Object to this set, to enable a feature that is
+              disabled by default, or to disable a feature that is enabled by
+              default.  A feature gate may be in the following phases: * alpha:
+              the feature is in dev-preview. It is disabled by default, but can
+              be enabled. * beta: the feature gate is in tech-preview. It is
+              enabled by default, but   can be disabled. * GA: the feature is
+              graduated and is always enabled. There is no way to   disable it.
+              * deprecated: the feature is deprecated. The feature gate will be
+              removed in a future release.  Feature-Gate list: *
+              decentralizedLiveMigration:   DecentralizedLiveMigration enables
+              the decentralized live migration   (cross-cluster migration)
+              feature. This feature allows live migration of
+              VirtualMachineInstances between different clusters. This feature
+              is in   Developer Preview.   Phase: beta  *
+              declarativeHotplugVolumes:   DeclarativeHotplugVolumes enables the
+              use of the declarative volume   hotplug feature in KubeVirt. When
+              set to true or nil, the   "DeclarativeHotplugVolumes" feature gate
+              is enabled and the   "HotplugVolumes" feature gate is not (default
+              behavior). When set to   false, the "HotplugVolumes" featuregate
+              is enabled in KubeVirt. This   feature is in Technical Preview.
+              Phase: beta  * template:   VirtualMachine Templates provide a
+              native, in-cluster VM templating for   KubeVirt. They allow you to
+              define reusable VM blueprints with   parameterized values that can
+              be processed to create virtual machine. the   "template" feature
+              gate enables this feature. Note: this feature is in   Tech
+              Preview.   Phase: beta  * alignCPUs:   Enable KubeVirt to request
+              up to two additional dedicated CPUs in order to   complete the
+              total CPU count to an even parity when using emulator thread
+              isolation. Note: this feature is in Developer Preview.   Phase:
+              alpha  * containerPathVolumes:   ContainerPathVolumes enables the
+              use of container paths as volumes in   KubeVirt. This allows VMs
+              to access files and directories from the   virt-launcher pod's
+              filesystem via virtiofs.   Phase: alpha  * deployKubeSecondaryDNS:
+              Deploy KubeSecondaryDNS by CNAO   Phase: alpha  *
+              deployObservabilityController:   Deploy the virt-observability-
+              controller component. When enabled, the   controller exposes
+              KubeVirt metrics and manages PrometheusRule resources
+              independently from the KubeVirt control plane.   Phase: alpha  *
+              downwardMetrics:   Allow to expose a limited set of host metrics
+              to guests.   Phase: alpha  * enableMultiArchBootImageImport:
+              EnableMultiArchBootImageImport allows the HCO to run on
+              heterogeneous   clusters with different CPU architectures. Setting
+              this field to true will   allow the HCO to create Golden Images
+              for different CPU architectures.   This feature is in Developer
+              Preview.   Phase: alpha  * incrementalBackup:   IncrementalBackup
+              enables changed block tracking backups and incremental   backups
+              using QEMU capabilities in KubeVirt. When enabled, this also
+              enables the UtilityVolumes feature gate in the KubeVirt CR. Note:
+              This   feature is in Tech Preview.   Phase: alpha  * objectGraph:
+              ObjectGraph enables the ObjectGraph VM and VMI subresource in
+              KubeVirt.   This subresource returns a structured list of k8s
+              objects that are related   to the specified VM or VMI, enabling
+              better dependency tracking. Note:   This feature is in Developer
+              Preview.   Phase: alpha  * disableMDevConfiguration:   Deprecated:
+              use spec.virtualization.mediatedDevicesConfiguration.enabled
+              instead. This feature gate is deprecated and will be removed in a
+              future   release.   Phase: deprecated  * persistentReservation:
+              This feature gate has graduated to a dedicated configuration
+              field. Use
+              spec.storage.persistentReservationConfiguration.enabled instead.
+              This   feature gate is deprecated and will be removed in a future
+              release.   Phase: deprecated
+
+            networking (dict[str, Any]): Networking contains all the configurations for networking
+
+            security (dict[str, Any]): Security contains all the security configurations
+
+            storage (dict[str, Any]): Storage contains all the configurations for storage
+
+            virtualization (dict[str, Any]): Virtualization contains all the configurations for virtualization
+
+            workload_sources (dict[str, Any]): WorkloadSources contains all the configurations for workload sources
+
+        """
+        super().__init__(**kwargs)
+
+        self.deployment = deployment
+        self.feature_gates = feature_gates
+        self.networking = networking
+        self.security = security
+        self.storage = storage
+        self.virtualization = virtualization
+        self.workload_sources = workload_sources
+
+    def to_dict(self) -> None:
+
+        super().to_dict()
+
+        if not self.kind_dict and not self.yaml_file:
+            self.res["spec"] = {}
+            _spec = self.res["spec"]
+
+            if self.deployment is not None:
+                _spec["deployment"] = self.deployment
+
+            if self.feature_gates is not None:
+                _spec["featureGates"] = self.feature_gates
+
+            if self.networking is not None:
+                _spec["networking"] = self.networking
+
+            if self.security is not None:
+                _spec["security"] = self.security
+
+            if self.storage is not None:
+                _spec["storage"] = self.storage
+
+            if self.virtualization is not None:
+                _spec["virtualization"] = self.virtualization
+
+            if self.workload_sources is not None:
+                _spec["workloadSources"] = self.workload_sources
+
+    # End of generated code

{openshift_python_wrapper-11.0.138 → openshift_python_wrapper-11.0.139}/ocp_resources/utils/utils.py

@@ -82,7 +82,7 @@ def convert_camel_case_to_snake_case(name: str) -> str:
         - The function handles both single-word camel case strings (e.g., "Service") and multi-word camel case strings
           (e.g., "myCamelCaseString").
     """
-    do_not_process_list = ["oauth", "kubevirt"]
+    do_not_process_list = ["hyperconverged", "oauth", "kubevirt"]
 
     # If the input string is in the do_not_proccess_list, return it as it is.
     if name.lower() in do_not_process_list:

{openshift_python_wrapper-11.0.138 → openshift_python_wrapper-11.0.139}/ocp_resources/virtual_machine_template.py

@@ -64,3 +64,38 @@ class VirtualMachineTemplate(NamespacedResource):
                 _spec["parameters"] = self.parameters
 
     # End of generated code
+
+    def process(
+        self,
+        parameters: dict[str, str] | None = None,
+        client: Any = None,
+    ) -> Any:
+        """
+        Process the VirtualMachineTemplate using the KubeVirt subresources API.
+
+        Sends a POST request to the process subresource endpoint, substituting the
+        provided parameter values into the template and returning the result.
+
+        Args:
+            parameters (dict[str, str] | None): Key-value pairs of template parameters
+                to substitute, e.g. ``{"NAME": "my-vm", "INSTANCETYPE": "u1.large"}``.
+                Defaults to an empty dict (no substitutions).
+            client: Optional Kubernetes API client. Defaults to ``self.client``.
+
+        Returns:
+            Any: The raw API server response object.
+
+        """
+        _client = client or self.client
+        _subresources_api = f"subresources.{self.api_version}"
+        body: dict[str, Any] = {
+            "apiVersion": _subresources_api,
+            "kind": "ProcessOptions",
+            "parameters": parameters or {},
+        }
+        response = _client.request(
+            "POST",
+            f"/apis/{_subresources_api}/namespaces/{self.namespace}/virtualmachinetemplates/{self.name}/process",
+            body,
+        )
+        return response

{openshift_python_wrapper-11.0.138 → openshift_python_wrapper-11.0.139}/ocp_resources/virtual_machine_template_request.py

@@ -16,23 +16,41 @@ class VirtualMachineTemplateRequest(NamespacedResource):
 
     def __init__(
         self,
+        template_labels: dict[str, Any] | None = None,
         template_name: str | None = None,
+        ttl_seconds_after_finished: int | None = None,
         virtual_machine_ref: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> None:
         r"""
         Args:
+            template_labels (dict[str, Any]): TemplateLabels holds optional labels to apply to the created
+              VirtualMachineTemplate. Labels with the "template.kubevirt.io/"
+              prefix are reserved for system use and are not allowed.
+
             template_name (str): TemplateName holds the optional name for the new
               VirtualMachineTemplate. If not specified the template will have
               the same name as the VirtualMachineTemplateRequest.
 
+            ttl_seconds_after_finished (int): TTLSecondsAfterFinished limits the lifetime of a
+              VirtualMachineTemplateRequest that has finished execution. Failed
+              VirtualMachineTemplateRequests are never cleaned up by the TTL
+              controller, so they remain available for debugging. If this field
+              is unset, the VirtualMachineTemplateRequest is not automatically
+              deleted and must be removed manually or through the owner
+              reference cleanup described below. If this field is set to zero,
+              the VirtualMachineTemplateRequest becomes eligible to be deleted
+              immediately after it finishes.
+
             virtual_machine_ref (dict[str, Any]): VirtualMachineReference holds a reference to a
               VirtualMachine.kubevirt.io
 
         """
         super().__init__(**kwargs)
 
+        self.template_labels = template_labels
         self.template_name = template_name
+        self.ttl_seconds_after_finished = ttl_seconds_after_finished
         self.virtual_machine_ref = virtual_machine_ref
 
     def to_dict(self) -> None:
@@ -48,7 +66,13 @@ class VirtualMachineTemplateRequest(NamespacedResource):
 
             _spec["virtualMachineRef"] = self.virtual_machine_ref
 
+            if self.template_labels is not None:
+                _spec["templateLabels"] = self.template_labels
+
             if self.template_name is not None:
                 _spec["templateName"] = self.template_name
 
+            if self.ttl_seconds_after_finished is not None:
+                _spec["ttlSecondsAfterFinished"] = self.ttl_seconds_after_finished
+
     # End of generated code

{openshift_python_wrapper-11.0.138 → openshift_python_wrapper-11.0.139}/pyproject.toml

@@ -75,7 +75,7 @@ include = [
 [project]
 requires-python = ">=3.10"
 name = "openshift-python-wrapper"
-version = "11.0.138"
+version = "11.0.139"
 description = "Wrapper around https://github.com/kubernetes-client/python"
 readme = "README.md"
 license = "Apache-2.0"

openshift_python_wrapper-11.0.139/tests/test_virtual_machine_template.py

@@ -0,0 +1,147 @@
+from typing import Any
+from unittest.mock import MagicMock
+
+import pytest
+
+from ocp_resources.resource import get_client
+from ocp_resources.virtual_machine_template import VirtualMachineTemplate
+
+# ── constants ────────────────────────────────────────────────────────────────
+
+VMT_NAMESPACE = "test-ns"
+VMT_NAME = "test-vmt"
+_API_GROUP = "template.kubevirt.io"
+_API_VERSION = "v1alpha1"
+_FULL_API_VERSION = f"{_API_GROUP}/{_API_VERSION}"
+# The process method builds: "subresources.<self.api_version>"
+_SUBRESOURCES_API = f"subresources.{_FULL_API_VERSION}"
+# Expected POST path used by process()
+VMT_PROCESS_PATH = f"/apis/{_SUBRESOURCES_API}/namespaces/{VMT_NAMESPACE}/virtualmachinetemplates/{VMT_NAME}/process"
+
+# Resource definition required to register VirtualMachineTemplate in the fake client
+_VMT_RESOURCE_DEF: dict[str, Any] = {
+    "kind": "VirtualMachineTemplate",
+    "api_version": _API_VERSION,
+    "group": _API_GROUP,
+    "version": _API_VERSION,
+    "group_version": _FULL_API_VERSION,
+    "plural": "virtualmachinetemplates",
+    "singular": "virtualmachinetemplate",
+    "namespaced": True,
+}
+
+
+# ── helpers ───────────────────────────────────────────────────────────────────
+
+
+def _make_fake_client(response_data: dict[str, Any] | None = None) -> Any:
+    """
+    Return a fake client (get_client(fake=True)) with VirtualMachineTemplate registered
+    and request() replaced by a MagicMock so call args and return values are inspectable.
+    """
+    client = get_client(fake=True)
+    client.register_resources(_VMT_RESOURCE_DEF)
+    mock_response = MagicMock()
+    mock_response.to_dict.return_value = response_data if response_data is not None else {}
+    # Intentionally replacing the stub method with a MagicMock for call-arg inspection
+    client.request = MagicMock(return_value=mock_response)  # type: ignore[method-assign]
+    return client
+
+
+# ── fixtures ──────────────────────────────────────────────────────────────────
+
+
+@pytest.fixture()
+def vmt() -> VirtualMachineTemplate:
+    return VirtualMachineTemplate(
+        client=_make_fake_client(),
+        name=VMT_NAME,
+        namespace=VMT_NAMESPACE,
+        virtual_machine={"spec": {}},
+    )
+
+
+# ── tests ─────────────────────────────────────────────────────────────────────
+
+
+class TestProcessPath:
+    """process() sends a POST to the correct subresource URL."""
+
+    def test_process_default_parameters_uses_correct_path(self, vmt: VirtualMachineTemplate) -> None:
+        process_client = _make_fake_client()
+        vmt.process(client=process_client)
+
+        method, path, _ = process_client.request.call_args.args
+        assert method == "POST"
+        assert path == VMT_PROCESS_PATH
+
+    def test_process_with_parameters_uses_correct_path(self, vmt: VirtualMachineTemplate) -> None:
+        process_client = _make_fake_client()
+        vmt.process(parameters={"NAME": "my-vm"}, client=process_client)
+
+        method, path, _ = process_client.request.call_args.args
+        assert method == "POST"
+        assert path == VMT_PROCESS_PATH
+
+
+class TestProcessOptionsBody:
+    """process() sends the correct ProcessOptions body."""
+
+    def test_body_kind_is_process_options(self, vmt: VirtualMachineTemplate) -> None:
+        process_client = _make_fake_client()
+        vmt.process(client=process_client)
+
+        _, _, body = process_client.request.call_args.args
+        assert body["kind"] == "ProcessOptions"
+
+    def test_body_api_version_matches_subresources_api(self, vmt: VirtualMachineTemplate) -> None:
+        process_client = _make_fake_client()
+        vmt.process(client=process_client)
+
+        _, _, body = process_client.request.call_args.args
+        assert body["apiVersion"] == _SUBRESOURCES_API
+
+    def test_body_parameters_empty_when_none_supplied(self, vmt: VirtualMachineTemplate) -> None:
+        """parameters=None should produce an empty dict in the request body."""
+        process_client = _make_fake_client()
+        vmt.process(client=process_client)
+
+        _, _, body = process_client.request.call_args.args
+        assert body["parameters"] == {}
+
+    def test_body_parameters_passed_through_when_supplied(self, vmt: VirtualMachineTemplate) -> None:
+        """Supplied parameters dict should appear unchanged in the request body."""
+        supplied = {"NAME": "my-vm", "INSTANCETYPE": "u1.large"}
+        process_client = _make_fake_client()
+        vmt.process(parameters=supplied, client=process_client)
+
+        _, _, body = process_client.request.call_args.args
+        assert body["parameters"] == supplied
+
+
+class TestProcessClientSelection:
+    """process() uses the injected client, falling back to self.client."""
+
+    def test_process_uses_injected_client(self, vmt: VirtualMachineTemplate) -> None:
+        injected = _make_fake_client()
+        vmt.process(client=injected)
+
+        injected.request.assert_called_once()
+        vmt.client.request.assert_not_called()
+
+    def test_process_falls_back_to_self_client_when_not_injected(self, vmt: VirtualMachineTemplate) -> None:
+        vmt.client.request.return_value.to_dict.return_value = {}
+        vmt.process()
+
+        vmt.client.request.assert_called_once()
+
+
+class TestProcessReturnValue:
+    """process() returns the raw response object from the API client."""
+
+    def test_process_returns_raw_response(self, vmt: VirtualMachineTemplate) -> None:
+        process_client = _make_fake_client()
+
+        result = vmt.process(client=process_client)
+
+        assert result is process_client.request.return_value