dataface 0.1.2__py3-none-any.whl

dataface/core/execute/sql_guard.py

@@ -0,0 +1,387 @@
+"""SQL statement-type guard for dft-core.
+
+Two public validators:
+  validate_select_only(sql, dialect=None)  — read-only queries only
+  validate_setup_sql(sql, dialect=None)    — TEMP CREATE + DuckDB MACRO only
+
+Both raise MutatingSqlError on policy violation, UnparseableSqlError when
+the SQL skeleton cannot be statically determined (Jinja shapes we don't model,
+or sqlglot parse failure). Callers decide what to do with each error type.
+
+The approach:
+1. Build a SQL skeleton from the Jinja AST: TemplateData verbatim, {{ expr }}
+   as placeholder identifiers, {% if %}/{% for %}/{% set %} walked structurally
+   so both branches of if are included (catching malicious-branch injection).
+   Unknown node types raise UnparseableSqlError (default-deny).
+2. Strip a leading EXPLAIN / EXPLAIN ANALYZE keyword — sqlglot opaquely wraps
+   `EXPLAIN <anything>` as a Command node, so the inner statement is invisible
+   to AST allowlist checks. Strip-and-revalidate forces the inner body through
+   the same gate, so `EXPLAIN DROP TABLE x` fails like the bare DROP would.
+3. sqlglot.parse(skeleton, read=dialect) to get top-level statements.
+4. Walk statements against the function's allowlist, then scan descendants for
+   mutating-statement types so CTE-laundered DML (`WITH x AS (DELETE …) SELECT
+   * FROM x`) is rejected.
+"""
+
+from __future__ import annotations
+
+import re
+
+import jinja2
+import jinja2.nodes
+import sqlglot
+import sqlglot.errors
+import sqlglot.expressions as exp
+
+from dataface.core.execute.errors import MutatingSqlError, UnparseableSqlError
+
+# Dataface dialect names → sqlglot dialect names. sqlglot calls SQL Server
+# "tsql"; we present it as "sqlserver"/"mssql". "mariadb" is an alias for
+# "mysql" in both. This is the canonical mapping for the guard; the wider
+# dataface.core.execute.dialects registry does not currently expose one.
+_DIALECT_MAP: dict[str, str] = {
+    "sqlserver": "tsql",
+    "mssql": "tsql",
+    "mariadb": "mysql",
+}
+
+
+def sqlglot_dialect(dialect: str | None) -> str | None:
+    """Translate a Dataface dialect name to the sqlglot equivalent.
+
+    sqlglot knows 'tsql' (not 'sqlserver'/'mssql') and 'mysql' (not 'mariadb').
+    Returns None unchanged (sqlglot default dialect).
+    """
+    if dialect is None:
+        return None
+    return _DIALECT_MAP.get(dialect, dialect)
+
+
+# Top-level statements allowed by validate_select_only. exp.Select is further
+# narrowed by an INTO-anywhere descendant scan below.
+_ALLOWED_QUERY_NODES: frozenset[type[exp.Expression]] = frozenset(
+    {
+        exp.Select,
+        exp.Subquery,
+        exp.Union,
+        exp.Intersect,
+        exp.Except,
+        exp.Describe,
+        exp.Show,
+    }
+)
+
+# Mutating statement types that must not appear anywhere in a SELECT-family
+# tree — including inside CTEs, subqueries, and UNION arms. The CTE-laundered
+# bypass shape `WITH x AS (DELETE … RETURNING *) SELECT * FROM x` parses as a
+# top-level Select with the DML buried as a descendant; descendant-scan closes
+# the gap. Top-level type-allowlist would otherwise admit the outer Select.
+_DISALLOWED_DESCENDANT_NODES: tuple[type[exp.Expression], ...] = (
+    exp.Insert,
+    exp.Update,
+    exp.Delete,
+    exp.Merge,
+    exp.Drop,
+    exp.Alter,
+    exp.TruncateTable,
+    exp.Create,
+    exp.Pragma,
+    exp.Grant,
+    exp.Attach,
+    exp.Detach,
+    # sqlglot has no exp.Revoke as of 26.x; REVOKE parses as a Command at the
+    # top level and is caught there. If a future sqlglot adds Revoke as a
+    # dedicated node, add it here so a buried REVOKE inside a CTE is caught.
+)
+
+_ALLOWED_SETUP_NODES: frozenset[type[exp.Expression]] = frozenset({exp.Create})
+
+
+# sqlglot models `EXPLAIN <stmt>` as an opaque Command — the inner statement
+# is invisible to the AST. Strip the EXPLAIN keyword (and common modifiers)
+# from the skeleton so the body re-parses through the normal allowlist and
+# `EXPLAIN DROP TABLE x` fails like the bare DROP would. Only the leading
+# EXPLAIN is stripped — a mid-stream `…; EXPLAIN …` parses as Command and
+# is rejected by the allowlist (acceptable fail-closed for an uncommon shape).
+_EXPLAIN_PREFIX_RE = re.compile(
+    r"^\s*EXPLAIN"
+    r"(?:\s+(?:ANALYZE|VERBOSE|QUERY\s+PLAN))*"
+    r"(?:\s*\([^)]*\))?"
+    r"\s+",
+    re.IGNORECASE,
+)
+
+
+def _strip_explain_prefix(skeleton: str) -> str:
+    return _EXPLAIN_PREFIX_RE.sub("", skeleton, count=1)
+
+
+# Databricks Delta Lake adds DETAIL / HISTORY variants to DESCRIBE that
+# sqlglot does not model — `DESCRIBE DETAIL my_table` fails to parse. Both
+# variants are read-only metadata reads (mirrors of Delta-log inspection).
+# Strip the variant keyword so the body re-parses as a standard exp.Describe.
+_DESCRIBE_VARIANT_PREFIX_RE = re.compile(
+    r"^\s*DESCRIBE\s+(?:DETAIL|HISTORY)\s+",
+    re.IGNORECASE,
+)
+
+
+def _strip_describe_variant_prefix(skeleton: str) -> str:
+    return _DESCRIBE_VARIANT_PREFIX_RE.sub("DESCRIBE ", skeleton, count=1)
+
+
+# Read-only commands sqlglot falls back to `Command` for on dialects that
+# lack a dedicated node (postgres / bigquery / redshift / databricks / default
+# all parse `SHOW TABLES` as `Command(name="SHOW")`). Terminal commands —
+# no inner statement to revalidate.
+_ALLOWED_TOP_LEVEL_COMMAND_KEYWORDS: frozenset[str] = frozenset({"SHOW"})
+
+
+def _is_allowed_top_level_command(stmt: exp.Expression) -> bool:
+    return (
+        isinstance(stmt, exp.Command)
+        and (stmt.name or "").upper() in _ALLOWED_TOP_LEVEL_COMMAND_KEYWORDS
+    )
+
+
+def _walk_jinja(node: jinja2.nodes.Node, out: list[str], counter: list[int]) -> None:
+    """Walk a jinja2 AST, appending SQL fragments to *out*.
+
+    counter is a one-element list used as a mutable int for placeholder naming.
+    Raises UnparseableSqlError for any node type outside the explicit table —
+    default-deny so AssignBlock / Macro / Include / extension nodes never
+    silently swallow embedded SQL.
+    """
+    if isinstance(node, jinja2.nodes.Template):
+        for child in node.body:
+            _walk_jinja(child, out, counter)
+
+    elif isinstance(node, jinja2.nodes.TemplateData):
+        out.append(node.data)
+
+    elif isinstance(node, jinja2.nodes.Output):
+        # Output interleaves TemplateData (literal SQL) and expression nodes
+        # ({{ ref('orders') }}, {{ var }}, …). Literals pass through; each
+        # expression becomes a placeholder identifier.
+        for child in node.nodes:
+            if isinstance(child, jinja2.nodes.TemplateData):
+                out.append(child.data)
+            else:
+                out.append(f"__dft_j{counter[0]}__")
+                counter[0] += 1
+
+    elif isinstance(node, jinja2.nodes.If):
+        # jinja2 represents elif_ as a flat list of If nodes (each with empty
+        # elif_), not a linked-list chain. Iterate every element so DROPs
+        # buried in the 2nd / 3rd elif slot are walked, not just the first.
+        for child in node.body:
+            _walk_jinja(child, out, counter)
+        for elif_node in node.elif_:
+            out.append(" ; ")
+            for child in elif_node.body:
+                _walk_jinja(child, out, counter)
+        if node.else_:
+            out.append(" ; ")
+            for child in node.else_:
+                _walk_jinja(child, out, counter)
+
+    elif isinstance(node, jinja2.nodes.For):
+        # Walk body once and the `else_` clause if present — jinja2 runs the
+        # else clause when the iterable is empty. Same branch-coverage posture
+        # as If: SQL hiding in the else branch must reach the skeleton.
+        for child in node.body:
+            _walk_jinja(child, out, counter)
+        if node.else_:
+            out.append(" ; ")
+            for child in node.else_:
+                _walk_jinja(child, out, counter)
+
+    elif isinstance(node, jinja2.nodes.Assign):
+        # {% set x = ... %} — emits nothing.
+        pass
+
+    else:
+        # AssignBlock ({% set sql %}...{% endset %}), Macro, Include, Import,
+        # FromImport, Extends, Block, FilterBlock, CallBlock, future jinja2
+        # additions — all default-deny. If AssignBlock fell through, the body's
+        # SQL would never reach the parser.
+        raise UnparseableSqlError(f"unsupported_jinja_node:{type(node).__name__}")
+
+
+def _build_skeleton(template_str: str) -> str:
+    """Return a SQL skeleton by walking the jinja2 AST.
+
+    TemplateData becomes literal SQL; `{{ expr }}` becomes a placeholder
+    identifier; `{% if %}` recurses all branches. Unknown jinja nodes raise
+    UnparseableSqlError so no SQL can hide inside them.
+    """
+    if "{{" not in template_str and "{%" not in template_str:
+        return template_str
+
+    env = jinja2.Environment()
+    try:
+        ast = env.parse(template_str)
+    except jinja2.TemplateSyntaxError as exc:
+        raise UnparseableSqlError(exc) from exc
+
+    out: list[str] = []
+    counter = [0]
+    _walk_jinja(ast, out, counter)
+    return "".join(out)
+
+
+def _parse(skeleton: str, dialect: str | None) -> list[exp.Expression | None]:
+    try:
+        return sqlglot.parse(skeleton, read=sqlglot_dialect(dialect))
+    except sqlglot.errors.ParseError as exc:
+        raise UnparseableSqlError(exc) from exc
+
+
+def _reject_mutating_descendants(
+    stmt: exp.Expression, allowlist_label: str = "query"
+) -> None:
+    """Scan stmt for mutating-statement descendants and raise on first hit.
+
+    Catches CTE-laundered DML (`WITH x AS (DELETE …) SELECT *`), DML inside
+    subqueries, DML inside UNION arms, and `SELECT … INTO` at any depth —
+    all of which would otherwise pass a top-level type-only check. Used by
+    both validate_select_only and validate_setup_sql; the latter passes
+    allowlist_label="setup" so the error message names the right policy.
+
+    sqlglot's find_all includes the calling node, so the outer Create on the
+    setup path would re-match itself — skip self explicitly. Nested CREATEs
+    inside `CREATE TEMP TABLE t AS (CREATE …)` still get rejected.
+    """
+    for desc in stmt.find_all(*_DISALLOWED_DESCENDANT_NODES):
+        if desc is stmt:
+            continue
+        raise MutatingSqlError(
+            rejected_node_kind=type(desc).__name__,
+            fragment_preview=desc.sql()[:60],
+            allowlist_label=allowlist_label,
+        )
+    for select in stmt.find_all(exp.Select):
+        if select.args.get("into") is not None:
+            raise MutatingSqlError(
+                rejected_node_kind="Select(into)",
+                fragment_preview=stmt.sql()[:60],
+                allowlist_label=allowlist_label,
+            )
+
+
+def _is_bq_temp_function_create(stmt: exp.Expression) -> bool:
+    """Return True iff stmt is a BigQuery-style CREATE TEMP FUNCTION.
+
+    Used by validate_select_only to permit the BigQuery scripting pattern
+    `CREATE TEMP FUNCTION ... ; SELECT ...`. Only FUNCTION kind is accepted;
+    CREATE TEMP TABLE and CREATE TEMP VIEW belong in validate_setup_sql, not
+    inline query scripts.
+    """
+    if not isinstance(stmt, exp.Create):
+        return False
+    kind = (stmt.args.get("kind") or "").upper()
+    if kind != "FUNCTION":
+        return False
+    props = stmt.args.get("properties")
+    return props is not None and any(
+        isinstance(p, exp.TemporaryProperty) for p in props.expressions
+    )
+
+
+def validate_select_only(sql: str, dialect: str | None = None) -> None:
+    """Raise MutatingSqlError on non-read-only SQL; UnparseableSqlError when undetermined.
+
+    Accepts: SELECT (no INTO), WITH, UNION, INTERSECT, EXCEPT, DESCRIBE, SHOW,
+    EXPLAIN of an allowed inner statement.
+    On BigQuery only: also accepts a script of one or more CREATE TEMP FUNCTION
+    statements followed by a final SELECT-family statement (inline scalar UDF
+    pattern from Looker-migrated dashboards).
+    Rejects: DROP, DELETE, INSERT, UPDATE, ALTER, GRANT, REVOKE, TRUNCATE,
+             ATTACH, LOAD, CALL, PRAGMA, CREATE, and any other mutating
+             statement — including DML hidden inside a CTE or subquery.
+
+    Args:
+        sql: Raw SQL string, possibly containing Jinja expressions.
+        dialect: sqlglot dialect name (e.g. "duckdb", "postgres"). None = default.
+    """
+    skeleton = _strip_describe_variant_prefix(
+        _strip_explain_prefix(_build_skeleton(sql))
+    )
+    statements = [
+        s
+        for s in _parse(skeleton, dialect)
+        if s is not None and not isinstance(s, exp.Semicolon)
+    ]
+
+    # BigQuery inline-UDF scripting pattern: one or more CREATE TEMP FUNCTION
+    # statements followed by a SELECT-family statement. This is a read-only
+    # pattern — the TEMP FUNCTIONs are ephemeral UDFs, not persistent DDL.
+    # Only allowed on the bigquery dialect; other dialects keep the full ban.
+    if dialect == "bigquery" and statements:
+        leading_temp_fns = [
+            s for s in statements[:-1] if _is_bq_temp_function_create(s)
+        ]
+        if leading_temp_fns and len(leading_temp_fns) == len(statements) - 1:
+            final = statements[-1]
+            # Validate the TEMP FUNCTION creates for buried DML.
+            for fn_stmt in leading_temp_fns:
+                _reject_mutating_descendants(fn_stmt)
+            # Validate the trailing statement as a normal query.
+            if type(final) in _ALLOWED_QUERY_NODES:
+                _reject_mutating_descendants(final)
+                return
+            if _is_allowed_top_level_command(final):
+                return
+            # Trailing statement is not a SELECT-family — fall through to
+            # per-statement validation which will reject it.
+
+    for stmt in statements:
+        if type(stmt) in _ALLOWED_QUERY_NODES:
+            _reject_mutating_descendants(stmt)
+            continue
+        if _is_allowed_top_level_command(stmt):
+            continue
+        raise MutatingSqlError(
+            rejected_node_kind=type(stmt).__name__,
+            fragment_preview=stmt.sql()[:60],
+        )
+
+
+def validate_setup_sql(sql: str, dialect: str | None = None) -> None:
+    """Raise MutatingSqlError on non-setup SQL; UnparseableSqlError when undetermined.
+
+    Accepts:
+      - CREATE TEMP FUNCTION/TABLE/VIEW (any dialect)
+      - CREATE [OR REPLACE] MACRO (DuckDB; no TEMP form exists)
+
+    Rejects everything else, including non-TEMP CREATE, DROP, INSERT, etc.
+    """
+    skeleton = _build_skeleton(sql)
+    for stmt in _parse(skeleton, dialect):
+        if stmt is None or isinstance(stmt, exp.Semicolon):
+            continue
+        if type(stmt) not in _ALLOWED_SETUP_NODES:
+            raise MutatingSqlError(
+                rejected_node_kind=type(stmt).__name__,
+                fragment_preview=stmt.sql()[:60],
+                allowlist_label="setup",
+            )
+        kind = (stmt.args.get("kind") or "").upper()
+        # sqlglot represents TEMP via TemporaryProperty in the properties list,
+        # not as args["temporary"] = True (that field is always None in practice).
+        props = stmt.args.get("properties")
+        is_temp = props is not None and any(
+            isinstance(p, exp.TemporaryProperty) for p in props.expressions
+        )
+        is_macro = kind == "MACRO"
+        is_allowed_temp_kind = kind in {"FUNCTION", "TABLE", "VIEW"}
+
+        if not (is_macro or (is_temp and is_allowed_temp_kind)):
+            raise MutatingSqlError(
+                rejected_node_kind=f"Create(kind={kind}, temporary={is_temp})",
+                fragment_preview=stmt.sql()[:60],
+                allowlist_label="setup",
+            )
+        # CTAS bodies can smuggle DML through CTEs or SELECT … INTO. Scan
+        # descendants the same way validate_select_only does.
+        _reject_mutating_descendants(stmt, allowlist_label="setup")

dataface/core/execute/sql_literals.py

@@ -0,0 +1,199 @@
+"""SQL literal inlining for dbt-adapter execution paths.
+
+dbt adapter.execute() accepts plain SQL only — no parameterized queries.
+This module provides functions for inlining positional $N params or named
+dialect-specific params as properly escaped SQL literals. Used by SqlAdapter
+and InspectConnection.
+
+Values passed here must come from validated sources (compiled dashboard YAML
+variables, or schema/table names from the inspector). Do not pass raw HTTP
+input through this function.
+"""
+
+import math
+import re
+from collections.abc import Callable
+from datetime import date, datetime, time
+from decimal import Decimal
+from typing import Any
+
+_DOLLAR_RE = re.compile(r"\$(\d+)")
+_PERCENT_S_RE = re.compile(r"%s")
+_QMARK_RE = re.compile(r"\?")
+
+
+def _to_sql_literal(value: Any) -> str:
+    """Convert a Python value to a SQL literal string."""
+    if value is None:
+        return "NULL"
+    if isinstance(value, bool):
+        return "TRUE" if value else "FALSE"
+    if isinstance(value, int):
+        return str(value)
+    if isinstance(value, float):
+        if math.isnan(value):
+            raise ValueError(
+                "NaN cannot be inlined as a SQL literal — different warehouses use "
+                "different syntax (FLOAT64 / DOUBLE / DOUBLE PRECISION / FLOAT). "
+                "Filter the value out before passing to inline_params, or pass a "
+                "string like 'NaN' if your warehouse supports it."
+            )
+        if math.isinf(value):
+            raise ValueError(
+                "Infinity cannot be inlined as a SQL literal — different warehouses "
+                "use different syntax. Filter the value out before passing to "
+                "inline_params, or pass a string."
+            )
+        return repr(value)
+    if isinstance(value, Decimal):
+        return str(value)
+    if isinstance(value, datetime):
+        return f"TIMESTAMP '{value.isoformat()}'"
+    if isinstance(value, date):
+        return f"DATE '{value.isoformat()}'"
+    if isinstance(value, time):
+        return f"TIME '{value.isoformat()}'"
+    if isinstance(value, bytes):
+        return f"X'{value.hex()}'"
+    # String — escape single quotes to prevent injection
+    escaped = str(value).replace("'", "''")
+    return f"'{escaped}'"
+
+
+def inline_params(sql: str, params: list[Any]) -> str:
+    """Inline $N-style positional params into a SQL string as SQL literals.
+
+    Replaces $1, $2, ... placeholders with properly escaped SQL literals.
+    Uses re.sub with a callback so each match position is visited exactly once —
+    substituted text is never re-scanned, preventing re-substitution attacks.
+
+    Args:
+        sql: SQL string with $1, $2, ... positional placeholders.
+        params: Ordered list of parameter values to inline.
+
+    Returns:
+        SQL string with all $N placeholders replaced by SQL literals.
+
+    Raises:
+        IndexError: A $N placeholder references an index outside [1, len(params)].
+    """
+
+    def repl(m: re.Match[str]) -> str:
+        idx = int(m.group(1)) - 1
+        if not 0 <= idx < len(params):
+            raise IndexError(
+                f"Parameter index ${m.group(1)} out of range "
+                f"for {len(params)} param(s)"
+            )
+        return _to_sql_literal(params[idx])
+
+    return _DOLLAR_RE.sub(repl, sql)
+
+
+def inline_dialect_params(
+    sql: str, params: list[Any], param_fn: Callable[[int], str]
+) -> str:
+    """Inline dialect-specific named params into SQL as SQL literals.
+
+    For dialects whose placeholder format is not `$N` (e.g., BigQuery's `@paramN`,
+    Databricks' `:param1`, SQL Server's `@p1`), replaces each placeholder with a
+    properly escaped SQL literal.
+
+    Uses a single-pass regex so substituted text is never re-scanned — a param
+    value that happens to contain another placeholder string is not re-substituted.
+
+    The dbt adapter.execute() accepts only plain SQL, so this function is used
+    when executing against named-param dialects via dbt adapters.
+
+    Args:
+        sql: SQL string with dialect-specific parameter placeholders.
+        params: Ordered list of parameter values (1-indexed by placeholder number).
+        param_fn: Callable(index: int) -> str — returns the placeholder string for
+            the given 1-based index. Pass the dialect's ``param`` method.
+
+    Returns:
+        SQL string with all dialect placeholders replaced by SQL literals.
+    """
+    if not params:
+        return sql
+
+    # Build a pattern that alternates all placeholders, sorted longest-first so
+    # @param10 is matched before @param1 when they share a common prefix.
+    placeholders = sorted(
+        (re.escape(param_fn(i)), i) for i in range(1, len(params) + 1)
+    )
+    # Sort by length descending to avoid partial-match of @param1 inside @param10
+    placeholders.sort(key=lambda t: len(t[0]), reverse=True)
+    idx_by_placeholder = dict(placeholders)
+    pattern = re.compile("|".join(ph for ph, _ in placeholders))
+
+    def repl(m: re.Match[str]) -> str:
+        ph = re.escape(m.group(0))
+        return _to_sql_literal(params[idx_by_placeholder[ph] - 1])
+
+    return pattern.sub(repl, sql)
+
+
+def inline_qmark_params(sql: str, params: list[Any]) -> str:
+    """Inline ?-style positional params into a SQL string as SQL literals.
+
+    Snowflake uses ? for positional parameters. Each ? is replaced in order
+    with the corresponding parameter value as a SQL literal.
+
+    Args:
+        sql: SQL string with ? positional placeholders.
+        params: Ordered list of parameter values to inline.
+
+    Returns:
+        SQL string with all ? placeholders replaced by SQL literals.
+
+    Raises:
+        ValueError: Param count does not match placeholder count.
+    """
+    n_placeholders = len(_QMARK_RE.findall(sql))
+    if len(params) != n_placeholders:
+        raise ValueError(
+            f"inline_qmark_params: {n_placeholders} ? placeholder(s) in SQL "
+            f"but {len(params)} param(s) provided"
+        )
+
+    it = iter(params)
+
+    def repl(m: re.Match[str]) -> str:
+        return _to_sql_literal(next(it))
+
+    return _QMARK_RE.sub(repl, sql)
+
+
+def inline_percent_params(sql: str, params: list[Any]) -> str:
+    """Inline %s-style positional params into a SQL string as SQL literals.
+
+    Used by InspectConnection where legacy code used %s placeholders for
+    schema/table name parameters that now need literal inlining via dbt adapters.
+    Uses re.sub with a callback so each match is visited exactly once —
+    substituted text is never re-scanned, preventing re-substitution attacks.
+
+    Args:
+        sql: SQL string with %s positional placeholders.
+        params: Ordered list of parameter values to inline. Count must match
+            exactly the number of %s placeholders — too few or too many raises.
+
+    Returns:
+        SQL string with all %s placeholders replaced by SQL literals.
+
+    Raises:
+        ValueError: Param count does not match placeholder count.
+    """
+    n_placeholders = len(_PERCENT_S_RE.findall(sql))
+    if len(params) != n_placeholders:
+        raise ValueError(
+            f"inline_percent_params: {n_placeholders} %s placeholder(s) in SQL "
+            f"but {len(params)} param(s) provided"
+        )
+
+    it = iter(params)
+
+    def repl(m: re.Match[str]) -> str:
+        return _to_sql_literal(next(it))
+
+    return _PERCENT_S_RE.sub(repl, sql)

