openshift-python-wrapper 4.21.0__tar.gz → 4.22.0__tar.gz

{openshift_python_wrapper-4.21.0 → openshift_python_wrapper-4.22.0}/.pre-commit-config.yaml

@@ -45,7 +45,7 @@ repos:
           ]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.15.0
+    rev: v0.15.17
     hooks:
       - id: ruff
       - id: ruff-format
@@ -56,7 +56,7 @@ repos:
       - id: gitleaks
 
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.19.1
+    rev: v2.1.0
     hooks:
       - id: mypy
         exclude: ^(tests/|examples/|docs/)

{openshift_python_wrapper-4.21.0 → openshift_python_wrapper-4.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openshift-python-wrapper
-Version: 4.21.0
+Version: 4.22.0
 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/
@@ -20,7 +20,7 @@ Requires-Dist: deepdiff>=8.0.1
 Requires-Dist: fastmcp>=2.10.4
 Requires-Dist: jinja2>=3.1.4
 Requires-Dist: jsonschema>=4.20.0
-Requires-Dist: kubernetes>=31.0.0
+Requires-Dist: kubernetes<36,>=31.0.0
 Requires-Dist: packaging>=24.1
 Requires-Dist: pyhelper-utils>=0.0.42
 Requires-Dist: python-benedict>=0.33.2

{openshift_python_wrapper-4.21.0 → openshift_python_wrapper-4.22.0}/class_generator/cli.py

@@ -489,7 +489,7 @@ def handle_test_generation(add_tests: bool) -> None:
         # Run the generated test file
         LOGGER.info("Running generated tests...")
         test_file = "class_generator/tests/test_class_generator.py"
-        exit_code = os.system(f"uv run pytest {test_file}")
+        exit_code = os.system(f"uv run --group tests pytest {test_file}")
 
         # os.system returns the exit status shifted left by 8 bits
         if exit_code != 0:

{openshift_python_wrapper-4.21.0 → openshift_python_wrapper-4.22.0}/class_generator/core/generator.py

@@ -2,6 +2,7 @@
 
 import filecmp
 import os
+import re
 from pathlib import Path
 from typing import Any
 
@@ -55,6 +56,16 @@ def generate_resource_file_from_dict(
 
     output = "# Generated using https://github.com/RedHatQE/openshift-python-wrapper/blob/main/scripts/resource/README.md\n\n"
     formatted_kind_str = convert_camel_case_to_snake_case(name=resource_dict["kind"])
+
+    if re.search(r"_[a-z]_", formatted_kind_str):
+        msg = (
+            f"'{resource_dict['kind']}' produced invalid filename '{formatted_kind_str}.py'.\n"
+            f"Add '{resource_dict['kind']}' acronym to 'normalize_acronyms' dict in:\n"
+            f"  ocp_resources/utils/utils.py -> convert_camel_case_to_snake_case()"
+        )
+        LOGGER.error(msg)
+        raise ValueError(msg)
+
     _file_suffix: str = f"{'_' + output_file_suffix if output_file_suffix else ''}"
 
     if add_tests:
@@ -94,8 +105,10 @@ def generate_resource_file_from_dict(
         output += rendered
 
     if dry_run:
+        console = Console()
+        console.print(f"\n[bold green]Would create file:[/bold green] {_output_file}")
         _code = Syntax(code=output, lexer="python", line_numbers=True)
-        Console().print(_code)
+        console.print(_code)
 
     else:
         write_and_format_rendered(filepath=_output_file, output=output)

{openshift_python_wrapper-4.21.0 → openshift_python_wrapper-4.22.0}/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-4.22.0/class_generator/formatters/file_writer.py

@@ -0,0 +1,71 @@
+"""File writing utilities for generated code."""
+
+from pathlib import Path
+
+from pyhelper_utils.shell import run_command
+from simple_logger.logger import get_logger
+
+LOGGER = get_logger(name=__name__)
+
+# Project root directory (contains pyproject.toml and .pre-commit-config.yaml)
+_PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
+
+
+def write_and_format_rendered(filepath: str, output: str) -> None:
+    """
+    Write rendered content to file and format with prek, falling back to ruff.
+
+    Args:
+        filepath: Path to write the file to
+        output: Content to write
+    """
+    with open(filepath, "w", encoding="utf-8") as fd:
+        fd.write(output)
+
+    pre_commit_config = str(_PROJECT_ROOT / ".pre-commit-config.yaml")
+    pyproject_toml = str(_PROJECT_ROOT / "pyproject.toml")
+
+    # Try prek first (runs all pre-commit hooks including ruff)
+    prek_success = False
+    try:
+        rc, stdout, stderr = run_command(
+            command=["uvx", "prek", "-c", pre_commit_config, "run", "--files", filepath],
+            verify_stderr=False,
+            check=False,
+            log_errors=False,
+        )
+        if not rc:
+            if stderr:
+                LOGGER.warning(f"Prek hooks failed for {filepath}, falling back to ruff.")
+                LOGGER.debug(f"prek stderr: {stderr}")
+            else:
+                prek_success = True
+
+            if stdout:
+                LOGGER.info(f"{filepath} fixed by prek")
+                LOGGER.debug(f"prek stdout: {stdout}")
+    except Exception as e:
+        LOGGER.warning(f"Failed to run prek for {filepath}, falling back to ruff: {e}")
+
+    if not prek_success:
+        _run_ruff_fallback(filepath=filepath, pyproject_toml=pyproject_toml)
+
+
+def _run_ruff_fallback(filepath: str, pyproject_toml: str) -> None:
+    """Run ruff check --fix and ruff format as fallback when prek fails."""
+    for ruff_cmd in (
+        ["uvx", "ruff", "check", "--fix", "--config", pyproject_toml, filepath],
+        ["uvx", "ruff", "format", "--config", pyproject_toml, filepath],
+    ):
+        try:
+            _, stdout, _ = run_command(
+                command=ruff_cmd,
+                verify_stderr=False,
+                check=False,
+                log_errors=False,
+            )
+            if stdout:
+                LOGGER.info(f"{filepath} fixed by ruff")
+                LOGGER.debug(f"ruff stdout: {stdout}")
+        except Exception as e:
+            LOGGER.error(f"Ruff fallback failed for {filepath}: {e}")

{openshift_python_wrapper-4.21.0 → openshift_python_wrapper-4.22.0}/class_generator/manifests/class_generator_template.j2

@@ -14,8 +14,12 @@
 {% endfor %}
 
 from typing import Any
-from ocp_resources.resource import {{ base_class }}
+
+{% if all_required_args %}
 from ocp_resources.exceptions import MissingRequiredArgumentError
+{% endif %}
+from ocp_resources.resource import {{ base_class }}
+
 
 class {{ kind }}({{ base_class }}):
     """

{openshift_python_wrapper-4.21.0 → openshift_python_wrapper-4.22.0}/class_generator/parsers/explain_parser.py

@@ -89,7 +89,7 @@ def parse_explain(kind: str) -> list[dict[str, Any]]:
 
         resource_dict: dict[str, Any] = {
             "base_class": "NamespacedResource" if namespaced else "Resource",
-            "description": _kind_schema.get("description", MISSING_DESCRIPTION_STR),
+            "description": _kind_schema.get("description") or MISSING_DESCRIPTION_STR,
             "fields": [],
             "spec": [],
         }

{openshift_python_wrapper-4.21.0 → openshift_python_wrapper-4.22.0}/class_generator/parsers/user_code_parser.py

@@ -60,8 +60,7 @@ def parse_user_code_from_file(file_path: str) -> tuple[str, str]:
                 "from typing import Any",
                 "from ocp_resources.resource import NamespacedResource",
                 "from ocp_resources.resource import Resource",
-                "from ocp_resources.resource import NamespacedResource, MissingRequiredArgumentError",
-                "from ocp_resources.resource import Resource, MissingRequiredArgumentError",
+                "from ocp_resources.exceptions import MissingRequiredArgumentError",
             }
 
             for _import in imports:

openshift_python_wrapper-4.22.0/class_generator/schema/__cluster_version__.txt

@@ -0,0 +1 @@
+v1.35.2