data-designer 0.1.0__py3-none-any.whl

data_designer/config/data_designer_config.py

@@ -0,0 +1,40 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from typing import Annotated, Optional
+
+from pydantic import Field
+
+from .analysis.column_profilers import ColumnProfilerConfigT
+from .base import ExportableConfigBase
+from .column_types import ColumnConfigT
+from .models import ModelConfig
+from .processors import ProcessorConfig
+from .sampler_constraints import ColumnConstraintT
+from .seed import SeedConfig
+
+
+class DataDesignerConfig(ExportableConfigBase):
+    """Configuration for NeMo Data Designer.
+
+    This class defines the main configuration structure for NeMo Data Designer,
+    which orchestrates the generation of synthetic data.
+
+    Attributes:
+        columns: Required list of column configurations defining how each column
+            should be generated. Must contain at least one column.
+        model_configs: Optional list of model configurations for LLM-based generation.
+            Each model config defines the model, provider, and inference parameters.
+        seed_config: Optional seed dataset settings to use for generation.
+        constraints: Optional list of column constraints.
+        profilers: Optional list of column profilers for analyzing generated data characteristics.
+    """
+
+    columns: list[Annotated[ColumnConfigT, Field(discriminator="column_type")]] = Field(min_length=1)
+    model_configs: Optional[list[ModelConfig]] = None
+    seed_config: Optional[SeedConfig] = None
+    constraints: Optional[list[ColumnConstraintT]] = None
+    profilers: Optional[list[ColumnProfilerConfigT]] = None
+    processors: Optional[list[ProcessorConfig]] = None

data_designer/config/dataset_builders.py

@@ -0,0 +1,11 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from enum import Enum
+
+
+class BuildStage(str, Enum):
+    PRE_BATCH = "pre_batch"
+    POST_BATCH = "post_batch"
+    PRE_GENERATION = "pre_generation"
+    POST_GENERATION = "post_generation"

data_designer/config/datastore.py

