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

dataface/core/compile/normalize_layout.py

@@ -18,9 +18,6 @@ from dataface.core.compile.models.chart.authored import (
 from dataface.core.compile.models.chart.normalized import Chart
 from dataface.core.compile.models.face.authored import (
     AuthoredFace,
-    ForeachConfig,
-    ForeachItem,
-    ForeachQuery,
     GridLayout,
     LayoutType,
     TabLayout,
@@ -36,7 +33,6 @@ from dataface.core.compile.normalize_charts import (
     generate_inline_chart_id,
     normalize_chart,
 )
-from dataface.core.compile.palette import palette as resolve_palette
 from dataface.core.utils import UniqueKeyLoader
 
 
@@ -75,7 +71,6 @@ def build_unified_layout(
     theme: str | None = None,
     parent_variables: dict[str, Any] | None = None,
     *,
-    _resolve_jinja: bool = False,
     resolved_style: ResolvedStyle,
     parent_level: int = 0,
     sources: dict[str, Any],
@@ -125,7 +120,6 @@ def build_unified_layout(
             theme,
             used_chart_ids,
             parent_variables,
-            _resolve_jinja=_resolve_jinja,
             parent_level=parent_level,
             cache_root=cache_root,
             sources=sources,
@@ -148,7 +142,6 @@ def build_unified_layout(
             theme,
             used_chart_ids,
             parent_variables,
-            _resolve_jinja=_resolve_jinja,
             parent_level=parent_level,
             cache_root=cache_root,
             sources=sources,
@@ -171,7 +164,6 @@ def build_unified_layout(
             theme,
             used_chart_ids,
             parent_variables,
-            _resolve_jinja=_resolve_jinja,
             parent_level=parent_level,
             cache_root=cache_root,
             sources=sources,
@@ -197,7 +189,6 @@ def build_unified_layout(
             face_cache,
             chart_registry,
             theme,
-            _resolve_jinja=_resolve_jinja,
             resolved_style=resolved_style,
             parent_level=parent_level,
             cache_root=cache_root,
@@ -257,7 +248,6 @@ def build_unified_layout(
             theme,
             used_chart_ids,
             parent_variables,
-            _resolve_jinja=_resolve_jinja,
             parent_level=parent_level,
             cache_root=cache_root,
             sources=sources,
@@ -284,7 +274,6 @@ def _resolve_layout_items(
     theme: str | None = None,
     used_chart_ids: set[str] | None = None,
     parent_variables: dict[str, Any] | None = None,
-    _resolve_jinja: bool = False,
     parent_level: int = 0,
     *,
     sources: dict[str, Any],
@@ -320,50 +309,26 @@ def _resolve_layout_items(
     local_chart_ids = local_chart_ids or set()
 
     for idx, item in enumerate(items):
-        # Handle foreach construct
-        if isinstance(item, ForeachItem):
-            foreach_items = _resolve_foreach_item(
-                item.foreach,
-                charts,
-                query_registry,
-                face_id,
-                depth,
-                f"{prefix}{idx}",
-                base_dir,
-                default_source,
-                face_cache,
-                chart_registry,
-                theme,
-                used_chart_ids,
-                parent_variables,
-                parent_level=parent_level,
-                cache_root=cache_root,
-                sources=sources,
-                local_chart_ids=local_chart_ids,
-            )
-            resolved.extend(foreach_items)
-        else:
-            layout_item = _resolve_single_item(
-                item,
-                charts,
-                query_registry,
-                face_id,
-                depth,
-                f"{prefix}{idx}",
-                base_dir,
-                default_source,
-                face_cache,
-                chart_registry,
-                theme,
-                used_chart_ids,
-                parent_variables,
-                _resolve_jinja=_resolve_jinja,
-                parent_level=parent_level,
-                cache_root=cache_root,
-                sources=sources,
-                local_chart_ids=local_chart_ids,
-            )
-            resolved.append(layout_item)
+        layout_item = _resolve_single_item(
+            item,
+            charts,
+            query_registry,
+            face_id,
+            depth,
+            f"{prefix}{idx}",
+            base_dir,
+            default_source,
+            face_cache,
+            chart_registry,
+            theme,
+            used_chart_ids,
+            parent_variables,
+            parent_level=parent_level,
+            cache_root=cache_root,
+            sources=sources,
+            local_chart_ids=local_chart_ids,
+        )
+        resolved.append(layout_item)
 
     return resolved
 
@@ -382,7 +347,6 @@ def _resolve_single_item(
     theme: str | None = None,
     used_chart_ids: set[str] | None = None,
     parent_variables: dict[str, Any] | None = None,
-    _resolve_jinja: bool = False,
     parent_level: int = 0,
     *,
     sources: dict[str, Any],
@@ -426,7 +390,6 @@ def _resolve_single_item(
                 chart_registry,
                 theme,
                 parent_variables,
-                _resolve_jinja=_resolve_jinja,
                 parent_level=parent_level,
                 cache_root=cache_root,
                 sources=sources,
@@ -466,13 +429,6 @@ def _resolve_single_item(
     if isinstance(item, AuthoredFace):
         from dataface.core.compile.normalizer import normalize_face
 
-        # In foreach context, resolve Jinja templates baked into the typed face.
-        # Pydantic parsed templates as literal strings; dump to dict, resolve, re-validate.
-        if _resolve_jinja and parent_variables:
-            face_dict = item.model_dump(exclude_none=True, by_alias=False)
-            face_dict = _resolve_dict_templates(face_dict, parent_variables)
-            item = AuthoredFace.model_validate(face_dict)
-
         details = item.details
         user_width = str(item.width) if item.width is not None else None
         layout_height = str(item.height) if item.height is not None else None
@@ -491,7 +447,6 @@ def _resolve_single_item(
                 "sources": sources,
                 "theme": theme,
                 "variables": parent_variables,
-                "_resolve_jinja": _resolve_jinja,
             },
             query_registry=query_registry,
             chart_registry=chart_registry,
@@ -550,9 +505,6 @@ def _resolve_single_item(
 
 
 # Layout keys that should not have templates resolved (processed by layout resolution)
-_LAYOUT_KEYS = frozenset({"rows", "cols", "grid", "tabs"})
-
-
 def _layout_source_path(item_id: str) -> str:
     match = re.fullmatch(r"(row|col|grid)(\d+)", item_id)
     if not match:
@@ -561,54 +513,6 @@ def _layout_source_path(item_id: str) -> str:
     return f"{key}[{match.group(2)}]"
 
 
-def _resolve_dict_templates(
-    data: dict[str, Any],
-    variables: dict[str, Any],
-) -> dict[str, Any]:
-    """Resolve Jinja templates recursively in dict values.
-
-    Used to resolve loop variables and inherited variables in nested face
-    definitions created by foreach (compile-time static expansion).
-
-    Args:
-        data: Dict with potentially templated string values
-        variables: Variables for Jinja resolution
-
-    Returns:
-        Dict with resolved string values
-    """
-    from dataface.core.compile.jinja import resolve_jinja_template
-
-    result: dict[str, Any] = {}
-    for key, value in data.items():
-        if isinstance(value, str):
-            # Resolve Jinja templates in strings
-            result[key] = resolve_jinja_template(value, variables, strict=False)
-        elif isinstance(value, dict):
-            # Recurse into nested dicts
-            result[key] = _resolve_dict_templates(value, variables)
-        elif isinstance(value, list):
-            # Don't recurse into layout items - those are processed by _resolve_layout_items
-            if key in _LAYOUT_KEYS:
-                result[key] = value
-            else:
-                result[key] = [
-                    (
-                        _resolve_dict_templates(v, variables)
-                        if isinstance(v, dict)
-                        else (
-                            resolve_jinja_template(v, variables, strict=False)
-                            if isinstance(v, str)
-                            else v
-                        )
-                    )
-                    for v in value
-                ]
-        else:
-            result[key] = value
-    return result
-
-
 def _resolve_board_file_import(
     file_path: str,
     query_registry: dict[str, AnyQuery],
@@ -621,7 +525,6 @@ def _resolve_board_file_import(
     chart_registry: dict[str, Any] | None = None,
     theme: str | None = None,
     parent_variables: dict[str, Any] | None = None,
-    _resolve_jinja: bool = False,
     parent_level: int = 0,
     *,
     sources: dict[str, Any],
@@ -647,8 +550,6 @@ def _resolve_board_file_import(
         theme: Vega-Lite theme to inherit
         used_chart_ids: Set of already-used chart IDs for uniqueness
         parent_variables: Variables from parent scope for template resolution
-        _resolve_jinja: If True, resolve Jinja templates in the YAML content
-                     (foreach creates static faces; all templates baked at compile time).
                      If False, skip YAML content resolution so interactive variables
                      remain as templates and are resolved at render time.
 
@@ -686,14 +587,6 @@ def _resolve_board_file_import(
     # Load and parse the YAML file
     try:
         yaml_content = nested_path.read_text()
-        # Only resolve Jinja templates in the YAML content when inside a foreach.
-        # Foreach creates static compile-time faces, so all templates (loop vars +
-        # interactive defaults) must be baked in. For regular imports, leave
-        # templates intact so they are resolved dynamically at render time.
-        if _resolve_jinja:
-            yaml_content = resolve_jinja_template(
-                yaml_content, parent_variables, strict=False
-            )
         face_data = yaml.load(yaml_content, Loader=UniqueKeyLoader)
     except yaml.YAMLError as e:
         raise CompilationError(
@@ -723,7 +616,6 @@ def _resolve_board_file_import(
         "sources": sources,
         "theme": theme,
         "variables": parent_variables,  # Pass variables to child
-        "_resolve_jinja": _resolve_jinja,  # Propagate foreach context to children
     }
 
     # Compile the nested face
@@ -741,158 +633,6 @@ def _resolve_board_file_import(
     return LayoutItem(type="face", face=compiled_nested)
 
 
-def _resolve_foreach_item(
-    foreach_config: ForeachConfig,
-    charts: dict[str, Chart],
-    query_registry: dict[str, AnyQuery],
-    face_id: str,
-    depth: int,
-    item_id: str,
-    base_dir: ProjectDirectory | None = None,
-    default_source: str | None = None,
-    face_cache: CachePatch = INHERIT_CACHE,
-    chart_registry: dict[str, Any] | None = None,
-    theme: str | None = None,
-    used_chart_ids: set[str] | None = None,
-    parent_variables: dict[str, Any] | None = None,
-    parent_level: int = 0,
-    *,
-    sources: dict[str, Any],
-    cache_root: CachePatch | None = None,
-    local_chart_ids: set[str] | None = None,
-) -> list[LayoutItem]:
-    """Resolve a foreach construct that iterates over inline data.
-
-    foreach allows dynamically generating layout items at compile time.
-    Each row from the inline data becomes available as a loop variable,
-    accessible via dot notation (e.g., {{ col.name }}).
-
-    Example YAML:
-        rows:
-          - foreach:
-              query:
-                data:
-                  - name: "revenue"
-                    type: "numeric"
-                  - name: "date"
-                    type: "date"
-              as: col
-              items:
-                - 'partials/{{ col.type }}.yml'
-
-    Note: At compile time, foreach only works with inline data (query.data).
-    Query references are not executed during compilation.
-
-    Args:
-        foreach_config: Validated ForeachConfig with query, as_, and items.
-        charts: Available charts
-        query_registry: Query registry
-        face_id: Parent face ID
-        depth: Nesting depth
-        item_id: ID prefix for generated items
-        base_dir: ProjectDirectory handle for resolving external file references
-        default_source: Default source for inline queries
-        face_cache: The declaring dashboard's `cache:` layer, inherited
-            by every query normalized below it
-        chart_registry: Raw chart definitions for nested face normalization
-        theme: Vega-Lite theme to inherit
-        used_chart_ids: Set of already-used chart IDs for uniqueness
-        parent_variables: Variables from parent scope
-
-    Returns:
-        List of LayoutItems generated from the foreach iteration
-    """
-    query_config = foreach_config.query
-    loop_var = foreach_config.as_
-    item_templates = foreach_config.items
-    parent_variables = parent_variables or {}
-
-    # Extract inline data from query config
-    # At compile time, foreach only works with inline data
-    static_data = _get_foreach_data(query_config)
-    if not static_data:
-        return []
-
-    # Generate layout items for each row
-    resolved_items: list[LayoutItem] = []
-    for idx, row in enumerate(static_data):
-        loop_context = _build_loop_context(row, loop_var, parent_variables)
-
-        for template_idx, template_item in enumerate(item_templates):
-            layout_item = _resolve_single_item(
-                template_item,
-                charts,
-                query_registry,
-                face_id,
-                depth,
-                f"{item_id}_foreach{idx}_{template_idx}",
-                base_dir,
-                default_source,
-                face_cache,
-                chart_registry,
-                theme,
-                used_chart_ids,
-                loop_context,
-                _resolve_jinja=True,
-                parent_level=parent_level,
-                cache_root=cache_root,
-                sources=sources,
-                local_chart_ids=local_chart_ids,
-            )
-            resolved_items.append(layout_item)
-
-    return resolved_items
-
-
-def _get_foreach_data(query_config: ForeachQuery) -> list[dict[str, Any]] | None:
-    """Extract data for foreach iteration from a ForeachQuery.
-
-    Args:
-        query_config: Validated ForeachQuery with optional data, static_data,
-            or palette.
-
-    Returns:
-        List of row dicts for iteration, or None if no data.
-    """
-    if query_config.palette is not None:
-        stops = resolve_palette(query_config.palette)
-        return [{"n": i, "hex": hex_value} for i, hex_value in enumerate(stops, 1)]
-    data = query_config.data or query_config.static_data
-    if isinstance(data, list):
-        return data
-    return None
-
-
-def _build_loop_context(
-    row: Any,
-    loop_var: str,
-    parent_variables: dict[str, Any],
-) -> dict[str, Any]:
-    """Build the variable context for a foreach iteration.
-
-    The loop variable is accessible via dot notation: {{ col.field }}
-    This keeps variable scoping explicit and avoids shadowing parent variables.
-
-    Args:
-        row: Current row data (dict or scalar)
-        loop_var: Name of the loop variable
-        parent_variables: Variables inherited from parent scope
-
-    Returns:
-        Combined context dict for Jinja resolution
-    """
-    loop_context = dict(parent_variables)
-
-    if isinstance(row, dict):
-        # Row is a dict - accessible as {{ loop_var.field }}
-        loop_context[loop_var] = row
-    else:
-        # Scalar value - wrap in dict with 'value' key
-        loop_context[loop_var] = {"value": row}
-
-    return loop_context
-
-
 def _resolve_grid_items(
     grid: GridLayout,
     charts: dict[str, Chart],
@@ -906,7 +646,6 @@ def _resolve_grid_items(
     theme: str | None = None,
     used_chart_ids: set[str] | None = None,
     parent_variables: dict[str, Any] | None = None,
-    _resolve_jinja: bool = False,
     parent_level: int = 0,
     *,
     sources: dict[str, Any],
@@ -960,7 +699,6 @@ def _resolve_grid_items(
             theme,
             used_chart_ids,
             parent_variables,
-            _resolve_jinja=_resolve_jinja,
             parent_level=parent_level,
             cache_root=cache_root,
             sources=sources,
@@ -1011,7 +749,6 @@ def _resolve_tab_items(
     chart_registry: dict[str, Any] | None = None,
     theme: str | None = None,
     *,
-    _resolve_jinja: bool = False,
     resolved_style: ResolvedStyle,
     parent_level: int = 0,
     sources: dict[str, Any],
@@ -1061,7 +798,6 @@ def _resolve_tab_items(
                     "face_cache": face_cache,
                     "sources": sources,
                     "theme": theme,
-                    "_resolve_jinja": _resolve_jinja,
                 },
                 query_registry=query_registry,
                 chart_registry=chart_registry,