Restructure GL flavors parsing and module structure

Signed-off-by: Tobias Wolf <[email protected]>

Author: NotTheEvilOne

src/gardenlinux/__init__.py

@@ -0,0 +1 @@
+from .parser import Parser

src/python_gardenlinux_lib/constants.py src/gardenlinux/constants.pysrc/python_gardenlinux_lib/constants.py renamed to src/gardenlinux/constants.py

@@ -5,10 +5,8 @@
 import json
 import os
 import sys
-import yaml
 
-from jsonschema import ValidationError
-from .parser import group_by_arch, parse_flavors, validate_flavors
+from .parser import Parser
 
 
 def generate_markdown_table(combinations, no_arch):
@@ -93,16 +91,10 @@ def main():
         sys.exit(f"Error: {flavors_file} does not exist.")
 
     # Load and validate the flavors.yaml
-    with open(flavors_file, 'r') as file:
-        flavors_data = yaml.safe_load(file)
+    with open(flavors_file, "r") as file:
+        flavors_data = file.read()
 
-    try:
-        validate_flavors(flavors_data)
-    except ValidationError as e:
-        sys.exit(f"Validation Error: {e.message}")
-
-    combinations = parse_flavors(
-        flavors_data,
+    combinations = Parser(flavors_data).filter(
         include_only_patterns=args.include_only,
         wildcard_excludes=args.exclude,
         only_build=args.build,
@@ -114,7 +106,7 @@ def main():
     )
 
     if args.json_by_arch:
-        grouped_combinations = group_by_arch(combinations)
+        grouped_combinations = Parser.group_by_arch(combinations)
 
         # If --no-arch, strip architectures from the grouped output
         if args.no_arch:
@@ -128,7 +120,7 @@ def main():
         print(generate_markdown_table(combinations, args.no_arch))
     else:
         if args.no_arch:
-            printable_combinations = sorted(set(remove_arch(combinations)))
+            printable_combinations = sorted(set(Parser.remove_arch(combinations)))
         else:
             printable_combinations = sorted(set(comb[1] for comb in combinations))
 

src/gardenlinux/flavors/__init__.py

@@ -0,0 +1,123 @@
+from jsonschema import validate as jsonschema_validate
+import fnmatch
+import logging
+import yaml
+
+from ..constants import GL_FLAVORS_SCHEMA
+
+class Parser(object):
+    def __init__(self, data, logger = None):
+        flavors_data = (yaml.safe_load(data) if isinstance(data, str) else data)
+        jsonschema_validate(instance=flavors_data, schema=GL_FLAVORS_SCHEMA)
+
+        self._flavors_data = flavors_data
+        self._logger = logger
+
+        if self._logger is None:
+            self._logger = logging.getLogger("gardenlinux.flavors")
+
+        if not self._logger.hasHandlers():
+            self._logger.addHandler(logging.NullHandler())
+
+        self._logger.debug("flavors.Parser initialized with data: {0!r}".format(flavors_data))
+
+    def filter(
+        self,
+        include_only_patterns=[],
+        wildcard_excludes=[],
+        only_build=False,
+        only_test=False,
+        only_test_platform=False,
+        only_publish=False,
+        filter_categories=[],
+        exclude_categories=[]
+    ):
+        """Parses the flavors.yaml file and generates combinations."""
+        self._logger.debug("flavors.Parser filtering with {0}".format(locals()))
+
+        combinations = []  # Use a list for consistent order
+
+        for target in self._flavors_data['targets']:
+            name = target['name']
+            category = target.get('category', '')
+
+            # Apply category filters
+            if filter_categories and category not in filter_categories:
+                continue
+            if exclude_categories and category in exclude_categories:
+                continue
+
+            for flavor in target['flavors']:
+                features = flavor.get('features', [])
+                arch = flavor.get('arch', 'amd64')
+                build = flavor.get('build', False)
+                test = flavor.get('test', False)
+                test_platform = flavor.get('test-platform', False)
+                publish = flavor.get('publish', False)
+
+                # Apply flag-specific filters in the order: build, test, test-platform, publish
+                if only_build and not build:
+                    continue
+                if only_test and not test:
+                    continue
+                if only_test_platform and not test_platform:
+                    continue
+                if only_publish and not publish:
+                    continue
+
+                # Process features
+                formatted_features = f"-{'-'.join(features)}" if features else ""
+
+                # Construct the combination
+                combination = f"{name}-{formatted_features}-{arch}"
+
+                # Format the combination to clean up "--" and "-_"
+                combination = combination.replace("--", "-").replace("-_", "_")
+
+                # Exclude combinations explicitly
+                if Parser.should_exclude(combination, [], wildcard_excludes):
+                    continue
+
+                # Apply include-only filters
+                if not Parser.should_include_only(combination, include_only_patterns):
+                    continue
+
+                combinations.append((arch, combination))
+
+        return sorted(combinations, key=lambda platform: platform[1].split("-")[0])  # Sort by platform name
+
+    @staticmethod
+    def group_by_arch(combinations):
+        """Groups combinations by architecture into a JSON dictionary."""
+        arch_dict = {}
+        for arch, combination in combinations:
+            arch_dict.setdefault(arch, []).append(combination)
+        for arch in arch_dict:
+            arch_dict[arch] = sorted(set(arch_dict[arch]))  # Deduplicate and sort
+        return arch_dict
+
+    @staticmethod
+    def remove_arch(combinations):
+        """Removes the architecture from combinations."""
+        return [combination.replace(f"-{arch}", "") for arch, combination in combinations]
+
+    @staticmethod
+    def should_exclude(combination, excludes, wildcard_excludes):
+        """
+        Checks if a combination should be excluded based on exact match or wildcard patterns.
+        """
+        # Exclude if in explicit excludes
+        if combination in excludes:
+            return True
+        # Exclude if matches any wildcard pattern
+        return any(fnmatch.fnmatch(combination, pattern) for pattern in wildcard_excludes)
+
+    @staticmethod
+    def should_include_only(combination, include_only_patterns):
+        """
+        Checks if a combination should be included based on `--include-only` wildcard patterns.
+        If no patterns are provided, all combinations are included by default.
+        """
+        if not include_only_patterns:
+            return True
+        return any(fnmatch.fnmatch(combination, pattern) for pattern in include_only_patterns)

…thon_gardenlinux_lib/flavors/__main__.py src/gardenlinux/flavors/__main__.pysrc/python_gardenlinux_lib/flavors/__main__.py renamed to src/gardenlinux/flavors/__main__.py src/python_gardenlinux_lib/flavors/__main__.py renamed to src/gardenlinux/flavors/__main__.py

@@ -1,24 +1,18 @@
 #!/usr/bin/env python
 
+# @TODO: This code is provided for backward compatibility only and deprecated.
+
+from gardenlinux.flavors.parser import Parser
 from git import Git
 import base64
 import json
 import logging
 import os
+import sys
 import subprocess
 import yaml
 
-from .parser import (
-    group_by_arch,
-    remove_arch,
-    should_include_only,
-    should_exclude,
-    validate_flavors
-)
-
-from .parser import parse_flavors as parse_flavors_data
-
-from ..constants import GL_FLAVORS_SCHEMA
+from gardenlinux.constants import GL_FLAVORS_SCHEMA
 
 # Define the schema for validation
 SCHEMA = GL_FLAVORS_SCHEMA
@@ -29,6 +23,52 @@ def find_repo_root():
 
     return Git(".").rev_parse("--show-superproject-working-tree")
 
+def validate_flavors(data):
+    """Validate the flavors.yaml data against the schema."""
+    try:
+        validate(instance=data, schema=SCHEMA)
+    except ValidationError as e:
+        sys.exit(f"Validation Error: {e.message}")
+
+
+def should_exclude(combination, excludes, wildcard_excludes):
+    """
+    Checks if a combination should be excluded based on exact match or wildcard patterns.
+    """
+    return Parser.should_exclude(combination, excludes, wildcard_excludes)
+
+
+def should_include_only(combination, include_only_patterns):
+    """
+    Checks if a combination should be included based on `--include-only` wildcard patterns.
+    If no patterns are provided, all combinations are included by default.
+    """
+    return Parser.should_include_only(combination, include_only_patterns)
+
+
+def parse_flavors_data(
+    data,
+    include_only_patterns=None,
+    wildcard_excludes=None,
+    only_build=False,
+    only_test=False,
+    only_test_platform=False,
+    only_publish=False,
+    filter_categories=None,
+    exclude_categories=None,
+):
+    """Parse flavors.yaml data and generate combinations."""
+    return Parser(data).filter(
+        include_only_patterns,
+        wildcard_excludes,
+        only_build,
+        only_test,
+        only_test_platform,
+        only_publish,
+        filter_categories,
+        exclude_categories
+    )
+
 def _get_flavors_from_github(commit):
     """Returns the flavors.yaml from GitHub if readable."""
 
@@ -87,7 +127,7 @@ def parse_flavors_commit(
     """
 
     if logger is None:
-        logger = logging.getLogger("gardenlinux.lib.flavors")
+        logger = logging.getLogger("gardenlinux.flavors")
         logger.addHandler(logging.NullHandler())
 
     version_info = (

src/gardenlinux/flavors/parser.py

@@ -8,7 +8,7 @@
 import pytest
 from dotenv import load_dotenv
 
-GL_ROOT_DIR = "test-data/gardenlinux/"
+GL_ROOT_DIR = "test-data/gardenlinux"
 
 
 def write_zot_config(config_dict, file_path):

src/python_gardenlinux_lib/flavors/parse_flavors.py

@@ -1,5 +1,3 @@
-from idlelib.window import registry
-
 import pytest
 import os