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

dataface/core/compile/migrations.py

@@ -100,6 +100,58 @@ class MigrationRegistry:
                     )
         return cls(moves, catalog=catalog)
 
+    @classmethod
+    def from_suffix_renames(
+        cls,
+        root_model: type[BaseModel],
+        source_schema: str,
+        target_schema: str,
+        renames: Iterable[tuple[YamlKeyPath, YamlKeyPath]],
+        *,
+        catalog: YamlSchemaCatalog,
+    ) -> MigrationRegistry:
+        """Build a move registry for tail-only path renames, one entry per
+        occurrence a shared style class is reused at.
+
+        ``MovedFrom`` (``from_model``) declares one fixed ``old_path`` per
+        field *declaration*, which is correct only for a field that occurs at
+        a single position in the tree. A cascade style class like
+        ``AxisLabelStyle`` is reused at hundreds of absolute positions (every
+        chart family's ``axis_x``/``axis_y``, every nested face, every theme
+        override) — one literal ``old_path`` cannot describe all of them.
+        ``renames`` instead pairs a *new-path tail* with the corresponding
+        *old-path tail*; this walks every occurrence of the new tail and
+        substitutes the old tail at that same position, keeping the shared
+        prefix. Candidates that don't structurally exist in both frozen
+        schemas (a coincidental tail match on an unrelated field, e.g. a mark
+        family also named ``line``) are silently dropped rather than passed
+        to ``Move`` — that keeps this safe to run over the whole field tree
+        without hand-enumerating every real position.
+        """
+        old_schema = catalog.schema_for(source_schema)
+        new_schema = catalog.schema_for(target_schema)
+        # Walk the field tree once and reuse it for every rename tuple —
+        # re-walking per rename is O(renames * tree_size) and the per-variant
+        # axis/scale models made tree_size large enough for that to matter.
+        paths = [path for path, _field in _walk_fields(root_model)]
+        seen: set[tuple[YamlKeyPath, YamlKeyPath]] = set()
+        moves: list[Move] = []
+        for new_tail, old_tail in renames:
+            width = len(new_tail)
+            for path in paths:
+                if len(path) < width or path[-width:] != new_tail:
+                    continue
+                old_path = path[:-width] + old_tail
+                key = (old_path, path)
+                if key in seen:
+                    continue
+                seen.add(key)
+                if _schema_path_exists(old_schema, old_path) and _schema_path_exists(
+                    new_schema, path
+                ):
+                    moves.append(Move(source_schema, target_schema, old_path, path))
+        return cls(moves, catalog=catalog)
+
     def transition_from(self, identifier: str) -> tuple[Move, ...]:
         if identifier not in self._moves_by_source:
             return ()
@@ -173,6 +225,37 @@ def migrate_face_yaml_text(yaml_text: str) -> str:
     return migrate_yaml_text(yaml_text, catalog=catalog, registry=registry)
 
 
+# 0.3.1 -> 0.3.2: the axis/scale model split (per-variant AxisXStyle/AxisYStyle,
+# BaseScaleStyle.continuous nesting) renamed several theme-cascade fields.
+# Every rename here is a pure tail substitution — same shared prefix, only the
+# trailing segment(s) change — so from_suffix_renames derives every occurrence
+# a rename applies at. Leaf renames that land *inside* the "labels"/"scale"
+# containers run before the "labels"/"line" container renames themselves: a
+# leaf move creates its destination container on demand, and the later
+# container move must find that destination still empty (or absent) to avoid
+# a spurious MigrationConflictError against an unrelated field that also sets
+# the old container. See dataface/AGENTS.md's "Two validation boundaries" —
+# these are structural moves; categorical_orient (deleted), ticks.interval
+# (reinterpreted vocabulary, not renamed), and the band/point/quantize scale
+# groups (deleted) are semantic changes with no lossless move and are left to
+# raise UnsupportedSchemaError for manual migration.
+_AXIS_RESHAPE_RENAMES: tuple[tuple[YamlKeyPath, YamlKeyPath], ...] = (
+    (("labels", "format"), ("format",)),
+    (("scale", "values"), ("values",)),
+    (("scale", "continuous", "domain"), ("scale", "domain")),
+    (("scale", "continuous", "zero"), ("scale", "zero")),
+    (("scale", "continuous", "type"), ("scale", "type")),
+    (("scale", "continuous", "domain_strategy"), ("scale", "domain_strategy")),
+    (("scale", "continuous", "log", "base"), ("scale", "base")),
+    (("scale", "continuous", "pow", "exponent"), ("scale", "exponent")),
+    (("scale", "continuous", "symlog", "constant"), ("scale", "constant")),
+    (("scale", "padding"), ("scale", "band_padding_inner")),
+    (("ticks", "length"), ("ticks", "size")),
+    (("labels",), ("label",)),
+    (("line",), ("domain",)),
+)
+
+
 @cache
 def _face_migration_context() -> tuple[YamlSchemaCatalog, MigrationRegistry]:
     """Load and validate the package's immutable migration metadata once."""