@@ -0,0 +1,151 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional, Union
+
+from huggingface_hub import HfApi, HfFileSystem
+import pandas as pd
+import pyarrow.parquet as pq
+from pydantic import BaseModel, Field
+
+from .errors import InvalidConfigError, InvalidFileFormatError, InvalidFilePathError
+from .utils.io_helpers import VALID_DATASET_FILE_EXTENSIONS, validate_path_contains_files_of_type
+
+if TYPE_CHECKING:
+    from .seed import SeedDatasetReference
+
+logger = logging.getLogger(__name__)
+
+
+class DatastoreSettings(BaseModel):
+    """Configuration for interacting with a datastore."""
+
+    endpoint: str = Field(
+        ...,
+        description="Datastore endpoint. Use 'https://huggingface.co' for the Hugging Face Hub.",
+    )
+    token: Optional[str] = Field(default=None, description="If needed, token to use for authentication.")
+
+
+def get_file_column_names(file_path: Union[str, Path], file_type: str) -> list[str]:
+    """Extract column names based on file type. Supports glob patterns like '../path/*.parquet'."""
+    file_path = Path(file_path)
+    if "*" in str(file_path):
+        matching_files = sorted(file_path.parent.glob(file_path.name))
+        if not matching_files:
+            raise InvalidFilePathError(f"🛑 No files found matching pattern: {str(file_path)!r}")
+        logger.debug(f"0️⃣ Using the first matching file in {str(file_path)!r} to determine column names in seed dataset")
+        file_path = matching_files[0]
+
+    if file_type == "parquet":
+        try:
+            schema = pq.read_schema(file_path)
+            if hasattr(schema, "names"):
+                return schema.names
+            else:
+                return [field.name for field in schema]
+        except Exception as e:
+            logger.warning(f"Failed to process parquet file {file_path}: {e}")
+            return []
+    elif file_type in ["json", "jsonl"]:
+        return pd.read_json(file_path, orient="records", lines=True, nrows=1).columns.tolist()
+    elif file_type == "csv":
+        try:
+            df = pd.read_csv(file_path, nrows=1)
+            return df.columns.tolist()
+        except (pd.errors.EmptyDataError, pd.errors.ParserError) as e:
+            logger.warning(f"Failed to process CSV file {file_path}: {e}")
+            return []
+    else:
+        raise InvalidFilePathError(f"🛑 Unsupported file type: {file_type!r}")
+
+
+def fetch_seed_dataset_column_names(seed_dataset_reference: SeedDatasetReference) -> list[str]:
+    if hasattr(seed_dataset_reference, "datastore_settings"):
+        return _fetch_seed_dataset_column_names_from_datastore(
+            seed_dataset_reference.repo_id,
+            seed_dataset_reference.filename,
+            seed_dataset_reference.datastore_settings,
+        )
+    return _fetch_seed_dataset_column_names_from_local_file(seed_dataset_reference.dataset)
+
+
+def resolve_datastore_settings(datastore_settings: DatastoreSettings | dict | None) -> DatastoreSettings:
+    if datastore_settings is None:
+        raise InvalidConfigError("🛑 Datastore settings are required in order to upload datasets to the datastore.")
+    if isinstance(datastore_settings, DatastoreSettings):
+        return datastore_settings
+    elif isinstance(datastore_settings, dict):
+        return DatastoreSettings.model_validate(datastore_settings)
+    else:
+        raise InvalidConfigError(
+            "🛑 Invalid datastore settings format. Must be DatastoreSettings object or dictionary."
+        )
+
+
+def upload_to_hf_hub(
+    dataset_path: Union[str, Path],
+    filename: str,
+    repo_id: str,
+    datastore_settings: DatastoreSettings,
+    **kwargs,
+) -> str:
+    datastore_settings = resolve_datastore_settings(datastore_settings)
+    dataset_path = _validate_dataset_path(dataset_path)
+    filename_ext = filename.split(".")[-1].lower()
+    if dataset_path.suffix.lower()[1:] != filename_ext:
+        raise InvalidFileFormatError(
+            f"🛑 Dataset file extension {dataset_path.suffix!r} does not match `filename` extension .{filename_ext!r}"
+        )
+
+    hfapi = HfApi(endpoint=datastore_settings.endpoint, token=datastore_settings.token)
+    hfapi.create_repo(repo_id, exist_ok=True, repo_type="dataset")
+    hfapi.upload_file(
+        path_or_fileobj=dataset_path,
+        path_in_repo=filename,
+        repo_id=repo_id,
+        repo_type="dataset",
+        **kwargs,
+    )
+    return f"{repo_id}/{filename}"
+
+
+def _fetch_seed_dataset_column_names_from_datastore(
+    repo_id: str,
+    filename: str,
+    datastore_settings: Optional[Union[DatastoreSettings, dict]] = None,
+) -> list[str]:
+    file_type = filename.split(".")[-1]
+    if f".{file_type}" not in VALID_DATASET_FILE_EXTENSIONS:
+        raise InvalidFileFormatError(f"🛑 Unsupported file type: {filename!r}")
+
+    datastore_settings = resolve_datastore_settings(datastore_settings)
+    fs = HfFileSystem(endpoint=datastore_settings.endpoint, token=datastore_settings.token)
+
+    with fs.open(f"datasets/{repo_id}/{filename}") as f:
+        return get_file_column_names(f, file_type)
+
+
+def _fetch_seed_dataset_column_names_from_local_file(dataset_path: str | Path) -> list[str]:
+    dataset_path = _validate_dataset_path(dataset_path, allow_glob_pattern=True)
+    return get_file_column_names(dataset_path, str(dataset_path).split(".")[-1])
+
+
+def _validate_dataset_path(dataset_path: Union[str, Path], allow_glob_pattern: bool = False) -> Path:
+    if allow_glob_pattern and "*" in str(dataset_path):
+        parts = str(dataset_path).split("*.")
+        file_path = parts[0]
+        file_extension = parts[-1]
+        validate_path_contains_files_of_type(file_path, file_extension)
+        return Path(dataset_path)
+    if not Path(dataset_path).is_file():
+        raise InvalidFilePathError("🛑 To upload a dataset to the datastore, you must provide a valid file path.")
+    if not Path(dataset_path).name.endswith(tuple(VALID_DATASET_FILE_EXTENSIONS)):
+        raise InvalidFileFormatError(
+            "🛑 Dataset files must be in `parquet`, `csv`, or `json` (orient='records', lines=True) format."
+        )
+    return Path(dataset_path)

