Add support for nested versions (#2)

Author: thepetk

main.py

@@ -55,9 +55,19 @@ def main():
             )
             continue
 
-        latest_version = sorted(package.versions, key=lambda v: v.version)[-1].version
-
-        if not rhdh_plugin_needs_update(latest_version, plugin.current_version):
+        # sort by version, considering dual versions
+        latest_package_version = sorted(
+            package.versions, key=lambda v: (v.version, v.second_version or "")
+        )[-1]
+        latest_version = latest_package_version.version
+        latest_second_version = latest_package_version.second_version
+
+        if not rhdh_plugin_needs_update(
+            latest_version,
+            plugin.current_version,
+            latest_second_version,
+            plugin.current_second_version,
+        ):
             logger.info(
                 f"plugin {plugin.plugin_name} is up-to-date "
                 f"(version: {plugin.current_version})"
@@ -72,7 +82,11 @@ def main():
         if UPDATE_PR_STRATEGY == GithubPullRequestStrategy.JOINT:
             logger.debug("caching plugin update for joint PR...")
             plugin_updates.append(
-                RHDHPluginUpdate(rhdh_plugin=plugin, new_version=latest_version)
+                RHDHPluginUpdate(
+                    rhdh_plugin=plugin,
+                    new_version=latest_version,
+                    new_second_version=latest_second_version,
+                )
             )
             continue
 
@@ -84,7 +98,7 @@ def main():
 
         try:
             updated_yaml = rhdh_config_updater.update_rhdh_plugin(
-                plugin, latest_version
+                plugin, latest_version, latest_second_version
             )
 
             pr_url = gh_api_client.create_pull_request(

src/github_api_client.py

@@ -5,7 +5,6 @@
 from github import Auth, Github
 from github.ContentFile import ContentFile
 from github.Repository import Repository
-from packaging.version import Version
 from requests import Response
 
 from src.constants import GITHUB_REF, UPDATE_PR_STRATEGY, logger
@@ -16,7 +15,7 @@
     RHDHPluginPackageVersion,
     RHDHPluginUpdaterConfig,
 )
-from src.utils import match_tag_prefix
+from src.utils import match_tag_prefix, parse_dual_version
 
 
 class GithubAPIClient:
@@ -111,12 +110,17 @@ def _convert_to_rhdh_plugin_package(
             if not isinstance(created_at, str):
                 continue
 
+            # remove prefix and parse potential dual version
+            version_string = tag.replace(matched_prefix, "")
+            version, second_version = parse_dual_version(version_string)
+
             logger.debug(f"found version {tag} for package {package_name}")
             versions.append(
                 RHDHPluginPackageVersion(
                     name=str(v.get("name", "")),
-                    version=Version(tag.replace(matched_prefix, "")),
+                    version=version,
                     created_at=created_at,
+                    second_version=second_version,
                 )
             )
 

src/loader.py

@@ -10,7 +10,7 @@
 )
 from src.exceptions import InvalidRHDHPluginPackageDefinitionException
 from src.types import RHDHPlugin, RHDHPluginUpdaterConfig
-from src.utils import get_plugins_list_from_dict, match_tag_prefix
+from src.utils import get_plugins_list_from_dict, match_tag_prefix, parse_dual_version
 
 
 class RHDHPluginsConfigLoader:
@@ -37,7 +37,9 @@ def _fetch_plugins_by_location(
 
         return plugins_list if isinstance(plugins_list, list) else []
 
-    def _parse_package_string(self, package: "str") -> "dict[str, str | Version]":
+    def _parse_package_string(
+        self, package: "str"
+    ) -> "dict[str, str | Version | None]":
         """
         parses the OCI package string to extract plugin info.
 
@@ -89,13 +91,16 @@ def _parse_package_string(self, package: "str") -> "dict[str, str | Version]":
                 f"Tag {raw_version} not valid for package {package}"
             )
 
-        version = Version(version=raw_version.replace(matched_prefix, ""))
+        # remove prefix and parse potential dual version
+        version_string = raw_version.replace(matched_prefix, "")
+        version, second_version = parse_dual_version(version_string)
 
         package_name = f"rhdh-plugin-export-overlays/{name}"
 
         return {
             "package_name": package_name,
             "version": version,
+            "second_version": second_version,
             "plugin_name": plugin_name,
         }
 
@@ -134,6 +139,7 @@ def _convert_rhdhplugin_list(
                     current_version=parsed["version"],  # type: ignore
                     plugin_name=str(parsed["plugin_name"]),
                     disabled=disabled,
+                    current_second_version=parsed.get("second_version"),  # type: ignore
                 )
             )
         return rhdh_plugins

src/types.py

@@ -15,6 +15,7 @@ class RHDHPluginPackageVersion:
     name: "str"
     version: "Version"
     created_at: "str"
+    second_version: "Version | None" = None
 
 
 @dataclass
@@ -37,6 +38,7 @@ class RHDHPlugin:
     current_version: "Version"
     plugin_name: "str"
     disabled: "bool"
+    current_second_version: "Version | None" = None
 
 
 @dataclass
@@ -47,6 +49,7 @@ class RHDHPluginUpdate:
 
     rhdh_plugin: "RHDHPlugin"
     new_version: "Version"
+    new_second_version: "Version | None" = None
 
 
 class RHDHPluginUpdaterConfig:

src/updater.py

@@ -23,13 +23,27 @@ def __init__(
         self.config_path = config_path
         self.config_location = config_location
 
+    def _build_version_string(
+        self, version: "Version", second_version: "Version | None" = None
+    ) -> "str":
+        """
+        builds a version string, including second version if present
+        """
+        if second_version:
+            return f"{version}__{second_version}"
+        return str(version)
+
     def _find_current_tag_prefix(self, content: "str", plugin: "RHDHPlugin") -> "str":
         """
         finds which tag prefix is currently being used for the plugin
         by searching the content for the plugin with any of the configured prefixes
         """
+        version_string = self._build_version_string(
+            plugin.current_version, plugin.current_second_version
+        )
+
         for prefix in RHDHPluginUpdaterConfig.GH_PACKAGE_TAG_PREFIX:
-            test_tag = f"{prefix}{plugin.current_version}"
+            test_tag = f"{prefix}{version_string}"
             pattern = re.compile(
                 rf"package:\s+(?:oci://)?[^\s]*{re.escape(plugin.plugin_name)}[^\s]*:{re.escape(test_tag)}![^\s]*",
                 re.MULTILINE,
@@ -44,20 +58,26 @@ def _update_plugin_version_in_content(
         content: "str",
         plugin: "RHDHPlugin",
         new_version: "Version",
+        new_second_version: "Version | None" = None,
     ) -> "str":
         """
         update a single plugin version in the YAML content using string replacement.
         This preserves the original YAML formatting.
         """
+        new_version_string = self._build_version_string(new_version, new_second_version)
         logger.debug(
-            f"updating config for plugin {plugin.plugin_name} to version {new_version}"
+            f"updating config for plugin {plugin.plugin_name} "
+            f"to version {new_version_string}"
         )
 
         # Find which tag prefix is currently used for this plugin
         current_prefix = self._find_current_tag_prefix(content, plugin)
 
-        old_tag = f"{current_prefix}{plugin.current_version}"
-        new_tag = f"{current_prefix}{new_version}"
+        old_version_string = self._build_version_string(
+            plugin.current_version, plugin.current_second_version
+        )
+        old_tag = f"{current_prefix}{old_version_string}"
+        new_tag = f"{current_prefix}{new_version_string}"
 
         # pattern to find the specific plugin's package line with the old version
         pattern = re.compile(
@@ -71,12 +91,12 @@ def _update_plugin_version_in_content(
         if updated_content != content:
             logger.debug(
                 f"updated config for {plugin.plugin_name} from "
-                f"{plugin.current_version} to {new_version}"
+                f"{old_version_string} to {new_version_string}"
             )
         else:
             logger.warning(
                 f"no match found for plugin {plugin.plugin_name} with version "
-                f"{plugin.current_version}"
+                f"{old_version_string}"
             )
 
         return updated_content
@@ -85,6 +105,7 @@ def update_rhdh_plugin(
         self,
         rhdh_plugin: "RHDHPlugin",
         new_version: "Version",
+        new_second_version: "Version | None" = None,
     ) -> "str":
         """
         updates a single plugin and return the updated YAML content.
@@ -93,7 +114,7 @@ def update_rhdh_plugin(
             content = f.read()
 
         updated_content = self._update_plugin_version_in_content(
-            content, rhdh_plugin, new_version
+            content, rhdh_plugin, new_version, new_second_version
         )
 
         return updated_content
@@ -110,7 +131,10 @@ def bulk_update_rhdh_plugins(
 
         for update in updates:
             content = self._update_plugin_version_in_content(
-                content, update.rhdh_plugin, update.new_version
+                content,
+                update.rhdh_plugin,
+                update.new_version,
+                update.new_second_version,
             )
 
         return content

src/utils.py

@@ -24,13 +24,69 @@ def get_plugins_list_from_dict(
     return [] if not isinstance(current, list) else current
 
 
+def parse_dual_version(version_string: "str") -> "tuple[Version, Version | None]":
+    """
+    parses a version string that may contain dual versions separated by '__'.
+    """
+    if "__" in version_string:
+        parts = version_string.split("__", 1)
+        if len(parts) == 2 and parts[1]:
+            return (Version(parts[0]), Version(parts[1]))
+
+    # single version or invalid dual version
+    return (Version(version_string.split("__")[0]), None)
+
+
+def compare_versions(
+    version1: "Version",
+    version2: "Version",
+    secondary1: "Version | None" = None,
+    secondary2: "Version | None" = None,
+) -> "int":
+    """
+    compares two versions with optional secondary versions
+    """
+    # compare primary versions
+    if version1 < version2:
+        return -1
+    if version1 > version2:
+        return 1
+
+    # primary versions are equal, compare secondary versions
+    if secondary1 is None and secondary2 is None:
+        return 0
+
+    if secondary1 is None:
+        return -1  # version2 has secondary, so it's greater
+
+    if secondary2 is None:
+        return 1  # version1 has secondary, so it's greater
+
+    # both have secondary versions
+    if secondary1 < secondary2:
+        return -1
+    if secondary1 > secondary2:
+        return 1
+
+    return 0
+
+
 def rhdh_plugin_needs_update(
-    latest_version: "Version", current_version: "Version"
+    latest_version: "Version",
+    current_version: "Version",
+    latest_secondary: "Version | None" = None,
+    current_secondary: "Version | None" = None,
 ) -> "bool":
     """
-    checks if the latest version is greater than the current version
+    checks if the latest version is greater than the current version.
+    supports dual versions with optional secondary version components.
     """
-    return latest_version > current_version
+    return (
+        compare_versions(
+            latest_version, current_version, latest_secondary, current_secondary
+        )
+        > 0
+    )
 
 
 def match_tag_prefix(tag: "str") -> "str | None":

tests/conftest.py

@@ -252,3 +252,41 @@ def sample_plugin_with_previous_prefix() -> "RHDHPlugin":
         plugin_name="another-plugin",
         disabled=False,
     )
+
+
+@pytest.fixture
+def sample_yaml_content_with_dual_versions() -> "str":
+    """
+    creates a sample YAML content with plugins using dual versions.
+    """
+    return """global:
+  dynamic:
+    plugins:
+      - disabled: false
+        package: oci://ghcr.io/redhat-developer/rhdh-plugin-export-overlays/dual-version-plugin:next__1.42.5__0.1.0!dual-version-plugin
+      - disabled: false
+        package: oci://ghcr.io/redhat-developer/rhdh-plugin-export-overlays/backstage-plugin-mcp-actions-backend:next__0.1.2!backstage-plugin-mcp-actions-backend
+"""
+
+
+@pytest.fixture
+def temp_yaml_file_with_dual_versions() -> "Any":
+    """
+    creates a temporary YAML file with dual version plugins for testing.
+    """
+    content = """global:
+  dynamic:
+    plugins:
+      - disabled: false
+        package: oci://ghcr.io/redhat-developer/rhdh-plugin-export-overlays/dual-version-plugin:next__1.42.5__0.1.0!dual-version-plugin
+      - disabled: false
+        package: oci://ghcr.io/redhat-developer/rhdh-plugin-export-overlays/backstage-plugin-mcp-actions-backend:next__0.1.2!backstage-plugin-mcp-actions-backend
+"""
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f:
+        f.write(content)
+        temp_path = f.name
+
+    yield temp_path
+
+    # clean temp files
+    Path(temp_path).unlink()