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

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/config.py

@@ -217,6 +217,11 @@ class ExecutionConfig(ConfigNode):
     max_query_duration_seconds: int = Field(
         gt=0, description="Maximum seconds a single query may run (must be > 0)."
     )
+    # Hard cap on files matched per glob pattern in file sources. Error is raised
+    # before any file is read so a runaway glob fails fast. Override in dataface.yml.
+    max_glob_file_count: int = Field(
+        gt=0, description="Maximum files a single glob may match (must be > 0)."
+    )
     # sqlglot uses different dialect names than Dataface's public-facing dialect strings.
     # This mapping normalizes Dataface names to sqlglot equivalents before parsing.
     dialect_aliases: dict[str, str]

dataface/core/compile/models/face/authored.py

@@ -22,6 +22,7 @@ from pydantic import (
     model_validator,
 )
 
+from dataface.core.aliases import normalize_alias_url
 from dataface.core.compile.models.cache import CachePatch
 from dataface.core.compile.models.chart.authored import AuthoredChart
 from dataface.core.compile.models.markers import Merge, Strategy
@@ -119,74 +120,6 @@ def _check_layout_item(v: Any) -> Any:
     return _reject_chartref_dict(v)
 
 
-class ForeachQuery(BaseModel):
-    """Inline data source for compile-time foreach loops."""
-
-    model_config = ConfigDict(extra="forbid")
-
-    data: list[dict[str, Any]] | None = Field(
-        default=None,
-        description="Inline row data for compile-time iteration.",
-    )
-    static_data: list[dict[str, Any]] | None = Field(
-        default=None,
-        description="Alias for data; inline row data for compile-time iteration.",
-    )
-    palette: str | None = Field(
-        default=None,
-        description=(
-            "Palette name to iterate its live stops from the palette YAML source "
-            "of truth (one row per stop: {n: 1-indexed position, hex: sRGB hex}). "
-            "Accepts the same 'name:steps' / 'name_r' shorthand as palette()."
-        ),
-    )
-
-    @model_validator(mode="after")
-    def _reject_palette_with_inline_data(self) -> ForeachQuery:
-        """palette: is a distinct data source; combining it with data:/static_data:
-        is ambiguous about which one drives the loop."""
-        if self.palette is not None and (
-            self.data is not None or self.static_data is not None
-        ):
-            raise ValueError(
-                "foreach.query.palette is mutually exclusive with data/static_data"
-            )
-        return self
-
-
-class ForeachConfig(BaseModel):
-    """foreach loop configuration.
-
-    `as` is a Python keyword so the field is declared as `as_` with an alias.
-    """
-
-    model_config = ConfigDict(extra="forbid", populate_by_name=True)
-
-    query: ForeachQuery = Field(
-        description="Inline data source providing the rows to iterate over."
-    )
-    as_: str = Field(
-        alias="as",
-        description="Variable name bound to each row (accessible as {{ as.field }}).",
-    )
-    items: Annotated[
-        list[
-            str | AuthoredFace | AuthoredChart | ForeachItem | dict[str, AuthoredChart]
-        ],
-        BeforeValidator(_check_layout_list),
-    ] = Field(description="Layout item templates resolved once per data row.")
-
-
-class ForeachItem(BaseModel):
-    """Top-level foreach construct in a layout list."""
-
-    model_config = ConfigDict(extra="forbid")
-
-    foreach: ForeachConfig = Field(
-        description="foreach loop configuration with query, as, and items."
-    )
-
-
 class GridItem(BaseModel):
     """Grid layout item with position and span.
 
@@ -209,7 +142,7 @@ class GridItem(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
     item: Annotated[
-        str | AuthoredFace | AuthoredChart | ForeachItem | dict[str, AuthoredChart],
+        str | AuthoredFace | AuthoredChart | dict[str, AuthoredChart],
         BeforeValidator(_check_layout_item),
     ] = Field(
         description="Chart name or inline chart/face definition to place in this grid cell."
@@ -288,17 +221,11 @@ class TabItem(BaseModel):
 
     # Layout fields (tab can contain nested layouts)
     rows: Annotated[
-        list[
-            str | AuthoredFace | AuthoredChart | ForeachItem | dict[str, AuthoredChart]
-        ]
-        | None,
+        list[str | AuthoredFace | AuthoredChart | dict[str, AuthoredChart]] | None,
         BeforeValidator(_check_layout_list),
     ] = Field(default=None, description="Vertical stack layout for this tab's content.")
     cols: Annotated[
-        list[
-            str | AuthoredFace | AuthoredChart | ForeachItem | dict[str, AuthoredChart]
-        ]
-        | None,
+        list[str | AuthoredFace | AuthoredChart | dict[str, AuthoredChart]] | None,
         BeforeValidator(_check_layout_list),
     ] = Field(default=None, description="Horizontal layout for this tab's content.")
     grid: GridLayout | None = Field(
@@ -510,6 +437,7 @@ class AuthoredFace(_FaceDesugarMixin):
             ),
         )
     )
+
     text: Annotated[str | None, Merge(Strategy.OVERRIDE)] = Field(
         default=None, description="Markdown text content for text-only sections."
     )
@@ -573,10 +501,7 @@ class AuthoredFace(_FaceDesugarMixin):
 
     # Layout (exactly one should be present)
     rows: Annotated[
-        list[
-            str | AuthoredFace | AuthoredChart | ForeachItem | dict[str, AuthoredChart]
-        ]
-        | None,
+        list[str | AuthoredFace | AuthoredChart | dict[str, AuthoredChart]] | None,
         BeforeValidator(_check_layout_list),
         Merge(Strategy.APPEND, nested=Strategy.CHILD),
     ] = Field(
@@ -584,10 +509,7 @@ class AuthoredFace(_FaceDesugarMixin):
         description="Vertical stack layout: list of chart names or inline chart/face definitions.",
     )
     cols: Annotated[
-        list[
-            str | AuthoredFace | AuthoredChart | ForeachItem | dict[str, AuthoredChart]
-        ]
-        | None,
+        list[str | AuthoredFace | AuthoredChart | dict[str, AuthoredChart]] | None,
         BeforeValidator(_check_layout_list),
         Merge(Strategy.APPEND, nested=Strategy.CHILD),
     ] = Field(
@@ -697,6 +619,21 @@ class AuthoredFace(_FaceDesugarMixin):
             )
         return data
 
+    @model_validator(mode="after")
+    def validate_aliases(self) -> AuthoredFace:
+        """Every alias must be absolute, per ``aliases``' own description.
+
+        Checked through ``normalize_alias_url`` so the authored surface and the
+        redirect index cannot disagree about what a well-formed alias is; the
+        normalized value is discarded, since the face stores what the author
+        wrote.
+        """
+        if self.aliases is None:
+            return self
+        for alias in self.aliases:
+            normalize_alias_url(alias)
+        return self
+
     @model_validator(mode="after")
     def validate_layout(self) -> AuthoredFace:
         """Ensure at least one layout type or content is defined."""
@@ -723,10 +660,8 @@ class AuthoredFace(_FaceDesugarMixin):
         return self.source
 
 
-# Resolve forward references (ForeachConfig.items references ForeachItem and
-# AuthoredFace; GridItem.item and TabItem.rows/cols also reference types defined
-# later in the file — rebuild after all classes are in scope)
-ForeachConfig.model_rebuild()
+# Resolve forward references (GridItem.item and TabItem.rows/cols reference types
+# defined later in the file — rebuild after all classes are in scope)
 GridItem.model_rebuild()
 TabItem.model_rebuild()
 AuthoredFace.model_rebuild()

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/query/authored.py

@@ -287,114 +287,6 @@ class AuthoredSchemaQuery(_BaseQueryFields):
     )
 
 
-class _AuthoredLookmlQueryFields(_BaseQueryFields):
-    """Fields shared by both LookML authoring shapes.
-
-    ``source:`` names the LookML *model* (declared under a warehouse source's
-    ``models:`` map), not a connection. Optional install:
-    ``pip install dataface[lookml]``.
-    """
-
-    type: Literal["lookml"] = Field(
-        default="lookml",
-        description="Query adapter type.",
-    )
-    fields: list[str] | None = Field(
-        default=None,
-        description=(
-            "Qualified 'view.field' refs to select. "
-            "Optional at authoring time: collected from chart channels when absent."
-        ),
-    )
-    sorts: list[str] | None = Field(
-        default=None,
-        description=(
-            "Looker sort clauses, e.g. "
-            "['view.field', 'view.other desc']. Lowered to ORDER BY via likeml."
-        ),
-    )
-    pivots: list[str] | None = Field(
-        default=None,
-        description="Qualified 'view.field' refs to pivot on.",
-    )
-    pivots_unwrapped: bool | None = Field(
-        default=None,
-        description=(
-            "Which of Looker's two pivot SQL shapes to emit: "
-            "False/None = wrapped (5-layer DENSE_RANK), True = plain GROUP BY."
-        ),
-    )
-    total: bool | None = Field(
-        default=None,
-        description="Looker grand-totals flag.",
-    )
-    subtotals: list[str] | None = Field(
-        default=None,
-        description="Dimension refs to subtotal via GROUP BY ROLLUP.",
-    )
-    filter_expression: str | None = Field(
-        default=None,
-        description=(
-            "Looker query-level free-form boolean filter over ${view.field} refs."
-        ),
-    )
-    dynamic_fields: list[dict[str, Any]] | None = Field(
-        default=None,
-        description=(
-            "Looker dynamic fields: custom measures / custom "
-            "dimensions synthesized into SQL. Table calculations compose as a derived "
-            "wrapper query, not here."
-        ),
-    )
-    limit: int | None = Field(
-        default=None,
-        description="Maximum number of rows returned.",
-    )
-    column_limit: int | None = Field(
-        default=None,
-        description="Looker column_limit — caps wrapped-pivot columns.",
-    )
-    filters: dict[str, Any] | None = Field(
-        default=None,
-        description=(
-            "RAW Looker filter expressions keyed by 'view.field' "
-            '(e.g. "13 months", "gold") — translated to SQL predicates by likeml.'
-        ),
-    )
-
-
-class AuthoredLookmlQuery(_AuthoredLookmlQueryFields):
-    """LookML query rooted at one explore."""
-
-    explore: Annotated[
-        str,
-        Field(
-            description=(
-                "LookML explore name. Presence of this key infers type: lookml. "
-                "Use a merge query instead to combine multiple sources."
-            )
-        ),
-    ]
-
-
-class AuthoredLookmlMergeQuery(_AuthoredLookmlQueryFields):
-    """LookML query that merges multiple sources."""
-
-    merge: Annotated[
-        list[dict[str, Any]],
-        Field(
-            description=(
-                "LookML merge sources — a list of source specs. "
-                "Each is either an explore spec ({explore, fields, filters?, merge_on?}) "
-                "or a query reference ({query, columns, merge_on?}) for a derived source "
-                "such as a table-calc wrapper. First is the primary; each secondary's "
-                "`merge_on` maps its key to the primary's. Presence of this key infers "
-                "type: lookml. Compiled to a FULL OUTER JOIN via likeml."
-            )
-        ),
-    ]
-
-
 def _discriminate_authored_query(v: Any) -> str | None:
     """Custom discriminator: return the type tag for the AuthoredQuery union.
 
@@ -419,14 +311,6 @@ def _discriminate_authored_query(v: Any) -> str | None:
         return (
             "values_rows" if isinstance(v, dict) and "rows" in v else "values_compact"
         )
-    if t == "lookml":
-        if isinstance(v, AuthoredLookmlMergeQuery):
-            return "lookml_merge"
-        if isinstance(v, AuthoredLookmlQuery):
-            return "lookml_explore"
-        return (
-            "lookml_merge" if isinstance(v, dict) and "merge" in v else "lookml_explore"
-        )
     return t
 
 
@@ -436,9 +320,7 @@ AuthoredQuery = Annotated[
     | Annotated[AuthoredHttpQuery, Tag("http")]
     | Annotated[AuthoredValuesQuery, Tag("values_rows")]
     | Annotated[AuthoredCompactValuesQuery, Tag("values_compact")]
-    | Annotated[AuthoredSchemaQuery, Tag("schema")]
-    | Annotated[AuthoredLookmlQuery, Tag("lookml_explore")]
-    | Annotated[AuthoredLookmlMergeQuery, Tag("lookml_merge")],
+    | Annotated[AuthoredSchemaQuery, Tag("schema")],
     Discriminator(_discriminate_authored_query),
 ]
 """Discriminated union over the authored query types.