dataface 0.3.2.dev22__py3-none-any.whl → 0.3.2.dev111__py3-none-any.whl

dataface/core/render/chart/table.py

@@ -12,7 +12,7 @@ import re
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
-from dataface.core.compile.colors import (
+from dataface.core.colors import (
     is_sanitizable_color,
     sanitize_color,
 )
@@ -23,7 +23,9 @@ from dataface.core.compile.models.chart.authored import (
 from dataface.core.compile.models.primitives import FontStyle
 from dataface.core.compile.models.style.authored import (
     PaginationConfig,
+    fill_table_column_defaults,
 )
+from dataface.core.compile.resolve import infer_pivot_measure_names
 
 if TYPE_CHECKING:
     from dataface.core.compile.models.chart.authored import (
@@ -71,7 +73,6 @@ from dataface.core.render.chart.table_support import (
     is_total_role,
     measure_column_demands,
     measure_column_word_floors,
-    parse_table_column_configs,
     resolve_cell_conditional_styles,
     resolve_cell_glyph,
     resolve_cell_glyph_from_overrides,
@@ -2489,6 +2490,7 @@ def _render_pagination_controls(
 def _transpose_data_for_render(
     formats: dict[str, str] | None,
     columns: dict[str, TableColumnConfig] | None,
+    column_defaults: TableColumnDefaultsConfig | None,
     data: list[dict[str, Any]],
 ) -> tuple[list[dict[str, Any]], dict[str, TableColumnConfig]]:
     """Pivot a single wide row into N (label, value) rows for the normal renderer.
@@ -2498,6 +2500,15 @@ def _transpose_data_for_render(
     - pivoted_columns maps "__metric__" (40% width) and "__value__" (60%, right-align)
       with "Metric" / "Value" header labels.
 
+    ``columns`` (the resolved, source-column-keyed mapping — column_defaults
+    already baked in there for the *source* columns) supplies each row's
+    label/format only. The two output columns below are a render-native key
+    space — they don't exist until this transform runs — so ``column_defaults``
+    is applied to them here via ``fill_table_column_defaults``, filling only
+    whichever fields "Metric"/"Value"/40%-width/right-align don't already
+    set — "__value__" has no width of its own, so ``column_defaults.width``
+    does pin it if authored.
+
     Raises ChartDataError when data does not have exactly one row.
     """
     if len(data) != 1:
@@ -2525,8 +2536,12 @@ def _transpose_data_for_render(
         pivoted.append({"__metric__": label, "__value__": formatted})
 
     pivoted_columns: dict[str, TableColumnConfig] = {
-        "__metric__": TableColumnConfig(label="Metric", width="40%"),
-        "__value__": TableColumnConfig(label="Value", align="right"),
+        "__metric__": fill_table_column_defaults(
+            TableColumnConfig(label="Metric", width="40%"), column_defaults
+        ),
+        "__value__": fill_table_column_defaults(
+            TableColumnConfig(label="Value", align="right"), column_defaults
+        ),
     }
     return pivoted, pivoted_columns
 
@@ -2564,7 +2579,9 @@ def _render_table_svg_core(
     tc = table_style.table
 
     # Chart-level pivot (rows/columns/values channels): reshape long → wide.
-    # Skip when data is empty — fall through to the "No data" empty-state below.
+    # Called unconditionally — a flat table (no pivot_columns) and empty data
+    # both pass straight through, so the layout sizer can call the same way and
+    # can't disagree with us about which shapes reshape.
     # groups is None for flat tables and single-dim single-measure pivot;
     # list-of-levels otherwise (triggers N-row header rendering below).
     # row_role_spec is hoisted here (ahead of the row loop that also reads it) so
@@ -2572,16 +2589,13 @@ def _render_table_svg_core(
     # row. TableRowStyle.role defaults to None — resolve_row_role/is_total_role
     # both accept None (treat every row as "value"), so unset is a valid case.
     row_role_spec = tc.row.role
-    _pivot_groups: list[list[tuple[str, int, int]]] | None = None
-    _pivot_effective_values: list[str] = []
-    if pivot_columns and data:
-        data, _pivot_groups, _pivot_effective_values = pivot_table_data(
-            data,
-            rows=rows or [],
-            columns=pivot_columns,
-            values=values,
-            row_role_spec=row_role_spec,
-        )
+    data, _pivot_groups, _pivot_effective_values = pivot_table_data(
+        data,
+        rows=rows or [],
+        columns=pivot_columns,
+        values=values,
+        row_role_spec=row_role_spec,
+    )
 
     # Build colors dict from chart-local TableChartStyle (which already has
     # board-level values cascaded in). board_style is only needed for font
@@ -2730,14 +2744,9 @@ def _render_table_svg_core(
     subtitle_lines = list(title_block.subtitle_lines)
     subtitle_font_size = title_block.subtitle_font_size
 
-    # Pass query column names so column_defaults can apply to all inferred columns
-    # when no explicit style.columns is provided (the "no columns" authoring shape).
-    query_columns = list(data[0].keys()) if data else None
-    column_configs = parse_table_column_configs(
-        columns_promoted,
-        column_defaults_promoted,
-        query_columns=query_columns,
-    )
+    # columns_promoted is already the complete, final per-column config
+    # mapping (defaults + explicit overrides + FK links baked in at resolve).
+    column_configs: dict[str, TableColumnConfig] = dict(columns_promoted or {})
 
     # Tables read conditional_formatting rules directly at render time — no
     # internal lowering into column configs.
@@ -2764,8 +2773,13 @@ def _render_table_svg_core(
             if existing is not None:
                 _expanded_cc[leaf] = existing
             else:
-                _expanded_cc[leaf] = TableColumnConfig(
-                    label=slug_to_text(_display_label)
+                # Measure not explicitly authored — its key space (this leaf)
+                # only exists after the pivot transform above, so resolve
+                # excluded it from column_configs; apply column_defaults here.
+                _expanded_cc[leaf] = fill_table_column_defaults(
+                    None,
+                    column_defaults_promoted,
+                    fallback_label=slug_to_text(_display_label),
                 )
         column_configs = {**column_configs, **_expanded_cc}
         # Remap column_when_rules: measure-name key → leaf keys.
@@ -2776,14 +2790,37 @@ def _render_table_svg_core(
             if _measure_part and _measure_part in column_when_rules:
                 _expanded_cwr[leaf] = column_when_rules[_measure_part]
         column_when_rules = {**column_when_rules, **_expanded_cwr}
+    elif pivot_columns and data:
+        # Single-dim single-measure pivot: leaf keys are the bare pivoted
+        # values themselves (no separator, no measure-name lookup needed) —
+        # but that key space still only exists after the pivot transform
+        # above, so any key not already explicitly authored gets
+        # column_defaults applied here, same as the multi-measure case.
+        for leaf in data[0]:
+            if leaf == row_role_spec or leaf in column_configs:
+                continue
+            column_configs[leaf] = fill_table_column_defaults(
+                None, column_defaults_promoted, fallback_label=slug_to_text(leaf)
+            )
 
     header_overflow = resolve_header_overflow(table_config, header_overflow_promoted)
 
     # Prefer explicit configured columns so helper/style columns can stay hidden.
     # Dict keys preserve insertion order, so authored column order is honored.
-    # For multi-measure pivot, columns_promoted is keyed by measure names —
-    # not leaf keys — so we always derive columns from data keys in pivot mode.
-    if columns_promoted and _pivot_groups is None:
+    #
+    # In pivot mode, columns_promoted's keys are the real leaf/pivoted-value
+    # keys ONLY for an explicitly-authored single-dim single-measure pivot
+    # (authors key style.columns by those bare values directly) — checked via
+    # the subset test below. For every other pivot shape (multi-measure/dim,
+    # or resolve's inferred row/pivot-dimension columns) columns_promoted is
+    # keyed by measure or dimension names that never match the actual
+    # post-transform keys, so the visible list must come from data instead.
+    # An empty `data` means the transform above never ran (nothing to check
+    # against) — honor the authored list so an authored table still shows
+    # its declared header in the empty-state render.
+    if columns_promoted and (
+        not pivot_columns or not data or set(columns_promoted).issubset(data[0])
+    ):
         columns = list(columns_promoted.keys())
     else:
         columns = list(data[0].keys()) if data else []
@@ -3397,7 +3434,9 @@ def render_table_svg(
     columns = chart.columns
 
     if chart.style.table.transpose and data:
-        data, columns = _transpose_data_for_render(chart.style.formats, columns, data)
+        data, columns = _transpose_data_for_render(
+            chart.style.formats, columns, chart.column_defaults, data
+        )
 
     return _render_table_svg_core(
         chart_id=chart.id,
@@ -3479,9 +3518,8 @@ def _validate_pivot_fields(
             f" carries the per-row role — observed keys: {observed}"
         )
 
-    claimed = set(rows) | set(columns) | ({row_role_spec} if row_role_spec else set())
-    effective_values: list[str] = (
-        values if values is not None else [k for k in all_keys if k not in claimed]
+    effective_values = infer_pivot_measure_names(
+        all_keys, rows, columns, values, row_role_spec
     )
     for v in effective_values:
         if v not in all_keys:
@@ -3548,12 +3586,18 @@ def pivot_table_data(
     data: list[dict[str, Any]],
     *,
     rows: list[str],
-    columns: list[str],
+    columns: list[str] | None,
     values: list[str] | None,
     row_role_spec: str | None = None,
 ) -> tuple[list[dict[str, Any]], list[list[tuple[str, int, int]]] | None, list[str]]:
     """Reshape long-form tidy data into a wide pivot matrix.
 
+    Also the single owner of the "is this a pivot?" decision: no ``columns``
+    means a flat table and the rows pass through untouched. The renderer and
+    the layout sizer (``layout_sizing._get_table_height_from_data``) both call
+    unconditionally, so the height the sizer reserves is always the row count
+    the renderer draws.
+
     Args:
         data: Long-form source rows.
         rows: Row-dimension field names (form the composite row key). When
@@ -3562,7 +3606,8 @@ def pivot_table_data(
             column order (mirrors ``values``'s own inference).
         columns: Pivot-column field(s) whose distinct values become column headers.
             Single field → single-dimension pivot. Multiple fields → nested
-            multi-dimension pivot (outer dim first, inner dim last).
+            multi-dimension pivot (outer dim first, inner dim last). Empty or
+            ``None`` → not a pivot; ``data`` comes back unchanged.
         values: Measure field names.  When ``None``, infers as all query columns
             not in ``rows``, not any column field, and not the role marker,
             preserving query column order.
@@ -3610,8 +3655,8 @@ def pivot_table_data(
             field onto rows or columns." (a total row keys by rows-dim like any
             other, so this covers both detail and total collisions).
     """
-    if not data:
-        return [], None, []
+    if not columns or not data:
+        return data, None, []
 
     # Both dims omitted → the remaining fields can't be split into rows vs
     # measures without guessing. Validate-and-error rather than degenerate into

dataface/core/render/chart/table_support.py

@@ -29,6 +29,7 @@ from dataface.core.render.chart.title_overflow import (
 from dataface.core.render.format_utils import default_number_format, format_value
 from dataface.core.render.utils import resolve_tone_color, slug_to_text
 from dataface.core.text.case import CaseValue, apply_case
+from dataface.core.text.format_d3 import portable_strftime
 from mdsvg.fonts import FontMeasurer
 
 # Three-lane numeric rendering constants used by table.py:_compute_lane_positions.
@@ -49,7 +50,6 @@ if TYPE_CHECKING:
         TableColumnConfig,
     )
     from dataface.core.compile.models.primitives import FormatConfig
-    from dataface.core.compile.models.style.authored import TableColumnDefaultsConfig
     from dataface.core.compile.models.style.theme import (
         KpiTonesStyle,
         TableChartStyle,
@@ -212,62 +212,11 @@ def _format_temporal_value(
         d = value
 
     try:
-        return d.strftime(format_spec)
+        return portable_strftime(d, format_spec)
     except ValueError as e:
         raise ValueError(f"Invalid temporal format spec {format_spec!r}: {e}") from e
 
 
-def _apply_column_defaults(
-    cfg: TableColumnConfig,
-    defaults: TableColumnDefaultsConfig,
-) -> TableColumnConfig:
-    updates = {
-        name: getattr(defaults, name)
-        for name in type(defaults).model_fields
-        if getattr(cfg, name) is None and getattr(defaults, name) is not None
-    }
-    return cfg.model_copy(update=updates) if updates else cfg
-
-
-def parse_table_column_configs(
-    columns_config: dict[str, TableColumnConfig] | None,
-    defaults: TableColumnDefaultsConfig | None = None,
-    query_columns: list[str] | None = None,
-) -> dict[str, TableColumnConfig]:
-    """Apply table-level defaults to the resolved column configurations.
-
-    When column_defaults is set and columns is unset, query_columns is used to
-    materialize a default config for every query-inferred column — enabling the
-    "no columns list" authoring shape where uniform presentation is set once at
-    the table style level.
-    """
-    from dataface.core.compile.models.chart.authored import (
-        SparkConfig,
-        TableColumnConfig,
-    )
-
-    # No explicit columns: if column_defaults is set, materialize defaults for
-    # every query-inferred column so authors need not list columns at all.
-    if not columns_config:
-        if defaults and query_columns:
-            return {
-                col: _apply_column_defaults(TableColumnConfig(), defaults)
-                for col in query_columns
-            }
-        return {}
-
-    result: dict[str, TableColumnConfig] = {}
-    for field_name, col_cfg in columns_config.items():
-        cfg = col_cfg
-        # Normalize spark string shorthand to SparkConfig so render code can
-        # use isinstance(cfg.spark, SparkConfig) uniformly.
-        if isinstance(cfg.spark, str):
-            cfg = cfg.model_copy(update={"spark": SparkConfig(type=cfg.spark)})
-        result[field_name] = _apply_column_defaults(cfg, defaults) if defaults else cfg
-
-    return result
-
-
 def parse_column_width(
     width_hint: int | str | None, available_width: float
 ) -> float | None:

dataface/core/render/chart/time_unit_detect.py

@@ -30,9 +30,10 @@ import re
 import statistics
 from typing import Any
 
-from dataface.core.compile.enrich import is_year_shaped
 from dataface.core.font_measure import FontMeasurer
 from dataface.core.render.chart.artifacts import ChartRenderData
+from dataface.core.text.format_d3 import portable_strftime
+from dataface.core.utils import is_year_shaped
 
 # ISO date: "2024-01-15"
 _ISO_DATE_RE = re.compile(r"^\d{4}-\d{2}-\d{2}$")
@@ -227,7 +228,7 @@ def _cadence_token_width(
     if format_tu == "yearweek":
         return measurer.measure(d.strftime("W%V"), size)
     if format_tu == "yearmonthdate":
-        return measurer.measure(d.strftime("%-d %b"), size)
+        return measurer.measure(portable_strftime(d, "%-d %b"), size)
     raise ValueError(
         f"_cadence_token_width: {format_tu!r} is not a bucketed calendar grain"
     )

dataface/core/render/chart/translate.py

@@ -21,10 +21,12 @@ the standard path like any other sub-spec.
 from __future__ import annotations
 
 import json
+from collections.abc import Callable
 from typing import Any
 
 from dataface.core.compile.models.style.resolved import ResolvedStyle
 from dataface.core.compile.vega_lite import VEGA_LITE_SCHEMA_URL
+from dataface.core.render.chart._types import VLDict
 from dataface.core.render.chart.presentation import (
     _HREF_FIELD,
     apply_presentation_defaults,
@@ -411,6 +413,25 @@ def _wrap_vconcat_label_rail(
 # ---------------------------------------------------------------------------
 
 
+def _in_chart_pane(vl: VLDict, stamp: Callable[[VLDict], VLDict]) -> VLDict:
+    """Run ``stamp`` on the pane that carries the marks.
+
+    An endpoint-label rail wraps the chart in a concat: ``hconcat`` for the
+    vertical layout (chart first, label pane right), ``vconcat`` for the
+    horizontal one (rail first, chart second). Neither VL nor Vega reads a
+    top-level ``encoding``, ``transform`` or ``params`` on a concat spec, so
+    anything that stamps those has to descend to the chart pane or it lands
+    somewhere the renderer never looks.
+    """
+    if "hconcat" in vl:
+        main, *rest = vl["hconcat"]
+        return {**vl, "hconcat": [_in_chart_pane(main, stamp), *rest]}
+    if "vconcat" in vl:
+        rail, main = vl["vconcat"]
+        return {**vl, "vconcat": [rail, _in_chart_pane(main, stamp)]}
+    return stamp(vl)
+
+
 def _apply_structured_tooltip(vl: dict[str, Any], expr: str) -> dict[str, Any]:
     """Inject the description encoding for the structured tooltip.
 
@@ -433,11 +454,13 @@ def _apply_structured_tooltip(vl: dict[str, Any], expr: str) -> dict[str, Any]:
     Vega signal expression (confirmed: identical rendered aria-label content,
     clean impute groupby with the fix, corrupted path without it).
 
-    Endpoint labels (right_pane layout) wrap the layered spec in an ``hconcat``
-    before this post-processing step runs (``_translate_layered`` calls
-    ``_wrap_endpoint_labels`` internally) — recurse into the main panel
-    (``hconcat[0]``) rather than stamping a no-op encoding onto the hconcat
-    wrapper itself; the label rail (``hconcat[1]``) carries no data marks.
+    Endpoint labels wrap the layered spec in an ``hconcat`` (right_pane,
+    vertical stacked bar/line/area, chart pane at index 0) or a ``vconcat``
+    (top_rail, horizontal stacked bar, chart pane at index 1 — the rail sits
+    above it) before this post-processing step runs (``_translate_layered``
+    calls ``_wrap_endpoint_labels`` internally) — recurse into the actual
+    chart pane rather than stamping a no-op encoding onto the wrapper itself;
+    the label pane/rail carries no data marks of its own.
 
     A layered spec needs one more override for ``BaselineFeature``'s
     zero/top/unity rule overlays specifically: they're appended sub-layers
@@ -457,41 +480,47 @@ def _apply_structured_tooltip(vl: dict[str, Any], expr: str) -> dict[str, Any]:
     channel" convention — the same one ``_full_rule_at`` and
     ``_isolate_independent_y_axis`` already rely on for ``axis``/``legend``).
     """
-    if "hconcat" in vl:
-        result = dict(vl)
-        main, *rest = vl["hconcat"]
-        result["hconcat"] = [_apply_structured_tooltip(main, expr), *rest]
+
+    def stamp(pane: VLDict) -> VLDict:
+        result = dict(pane)
+        enc = dict(result.get("encoding") or {})
+        enc["description"] = {"value": {"expr": expr}}
+        result["encoding"] = enc
+        layers = result.get("layer")
+        if isinstance(layers, list):
+            result["layer"] = [
+                (
+                    {
+                        **layer,
+                        "encoding": {
+                            **(layer.get("encoding") or {}),
+                            "description": None,
+                        },
+                    }
+                    if "data" in layer
+                    else layer
+                )
+                for layer in layers
+            ]
         return result
-    result = dict(vl)
-    enc = dict(result.get("encoding") or {})
-    enc["description"] = {"value": {"expr": expr}}
-    result["encoding"] = enc
-    layers = result.get("layer")
-    if isinstance(layers, list):
-        result["layer"] = [
-            (
-                {
-                    **layer,
-                    "encoding": {**(layer.get("encoding") or {}), "description": None},
-                }
-                if "data" in layer
-                else layer
-            )
-            for layer in layers
-        ]
-    return result
+
+    return _in_chart_pane(vl, stamp)
 
 
 def _apply_href_link(vl: dict[str, Any], href_link: str) -> dict[str, Any]:
     """Inject calculate transform + href encoding for click interactivity."""
-    result = dict(vl)
-    transforms = list(result.get("transform") or [])
-    transforms.append({"calculate": href_link, "as": _HREF_FIELD})
-    result["transform"] = transforms
-    enc = dict(result.get("encoding") or {})
-    enc["href"] = {"field": _HREF_FIELD, "type": "nominal"}
-    result["encoding"] = enc
-    return result
+
+    def stamp(pane: VLDict) -> VLDict:
+        result = dict(pane)
+        transforms = list(result.get("transform") or [])
+        transforms.append({"calculate": href_link, "as": _HREF_FIELD})
+        result["transform"] = transforms
+        enc = dict(result.get("encoding") or {})
+        enc["href"] = {"field": _HREF_FIELD, "type": "nominal"}
+        result["encoding"] = enc
+        return result
+
+    return _in_chart_pane(vl, stamp)
 
 
 def _apply_legend_toggle(vl: dict[str, Any], color_field: str) -> dict[str, Any]:
@@ -500,9 +529,12 @@ def _apply_legend_toggle(vl: dict[str, Any], color_field: str) -> dict[str, Any]
     In a layered spec the param is anchored inside the first data-bearing layer
     to avoid duplicate Vega signals.
     """
+    if "hconcat" in vl or "vconcat" in vl:
+        return _in_chart_pane(vl, lambda pane: _apply_legend_toggle(pane, color_field))
+
     enc = vl.get("encoding")
     if not isinstance(enc, dict):
-        return vl  # hconcat/vconcat wrappers have no top-level encoding
+        return vl
 
     color_enc = enc.get("color")
     if not isinstance(color_enc, dict):
@@ -626,12 +658,14 @@ def assemble_final_vl(
 
     Args:
         spec: ``ChartSpec`` produced by an emitter and mutated by the feature
-            pipeline.  Must carry ``title``/``subtitle``/``title_font`` if
-            needed (set by ``FaceRenderSession.emit_chart`` from the resolved
-            chart).
-        board_style: Fully resolved board-level style.  Supplies
-            ``vega_config`` (baked theme config) and ``charts`` (per-chart
-            style overlay).
+            pipeline.  Must carry ``title``/``subtitle``/``title_font``/
+            ``background``/``title_style`` (set by
+            ``FaceRenderSession.emit_chart`` from the resolved chart —
+            ``title`` is the raw jinja-resolved text; title-case is applied
+            here from ``title_style.font.case``, VL-presentation only).
+        board_style: Fully resolved board-level style.  Supplies only
+            ``vega_config`` (baked theme config) — unchanged face-level
+            presentation, not a per-chart decision.
 
     Returns:
         Vega-Lite JSON-serialisable spec dict with config and background applied.
@@ -641,16 +675,20 @@ def assemble_final_vl(
     """
     vl = translate_to_vl(spec)
 
+    assert spec.background is not None and spec.title_style is not None, (
+        "ChartSpec.background/title_style must be set by "
+        "FaceRenderSession.emit_chart before assemble_final_vl runs"
+    )
     vl = apply_presentation_defaults(
         vl,
-        board_style.charts,
+        spec.background,
         board_style.vega_config,
     )
 
     if spec.title or spec.subtitle:
         from dataface.core.render.chart.spec_builders import set_chart_title
 
-        set_chart_title(vl, spec.title, spec.subtitle, style=board_style.charts)
+        set_chart_title(vl, spec.title, spec.subtitle, case=spec.title_style.font.case)
 
     # config.title.fontSize/fontWeight come from theme YAML as floats; coerce to int.
     if "config" in vl and "title" in vl["config"]: