coeftable 0.3.0__tar.gz → 0.3.1__tar.gz

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

@@ -11,11 +11,6 @@ on:
         description: "Git ref to build. Defaults to the triggering ref."
         required: false
         type: string
-      publish:
-        description: "Upload the built package to PyPI."
-        required: false
-        default: false
-        type: boolean
   workflow_dispatch:
 
 jobs:
@@ -40,29 +35,33 @@ 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
-    # manual run selecting one, which is how a stranded release gets
-    # published -- is also a release build. A run on a branch never is.
-    if: inputs.publish || startsWith(github.ref, 'refs/tags')
+    # PyPI Trusted Publishing does not support reusable workflows
+    # (https://github.com/pypa/gh-action-pypi-publish/issues/166): a
+    # `workflow_call` invocation of this job would present the *caller's*
+    # workflow identity, not this one, and fail to match the Trusted
+    # Publisher entry registered for this workflow. So this job never
+    # publishes when called reusably -- release.yml calls this workflow
+    # for `build-package` only and does its own top-level publish. This
+    # job runs only for a direct trigger of this workflow sitting on a
+    # tag: a tag push, or a manual run selecting a tag ref (how a
+    # stranded release gets republished). A run on a branch never does.
+    if: startsWith(github.ref, 'refs/tags')
     environment:
       name: publish
       url: https://pypi.org/p/coeftable
     needs: build-package
     permissions:
+      contents: read
       id-token: write
     steps:
       - uses: actions/download-artifact@v8
         with:
           name: Packages
           path: dist
+      # Must be invoked straight from the job, never via a local composite
+      # action. This action builds a Docker trampoline whose image it names
+      # from `github.action_repository`/`github.action_ref`, and both are
+      # empty for an action nested inside another composite action
+      # (actions/runner#2473). It then falls back to this repository and its
+      # branch, and tries to pull an image that was never published.
       - uses: pypa/gh-action-pypi-publish@release/v1

{coeftable-0.3.0 → coeftable-0.3.1}/.github/workflows/release.yml

@@ -90,10 +90,12 @@ jobs:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: gh release create "${{ steps.version.outputs.tag }}" --generate-notes
 
-  publish:
-    # Called directly rather than left to the tag-push trigger on the publish
-    # workflow: the tag above is pushed with the workflow token, and GitHub
-    # does not raise workflow-triggering events for it.
+  build:
+    # Called reusably for the build step only: `publish.yml`'s own
+    # `publish` job is gated on `startsWith(github.ref, 'refs/tags')`,
+    # which is false here (`github.ref` reflects this run's own
+    # branch/dispatch ref, not the `ref:` input below), so it no-ops --
+    # only `build-package` executes.
     needs: tag
     uses: ./.github/workflows/publish.yml
     permissions:
@@ -102,7 +104,37 @@ jobs:
       id-token: write
     with:
       ref: ${{ needs.tag.outputs.tag }}
-      publish: true
+
+  publish:
+    # A real top-level job, not delegated via `uses:`: PyPI Trusted
+    # Publishing does not support reusable workflows -- the OIDC
+    # certificate's Build Config URI reflects the top-level caller
+    # (release.yml) for a `uses:`-invoked job, which then fails to match
+    # a Trusted Publisher entry registered for the *called* workflow.
+    # See https://github.com/pypa/gh-action-pypi-publish/issues/166 and
+    # the "Non-goals" section of that action's README: "keep the job
+    # calling pypi-publish in a top-level [workflow]". `build-package`
+    # itself has no such restriction and stays reusable above.
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: publish
+      url: https://pypi.org/p/coeftable
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          name: Packages
+          path: dist
+      # Must be invoked straight from the job, never via a local composite
+      # action. This action builds a Docker trampoline whose image it names
+      # from `github.action_repository`/`github.action_ref`, and both are
+      # empty for an action nested inside another composite action
+      # (actions/runner#2473). It then falls back to this repository and its
+      # branch, and tries to pull an image that was never published.
+      - uses: pypa/gh-action-pypi-publish@release/v1
 
   changelog:
     # Same reason as the publish job above: the release is created with the

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

