data-designer 0.1.4__py3-none-any.whl → 0.2.0__py3-none-any.whl

data_designer/config/sampler_params.py

@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from enum import Enum
-from typing import Literal, Optional, Union
+from typing import Literal
 
 import pandas as pd
 from pydantic import Field, field_validator, model_validator
@@ -54,12 +54,12 @@ class CategorySamplerParams(ConfigBase):
             Larger weights result in higher sampling probability for the corresponding value.
     """
 
-    values: list[Union[str, int, float]] = Field(
+    values: list[str | int | float] = Field(
         ...,
         min_length=1,
         description="List of possible categorical values that can be sampled from.",
     )
-    weights: Optional[list[float]] = Field(
+    weights: list[float] | None = Field(
         default=None,
         description=(
             "List of unnormalized probability weights to assigned to each value, in order. "
@@ -134,7 +134,7 @@ class SubcategorySamplerParams(ConfigBase):
     """
 
     category: str = Field(..., description="Name of parent category to this subcategory.")
-    values: dict[str, list[Union[str, int, float]]] = Field(
+    values: dict[str, list[str | int | float]] = Field(
         ...,
         description="Mapping from each value of parent category to a list of subcategory values.",
     )
@@ -214,7 +214,7 @@ class UUIDSamplerParams(ConfigBase):
             lowercase UUIDs.
     """
 
-    prefix: Optional[str] = Field(default=None, description="String prepended to the front of the UUID.")
+    prefix: str | None = Field(default=None, description="String prepended to the front of the UUID.")
     short_form: bool = Field(
         default=False,
         description="If true, all UUIDs sampled will be truncated at 8 characters.",
@@ -259,7 +259,7 @@ class ScipySamplerParams(ConfigBase):
         ...,
         description="Parameters of the scipy.stats distribution given in `dist_name`.",
     )
-    decimal_places: Optional[int] = Field(
+    decimal_places: int | None = Field(
         default=None, description="Number of decimal places to round the sampled values to."
     )
     sampler_type: Literal[SamplerType.SCIPY] = SamplerType.SCIPY
@@ -356,7 +356,7 @@ class GaussianSamplerParams(ConfigBase):
 
     mean: float = Field(..., description="Mean of the Gaussian distribution")
     stddev: float = Field(..., description="Standard deviation of the Gaussian distribution")
-    decimal_places: Optional[int] = Field(
+    decimal_places: int | None = Field(
         default=None, description="Number of decimal places to round the sampled values to."
     )
     sampler_type: Literal[SamplerType.GAUSSIAN] = SamplerType.GAUSSIAN
@@ -398,7 +398,7 @@ class UniformSamplerParams(ConfigBase):
 
     low: float = Field(..., description="Lower bound of the uniform distribution, inclusive.")
     high: float = Field(..., description="Upper bound of the uniform distribution, inclusive.")
-    decimal_places: Optional[int] = Field(
+    decimal_places: int | None = Field(
         default=None, description="Number of decimal places to round the sampled values to."
     )
     sampler_type: Literal[SamplerType.UNIFORM] = SamplerType.UNIFORM
@@ -421,8 +421,8 @@ class PersonSamplerParams(ConfigBase):
 
     Attributes:
         locale: Locale string determining the language and geographic region for synthetic people.
-            Format: language_COUNTRY (e.g., "en_US", "en_GB", "fr_FR", "de_DE", "es_ES", "ja_JP").
-            Defaults to "en_US".
+            Must be a locale supported by a managed Nemotron Personas dataset. The dataset must
+            be downloaded and available in the managed assets directory.
         sex: If specified, filters to only sample people of the specified sex. Options: "Male" or
             "Female". If None, samples both sexes.
         city: If specified, filters to only sample people from the specified city or cities. Can be
@@ -447,11 +447,11 @@ class PersonSamplerParams(ConfigBase):
             f"{', '.join(LOCALES_WITH_MANAGED_DATASETS)}."
         ),
     )
-    sex: Optional[SexT] = Field(
+    sex: SexT | None = Field(
         default=None,
         description="If specified, then only synthetic people of the specified sex will be sampled.",
     )
-    city: Optional[Union[str, list[str]]] = Field(
+    city: str | list[str] | None = Field(
         default=None,
         description="If specified, then only synthetic people from these cities will be sampled.",
     )
@@ -461,7 +461,7 @@ class PersonSamplerParams(ConfigBase):
         min_length=2,
         max_length=2,
     )
-    select_field_values: Optional[dict[str, list[str]]] = Field(
+    select_field_values: dict[str, list[str]] | None = Field(
         default=None,
         description=(
             "Sample synthetic people with the specified field values. This is meant to be a flexible argument for "
@@ -529,11 +529,11 @@ class PersonFromFakerSamplerParams(ConfigBase):
             "that a synthetic person will be sampled from. E.g, en_US, en_GB, fr_FR, ..."
         ),
     )
-    sex: Optional[SexT] = Field(
+    sex: SexT | None = Field(
         default=None,
         description="If specified, then only synthetic people of the specified sex will be sampled.",
     )
-    city: Optional[Union[str, list[str]]] = Field(
+    city: str | list[str] | None = Field(
         default=None,
         description="If specified, then only synthetic people from these cities will be sampled.",
     )
@@ -585,22 +585,22 @@ class PersonFromFakerSamplerParams(ConfigBase):
         return value
 
 
-SamplerParamsT: TypeAlias = Union[
-    SubcategorySamplerParams,
-    CategorySamplerParams,
-    DatetimeSamplerParams,
-    PersonSamplerParams,
-    PersonFromFakerSamplerParams,
-    TimeDeltaSamplerParams,
-    UUIDSamplerParams,
-    BernoulliSamplerParams,
-    BernoulliMixtureSamplerParams,
-    BinomialSamplerParams,
-    GaussianSamplerParams,
-    PoissonSamplerParams,
-    UniformSamplerParams,
-    ScipySamplerParams,
-]
+SamplerParamsT: TypeAlias = (
+    SubcategorySamplerParams
+    | CategorySamplerParams
+    | DatetimeSamplerParams
+    | PersonSamplerParams
+    | PersonFromFakerSamplerParams
+    | TimeDeltaSamplerParams
+    | UUIDSamplerParams
+    | BernoulliSamplerParams
+    | BernoulliMixtureSamplerParams
+    | BinomialSamplerParams
+    | GaussianSamplerParams
+    | PoissonSamplerParams
+    | UniformSamplerParams
+    | ScipySamplerParams
+)
 
 
 def is_numerical_sampler_type(sampler_type: SamplerType) -> bool:

data_designer/config/seed.py

@@ -3,7 +3,6 @@
 
 from abc import ABC
 from enum import Enum
-from typing import Optional, Union
 
 from pydantic import Field, field_validator, model_validator
 from typing_extensions import Self
@@ -112,7 +111,7 @@ class SeedConfig(ConfigBase):
 
     dataset: str
     sampling_strategy: SamplingStrategy = SamplingStrategy.ORDERED
-    selection_strategy: Optional[Union[IndexRange, PartitionBlock]] = None
+    selection_strategy: IndexRange | PartitionBlock | None = None
 
 
 class SeedDatasetReference(ABC, ConfigBase):

data_designer/config/utils/code_lang.py

@@ -4,7 +4,6 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import Union
 
 
 class CodeLang(str, Enum):
@@ -26,17 +25,17 @@ class CodeLang(str, Enum):
     SQL_ANSI = "sql:ansi"
 
     @staticmethod
-    def parse(value: Union[str, CodeLang]) -> tuple[str, Union[str, None]]:
+    def parse(value: str | CodeLang) -> tuple[str, str | None]:
         value = value.value if isinstance(value, CodeLang) else value
         split_vals = value.split(":")
         return (split_vals[0], split_vals[1] if len(split_vals) > 1 else None)
 
     @staticmethod
-    def parse_lang(value: Union[str, CodeLang]) -> str:
+    def parse_lang(value: str | CodeLang) -> str:
         return CodeLang.parse(value)[0]
 
     @staticmethod
-    def parse_dialect(value: Union[str, CodeLang]) -> Union[str, None]:
+    def parse_dialect(value: str | CodeLang) -> str | None:
         return CodeLang.parse(value)[1]
 
     @staticmethod
@@ -58,7 +57,7 @@ SQL_DIALECTS: set[CodeLang] = {
 ##########################################################
 
 
-def code_lang_to_syntax_lexer(code_lang: Union[CodeLang, str]) -> str:
+def code_lang_to_syntax_lexer(code_lang: CodeLang | str) -> str:
     """Convert the code language to a syntax lexer for Pygments.
 
     Reference: https://pygments.org/docs/lexers/

data_designer/config/utils/constants.py

@@ -97,8 +97,6 @@ DEFAULT_AGE_RANGE = [18, 114]
 MIN_AGE = 0
 MAX_AGE = 114
 
-LOCALES_WITH_MANAGED_DATASETS = ["en_US", "ja_JP", "en_IN", "hi_IN"]
-
 US_STATES_AND_MAJOR_TERRITORIES = {
     # States
     "AK",
@@ -299,15 +297,40 @@ PREDEFINED_PROVIDERS = [
     },
 ]
 
+
+DEFAULT_TEXT_INFERENCE_PARAMS = {"temperature": 0.85, "top_p": 0.95}
+DEFAULT_REASONING_INFERENCE_PARAMS = {"temperature": 0.35, "top_p": 0.95}
+DEFAULT_VISION_INFERENCE_PARAMS = {"temperature": 0.85, "top_p": 0.95}
+DEFAULT_EMBEDDING_INFERENCE_PARAMS = {"encoding_format": "float"}
+
+
 PREDEFINED_PROVIDERS_MODEL_MAP = {
     NVIDIA_PROVIDER_NAME: {
-        "text": "nvidia/nvidia-nemotron-nano-9b-v2",
-        "reasoning": "openai/gpt-oss-20b",
-        "vision": "nvidia/nemotron-nano-12b-v2-vl",
+        "text": {"model": "nvidia/nemotron-3-nano-30b-a3b", "inference_parameters": {"temperature": 1.0, "top_p": 1.0}},
+        "reasoning": {"model": "openai/gpt-oss-20b", "inference_parameters": DEFAULT_REASONING_INFERENCE_PARAMS},
+        "vision": {"model": "nvidia/nemotron-nano-12b-v2-vl", "inference_parameters": DEFAULT_VISION_INFERENCE_PARAMS},
+        "embedding": {
+            "model": "nvidia/llama-3.2-nv-embedqa-1b-v2",
+            "inference_parameters": DEFAULT_EMBEDDING_INFERENCE_PARAMS | {"extra_body": {"input_type": "query"}},
+        },
     },
     OPENAI_PROVIDER_NAME: {
-        "text": "gpt-4.1",
-        "reasoning": "gpt-5",
-        "vision": "gpt-5",
+        "text": {"model": "gpt-4.1", "inference_parameters": DEFAULT_TEXT_INFERENCE_PARAMS},
+        "reasoning": {"model": "gpt-5", "inference_parameters": DEFAULT_REASONING_INFERENCE_PARAMS},
+        "vision": {"model": "gpt-5", "inference_parameters": DEFAULT_VISION_INFERENCE_PARAMS},
+        "embedding": {"model": "text-embedding-3-large", "inference_parameters": DEFAULT_EMBEDDING_INFERENCE_PARAMS},
     },
 }
+
+# Persona locale metadata - used by the CLI and the person sampler.
+NEMOTRON_PERSONAS_DATASET_SIZES = {
+    "en_US": "1.24 GB",
+    "en_IN": "2.39 GB",
+    "hi_Deva_IN": "4.14 GB",
+    "hi_Latn_IN": "2.7 GB",
+    "ja_JP": "1.69 GB",
+}
+
+LOCALES_WITH_MANAGED_DATASETS = list[str](NEMOTRON_PERSONAS_DATASET_SIZES.keys())
+
+NEMOTRON_PERSONAS_DATASET_PREFIX = "nemotron-personas-dataset-"

data_designer/config/utils/io_helpers.py

@@ -8,7 +8,7 @@ from datetime import date, datetime, timedelta
 from decimal import Decimal
 from numbers import Number
 from pathlib import Path
-from typing import Any, Union
+from typing import Any
 
 import numpy as np
 import pandas as pd
@@ -128,7 +128,7 @@ def write_seed_dataset(dataframe: pd.DataFrame, file_path: Path) -> None:
         dataframe.to_json(file_path, orient="records", lines=True)
 
 
-def validate_dataset_file_path(file_path: Union[str, Path], should_exist: bool = True) -> Path:
+def validate_dataset_file_path(file_path: str | Path, should_exist: bool = True) -> Path:
     """Validate that a dataset file path has a valid extension and optionally exists.
 
     Args:
@@ -165,7 +165,7 @@ def validate_path_contains_files_of_type(path: str | Path, file_extension: str)
         raise InvalidFilePathError(f"🛑 Path {path!r} does not contain files of type {file_extension!r}.")
 
 
-def smart_load_dataframe(dataframe: Union[str, Path, pd.DataFrame]) -> pd.DataFrame:
+def smart_load_dataframe(dataframe: str | Path | pd.DataFrame) -> pd.DataFrame:
     """Load a dataframe from file if a path is given, otherwise return the dataframe.
 
     Args:
@@ -197,7 +197,7 @@ def smart_load_dataframe(dataframe: Union[str, Path, pd.DataFrame]) -> pd.DataFr
         raise ValueError(f"Unsupported file format: {dataframe}")
 
 
-def smart_load_yaml(yaml_in: Union[str, Path, dict]) -> dict:
+def smart_load_yaml(yaml_in: str | Path | dict) -> dict:
     """Return the yaml config as a dict given flexible input types.
 
     Args:
@@ -227,7 +227,7 @@ def smart_load_yaml(yaml_in: Union[str, Path, dict]) -> dict:
     return yaml_out
 
 
-def serialize_data(data: Union[dict, list, str, Number], **kwargs) -> str:
+def serialize_data(data: dict | list | str | Number, **kwargs) -> str:
     if isinstance(data, dict):
         return json.dumps(data, ensure_ascii=False, default=_convert_to_serializable, **kwargs)
     elif isinstance(data, list):

data_designer/config/utils/misc.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 
 import json
 from contextlib import contextmanager
-from typing import Optional, Union
 
 from jinja2 import TemplateSyntaxError, meta
 from jinja2.sandbox import ImmutableSandboxedEnvironment
@@ -58,9 +57,7 @@ def get_prompt_template_keywords(template: str) -> set[str]:
     return keywords
 
 
-def json_indent_list_of_strings(
-    column_names: list[str], *, indent: Optional[Union[int, str]] = None
-) -> Optional[Union[list[str], str]]:
+def json_indent_list_of_strings(column_names: list[str], *, indent: int | str | None = None) -> list[str] | str | None:
     """Convert a list of column names to a JSON string if the list is long.
 
     This function helps keep Data Designer's __repr__ output clean and readable.

data_designer/config/utils/numerical_helpers.py

@@ -3,7 +3,7 @@
 
 import numbers
 from numbers import Number
-from typing import Any, Type
+from typing import Any
 
 from data_designer.config.utils.constants import REPORTING_PRECISION
 
@@ -18,7 +18,7 @@ def is_float(val: Any) -> bool:
 
 def prepare_number_for_reporting(
     value: Number,
-    target_type: Type[Number],
+    target_type: type[Number],
     precision: int = REPORTING_PRECISION,
 ) -> Number:
     """Ensure native python types and round to `precision` decimal digits."""

data_designer/config/utils/type_helpers.py

@@ -3,7 +3,7 @@
 
 import inspect
 from enum import Enum
-from typing import Any, Literal, Type, get_args, get_origin
+from typing import Any, Literal, get_args, get_origin
 
 from pydantic import BaseModel
 
@@ -56,7 +56,7 @@ def create_str_enum_from_discriminated_type_union(
     return StrEnum(enum_name, {v.replace("-", "_").upper(): v for v in set(discriminator_field_values)})
 
 
-def get_sampler_params() -> dict[str, Type[BaseModel]]:
+def get_sampler_params() -> dict[str, type[BaseModel]]:
     """Returns a dictionary of sampler parameter classes."""
     params_cls_list = [
         params_cls
@@ -83,7 +83,7 @@ def get_sampler_params() -> dict[str, Type[BaseModel]]:
     return params_cls_dict
 
 
-def resolve_string_enum(enum_instance: Any, enum_type: Type[Enum]) -> Enum:
+def resolve_string_enum(enum_instance: Any, enum_type: type[Enum]) -> Enum:
     if not issubclass(enum_type, Enum):
         raise InvalidEnumValueError(f"🛑 `enum_type` must be a subclass of Enum. You provided: {enum_type}")
     invalid_enum_value_error = InvalidEnumValueError(

data_designer/config/utils/validation.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 
 from enum import Enum
 from string import Formatter
-from typing import Optional
 
 from jinja2 import meta
 from jinja2.sandbox import ImmutableSandboxedEnvironment
@@ -15,10 +14,13 @@ from rich.console import Console, Group
 from rich.padding import Padding
 from rich.panel import Panel
 
-from data_designer.config.column_types import ColumnConfigT, DataDesignerColumnType, column_type_is_llm_generated
-from data_designer.config.processors import ProcessorConfig, ProcessorType
+from data_designer.config.column_types import ColumnConfigT, DataDesignerColumnType, column_type_is_model_generated
+from data_designer.config.processors import ProcessorConfigT, ProcessorType
 from data_designer.config.utils.constants import RICH_CONSOLE_THEME
-from data_designer.config.utils.misc import can_run_data_designer_locally
+from data_designer.config.utils.misc import (
+    can_run_data_designer_locally,
+    get_prompt_template_keywords,
+)
 from data_designer.config.validator_params import ValidatorType
 
 
@@ -42,7 +44,7 @@ class ViolationLevel(str, Enum):
 
 
 class Violation(BaseModel):
-    column: Optional[str] = None
+    column: str | None = None
     type: ViolationType
     message: str
     level: ViolationLevel
@@ -54,7 +56,7 @@ class Violation(BaseModel):
 
 def validate_data_designer_config(
     columns: list[ColumnConfigT],
-    processor_configs: list[ProcessorConfig],
+    processor_configs: list[ProcessorConfigT],
     allowed_references: list[str],
 ) -> list[Violation]:
     violations = []
@@ -63,6 +65,7 @@ def validate_data_designer_config(
     violations.extend(validate_expression_references(columns=columns, allowed_references=allowed_references))
     violations.extend(validate_columns_not_all_dropped(columns=columns))
     violations.extend(validate_drop_columns_processor(columns=columns, processor_configs=processor_configs))
+    violations.extend(validate_schema_transform_processor(columns=columns, processor_configs=processor_configs))
     if not can_run_data_designer_locally():
         violations.extend(validate_local_only_columns(columns=columns))
     return violations
@@ -115,7 +118,7 @@ def validate_prompt_templates(
 ) -> list[Violation]:
     env = ImmutableSandboxedEnvironment()
 
-    columns_with_prompts = [c for c in columns if column_type_is_llm_generated(c.column_type)]
+    columns_with_prompts = [c for c in columns if column_type_is_model_generated(c.column_type)]
 
     violations = []
     for column in columns_with_prompts:
@@ -269,9 +272,9 @@ def validate_columns_not_all_dropped(
 
 def validate_drop_columns_processor(
     columns: list[ColumnConfigT],
-    processor_configs: list[ProcessorConfig],
+    processor_configs: list[ProcessorConfigT],
 ) -> list[Violation]:
-    all_column_names = set([c.name for c in columns])
+    all_column_names = {c.name for c in columns}
     for processor_config in processor_configs:
         if processor_config.processor_type == ProcessorType.DROP_COLUMNS:
             invalid_columns = set(processor_config.column_names) - all_column_names
@@ -288,6 +291,33 @@ def validate_drop_columns_processor(
     return []
 
 
+def validate_schema_transform_processor(
+    columns: list[ColumnConfigT],
+    processor_configs: list[ProcessorConfigT],
+) -> list[Violation]:
+    violations = []
+
+    all_column_names = {c.name for c in columns}
+    for processor_config in processor_configs:
+        if processor_config.processor_type == ProcessorType.SCHEMA_TRANSFORM:
+            for col, template in processor_config.template.items():
+                template_keywords = get_prompt_template_keywords(template)
+                invalid_keywords = set(template_keywords) - all_column_names
+                if len(invalid_keywords) > 0:
+                    invalid_keywords = ", ".join([f"'{k}'" for k in invalid_keywords])
+                    message = f"Ancillary dataset processor attempts to reference columns {invalid_keywords} in the template for '{col}', but the columns are not defined in the dataset."
+                    violations.append(
+                        Violation(
+                            column=None,
+                            type=ViolationType.INVALID_REFERENCE,
+                            message=message,
+                            level=ViolationLevel.ERROR,
+                        )
+                    )
+
+    return violations
+
+
 def validate_expression_references(
     columns: list[ColumnConfigT],
     allowed_references: list[str],

data_designer/config/utils/visualization.py

@@ -8,7 +8,7 @@ import os
 from collections import OrderedDict
 from enum import Enum
 from functools import cached_property
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING, Any
 
 import numpy as np
 import pandas as pd
@@ -36,11 +36,11 @@ if TYPE_CHECKING:
 console = Console()
 
 
-def get_nvidia_api_key() -> Optional[str]:
+def get_nvidia_api_key() -> str | None:
     return os.getenv(NVIDIA_API_KEY_ENV_VAR_NAME)
 
 
-def get_openai_api_key() -> Optional[str]:
+def get_openai_api_key() -> str | None:
     return os.getenv(OPENAI_API_KEY_ENV_VAR_NAME)
 
 
@@ -72,13 +72,17 @@ class WithRecordSamplerMixin:
         else:
             raise DatasetSampleDisplayError("No valid dataset found in results object.")
 
+    def _has_processor_artifacts(self) -> bool:
+        return hasattr(self, "processor_artifacts") and self.processor_artifacts is not None
+
     def display_sample_record(
         self,
-        index: Optional[int] = None,
+        index: int | None = None,
         *,
         hide_seed_columns: bool = False,
         syntax_highlighting_theme: str = "dracula",
-        background_color: Optional[str] = None,
+        background_color: str | None = None,
+        processors_to_display: list[str] | None = None,
     ) -> None:
         """Display a sample record from the Data Designer dataset preview.
 
@@ -90,6 +94,7 @@ class WithRecordSamplerMixin:
                 documentation from `rich` for information about available themes.
             background_color: Background color to use for the record. See the `Syntax`
                 documentation from `rich` for information about available background colors.
+            processors_to_display: List of processors to display the artifacts for. If None, all processors will be displayed.
         """
         i = index or self._display_cycle_index
 
@@ -99,8 +104,25 @@ class WithRecordSamplerMixin:
         except IndexError:
             raise DatasetSampleDisplayError(f"Index {i} is out of bounds for dataset of length {num_records}.")
 
+        processor_data_to_display = None
+        if self._has_processor_artifacts() and len(self.processor_artifacts) > 0:
+            if processors_to_display is None:
+                processors_to_display = list(self.processor_artifacts.keys())
+
+            if len(processors_to_display) > 0:
+                processor_data_to_display = {}
+                for processor in processors_to_display:
+                    if (
+                        isinstance(self.processor_artifacts[processor], list)
+                        and len(self.processor_artifacts[processor]) == num_records
+                    ):
+                        processor_data_to_display[processor] = self.processor_artifacts[processor][i]
+                    else:
+                        processor_data_to_display[processor] = self.processor_artifacts[processor]
+
         display_sample_record(
             record=record,
+            processor_data_to_display=processor_data_to_display,
             config_builder=self._config_builder,
             background_color=background_color,
             syntax_highlighting_theme=syntax_highlighting_theme,
@@ -112,11 +134,11 @@ class WithRecordSamplerMixin:
 
 
 def create_rich_histogram_table(
-    data: dict[str, Union[int, float]],
+    data: dict[str, int | float],
     column_names: tuple[int, int],
     name_style: str = ColorPalette.BLUE.value,
     value_style: str = ColorPalette.TEAL.value,
-    title: Optional[str] = None,
+    title: str | None = None,
     **kwargs,
 ) -> Table:
     table = Table(title=title, **kwargs)
@@ -132,11 +154,12 @@ def create_rich_histogram_table(
 
 
 def display_sample_record(
-    record: Union[dict, pd.Series, pd.DataFrame],
+    record: dict | pd.Series | pd.DataFrame,
     config_builder: DataDesignerConfigBuilder,
-    background_color: Optional[str] = None,
+    processor_data_to_display: dict[str, list[str] | str] | None = None,
+    background_color: str | None = None,
     syntax_highlighting_theme: str = "dracula",
-    record_index: Optional[int] = None,
+    record_index: int | None = None,
     hide_seed_columns: bool = False,
 ):
     if isinstance(record, (dict, pd.Series)):
@@ -171,6 +194,7 @@ def display_sample_record(
         + config_builder.get_columns_of_type(DataDesignerColumnType.EXPRESSION)
         + config_builder.get_columns_of_type(DataDesignerColumnType.LLM_TEXT)
         + config_builder.get_columns_of_type(DataDesignerColumnType.LLM_STRUCTURED)
+        + config_builder.get_columns_of_type(DataDesignerColumnType.EMBEDDING)
     )
     if len(non_code_columns) > 0:
         table = Table(title="Generated Columns", **table_kws)
@@ -178,6 +202,10 @@ def display_sample_record(
         table.add_column("Value")
         for col in non_code_columns:
             if not col.drop:
+                if col.column_type == DataDesignerColumnType.EMBEDDING:
+                    record[col.name]["embeddings"] = [
+                        get_truncated_list_as_string(embd) for embd in record[col.name].get("embeddings")
+                    ]
                 table.add_row(col.name, convert_to_row_element(record[col.name]))
         render_list.append(pad_console_element(table))
 
@@ -230,6 +258,15 @@ def display_sample_record(
             table.add_row(*row)
             render_list.append(pad_console_element(table, (1, 0, 1, 0)))
 
+    if processor_data_to_display and len(processor_data_to_display) > 0:
+        for processor_name, processor_data in processor_data_to_display.items():
+            table = Table(title=f"Processor Outputs: {processor_name}", **table_kws)
+            table.add_column("Name")
+            table.add_column("Value")
+            for col, value in processor_data.items():
+                table.add_row(col, convert_to_row_element(value))
+        render_list.append(pad_console_element(table, (1, 0, 1, 0)))
+
     if record_index is not None:
         index_label = Text(f"[index: {record_index}]", justify="center")
         render_list.append(index_label)
@@ -237,9 +274,19 @@ def display_sample_record(
     console.print(Group(*render_list), markup=False)
 
 
+def get_truncated_list_as_string(long_list: list[Any], max_items: int = 2) -> str:
+    if max_items <= 0:
+        raise ValueError("max_items must be greater than 0")
+    if len(long_list) > max_items:
+        truncated_part = long_list[:max_items]
+        return f"[{', '.join(str(x) for x in truncated_part)}, ...]"
+    else:
+        return str(long_list)
+
+
 def display_sampler_table(
     sampler_params: dict[SamplerType, ConfigBase],
-    title: Optional[str] = None,
+    title: str | None = None,
 ) -> None:
     table = Table(expand=True)
     table.add_column("Type")
@@ -274,15 +321,15 @@ def display_model_configs_table(model_configs: list[ModelConfig]) -> None:
     table_model_configs.add_column("Alias")
     table_model_configs.add_column("Model")
     table_model_configs.add_column("Provider")
-    table_model_configs.add_column("Temperature")
-    table_model_configs.add_column("Top P")
+    table_model_configs.add_column("Inference Parameters")
     for model_config in model_configs:
+        params_display = model_config.inference_parameters.format_for_display()
+
         table_model_configs.add_row(
             model_config.alias,
             model_config.model,
             model_config.provider,
-            str(model_config.inference_parameters.temperature),
-            str(model_config.inference_parameters.top_p),
+            params_display,
         )
     group_args: list = [Rule(title="Model Configs"), table_model_configs]
     if len(model_configs) == 0: