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

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

dataface/core/compile/models/refs.py

@@ -43,8 +43,6 @@ def infer_query_type_from_keys(query_dict: dict[str, Any]) -> str:
         return "values"
     if "metrics" in query_dict or "dimensions" in query_dict:
         return "metricflow"
-    if "explore" in query_dict or "merge" in query_dict:
-        return "lookml"
     if "url" in query_dict:
         return "http"
     return "sql"