dataface 0.1.5.dev206__py3-none-any.whl → 0.1.5.dev237__py3-none-any.whl

dataface/DATAFACE_SYNTAX.md

@@ -206,15 +206,20 @@ chart_focus: revenue_trend     # Render only one chart with its dependent variab
 details: "Click to expand"     # Collapsible section
 expanded_title: "Hide details"
 expanded: false
+
+aliases:                       # Additional URLs that 302-redirect to this face
+  - /old-reports/
+  - /legacy/sales/
 ```
 
-Top-level fields (23 total):
+Top-level fields (24 total):
 
 | Field | Type | Notes |
 |-------|------|-------|
 | `title` | string | Display title |
 | `description` | string | Description text |
 | `tags` | list[string] | Tags for categorization/search |
+| `aliases` | list[string] | See [Aliases](#aliases) below |
 | `text` | string | Markdown body for text-only faces |
 | `source` | string | Default source shorthand (equivalent to `sources.default`) |
 | `sources` | object | `{default: name, <name>: {type: ...}}` |
@@ -238,6 +243,27 @@ Top-level fields (23 total):
 
 `face:` as a top-level key is rejected. Put face properties (title, rows, queries, …) directly at the YAML root.
 
+### Aliases
+
+`aliases:` is a list of absolute URL paths that 302-redirect to this face's canonical file-path URL.  Each entry must start with `/`; trailing slashes are normalized automatically.
+
+```yaml
+aliases:
+  - /old-reports/
+  - /legacy/sales/
+```
+
+Rules:
+- An alias must not collide with a real face file path — the server raises an error at startup if it does.
+- Each alias must be unique across the project — two faces claiming the same alias is a startup error.
+- Aliasing a generated system route (entity or inspector view) is allowed: the redirect takes precedence, letting you override what that URL serves.
+
+There are two ways to override an entity/inspector route for a given path:
+- **Face file at that path** — create `faces/entity/warehouse/schema/table.yml` and the server renders it directly (no redirect).
+- **`aliases:` entry** — any face can declare `/entity/…/` as an alias; the server issues a 302 to the declaring face's canonical URL.
+
+Both approaches work.  A face file wins without a redirect round-trip; an alias lets a face live anywhere and still capture a system-view URL.
+
 ### Board style
 
 `style:` on a face, nested face, or layout section accepts a fixed set of keys — not arbitrary CSS:
@@ -346,7 +372,7 @@ queries:
       - [Bob, 87.1]
 ```
 
-Query types (`type:` literals): `sql`, `csv`, `http`, `dbt_model`, `metricflow`, `values`. `schema_resolver` is internal-only and not part of the authored surface.
+Query types (`type:` literals): `sql`, `csv`, `http`, `dbt_model`, `metricflow`, `values`. `schema` is internal-only and not part of the authored surface.
 
 Common fields (all query types):
 

dataface/agent_api/__init__.py

@@ -53,8 +53,20 @@ from dataface.agent_api.init import (
 )
 from dataface.agent_api.project import Project as Project
 from dataface.agent_api.query import QueryFaceResult, query_face
+from dataface.agent_api.schema_hints import (
+    SchemaHints as SchemaHints,
+    schema_hints as schema_hints,
+)
 from dataface.agent_api.validate import ValidateDashboardArgs, ValidateResult
+from dataface.agent_api.validate_query import (
+    QueryDiagnostic as QueryDiagnostic,
+    validate_query as validate_query,
+)
 from dataface.core.compile.config import ProjectSourcesConfig as ProjectSourcesConfig
