Fix: Modify the group labels when render_formats() is called (#769)

* modify the stub formats when render_formats() is called

* Refactor rowgroup label update logic into helper fn

* Add tests for row group label formatting

* Move update_group_row_labels into Stub

---------

Co-authored-by: Michael Chow <mc_al_github@fastmail.com>
Co-authored-by: Richard Iannone <riannone@me.com>

Author: 3 people

great_tables/_gt_data.py

@@ -24,6 +24,7 @@
     copy_data,
     create_empty_frame,
     get_column_names,
+    is_na,
     n_rows,
     to_list,
     validate_frame,
@@ -626,6 +627,49 @@ def order_groups(self, group_order: RowGroups) -> Self:
         # TODO: validate
         return self.__class__(self.rows, self.group_rows.reorder(group_order))
 
+    def update_group_row_labels(self, body: Body, tbl_data: TblData, boxhead: Boxhead) -> Self:
+        """Update group row labels using formatted values from the rendered body.
+
+        For each group, the formatted cell value for the first row of the group is
+        looked up in `body`. If the cell was not formatted (i.e., it is still NA),
+        the original value from `tbl_data` is used instead.
+
+        If no row-group column exists in `boxhead`, the stub is returned unchanged.
+
+        Parameters
+        ----------
+        body
+            The rendered body whose cells may contain formatted values.
+        tbl_data
+            The original (unformatted) source data.
+        boxhead
+            The boxhead containing column metadata, used to identify the row-group column.
+
+        Returns
+        -------
+        Stub
+            A new Stub with group labels replaced by formatted values, or the
+            original Stub if no row-group column exists.
+        """
+        rowgroup_var = boxhead._get_row_group_column()
+        if rowgroup_var is None:
+            return self
+
+        new_group_rows: list[Any] = []
+
+        for group_row in self.group_rows:
+            first_index = group_row.indices[0]
+            cell_content = _get_cell(body.body, first_index, rowgroup_var.var)
+
+            # When no formatter was applied, the cell is still NA — fall back to
+            # the original data value.
+            if is_na(tbl_data, cell_content):
+                cell_content = _get_cell(tbl_data, first_index, rowgroup_var.var)
+
+            new_group_rows.append(group_row.with_group_label(cell_content))
+
+        return self.__class__(self.rows, GroupRows(new_group_rows))
+
     def group_indices_map(self) -> list[tuple[int, GroupRowInfo | None]]:
         return self.group_rows.indices_map(len(self.rows))
 
@@ -717,6 +761,10 @@ def defaulted_label(self) -> str:
         label = self.group_label if self.group_label is not None else self.group_id
         return label
 
+    def with_group_label(self, label: str | None) -> Self:
+        """Return a copy of the object with the specified group label."""
+        return replace(self, group_label=label)
+
 
 class MISSING_GROUP:
     """Represent a category of all missing group levels in data."""

great_tables/_row_groups.py

@@ -1 +0,0 @@
-from __future__ import annotations

great_tables/gt.py

@@ -320,7 +320,11 @@ def _render_formats(self, context: str) -> Self:
         # TODO: this body method performs a mutation. Should we make a copy of body?
         new_body.render_formats(self._tbl_data, self._formats, context)
         new_body.render_formats(self._tbl_data, self._substitutions, context)
-        return self._replace(_body=new_body)
+
+        # Update group row labels with formatted values when a row_group column exists
+        new_stub = self._stub.update_group_row_labels(new_body, self._tbl_data, self._boxhead)
+
+        return self._replace(_body=new_body, _stub=new_stub)
 
     def _build_data(self, context: str) -> Self:
         # Build the body of the table by generating a dictionary

tests/test_row_groups.py

@@ -0,0 +1,85 @@
+import pandas as pd
+import pytest
+
+from great_tables import GT
+from great_tables._gt_data import Body, GroupRowInfo, GroupRows, Stub, RowInfo
+
+
+@pytest.fixture
+def grouped_gt():
+    """A GT table with a groupname column and two groups."""
+    df = pd.DataFrame(
+        {
+            "group": ["A", "A", "B", "B"],
+            "value": [1, 2, 3, 4],
+        }
+    )
+    return GT(df, groupname_col="group")
+
+
+@pytest.fixture
+def numeric_grouped_gt():
+    """A GT table with a numeric groupname column and two groups."""
+    df = pd.DataFrame(
+        {
+            "group": [1000, 1000, 2000, 2000],
+            "value": [1, 2, 3, 4],
+        }
+    )
+    return GT(df, groupname_col="group")
+
+
+def test_update_group_row_labels_uses_formatted_value(numeric_grouped_gt: GT):
+    """When a formatter has been applied, group labels should reflect the formatted value."""
+    gt_fmt = numeric_grouped_gt.fmt_number(columns="group", decimals=0)
+
+    built = gt_fmt._render_formats("html")
+    labels = [gr.defaulted_label() for gr in built._stub.group_rows]
+
+    assert labels == ["1,000", "2,000"]
+
+
+def test_update_group_row_labels_falls_back_to_original(grouped_gt: GT):
+    """When no formatter is applied, group labels should use the original data value."""
+    built = grouped_gt._render_formats("html")
+    labels = [gr.defaulted_label() for gr in built._stub.group_rows]
+
+    assert labels == ["A", "B"]
+
+
+def test_update_group_row_labels_no_groups():
+    """When there is no groupname column, the stub is returned unchanged."""
+    df = pd.DataFrame({"value": [1, 2, 3]})
+    gt_tbl = GT(df)
+
+    built = gt_tbl._render_formats("html")
+
+    # No group rows should exist
+    assert len(built._stub.group_rows) == 0
+
+
+def test_formatted_group_label_in_html(numeric_grouped_gt: GT):
+    """Formatted group labels should appear in the rendered HTML output."""
+    html = numeric_grouped_gt.fmt_number(columns="group", decimals=0).as_raw_html()
+
+    assert ">1,000</th>" in html
+    assert ">2,000</th>" in html
+
+
+def test_markdown_link_in_group_label_renders_as_anchor():
+    """Markdown links in group labels should render as <a> tags in HTML output."""
+    df = pd.DataFrame(
+        {
+            "group": [
+                "[Google](https://google.com)",
+                "[Google](https://google.com)",
+                "[GitHub](https://github.com)",
+                "[GitHub](https://github.com)",
+            ],
+            "value": [1, 2, 3, 4],
+        }
+    )
+    html = GT(df, groupname_col="group").fmt_markdown(columns="group").as_raw_html()
+
+    assert '<a href="https://google.com">Google</a>' in html
+    assert '<a href="https://github.com">GitHub</a>' in html