dataface 0.4.1.dev5__py3-none-any.whl → 0.4.1.dev32__py3-none-any.whl

dataface/DATAFACE_SYNTAX.md

@@ -957,6 +957,18 @@ WHERE plan IN ({{ plans | map('tojson') | join(', ') }})
 WHERE {{ filter('plan', plans) }}
 ```
 
+**Numeric arithmetic antipattern** — `{{ n | int }}` and `{{ n | float }}` raise an error on parameterized variables. Jinja's `| int` filter calls `int(value)` internally; on a parameterized variable this would silently return 0, so Dataface rejects it instead. Write SQL arithmetic directly on the variable:
+
+```sql
+-- WRONG: raises ERR-JINJA-ERROR at render time
+INTERVAL -({{ months | int - 1 }}) MONTH
+
+-- CORRECT: {{ months }} emits the bound parameter; the database handles arithmetic
+INTERVAL -({{ months }} - 1) MONTH
+```
+
+In a direct query (no `{{ queries.X }}` references), `{{ n }}` emits a bound parameter (`$1`, `%s`, `?` depending on dialect). In a composed query (one using `{{ queries.X }}`), variables are resolved as literals before the parameterization pass — `{{ n }}` with `n: 3` becomes the literal `3`. In both cases, `{{ n | int }}` and `{{ n | float }}` raise — so adding or removing a `{{ queries.X }}` reference cannot change the value a filter expression produces. Arithmetic, casting, and type coercion belong in the SQL expression around the variable, not in a Jinja filter.
+
 Common mistakes (the validator rejects these — listed here so authors don't hit them):
 
 - `options.values: [...]` → use `options.static: [...]`.

dataface/agent_api/docs/yaml-reference.md

@@ -1177,13 +1177,10 @@ Authored overlay for VariablesStyle. Variable controls chrome styling.
 | `label` | [VariablesLabelStyle](#variableslabelstyle) | ✓ | Variable label typography. |
 | `value` | [VariablesValueStyle](#variablesvaluestyle) | ✓ | Variable value typography. |
 | `placeholder` | [VariablesPlaceholderStyle](#variablesplaceholderstyle) | ✓ | Style for unselected/hint text in variable inputs. |
-| `padding` | float | ✓ | Outer padding around the variables panel in pixels. |
 | `container_height` | float | ✓ | Height of the variables panel container in pixels. |
-| `container_padding` | float | ✓ | Inner padding of the variables panel container in pixels. |
 | `border` | [BorderStyle](#borderstyle) | ✓ | Variables panel border style. |
 | `control_gap` | float | ✓ | Gap between label and input within a single control in pixels. |
 | `input` | [InputStyle](#inputstyle) | ✓ | Input control style. |
-| `popover_rail_background` | str | ✓ | Background color for the preset rail (left column) inside the daterange chip's popover. Typically the theme's `surface-subtle` step — gray-50 on white-canvas themes, a cream-toned light on warm-canvas themes. Distinct from the popover card itself, which is always white-equivalent. |
 
 <a id="pagestyle"></a>
 ## PageStyle
@@ -2076,7 +2073,6 @@ Authored overlay for VariablesValueStyle. Per-value font substyle for variable c
 | Field | Type | Optional | Description |
 |-------|------|:--------:|-------------|
 | `font` | [FontStyle](#fontstyle) | ✓ | Variable value font style overrides. Unset fields fall back to [`style.variables.font`](#variablesstyle). |
-| `numeric_variant` | enum: "normal", "tabular-nums" | ✓ | OpenType numeric feature for value displays ('normal' or 'tabular-nums'). |
 
 <a id="variablesplaceholderstyle"></a>
 ## VariablesPlaceholderStyle

dataface/ai/skills/dashboard-pack-scaffolding/SKILL.md

@@ -153,7 +153,7 @@ in queries.
 dft serve
 ```
 
-Visit a landing page (e.g. `http://localhost:8080/zendesk/`) and click one of
+Visit a landing page (e.g. `http://localhost:8001/zendesk/`) and click one of
 the data links. It should redirect to the authored face. If it serves the
 generic system view instead, the alias is not set — check the face file.
 

dataface/cli/_error_format.py

@@ -15,6 +15,7 @@ not from a caller-supplied flag.
 from __future__ import annotations
 
 import json
+import sys
 from pathlib import Path
 
 from rich.markup import escape
@@ -50,25 +51,28 @@ def print_error(message: str) -> None:
         console.print(f"[bold red]Error:[/] {message}")
 
 