+from dataface.core.errors.structured import StructuredError as StructuredError
+from dataface.core.fonts import get_inter_font_path as get_inter_font_path
+from dataface.core.render.board_links import LinkContext as LinkContext
+from dataface.core.render.errors import RenderError as RenderError
 
 __all__ = [
     "DescribeFaceArgs",
@@ -63,15 +75,23 @@ __all__ = [
     "DocsResult",
     "DocsSearchHit",
     "InitResult",
+    "LinkContext",
     "Project",
     "ProjectSourcesConfig",
+    "QueryDiagnostic",
     "QueryFaceResult",
     "RenderedDashboard",
+    "RenderError",
+    "SchemaHints",
+    "StructuredError",
     "Topic",
     "ValidateDashboardArgs",
     "ValidateResult",
     "describe_face",
+    "get_inter_font_path",
     "init_project",
     "query_face",
     "render_dashboard",
+    "schema_hints",
+    "validate_query",
 ]

dataface/agent_api/docs/yaml-reference.md

@@ -9,6 +9,7 @@ AuthoredFace (dataface) definition from YAML.
 | `title` | str | ✓ | Dashboard title displayed at the top. |
 | `description` | str | ✓ | Description text for the dashboard. |
 | `tags` | list[str] | ✓ | Tags for categorization and search. |
+| `aliases` | list[str] | ✓ | Additional URLs that redirect to this face's canonical file-path URL. Each entry must be absolute (leading /). Requests to these URLs are redirected (302) to the face's real path, query string preserved. Valid on .yml, .yaml, .md, and folder index.* faces. |
 | `docs` | str | ✓ | Relative path under the docs site for the canonical doc page that explains this face. Surfaced as a 'Docs →' link in the playground gallery when DFT_DOCS_URL is set. |
 | `text` | str | ✓ | Markdown text content for text-only sections. |
 | `allow_html` | bool | ✓ | Render the face's body text as raw HTML via foreignObject instead of markdown. TRUSTED-CONTENT ONLY: the HTML (including any Jinja-interpolated values) is rendered as-authored — this is NOT a security sandbox. mdsvg strips <script>/event-handlers as a best-effort guard, not a guarantee. Enable only on first-party faces you fully control. |
@@ -72,7 +73,7 @@ AuthoredQuery definition from YAML.
 
 | Field | Type | Optional | Description |
 |-------|------|:--------:|-------------|
-| `type` | enum: "sql", "metricflow", "dbt_model", "http", "csv", "values", "schema_resolver" | ✓ | Query adapter type. Defaults to 'sql'. Options: sql, metricflow, dbt_model, http, csv, values, schema_resolver. |
+| `type` | enum: "sql", "metricflow", "dbt_model", "http", "csv", "values", "schema" | ✓ | Query adapter type. Defaults to 'sql'. Options: sql, metricflow, dbt_model, http, csv, values, schema. |
 | `source` | str \| dict[str, Any] | ✓ | Database source reference (name string) or inline source config dict. |
 | `target` | str | ✓ | dbt target name for dbt_model queries (defaults to 'dev'). |
 | `sql` | str | ✓ | SQL query string. Supports Jinja2 templates referencing variables. |
@@ -92,9 +93,9 @@ AuthoredQuery definition from YAML.
 | `filter` | dict[str, Any] | ✓ | Row-level filter applied to CSV or values data. |
 | `delimiter` | str | ✓ | Column delimiter for CSV queries. Default: comma (','). |
 | `encoding` | str | ✓ | File encoding for CSV queries. Default: UTF-8. |
-| `schema` | str | ✓ | Schema name for schema_resolver queries (YAML key: schema). |
-| `table` | str | ✓ | Table name for schema_resolver queries. |
-| `column` | str | ✓ | Column name for schema_resolver queries. |
+| `schema` | str | ✓ | Schema name for schema queries (YAML key: schema). |
+| `table` | str | ✓ | Table name for schema queries. |
+| `column` | str | ✓ | Column name for schema queries. |
 | `rows` | list[dict[str, Any]] | ✓ | Inline data rows for values-type queries (list of row dicts). |
 | `values` | list[list[Any]] | ✓ | Inline column-oriented data for values-type queries (list of lists). |
 | `description` | str | ✓ | Human-readable description of the query. Used by AI search and tooling. |

dataface/agent_api/entity_paths.py

@@ -0,0 +1,221 @@
+"""Entity URL surfacing and alias typo lint.
+
+Provides:
+- EntityPathInfo: the agent-facing wire shape for a canonical entity URL
+  (url, resolves_to: "generic" | "authored", face)
+- entity_paths_for_source/schema/table: compute entity URLs and check the
+  alias index to determine whether a face overrides the generic system view
+- entity_paths_list: flat list of EntityPathInfo (source + schema + table level)
+  from a SchemaResponse — used for --entity-paths CLI flag and agent discovery
+- validate_entity_aliases: typo lint for /entity/ prefixed aliases — checks
+  source names only (config only, no DB connection required).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Literal
+
+if TYPE_CHECKING:
+    from dataface.agent_api.schema import SchemaResponse
+    from dataface.core.serve.alias_index import AliasIndex
+
+
+@dataclass
+class EntityPathInfo:
+    """Canonical entity URL with resolution status.
+
+    Wire shape (pinned by contract test — any change is a breaking API change):
+        {"url": "/entity/src/schema/table/", "resolves_to": "generic"}
+        {"url": "...", "resolves_to": "authored", "face": "/sales/"}
+    """
+
+    url: str
+    resolves_to: Literal["generic", "authored"]
+    face: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize to the agent wire shape, omitting face when generic."""
+        d: dict[str, Any] = {"url": self.url, "resolves_to": self.resolves_to}
+        if self.face is not None:
+            d["face"] = self.face
+        return d
+
+
+def entity_paths_for_source(
+    source: str,
+    *,
+    alias_index: AliasIndex,
+) -> EntityPathInfo:
+    """Return the entity URL info for a source.
+
+    The canonical URL is /entity/<source>/. When a face aliases it the
+    resolves_to is 'authored' and face is the canonical face URL.
+    """
+    url = f"/entity/{source}/"
+    face = alias_index.lookup(url)
+    if face is not None:
+        return EntityPathInfo(url=url, resolves_to="authored", face=face)
+    return EntityPathInfo(url=url, resolves_to="generic")
+
+
+def entity_paths_for_schema(
+    source: str,
+    schema: str,
+    *,
+    alias_index: AliasIndex,
+) -> EntityPathInfo:
+    """Return the entity URL info for a schema.
+
+    The canonical URL is /entity/<source>/<schema>/. When a face aliases it
+    the resolves_to is 'authored' and face is the canonical face URL.
+    """
+    url = f"/entity/{source}/{schema}/"
+    face = alias_index.lookup(url)
+    if face is not None:
+        return EntityPathInfo(url=url, resolves_to="authored", face=face)
+    return EntityPathInfo(url=url, resolves_to="generic")
+
+
+def entity_paths_for_table(
+    source: str,
+    schema: str,
+    table: str,
+    *,
+    alias_index: AliasIndex,
+) -> EntityPathInfo:
+    """Return the entity URL info for a table.
+
+    The canonical URL is /entity/<source>/<schema>/<table>/. When a face
+    aliases it the resolves_to is 'authored' and face is the canonical face URL.
+    """
+    url = f"/entity/{source}/{schema}/{table}/"
+    face = alias_index.lookup(url)
+    if face is not None:
+        return EntityPathInfo(url=url, resolves_to="authored", face=face)
+    return EntityPathInfo(url=url, resolves_to="generic")
+
+
+def validate_entity_aliases(
+    aliases: list[str],
+    *,
+    source_names: frozenset[str],
+) -> list[str]:
+    """Lint /entity/ prefixed aliases against configured source names.
+
+    Called at dft-validate time (connection-free). Checks that every
+    /entity/ URL references a known source, and errors with available
+    sources as a hint when not.
+
+    Returns a list of error message strings (empty = all valid).
+    Aliases not prefixed with /entity/ are silently skipped.
+    """
+    errors: list[str] = []
+    for raw_alias in aliases:
+        # Normalize: trailing-slash canonical, strip percent-encoding
+        from urllib.parse import unquote
+
+        alias = unquote(raw_alias)
+        if not alias.endswith("/"):
+            alias = alias + "/"
+
+        if not alias.startswith("/entity/"):
+            continue
+
+        # Strip leading "/entity/" and trailing "/" to get segments
+        inner = alias[len("/entity/") :]
+        if inner.endswith("/"):
+            inner = inner[:-1]
+        segments = [s for s in inner.split("/") if s]
+
+        if not segments:
+            # Bare /entity/ — no validation needed
+            continue
+
+        # Segment 0: source
+        source = segments[0]
+        if source not in source_names:
+            available = sorted(source_names)
+            hint = (
+                f"available sources: {', '.join(available)}"
+                if available
+                else "no sources configured"
+            )
+            errors.append(
+                f"Entity alias {raw_alias!r} references unknown source {source!r}. "
+                f"Did you mean one of: {hint}"
+            )
+
+    return errors
+
+
+def entity_paths_list(
+    schema_response: SchemaResponse,
+    *,
+    alias_index: AliasIndex,
+) -> list[EntityPathInfo]:
+    """Build a flat list of EntityPathInfo from a SchemaResponse.
+
+    Iterates all sources → schemas → tables in the response and returns one
+    EntityPathInfo per source, per schema, and per table, checking the alias
+    index for author overrides at each level.
+    """
+    result: list[EntityPathInfo] = []
+    for source_name, source_data in schema_response.sources.items():
+        result.append(entity_paths_for_source(source_name, alias_index=alias_index))
+        for schema_name, schema_data in (source_data.get("schemas") or {}).items():
+            result.append(
+                entity_paths_for_schema(
+                    source_name, schema_name, alias_index=alias_index
+                )
+            )
+            for table_name in schema_data.get("tables") or {}:
+                result.append(
+                    entity_paths_for_table(
+                        source_name,
+                        schema_name,
+                        table_name,
+                        alias_index=alias_index,
+                    )
+                )
+    return result
+
+
+def build_alias_index_for_project(project_dir: Path) -> AliasIndex:
+    """Build an AliasIndex from a project directory.
+
+    Uses the same faces_at_root detection logic as the server. Intended for
+    CLI commands (dft schema --entity-paths) that need alias lookup without
+    starting a server.
+    """
+    from dataface.core.serve.alias_index import AliasIndex
+
+    faces_dir = project_dir / "faces"
+    faces_at_root = faces_dir.is_dir()
+    return AliasIndex.build(
+        project_dir=project_dir,
+        faces_dir=faces_dir,
+        faces_at_root=faces_at_root,
+    )
+
+
+def entity_alias_errors_for_file(
+    face_file: Path,
+    source_names: frozenset[str],
+) -> list[str]:
+    """Read aliases from a face file and lint any /entity/ prefixed ones.
+
+    Source-name check only — no DB connection, no resolver. Called from the
+    validate path which must stay connection-free.
+
+    Returns a list of error message strings; empty means no entity alias issues.
+    Silently returns [] when the file cannot be parsed (compile catches that).
+    """
+    from dataface.core.serve.alias_index import _read_aliases_from_file
+
+    try:
+        aliases = _read_aliases_from_file(face_file)
+    except ValueError:
+        return []  # compile path reports alias parse errors with better context
+    return validate_entity_aliases(aliases, source_names=source_names)

dataface/agent_api/project.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import sys
 from dataclasses import dataclass
+from functools import cached_property
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
@@ -27,8 +28,8 @@ from dataface.agent_api.validate import (
 )
 from dataface.core.compile.config import (
     ProjectSourcesConfig,
-    get_project_sources,
     get_project_warnings_ignore,
+    load_project_sources,
 )
 from dataface.core.execute.adapters.adapter_registry import (
     AdapterRegistry,
@@ -39,6 +40,7 @@ from dataface.core.execute.duckdb_cache import DuckDBCache
 if TYPE_CHECKING:
     from dataface.core.dashboard import RenderedDashboard, RenderFormat
     from dataface.core.execute.source_resolver import SourceResolver
+    from dataface.core.render.board_links import LinkContext
 
 
 @dataclass(init=False)
@@ -55,7 +57,6 @@ class Project:
     project_root: Path
     cache: DuckDBCache | None
     _owns_registry: bool
-    _adapter_registry: AdapterRegistry | None
     _read_only: bool
     _dbt_project_path: Path | None
     _connection_string: str | None
@@ -64,22 +65,26 @@ class Project:
     _duckdb_config: dict[str, Any] | None
     _allow_external_access_in_readonly: bool
     _resolver: SourceResolver | None
-    _sources_cache: ProjectSourcesConfig | None
-    _warnings_ignore_cache: frozenset[str] | None
+    _sources: ProjectSourcesConfig
+    _warnings_ignore: frozenset[str]
 
     def __init__(
         self,
         project_root: Path,
         cache: DuckDBCache | None = None,
         adapter_registry: AdapterRegistry | None = None,
+        read_only: bool = True,
     ) -> None:
         self.project_root = project_root
         self.cache = cache
         # We own the registry only when we'll lazy-build it ourselves. An injected
         # registry belongs to the caller; we use it but don't close it on their behalf.
         self._owns_registry = adapter_registry is None
-        self._adapter_registry = adapter_registry
-        self._read_only = True
+        if adapter_registry is not None:
+            # cached_property stores in __dict__; pre-populating makes the descriptor
+            # short-circuit the build on first access.
+            self.__dict__["adapter_registry"] = adapter_registry
+        self._read_only = read_only
         self._dbt_project_path = None
         self._connection_string = None
         self._dialect = "duckdb"
@@ -87,8 +92,8 @@ class Project:
         self._duckdb_config = None
         self._allow_external_access_in_readonly = False
         self._resolver = None
-        self._sources_cache = None
-        self._warnings_ignore_cache = None
+        self._sources = load_project_sources(self.project_root)
+        self._warnings_ignore = get_project_warnings_ignore(self.project_root)
 
     @classmethod
     def open(
@@ -116,8 +121,9 @@ class Project:
         Call ``refresh()`` to close the current registry and force a rebuild on the
         next access.
         """
-        project = cls(project_root=Path(project_dir).resolve(), cache=cache)
-        project._read_only = read_only
+        project = cls(
+            project_root=Path(project_dir).resolve(), cache=cache, read_only=read_only
+        )
         project._dbt_project_path = dbt_project_path
         project._connection_string = connection_string
         project._dialect = dialect
@@ -133,7 +139,7 @@ class Project:
     def __exit__(self, *exc_info: object) -> None:
         self.close()
 
-    @property
+    @cached_property
     def adapter_registry(self) -> AdapterRegistry:
         """Lazily build the registry on first access; cached thereafter.
 
@@ -141,65 +147,67 @@ class Project:
         own it (i.e. it was not injected at construction time).
         When constructed with an injected registry, returns it directly.
         """
-        if self._adapter_registry is None:
-            self._adapter_registry = build_adapter_registry(
-                self.project_root,
-                read_only=self._read_only,
-                dbt_project_path=self._dbt_project_path,
-                connection_string=self._connection_string,
-                profile_type=self._dialect,
-                target=self._target,
-                duckdb_config=self._duckdb_config,
-                allow_external_access_in_readonly=self._allow_external_access_in_readonly,
-                resolver=self._resolver,
-            )
-        return self._adapter_registry
+        return build_adapter_registry(
+            self.project_root,
+            read_only=self._read_only,
+            dbt_project_path=self._dbt_project_path,
+            connection_string=self._connection_string,
+            profile_type=self._dialect,
+            target=self._target,
+            duckdb_config=self._duckdb_config,
+            allow_external_access_in_readonly=self._allow_external_access_in_readonly,
+            resolver=self._resolver,
+        )
 
     def refresh(self) -> None:
         """Policy-free rebuild primitive.
 
         For projects opened via ``open()``: closes the current registry (if built)
-        and clears it so the next access rebuilds from disk. Also clears the
-        sources and warnings_ignore caches so the next call re-reads from disk.
+        and clears it so the next access rebuilds from disk. Also re-reads
+        sources and warnings_ignore from disk.
 
         For projects constructed with an injected ``adapter_registry``: skips the
-        registry rebuild (build arguments are not available), but still clears the
-        config caches.
+        registry rebuild (build arguments are not available), but still re-reads
+        the config fields.
         """
-        if self._owns_registry:
-            if self._adapter_registry is not None:
-                self._adapter_registry.close()
-                self._adapter_registry = None
-        self._sources_cache = None
-        self._warnings_ignore_cache = None
+        if self._owns_registry and "adapter_registry" in self.__dict__:
+            self.adapter_registry.close()
+            del self.__dict__["adapter_registry"]
+        self._sources = load_project_sources(self.project_root)
+        self._warnings_ignore = get_project_warnings_ignore(self.project_root)
 
     def close(self) -> None:
         """Close the adapter registry iff we own it. The cache is the caller's to close."""
-        if self._owns_registry and self._adapter_registry is not None:
-            self._adapter_registry.close()
-            self._adapter_registry = None
-
-    # ── Config accessors ─────────────────────────────────────────────────────
+        if self._owns_registry and "adapter_registry" in self.__dict__:
+            self.adapter_registry.close()
+            del self.__dict__["adapter_registry"]
 
+    # Read-only views: project lifecycle owns these; external writers go through refresh().
+    @property
     def sources(self) -> ProjectSourcesConfig:
-        """Project-level sources config. Cached on the instance; refresh() invalidates."""
-        if self._sources_cache is None:
-            self._sources_cache = get_project_sources(self.project_root)
-        return self._sources_cache
+        return self._sources
 
+    @property
     def warnings_ignore(self) -> frozenset[str]:
-        """Warning codes to suppress. Cached on the instance; refresh() invalidates."""
-        if self._warnings_ignore_cache is None:
-            self._warnings_ignore_cache = get_project_warnings_ignore(self.project_root)
-        return self._warnings_ignore_cache
+        return self._warnings_ignore
 
     # ── Verb forwarders ──────────────────────────────────────────────────────
 
     def validate(self, face_path: Path) -> ValidateResult:
-        return _validate.validate(face_path, project_dir=self.project_root)
+        result = _validate.validate(face_path, project_dir=self.project_root)
+        annotated = _validate.annotate_with_entity_lint([result], project=self)
+        return annotated[0]
 
     def validate_paths(self, paths: list[Path] | None) -> list[ValidateResult]:
-        return _validate.validate_paths(paths, project_dir=self.project_root)
+        results = _validate.validate_paths(paths, project_dir=self.project_root)
+        return _validate.annotate_with_entity_lint(results, project=self)
+
+    def _source_names(self) -> frozenset[str]:
+        """Return the configured source names for entity alias validation.
+
+        Reads from the project config file — no adapter registry or DB connection needed.
+        """
+        return frozenset(self._sources.sources.keys())
 
     def describe_face(self, path: Path) -> _describe.DescribeFaceResult:
         return _describe.describe_face(path, project_dir=self.project_root)
@@ -293,6 +301,7 @@ class Project:
         scale: float | None = None,
         ignore_codes: set[str] | None = None,
         max_workers: int | None = None,
+        link_context: LinkContext | None = None,
     ) -> RenderedDashboard:
         return _dashboards.render_dashboard(
             path=path,
@@ -300,6 +309,7 @@ class Project:
             variables=variables,
             adapter_registry=self.adapter_registry,
             project_dir=self.project_root,
+            project_sources=self.sources,
             duckdb_cache=self.cache,
             format=format,
             use_cache=use_cache,
@@ -308,5 +318,6 @@ class Project:
             scale=scale,
             ignore_codes=ignore_codes,
             max_workers=max_workers,
-            warnings_ignore=self.warnings_ignore(),
+            warnings_ignore=self.warnings_ignore,
+            link_context=link_context,
         )

dataface/agent_api/schema_hints.py

@@ -0,0 +1,49 @@
+"""Stateless view of compile-time schema constants for authoring agents."""
+
+from __future__ import annotations
+
+import typing
+
+from pydantic import BaseModel
+
+from dataface.core.compile.config import list_built_in_themes
+from dataface.core.compile.models.chart.authored import (
+    _INTERNAL_CHART_TYPES,
+    CHART_TYPE_DISPLAY,
+    ChartType,
+)
+from dataface.core.compile.models.variable.authored import VariableInputType
+
+
+class ChartTypeDisplay(BaseModel):
+    label: str
+    icon: str
+
+
+class SchemaHints(BaseModel):
+    chart_types: list[str]
+    input_types: list[str]
+    theme_names: list[str]
+    chart_type_display: dict[str, ChartTypeDisplay]
+
+
+def schema_hints() -> SchemaHints:
+    """Return compile-time schema constants for Dataface authoring agents.
+
+    Takes no arguments and reads no process state. Two consecutive calls
+    return equal results.
+    """
+    public_chart_types = [t for t in ChartType if t not in _INTERNAL_CHART_TYPES]
+    return SchemaHints(
+        chart_types=[t.value for t in public_chart_types],
+        input_types=list(typing.get_args(VariableInputType)),
+        theme_names=list_built_in_themes(),
+        chart_type_display={
+            t.value: ChartTypeDisplay(
+                label=CHART_TYPE_DISPLAY[t]["label"],
+                icon=CHART_TYPE_DISPLAY[t]["icon"],
+            )
+            for t in public_chart_types
+            if t in CHART_TYPE_DISPLAY
+        },
+    )