dataface/core/fonts.py

@@ -0,0 +1,52 @@
+"""Shared font path accessors for compile and render layers."""
+
+from pathlib import Path
+
+
+def get_fonts_dir() -> Path:
+    """Return the directory holding every vendored font asset."""
+    return Path(__file__).parent / "render" / "fonts"
+
+
+def get_inter_font_path() -> Path:
+    """Return the vendored Inter variable font file."""
+    return get_fonts_dir() / "InterVariable.ttf"
+
+
+def get_dft_sans_tabular_font_path() -> Path:
+    """Return the vendored DFT Sans Tabular font file."""
+    return get_fonts_dir() / "DFTSansTabular-Regular.ttf"
+
+
+def get_dft_serif_oldstyle_tabular_font_path() -> Path:
+    """Return the vendored DFT Serif Oldstyle Tabular font file."""
+    return get_fonts_dir() / "DFTSerifOldstyleTabular-Regular.ttf"
+
+
+def get_dft_serif_oldstyle_proportional_font_path() -> Path:
+    """Return the vendored DFT Serif Oldstyle Proportional font file."""
+    return get_fonts_dir() / "DFTSerifOldstyleProportional-Regular.ttf"
+
+
+def get_source_serif_4_ttf_path() -> Path:
+    """Return the vendored Source Serif 4 TTF for ReportLab."""
+    return get_fonts_dir() / "SourceSerif4-Regular.ttf"
+
+
+NOTO_EMOJI_FONT_FAMILY = "Noto Emoji"
+NOTO_COLOR_EMOJI_FONT_FAMILY = "Noto Color Emoji"
+
+
+def get_noto_emoji_font_path() -> Path:
+    """Return the vendored Noto Emoji TTF for ReportLab and vl-convert."""
+    return get_fonts_dir() / "NotoEmoji-Regular.ttf"
+
+
+def get_noto_color_emoji_font_path() -> Path:
+    """Return the vendored Noto Color Emoji TTF for ReportLab and vl-convert."""
+    return get_fonts_dir() / "NotoColorEmoji-Regular.ttf"
+
+
+def get_mono_font_path() -> Path:
+    """Return the vendored monospace font used for strict code measurement."""
+    return get_fonts_dir() / "SourceCodePro-Regular.ttf"

dataface/core/inspect/__init__.py

@@ -0,0 +1,32 @@
+"""OSS inspect module — schema sources, resolver, search, and HTML templates.
+
+The profiler engine (TableInspector, detectors, cache I/O) lives in the
+private ``dataface-super-schema`` package. This module only contains the
+open-source components: DbtSchemaSource, LayeredSchemaResolver, schema
+search, and the HTML inspect templates.
+"""
+
+from dataface.core.inspect.renderer import (
+    InspectProfileCompileError,
+    render_inspect_dashboard,
+    validate_inspect_variables,
+)
+
+# Static list of available inspect templates.
+# Template files live in dataface/core/inspect/templates/{name}.yml
+INSPECT_TEMPLATES: list[str] = [
+    "categorical_column",
+    "charts",
+    "date_column",
+    "model",
+    "numeric_column",
+    "quality",
+    "string_column",
+]
+
+__all__ = [
+    "render_inspect_dashboard",
+    "InspectProfileCompileError",
+    "validate_inspect_variables",
+    "INSPECT_TEMPLATES",
+]