addd support policy sorting

Signed-off-by: sirutBuasai <sirutbuasai27@outlook.com>

Author: sirutBuasai

.kiro/steering/docs.md

@@ -172,6 +172,9 @@ from utils import render_table
 # Build a complete row (uses img.get_display() internally)
 row = build_image_row(img, columns)  # ["PyTorch 2.9", "py312", ...]
 
+# Build row with field overrides (e.g., for version consolidation in support_policy)
+row = build_image_row(img, columns, overrides={"version": "2.9"})
+
 # Render markdown table
 table = render_table(headers, rows)
 ```
@@ -216,7 +219,7 @@ To generate release notes for an image, add the following fields to the image co
 
 ```yaml
 # Required for release notes generation (both must be present)
-announcement:
+announcements:
   - "Introduced containers for PyTorch 2.9 for Training"
   - "Added Python 3.12 support"
 
@@ -236,14 +239,14 @@ optional:
 **Required fields for release notes** are defined in `constants.py`:
 
 ```python
-RELEASE_NOTES_REQUIRED_FIELDS = ["announcement", "packages"]
+RELEASE_NOTES_REQUIRED_FIELDS = ["announcements", "packages"]
 ```
 
 The `packages` field uses keys that map to display names in `global.yml` under `display_names`.
 
 ### Release Notes Generation
 
-Release notes are automatically generated for images that have all required fields (`announcement` and `packages`).
+Release notes are automatically generated for images that have all required fields (`announcements` and `packages`).
 
 **Output structure:**
 
@@ -275,7 +278,7 @@ This separation uses the `ImageConfig.is_supported` property.
 
 **Generated release note sections:**
 
-1. **Announcement** - Bullet list from `announcement` field
+1. **Announcements** - Bullet list from `announcements` field
 1. **Core Packages** - Table from `packages` field (keys mapped via `display_names`)
 1. **Security Advisory** - Hardcoded section with link to AWS Security Bulletin
 1. **Reference** - Docker image URIs (private ECR + public ECR if `public_registry: true`) and links to available_images.md and support_policy.md
@@ -357,11 +360,16 @@ table_order:
 
 The `framework_groups` configuration consolidates support policy rows by framework. Repositories in the same group are combined into a single row using the framework name (e.g., "PyTorch").
 
+**Version Display:**
+
+- Images with the same major.minor version (e.g., `2.6.0` and `2.6.1`) are consolidated into a single row displayed as `2.6` if they have identical GA/EOP dates
+- If patch versions have different GA/EOP dates, each is displayed separately with full version (e.g., `2.6.0`, `2.6.1`) and a warning is logged
+
 **Requirements:**
 
-- All repositories in a group that have a given version must have identical GA/EOP dates
+- All repositories in a group that have a given full version (X.Y.Z) must have identical GA/EOP dates
 - Missing versions in some repositories are allowed (only present repos are consolidated)
-- A `ValueError` is raised if dates differ within a group for the same version
+- A `ValueError` is raised if dates differ within a group for the same full version
 
 To add a new framework group, add an entry to `framework_groups` with the framework name as key and list of repositories as value.
 

docs/DEVELOPMENT.md

@@ -85,7 +85,12 @@ ga: "2025-10-15"    # General Availability date
 eop: "2026-10-15"   # End of Patch date
 ```
 
-**Validation:** All images in the same framework group with the same version must have identical GA/EOP dates.
+**Version Consolidation:**
+
+- Images with the same major.minor version (e.g., `2.6.0` and `2.6.1`) are consolidated into a single row displayed as `2.6` if they have identical GA/EOP dates
+- If patch versions have different GA/EOP dates, each is displayed separately with full version (e.g., `2.6.0`, `2.6.1`) and a warning is logged
+
+**Validation:** All images in the same framework group with the same full version (X.Y.Z) must have identical GA/EOP dates.
 
 ______________________________________________________________________
 

docs/src/generate.py

@@ -187,36 +187,66 @@ def generate_support_policy(dry_run: bool = False) -> str:
         if not images:
             continue
 
-        # Deduplicate by version, validating date consistency
-        version_map: dict[str, ImageConfig] = {}
+        # Group by major.minor, then decide display format based on date consistency
+        major_minor_groups: dict[str, list[ImageConfig]] = {}
         for img in images:
-            existing = version_map.get(img.version)
-            if existing and (existing.ga != img.ga or existing.eop != img.eop):
-                raise ValueError(
-                    f"Inconsistent dates for {framework_group} {img.version}: \n"
-                    f"\tExisting: {existing._repository}-{existing.version}-{existing.accelerator}-{existing.platform}\n"
-                    f"\tImage: {img._repository}-{img.version}-{img.accelerator}-{img.platform}\n"
-                    f"\t({existing.ga}, {existing.eop}) vs ({img.ga}, {img.eop})"
+            v = parse_version(img.version)
+            major_minor = f"{v.major}.{v.minor}"
+            major_minor_groups.setdefault(major_minor, []).append(img)
+
+        version_map: dict[str, ImageConfig] = {}
+        for major_minor, group in major_minor_groups.items():
+            # Check if all images in group have same ga/eop
+            first = group[0]
+            all_same_dates = all(img.ga == first.ga and img.eop == first.eop for img in group)
+
+            if all_same_dates:
+                # Consolidate to major.minor display
+                version_map[major_minor] = first
+            else:
+                # Keep full versions, warn about inconsistency
+                versions_info = ", ".join(f"{img.version} ({img.ga}, {img.eop})" for img in group)
+                LOGGER.warning(
+                    f"Different GA/EOP dates for {framework_group} patch versions: {versions_info}"
                 )
-            version_map[img.version] = img
+                # Keep each patch version as separate row with full version display
+                for img in group:
+                    existing = version_map.get(img.version)
+                    # Error if same full version (e.g., X.Y.Z) has different dates across images
+                    if existing and (existing.ga != img.ga or existing.eop != img.eop):
+                        raise ValueError(
+                            f"Inconsistent dates for {framework_group} {img.version}: \n"
+                            f"\tExisting: {existing._repository}-{existing.version}-{existing.accelerator}-{existing.platform}\n"
+                            f"\tImage: {img._repository}-{img.version}-{img.accelerator}-{img.platform}\n"
+                            f"\t({existing.ga}, {existing.eop}) vs ({img.ga}, {img.eop})"
+                        )
+                    # Deduplicate same full version with same dates
+                    version_map[img.version] = img
 
         # Merge legacy entries for this framework
         for legacy_img in legacy_data.get(framework_group, []):
             if legacy_img.version not in version_map:
                 version_map[legacy_img.version] = legacy_img
 
-        # Sort by version descending and separate supported/unsupported
-        for img in sort_by_version(list(version_map.values())):
-            (supported if img.is_supported else unsupported).append(img)
+        # Sort by version descending within this framework group
+        # Key is the display version (major.minor if consolidated, full version otherwise)
+        sorted_keys = sorted(
+            version_map.keys(), key=lambda k: parse_version(version_map[k].version), reverse=True
+        )
+        for key in sorted_keys:
+            img = version_map[key]
+            (supported if img.is_supported else unsupported).append((img, key))
 
     # Build tables
     table_config = load_table_config("extra/support_policy")
     columns = table_config.get("columns", [])
     headers = [col["header"] for col in columns]
 
-    supported_table = render_table(headers, [build_image_row(img, columns) for img in supported])
+    supported_table = render_table(
+        headers, [build_image_row(img, columns, {"version": ver}) for img, ver in supported]
+    )
     unsupported_table = render_table(
-        headers, [build_image_row(img, columns) for img in unsupported]
+        headers, [build_image_row(img, columns, {"version": ver}) for img, ver in unsupported]
     )
 
     # Render template

docs/src/image_config.py

@@ -167,13 +167,17 @@ def get_display(self, field: str) -> str:
         return str(value) if value is not None else "-"
 
 
-def build_image_row(img: ImageConfig, columns: list[dict]) -> list[str]:
+def build_image_row(img: ImageConfig, columns: list[dict], overrides: dict = None) -> list[str]:
     """Build a table row from an ImageConfig using column definitions.
 
     In tables/<table>.yml, the <field> name will map to img.<field> / img.get(<field>) attribute.
     If you need to do string manipulation on the field, create a new property with convention display_<field>.
+
+    Args:
+        overrides: Optional dict of field -> value to override img values (e.g., {"version": "2.6"})
     """
-    return [img.get_display(col["field"]) for col in columns]
+    overrides = overrides or {}
+    return [overrides.get(col["field"], img.get_display(col["field"])) for col in columns]
 
 
 def load_repository_images(repository: str) -> list[ImageConfig]: