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

dataface/core/compile/models/style/resolved/_cascade.py

@@ -11,7 +11,7 @@ Public surface:
   resolve_mark()            — merge global + family-level mark defaults
   insert_emoji_family()     — insert emoji font into a CSS font-family stack
   apply_emoji_to_family()   — conditionally insert emoji font by mode
-  build_resolved_axis()     — build a ResolvedAxisStyle from an AxisStyle
+  build_resolved_axis()     — build a ResolvedAxisStyle from a BaseAxisStyle
   clear_resolve_style_cache() — evict the no-patch cache after config reloads
 
 Private helpers are prefixed with _ and not intended for callers outside
@@ -34,13 +34,18 @@ from dataface.core.compile.models.primitives import FontStyle, ResolvedFontStyle
 from dataface.core.compile.models.style.authored import PaginationConfig
 from dataface.core.compile.models.style.theme import (
     AxisLabelOverlapConfig,
-    AxisStyle,
+    AxisXStyle,
+    AxisYStyle,
+    BaseScaleStyle,
     CalloutChartStyle,
     ChartsStyle,
+    DimensionLabelStyle,
+    DimensionTicksStyle,
     LegendStyle,
     SparkStyle,
     Style,
     TitleStyle,
+    XScaleStyle,
     font_weight_as_css,
 )
 from dataface.core.compile.vega_lite.mapping import effective_vega_config
@@ -49,16 +54,21 @@ from dataface.core.compile.vega_lite.mapping import effective_vega_config
 from dataface.core.fonts import NOTO_COLOR_EMOJI_FONT_FAMILY, NOTO_EMOJI_FONT_FAMILY
 
 from ._base import (
-    ResolvedAxisDomainStyle,
     ResolvedAxisElementStyle,
     ResolvedAxisGridStyle,
     ResolvedAxisGridZeroStyle,
     ResolvedAxisLabelOverlapConfig,
+    ResolvedAxisLineStyle,
     ResolvedAxisStyle,
     ResolvedAxisTicksStyle,
     ResolvedChartsStyle,
     ResolvedLegendElementStyle,
     ResolvedLegendStyle,
+    ResolvedScaleContinuousStyle,
+    ResolvedScaleLogStyle,
+    ResolvedScalePowStyle,
+    ResolvedScaleStyle,
+    ResolvedScaleSymlogStyle,
     ResolvedStyle,
 )
 from .callout import ResolvedCalloutElementStyle, ResolvedCalloutStyle
@@ -440,30 +450,36 @@ def _seed_spark_colors(style: Style) -> Style:
     return style.model_copy(update={"charts": new_charts})
 
 
-# Fields on AxisElementStyle that are optional VL passthroughs:
-# inherited from parent axis to child (axis_x/y/etc.) via the InheritGraph,
-# then carried through build_resolved_axis to ResolvedAxisElementStyle.
+# Fields on AxisLabelStyle (base) that are optional VL passthroughs.
 # "overlap" is handled explicitly (AxisLabelOverlapConfig → ResolvedAxisLabelOverlapConfig).
 # "align" is handled explicitly too (_resolve_own_side_align) — its authored
 # type carries inward/outward, which must be mapped against the axis's final
 # edge before it can land on the narrower resolved Literal["left","right"].