+def emit_diagnostics_jsonl(diags: list[Diagnostic]) -> None:
+    """Write diagnostics as JSON Lines to stderr — one compact JSON object per line.
+
+    Callers use this for the ``--diagnostics-json`` path: every diagnostic
+    (error or warning) is emitted to stderr so stdout stays the render payload,
+    and line-delimited JSON survives a truncated read with whole objects intact.
+    """
+    for d in diags:
+        print(json.dumps(d.model_dump(exclude_none=True)), file=sys.stderr)
+
+
 def print_diagnostics(
     diags: list[Diagnostic],
     *,
-    json_output: bool = False,
     path: Path | None = None,
 ) -> None:
-    """Print Diagnostics as Rich panels (stderr) or JSON (stdout).
+    """Print Diagnostics as Rich panels to stderr.
 
     `path` is a fallback "At:" location used only when a diagnostic has no
     `range` of its own (e.g. compile-time warnings that don't carry position
     data yet).
     """
-    if json_output:
-        print(
-            json.dumps(
-                {"errors": [d.model_dump(exclude_none=True) for d in diags]}, indent=2
-            )
-        )
-        return
     console = dft_console(stderr=True)
     for d in diags:
         style = "red" if d.level == "error" else "yellow"

dataface/cli/commands/render.py

@@ -10,7 +10,7 @@ from typing import TYPE_CHECKING
 import typer
 
 from dataface.agent_api import Diagnostic, RenderFormat
-from dataface.cli._error_format import print_diagnostics
+from dataface.cli._error_format import emit_diagnostics_jsonl, print_diagnostics
 from dataface.cli._project import with_project
 from dataface.cli.filesystem_project import FilesystemProject
 
@@ -119,6 +119,7 @@ def _emit_result(
     no_warnings: bool,
     fail_on_chart_errors: bool,
     print0: bool,
+    diagnostics_json: bool = False,
 ) -> str | None:
     """Turn a completed render into terminal/file output, or raise RenderFailed.
 
@@ -136,7 +137,11 @@ def _emit_result(
     if fail_on_chart_errors and result.chart_errors:
         raise RenderFailed(result.chart_errors)
 
-    if not no_warnings:
+    if diagnostics_json:
+        all_diags = list(result.warnings) + list(result.chart_errors)
+        if all_diags:
+            emit_diagnostics_jsonl(all_diags)
+    elif not no_warnings:
         _print_warnings(result.warnings)
 
     if format in ("json", "data"):
@@ -173,6 +178,7 @@ def render_command(
     max_workers: int | None = None,
     print0: bool = False,
     chart: str | None = None,
+    diagnostics_json: bool = False,
     *,
     project: FilesystemProject,
 ) -> str | None:
@@ -258,6 +264,7 @@ def render_command(
         no_warnings=no_warnings,
         fail_on_chart_errors=fail_on_chart_errors,
         print0=print0,
+        diagnostics_json=diagnostics_json,
     )
 
 
@@ -269,7 +276,7 @@ def render_command_from_yaml(
     variables: dict[str, str] | None = None,
     use_cache: bool = True,
     cache_path: Path | None = None,
-    json_errors: bool = False,
+    diagnostics_json: bool = False,
     no_warnings: bool = False,
     ignore_codes: set[str] | None = None,
     fail_on_chart_errors: bool = True,
@@ -296,7 +303,8 @@ def render_command_from_yaml(
             if absent), overriding project config. None (the default) falls
             through to the project's dataface.yml cache: block (path: null
             there means the zero-config in-memory default).
-        json_errors: Emit errors as JSON to stdout instead of Rich panels to stderr
+        diagnostics_json: Emit all diagnostics (errors and warnings) as JSON Lines
+            to stderr. Stdout stays the render payload on success.
         no_warnings: Suppress stderr warning output (warnings still appear in JSON)
         ignore_codes: Warning codes to suppress via the partition seam
         fail_on_chart_errors: Exit 1 when any per-chart runtime error exists
@@ -354,9 +362,14 @@ def render_command_from_yaml(
             no_warnings=no_warnings,
             fail_on_chart_errors=fail_on_chart_errors,
             print0=print0,
+            diagnostics_json=diagnostics_json,
         )
     except RenderFailed as exc:
-        print_diagnostics(exc.errors, json_output=json_errors)
+        if exc.errors:
+            if diagnostics_json:
+                emit_diagnostics_jsonl(exc.errors)
+            else:
+                print_diagnostics(exc.errors)
         raise typer.Exit(1) from exc
 
 
@@ -436,7 +449,7 @@ def render_commands(
     variables: dict[str, str] | None = None,
     use_cache: bool = True,
     cache_path: Path | None = None,
-    json_errors: bool = False,
+    diagnostics_json: bool = False,
     no_warnings: bool = False,
     ignore_codes: set[str] | None = None,
     fail_on_chart_errors: bool = True,
@@ -491,9 +504,14 @@ def render_commands(
                 max_workers=max_workers,
                 print0=print0,
                 chart=chart,
+                diagnostics_json=diagnostics_json,
             )
         except RenderFailed as exc:
-            print_diagnostics(exc.errors, json_output=json_errors)
+            if exc.errors:
+                if diagnostics_json:
+                    emit_diagnostics_jsonl(exc.errors)
+                else:
+                    print_diagnostics(exc.errors)
             has_failure = True
             if fail_fast:
                 raise typer.Exit(1) from exc

dataface/cli/main.py

@@ -718,14 +718,14 @@ def render(
             ),
         ),
     ] = None,
