dataface 0.1.2__py3-none-any.whl

dataface/core/render/templates/svg/grid_pattern.svg

@@ -0,0 +1,3 @@
+<pattern id="grid-pattern" width="100" height="100" patternUnits="userSpaceOnUse">
+    <path d="M 100 0 L 0 0 0 100" fill="none" stroke="#e0e0e0" stroke-width="1"/>
+</pattern>

dataface/core/render/templates/svg/styles.css

@@ -0,0 +1,51 @@
+<style type="text/css">
+/* SVG Chart Styles
+ * These styles are embedded in dataface SVGs for interactive features.
+ */
+
+{% if emoji_mode != "disabled" %}{% include '_emoji_font_face.css' %}{% endif %}
+{% if emoji_mode in ("monochrome", "color") %}svg text { font-variant-emoji: text; }{% endif %}
+
+/* Chart base styles */
+.dft-chart {
+    position: relative;
+}
+
+/* Chart loading state */
+.dft-chart.loading {
+    opacity: 0.5;
+    pointer-events: none;
+}
+
+/* Chart highlight overlay when hovering over dependent variable */
+/* Border only, no fill - just outlines the dependent charts */
+.dft-chart-highlight-overlay {
+    fill: none;
+    stroke: #667eea;
+    stroke-width: 3;
+    pointer-events: none;
+    opacity: 1;
+    transition: opacity 0.15s ease-in-out;
+}
+
+/* Variable control hover */
+.variable-control:hover {
+    cursor: pointer;
+}
+
+.variable-control[data-disabled="true"] {
+    opacity: 0.55;
+    cursor: not-allowed;
+}
+
+.variable-control[data-disabled="true"]:hover {
+    cursor: not-allowed;
+}
+
+{% include 'controls/_styles.css' %}
+
+/* Spinner animation for loading state */
+@keyframes dft-spin {
+    to { transform: rotate(360deg); }
+}
+</style>

dataface/core/render/terminal.py