-_ELEM_PASSTHROUGH = (
+_LABEL_PASSTHROUGH = (
     "max_width",
     "angle",
-    "baseline",
-    "separation",
+    "min_gap",
     "visible",
-    "time_unit",
     "expr",
     "bound",
     "flush",
     "offset",
-    "line_height",
-    "anchor",
+    "format",
+)
+
+# Additional passthrough fields only on DimensionLabelStyle (AxisXStyle.labels).
+# Absent from AxisLabelStyle (used by AxisYStyle.labels and axis_quantitative/band).
+_ELEM_X_LABEL_PASSTHROUGH = (
+    "time_unit",
     "tilt_increments",
     "values",
 )
 
+# AxisTitleStyle is deliberately thin (font/padding/angle/align/visible only)
+# — a title is one short static string, not a per-tick label stream, so it
+# has none of the label-overlap/VL-passthrough machinery above.
+_TITLE_PASSTHROUGH = ("padding", "angle", "visible")
+
 
 def _resolve_own_side_align(
     align: Literal["left", "right", "center", "inward", "outward"] | None,
@@ -503,24 +519,77 @@ def _resolve_overlap_config(
         return None
     if overlap.tilt is None or overlap.skip is None:
         raise ValueError(
-            f"axis.label.overlap has None fields after cascade: {overlap!r}; "
+            f"axis.labels.overlap has None fields after cascade: {overlap!r}; "
             "theme must supply both bools (tilt, skip) via _base.yaml"
         )
     return ResolvedAxisLabelOverlapConfig(tilt=overlap.tilt, skip=overlap.skip)
 
 
+def build_resolved_scale(
+    scale: BaseScaleStyle | XScaleStyle | None,
+) -> ResolvedScaleStyle | None:
+    """Convert authored BaseScaleStyle/XScaleStyle to ResolvedScaleStyle.
+
+    Returns None when no scale was authored (axis or chart has no scale override).
+    continuous is None when not authored. x_reverse is populated only from
+    XScaleStyle; None on all other inputs.
+    """
+    if scale is None:
+        return None
+    return ResolvedScaleStyle(
+        round=scale.round,
+        clamp=scale.clamp,
+        nice=scale.nice,
+        padding=scale.padding,
+        headroom=scale.headroom,
+        values=scale.values,
+        continuous=(
+            ResolvedScaleContinuousStyle(
+                zero=scale.continuous.zero,
+                type=scale.continuous.type,
+                domain=scale.continuous.domain,
+                domain_strategy=scale.continuous.domain_strategy,
+                log=(
+                    ResolvedScaleLogStyle(base=scale.continuous.log.base)
+                    if scale.continuous.log is not None
+                    else None
+                ),
+                pow=(
+                    ResolvedScalePowStyle(exponent=scale.continuous.pow.exponent)
+                    if scale.continuous.pow is not None
+                    else None
+                ),
+                symlog=(
+                    ResolvedScaleSymlogStyle(constant=scale.continuous.symlog.constant)
+                    if scale.continuous.symlog is not None
+                    else None
+                ),
+            )
+            if scale.continuous is not None
+            else None
+        ),
+        x_reverse=scale.x_reverse if isinstance(scale, XScaleStyle) else None,
+    )
+
+
 def build_resolved_axis(
-    axis: AxisStyle,
+    axis: AxisXStyle | AxisYStyle,
     *,
+    band_position: float | None = None,
     edge: Literal["left", "right"] | None = None,
     tick_values: tuple[float, ...] = (),
     domain_max: float | EllipsisType = ...,
     domain_min: float | EllipsisType = ...,
 ) -> ResolvedAxisStyle:
-    """Build the frozen, render-ready ResolvedAxisStyle from a merged AxisStyle.
+    """Build ResolvedAxisStyle from a channel-typed AxisXStyle or AxisYStyle.
+
+    Accepts AxisXStyle or AxisYStyle (after resolved_axis_style's merge chain).
+    band_position is passed explicitly since BandAxisStyle is structurally absent
+    from AxisXStyle/AxisYStyle — the caller extracts it from BandAxisStylePatch.
 
-    ``edge`` is the axis's final left/right placement (None for a bottom/top
-    axis). It resolves ``label.align``/
+    ``edge`` is the axis's final left/right placement, when known (None for a
+    bottom/top axis, or when the caller hasn't determined the edge yet — see
+    ``resolved_axis_style``'s docstring). It resolves ``labels.align``/
     ``title.align``'s inward/outward directives to concrete left/right (or
     None) via ``_resolve_own_side_align`` — the only place that mapping
     happens, so the render layer only ever sees left/right/None.
@@ -533,6 +602,26 @@ def build_resolved_axis(
             )
         return value
 
+    # grid.zero only exists on y-axis (AxisYStyle.grid is MeasureGridStyle, not BaseAxisGridStyle).
+    if isinstance(axis, AxisYStyle):
+        grid_zero: ResolvedAxisGridZeroStyle | None = (
+            ResolvedAxisGridZeroStyle(
+                color=_require(axis.grid.zero.color, "charts.axis_y.grid.zero.color"),
+                width=_require(axis.grid.zero.width, "charts.axis_y.grid.zero.width"),
+            )
+            if axis.grid.zero is not None
+            else None
+        )
+    else:
+        grid_zero = None
+
+    # label passthrough: x-axis adds tilt_increments/values/time_unit from DimensionLabelStyle.
+    label_kwargs = {f: getattr(axis.labels, f) for f in _LABEL_PASSTHROUGH}
+    if isinstance(axis.labels, DimensionLabelStyle):
+        label_kwargs.update(
+            {f: getattr(axis.labels, f) for f in _ELEM_X_LABEL_PASSTHROUGH}
+        )
+
     return ResolvedAxisStyle(
         grid=ResolvedAxisGridStyle(
             visible=_require(axis.grid.visible, "charts.axis.grid.visible"),
@@ -540,57 +629,52 @@ def build_resolved_axis(
             width=_require(axis.grid.width, "charts.axis.grid.width"),
             color=_require(axis.grid.color, "charts.axis.grid.color"),
             dash=axis.grid.dash,
-            zero=ResolvedAxisGridZeroStyle(
-                color=_require(
-                    axis.grid.zero.color if axis.grid.zero else None,
-                    "charts.axis.grid.zero.color",
-                ),
-                width=_require(
-                    axis.grid.zero.width if axis.grid.zero else None,
-                    "charts.axis.grid.zero.width",
-                ),
-            ),
+            zero=grid_zero,
         ),
-        domain=ResolvedAxisDomainStyle(
-            visible=_require(axis.domain.visible, "charts.axis.domain.visible"),
-            width=_require(axis.domain.width, "charts.axis.domain.width"),
-            color=_require(axis.domain.color, "charts.axis.domain.color"),
+        line=ResolvedAxisLineStyle(
+            visible=_require(axis.line.visible, "charts.axis.line.visible"),
+            width=_require(axis.line.width, "charts.axis.line.width"),
+            color=_require(axis.line.color, "charts.axis.line.color"),
         ),
         ticks=ResolvedAxisTicksStyle(
             visible=_require(axis.ticks.visible, "charts.axis.ticks.visible"),
             color=_require(axis.ticks.color, "charts.axis.ticks.color"),
             width=axis.ticks.width,
-            size=axis.ticks.size,
+            length=axis.ticks.length,
+            offset=axis.ticks.offset,
             count=axis.ticks.count,
-            interval=axis.ticks.interval,
             step=axis.ticks.step,
+            time_unit=(
+                axis.ticks.time_unit
+                if isinstance(axis.ticks, DimensionTicksStyle)
+                else None
+            ),
         ),
-        label=ResolvedAxisElementStyle(
-            font=resolve_cascaded_font(axis.label.font, "charts.axis.label.font"),
-            padding=_require(axis.label.padding, "charts.axis.label.padding"),
-            align=_resolve_own_side_align(axis.label.align, edge),
-            overlap=_resolve_overlap_config(axis.label.overlap),
-            **{f: getattr(axis.label, f) for f in _ELEM_PASSTHROUGH},
+        labels=ResolvedAxisElementStyle(
+            font=resolve_cascaded_font(axis.labels.font, "charts.axis.labels.font"),
+            padding=_require(axis.labels.padding, "charts.axis.labels.padding"),
+            align=_resolve_own_side_align(axis.labels.align, edge),
+            overlap=_resolve_overlap_config(axis.labels.overlap),
+            **label_kwargs,
         ),
         title=ResolvedAxisElementStyle(
             font=resolve_cascaded_font(axis.title.font, "charts.axis.title.font"),
-            padding=_require(axis.title.padding, "charts.axis.title.padding"),
             align=_resolve_own_side_align(axis.title.align, edge),
-            overlap=_resolve_overlap_config(axis.title.overlap),
-            **{f: getattr(axis.title, f) for f in _ELEM_PASSTHROUGH},
+            **{f: getattr(axis.title, f) for f in _TITLE_PASSTHROUGH},
         ),
         position=axis.position,
-        categorical_orient=axis.categorical_orient,
-        mirror=axis.mirror,
-        band_position=axis.band_position,
-        offset=axis.offset,
-        scale=axis.scale,
-        fill=axis.fill,
-        format=axis.format,
-        values=axis.values,
-        time_unit=axis.time_unit,
-        type=axis.type,
-        fiscal_year_start_month=axis.fiscal_year_start_month,
+        mirror=axis.mirror if isinstance(axis, AxisYStyle) else None,
+        band_position=band_position,
+        scale=build_resolved_scale(axis.scale),
+        fill=axis.fill if isinstance(axis, AxisXStyle) else None,
+        time_unit=axis.time_unit if isinstance(axis, AxisXStyle) else None,
+        type=axis.type if isinstance(axis, AxisXStyle) else None,
+        # fiscal_year_start_month is x-only (year/yearquarter bucket
+        # anchoring); non-x axes get the neutral calendar-convention default
+        # (1 = January) since the resolved field stays a required int.
+        fiscal_year_start_month=(
+            axis.fiscal_year_start_month if isinstance(axis, AxisXStyle) else 1
+        ),
         tick_values=tick_values,
         domain_max=None if domain_max is ... else domain_max,
         domain_min=None if domain_min is ... else domain_min,
@@ -731,7 +815,10 @@ def _build_resolved_charts(
         single_series_palette=resolved_single_series_palette,
         requested_alias_palette=_categorical_obj.requested_alias_palette,
         dashes=charts.dashes if charts.dashes is not None else [],
-        axis=build_resolved_axis(charts.axis),
+        # axis is a raw BaseAxisStyle passthrough — no eager resolution here.
+        # resolved_axis_style() in style_cascade.py merges it with channel-typed
+        # axis_x/axis_y at emit time, seeding channel-specific fields from the typed value.
+        axis=charts.axis,
         axis_x=charts.axis_x,
         axis_y=charts.axis_y,
         axis_quantitative=charts.axis_quantitative,

dataface/core/compile/models/style/resolved/area.py

@@ -14,7 +14,7 @@ class ResolvedAreaStyle(_SeriesCartesianResolvedStyle):
     """Area family style slice — self-contained, globals merged down.
 
     Every field is concrete after resolve; the area emitter reads only these.
-    Inherits axis_x, axis_y, tooltip_format, background, series_label,
+    Inherits axis_x, axis_y, tooltip_format, series_label,
     endpoint_labels, single_series_fill, label_usable_ratio
     from the cartesian base hierarchy.
     """

dataface/core/compile/models/style/resolved/bar.py

@@ -16,7 +16,7 @@ class ResolvedBarStyle(_SeriesCartesianResolvedStyle):
     """Bar family style slice — self-contained, globals merged down.
 
     Every field is concrete after resolve; the bar emitter reads only these.
-    Inherits axis_x, axis_y, tooltip_format, background, series_label,
+    Inherits axis_x, axis_y, tooltip_format, series_label,
     endpoint_labels, single_series_fill, label_usable_ratio
     from the cartesian base hierarchy.
     """

dataface/core/compile/models/style/resolved/line.py

@@ -14,7 +14,7 @@ class ResolvedLineStyle(_SeriesCartesianResolvedStyle):
     """Line family style slice — self-contained, globals merged down.
 
     Every field is concrete after resolve; the line emitter reads only these.
-    Inherits axis_x, axis_y, tooltip_format, background, series_label,
+    Inherits axis_x, axis_y, tooltip_format, series_label,
     endpoint_labels, single_series_fill, label_usable_ratio
     from the cartesian base hierarchy.
     """

dataface/core/compile/models/style/resolved/scatter.py

@@ -4,7 +4,8 @@ from __future__ import annotations
 
 from pydantic import ConfigDict, Field
 
-from dataface.core.compile.models.style.theme import PointMarkStyle, ScaleStyle
+from dataface.core.compile.models.style.resolved._base import ResolvedScaleStyle
+from dataface.core.compile.models.style.theme import PointMarkStyle
 
 from ._cartesian import _CartesianResolvedStyle
 
@@ -23,7 +24,7 @@ class ResolvedScatterStyle(_CartesianResolvedStyle):
     single_series_fill: str = Field(
         description="Fill color for single-series points (ink palette slot 0)."
     )
-    scale: ScaleStyle | None = Field(
+    scale: ResolvedScaleStyle | None = Field(
         default=None,
         description="Board-level chart scale override; None = no override.",
     )

dataface/core/compile/models/style/theme/__init__.py

@@ -49,22 +49,33 @@ from dataface.core.compile.models.style.theme.area import (
     AreaLineStyle,
 )
 from dataface.core.compile.models.style.theme.axis import (
-    AxisDomainStyle,
-    AxisElementStyle,
-    AxisGridStyle,
     AxisGridZeroStyle,
     AxisLabelOverlapConfig,
+    AxisLabelStyle,
+    AxisLineStyle,
     AxisMirrorStyle,
-    AxisStyle,
-    AxisTicksCadenceValidationMixin,
     AxisTicksStyle,
-    ScaleBandStyle,
+    AxisTitleStyle,
+    AxisXStyle,
+    AxisYStyle,
+    BandAxisStyle,
+    BaseAxisGridStyle,
+    BaseAxisStyle,
+    BaseScaleStyle,
+    DimensionLabelStyle,
+    DimensionTicksStyle,
+    MeasureGridStyle,
+    QuantitativeAxisStyle,
+    ScaleContinuousStyle,
     ScaleDomainValidationMixin,
-    ScaleStyle,
+    ScaleLogStyle,
+    ScalePowStyle,
+    ScaleSymlogStyle,
     TooltipBorderStyle,
     TooltipShadowStyle,
     TooltipSlotStyle,
     TooltipStyle,
+    XScaleStyle,
 )
 from dataface.core.compile.models.style.theme.bar import (
     BarChartMarksStyle,
@@ -243,15 +254,28 @@ __all__ = [
     "AreaLayerStyle",
     "AreaLineStyle",
     "AreaMarkStyle",
-    "AxisDomainStyle",
-    "AxisElementStyle",
-    "AxisGridStyle",
     "AxisGridZeroStyle",
     "AxisLabelOverlapConfig",
+    "AxisLabelStyle",
+    "AxisLineStyle",
     "AxisMirrorStyle",
-    "AxisStyle",
-    "AxisTicksCadenceValidationMixin",
     "AxisTicksStyle",
+    "AxisTitleStyle",
+    "AxisXStyle",
+    "AxisYStyle",
+    "BandAxisStyle",
+    "BaseAxisGridStyle",
+    "BaseAxisStyle",
+    "BaseScaleStyle",
+    "DimensionLabelStyle",
+    "DimensionTicksStyle",
+    "MeasureGridStyle",
+    "QuantitativeAxisStyle",
+    "ScaleContinuousStyle",
+    "ScaleLogStyle",
+    "ScalePowStyle",
+    "ScaleSymlogStyle",
+    "XScaleStyle",
     "BarChartMarksStyle",
     "BarChartStyle",
     "BarLayerStyle",
@@ -321,9 +345,7 @@ __all__ = [
     "RectMarkStyle",
     "RootFontStyle",
     "RuleMarkStyle",
-    "ScaleBandStyle",
     "ScaleDomainValidationMixin",
-    "ScaleStyle",
     "ScatterChartMarksStyle",
     "ScatterChartStyle",
     "ScatterLayerStyle",

dataface/core/compile/models/style/theme/_chart_base.py

@@ -10,8 +10,12 @@ if TYPE_CHECKING:
     # finishes executing). The import here is TYPE_CHECKING-only to give mypy and
     # ruff the static definitions they need without creating a circular import.
     from dataface.core.compile.models.style.authored import (  # noqa: PLC0415
-        AxisStylePatch,
+        AxisXStylePatch,
+        AxisYStylePatch,
+        BandAxisStylePatch,
+        BaseAxisStylePatch,
         DataTableStylePatch,
+        QuantitativeAxisStylePatch,
         TooltipStylePatch,
     )
 
@@ -32,7 +36,7 @@ from dataface.core.compile.models.primitives import (
     StaticGradientColorStyle,
 )
 from dataface.core.compile.models.style.theme.axis import (
-    ScaleStyle,
+    BaseScaleStyle,
     TooltipStyle,
 )
 from dataface.core.compile.models.style.theme.board import (
@@ -148,28 +152,30 @@ class _CartesianChartStyle(_ChartStyleBaseAllOptional):
     # inherits the global axis at render time via resolved_axis_style's merge over
     # the fully-resolved base axis. Without this, apply_inherit slot-fills these
     # patches from the generic charts.font (prose ink) — so merely authoring an
-    # unrelated field like bar.axis_x.label.padding materializes label.font and
+    # unrelated field like bar.axis_x.labels.padding materializes labels.font and
     # drags prose ink into the label color, overriding the theme's muted axis
     # color at the merge. Mirrors the `title` sentinel above (chart-local title
     # is likewise a skip-slots sparse patch). The axis element font/color/family
     # cascade is owned by the global axis nodes, not the per-family override.
-    axis: Annotated[AxisStylePatch | None, SkipInheritSlots()] = Field(
+    axis: Annotated[BaseAxisStylePatch | None, SkipInheritSlots()] = Field(
         default=None,
         description="Override applied to both x and y axes; None inherits the global axis at render.",
     )
-    axis_x: Annotated[AxisStylePatch | None, SkipInheritSlots()] = Field(
+    axis_x: Annotated[AxisXStylePatch | None, SkipInheritSlots()] = Field(
         default=None,
         description="Per-chart-type x-axis style overrides; None inherits the global axis_x at render.",
     )
-    axis_y: Annotated[AxisStylePatch | None, SkipInheritSlots()] = Field(
+    axis_y: Annotated[AxisYStylePatch | None, SkipInheritSlots()] = Field(
         default=None,
         description="Per-chart-type y-axis style overrides; None inherits the global axis_y at render.",
     )
-    axis_quantitative: Annotated[AxisStylePatch | None, SkipInheritSlots()] = Field(
+    axis_quantitative: Annotated[
+        QuantitativeAxisStylePatch | None, SkipInheritSlots()
+    ] = Field(
         default=None,
         description="Per-chart-type quantitative-axis overrides; None inherits the global axis_quantitative at render.",
     )
-    axis_band: Annotated[AxisStylePatch | None, SkipInheritSlots()] = Field(
+    axis_band: Annotated[BandAxisStylePatch | None, SkipInheritSlots()] = Field(
         default=None,
         description="Per-chart-type categorical (band) axis overrides; None inherits the global band axis at render.",
     )
@@ -181,7 +187,9 @@ class _CartesianChartStyle(_ChartStyleBaseAllOptional):
         default=None,
         description="Default time format for temporal axes (D3 time format string); None inherits from theme.",
     )
-    scale: ScaleStyle | None = Field(
+    # BaseScaleStyle (not XScaleStyle): this slot merges onto both x and y axes,
+    # so it must not carry x_reverse (which is structurally absent on BaseScaleStyle).
+    scale: BaseScaleStyle | None = Field(
         default=None,
         description="Chart-type encoding scale overrides applied to both x and y; None means no override.",
     )