data_designer/config/default_model_settings.py

@@ -0,0 +1,123 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+
+from functools import lru_cache
+import logging
+from pathlib import Path
+from typing import Any, Literal, Optional
+
+from .models import InferenceParameters, ModelConfig, ModelProvider
+from .utils.constants import (
+    MANAGED_ASSETS_PATH,
+    MODEL_CONFIGS_FILE_PATH,
+    MODEL_PROVIDERS_FILE_PATH,
+    PREDEFINED_PROVIDERS,
+    PREDEFINED_PROVIDERS_MODEL_MAP,
+)
+from .utils.info import ConfigBuilderInfo, InfoType, InterfaceInfo
+from .utils.io_helpers import load_config_file, save_config_file
+
+logger = logging.getLogger(__name__)
+
+
+def get_default_text_alias_inference_parameters() -> InferenceParameters:
+    return InferenceParameters(
+        temperature=0.85,
+        top_p=0.95,
+    )
+
+
+def get_default_reasoning_alias_inference_parameters() -> InferenceParameters:
+    return InferenceParameters(
+        temperature=0.35,
+        top_p=0.95,
+    )
+
+
+def get_default_vision_alias_inference_parameters() -> InferenceParameters:
+    return InferenceParameters(
+        temperature=0.85,
+        top_p=0.95,
+    )
+
+
+def get_default_inference_parameters(model_alias: Literal["text", "reasoning", "vision"]) -> InferenceParameters:
+    if model_alias == "reasoning":
+        return get_default_reasoning_alias_inference_parameters()
+    elif model_alias == "vision":
+        return get_default_vision_alias_inference_parameters()
+    else:
+        return get_default_text_alias_inference_parameters()
+
+
+def get_builtin_model_configs() -> list[ModelConfig]:
+    model_configs = []
+    for provider, model_alias_map in PREDEFINED_PROVIDERS_MODEL_MAP.items():
+        for model_alias, model_id in model_alias_map.items():
+            model_configs.append(
+                ModelConfig(
+                    alias=f"{provider}-{model_alias}",
+                    model=model_id,
+                    provider=provider,
+                    inference_parameters=get_default_inference_parameters(model_alias),
+                )
+            )
+    return model_configs
+
+
+def get_builtin_model_providers() -> list[ModelProvider]:
+    return [ModelProvider.model_validate(provider) for provider in PREDEFINED_PROVIDERS]
+
+
+def get_default_model_configs() -> list[ModelConfig]:
+    if MODEL_CONFIGS_FILE_PATH.exists():
+        config_dict = load_config_file(MODEL_CONFIGS_FILE_PATH)
+        if "model_configs" in config_dict:
+            return [ModelConfig.model_validate(mc) for mc in config_dict["model_configs"]]
+    raise FileNotFoundError(f"Default model configs file not found at {str(MODEL_CONFIGS_FILE_PATH)!r}")
+
+
+def get_default_providers() -> list[ModelProvider]:
+    config_dict = _get_default_providers_file_content(MODEL_PROVIDERS_FILE_PATH)
+    if "providers" in config_dict:
+        return [ModelProvider.model_validate(p) for p in config_dict["providers"]]
+    return []
+
+
+def get_default_provider_name() -> Optional[str]:
+    return _get_default_providers_file_content(MODEL_PROVIDERS_FILE_PATH).get("default")
+
+
+def resolve_seed_default_model_settings() -> None:
+    if not MODEL_CONFIGS_FILE_PATH.exists():
+        logger.info(
+            f"🍾 Default model configs were not found, so writing the following to {str(MODEL_CONFIGS_FILE_PATH)!r}"
+        )
+        config_builder_info = ConfigBuilderInfo(model_configs=get_builtin_model_configs())
+        config_builder_info.display(info_type=InfoType.MODEL_CONFIGS)
+        save_config_file(
+            MODEL_CONFIGS_FILE_PATH, {"model_configs": [mc.model_dump() for mc in get_builtin_model_configs()]}
+        )
+
+    if not MODEL_PROVIDERS_FILE_PATH.exists():
+        logger.info(
+            f"🪄  Default model providers were not found, so writing the following to {str(MODEL_PROVIDERS_FILE_PATH)!r}"
+        )
+        interface_info = InterfaceInfo(model_providers=get_builtin_model_providers())
+        interface_info.display(info_type=InfoType.MODEL_PROVIDERS)
+        save_config_file(
+            MODEL_PROVIDERS_FILE_PATH, {"providers": [p.model_dump() for p in get_builtin_model_providers()]}
+        )
+
+    if not MANAGED_ASSETS_PATH.exists():
+        logger.debug(f"🏗️ Default managed assets path was not found, so creating it at {str(MANAGED_ASSETS_PATH)!r}")
+        MANAGED_ASSETS_PATH.mkdir(parents=True, exist_ok=True)
+
+
+@lru_cache(maxsize=1)
+def _get_default_providers_file_content(file_path: Path) -> dict[str, Any]:
+    """Load and cache the default providers file content."""
+    if file_path.exists():
+        return load_config_file(file_path)
+    raise FileNotFoundError(f"Default model providers file not found at {str(file_path)!r}")

data_designer/config/errors.py

@@ -0,0 +1,19 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from ..errors import DataDesignerError
+
+
+class BuilderConfigurationError(DataDesignerError): ...
+
+
+class InvalidColumnTypeError(DataDesignerError): ...
+
+
+class InvalidConfigError(DataDesignerError): ...
+
+
+class InvalidFilePathError(DataDesignerError): ...
+
+
+class InvalidFileFormatError(DataDesignerError): ...

data_designer/config/interface.py

@@ -0,0 +1,54 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Generic, Protocol, TypeVar
+
+import pandas as pd
+
+from .models import ModelConfig, ModelProvider
+from .utils.constants import DEFAULT_NUM_RECORDS
+from .utils.info import InterfaceInfo
+
+if TYPE_CHECKING:
+    from .analysis.dataset_profiler import DatasetProfilerResults
+    from .config_builder import DataDesignerConfigBuilder
+    from .preview_results import PreviewResults
+
+
+class ResultsProtocol(Protocol):
+    def load_analysis(self) -> DatasetProfilerResults: ...
+    def load_dataset(self) -> pd.DataFrame: ...
+
+
+ResultsT = TypeVar("ResultsT", bound=ResultsProtocol)
+
+
+class DataDesignerInterface(ABC, Generic[ResultsT]):
+    @abstractmethod
+    def create(
+        self,
+        config_builder: DataDesignerConfigBuilder,
+        *,
+        num_records: int = DEFAULT_NUM_RECORDS,
+    ) -> ResultsT: ...
+
+    @abstractmethod
+    def preview(
+        self,
+        config_builder: DataDesignerConfigBuilder,
+        *,
+        num_records: int = DEFAULT_NUM_RECORDS,
+    ) -> PreviewResults: ...
+
+    @abstractmethod
+    def get_default_model_configs(self) -> list[ModelConfig]: ...
+
+    @abstractmethod
+    def get_default_model_providers(self) -> list[ModelProvider]: ...
+
+    @property
+    @abstractmethod
+    def info(self) -> InterfaceInfo: ...

data_designer/config/models.py

