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

dataface/core/render/chart/vl_field_maps.py

@@ -2,10 +2,11 @@
 
 from __future__ import annotations
 
-from typing import Literal
+from typing import Any, Literal
 
 from pydantic import BaseModel
 
+from dataface.core.compile.models.style.resolved._base import ResolvedScaleStyle
 from dataface.core.compile.models.style.theme.marks import BarMarkStyle
 from dataface.core.compile.tick_values import numeric_domain_bounds
 from dataface.core.render.chart._types import VLDict
@@ -19,40 +20,76 @@ from dataface.core.render.chart.emitters._measured_label_padding import (
     quantitative_tick_labels,
 )
 
-SCALE_FIELD_MAP: dict[str, str] = {
-    # ``paddingInner`` / ``paddingOuter`` are the encoding-level VL field names
-    # for band-scale gutter and edge padding. The ``bandPaddingInner`` /
-    # ``bandPaddingOuter`` variants only work at the global config level
-    # (``config.scale.bandPaddingInner``) — they are silently ignored when
-    # placed on ``encoding.{x,y}.scale``.
-    "band_padding_inner": "paddingInner",
-    "band_padding_outer": "paddingOuter",
-    "point_padding": "pointPadding",
-    "rect_band_padding_inner": "rectBandPaddingInner",
-    "round": "round",
+# ``type``/log.base/pow.exponent/symlog.constant emit log/pow/symlog scale
+# config. Must not be omitted — a missed field silently resolves to None and
+# drops scale config from the emitted spec.
+_SCALE_CONTINUOUS_FIELD_MAP: dict[str, str] = {
     "zero": "zero",
-    "clamp": "clamp",
-    "continuous_padding": "continuousPadding",
-    "quantile_count": "quantileCount",
-    "quantize_count": "quantizeCount",
-    "use_unaggregated_domain": "useUnaggregatedDomain",
-    "x_reverse": "xReverse",
     "type": "type",
-    "base": "base",
-    "exponent": "exponent",
-    "constant": "constant",
+    # domain and nice are encoding-level only (see SCALE_ENCODING_FIELD_MAP).
 }
-
-# Encoding-level-only scale fields applied to encoding.x.scale / encoding.y.scale.
+# Universal top-level scale fields (not in any sub-group).
+_SCALE_UNIVERSAL_FIELD_MAP: dict[str, str] = {
+    "round": "round",
+    "clamp": "clamp",
+}
+# Encoding-level-only scale fields: nice, padding shorthand. domain is read
+# explicitly from scale.continuous.domain below (nested, not a flat field).
+# Applied to encoding.x.scale / encoding.y.scale only (not VL config).
 SCALE_ENCODING_FIELD_MAP: dict[str, str] = {
-    "domain": "domain",
     "nice": "nice",
     # Unified shorthand. VL dispatches based on scale type (bandPaddingOuter,
     # pointPadding, continuousPadding). Encoding-level only.
     "padding": "padding",
 }
+# x-channel-only scale fields.
+_SCALE_X_ONLY_FIELD_MAP: dict[str, str] = {
+    "x_reverse": "xReverse",
+}
+
 
-from typing import Any
+def emit_resolved_scale_vl(
+    scale: ResolvedScaleStyle | None,
+    *,
+    include_encoding_fields: bool = True,
+    include_x_only: bool = False,
+) -> dict[str, Any]:
+    """Emit a VL scale dict from a ResolvedScaleStyle (non-None fields only).
+
+    Args:
+        scale: Resolved scale to emit. Returns {} when None.
+        include_encoding_fields: When True (default), includes domain/nice/padding
+            (encoding-level-only fields). Set False for VL config-level emit.
+        include_x_only: When True, includes xReverse (x-channel only).
+    """
+    if scale is None:
+        return {}
+    out: dict[str, Any] = {}
+    out.update(map_fields(scale, _SCALE_UNIVERSAL_FIELD_MAP))
+    if scale.continuous is not None:
+        out.update(map_fields(scale.continuous, _SCALE_CONTINUOUS_FIELD_MAP))
+        if scale.continuous.log is not None and scale.continuous.log.base is not None:
+            out["base"] = scale.continuous.log.base
+        if (
+            scale.continuous.pow is not None
+            and scale.continuous.pow.exponent is not None
+        ):
+            out["exponent"] = scale.continuous.pow.exponent
+        if (
+            scale.continuous.symlog is not None
+            and scale.continuous.symlog.constant is not None
+        ):
+            out["constant"] = scale.continuous.symlog.constant
+    if include_encoding_fields:
+        out.update(map_fields(scale, SCALE_ENCODING_FIELD_MAP))
+        if scale.continuous is not None:
+            domain = scale.continuous.domain
+            if domain is not None:
+                out["domain"] = domain
+    if include_x_only:
+        if scale.x_reverse is not None:
+            out["xReverse"] = scale.x_reverse
+    return out
 
 
 def _n(obj: Any, *path: str) -> Any:
@@ -97,9 +134,9 @@ def axis_to_vl(
 ) -> dict[str, Any]:
     """Map any axis style object → VL axis config dict (non-None fields only).
 
-    Works for AxisStyle (all fields concrete, always emitted) and
-    AxisStylePatch (skip None). Single canonical mapper for all axis
-    variants — theme global/channel/type-conditional and chart-local patches.
+    Works for any concrete axis style (all fields emitted) and any axis-variant
+    patch (skip None). Single canonical mapper for all axis variants — theme
+    global/channel/type-conditional and chart-local patches.
 
     ``label_overlap`` is the render-local VL directive from resolve_axis_x_overlap;
     it is not stored on the resolved model (VL vocabulary stays out of Resolved*).
@@ -108,27 +145,25 @@ def axis_to_vl(
         return {}
     d: dict[str, Any] = {}
 
-    # Label font (nested via label.font)
-    if (v := _n(axis, "label", "font", "color")) is not None:
+    # Label font (nested via labels.font)
+    if (v := _n(axis, "labels", "font", "color")) is not None:
         d["labelColor"] = v
-    if (v := _n(axis, "label", "font", "family")) is not None:
+    if (v := _n(axis, "labels", "font", "family")) is not None:
         d["labelFont"] = v
-    if (v := _n(axis, "label", "font", "size")) is not None:
+    if (v := _n(axis, "labels", "font", "size")) is not None:
         d["labelFontSize"] = v
-    if (v := _n(axis, "label", "font", "weight")) is not None:
+    if (v := _n(axis, "labels", "font", "weight")) is not None:
         d["labelFontWeight"] = v
-    if (v := _n(axis, "label", "padding")) is not None:
+    if (v := _n(axis, "labels", "padding")) is not None:
         d["labelPadding"] = v
-    if (v := _n(axis, "label", "max_width")) is not None:
+    if (v := _n(axis, "labels", "max_width")) is not None:
         d["labelLimit"] = v
     if label_angle is not None:
         d["labelAngle"] = label_angle
-    elif (v := _n(axis, "label", "angle")) is not None:
+    elif (v := _n(axis, "labels", "angle")) is not None:
         d["labelAngle"] = v
-    if (v := _n(axis, "label", "align")) is not None:
+    if (v := _n(axis, "labels", "align")) is not None:
         d["labelAlign"] = v
-    if (v := _n(axis, "label", "baseline")) is not None:
-        d["labelBaseline"] = v
     # label_overlap is the render-local VL directive from resolve_axis_x_overlap.
     # "allow" → false (no reduction; labels may overlap).
     # "parity" → pass through as-is (VL drops every other label).
@@ -137,22 +172,20 @@ def axis_to_vl(
         d["labelOverlap"] = False
     elif label_overlap == "parity":
         d["labelOverlap"] = label_overlap
-    if (v := _n(axis, "label", "separation")) is not None:
+    if (v := _n(axis, "labels", "min_gap")) is not None:
         d["labelSeparation"] = v
-    if (v := _n(axis, "label", "visible")) is not None:
+    if (v := _n(axis, "labels", "visible")) is not None:
         d["labels"] = v
-    if (v := _n(axis, "label", "expr")) is not None:
+    if (v := _n(axis, "labels", "expr")) is not None:
         d["labelExpr"] = v
-    if (v := _n(axis, "label", "bound")) is not None:
+    if (v := _n(axis, "labels", "bound")) is not None:
         d["labelBound"] = v
-    if (v := _n(axis, "label", "flush")) is not None:
+    if (v := _n(axis, "labels", "flush")) is not None:
         d["labelFlush"] = v
-    if (v := _n(axis, "label", "offset")) is not None:
+    if (v := _n(axis, "labels", "offset")) is not None:
         d["labelOffset"] = v
-    if (v := _n(axis, "label", "line_height")) is not None:
-        d["labelLineHeight"] = v
-    if (v := _n(axis, "label", "anchor")) is not None:
-        d["labelAnchor"] = v
+    if (v := _n(axis, "labels", "format")) is not None:
+        d["format"] = v
 
     # Title: null suppresses the visual axis label (title still appears in tooltips
     # via encoding.title). Emitting null is the correct VL mechanism — it removes
@@ -184,12 +217,12 @@ def axis_to_vl(
     if (v := _n(axis, "grid", "dash")) is not None:
         d["gridDash"] = v
 
-    # Domain
-    if (v := _n(axis, "domain", "visible")) is not None:
+    # Domain (Dataface's `line` field — VL's axis.domain* properties)
+    if (v := _n(axis, "line", "visible")) is not None:
         d["domain"] = v
-    if (v := _n(axis, "domain", "width")) is not None:
+    if (v := _n(axis, "line", "width")) is not None:
         d["domainWidth"] = v
-    if (v := _n(axis, "domain", "color")) is not None:
+    if (v := _n(axis, "line", "color")) is not None:
         d["domainColor"] = v
 
     # Ticks
@@ -197,21 +230,19 @@ def axis_to_vl(
         d["ticks"] = v
     if (v := _n(axis, "ticks", "color")) is not None:
         d["tickColor"] = v
-    if (v := _n(axis, "ticks", "size")) is not None:
+    if (v := _n(axis, "ticks", "length")) is not None:
         d["tickSize"] = v
     if (v := _n(axis, "ticks", "width")) is not None:
         d["tickWidth"] = v
+    if (v := _n(axis, "ticks", "offset")) is not None:
+        d["offset"] = v
 
     # Flat fields
     if (v := _n(axis, "position")) is not None:
         d["orient"] = v
-    if (v := _n(axis, "offset")) is not None:
-        d["offset"] = v
     if (v := _n(axis, "band_position")) is not None:
         d["bandPosition"] = v
-    if (v := _n(axis, "format")) is not None:
-        d["format"] = v
-    if (v := _n(axis, "values")) is not None:
+    if (v := _n(axis, "scale", "values")) is not None:
         d["values"] = v
 
     return d
@@ -262,28 +293,32 @@ def measure_axis_to_vl(
         orient in ("left", "right")
         and align == orient
         and "labelExpr" not in d
-        and axis.label.font.case not in ("upper", "lower")
+        and axis.labels.font.case not in ("upper", "lower")
     ):
         if category_labels:
             labels = list(category_labels)
-        elif axis.format is not None:
+        elif axis.labels.format is not None:
             if axis.tick_values:
-                labels = quantitative_tick_labels(tuple(axis.tick_values), axis.format)
+                labels = quantitative_tick_labels(
+                    tuple(axis.tick_values), axis.labels.format
+                )
             else:
-                domain = axis.scale.domain if axis.scale is not None else None
+                _sc = axis.scale
+                _sc_cont = _sc.continuous if _sc is not None else None
+                domain = _sc_cont.domain if _sc_cont is not None else None
                 bounds = numeric_domain_bounds(domain)
                 values = numeric_values(data, y_fields) + (
                     list(bounds) if bounds is not None else []
                 )
-                labels = estimated_quantitative_tick_labels(values, axis.format)
+                labels = estimated_quantitative_tick_labels(values, axis.labels.format)
     if labels:
         tick_size = (
-            axis.ticks.size if axis.ticks.size is not None else DEFAULT_VL_TICK_SIZE
+            axis.ticks.length if axis.ticks.length is not None else DEFAULT_VL_TICK_SIZE
         )
-        padding = measured_label_padding(labels, axis.label.font, tick_size)
+        padding = measured_label_padding(labels, axis.labels.font, tick_size)
         label_limit = (
-            axis.label.max_width
-            if axis.label.max_width is not None
+            axis.labels.max_width
+            if axis.labels.max_width is not None
             else DEFAULT_VL_LABEL_LIMIT
         )
         d["labelPadding"] = cap_padding_to_label_limit(padding, label_limit, tick_size)
@@ -329,7 +364,7 @@ def inject_axis_label_case(ax_vl: dict[str, Any], axis: Any) -> dict[str, Any]:
     MUST be called AFTER build_cartesian_x_encoding for x-axes so the temporal
     smart-cadence labelExpr is already set before wrapping.
     """
-    case = _n(axis, "label", "font", "case")
+    case = _n(axis, "labels", "font", "case")
     if case not in ("upper", "lower"):
         return ax_vl
     inner = ax_vl.get("labelExpr", "datum.label")
@@ -337,21 +372,21 @@ def inject_axis_label_case(ax_vl: dict[str, Any], axis: Any) -> dict[str, Any]:
 
 
 def inject_axis_label_values_filter(ax_vl: dict[str, Any], axis: Any) -> dict[str, Any]:
-    """Wrap labelExpr with a membership filter for authored ``label.values``.
+    """Wrap labelExpr with a membership filter for authored ``labels.values``.
 
-    Blanks any tick whose date isn't in ``axis.label.values``, decoupling
+    Blanks any tick whose date isn't in ``axis.labels.values``, decoupling
     label density from tick/grid density: tick/grid values are left
-    dense (auto-filled or explicitly authored via ``axis.values``); only the
-    listed dates keep their label text. The inner expression defaults to
+    dense (auto-filled or explicitly authored via ``axis.scale.values``); only
+    the listed dates keep their label text. The inner expression defaults to
     ``datum.label`` when no labelExpr is present yet, so authoring only
-    ``label.values`` on an otherwise-plain temporal axis still respects
+    ``labels.values`` on an otherwise-plain temporal axis still respects
     whatever ``format`` VL already applied to ``datum.label``.
 
     MUST be called AFTER build_cartesian_x_encoding / inject_axis_label_case
     so it wraps whatever label text (smart cadence, custom format, case) those
-    steps already produced — label.values always wins on top.
+    steps already produced — labels.values always wins on top.
     """
-    label_values = _n(axis, "label", "values")
+    label_values = _n(axis, "labels", "values")
     if label_values is None:
         return ax_vl
     from dataface.core.render.chart.time_unit_detect import label_values_filter_expr

dataface/core/render/conditions.py

@@ -0,0 +1,122 @@
+"""Boolean conditions authored in YAML — ``enabled``, ``visible``.
+
+Stage: RENDER
+Purpose: Turn a bool, a Jinja expression, or a single-row query probe into the
+yes/no a renderer needs.
+
+Three surfaces share this: a variable's ``enabled``, a layout item's
+``visible``, and the terminal renderer's copy of the same question. They differ
+only in what a missing condition means, which is why ``if_none`` is a parameter
+rather than a default baked in here.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from dataface.core.compile.jinja import resolve_jinja_template
+
+if TYPE_CHECKING:
+    from dataface.core.compile.models.variable.authored import SingleRowBoolProbe
+    from dataface.core.execute.chart_data_provider import ChartDataProvider
+
+
+def coerce_bool(value: Any) -> bool:
+    """Coerce value to bool; raise ValueError for unrecognized inputs."""
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, (int, float)):
+        if value == 1:
+            return True
+        if value == 0:
+            return False
+    if isinstance(value, str):
+        lower = value.strip().lower()
+        if lower in ("true", "1", "yes"):
+            return True
+        if lower in ("false", "0", "no"):
+            return False
+    raise ValueError(f"Cannot coerce {value!r} to bool; expected true/false/1/0/yes/no")
+
+
+def eval_bool_condition(
+    expr: bool | str | SingleRowBoolProbe | None,
+    if_none: bool,
+    current_values: dict[str, Any],
+    executor: ChartDataProvider | None,
+    context: str,
+) -> bool:
+    """Evaluate a bool/str/probe condition and return the result.
+
+    Shared core for Variable.enabled and LayoutItem.visible; callers pass
+    ``if_none`` to control the meaning of a missing (None) value.
+
+    - None: return ``if_none`` (enabled → True, visible → True).
+    - bool: return as-is.
+    - str: auto-wrap in ``{{ }}`` if needed, evaluate as Jinja, coerce to bool.
+    - SingleRowBoolProbe: execute the named query; expect exactly 1 row; coerce
+      the named column to bool.
+
+    Args:
+        expr: The condition value (from YAML or a compiled model field).
+        if_none: Value to return when expr is None.
+        current_values: Current variable values for Jinja resolution.
+        executor: Required when expr is a SingleRowBoolProbe.
+        context: Human-readable label for error messages (e.g. "Variable 'region' disabled").
+
+    Raises:
+        ValueError: Wrong row count, missing column, non-bool-coercible value, or
+            no executor for a query-backed condition.
+    """
+    if expr is None:
+        return if_none
+    if isinstance(expr, bool):
+        return expr
+    if isinstance(expr, str):
+        # Auto-wrap bare variable names / Jinja expressions (no {{ }} required).
+        jinja_expr = expr if "{{" in expr else f"{{{{ {expr} }}}}"
+        rendered = resolve_jinja_template(jinja_expr, variables=current_values)
+        return coerce_bool(rendered)
+    if executor is None:
+        raise ValueError(
+            f"{context} query '{expr.query}' requires an executor but none was provided"
+        )
+    rows = executor.execute_query(expr.query, current_values)
+    if not rows:
+        raise ValueError(
+            f"{context} query '{expr.query}' returned no rows; expected exactly 1"
+        )
+    if len(rows) > 1:
+        raise ValueError(
+            f"{context} query '{expr.query}' returned {len(rows)} rows; expected exactly 1"
+        )
+    row = rows[0]
+    if expr.column not in row:
+        raise ValueError(
+            f"{context} query '{expr.query}' has no column '{expr.column}'; "
+            f"available: {list(row.keys())}"
+        )
+    return coerce_bool(row[expr.column])
+
+
+def evaluate_visible(
+    expr: bool | str | SingleRowBoolProbe | None,
+    current_values: dict[str, Any],
+    executor: ChartDataProvider | None,
+    context: str = "layout item",
+) -> bool:
+    """Return True when the layout item should be rendered.
+
+    Args:
+        expr: The visible value from the layout item.
+        current_values: Current variable values for Jinja resolution.
+        executor: Required when expr is a SingleRowBoolProbe.
+        context: Human-readable label for error messages (e.g. "layout item 'kpi_a'").
+    """
+    return eval_bool_condition(
+        expr,
+        True,
+        current_values,
+        executor,
+        f"{context} visible",
+    )