@@ -182,7 +265,17 @@ def _face_migration_context() -> tuple[YamlSchemaCatalog, MigrationRegistry]:
     )
 
     catalog = load_yaml_schema_catalog()
-    registry = MigrationRegistry.from_model(AuthoredFace, catalog=catalog)
+    marker_registry = MigrationRegistry.from_model(AuthoredFace, catalog=catalog)
+    axis_reshape_registry = MigrationRegistry.from_suffix_renames(
+        AuthoredFace,
+        "0.3.1",
+        "0.3.2",
+        _AXIS_RESHAPE_RENAMES,
+        catalog=catalog,
+    )
+    registry = MigrationRegistry(
+        marker_registry.moves + axis_reshape_registry.moves, catalog=catalog
+    )
     return catalog, registry
 
 
@@ -223,14 +316,20 @@ def migrate_mapping(
     while identifier != current:
         moves = registry.transition_from(identifier)
         if not moves:
-            current_errors = _current_schema_rejections(result, catalog)
-            if not current_errors:
-                break
-            raise _unsupported_schema_error(current_errors[0])
+            break
         for move in moves:
             _apply_move(result, move)
         identifier = moves[0].target_schema
 
+    # A transition's declared moves may not cover every field a source schema
+    # allowed (a deleted field has no lossless Move — see MovedFrom's
+    # docstring). Recognizing an older schema and exhausting its transition
+    # chain is not proof the result is current-compatible; check explicitly
+    # rather than trust silently reaching the current identifier.
+    current_errors = _current_schema_rejections(result, catalog)
+    if current_errors:
+        raise _unsupported_schema_error(current_errors[0])
+
     if not allow_expired:
         warnings.warn(
             "Dataface migrated this YAML in memory; run `dft migrate` to update "
@@ -268,10 +367,7 @@ def migrate_yaml_text(
     while identifier != catalog.versions[0]:
         moves = registry.transition_from(identifier)
         if not moves:
-            current_errors = _current_schema_rejections(staged, catalog)
-            if not current_errors:
-                break
-            raise _unsupported_schema_error(current_errors[0])
+            break
         for move in moves:
             for parent, key, bindings in list(_source_locations(staged, move.old_path)):
                 if isinstance(parent, list):
@@ -294,6 +390,13 @@ def migrate_yaml_text(
                 removals.add(".".join(source))
             _apply_move(staged, move)
         identifier = moves[0].target_schema
+
+    # See migrate_mapping's identical check: a transition's declared moves
+    # may not cover every field the source schema allowed.
+    current_errors = _current_schema_rejections(staged, catalog)
+    if current_errors:
+        raise _unsupported_schema_error(current_errors[0])
+
     return set_face_values(
         yaml_text,
         {**updates, **dict.fromkeys(removals)},

dataface/core/compile/models/chart/normalized/kpi.py

@@ -7,7 +7,6 @@ from typing import Any, Literal
 from pydantic import Field
 
 from dataface.core.compile.models.chart.authored import KpiSupportConfig
-from dataface.core.compile.models.primitives import FormatConfig
 from dataface.core.compile.models.style.authored import KpiChartStylePatch
 
 from ._base import _BaseChartFields
@@ -34,9 +33,6 @@ class KpiChart(_BaseChartFields):
         default="stacked",
         description="Layout variant, passed through from authored KpiChart.variant.",
     )
-    format: str | FormatConfig | None = Field(
-        default=None, description="Number format override."
-    )
     background: str | dict[str, Any] | None = Field(
         default=None,
         description=(

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

@@ -29,7 +29,7 @@ from dataface.core.compile.models.query.normalized import AnyQuery
 from dataface.core.compile.models.style.resolved import (
     ResolvedLegendStyle,
 )
-from dataface.core.compile.models.style.theme.board import PaddingStyle
+from dataface.core.compile.models.style.theme.board import PaddingStyle, TitleStyle
 from dataface.core.compile.models.vega_lite.contracts import Projection
 
 
@@ -94,23 +94,41 @@ class _BaseResolvedChartFields(BaseModel):
     legend: ResolvedLegendStyle = Field(
         description="Baked board-level legend style from the style cascade.",
     )
-    layout_padding: PaddingStyle | None = Field(
-        default=None,
+    layout_padding: PaddingStyle = Field(
         description=(
-            "Effective per-chart layout padding baked in at resolve time. "
-            "Combines board.charts.padding with any chart-local style.<family>.padding "
-            "override. None only for charts resolved outside the full pipeline "
-            "(e.g. unit tests). render_layout_item falls back to board-level padding "
-            "when None."
+            "Effective per-chart layout padding, baked in at construction time by "
+            "every family resolver. Combines board.charts.padding with any "
+            "chart-local style.<family>.padding override."
         ),
     )
 
 
 class _SharedResolvedChartFields(_BaseResolvedChartFields):
-    """Adds title/subtitle for all families except KPI and Callout."""
+    """Adds title/subtitle/background for all families except KPI and Callout."""
 
-    title: str | None = Field(default=None, description="Chart title.")
+    title: str | None = Field(
+        default=None,
+        description=(
+            "Jinja-resolved chart title, raw (no title-case transform). Also "
+            "backs non-VL consumers (e.g. the data-chart-title wire attribute) "
+            "that have always emitted the authored text as-is."
+        ),
+    )
     subtitle: str | None = Field(default=None, description="Chart subtitle.")
+    background: str = Field(
+        description=(
+            "Effective chart background: chart-local style.<family>.background "
+            "when authored, otherwise the board/face background."
+        ),
+    )
+    title_style: TitleStyle = Field(
+        description=(
+            "Effective title style — chart-local style.<family>.title merged "
+            "onto the board title style. Render-time VL assembly reads "
+            "title_style.font.case to case-transform `title` (VL presentation "
+            "only), and title_style.overflow for title-wrap mode."
+        ),
+    )
 
 
 class _CartesianResolvedChartFields(_SharedResolvedChartFields):

dataface/core/compile/models/chart/resolved/callout.py

@@ -74,10 +74,9 @@ class ResolvedCalloutChart(BaseModel):
         default_factory=dict,
         description="Always empty — callout has no data channels.",
     )
-    layout_padding: PaddingStyle | None = Field(
-        default=None,
+    layout_padding: PaddingStyle = Field(
         description=(
-            "Effective per-chart layout padding baked in at resolve time. "
+            "Effective per-chart layout padding, baked in at construction time. "
             "Structural parity with _BaseResolvedChartFields so render_layout_item "
             "can access chart.layout_padding without isinstance guards."
         ),

dataface/core/compile/models/chart/resolved/kpi.py

@@ -7,10 +7,10 @@ from typing import Literal
 from pydantic import Field
 
 from dataface.core.compile.models.chart.authored import KpiSupportConfig
+from dataface.core.compile.models.primitives import FormatConfig
 from dataface.core.compile.models.style.resolved import ResolvedKpiStyle
 
 from ._base import _BaseResolvedChartFields
-from ._layer import FormatState
 
 
 class ResolvedKpiChart(_BaseResolvedChartFields):
@@ -50,9 +50,13 @@ class ResolvedKpiChart(_BaseResolvedChartFields):
         default="stacked",
         description="Layout variant — dispatches to a distinct SVG emit path.",
     )
-    format: FormatState = Field(
+    format: FormatConfig | None = Field(
         default=None,
-        description="D3-format string, FormatConfig, or None for the headline value.",
+        description=(
+            "Final headline value format — resolve() has already applied the "
+            "narrative-notation and SI-compaction defaults against this "
+            "chart's row; render consumes it as-is."
+        ),
     )
     style: ResolvedKpiStyle = Field(
         description="KPI family style slice.",

dataface/core/compile/models/chart/resolved/table.py

@@ -39,7 +39,15 @@ class ResolvedTableChart(_SharedResolvedChartFields):
     # not from source_chart.style (which no longer exists on Resolved*Chart).
     columns: dict[str, TableColumnConfig] | None = Field(
         default=None,
-        description="Per-column display config (width, format, label, …).",
+        description=(
+            "Final per-column display config (width, format, label, …), keyed by "
+            "column name. Complete for every column resolve can see: defaults, "
+            "explicit overrides, and runtime FK links are already merged. Excludes "
+            "pivot measure columns (see `column_defaults`) — their real key space "
+            "only exists after render's pivot transform runs. None means no "
+            "column-level config or runtime link facts apply — render falls back "
+            "to plain query columns."
+        ),
     )
     header_overflow: Literal["clip", "truncate", "wrap-two", "wrap"] | None = Field(
         default=None,
@@ -47,7 +55,13 @@ class ResolvedTableChart(_SharedResolvedChartFields):
     )
     column_defaults: TableColumnDefaultsConfig | None = Field(
         default=None,
-        description="Defaults applied to query-inferred columns.",
+        description=(
+            "Table-level column defaults, kept only for render's two render-native "
+            "column key spaces — pivot leaf/measure columns and transpose's "
+            "__metric__/__value__ pair — neither of which exists until a "
+            "render-time data transform runs. Every other column (explicit or "
+            "query-inferred) already has defaults merged into `columns`."
+        ),
     )
     style: ResolvedTableStyle = Field(
         description="Table family style slice.",

dataface/core/compile/models/markers.py

@@ -104,7 +104,7 @@ class SkipInheritSlots:
     ``_ChartStyleBase`` must not inherit from the root cascade.
 
     **On a leaf scalar field**: prevents the leaf from being added to the graph
-    via slot expansion.  Use on ``AxisStyle`` fields that the style resolver does
+    via slot expansion.  Use on axis style fields that the style resolver does
     not cascade — e.g. ``grid.dash``, ``ticks.count``, ``scale``, ``position`` —
     so the inherit graph only declares what the resolver actually does.
 

dataface/core/compile/models/primitives.py

@@ -8,12 +8,13 @@ cannot live in either without creating a circular import.
 from __future__ import annotations
 
 import re
-from typing import Annotated, Any, Literal
+from typing import TYPE_CHECKING, Annotated, Any, Literal
 
 from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
 
 from dataface.core.compile.models.factories import (
     _PatchBase,
+    build_patch_model_ext,
     register_as_own_patch,
     register_patch,
 )
@@ -410,7 +411,158 @@ class FontColorStrokeStyle(StrokeStyle):
     )
 
 
-class ScaleTargetConfig(BaseModel):
+# Vega/Vega-Lite's built-in named color schemes (https://vega.github.io/vega/docs/schemes/),
+# the only strings ``ScaleTargetConfig.palette`` forwards straight through to VL's
+# ``scale.scheme``. Sampled-discrete shorthand like "blues-9" is not a real scheme
+# name — VL fails deep inside rendering ("Cannot read properties of undefined")
+# rather than rejecting it up front, so this is validated at compile time instead.
+#
+# Empirically verified against this repo's pinned vl-convert (not hand-copied from
+# docs alone): every name below was round-tripped through
+# ``vlc.vegalite_to_svg`` with a quantitative ``scale.scheme`` encoding and
+# confirmed to render — see ``test_vega_scheme_names_parity.py``, which re-runs
+# that sweep and fails if this set and the bundled renderer ever diverge.
+VEGA_SCHEME_NAMES: frozenset[str] = frozenset(
+    {
+        # Categorical
+        "accent",
+        "category10",
+        "category20",
+        "category20b",
+        "category20c",
+        "dark2",
+        "observable10",
+        "paired",
+        "pastel1",
+        "pastel2",
+        "set1",
+        "set2",
+        "set3",
+        "tableau10",
+        "tableau20",
+        # Sequential (single-hue)
+        "blues",
+        "tealblues",
+        "teals",
+        "greens",
+        "browns",
+        "greys",
+        "oranges",
+        "purples",
+        "reds",
+        "warmgreys",
+        # Sequential (multi-hue)
+        "viridis",
+        "magma",
+        "inferno",
+        "plasma",
+        "cividis",
+        "turbo",
+        "bluegreen",
+        "bluepurple",
+        "goldgreen",
+        "goldorange",
+        "goldred",
+        "greenblue",
+        "orangered",
+        "purplebluegreen",
+        "purpleblue",
+        "purplered",
+        "redpurple",
+        "yellowgreenblue",
+        "yellowgreen",
+        "yelloworangebrown",
+        "yelloworangered",
+        # Diverging
+        "blueorange",
+        "brownbluegreen",
+        "purplegreen",
+        "pinkyellowgreen",
+        "purpleorange",
+        "redblue",
+        "redgrey",
+        "redyellowblue",
+        "redyellowgreen",
+        "spectral",
+        # Cyclical
+        "rainbow",
+        "sinebow",
+        # For dark backgrounds
+        "darkblue",
+        "darkgold",
+        "darkgreen",
+        "darkmulti",
+        "darkred",
+        # For light backgrounds
+        "lightgreyred",
+        "lightgreyteal",
+        "lightmulti",
+        "lightorange",
+        "lighttealblue",
+    }
+)
+
+
+class ScaleTargetPaletteValidationMixin(BaseModel):
+    """Shared authored-input validator for ``ScaleTargetConfig.palette``.
+
+    Inherited by both ``ScaleTargetConfig`` and ``ScaleTargetConfigPatch`` so
+    chart-local authored patches reject a bad palette at the compile boundary
+    (where ``normalize_face()`` wraps the resulting ``pydantic.ValidationError``
+    into a proper ``ERR-VALIDATION-FIELD`` diagnostic) instead of only at
+    resolve time, where the raw pydantic error leaks past Dataface's error
+    formatting — ``build_patch_model_ext`` only carries over validators that
+    live on the patch model's base class (mirrors ``ScaleDomainValidationMixin``).
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    @model_validator(mode="before")
+    @classmethod
+    def _validate_named_palette(cls, data: object) -> object:
+        """A string palette is either a literal Vega scheme name (forwarded
+        as-is to VL's ``scale.scheme`` by geo/heatmap gradient rendering) or a
+        Dataface named palette (resolved to hex stops downstream by
+        ``resolve_palette_stops``). Reject anything that resolves as neither.
+
+        A dash-suffixed name whose prefix is a real scheme (``"blues-9"``,
+        VL's sampled-discrete shorthand, which Dataface does not forward) gets
+        a specific hint naming the continuous scheme instead of the generic
+        unknown-palette message — that shape is the exact mistake this
+        validator exists to catch: an author reaching for N discrete buckets
+        that Dataface doesn't support yet, not a random typo.
+
+        ``mode="before"`` on the raw dict (not ``field_validator``) so this
+        runs unchanged on both ``ScaleTargetConfig`` and the generated
+        ``ScaleTargetConfigPatch`` — a field-scoped validator would need the
+        field to exist on this mixin itself, which a patch base never does.
+        """
+        if not isinstance(data, dict):
+            return data
+        value = data.get("palette")
+        if not isinstance(value, str) or value in VEGA_SCHEME_NAMES:
+            return data
+        from dataface.core.compile.palette import (  # noqa: PLC0415
+            UnknownPaletteError,
+            palette as resolve_palette,
+        )
+
+        try:
+            resolve_palette(value)
+        except UnknownPaletteError as exc:
+            base, _, suffix = value.rpartition("-")
+            if base in VEGA_SCHEME_NAMES and suffix.isdigit():
+                raise ValueError(
+                    f"palette {value!r} requests a {suffix}-step discrete "
+                    f"variant of the '{base}' scheme. Dataface does not support "
+                    "bucketed/quantized color scales yet — use the continuous "
+                    f"scheme '{base}' instead."
+                ) from None
+            raise ValueError(str(exc)) from None
+        return data
+
+
+class ScaleTargetConfig(ScaleTargetPaletteValidationMixin):
     """Scale configuration for a single style target (background or color).
 
     Used as a chart channel annotation (``ColumnScaleConfig``) and as the
@@ -447,6 +599,27 @@ class ScaleTargetConfig(BaseModel):
     )
 
 
+# Patch type for ScaleTargetConfig — generated (and registered) here, right after
+# the compiled class, so every later recursive build_patch_model_ext call that
+# encounters ScaleTargetConfig as a nested field (StaticGradientColorStyle.gradient,
+# ColumnScaleConfig.color/background) reuses this exact registered class instead of
+# a vanilla auto-generated one with no palette validation.
+if TYPE_CHECKING:
+
+    class ScaleTargetConfigPatch(ScaleTargetConfig):
+        pass
+
+else:
+
+    class _ScaleTargetConfigPatchBase(_PatchBase, ScaleTargetPaletteValidationMixin):
+        """Base for ScaleTargetConfigPatch: extra="forbid" from _PatchBase plus
+        the palette validation from ScaleTargetPaletteValidationMixin."""
+
+    ScaleTargetConfigPatch = register_patch(ScaleTargetConfig)(
+        build_patch_model_ext(ScaleTargetConfig, base_cls=_ScaleTargetConfigPatchBase)
+    )
+
+
 class CategoricalColorStyle(BaseModel):
     """Categorical palette config: per-series colors and single-series ink list."""
 

dataface/core/compile/models/source.py

@@ -875,7 +875,11 @@ class RedshiftSourceConfig(
 ):
     """Redshift source configuration.
 
-    Field names match dbt profiles.yml exactly.
+    Field names match dbt profiles.yml exactly, except `autocommit`: Dataface
+    only reads on this connection, and a non-autocommit session holds
+    AccessShareLock on every table it read until the connection closes,
+    blocking any writer that needs ACCESS EXCLUSIVE. `build_adapter` forces
+    it on unconditionally, so it isn't part of the authored surface.
 
     Read-only posture: no native driver flag. Bind to a SELECT-only IAM role
     or database user at the Redshift/IAM layer.
@@ -957,10 +961,6 @@ class RedshiftSourceConfig(
         str | None,
         Field(description="AWS region containing the Redshift target."),
     ] = None
-    autocommit: Annotated[
-        bool | None,
-        Field(description="Whether Redshift statements autocommit."),
-    ] = True
     access_key_id: Annotated[
         str | None,
         Field(description="AWS access key identifier."),

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

@@ -42,25 +42,36 @@ from pydantic import BaseModel, ConfigDict, Field, model_validator
 # Regression coverage: test_style_authored_bootstrap_order.py.
 from dataface.core.compile.models.style.authored._base import (
     AreaMarkStylePatch,
-    AxisDomainStylePatch,
-    AxisElementStylePatch,
     AxisGridStylePatch,
-    AxisStylePatch,
+    AxisLabelStylePatch,
+    AxisLineStylePatch,
     AxisTicksStylePatch,
+    AxisTitleStylePatch,
+    AxisXStylePatch,
+    AxisYStylePatch,
+    BandAxisStylePatch,
     BarMarkStylePatch,
+    BaseAxisGridStylePatch,
+    BaseAxisStylePatch,
+    BaseScaleStylePatch,
     DataTableStylePatch,
+    DimensionLabelStylePatch,
+    DimensionTicksStylePatch,
     EndpointLabelsConfig,
     EndpointLabelsConfigPatch,
     GlobalMarksStylePatch,
     LegendStylePatch,
     LineMarkStylePatch,
+    MeasureGridStylePatch,
     PaddingStylePatch,
     PointMarkStylePatch,
-    ScaleStylePatch,
+    QuantitativeAxisStylePatch,
+    ScaleContinuousStylePatch,
     StylePatch,
     TitleStylePatch,
     TooltipStylePatch,
     TotalStylePatch,
+    XScaleStylePatch,
 )
 from dataface.core.compile.models.style.authored.area import AreaChartStylePatch
 from dataface.core.compile.models.style.authored.bar import BarChartStylePatch
@@ -99,6 +110,7 @@ from dataface.core.compile.models.style.authored.table import (
     TableColumnConfig,
     TableColumnDefaultsConfig,
     _validate_glyph_pair as _validate_glyph_pair,
+    fill_table_column_defaults,
 )
 
 __all__ = [
@@ -106,11 +118,23 @@ __all__ = [
     "_validate_glyph_pair",
     "AreaChartStylePatch",
     "AreaMarkStylePatch",
-    "AxisDomainStylePatch",
-    "AxisElementStylePatch",
     "AxisGridStylePatch",
-    "AxisStylePatch",
+    "AxisLabelStylePatch",
+    "AxisLineStylePatch",
     "AxisTicksStylePatch",
+    "AxisTitleStylePatch",
+    "AxisXStylePatch",
+    "AxisYStylePatch",
+    "BandAxisStylePatch",
+    "BaseAxisGridStylePatch",
+    "BaseAxisStylePatch",
+    "BaseScaleStylePatch",
+    "DimensionLabelStylePatch",
+    "DimensionTicksStylePatch",
+    "MeasureGridStylePatch",
+    "QuantitativeAxisStylePatch",
+    "ScaleContinuousStylePatch",
+    "XScaleStylePatch",
     "BarChartStylePatch",
     "BarMarkStylePatch",
     "CalloutChartStylePatch",
@@ -131,7 +155,6 @@ __all__ = [
     "PieChartStylePatch",
     "PointMapChartStylePatch",
     "PointMarkStylePatch",
-    "ScaleStylePatch",
     "ScatterChartStylePatch",
     "SparkBarBarStylePatch",
     "SparkBarChartLabelStylePatch",
@@ -146,6 +169,7 @@ __all__ = [
     "TableColumnDefaultsConfig",
     "TitleStylePatch",
     "TooltipStylePatch",
+    "fill_table_column_defaults",
     "TotalStylePatch",
 ]