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

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

@@ -28,8 +28,12 @@ from dataface.core.compile.models.primitives import (
     SpacingValues,
 )
 from dataface.core.compile.models.style.authored import (
-    AxisStylePatch,
+    AxisXStylePatch,
+    AxisYStylePatch,
+    BandAxisStylePatch,
+    BaseAxisStylePatch,
     PaginationConfig,
+    QuantitativeAxisStylePatch,
 )
 from dataface.core.compile.models.style.resolved.callout import (
     ResolvedCalloutElementStyle,
@@ -38,8 +42,10 @@ from dataface.core.compile.models.style.resolved.callout import (
 from dataface.core.compile.models.style.theme import (
     AreaChartStyle,
     AxisMirrorStyle,
-    AxisStyle,
+    AxisXStyle,
+    AxisYStyle,
     BarChartStyle,
+    BaseAxisStyle,
     BoardStyle,
     DataTableStyle,
     FooterStyle,
@@ -57,7 +63,7 @@ from dataface.core.compile.models.style.theme import (
     PieChartStyle,
     PlaceholderStyle,
     PointMapChartStyle,
-    ScaleStyle,
+    QuantitativeAxisStyle,
     ScatterChartStyle,
     SeriesLabelStyle,
     SparkBarChartStyle,
@@ -76,6 +82,72 @@ from dataface.core.compile.models.style.theme import (
 _VLConfig = dict[str, Any]
 
 
+# ── Resolved scale classes ────────────────────────────────────────────────────
+# Pydantic BaseModels (not dataclasses) — keeps map_fields(scale, FIELD_MAP)
+# working and .model_copy() working at resolve call sites in _resolve.py.
+
+
+class ResolvedScaleLogStyle(BaseModel):
+    """Resolved log-scale param."""
+
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+    base: float | None = None
+
+
+class ResolvedScalePowStyle(BaseModel):
+    """Resolved power-scale param."""
+
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+    exponent: float | None = None
+
+
+class ResolvedScaleSymlogStyle(BaseModel):
+    """Resolved symlog-scale param."""
+
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+    constant: float | None = None
+
+
+class ResolvedScaleContinuousStyle(BaseModel):
+    """Resolved continuous-scale config."""
+
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+    zero: bool | Literal["auto"] | None = None
+    type: Literal["linear", "log", "pow", "sqrt", "symlog", "temporal"] | None = None
+    domain: list[Any] | None = None
+    domain_strategy: Literal["stable", "auto"] | None = None
+    log: ResolvedScaleLogStyle | None = None
+    pow: ResolvedScalePowStyle | None = None
+    symlog: ResolvedScaleSymlogStyle | None = None
+
+
+class ResolvedScaleStyle(BaseModel):
+    """Resolved scale config — universal + continuous-only superset.
+
+    Populated by build_resolved_scale() in _cascade.py. Render consumers read
+    grouped paths (e.g. .scale.continuous.zero, .scale.continuous.log.base)
+    not flat paths. x_reverse is populated only when resolving an x-channel scale.
+    band/point/quantize/mark_size were deleted (2026-08 trim) along with the
+    authoring surface for them.
+    """
+
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+    round: bool | None = None
+    clamp: bool | None = None
+    nice: bool | None = None
+    padding: float | None = None
+    headroom: float | None = None
+    values: list[Any] | None = None
+    continuous: ResolvedScaleContinuousStyle | None = None
+    # Populated only when resolving an x-channel scale (XScaleStyle source).
+    x_reverse: bool | None = None
+
+
 @dataclasses.dataclass(frozen=True)
 class ResolvedAxisLabelOverlapConfig:
     """Resolved axis label overlap strategy enablement — all fields required.
@@ -91,19 +163,25 @@ class ResolvedAxisLabelOverlapConfig:
 
 @dataclasses.dataclass(frozen=True)
 class ResolvedAxisElementStyle:
-    """Resolved axis label or title — all fields required, no defaults.
+    """Resolved axis label or title — one shared superset dataclass.
 
-    Chart-local Patch fields (label.angle, label.padding, etc.) flow through
+    Chart-local Patch fields (labels.angle, labels.padding, etc.) flow through
     the typed ``axis_overrides_*`` sentinels on ``ResolvedChartsStyle`` and
     are merged at emit time by ``resolved_axis_style``. They never land on a
     Resolved axis directly.
+
+    Title's source type (``AxisTitleStyle``) only has font/angle/align/visible
+    — its resolved instance leaves every other field at its default (usually
+    None), same as how x-only/y-only fields already work on ``ResolvedAxisStyle``
+    itself. ``padding`` is optional (not required) for exactly this reason:
+    title has no padding concept post-trim.
     """
 
     font: ResolvedFontStyle
-    padding: float
+    padding: float | None = None
     # Optional VL-passthrough fields — carried from theme through resolve boundary.
     # None means "use VL default"; build_resolved_axis carries them through to
-    # the VL emit layer. Mirrors AxisElementStyle passthrough fields.
+    # the VL emit layer. Mirrors AxisLabelStyle passthrough fields.
     max_width: float | None = None
     angle: float | None = None
     # Narrower than the authored Literal["left","right","center","inward",
@@ -114,19 +192,17 @@ class ResolvedAxisElementStyle:
     # before #5845 (center still needs its own away-from-plot fallback on a
     # left/right axis — see bar.py / vl_field_maps.py).
     align: Literal["left", "right", "center"] | None = None
-    baseline: str | None = None
     # Resolved overlap strategy enablement. None = cascade did not populate
     # (resolver skips). Three required bools after cascade from _base.yaml.
     overlap: ResolvedAxisLabelOverlapConfig | None = None
-    separation: float | None = None
+    min_gap: float | None = None  # renamed from `separation`, same meaning
     visible: bool | None = None  # None = cascade-inherit from parent axis slot
     time_unit: str | None = None
     expr: str | None = None
     bound: bool | float | None = None
     flush: bool | float | None = None
     offset: float | None = None
-    line_height: float | None = None
-    anchor: str | None = None
+    format: str | None = None  # tick-label format string; None uses VL auto-format
     tilt_increments: list[float] | None = None
     # Sparse label-only cadence override — None labels every tick per
     # the usual smart cadence/format; a list blanks every tick not in it.
@@ -148,11 +224,13 @@ class ResolvedAxisGridStyle:
     width: float
     color: str
     dash: list[float] | None  # None → solid line (VL default)
-    zero: ResolvedAxisGridZeroStyle
+    # None on non-measure axes (axis_x, axis_quantitative, axis_band):
+    # zero-baseline gridline only makes sense on the measure (y) axis.
+    zero: ResolvedAxisGridZeroStyle | None
 
 
 @dataclasses.dataclass(frozen=True)
-class ResolvedAxisDomainStyle:
+class ResolvedAxisLineStyle:
     visible: bool
     width: float
     color: str
@@ -164,16 +242,18 @@ class ResolvedAxisTicksStyle:
     color: str
     # None means "use VL default" — kept distinct from a numeric override.
     width: float | None
-    size: float | None
+    length: float | None
+    offset: float | None
     # Target tick count. Quantitative: baked into explicit tick_values at
     # resolve(). Temporal axis_x: passed through as VL axis.tickCount at emit.
     # None → VL picks automatically.
     count: int | None
-    # Step-anchored cadence unit/multiple. Continuous temporal axis_x only;
+    step: int | None
+    # Step-anchored cadence unit. Continuous temporal axis_x only (populated
+    # only when the source is DimensionTicksStyle — see build_resolved_axis);
     # passed through as VL axis.tickCount: {interval, step} at emit. None →
     # no cadence override (falls back to count, then VL's own default).
-    interval: Literal["year", "quarter", "month"] | None
-    step: int | None
+    time_unit: str | None = None
 
 
 @dataclasses.dataclass(frozen=True)
@@ -187,29 +267,31 @@ class ResolvedAxisStyle:
     """
 
     grid: ResolvedAxisGridStyle
-    domain: ResolvedAxisDomainStyle
+    line: ResolvedAxisLineStyle
     ticks: ResolvedAxisTicksStyle
-    label: ResolvedAxisElementStyle
+    labels: ResolvedAxisElementStyle
     title: ResolvedAxisElementStyle
     position: str | None  # None is a valid concrete value ("use VL default")
-    categorical_orient: str | None
     # y-axis only: draw the y-scale on both edges. An AxisMirrorStyle object
     # additionally relabels the mirrored edge (format/expr); see AxisMirrorStyle.
     mirror: bool | AxisMirrorStyle | None
     band_position: float | None
-    offset: float | None
-    scale: ScaleStyle | None  # per-axis scale override (board cascade only)
-    fill: Literal[
-        "null",
-        "zero",
-        "linear",
-        "step-after",
-        "step-before",
-        "step-center",
-        "curve",
-    ]  # only active on axis_x ordinal bucketed-time charts
-    format: str | None  # tick-label format string; None uses VL auto-format
-    values: list[Any] | None  # explicit tick values; None uses VL auto
+    scale: ResolvedScaleStyle | None  # per-axis scale override (board cascade only)
+    # None on non-dimension axes (axis_y, axis_quantitative, axis_band):
+    # fill only exists on axis_x (AxisXStyle.fill). Theme supplies the x default;
+    # the resolver carries it through to the emitter; non-x axes get None here.
+    fill: (
+        Literal[
+            "null",
+            "zero",
+            "linear",
+            "step-after",
+            "step-before",
+            "step-center",
+            "curve",
+        ]
+        | None
+    )
     time_unit: str | None  # time-unit bucketing for temporal x-axes
     type: Literal["auto", "ordinal", "temporal"] | None  # scale type for bucketed-time
     # Fiscal-year-start month (1=Jan..12=Dec) for year/yearquarter bucket
@@ -303,18 +385,17 @@ class ResolvedChartsStyle:
     default_chart_height: float
     default_table_height: float
     label_usable_ratio: float
-    # Theme axis layers. `axis` is Layer 1+2's required-complete base (every
-    # leaf filled by apply_inherit from non-axis theme fields). `axis_x`/
-    # `axis_y`/`axis_quantitative` are authored-only overlays — sparse by
-    # design (SkipInheritSlots means apply_inherit never fills their None
-    # leaves from `axis`). resolved_axis_style() merges them onto `axis` in
-    # the canonical cascade order at emit time; build_resolved_style does NOT
-    # pre-merge chart-local axis Patches into these — those live on
-    # axis_overrides_* below.
-    axis: ResolvedAxisStyle
-    axis_x: AxisStyle
-    axis_y: AxisStyle
-    axis_quantitative: AxisStyle
+    # Theme axis layers.
+    # `axis` is Layer 1's channel-agnostic base (BaseAxisStyle — raw passthrough,
+    # not eagerly resolved). `axis_x`/`axis_y`/`axis_quantitative` are
+    # authored-only overlays — sparse by design (SkipInheritSlots means
+    # apply_inherit never fills their None leaves from `axis`).
+    # resolved_axis_style() merges them onto a starting AxisXStyle/AxisYStyle
+    # in the canonical cascade order at emit time.
+    axis: BaseAxisStyle
+    axis_x: AxisXStyle
+    axis_y: AxisYStyle
+    axis_quantitative: QuantitativeAxisStyle
     legend: ResolvedLegendStyle
     # Global mark defaults (tier 1 of the three-tier cascade).
     # apply_inherit pre-applies these into every per-family marks container
@@ -360,19 +441,18 @@ class ResolvedChartsStyle:
     # resolve_format() so aliases resolve through the face→theme cascade.
     formats: dict[str, str] | None = None
 
-    # Chart-local axis overrides (Layers 4/5/6) as typed AxisStylePatch
-    # sentinels — populated only by build_resolved_style from the chart's
-    # ChartStylePatch. None = no chart-local override on that axis variant.
-    # These are NOT exposed to chart emit code directly; resolved_axis_style is
-    # the single canonical reader, returning a fully-merged AxisStyle.
-    axis_overrides_global: AxisStylePatch | None = None
-    axis_overrides_x: AxisStylePatch | None = None
-    axis_overrides_y: AxisStylePatch | None = None
-    axis_overrides_quantitative: AxisStylePatch | None = None
-    axis_overrides_band: AxisStylePatch | None = None
+    # Chart-local axis overrides (Layers 4/5/6) as typed patches — populated
+    # only by build_resolved_style from the chart's ChartStylePatch. None = no
+    # chart-local override on that axis variant. These are NOT exposed to chart
+    # emit code directly; resolved_axis_style is the single canonical reader.
+    axis_overrides_global: BaseAxisStylePatch | None = None
+    axis_overrides_x: AxisXStylePatch | None = None
+    axis_overrides_y: AxisYStylePatch | None = None
+    axis_overrides_quantitative: QuantitativeAxisStylePatch | None = None
+    axis_overrides_band: BandAxisStylePatch | None = None
     # Chart-level scale override — populated only by build_resolved_style from
     # style.scale. None = no chart-local global scale override.
-    scale: ScaleStyle | None = None
+    scale: ResolvedScaleStyle | None = None
     # Chart-local-only Vega passthrough — populated by build_resolved_style
     # from style.color. None = no chart-local color override.
     color: str | None = None
@@ -445,10 +525,10 @@ def effective_padding(resolved: ResolvedStyle) -> SpacingValues:
 
 
 __all__ = [
-    "ResolvedAxisDomainStyle",
     "ResolvedAxisElementStyle",
     "ResolvedAxisGridStyle",
     "ResolvedAxisGridZeroStyle",
+    "ResolvedAxisLineStyle",
     "ResolvedAxisStyle",
     "ResolvedAxisTicksStyle",
     "ResolvedCalloutElementStyle",
@@ -456,6 +536,11 @@ __all__ = [
     "ResolvedChartsStyle",
     "ResolvedLegendElementStyle",
     "ResolvedLegendStyle",
+    "ResolvedScaleContinuousStyle",
+    "ResolvedScaleLogStyle",
+    "ResolvedScalePowStyle",
+    "ResolvedScaleStyle",
+    "ResolvedScaleSymlogStyle",
     "ResolvedStyle",
     "effective_padding",
 ]

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

@@ -11,7 +11,7 @@ _CartesianResolvedStyle
 
 _SeriesCartesianResolvedStyle (_CartesianResolvedStyle)
     bar / line / area — the "standard series" families that share a common
-    series-label contract, endpoint-label feature gate, and the background /
+    series-label contract, endpoint-label feature gate, and the
     fill / ratio / format fields the feature layer reads.
 """
 
@@ -29,10 +29,11 @@ from ._marks import ResolvedSeriesLabelStyle
 class _CartesianResolvedStyle(BaseModel):
     """Shared resolved fields for all cartesian chart families.
 
-    All six cartesian style slices inherit this so axes, tooltip_format, and
-    background are declared once. background is board-level (every chart lives
-    against the same canvas color) even when a particular family's emitter
-    doesn't currently consume it.
+    All six cartesian style slices inherit this so axes and tooltip_format
+    are declared once. The chart's effective canvas color (used by halo
+    strokes, inside-mark value labels, and the VL spec root) lives on the
+    resolved chart envelope (``ResolvedChart.background``), not here — see
+    ``_SharedResolvedChartFields`` in ``compile/models/chart/resolved/_base.py``.
     """
 
     model_config = ConfigDict(frozen=True, extra="forbid")
@@ -46,12 +47,6 @@ class _CartesianResolvedStyle(BaseModel):
     tooltip_format: str = Field(
         description="Resolved d3 tooltip number format ('' = VL default).",
     )
-    background: str = Field(
-        description=(
-            "Board effective background color. Used for halo strokes, "
-            "inside-mark value labels, and any future per-chart overlay."
-        ),
-    )
     title_font: ResolvedFontStyle | None = Field(
         default=None,
         description="Baked title font (size/weight/family/…) from the width tier.",