coeftable 0.2.1__tar.gz → 0.3.0__tar.gz

{coeftable-0.2.1 → coeftable-0.3.0}/.github/workflows/publish.yml

@@ -40,6 +40,14 @@ jobs:
 
   publish:
     runs-on: ubuntu-latest
+    # PyPI must have a trusted publisher registered for BOTH entry points,
+    # each with environment "publish": this workflow, for a manual run or a
+    # hand-pushed tag, and release.yml, for an automated release. Upload
+    # authentication matches on the reusable workflow, but the build
+    # provenance attestation carries the TOP-LEVEL workflow, so an automated
+    # release presents release.yml and is rejected with "does not match
+    # expected Trusted Publisher" unless that entry point is registered too.
+    #
     # A tag pushed by a workflow using the default token does not raise a
     # push event, so a release cut by automation asks for the upload
     # explicitly. Any other run sitting on a tag -- a hand-pushed tag, or a

{coeftable-0.2.1 → coeftable-0.3.0}/CHANGELOG.md

@@ -1,3 +1,21 @@
+<a id="v0.2.1"></a>
+# [v0.2.1](https://github.com/kylejcaron/coeftable/releases/tag/v0.2.1) - 2026-08-05
+
+<!-- Release notes generated using configuration in .github/release.yml at v0.2.1 -->
+
+## What's Changed
+### Maintenance
+* Update changelog for v0.2.0 by [@github-actions](https://github.com/github-actions)[bot] in [#11](https://github.com/kylejcaron/coeftable/pull/11)
+* Publish releases to PyPI automatically by [@kylejcaron](https://github.com/kylejcaron) in [#12](https://github.com/kylejcaron/coeftable/pull/12)
+
+## New Contributors
+* [@github-actions](https://github.com/github-actions)[bot] made their first contribution in [#11](https://github.com/kylejcaron/coeftable/pull/11)
+
+**Full Changelog**: https://github.com/kylejcaron/coeftable/compare/v0.2.0...v0.2.1
+
+[Changes][v0.2.1]
+
+
 <a id="v0.2.0"></a>
 # [v0.2.0](https://github.com/kylejcaron/coeftable/releases/tag/v0.2.0) - 2026-08-04
 
@@ -36,6 +54,7 @@
 [Changes][v0.1.0]
 
 
+[v0.2.1]: https://github.com/kylejcaron/coeftable/compare/v0.2.0...v0.2.1
 [v0.2.0]: https://github.com/kylejcaron/coeftable/compare/v0.1.0...v0.2.0
 [v0.1.0]: https://github.com/kylejcaron/coeftable/tree/v0.1.0
 

{coeftable-0.2.1 → coeftable-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coeftable
-Version: 0.2.1
+Version: 0.3.0
 Summary: Publication-quality summary tables for estimates with uncertainty.
 Project-URL: Homepage, https://github.com/kylejcaron/coeftable
 Project-URL: Repository, https://github.com/kylejcaron/coeftable
@@ -87,10 +87,11 @@ ct.CoefTable(df, rows="metric", estimate="est", ci=("lb", "ub"))
 ```
 
 A `CoefTable` renders itself in marimo, Jupyter, and any other `_repr_html_`-aware viewer —
-leave it as the last expression in a cell, no extra call needed. Outside a notebook, use
-`.gt()` to reach the underlying [great_tables](https://posit-dev.github.io/great-tables/)
-object: `table.gt().as_raw_html()` for an HTML string, `table.gt().save("t.png")` for an
-image, `table.gt().tab_options(...)` to keep styling with great_tables' own API.
+leave it as the last expression in a cell, no extra call needed. Outside a notebook,
+`table.as_raw_html()` is the HTML string entry point. `.gt()` remains the escape hatch to the
+underlying [great_tables](https://posit-dev.github.io/great-tables/) object itself:
+`table.gt().save("t.png")` for an image, `table.gt().tab_options(...)` to keep styling with
+great_tables' own API.
 
 ## Data shape
 
@@ -103,7 +104,12 @@ a `parameter` column.
 **Dimensions:**
 - `rows` — the label for each row in the table (e.g. a metric name).
 - `nest` — an optional secondary label stacked below each row.
-- `groups` — an optional column whose values produce section headers.
+- `groups` — an optional column whose values produce section headers. Pass
+  `collapsible_groups=True` to make those sections collapsible in the rendered
+  HTML — a pure CSS toggle (relies on `:has()`, Baseline since late 2023; on an
+  older browser without it the toggle no-ops and sections stay expanded), no
+  JavaScript, sections start expanded. Applies to `as_raw_html()`/`_repr_html_`;
+  `.gt()` is unaffected.
 - `split_columns` — an optional column whose values produce repeated column
   groups side by side, useful for comparing methods.
 
@@ -172,8 +178,7 @@ methods = pl.DataFrame(
 (
     ct.CoefTable(
         methods, rows="metric", split_columns="method", estimate="est", ci=("lb", "ub")
-    )
-    .header("Cohort Revenue by Method")
+    ).header("Cohort Revenue by Method")
 )
 ```
 
@@ -184,11 +189,11 @@ Four built-in themes are available from `coeftable.theme`:
 ```python
 from coeftable.theme import BLUE, COLORBLIND, DEFAULT, MONO, TEXTUAL
 
-DEFAULT       # Alias for TEXTUAL -- what CoefTable uses if you don't set a theme
-TEXTUAL       # Minimal, publication-style: muted colours, light chrome
-BLUE          # The original blue-grey palette
-COLORBLIND    # Colourblind-safe palette
-MONO          # Grayscale for mono journals
+DEFAULT  # Alias for TEXTUAL -- what CoefTable uses if you don't set a theme
+TEXTUAL  # Minimal, publication-style: muted colours, light chrome
+BLUE  # The original blue-grey palette
+COLORBLIND  # Colourblind-safe palette
+MONO  # Grayscale for mono journals
 ```
 
 Apply one with `.with_theme(...)`:
@@ -209,9 +214,8 @@ Use `with_direction` to mark rows where lower values are favourable (reusing
 the `df` frame from [Quick start](#quick-start)):
 
 ```python
-table = (
-    ct.CoefTable(df, rows="metric", estimate="est", ci=("lb", "ub"))
-    .with_direction({"Latency": "lower_is_better"})
+table = ct.CoefTable(df, rows="metric", estimate="est", ci=("lb", "ub")).with_direction(
+    {"Latency": "lower_is_better"}
 )
 ```
 
@@ -373,3 +377,29 @@ trend = pl.DataFrame(
     .sparkline("Override", value="lift", ref=1.0, ylim=(0.9, 1.1))
 )
 ```
+
+**No reference, or a hidden one.** `ref` also drives the dashed line and
+colour resolution; two ways to opt out, for data with no meaningful
+zero (revenue, durations, absolute counts):
+
+```python
+absolute = pl.DataFrame(
+    {
+        "metric": ["Revenue", "Latency"],
+        "value": [[282.3, 300.1, 320.0], [900.0, 910.0, 920.0]],
+    }
+)
+
+(
+    ct.CoefTable(absolute, rows="metric")
+    # ref=None: no reference at all. No dashed line, no forced domain
+    # inclusion of 0, and every cell colours neutral -- "favorable" has
+    # no meaning without something to compare against.
+    .sparkline("No reference", value="value", ref=None)
+    # ref=0.0, show_ref=False: the reference is real and still drives
+    # colour (favorable/unfavorable against 0), it just isn't drawn or
+    # forced into the domain. Opt in deliberately: a mark can then claim
+    # "above the reference" while the reference sits off-canvas.
+    .sparkline("Hidden reference", value="value", ref=0.0, show_ref=False)
+)
+```

{coeftable-0.2.1 → coeftable-0.3.0}/README.md

@@ -33,10 +33,11 @@ ct.CoefTable(df, rows="metric", estimate="est", ci=("lb", "ub"))
 ```
 
 A `CoefTable` renders itself in marimo, Jupyter, and any other `_repr_html_`-aware viewer —
-leave it as the last expression in a cell, no extra call needed. Outside a notebook, use
-`.gt()` to reach the underlying [great_tables](https://posit-dev.github.io/great-tables/)
-object: `table.gt().as_raw_html()` for an HTML string, `table.gt().save("t.png")` for an
-image, `table.gt().tab_options(...)` to keep styling with great_tables' own API.
+leave it as the last expression in a cell, no extra call needed. Outside a notebook,
+`table.as_raw_html()` is the HTML string entry point. `.gt()` remains the escape hatch to the
+underlying [great_tables](https://posit-dev.github.io/great-tables/) object itself:
+`table.gt().save("t.png")` for an image, `table.gt().tab_options(...)` to keep styling with
+great_tables' own API.
 
 ## Data shape
 
@@ -49,7 +50,12 @@ a `parameter` column.
 **Dimensions:**
 - `rows` — the label for each row in the table (e.g. a metric name).
 - `nest` — an optional secondary label stacked below each row.
-- `groups` — an optional column whose values produce section headers.
+- `groups` — an optional column whose values produce section headers. Pass
+  `collapsible_groups=True` to make those sections collapsible in the rendered
+  HTML — a pure CSS toggle (relies on `:has()`, Baseline since late 2023; on an
+  older browser without it the toggle no-ops and sections stay expanded), no
+  JavaScript, sections start expanded. Applies to `as_raw_html()`/`_repr_html_`;
+  `.gt()` is unaffected.
 - `split_columns` — an optional column whose values produce repeated column
   groups side by side, useful for comparing methods.
 
@@ -118,8 +124,7 @@ methods = pl.DataFrame(
 (
     ct.CoefTable(
         methods, rows="metric", split_columns="method", estimate="est", ci=("lb", "ub")
-    )
-    .header("Cohort Revenue by Method")
+    ).header("Cohort Revenue by Method")
 )
 ```
 
@@ -130,11 +135,11 @@ Four built-in themes are available from `coeftable.theme`:
 ```python
 from coeftable.theme import BLUE, COLORBLIND, DEFAULT, MONO, TEXTUAL
 
-DEFAULT       # Alias for TEXTUAL -- what CoefTable uses if you don't set a theme
-TEXTUAL       # Minimal, publication-style: muted colours, light chrome
-BLUE          # The original blue-grey palette
-COLORBLIND    # Colourblind-safe palette
-MONO          # Grayscale for mono journals
+DEFAULT  # Alias for TEXTUAL -- what CoefTable uses if you don't set a theme
+TEXTUAL  # Minimal, publication-style: muted colours, light chrome
+BLUE  # The original blue-grey palette
+COLORBLIND  # Colourblind-safe palette
+MONO  # Grayscale for mono journals
 ```
 
 Apply one with `.with_theme(...)`:
@@ -155,9 +160,8 @@ Use `with_direction` to mark rows where lower values are favourable (reusing
 the `df` frame from [Quick start](#quick-start)):
 
 ```python
-table = (
-    ct.CoefTable(df, rows="metric", estimate="est", ci=("lb", "ub"))
-    .with_direction({"Latency": "lower_is_better"})
+table = ct.CoefTable(df, rows="metric", estimate="est", ci=("lb", "ub")).with_direction(
+    {"Latency": "lower_is_better"}
 )
 ```
 
@@ -319,3 +323,29 @@ trend = pl.DataFrame(
     .sparkline("Override", value="lift", ref=1.0, ylim=(0.9, 1.1))
 )
 ```
+
+**No reference, or a hidden one.** `ref` also drives the dashed line and
+colour resolution; two ways to opt out, for data with no meaningful
+zero (revenue, durations, absolute counts):
+
+```python
+absolute = pl.DataFrame(
+    {
+        "metric": ["Revenue", "Latency"],
+        "value": [[282.3, 300.1, 320.0], [900.0, 910.0, 920.0]],
+    }
+)
+
+(
+    ct.CoefTable(absolute, rows="metric")
+    # ref=None: no reference at all. No dashed line, no forced domain
+    # inclusion of 0, and every cell colours neutral -- "favorable" has
+    # no meaning without something to compare against.
+    .sparkline("No reference", value="value", ref=None)
+    # ref=0.0, show_ref=False: the reference is real and still drives
+    # colour (favorable/unfavorable against 0), it just isn't drawn or
+    # forced into the domain. Opt in deliberately: a mark can then claim
+    # "above the reference" while the reference sits off-canvas.
+    .sparkline("Hidden reference", value="value", ref=0.0, show_ref=False)
+)
+```

{coeftable-0.2.1 → coeftable-0.3.0}/src/coeftable/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.1'
-__version_tuple__ = version_tuple = (0, 2, 1)
+__version__ = version = '0.3.0'
+__version_tuple__ = version_tuple = (0, 3, 0)
 
 __commit_id__ = commit_id = None

coeftable-0.3.0/src/coeftable/collapsible.py

@@ -0,0 +1,166 @@
+"""Post-process `great_tables` HTML to make row-group sections collapsible.
+
+`make_collapsible` is a pure string transform: it knows nothing about
+`CoefTable`. It walks the rendered `<tbody>`, tags each group heading row and
+its member rows with `data-ct-group*` attributes, and appends a `<style>`
+block whose `:has()` rules do the collapsing -- no JavaScript.
+"""
+
+from __future__ import annotations
+
+import re
+
+SHARED_AXIS_ROW_MARK = "--ct-axis-row:1"
+"""CSS custom property `render.py` stamps on a table-wide axis/footer row
+(`scale in {"table", "split_column"}`) so this module can recognise it and
+leave it untagged. A single string literal, imported by both the producer
+and the consumer, so the two can never drift apart."""
+
+_TBODY_OPEN_RE = re.compile(r'<tbody\s+class="gt_table_body"[^>]*>')
+_WRAPPER_DIV_ID_RE = re.compile(r'<div\s+id="([^"]+)"')
+_ROW_TOKEN_RE = re.compile(r"<tr(?=[\s>])|</tr>")
+_GROUP_HEADING_TH_RE = re.compile(r'(<th\s+class="gt_group_heading"[^>]*>)(.*?)(</th>)', re.DOTALL)
+
+_BASE_CSS = """\
+#{uid} .ct-group-state{{
+  position:absolute;width:1px;height:1px;overflow:hidden;
+  clip-path:inset(50%);white-space:nowrap
+}}
+#{uid} label.ct-group-toggle{{display:block;cursor:pointer}}
+#{uid} .ct-caret{{display:inline-block;width:1em}}
+#{uid} .ct-group-state:focus-visible + label.ct-group-toggle{{
+  outline:2px solid currentColor;outline-offset:2px
+}}
+/* per group n: */
+"""
+
+_GROUP_CSS = (
+    '#{uid} tbody:has(#{cid}:checked) tr[data-ct-group-member="{n}"]{{display:none}}\n'
+    '#{uid} tbody:has(#{cid}:checked) label[for="{cid}"] .ct-caret{{transform:rotate(-90deg)}}\n'
+)
+
+
+def _top_level_row_spans(body: str) -> list[tuple[int, int]]:
+    """Depth-tracking scan for `<tr>...</tr>` spans at nesting depth 0.
+
+    A markdown/passthrough cell can legitimately contain a nested
+    `<table>`, so a naive `"<tr" in body` split would also tag its rows.
+    Only rows that open and close at depth 0 are real body rows.
+    """
+    depth = 0
+    start: int | None = None
+    spans: list[tuple[int, int]] = []
+    for m in _ROW_TOKEN_RE.finditer(body):
+        if m.group(0) == "</tr>":
+            depth -= 1
+            if depth == 0 and start is not None:
+                spans.append((start, m.end()))
+                start = None
+        else:
+            if depth == 0:
+                start = m.start()
+            depth += 1
+    return spans
+
+
+def _insert_tr_attr(row: str, attr: str) -> str:
+    """Insert `attr` into the row's opening `<tr...>` tag, right after `<tr`."""
+    close = row.index(">")
+    return "<tr " + attr + row[len("<tr") : close] + row[close:]
+
+
+def _tag_heading_row(row: str, *, uid: str, n: int) -> str:
+    cid = f"ct-{uid}-g{n}"
+
+    def _wrap_heading(match: re.Match[str]) -> str:
+        open_th, inner, close_th = match.group(1), match.group(2), match.group(3)
+        checkbox = f'<input class="ct-group-state" type="checkbox" id="{cid}">'
+        label = (
+            f'<label class="ct-group-toggle" for="{cid}">'
+            f'<span class="ct-caret" aria-hidden="true">\u25be</span>{inner}</label>'
+        )
+        return f"{open_th}{checkbox}{label}{close_th}"
+
+    row = _GROUP_HEADING_TH_RE.sub(_wrap_heading, row, count=1)
+    return _insert_tr_attr(row, f'data-ct-group="{n}"')
+
+
+def _tag_member_row(row: str, *, n: int) -> str:
+    return _insert_tr_attr(row, f'data-ct-group-member="{n}"')
+
+
+def make_collapsible(html: str) -> str:
+    """Tag `great_tables` row-group headings so CSS alone can collapse them.
+
+    Locates the `<tbody class="gt_table_body">...</tbody>` slice and walks
+    its rows with a depth-tracking scan (not a naive split, which would
+    also match `<tr>` tags nested inside a markdown/passthrough cell).
+    Each group heading row (identified by its `<th class="gt_group_heading">`,
+    present whether the label is empty or not) gets a `data-ct-group="n"`
+    attribute, its heading text is wrapped in a `<label>`/`<input
+    type="checkbox">` pair, and every following row up to the next heading
+    gets `data-ct-group-member="n"` -- except a shared forest/sparkline
+    axis row (marked by `render.py` with the `SHARED_AXIS_ROW_MARK` CSS
+    custom property), which stays untagged so it never disappears into
+    whichever group happens to precede it. A `<style>` block using `:has()`
+    is appended after the wrapper `</div>` to do the actual hiding.
+
+    Returns `html` unchanged if the tbody is not found, or if no group
+    heading row (empty- or non-empty-label) is present.
+    """
+    tbody_open = _TBODY_OPEN_RE.search(html)
+    if tbody_open is None:
+        return html
+    tbody_close = html.find("</tbody>", tbody_open.end())
+    if tbody_close == -1:
+        return html
+
+    body = html[tbody_open.end() : tbody_close]
+    spans = _top_level_row_spans(body)
+    if not any('class="gt_group_heading"' in body[s:e] for s, e in spans):
+        return html
+
+    uid_match = _WRAPPER_DIV_ID_RE.search(html)
+    if uid_match is None:
+        return html
+    uid = uid_match.group(1)
+
+    pieces: list[str] = []
+    cursor = 0
+    n = -1
+    group_ids: list[str] = []
+    for start, end in spans:
+        pieces.append(body[cursor:start])
+        row = body[start:end]
+        if 'class="gt_group_heading"' in row:
+            n += 1
+            pieces.append(_tag_heading_row(row, uid=uid, n=n))
+            group_ids.append(f"ct-{uid}-g{n}")
+        elif SHARED_AXIS_ROW_MARK in row:
+            # A forest/sparkline axis row whose domain is table-wide
+            # (scale in {"table", "split_column"}; render.py stamps only
+            # these). It is not any single group's data and must stay
+            # visible no matter which group collapses -- leave it
+            # untagged rather than folding it into whichever group
+            # happens to precede it in row order. A per-group axis row
+            # (scale="row_group"/"row") carries no marker and falls
+            # through to the ordinary member-row branch below, so it
+            # correctly collapses with its own group.
+            pieces.append(row)
+        elif n >= 0:
+            pieces.append(_tag_member_row(row, n=n))
+        else:
+            pieces.append(row)
+        cursor = end
+    pieces.append(body[cursor:])
+    new_body = "".join(pieces)
+
+    new_html = html[: tbody_open.end()] + new_body + html[tbody_close:]
+
+    style = "<style>\n" + _BASE_CSS.format(uid=uid)
+    for n, cid in enumerate(group_ids):
+        style += _GROUP_CSS.format(uid=uid, cid=cid, n=n)
+    style += "</style>"
+
+    div_close = new_html.rfind("</div>")
+    return new_html[: div_close + len("</div>")] + style + new_html[div_close + len("</div>") :]

{coeftable-0.2.1 → coeftable-0.3.0}/src/coeftable/frame.py

@@ -45,6 +45,12 @@ class Resolved:
         Name of the row-group column, if any.
     band_rows, divider_rows, axis_rows
         Zero-based row indices for banding, dividers and axis rows.
+    shared_axis_rows
+        Subset of `axis_rows` whose axis is table-wide (`scale in
+        {"table", "split_column"}`) rather than per-group or per-row-key
+        -- see `assemble_rows`. `render.py` marks only these for
+        `collapsible.py` to leave untagged; the rest stay tied to
+        whichever group they belong to.
     markdown_columns
         Output columns whose contents are HTML.
     plot_columns
@@ -61,6 +67,7 @@ class Resolved:
     band_rows: list[int] = field(default_factory=list)
     divider_rows: list[int] = field(default_factory=list)
     axis_rows: list[int] = field(default_factory=list)
+    shared_axis_rows: list[int] = field(default_factory=list)
     markdown_columns: list[str] = field(default_factory=list)
     plot_columns: list[str] = field(default_factory=list)
 
@@ -118,6 +125,23 @@ def resolve(table: CoefTable) -> Resolved:
                 f"(rows/nest/groups key {column.label!r}); choose a different label."
             )
 
+    # The overlaid `series` dimension cannot also be a table axis: the
+    # table's row structure already spends whichever of these an
+    # identity maps to, so naming the same column both ways is
+    # ambiguous about which grouping wins.
+    axis_keys = {n for n in (table.rows, table.nest, table.groups, table.split_columns) if n}
+    for column in table.columns:
+        if (
+            isinstance(column, Sparkline)
+            and column.series is not None
+            and column.series in axis_keys
+        ):
+            raise SpecError(
+                f"Sparkline column {column.label!r} series={column.series!r} collides "
+                "with a table layout key (rows/nest/groups/split_columns); the "
+                "overlaid dimension cannot also be a table axis."
+            )
+
     frame = nw.from_native(table.data, eager_only=True)
     _check_columns(frame, table)
 
@@ -203,6 +227,14 @@ def resolve(table: CoefTable) -> Resolved:
                 [key_fn(row_key, group, split) for split in grid.splits]
                 for (row_key, _nest), group in zip(grid.ordered, grid.row_group, strict=True)
             ]
+    # A footer's domain is table-wide only when the column itself says so
+    # (see `Prepared.shared_footer`) -- inferring it from `scale` would be
+    # wrong for `Sparkline`, whose x-axis footer_key is always constant
+    # regardless of `scale` (that setting only buckets each row's own
+    # y-domain, never the shared axis's closing scope).
+    shared_footer_labels = {
+        label for label in footer_keys if prepared_by_label[label].shared_footer
+    }
 
     def render_footer(pending: dict[str, list[Any]]) -> dict[str, str]:
         out: dict[str, str] = {}
@@ -216,7 +248,9 @@ def resolve(table: CoefTable) -> Resolved:
                     out[output_name(column, split)] = text
         return out
 
-    assembled = assemble_rows(grid, display_columns, cell_values, footer_keys, render_footer)
+    assembled = assemble_rows(
+        grid, display_columns, cell_values, footer_keys, render_footer, shared_footer_labels
+    )
 
     data: dict[str, list[Any]] = {}
     if table.groups:
@@ -240,6 +274,7 @@ def resolve(table: CoefTable) -> Resolved:
         band_rows=assembled.band_rows,
         divider_rows=assembled.divider_rows,
         axis_rows=assembled.axis_rows,
+        shared_axis_rows=assembled.shared_axis_rows,
         markdown_columns=markdown,
         plot_columns=plot_columns,
     )

{coeftable-0.2.1 → coeftable-0.3.0}/src/coeftable/grid.py

@@ -8,7 +8,7 @@ kind (`Estimate`, `Forest`, `Passthrough`) it is laying out.
 from __future__ import annotations
 
 import math
-from collections.abc import Callable
+from collections.abc import Callable, Set
 from dataclasses import dataclass
 from typing import Any
 
@@ -153,6 +153,11 @@ class AssembledRows:
         Per-row values for the rows/nest/groups layout columns.
     band_rows, divider_rows, axis_rows
         Zero-based indices into the final row sequence.
+    shared_axis_rows
+        Subset of `axis_rows` where every column closing at that row has a
+        table-wide domain (`scale` in `{"table", "split_column"}`) rather
+        than a per-group or per-row-key one -- see `shared_footer_labels`
+        on `assemble_rows`.
     cells
         Rendered cell text per display column, one entry per final row.
     """
@@ -163,6 +168,7 @@ class AssembledRows:
     band_rows: list[int]
     divider_rows: list[int]
     axis_rows: list[int]
+    shared_axis_rows: list[int]
     cells: dict[str, list[str]]
 
 
@@ -172,6 +178,7 @@ def assemble_rows(
     cell_values: dict[str, list[str]],
     footer_keys: dict[str, list[list[Any]]],
     render_footer: Callable[[dict[str, list[Any]]], dict[str, str]],
+    shared_footer_labels: Set[str] = frozenset(),
 ) -> AssembledRows:
     """Interleave rendered cells with footer rows, and lay out band/dividers.
 
@@ -198,6 +205,15 @@ def assemble_rows(
     render_footer
         Called with the labels (with their keys) due at this row; returns
         the rendered footer text per display column.
+    shared_footer_labels
+        Labels (a subset of `footer_keys`' keys) whose footer closes once
+        for the whole table rather than once per group or row key. This
+        module is column-agnostic (see the module docstring), so the
+        caller decides membership -- `frame.py` populates it from each
+        column's own `Prepared.shared_footer`. An axis row is recorded in
+        `shared_axis_rows` only when every column closing at that row is
+        in this set; a row combining a shared and a per-group footer is
+        treated as per-group, since it is not safe to show unconditionally.
 
     Returns
     -------
@@ -211,14 +227,27 @@ def assemble_rows(
     band_rows: list[int] = []
     divider_rows: list[int] = []
     axis_rows: list[int] = []
+    shared_axis_rows: list[int] = []
     emitted: dict[str, set[Any]] = {label: set() for label in footer_keys}
 
     def blank_row() -> None:
         for name in display_columns:
             cells[name].append("")
 
-    previous_row_key: Any = None
+    previous_row_key_by_group: dict[Any, Any] = {}
     for position, (row_key, nest_key) in enumerate(grid.ordered):
+        group = grid.row_group[position]
+        # `great_tables`' `groupname_col` (see `render.py`) collects rows
+        # into contiguous per-group blocks for *display*, independent of
+        # this row-key-major physical order (`grid.ordered`). A row key
+        # spanning more than one group -- e.g. "Revenue" appearing under
+        # both "US" and "EU" -- is therefore not adjacent to its own
+        # prior occurrence once grouped; tracking "first occurrence"
+        # per group (rather than one running `previous_row_key`) keeps
+        # the label shown once per group block, matching what actually
+        # renders, instead of blanking every occurrence after the first
+        # anywhere in the table.
+        previous_row_key = previous_row_key_by_group.get(group)
         first_of_key = row_key != previous_row_key
         if first_of_key and previous_row_key is not None:
             divider_rows.append(len(layout_rows))
@@ -226,8 +255,8 @@ def assemble_rows(
             band_rows.append(len(layout_rows))
         layout_rows.append(f"<b>{row_key}</b>" if first_of_key else "")
         layout_nest.append("" if nest_key is None else str(nest_key))
-        layout_group.append(grid.row_group[position])
-        previous_row_key = row_key
+        layout_group.append(group)
+        previous_row_key_by_group[group] = row_key
 
         for name in display_columns:
             cells[name].append(cell_values[name][position])
@@ -252,6 +281,8 @@ def assemble_rows(
             layout_nest.append("")
             layout_group.append(layout_group[-1])
             axis_rows.append(len(layout_rows) - 1)
+            if set(pending) <= shared_footer_labels:
+                shared_axis_rows.append(len(layout_rows) - 1)
             for label, keys in pending.items():
                 emitted[label].update(keys)
             for name, text in render_footer(pending).items():
@@ -264,5 +295,6 @@ def assemble_rows(
         band_rows=band_rows,
         divider_rows=divider_rows,
         axis_rows=axis_rows,
+        shared_axis_rows=shared_axis_rows,
         cells=cells,
     )

{coeftable-0.2.1 → coeftable-0.3.0}/src/coeftable/render.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from great_tables import GT, loc, style
 
+from coeftable.collapsible import SHARED_AXIS_ROW_MARK
 from coeftable.frame import resolve
 from coeftable.spec import CoefTable
 
@@ -88,6 +89,18 @@ def to_gt(table: CoefTable) -> GT:
             ],
             locations=loc.body(rows=resolved.axis_rows),
         )
+    if resolved.shared_axis_rows:
+        # Marks this as a table-wide axis/footer row rather than a
+        # per-group one: `collapsible.py` reads this to keep the row
+        # visible regardless of which group precedes it, since a
+        # `scale="table"`/`"split_column"` axis belongs to the whole
+        # column, not to whichever group happens to render last. A
+        # `scale="row_group"`/`"row"` axis row is *not* in this set --
+        # it genuinely belongs to one group and stays a normal member.
+        gt = gt.tab_style(
+            style=style.css(SHARED_AXIS_ROW_MARK),
+            locations=loc.body(rows=resolved.shared_axis_rows),
+        )
     if resolved.group_column:
         gt = gt.tab_style(
             style=[