-    json_errors: Annotated[
+    diagnostics_json: Annotated[
         bool,
         typer.Option(
-            "--json-errors",
+            "--diagnostics-json",
             help=(
-                "Emit errors as JSON to stdout instead of formatted panels. "
-                "Only affects the error path; the success-path output is "
-                "still controlled by --format."
+                "Emit all diagnostics (errors and warnings) as JSON Lines to stderr. "
+                "Stdout stays the render payload on success; stderr carries "
+                "one compact JSON object per diagnostic, line-delimited."
             ),
         ),
     ] = False,
@@ -830,7 +830,7 @@ def render(
       dft render faces/sales.yml --format terminal
       dft render faces/sales.yml --no-cache
       dft render faces/sales.yml --cache renders.duckdb
-      dft render faces/sales.yml --json-errors
+      dft render faces/sales.yml --diagnostics-json
       dft render faces/sales.yml --no-warnings
       dft render faces/sales.yml --ignore-warning WARN-REDUNDANT-ENCODING
       dft render faces/sales.yml --allow-chart-errors
@@ -891,7 +891,7 @@ def render(
             variables=variables or None,
             use_cache=use_cache,
             cache_path=cache,
-            json_errors=json_errors,
+            diagnostics_json=diagnostics_json,
             no_warnings=no_warnings,
             ignore_codes=ignore_codes,
             fail_on_chart_errors=fail_on_chart_errors,
@@ -909,7 +909,7 @@ def render(
         variables=variables or None,
         use_cache=use_cache,
         cache_path=cache,
-        json_errors=json_errors,
+        diagnostics_json=diagnostics_json,
         no_warnings=no_warnings,
         ignore_codes=ignore_codes,
         fail_on_chart_errors=fail_on_chart_errors,

dataface/core/compile/chart_focus.py

@@ -42,6 +42,7 @@ from dataface.core.compile.models.face.normalized import (
     Layout,
     LayoutItem,
 )
+from dataface.core.compile.sizing import chart_slot_width
 
 
 def focus_on_chart(face: Face, chart_id: str) -> Face:
@@ -50,6 +51,9 @@ def focus_on_chart(face: Face, chart_id: str) -> Face:
     Creates a new face with:
     - Only the specified chart in the layout
     - Only the variables that chart depends on
+    - The chart pinned at the slot width the dashboard layout assigned it,
+      so the focused render is geometry-identical to the dashboard (WYSIWYG);
+      a chart not placed in the layout keeps its preferred width
     - All sources and queries unchanged (they're lazy-loaded anyway)
 
     This is called automatically when `chart_focus` is set in the YAML.
@@ -88,8 +92,15 @@ def focus_on_chart(face: Face, chart_id: str) -> Face:
         if name in chart.variable_dependencies
     }
 
-    # Create a simple layout with just this chart
-    chart_item = LayoutItem(type="chart", chart=chart)
+    # Pin the dashboard slot width so the focused chart keeps the exact
+    # geometry it had on the board (band widths, axis-label fit). The board
+    # container hugs the pinned width the same way it hugs preferred widths.
+    slot_width = chart_slot_width(face, chart_id)
+    chart_item = LayoutItem(
+        type="chart",
+        chart=chart,
+        user_width=None if slot_width is None else f"{slot_width}px",
+    )
     simple_layout = Layout(type=LayoutType.ROWS, items=[chart_item])
 
     # Create new face with focused content

dataface/core/compile/jinja.py

@@ -48,6 +48,7 @@ from jinja2 import (
 
 from dataface.core.compile._jinja_helpers import _LenientUndefined, _QueryNamespace
 from dataface.core.compile.errors import CompilationError, JinjaError
+from dataface.core.compile.parameterized import _LiteralCollector, _ParameterizedValue
 
 logger = logging.getLogger(__name__)
 
@@ -554,10 +555,25 @@ def resolve_query_sql_with_dependencies(
     # Phase 2: resolve variables via Jinja. filter()/filter_date_range() calls
     # are deferred (left verbatim) so they reach the SQL adapter's parameterized
     # pass instead of the raising compile-time stub — see resolve_jinja_template.
+    #
+    # Variables are wrapped in _ParameterizedValue with a _LiteralCollector so
+    # that {{ n }} still inlines as a literal (the reference-path contract) while
+    # {{ n | int }} / {{ n | float }} raise — matching the direct-path behavior
+    # and preventing silent value changes when {{ queries.X }} refs are added or
+    # removed. Using the same wrapper class as the direct path ensures equality,
+    # membership, and iteration operators delegate correctly to the raw value.
     if target_sql and ("{{" in target_sql or "{%" in target_sql):
-        target_sql = resolve_jinja_template(
-            target_sql, variables=variables, defer_filters=True
-        )
+        _collector = _LiteralCollector()
+        guarded_vars = {
+            name: _ParameterizedValue(name, val, _collector)
+            for name, val in (variables.items() if variables else ())
+        }
+        try:
+            target_sql = resolve_jinja_template(
+                target_sql, variables=guarded_vars, defer_filters=True
+            )
+        except (TypeError, KeyError) as e:
+            raise JinjaError(f"Template error: {e}", target_sql) from e
 
     return target_sql
 

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

@@ -64,7 +64,6 @@ from ._conditional_formatting import (
     ConditionalRule,
     FieldConditionalFormatting,
     _PredicateBase,
-    coerce_numeric,
     match_predicate,
 )
 from ._data_table import (
@@ -211,7 +210,6 @@ __all__ = [
     "FieldConditionalFormatting",
     "_PREDICATE_OPS",
     "_PredicateBase",
-    "coerce_numeric",
     "match_predicate",
     # data_table
     "CHART_DATA_TABLE_SUPPORTED_TYPES",

dataface/core/compile/models/chart/authored/_conditional_formatting.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import math
 from typing import Any, Literal
 
 from pydantic import (
@@ -20,6 +19,7 @@ from dataface.core.compile.models.style.theme import (
     VALID_FONT_WEIGHTS,
     font_weight_as_css,
 )
+from dataface.core.utils import coerce_numeric_cell
 
 
 class _PredicateBase(BaseModel):
@@ -120,22 +120,6 @@ def _validate_exactly_one_predicate(obj: Any) -> None:
         )
 
 
-def coerce_numeric(v: Any) -> float | None:
-    """Return float(v) for finite numeric-compatible values; None otherwise."""
-    if v is None or isinstance(v, bool):
-        return None
-    if isinstance(v, (int, float)):
-        result = float(v)
-        return result if math.isfinite(result) else None
-    if isinstance(v, str):
-        try:
-            result = float(v)
-            return result if math.isfinite(result) else None
-        except (ValueError, TypeError):
-            return None
-    return None
-
-
 def _in_value_matches(candidate: Any, value: Any) -> bool:
     """Equality check for a single ``in`` candidate, with the bool/int guard."""
     if isinstance(value, bool) != isinstance(candidate, bool):
@@ -159,7 +143,7 @@ def match_predicate(rule: _PredicateBase, value: Any) -> bool:
         return value != rule.ne
     if rule.in_ is not None:
         return any(_in_value_matches(candidate, value) for candidate in rule.in_)
-    v_coerced = coerce_numeric(value)
+    v_coerced = coerce_numeric_cell(value)
     if v_coerced is None:
         return False
     v = v_coerced

dataface/core/compile/models/style/theme/variables.py

@@ -40,10 +40,6 @@ class VariablesValueStyle(BaseModel):
         default_factory=FontStyle,
         description="Variable value font style overrides.",
     )
-    # OpenType numeric feature for slider, number, and date-range value displays.
-    numeric_variant: Literal["normal", "tabular-nums"] = Field(
-        description="OpenType numeric feature for value displays ('normal' or 'tabular-nums')."
-    )
 
 
 class VariablesPlaceholderStyle(BaseModel):
@@ -107,26 +103,11 @@ class VariablesStyle(BaseModel):
     placeholder: VariablesPlaceholderStyle = Field(
         description="Style for unselected/hint text in variable inputs."
     )
-    padding: float = Field(
-        description="Outer padding around the variables panel in pixels."
-    )
     container_height: float = Field(
         description="Height of the variables panel container in pixels."
     )
-    container_padding: float = Field(
-        description="Inner padding of the variables panel container in pixels."
-    )
     border: BorderStyle = Field(description="Variables panel border style.")
     control_gap: float = Field(
         description="Gap between label and input within a single control in pixels."
     )
     input: InputStyle = Field(description="Input control style.")
-    popover_rail_background: str = Field(
-        description=(
-            "Background color for the preset rail (left column) inside the "
-            "daterange chip's popover. Typically the theme's `surface-subtle` "
-            "step — gray-50 on white-canvas themes, a cream-toned light on "
-            "warm-canvas themes. Distinct from the popover card itself, which "
-            "is always white-equivalent."
-        )
-    )

dataface/core/compile/parameterized.py

@@ -209,13 +209,27 @@ class _NullValue:
         return not self.__eq__(other)
 
 
+class _LiteralCollector:
+    """Passthrough collector for _ParameterizedValue on the Phase-2 composed-query path.
+
+    Variables on this path inline as literal SQL (the reference-path contract): {{ n }}
+    becomes the raw value, not a $N parameter.  Returning "NULL" for None matches
+    the _NullValue behavior on the direct parameterized path.
+    """
+
+    def get_param(self, name: str, value: Any) -> str:
+        return "NULL" if value is None else str(value)
+
+
 class _ParameterizedValue:
     """Wrapper for parameterized variable values.
 
     When rendered by Jinja, returns the parameter placeholder.
     """
 
-    def __init__(self, name: str, value: Any, collector: _ParameterCollector):
+    def __init__(
+        self, name: str, value: Any, collector: _ParameterCollector | _LiteralCollector
+    ):
         self._name = name
         self._value = value
         self._collector = collector
@@ -247,6 +261,50 @@ class _ParameterizedValue:
             return self._value[key]
         raise TypeError(f"'{type(self._value).__name__}' is not subscriptable")
 
+    def __int__(self) -> int:
+        # Jinja's | int filter calls int(value) and catches TypeError, returning
+        # 0 on failure — so without this override the filter silently emits 0.
+        # Raising here bypasses that swallowing and surfaces the error.
+        if isinstance(self._collector, _LiteralCollector):
+            raise JinjaError(
+                f"Variable '{self._name}': the '| int' filter cannot coerce a face "
+                f"variable in a composed query — it would silently return 0. "
+                f"Use SQL arithmetic directly: {{{{ {self._name} }}}} - 1 inlines "
+                f"the value minus 1."
+            )
+        raise JinjaError(
+            f"Variable '{self._name}': the '| int' filter cannot coerce a parameterized "
+            f"variable — it would silently return 0. Use SQL arithmetic on the variable "
+            f"directly instead: {{{{ {self._name} }}}} - 1 emits $N - 1 where $N is "
+            f"the bound parameter (e.g. INTERVAL -({{{{ {self._name} }}}} - 1) MONTH)."
+        )
+
+    def __index__(self) -> int:
+        if isinstance(self._collector, _LiteralCollector):
+            raise JinjaError(
+                f"Variable '{self._name}': integer index conversion is not supported "
+                f"on face variables in a composed query."
+            )
+        raise JinjaError(
+            f"Variable '{self._name}': integer index conversion is not supported "
+            f"on parameterized variables. Use SQL arithmetic on the variable "
+            f"directly instead: {{{{ {self._name} }}}} - 1 emits the bound parameter "
+            f"minus 1."
+        )
+
+    def __float__(self) -> float:
+        if isinstance(self._collector, _LiteralCollector):
+            raise JinjaError(
+                f"Variable '{self._name}': the '| float' filter cannot coerce a face "
+                f"variable in a composed query — it would silently return 0.0. "
+                f"Use SQL arithmetic directly: {{{{ {self._name} }}}} * 1.0 or cast in SQL."
+            )
+        raise JinjaError(
+            f"Variable '{self._name}': the '| float' filter cannot coerce a parameterized "
+            f"variable — it would silently return 0.0. Use SQL arithmetic on the variable "
+            f"directly instead: {{{{ {self._name} }}}} * 1.0 or cast in SQL."
+        )
+
 
 def _compute_template_hash(template: str) -> str:
     """Compute hash of template for caching.