@@ -0,0 +1,311 @@
+"""Terminal rendering module.
+
+Stage: RENDER
+Purpose: Render compiled datafaces to terminal output.
+
+This module provides terminal rendering functionality using:
+- Plotext for charts
+- Rich for tables and text formatting
+- Custom layout rendering for terminal constraints
+
+Entry Points:
+    - render_face_terminal(face, executor, variables, **options) -> str
+    - render_chart_terminal(chart, data, **options) -> str
+"""
+
+import shutil
+from typing import Any
+
+from dataface.core.compile.models.chart.compiled import (
+    Chart,
+)
+from dataface.core.compile.models.face.compiled import (
+    Face,
+    Layout,
+    LayoutItem,
+    VariableValues,
+)
+from dataface.core.execute.executor import Executor
+from dataface.core.render.variable_controls import evaluate_visible
+
+
+def _dispatch_layout(
+    layout: Layout,
+    executor: Executor,
+    variables: dict[str, Any],
+    width: int,
+    height: int,
+    gap: int,
+    background: str | None,
+    grid_columns: int,
+) -> str:
+    """Dispatch to the correct terminal layout renderer based on layout type."""
+    from dataface.core.render.terminal_layouts import (
+        render_cols_layout_terminal,
+        render_grid_layout_terminal,
+        render_rows_layout_terminal,
+        render_tabs_layout_terminal,
+    )
+
+    if layout.type == "cols":
+        return render_cols_layout_terminal(
+            layout.items,
+            executor,
+            variables,
+            width,
+            height,
+            gap=gap,
+            background=background,
+        )
+    if layout.type == "grid":
+        return render_grid_layout_terminal(
+            layout.items,
+            executor,
+            variables,
+            width,
+            height,
+            columns=layout.columns or grid_columns,
+            gap=gap,
+            background=background,
+        )
+    if layout.type == "tabs":
+        return render_tabs_layout_terminal(
+            layout.items,
+            executor,
+            variables,
+            width,
+            height,
+            layout.tab_titles,
+            layout.default_tab or 0,
+            layout.tab_position or "top",
+            background,
+        )
+    # "rows" or any unknown type — fall back to rows
+    return render_rows_layout_terminal(
+        layout.items,
+        executor,
+        variables,
+        width,
+        height,
+        gap=gap,
+        background=background,
+    )
+
+
+def render_face_terminal(
+    face: Face,
+    executor: Executor,
+    variables: VariableValues | None = None,
+    width: int | None = None,
+    height: int | None = None,
+    colors: bool = True,
+    **options: Any,
+) -> str:
+    """Render a compiled dataface to terminal output.
+
+    Args:
+        face: Compiled dataface to render
+        executor: Executor for query execution
+        variables: Variable values for queries
+        width: Terminal width in characters (auto-detect if None)
+        height: Terminal height in characters (auto-detect if None)
+        colors: Whether to use ANSI colors
+        **options: Additional rendering options
+
+    Returns:
+        Terminal-formatted dataface string
+    """
+    # Auto-detect terminal size if not provided
+    if width is None or height is None:
+        try:
+            term_size = shutil.get_terminal_size()
+            width = width or term_size.columns
+            height = height or term_size.lines
+        except (OSError, ValueError):
+            # shutil.get_terminal_size() can fail in non-TTY environments (CI, pipes, etc.)
+            # Fallback to standard terminal size
+            width = width or 80
+            height = height or 24
+
+    # Trust the normalizer - use pre-computed variable_defaults
+    variable_registry = face.variable_registry or {}
+
+    # Merge variables: start with None for all vars, then defaults, then user values
+    all_variables: dict[str, Any] = dict.fromkeys(variable_registry)
+    all_variables.update(face.variable_defaults)  # Pre-computed by normalizer
+    if variables:
+        all_variables.update(variables)
+
+    # Calculate layout dimensions
+    from dataface.core.compile.config import get_config
+
+    config = get_config()
+    face_width = width - 4  # Account for padding
+    face_height = height - 4
+
+    # Render title if present
+    title_lines: list[str] = []
+    title_height = 0
+    if face.title:
+        from dataface.core.compile.jinja import resolve_jinja_template
+
+        resolved_title = resolve_jinja_template(face.title, all_variables)
+
+        # Format title with border
+        title_lines.append("=" * face_width)
+        title_lines.append(f" {resolved_title}")
+        title_lines.append("=" * face_width)
+        title_lines.append("")
+        title_height = len(title_lines)
+
+    # Calculate layout area
+    layout_width = face_width
+    layout_height = face_height - title_height
+
+    layout_output = _dispatch_layout(
+        face.layout,
+        executor,
+        all_variables,
+        layout_width,
+        layout_height,
+        gap=1,
+        background=face.authored_style.background if face.authored_style else None,
+        grid_columns=config.style.layout.grid.columns,
+    )
+
+    # Combine title and layout
+    output_lines = title_lines + [layout_output]
+
+    return "\n".join(output_lines)
+
+
+def render_layout_item_terminal(
+    item: LayoutItem,
+    executor: Executor,
+    variables: VariableValues,
+    available_width: int,
+    available_height: int,
+) -> str:
+    """Render a single layout item (chart or nested face) to terminal.
+
+    Args:
+        item: Layout item to render
+        executor: Executor for query execution
+        variables: Variable values for queries
+        available_width: Available terminal width in characters
+        available_height: Available terminal height in characters
+
+    Returns:
+        Terminal-formatted string for the item
+    """
+    if not evaluate_visible(item.visible, variables, executor):
+        return ""
+    if item.type == "chart" and item.chart:
+        return render_chart_item_terminal(
+            item.chart, executor, variables, available_width, available_height
+        )
+    elif item.type == "face" and item.face:
+        return render_nested_face_terminal(
+            item.face, executor, variables, available_width, available_height
+        )
+    return ""
+
+
+def render_chart_item_terminal(
+    chart: Chart,
+    executor: Executor,
+    variables: VariableValues,
+    available_width: int,
+    available_height: int,
+) -> str:
+    """Render a chart item to terminal.
+
+    Args:
+        chart: Chart to render
+        executor: Executor for query execution
+        variables: Variable values for queries
+        available_width: Available terminal width in characters
+        available_height: Available terminal height in characters
+
+    Returns:
+        Terminal-formatted chart string
+    """
+    try:
+        # Execute query to get data
+        data = executor.execute_chart(chart, variables)
+
+        # Resolve Jinja templates in chart title/label if present.
+        # KPI charts carry their authored text in ``label`` (the slot rendered
+        # above the headline value); every other chart type uses ``title``.
+        from dataface.core.compile.jinja import resolve_jinja_template
+
+        updates: dict[str, str] = {}
+        if chart.title:
+            updates["title"] = resolve_jinja_template(chart.title, variables)
+        if chart.label:
+            updates["label"] = resolve_jinja_template(chart.label, variables)
+        resolved_chart = chart.model_copy(update=updates) if updates else chart
+
+        # Render chart
+        from dataface.core.render.terminal_charts import render_chart_terminal
+
+        return render_chart_terminal(
+            resolved_chart,
+            data,
+            width=available_width,
+            height=available_height,
+            colors=True,
+        )
+
+    except (ValueError, KeyError, TypeError, AttributeError) as e:
+        # Render error message for chart rendering failures
+        error_msg = str(e)[:200]  # Show more of the error for debugging
+        return f"[Error rendering {chart.id}: {error_msg}]"
+
+
+def render_nested_face_terminal(
+    face: Face,
+    executor: Executor,
+    variables: VariableValues,
+    available_width: int,
+    available_height: int,
+) -> str:
+    """Render a nested face to terminal.
+
+    Args:
+        face: Face to render
+        executor: Executor for query execution
+        variables: Variable values for queries
+        available_width: Available terminal width in characters
+        available_height: Available terminal height in characters
+
+    Returns:
+        Terminal-formatted face string
+    """
+    from dataface.core.compile.config import get_config
+
+    config = get_config()
+
+    title_lines: list[str] = []
+    if face.title:
+        from dataface.core.compile.jinja import resolve_jinja_template
+
+        resolved_title = resolve_jinja_template(face.title, variables)
+        title_lines.append(f"─ {resolved_title} ─")
+        title_lines.append("")
+
+    title_height = len(title_lines)
+    layout_height = available_height - title_height
+
+    layout_output = _dispatch_layout(
+        face.layout,
+        executor,
+        variables,
+        available_width,
+        layout_height,
+        gap=1,
+        background=face.authored_style.background if face.authored_style else None,
+        grid_columns=config.style.layout.grid.columns,
+    )
+
+    return "\n".join(title_lines + [layout_output])