@@ -1,3 +1,41 @@
+<a id="v0.3.1"></a>
+# [v0.3.1](https://github.com/kylejcaron/coeftable/releases/tag/v0.3.1) - 2026-08-14
+
+<!-- Release notes generated using configuration in .github/release.yml at v0.3.1 -->
+
+## What's Changed
+### Bug Fixes
+* Fix row-group handling: labels spanning groups, row striping, and layout key collisions by [@kylejcaron](https://github.com/kylejcaron) in [#26](https://github.com/kylejcaron/coeftable/pull/26)
+* Build core metadata 2.4 so releases pass validation by [@kylejcaron](https://github.com/kylejcaron) in [#27](https://github.com/kylejcaron/coeftable/pull/27)
+### Maintenance
+* Update changelog for v0.3.0 by [@github-actions](https://github.com/github-actions)[bot] in [#21](https://github.com/kylejcaron/coeftable/pull/21)
+* Fix automated releases: PyPI Trusted Publishing rejects reusable workflows by [@kylejcaron](https://github.com/kylejcaron) in [#22](https://github.com/kylejcaron/coeftable/pull/22)
+
+
+**Full Changelog**: https://github.com/kylejcaron/coeftable/compare/v0.3.0...v0.3.1
+
+[Changes][v0.3.1]
+
+
+<a id="v0.3.0"></a>
+# [v0.3.0](https://github.com/kylejcaron/coeftable/releases/tag/v0.3.0) - 2026-08-05
+
+<!-- Release notes generated using configuration in .github/release.yml at v0.3.0 -->
+
+## What's Changed
+### Maintenance
+* Update changelog for v0.2.1 by [@github-actions](https://github.com/github-actions)[bot] in [#13](https://github.com/kylejcaron/coeftable/pull/13)
+* Document the PyPI trusted-publisher requirement for both entry points by [@kylejcaron](https://github.com/kylejcaron) in [#14](https://github.com/kylejcaron/coeftable/pull/14)
+* Add collapsible group sections by [@kylejcaron](https://github.com/kylejcaron) in [#18](https://github.com/kylejcaron/coeftable/pull/18)
+* Allow ref=None on Sparkline to drop the reference line and its domain constraint by [@kylejcaron](https://github.com/kylejcaron) in [#19](https://github.com/kylejcaron/coeftable/pull/19)
+* Support multiple overlaid series in one sparkline cell by [@kylejcaron](https://github.com/kylejcaron) in [#20](https://github.com/kylejcaron/coeftable/pull/20)
+
+
+**Full Changelog**: https://github.com/kylejcaron/coeftable/compare/v0.2.1...v0.3.0
+
+[Changes][v0.3.0]
+
+
 <a id="v0.2.1"></a>
 # [v0.2.1](https://github.com/kylejcaron/coeftable/releases/tag/v0.2.1) - 2026-08-05
 
@@ -54,6 +92,8 @@
 [Changes][v0.1.0]
 
 
+[v0.3.1]: https://github.com/kylejcaron/coeftable/compare/v0.3.0...v0.3.1
+[v0.3.0]: https://github.com/kylejcaron/coeftable/compare/v0.2.1...v0.3.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.3.0 → coeftable-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coeftable
-Version: 0.3.0
+Version: 0.3.1
 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
@@ -104,7 +104,10 @@ 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. Pass
+- `groups` — an optional column whose values produce section headers. A row
+  label may appear under more than one group, in which case it renders once per
+  section — so the same set of metrics can be reported per region without
+  inventing a `nest` column to tell them apart. 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
@@ -182,6 +185,34 @@ methods = pl.DataFrame(
 )
 ```
 
+## Repeating metrics across sections
+
+A row label may appear under more than one `groups` value. The same metrics can
+therefore be reported per region, each section repeating the full set:
+
+```python
+import polars as pl
+import coeftable as ct
+
+regions = pl.DataFrame(
+    {
+        "metric": ["Revenue", "Signups", "Revenue", "Signups"],
+        "region": ["US", "US", "EU", "EU"],
+        "est": [1.2, 0.4, 2.1, 0.9],
+        "lb": [0.8, 0.1, 1.5, 0.5],
+        "ub": [1.6, 0.7, 2.7, 1.3],
+    }
+)
+
+(
+    ct.CoefTable(
+        regions, rows="metric", groups="region", collapsible_groups=True
+    )
+    .estimate("Effect", "est", ci=("lb", "ub"))
+    .forest("Effect Plot", of="Effect", ref=0.0, symmetric=True)
+)
+```
+
 ## Theming
 
 Four built-in themes are available from `coeftable.theme`:
@@ -236,8 +267,13 @@ companion-frame choice used elsewhere in coeftable:
 arrives in: a SQL export, a dbt model, an experimentation platform's daily
 metrics table. Pass `data=` a separate frame with one row per point, and
 `value` / `ci` / `x` name *scalar* columns on it. coeftable groups the
-companion frame by the table's `rows` (+ `nest`, + `split_columns`) keys
-and collapses each group into a series internally:
+companion frame by the table's `rows` (+ `nest`, + `groups`, +
+`split_columns`) keys and collapses each group into a series internally.
+`groups` participates only when `data` actually carries that column, so a
+companion frame keyed on the row alone stays valid. The one case that needs
+it is a row label appearing under more than one group: without the group
+column in `data` those rows are indistinguishable, so coeftable reports it
+rather than serving every section the same merged series.
 
 ```python
 import datetime as dt

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

@@ -50,7 +50,10 @@ 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. Pass
+- `groups` — an optional column whose values produce section headers. A row
+  label may appear under more than one group, in which case it renders once per
+  section — so the same set of metrics can be reported per region without
+  inventing a `nest` column to tell them apart. 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
@@ -128,6 +131,34 @@ methods = pl.DataFrame(
 )
 ```
 
+## Repeating metrics across sections
+
+A row label may appear under more than one `groups` value. The same metrics can
+therefore be reported per region, each section repeating the full set:
+
+```python
+import polars as pl
+import coeftable as ct
+
+regions = pl.DataFrame(
+    {
+        "metric": ["Revenue", "Signups", "Revenue", "Signups"],
+        "region": ["US", "US", "EU", "EU"],
+        "est": [1.2, 0.4, 2.1, 0.9],
+        "lb": [0.8, 0.1, 1.5, 0.5],
+        "ub": [1.6, 0.7, 2.7, 1.3],
+    }
+)
+
+(
+    ct.CoefTable(
+        regions, rows="metric", groups="region", collapsible_groups=True
+    )
+    .estimate("Effect", "est", ci=("lb", "ub"))
+    .forest("Effect Plot", of="Effect", ref=0.0, symmetric=True)
+)
+```
+
 ## Theming
 
 Four built-in themes are available from `coeftable.theme`:
@@ -182,8 +213,13 @@ companion-frame choice used elsewhere in coeftable:
 arrives in: a SQL export, a dbt model, an experimentation platform's daily
 metrics table. Pass `data=` a separate frame with one row per point, and
 `value` / `ci` / `x` name *scalar* columns on it. coeftable groups the
-companion frame by the table's `rows` (+ `nest`, + `split_columns`) keys
-and collapses each group into a series internally:
+companion frame by the table's `rows` (+ `nest`, + `groups`, +
+`split_columns`) keys and collapses each group into a series internally.
+`groups` participates only when `data` actually carries that column, so a
+companion frame keyed on the row alone stays valid. The one case that needs
+it is a row label appearing under more than one group: without the group
+column in `data` those rows are indistinguishable, so coeftable reports it
+rather than serving every section the same merged series.
 
 ```python
 import datetime as dt

{coeftable-0.3.0 → coeftable-0.3.1}/pyproject.toml

@@ -44,8 +44,14 @@ Homepage = "https://github.com/kylejcaron/coeftable"
 Repository = "https://github.com/kylejcaron/coeftable"
 Issues = "https://github.com/kylejcaron/coeftable/issues"
 
+# PyPI rejects core metadata 2.5, which hatchling 1.30 defaults to.
+# Drop once https://github.com/pypi/warehouse/issues/19083 ships.
 [tool.hatch.build.targets.wheel]
 packages = ["src/coeftable"]
+core-metadata-version = "2.4"
+
+[tool.hatch.build.targets.sdist]
+core-metadata-version = "2.4"
 
 [tool.hatch.version]
 source = "vcs"

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

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

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

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
+from itertools import combinations
 from typing import Any
 
 import narwhals as nw
@@ -125,6 +126,19 @@ def resolve(table: CoefTable) -> Resolved:
                 f"(rows/nest/groups key {column.label!r}); choose a different label."
             )
 
+    # Two layout roles naming the same column collide in the output frame,
+    # which `resolve()` builds keyed by column name -- the later write
+    # silently discards the earlier role's values, so the table renders with
+    # one role's layout missing. Reject it rather than emit a corrupt table.
+    roles = [("rows", table.rows), ("nest", table.nest), ("groups", table.groups)]
+    named = [(role, key) for role, key in roles if key is not None]
+    for (first_role, first_key), (second_role, second_key) in combinations(named, 2):
+        if first_key == second_key:
+            raise SpecError(
+                f"Layout keys {first_role}= and {second_role}= both name column "
+                f"{first_key!r}; each layout role needs its own column."
+            )
+
     # 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
@@ -160,6 +174,7 @@ def resolve(table: CoefTable) -> Resolved:
         split_keys=split_keys,
         rows=table.rows,
         nest=table.nest,
+        groups=table.groups,
         split_columns=table.split_columns,
     )
     prepared: list[Prepared] = [column.prepare(scan) for column in table.columns]
@@ -192,11 +207,11 @@ def resolve(table: CoefTable) -> Resolved:
 
     # Cell pass: one call to `column.cell` per (row, split, column).
     cell_values: dict[str, list[str]] = {name: [] for name in display_columns}
-    for position, (row_key, nest_key) in enumerate(grid.ordered):
+    for position, (row_key, nest_key, identity_group) in enumerate(grid.ordered):
         direction = table.direction_for(str(row_key))
         group = grid.row_group[position]
         for split in grid.splits:
-            index = grid.source_index.get(((row_key, nest_key), split))
+            index = grid.source_index.get(((row_key, nest_key, identity_group), split))
             for column, prep in zip(table.columns, prepared, strict=True):
                 name = output_name(column, split)
                 if index is None:
@@ -225,7 +240,7 @@ def resolve(table: CoefTable) -> Resolved:
             key_fn = prep.footer_key
             footer_keys[column.label] = [
                 [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)
+                for (row_key, _nest, group) in grid.ordered
             ]
     # A footer's domain is table-wide only when the column itself says so
     # (see `Prepared.shared_footer`) -- inferring it from `scale` would be

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

@@ -32,24 +32,6 @@ def _ordered_unique(values: list[Any], *, sort: bool) -> list[Any]:
     return sorted(seen, key=str) if sort else seen
 
 
-def _first_source(
-    source_index: dict[tuple[tuple[Any, Any], Any], int],
-    identity: tuple[Any, Any],
-    splits: list[Any],
-) -> int:
-    """Return the input row backing `identity`, preferring the first split value.
-
-    Split-column data is often sparse, so the first split value may have no row
-    for a given identity. Falling back to any split keeps layout metadata such
-    as the row-group value resolvable.
-    """
-    for split in splits:
-        found = source_index.get((identity, split))
-        if found is not None:
-            return found
-    raise KeyError(f"No input row for {identity!r} under any split value.")
-
-
 @dataclass(frozen=True)
 class Grid:
     """Row identity and ordering for one resolved table, independent of column kind.
@@ -57,23 +39,23 @@ class Grid:
     Parameters
     ----------
     ordered
-        Output rows as `(row key, nest key)` identities, in display order.
-    unique_rows
-        Distinct row keys, in the same order banding and dividers key off.
+        Output rows as `(row key, nest key, group)` identities, in display
+        order: group-major, then row-key order within each group, matching the
+        order `great_tables` renders them in.
     splits
         Distinct split-column values, in display order, or `[None]` when the
         table has no split column.
     source_index
-        Maps `((row key, nest key), split)` to the input frame row backing it.
+        Maps `((row key, nest key, group), split)` to the input frame row
+        backing it.
     row_group
-        The row-group value for each `ordered` position, falling back across
-        splits via `_first_source` when the first split has no data there.
+        The row-group value for each `ordered` position, read straight off the
+        identity.
     """
 
-    ordered: list[tuple[Any, Any]]
-    unique_rows: list[Any]
+    ordered: list[tuple[Any, Any, Any]]
     splits: list[Any]
-    source_index: dict[tuple[tuple[Any, Any], Any], int]
+    source_index: dict[tuple[tuple[Any, Any, Any], Any], int]
     row_group: list[Any]
 
 
@@ -106,37 +88,46 @@ def build_grid(
     Raises
     ------
     SpecError
-        When the same (rows, nest, split_columns) combination appears more
-        than once in the input frame.
+        When the same (rows, nest, groups, split_columns) combination appears
+        more than once in the input frame.
     """
     n = len(row_keys)
-    identities = [(row_keys[i], nest_keys[i]) for i in range(n)]
-    unique_rows = _ordered_unique([r for r, _ in identities], sort=sort_rows)
-    ordered: list[tuple[Any, Any]] = []
-    for row_key in unique_rows:
-        for identity in identities:
-            if identity[0] == row_key and identity not in ordered:
-                ordered.append(identity)
+    identities = [(row_keys[i], nest_keys[i], group_keys[i]) for i in range(n)]
+    unique_rows = _ordered_unique([r for r, _, _ in identities], sort=sort_rows)
+    # Groups keep input order regardless of `sort_rows`, matching what
+    # `great_tables` would have done, so no existing table's group order moves.
+    unique_groups = _ordered_unique(group_keys, sort=False)
+
+    # Group-major: rows are laid out in the same order they render in, so the
+    # band/divider indices computed below stay valid. Ordering by row key alone
+    # would leave `great_tables` to regroup, desynchronising those indices from
+    # what the reader sees whenever a group's rows are not already adjacent.
+    ordered: list[tuple[Any, Any, Any]] = []
+    for group in unique_groups:
+        for row_key in unique_rows:
+            for identity in identities:
+                if identity[0] == row_key and identity[2] == group and identity not in ordered:
+                    ordered.append(identity)
 
     splits = _ordered_unique(split_keys, sort=sort_rows) if has_splits else [None]
-    source_index: dict[tuple[tuple[Any, Any], Any], int] = {}
+    source_index: dict[tuple[tuple[Any, Any, Any], Any], int] = {}
     for i in range(n):
         key = (identities[i], split_keys[i])
         if key in source_index:
-            row_label, nest_label = identities[i]
+            row_label, nest_label, group_label = identities[i]
             extra = f", split={split_keys[i]!r}" if split_keys[i] is not None else ""
             raise SpecError(
-                f"Duplicate input row for row={row_label!r}, nest={nest_label!r}{extra}"
-                f" — each (rows, nest, split_columns) combination "
+                f"Duplicate input row for row={row_label!r}, nest={nest_label!r}, "
+                f"group={group_label!r}{extra}"
+                f" — each (rows, nest, groups, split_columns) combination "
                 f"must appear at most once."
             )
         source_index[key] = i
 
-    row_group = [group_keys[_first_source(source_index, identity, splits)] for identity in ordered]
+    row_group = [identity[2] for identity in ordered]
 
     return Grid(
         ordered=ordered,
-        unique_rows=unique_rows,
         splits=splits,
         source_index=source_index,
         row_group=row_group,
@@ -235,23 +226,26 @@ def assemble_rows(
             cells[name].append("")
 
     previous_row_key_by_group: dict[Any, Any] = {}
-    for position, (row_key, nest_key) in enumerate(grid.ordered):
+    block_index = -1
+    for position, (row_key, nest_key, _group) 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.
+        # A row key may appear under more than one group -- e.g. "Revenue"
+        # under both "US" and "EU" -- so it is not adjacent to its own prior
+        # occurrence. Tracking "first occurrence" per group (rather than one
+        # running `previous_row_key`) keeps the label shown once per group
+        # block 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))
-        if grid.unique_rows.index(row_key) % 2 == 0:
+        # Banding alternates over row-key blocks in display order. Keying off a
+        # global index into the distinct row keys would stripe two adjacent
+        # blocks the same shade whenever a row key spans groups, or groups
+        # interleave.
+        if first_of_key:
+            block_index += 1
+        if block_index % 2 == 0:
             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))