openshift-python-wrapper 11.0.117__tar.gz → 11.0.118__tar.gz

openshift_python_wrapper-11.0.118/.git

@@ -0,0 +1 @@
+gitdir: /tmp/github-webhook-openshift-python-wrapper-pmksfq2g/.git/worktrees/github-webhook-openshift-python-wrapper-pmksfq2g-worktree-a249b4d1-4ec7-4be9-8afc-75119b851f54

{openshift_python_wrapper-11.0.117 → openshift_python_wrapper-11.0.118}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openshift-python-wrapper
-Version: 11.0.117
+Version: 11.0.118
 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.117 → openshift_python_wrapper-11.0.118}/class_generator/core/schema.py

@@ -163,6 +163,10 @@ def identify_missing_resources(client: str, existing_resources_mapping: dict[Any
     """
     Identify resources that exist in the cluster but are missing from our mapping.
 
+    Compares using (group, kind) pairs so that resources with the same kind but
+    different API groups (e.g. velero.io/Backup vs postgresql.cnpg.noobaa.io/Backup)
+    are tracked independently.
+
     Args:
         client: Path to kubectl/oc client binary
         existing_resources_mapping: Current resources mapping
@@ -172,7 +176,7 @@ def identify_missing_resources(client: str, existing_resources_mapping: dict[Any
     """
     missing_resources: set[str] = set()
 
-    # Get all available resources from cluster
+    # Get all available resources from cluster with their API groups
     cmd = f"{client} api-resources --no-headers"
     success, output, _ = run_command(command=shlex.split(cmd), check=False, log_errors=False)
 
@@ -180,49 +184,75 @@ def identify_missing_resources(client: str, existing_resources_mapping: dict[Any
         LOGGER.debug("Failed to get api-resources from cluster")
         return missing_resources
 
-    # Extract kinds from cluster resources
-    cluster_resources = set()
+    # Build kind -> set of groups from cluster resources
+    cluster_kind_groups: dict[str, set[str]] = {}
     lines = output.strip().split("\n")
 
     for line in lines:
         parts = [p for p in line.split() if p]
-        if parts:
-            kind = parts[-1]  # KIND is the last column
-            cluster_resources.add(kind)
+        if len(parts) < 3:
+            continue
 
-    # Find missing resources by comparing with existing mapping
-    existing_kinds = set()
-    for _, resource_schemas in existing_resources_mapping.items():
-        # Verify resource_schemas is a non-empty list
-        if not isinstance(resource_schemas, list) or not resource_schemas:
+        # Find APIVERSION column by looking for version patterns
+        # (same logic as build_dynamic_resource_to_api_mapping)
+        apiversion_idx = None
+        for i, part in enumerate(parts):
+            if ("/" in part and ("v" in part or "alpha" in part or "beta" in part)) or (
+                part.startswith("v") and part[1:].replace(".", "").replace("alpha", "").replace("beta", "").isdigit()
+            ):
+                apiversion_idx = i
+                break
+
+        if apiversion_idx is None:
             continue
 
-        # Verify first_schema is a dict
-        first_schema = resource_schemas[0]
-        if not isinstance(first_schema, dict):
-            LOGGER.debug(f"Skipping malformed schema: first_schema is not a dict, got {type(first_schema)}")
+        # KIND is 2 columns after APIVERSION (APIVERSION, NAMESPACED, KIND)
+        if len(parts) <= apiversion_idx + 2:
             continue
 
-        # Get gvk_list via .get and ensure it is a list
-        gvk_list = first_schema.get("x-kubernetes-group-version-kind")
-        if not isinstance(gvk_list, list) or not gvk_list:
-            LOGGER.debug(
-                f"Skipping malformed schema: x-kubernetes-group-version-kind is not a non-empty list, got {type(gvk_list)}"
-            )
+        apiversion = parts[apiversion_idx]
+        kind = parts[apiversion_idx + 2]
+
+        # Extract group from apiversion: "velero.io/v1" -> "velero.io", "v1" -> ""
+        group = apiversion.rsplit("/", 1)[0] if "/" in apiversion else ""
+
+        cluster_kind_groups.setdefault(kind, set()).add(group)
+
+    # Build kind -> set of groups from existing mappings
+    existing_kind_groups: dict[str, set[str]] = {}
+    for _, resource_schemas in existing_resources_mapping.items():
+        if not isinstance(resource_schemas, list) or not resource_schemas:
             continue
 
-        # Iterate gvk_list items and for each item confirm it's a dict before calling .get("kind")
-        for gvk_item in gvk_list:
-            if not isinstance(gvk_item, dict):
-                LOGGER.debug(f"Skipping malformed gvk item: not a dict, got {type(gvk_item)}")
+        # Check ALL schemas in the list, not just the first one
+        for schema in resource_schemas:
+            if not isinstance(schema, dict):
                 continue
 
-            kind = gvk_item.get("kind")
-            # Check that kind is a non-empty string before adding to existing_kinds
-            if isinstance(kind, str) and kind.strip():
-                existing_kinds.add(kind.strip())
+            gvk_list = schema.get("x-kubernetes-group-version-kind")
+            if not isinstance(gvk_list, list) or not gvk_list:
+                continue
+
+            for gvk_item in gvk_list:
+                if not isinstance(gvk_item, dict):
+                    continue
+
+                kind = gvk_item.get("kind")
+                if not isinstance(kind, str) or not kind.strip():
+                    continue
+
+                kind = kind.strip()
+                group_raw = gvk_item.get("group", "")
+                group = group_raw.strip() if isinstance(group_raw, str) else ""
+
+                existing_kind_groups.setdefault(kind, set()).add(group)
+
+    # Find missing resources: kind is missing if any cluster group is not in existing groups
+    for kind, cluster_groups in cluster_kind_groups.items():
+        existing_groups = existing_kind_groups.get(kind, set())
+        if not cluster_groups.issubset(existing_groups):
+            missing_resources.add(kind)
 
-    missing_resources = cluster_resources - existing_kinds
     LOGGER.info(f"Found {len(missing_resources)} missing resources: {sorted(list(missing_resources)[:10])}")
 
     return missing_resources
@@ -661,9 +691,32 @@ def process_schema_definitions(
                         f"Added new schema version for existing resource: {kind_lower} ({group or 'core'}/{version})"
                     )
             else:
-                # Don't update existing resources when cluster version is older
-                LOGGER.debug(f"Skipping update for existing resource: {kind_lower}")
-                continue
+                # Older cluster: keep existing schemas untouched, but still add
+                # missing group/version variants for existing kinds.
+                existing_schemas = resources_mapping.get(kind_lower, [])
+                variant_exists = False
+                for existing_schema in existing_schemas:
+                    if not isinstance(existing_schema, dict):
+                        continue
+                    existing_gvk_list = existing_schema.get("x-kubernetes-group-version-kind") or []
+                    for existing_gvk in existing_gvk_list:
+                        if not isinstance(existing_gvk, dict):
+                            continue
+                        if existing_gvk.get("group") == group and existing_gvk.get("version") == version:
+                            variant_exists = True
+                            break
+                    if variant_exists:
+                        break
+
+                if variant_exists:
+                    LOGGER.debug(f"Skipping update for existing resource: {kind_lower}")
+                    continue
+
+                existing_schemas.append(schema_data)
+                updated_resources += 1
+                LOGGER.debug(
+                    f"Added missing schema variant for existing resource: {kind_lower} ({group or 'core'}/{version})"
+                )
 
             # Also store in definitions for separate definitions file
             definitions[schema_name] = schema_data

{openshift_python_wrapper-11.0.117 → openshift_python_wrapper-11.0.118}/class_generator/tests/test_schema_new_functions.py

@@ -306,16 +306,16 @@ class TestIdentifyMissingResources:
     @patch("class_generator.core.schema.run_command")
     def test_successful_missing_resources_identification(self, mock_run_command):
         """Test successful identification of missing resources."""
-        api_resources_output = """pods                          po           v1                    Pod
-services                      svc          v1                    Service
-deployments                   deploy       apps/v1               Deployment
-configmaps                    cm           v1                    ConfigMap"""
+        api_resources_output = """pods                              po           v1                             true         Pod
+services                          svc          v1                             true         Service
+deployments                       deploy       apps/v1                        true         Deployment
+configmaps                        cm           v1                             true         ConfigMap"""
 
         mock_run_command.return_value = (True, api_resources_output, "")
 
         existing_mapping = {
-            "pod": [{"x-kubernetes-group-version-kind": [{"kind": "Pod"}]}],
-            "service": [{"x-kubernetes-group-version-kind": [{"kind": "Service"}]}],
+            "pod": [{"x-kubernetes-group-version-kind": [{"group": "", "version": "v1", "kind": "Pod"}]}],
+            "service": [{"x-kubernetes-group-version-kind": [{"group": "", "version": "v1", "kind": "Service"}]}],
         }
 
         result = identify_missing_resources("kubectl", existing_mapping)
@@ -333,14 +333,14 @@ configmaps                    cm           v1                    ConfigMap"""
     @patch("class_generator.core.schema.run_command")
     def test_no_missing_resources(self, mock_run_command):
         """Test when no resources are missing."""
-        api_resources_output = """pods                          po           v1                    Pod
-services                      svc          v1                    Service"""
+        api_resources_output = """pods                              po           v1                             true         Pod
+services                          svc          v1                             true         Service"""
 
         mock_run_command.return_value = (True, api_resources_output, "")
 
         existing_mapping = {
-            "pod": [{"x-kubernetes-group-version-kind": [{"kind": "Pod"}]}],
-            "service": [{"x-kubernetes-group-version-kind": [{"kind": "Service"}]}],
+            "pod": [{"x-kubernetes-group-version-kind": [{"group": "", "version": "v1", "kind": "Pod"}]}],
+            "service": [{"x-kubernetes-group-version-kind": [{"group": "", "version": "v1", "kind": "Service"}]}],
         }
 
         result = identify_missing_resources("kubectl", existing_mapping)
@@ -349,7 +349,9 @@ services                      svc          v1                    Service"""
     @patch("class_generator.core.schema.run_command")
     def test_malformed_existing_mapping_handled(self, mock_run_command):
         """Test that malformed existing mapping is handled gracefully."""
-        api_resources_output = "pods                          po           v1                    Pod"
+        api_resources_output = (
+            "pods                              po           v1                             true         Pod"
+        )
         mock_run_command.return_value = (True, api_resources_output, "")
 
         # Malformed mapping - missing required structure
@@ -359,6 +361,166 @@ services                      svc          v1                    Service"""
         assert "Pod" in result
 
 
+class TestIdentifyMissingResourcesDuplicateKinds:
+    """Test identify_missing_resources with duplicate kinds across API groups."""
+
+    CLUSTER_OUTPUT_DUPLICATE_BACKUP = (
+        "configmaps                        cm           v1                                     true         ConfigMap\n"
+        "backups                                        velero.io/v1                           true         Backup\n"
+        "backups                                        postgresql.cnpg.noobaa.io/v1           true         Backup\n"
+        "widgets                                        example.com/v1                         true         Widget"
+    )
+
+    @pytest.mark.parametrize(
+        "test_id, existing_mapping, expected_missing",
+        [
+            pytest.param(
+                "duplicate_kind_one_group_covered",
+                {
+                    "backup": [
+                        {
+                            "x-kubernetes-group-version-kind": [
+                                {"group": "postgresql.cnpg.noobaa.io", "version": "v1", "kind": "Backup"}
+                            ],
+                            "namespaced": True,
+                        }
+                    ],
+                    "configmap": [
+                        {
+                            "x-kubernetes-group-version-kind": [{"group": "", "version": "v1", "kind": "ConfigMap"}],
+                            "namespaced": True,
+                        }
+                    ],
+                },
+                {"Backup", "Widget"},
+                id="duplicate_kind_one_group_covered",
+            ),
+            pytest.param(
+                "duplicate_kind_all_groups_covered",
+                {
+                    "backup_velero": [
+                        {
+                            "x-kubernetes-group-version-kind": [
+                                {"group": "velero.io", "version": "v1", "kind": "Backup"}
+                            ],
+                            "namespaced": True,
+                        }
+                    ],
+                    "backup_cnpg": [
+                        {
+                            "x-kubernetes-group-version-kind": [
+                                {"group": "postgresql.cnpg.noobaa.io", "version": "v1", "kind": "Backup"}
+                            ],
+                            "namespaced": True,
+                        }
+                    ],
+                    "configmap": [
+                        {
+                            "x-kubernetes-group-version-kind": [{"group": "", "version": "v1", "kind": "ConfigMap"}],
+                            "namespaced": True,
+                        }
+                    ],
+                    "widget": [
+                        {
+                            "x-kubernetes-group-version-kind": [
+                                {"group": "example.com", "version": "v1", "kind": "Widget"}
+                            ],
+                            "namespaced": True,
+                        }
+                    ],
+                },
+                set(),
+                id="duplicate_kind_all_groups_covered",
+            ),
+            pytest.param(
+                "completely_new_kind",
+                {
+                    "configmap": [
+                        {
+                            "x-kubernetes-group-version-kind": [{"group": "", "version": "v1", "kind": "ConfigMap"}],
+                            "namespaced": True,
+                        }
+                    ],
+                },
+                {"Backup", "Widget"},
+                id="completely_new_kind",
+            ),
+            pytest.param(
+                "core_api_resource_covered",
+                {
+                    "backup_velero": [
+                        {
+                            "x-kubernetes-group-version-kind": [
+                                {"group": "velero.io", "version": "v1", "kind": "Backup"}
+                            ],
+                            "namespaced": True,
+                        }
+                    ],
+                    "backup_cnpg": [
+                        {
+                            "x-kubernetes-group-version-kind": [
+                                {"group": "postgresql.cnpg.noobaa.io", "version": "v1", "kind": "Backup"}
+                            ],
+                            "namespaced": True,
+                        }
+                    ],
+                    "configmap": [
+                        {
+                            "x-kubernetes-group-version-kind": [{"group": "", "version": "v1", "kind": "ConfigMap"}],
+                            "namespaced": True,
+                        }
+                    ],
+                },
+                {"Widget"},
+                id="core_api_resource_covered",
+            ),
+        ],
+    )
+    @patch("class_generator.core.schema.run_command")
+    def test_identify_missing_resources_duplicate_kinds(
+        self,
+        mock_run_command,
+        test_id,
+        existing_mapping,
+        expected_missing,
+    ):
+        """Test identify_missing_resources correctly handles duplicate kinds across API groups."""
+        mock_run_command.return_value = (True, self.CLUSTER_OUTPUT_DUPLICATE_BACKUP, "")
+
+        result = identify_missing_resources("oc", existing_mapping)
+        assert result == expected_missing, f"[{test_id}] Expected {expected_missing}, got {result}"
+
+    def test_allow_updates_false_appends_missing_group_variant(self):
+        """Test that allow_updates=False still appends missing group variants for existing kinds."""
+        schemas = {
+            "apis/postgresql.cnpg.noobaa.io/v1": {
+                "components": {
+                    "schemas": {
+                        "io.example.Backup": {
+                            "type": "object",
+                            "x-kubernetes-group-version-kind": [
+                                {"group": "postgresql.cnpg.noobaa.io", "version": "v1", "kind": "Backup"}
+                            ],
+                        }
+                    }
+                }
+            }
+        }
+        existing_mapping = {
+            "backup": [{"x-kubernetes-group-version-kind": [{"group": "velero.io", "version": "v1", "kind": "Backup"}]}]
+        }
+
+        resources_mapping, _ = process_schema_definitions(
+            schemas=schemas,
+            namespacing_dict={"Backup": True},
+            existing_resources_mapping=existing_mapping,
+            allow_updates=False,
+        )
+
+        groups = {item["x-kubernetes-group-version-kind"][0].get("group", "") for item in resources_mapping["backup"]}
+        assert groups == {"velero.io", "postgresql.cnpg.noobaa.io"}
+
+
 class TestBuildDynamicResourceToApiMapping:
     """Test build_dynamic_resource_to_api_mapping function."""
 

{openshift_python_wrapper-11.0.117 → openshift_python_wrapper-11.0.118}/pyproject.toml

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

{openshift_python_wrapper-11.0.117 → openshift_python_wrapper-11.0.118}/uv.lock

@@ -1243,7 +1243,7 @@ wheels = [
 
 [[package]]
 name = "openshift-python-wrapper"
-version = "11.0.117"
+version = "11.0.118"
 source = { editable = "." }
 dependencies = [
     { name = "cloup" },

openshift_python_wrapper-11.0.117/.git

@@ -1 +0,0 @@
-gitdir: /tmp/github-webhook-openshift-python-wrapper-rafsx54n/.git/worktrees/github-webhook-openshift-python-wrapper-rafsx54n-worktree-64d4952f-1cfc-4271-a303-e0a96e3e4686