@@ -0,0 +1,231 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from abc import ABC, abstractmethod
+from enum import Enum
+import logging
+from pathlib import Path
+from typing import Any, Generic, List, Optional, TypeVar, Union
+
+import numpy as np
+from pydantic import BaseModel, Field, model_validator
+from typing_extensions import Self, TypeAlias
+
+from .base import ConfigBase
+from .errors import InvalidConfigError
+from .utils.constants import (
+    MAX_TEMPERATURE,
+    MAX_TOP_P,
+    MIN_TEMPERATURE,
+    MIN_TOP_P,
+)
+from .utils.io_helpers import smart_load_yaml
+
+logger = logging.getLogger(__name__)
+
+
+class Modality(str, Enum):
+    IMAGE = "image"
+
+
+class ModalityDataType(str, Enum):
+    URL = "url"
+    BASE64 = "base64"
+
+
+class ImageFormat(str, Enum):
+    PNG = "png"
+    JPG = "jpg"
+    JPEG = "jpeg"
+    GIF = "gif"
+    WEBP = "webp"
+
+
+class DistributionType(str, Enum):
+    UNIFORM = "uniform"
+    MANUAL = "manual"
+
+
+class ModalityContext(ABC, BaseModel):
+    modality: Modality
+    column_name: str
+    data_type: ModalityDataType
+
+    @abstractmethod
+    def get_context(self, record: dict) -> dict[str, Any]: ...
+
+
+class ImageContext(ModalityContext):
+    modality: Modality = Modality.IMAGE
+    image_format: Optional[ImageFormat] = None
+
+    def get_context(self, record: dict) -> dict[str, Any]:
+        context = dict(type="image_url")
+        context_value = record[self.column_name]
+        if self.data_type == ModalityDataType.URL:
+            context["image_url"] = context_value
+        else:
+            context["image_url"] = {
+                "url": f"data:image/{self.image_format.value};base64,{context_value}",
+                "format": self.image_format.value,
+            }
+        return context
+
+    @model_validator(mode="after")
+    def _validate_image_format(self) -> Self:
+        if self.data_type == ModalityDataType.BASE64 and self.image_format is None:
+            raise ValueError(f"image_format is required when data_type is {self.data_type.value}")
+        return self
+
+
+DistributionParamsT = TypeVar("DistributionParamsT", bound=ConfigBase)
+
+
+class Distribution(ABC, ConfigBase, Generic[DistributionParamsT]):
+    distribution_type: DistributionType
+    params: DistributionParamsT
+
+    @abstractmethod
+    def sample(self) -> float: ...
+
+
+class ManualDistributionParams(ConfigBase):
+    values: List[float] = Field(min_length=1)
+    weights: Optional[List[float]] = None
+
+    @model_validator(mode="after")
+    def _normalize_weights(self) -> Self:
+        if self.weights is not None:
+            self.weights = [w / sum(self.weights) for w in self.weights]
+        return self
+
+    @model_validator(mode="after")
+    def _validate_equal_lengths(self) -> Self:
+        if self.weights and len(self.values) != len(self.weights):
+            raise ValueError("`values` and `weights` must have the same length")
+        return self
+
+
+class ManualDistribution(Distribution[ManualDistributionParams]):
+    distribution_type: Optional[DistributionType] = "manual"
+    params: ManualDistributionParams
+
+    def sample(self) -> float:
+        return float(np.random.choice(self.params.values, p=self.params.weights))
+
+
+class UniformDistributionParams(ConfigBase):
+    low: float
+    high: float
+
+    @model_validator(mode="after")
+    def _validate_low_lt_high(self) -> Self:
+        if self.low >= self.high:
+            raise ValueError("`low` must be less than `high`")
+        return self
+
+
+class UniformDistribution(Distribution[UniformDistributionParams]):
+    distribution_type: Optional[DistributionType] = "uniform"
+    params: UniformDistributionParams
+
+    def sample(self) -> float:
+        return float(np.random.uniform(low=self.params.low, high=self.params.high, size=1)[0])
+
+
+DistributionT: TypeAlias = Union[UniformDistribution, ManualDistribution]
+
+
+class InferenceParameters(ConfigBase):
+    temperature: Optional[Union[float, DistributionT]] = None
+    top_p: Optional[Union[float, DistributionT]] = None
+    max_tokens: Optional[int] = Field(default=None, ge=1)
+    max_parallel_requests: int = Field(default=4, ge=1)
+    timeout: Optional[int] = Field(default=None, ge=1)
+    extra_body: Optional[dict[str, Any]] = None
+
+    @property
+    def generate_kwargs(self) -> dict[str, Union[float, int]]:
+        result = {}
+        if self.temperature is not None:
+            result["temperature"] = (
+                self.temperature.sample() if hasattr(self.temperature, "sample") else self.temperature
+            )
+        if self.top_p is not None:
+            result["top_p"] = self.top_p.sample() if hasattr(self.top_p, "sample") else self.top_p
+        if self.max_tokens is not None:
+            result["max_tokens"] = self.max_tokens
+        if self.timeout is not None:
+            result["timeout"] = self.timeout
+        if self.extra_body is not None and self.extra_body != {}:
+            result["extra_body"] = self.extra_body
+        return result
+
+    @model_validator(mode="after")
+    def _validate_temperature(self) -> Self:
+        return self._run_validation(
+            value=self.temperature,
+            param_name="temperature",
+            min_value=MIN_TEMPERATURE,
+            max_value=MAX_TEMPERATURE,
+        )
+
+    @model_validator(mode="after")
+    def _validate_top_p(self) -> Self:
+        return self._run_validation(
+            value=self.top_p,
+            param_name="top_p",
+            min_value=MIN_TOP_P,
+            max_value=MAX_TOP_P,
+        )
+
+    def _run_validation(
+        self,
+        value: Union[float, DistributionT, None],
+        param_name: str,
+        min_value: float,
+        max_value: float,
+    ) -> Self:
+        if value is None:
+            return self
+        value_err = ValueError(f"{param_name} defined in model config must be between {min_value} and {max_value}")
+        if isinstance(value, Distribution):
+            if value.distribution_type == DistributionType.UNIFORM:
+                if value.params.low < min_value or value.params.high > max_value:
+                    raise value_err
+            elif value.distribution_type == DistributionType.MANUAL:
+                if any(not self._is_value_in_range(v, min_value, max_value) for v in value.params.values):
+                    raise value_err
+        else:
+            if not self._is_value_in_range(value, min_value, max_value):
+                raise value_err
+        return self
+
+    def _is_value_in_range(self, value: float, min_value: float, max_value: float) -> bool:
+        return min_value <= value <= max_value
+
+
+class ModelConfig(ConfigBase):
+    alias: str
+    model: str
+    inference_parameters: InferenceParameters = Field(default_factory=InferenceParameters)
+    provider: Optional[str] = None
+
+
+class ModelProvider(ConfigBase):
+    name: str
+    endpoint: str
+    provider_type: str = "openai"
+    api_key: Optional[str] = None
+    extra_body: Optional[dict[str, Any]] = None
+
+
+def load_model_configs(model_configs: Union[list[ModelConfig], str, Path]) -> list[ModelConfig]:
+    if isinstance(model_configs, list) and all(isinstance(mc, ModelConfig) for mc in model_configs):
+        return model_configs
+    json_config = smart_load_yaml(model_configs)
+    if "model_configs" not in json_config:
+        raise InvalidConfigError(
+            "The list of model configs must be provided under model_configs in the configuration file."
+        )
+    return [ModelConfig.model_validate(mc) for mc in json_config["model_configs"]]

data_designer/config/preview_results.py

@@ -0,0 +1,32 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from typing import Optional
+
+import pandas as pd
+
+from .analysis.dataset_profiler import DatasetProfilerResults
+from .config_builder import DataDesignerConfigBuilder
+from .utils.visualization import WithRecordSamplerMixin
+
+
+class PreviewResults(WithRecordSamplerMixin):
+    def __init__(
+        self,
+        *,
+        config_builder: DataDesignerConfigBuilder,
+        dataset: Optional[pd.DataFrame] = None,
+        analysis: Optional[DatasetProfilerResults] = None,
+    ):
+        """Creates a new instance with results from a Data Designer preview run.
+
+        Args:
+            config_builder: Data Designer configuration builder.
+            dataset: Dataset of the preview run.
+            analysis: Analysis of the preview run.
+        """
+        self.dataset: pd.DataFrame | None = dataset
+        self.analysis: DatasetProfilerResults | None = analysis
+        self._config_builder = config_builder