data-designer-config 0.4.0rc2__tar.gz → 0.5.0rc1__tar.gz

{data_designer_config-0.4.0rc2 → data_designer_config-0.5.0rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: data-designer-config
-Version: 0.4.0rc2
+Version: 0.5.0rc1
 Summary: Configuration layer for DataDesigner synthetic data generation
 License-Expression: Apache-2.0
 Classifier: Development Status :: 4 - Beta

{data_designer_config-0.4.0rc2 → data_designer_config-0.5.0rc1}/pyproject.toml

@@ -31,16 +31,16 @@ dependencies = [
 ]
 
 [build-system]
-requires = ["hatchling", "hatch-vcs"]
+requires = ["hatchling", "uv-dynamic-versioning>=0.7.0"]
 build-backend = "hatchling.build"
 
 [tool.hatch.version]
-source = "vcs"
-fallback-version = "0.1.0.dev0"
-raw-options = { root = "../.." }
+source = "uv-dynamic-versioning"
 
-[tool.hatch.build.hooks.vcs]
-version-file = "src/data_designer/config/_version.py"
+[tool.uv-dynamic-versioning]
+vcs = "git"
+style = "pep440"
+bump = true
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/data_designer"]
@@ -48,5 +48,10 @@ packages = ["src/data_designer"]
 [tool.ruff]
 extend = "../../pyproject.toml"
 
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_default_fixture_loop_scope = "session"
+env = ["DISABLE_DATA_DESIGNER_PLUGINS=true"]
+
 [tool.uv]
 package = true

data_designer_config-0.5.0rc1/src/data_designer/config/__init__.py

@@ -0,0 +1,226 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import importlib
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    # These imports are for IDE autocomplete and type checking only.
+    # At runtime, __getattr__ lazily loads the actual objects.
+    from data_designer.config.analysis.column_profilers import (  # noqa: F401
+        JudgeScoreProfilerConfig,
+    )
+    from data_designer.config.column_configs import (  # noqa: F401
+        CustomColumnConfig,
+        EmbeddingColumnConfig,
+        ExpressionColumnConfig,
+        GenerationStrategy,
+        LLMCodeColumnConfig,
+        LLMJudgeColumnConfig,
+        LLMStructuredColumnConfig,
+        LLMTextColumnConfig,
+        SamplerColumnConfig,
+        Score,
+        SeedDatasetColumnConfig,
+        ValidationColumnConfig,
+    )
+    from data_designer.config.column_types import DataDesignerColumnType  # noqa: F401
+    from data_designer.config.config_builder import DataDesignerConfigBuilder  # noqa: F401
+    from data_designer.config.custom_column import custom_column_generator  # noqa: F401
+    from data_designer.config.data_designer_config import DataDesignerConfig  # noqa: F401
+    from data_designer.config.dataset_builders import BuildStage  # noqa: F401
+    from data_designer.config.mcp import (  # noqa: F401
+        LocalStdioMCPProvider,
+        MCPProvider,
+        ToolConfig,
+    )
+    from data_designer.config.models import (  # noqa: F401
+        ChatCompletionInferenceParams,
+        EmbeddingInferenceParams,
+        GenerationType,
+        ImageContext,
+        ImageFormat,
+        ManualDistribution,
+        ManualDistributionParams,
+        Modality,
+        ModalityContext,
+        ModalityDataType,
+        ModelConfig,
+        ModelProvider,
+        UniformDistribution,
+        UniformDistributionParams,
+    )
+    from data_designer.config.processors import (  # noqa: F401
+        DropColumnsProcessorConfig,
+        ProcessorType,
+        SchemaTransformProcessorConfig,
+    )
+    from data_designer.config.run_config import RunConfig  # noqa: F401
+    from data_designer.config.sampler_constraints import (  # noqa: F401
+        ColumnInequalityConstraint,
+        ScalarInequalityConstraint,
+    )
+    from data_designer.config.sampler_params import (  # noqa: F401
+        BernoulliMixtureSamplerParams,
+        BernoulliSamplerParams,
+        BinomialSamplerParams,
+        CategorySamplerParams,
+        DatetimeSamplerParams,
+        GaussianSamplerParams,
+        PersonFromFakerSamplerParams,
+        PersonSamplerParams,
+        PoissonSamplerParams,
+        SamplerType,
+        ScipySamplerParams,
+        SubcategorySamplerParams,
+        TimeDeltaSamplerParams,
+        UniformSamplerParams,
+        UUIDSamplerParams,
+    )
+    from data_designer.config.seed import (  # noqa: F401
+        IndexRange,
+        PartitionBlock,
+        SamplingStrategy,
+        SeedConfig,
+    )
+    from data_designer.config.seed_source import (  # noqa: F401
+        DataFrameSeedSource,
+        HuggingFaceSeedSource,
+        LocalFileSeedSource,
+    )
+    from data_designer.config.utils.code_lang import CodeLang  # noqa: F401
+    from data_designer.config.utils.info import InfoType  # noqa: F401
+    from data_designer.config.utils.trace_type import TraceType  # noqa: F401
+    from data_designer.config.validator_params import (  # noqa: F401
+        CodeValidatorParams,
+        LocalCallableValidatorParams,
+        RemoteValidatorParams,
+        ValidatorType,
+    )
+
+# Base module path and submodule paths for lazy imports
+_MOD_BASE = "data_designer.config"
+_MOD_COLUMN_CONFIGS = f"{_MOD_BASE}.column_configs"
+_MOD_MCP = f"{_MOD_BASE}.mcp"
+_MOD_MODELS = f"{_MOD_BASE}.models"
+_MOD_PROCESSORS = f"{_MOD_BASE}.processors"
+_MOD_SAMPLER_CONSTRAINTS = f"{_MOD_BASE}.sampler_constraints"
+_MOD_SAMPLER_PARAMS = f"{_MOD_BASE}.sampler_params"
+_MOD_SEED = f"{_MOD_BASE}.seed"
+_MOD_SEED_SOURCE = f"{_MOD_BASE}.seed_source"
+_MOD_VALIDATOR_PARAMS = f"{_MOD_BASE}.validator_params"
+_MOD_UTILS = f"{_MOD_BASE}.utils"
+
+# Mapping of export names to (module_path, attribute_name) for lazy loading
+_LAZY_IMPORTS: dict[str, tuple[str, str]] = {
+    # analysis.column_profilers
+    "JudgeScoreProfilerConfig": (f"{_MOD_BASE}.analysis.column_profilers", "JudgeScoreProfilerConfig"),
+    # column_configs
+    "CustomColumnConfig": (_MOD_COLUMN_CONFIGS, "CustomColumnConfig"),
+    "EmbeddingColumnConfig": (_MOD_COLUMN_CONFIGS, "EmbeddingColumnConfig"),
+    "ExpressionColumnConfig": (_MOD_COLUMN_CONFIGS, "ExpressionColumnConfig"),
+    "GenerationStrategy": (_MOD_COLUMN_CONFIGS, "GenerationStrategy"),
+    "LLMCodeColumnConfig": (_MOD_COLUMN_CONFIGS, "LLMCodeColumnConfig"),
+    "LLMJudgeColumnConfig": (_MOD_COLUMN_CONFIGS, "LLMJudgeColumnConfig"),
+    "LLMStructuredColumnConfig": (_MOD_COLUMN_CONFIGS, "LLMStructuredColumnConfig"),
+    "LLMTextColumnConfig": (_MOD_COLUMN_CONFIGS, "LLMTextColumnConfig"),
+    "SamplerColumnConfig": (_MOD_COLUMN_CONFIGS, "SamplerColumnConfig"),
+    "Score": (_MOD_COLUMN_CONFIGS, "Score"),
+    "SeedDatasetColumnConfig": (_MOD_COLUMN_CONFIGS, "SeedDatasetColumnConfig"),
+    "ValidationColumnConfig": (_MOD_COLUMN_CONFIGS, "ValidationColumnConfig"),
+    # column_types
+    "DataDesignerColumnType": (f"{_MOD_BASE}.column_types", "DataDesignerColumnType"),
+    # config_builder
+    "DataDesignerConfigBuilder": (f"{_MOD_BASE}.config_builder", "DataDesignerConfigBuilder"),
+    # custom_column
+    "custom_column_generator": (f"{_MOD_BASE}.custom_column", "custom_column_generator"),
+    # data_designer_config
+    "DataDesignerConfig": (f"{_MOD_BASE}.data_designer_config", "DataDesignerConfig"),
+    # dataset_builders
+    "BuildStage": (f"{_MOD_BASE}.dataset_builders", "BuildStage"),
+    # mcp
+    "LocalStdioMCPProvider": (_MOD_MCP, "LocalStdioMCPProvider"),
+    "MCPProvider": (_MOD_MCP, "MCPProvider"),
+    "ToolConfig": (_MOD_MCP, "ToolConfig"),
+    # models
+    "ChatCompletionInferenceParams": (_MOD_MODELS, "ChatCompletionInferenceParams"),
+    "EmbeddingInferenceParams": (_MOD_MODELS, "EmbeddingInferenceParams"),
+    "GenerationType": (_MOD_MODELS, "GenerationType"),
+    "ImageContext": (_MOD_MODELS, "ImageContext"),
+    "ImageFormat": (_MOD_MODELS, "ImageFormat"),
+    "ManualDistribution": (_MOD_MODELS, "ManualDistribution"),
+    "ManualDistributionParams": (_MOD_MODELS, "ManualDistributionParams"),
+    "Modality": (_MOD_MODELS, "Modality"),
+    "ModalityContext": (_MOD_MODELS, "ModalityContext"),
+    "ModalityDataType": (_MOD_MODELS, "ModalityDataType"),
+    "ModelConfig": (_MOD_MODELS, "ModelConfig"),
+    "ModelProvider": (_MOD_MODELS, "ModelProvider"),
+    "UniformDistribution": (_MOD_MODELS, "UniformDistribution"),
+    "UniformDistributionParams": (_MOD_MODELS, "UniformDistributionParams"),
+    # processors
+    "DropColumnsProcessorConfig": (_MOD_PROCESSORS, "DropColumnsProcessorConfig"),
+    "ProcessorType": (_MOD_PROCESSORS, "ProcessorType"),
+    "SchemaTransformProcessorConfig": (_MOD_PROCESSORS, "SchemaTransformProcessorConfig"),
+    # run_config
+    "RunConfig": (f"{_MOD_BASE}.run_config", "RunConfig"),
+    # sampler_constraints
+    "ColumnInequalityConstraint": (_MOD_SAMPLER_CONSTRAINTS, "ColumnInequalityConstraint"),
+    "ScalarInequalityConstraint": (_MOD_SAMPLER_CONSTRAINTS, "ScalarInequalityConstraint"),
+    # sampler_params
+    "BernoulliMixtureSamplerParams": (_MOD_SAMPLER_PARAMS, "BernoulliMixtureSamplerParams"),
+    "BernoulliSamplerParams": (_MOD_SAMPLER_PARAMS, "BernoulliSamplerParams"),
+    "BinomialSamplerParams": (_MOD_SAMPLER_PARAMS, "BinomialSamplerParams"),
+    "CategorySamplerParams": (_MOD_SAMPLER_PARAMS, "CategorySamplerParams"),
+    "DatetimeSamplerParams": (_MOD_SAMPLER_PARAMS, "DatetimeSamplerParams"),
+    "GaussianSamplerParams": (_MOD_SAMPLER_PARAMS, "GaussianSamplerParams"),
+    "PersonFromFakerSamplerParams": (_MOD_SAMPLER_PARAMS, "PersonFromFakerSamplerParams"),
+    "PersonSamplerParams": (_MOD_SAMPLER_PARAMS, "PersonSamplerParams"),
+    "PoissonSamplerParams": (_MOD_SAMPLER_PARAMS, "PoissonSamplerParams"),
+    "SamplerType": (_MOD_SAMPLER_PARAMS, "SamplerType"),
+    "ScipySamplerParams": (_MOD_SAMPLER_PARAMS, "ScipySamplerParams"),
+    "SubcategorySamplerParams": (_MOD_SAMPLER_PARAMS, "SubcategorySamplerParams"),
+    "TimeDeltaSamplerParams": (_MOD_SAMPLER_PARAMS, "TimeDeltaSamplerParams"),
+    "UniformSamplerParams": (_MOD_SAMPLER_PARAMS, "UniformSamplerParams"),
+    "UUIDSamplerParams": (_MOD_SAMPLER_PARAMS, "UUIDSamplerParams"),
+    # seed
+    "IndexRange": (_MOD_SEED, "IndexRange"),
+    "PartitionBlock": (_MOD_SEED, "PartitionBlock"),
+    "SamplingStrategy": (_MOD_SEED, "SamplingStrategy"),
+    "SeedConfig": (_MOD_SEED, "SeedConfig"),
+    # seed_source
+    "DataFrameSeedSource": (_MOD_SEED_SOURCE, "DataFrameSeedSource"),
+    "HuggingFaceSeedSource": (_MOD_SEED_SOURCE, "HuggingFaceSeedSource"),
+    "LocalFileSeedSource": (_MOD_SEED_SOURCE, "LocalFileSeedSource"),
+    # utils
+    "CodeLang": (f"{_MOD_UTILS}.code_lang", "CodeLang"),
+    "InfoType": (f"{_MOD_UTILS}.info", "InfoType"),
+    "TraceType": (f"{_MOD_UTILS}.trace_type", "TraceType"),
+    # validator_params
+    "CodeValidatorParams": (_MOD_VALIDATOR_PARAMS, "CodeValidatorParams"),
+    "LocalCallableValidatorParams": (_MOD_VALIDATOR_PARAMS, "LocalCallableValidatorParams"),
+    "RemoteValidatorParams": (_MOD_VALIDATOR_PARAMS, "RemoteValidatorParams"),
+    "ValidatorType": (_MOD_VALIDATOR_PARAMS, "ValidatorType"),
+}
+
+__all__ = list(_LAZY_IMPORTS.keys())
+
+
+def __getattr__(name: str) -> object:
+    """Lazily import config module exports when accessed.
+
+    This allows fast imports of data_designer.config while deferring loading
+    of submodules until they're actually needed.
+    """
+    if name in _LAZY_IMPORTS:
+        module_path, attr_name = _LAZY_IMPORTS[name]
+        module = importlib.import_module(module_path)
+        return getattr(module, attr_name)
+
+    raise AttributeError(f"module 'data_designer.config' has no attribute {name!r}")
+
+
+def __dir__() -> list[str]:
+    """Return list of available exports for tab-completion."""
+    return __all__

data_designer_config-0.5.0rc1/src/data_designer/config/base.py

@@ -0,0 +1,67 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+# IMPORTANT: This module must NOT import from any data_designer submodules (i.e., data_designer.*).
+# These base abstractions are foundational and should only depend on pydantic and Python builtins.
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+from pydantic import BaseModel, ConfigDict
+
+
+class ConfigBase(BaseModel):
+    model_config = ConfigDict(
+        protected_namespaces=(),
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="forbid",
+        json_schema_mode_override="validation",
+    )
+
+
+class SingleColumnConfig(ConfigBase, ABC):
+    """Abstract base class for all single-column configuration types.
+
+    This class serves as the foundation for all column configurations in DataDesigner,
+    defining shared fields and properties across all column types.
+
+    Attributes:
+        name: Unique name of the column to be generated.
+        drop: If True, the column will be generated but removed from the final dataset.
+            Useful for intermediate columns that are dependencies for other columns.
+        column_type: Discriminator field that identifies the specific column type.
+            Subclasses must override this field to specify the column type with a `Literal` value.
+    """
+
+    name: str
+    drop: bool = False
+    column_type: str
+
+    @staticmethod
+    def get_column_emoji() -> str:
+        return "🎨"
+
+    @property
+    @abstractmethod
+    def required_columns(self) -> list[str]:
+        """Returns a list of column names that must exist before this column can be generated.
+
+        Returns:
+            List of column names that this column depends on. Empty list indicates
+            no dependencies. Override in subclasses to specify dependencies.
+        """
+
+    @property
+    @abstractmethod
+    def side_effect_columns(self) -> list[str]:
+        """Returns a list of additional columns that this column will create as a side effect.
+
+        Some column types generate additional metadata or auxiliary columns alongside
+        the primary column (e.g., reasoning traces for LLM columns).
+
+        Returns:
+            List of column names that this column will create as a side effect. Empty list
+            indicates no side effect columns. Override in subclasses to specify side effects.
+        """

{data_designer_config-0.4.0rc2 → data_designer_config-0.5.0rc1}/src/data_designer/config/column_configs.py

@@ -3,66 +3,28 @@
 
 from __future__ import annotations
 
-from abc import ABC, abstractmethod
-from typing import Annotated, Literal
+from enum import Enum
+from typing import Annotated, Any, Literal
 
-from pydantic import BaseModel, Discriminator, Field, model_validator
+from pydantic import BaseModel, Discriminator, Field, field_serializer, field_validator, model_validator
 from typing_extensions import Self
 
-from data_designer.config.base import ConfigBase
+from data_designer.config.base import ConfigBase, SingleColumnConfig
 from data_designer.config.errors import InvalidConfigError
 from data_designer.config.models import ImageContext
 from data_designer.config.sampler_params import SamplerParamsT, SamplerType
 from data_designer.config.utils.code_lang import CodeLang
-from data_designer.config.utils.constants import REASONING_TRACE_COLUMN_POSTFIX
+from data_designer.config.utils.constants import REASONING_CONTENT_COLUMN_POSTFIX, TRACE_COLUMN_POSTFIX
 from data_designer.config.utils.misc import assert_valid_jinja2_template, extract_keywords_from_jinja2_template
+from data_designer.config.utils.trace_type import TraceType
 from data_designer.config.validator_params import ValidatorParamsT, ValidatorType
 
 
-class SingleColumnConfig(ConfigBase, ABC):
-    """Abstract base class for all single-column configuration types.
+class GenerationStrategy(str, Enum):
+    """Strategy for custom column generation."""
 
-    This class serves as the foundation for all column configurations in DataDesigner,
-    defining shared fields and properties across all column types.
-
-    Attributes:
-        name: Unique name of the column to be generated.
-        drop: If True, the column will be generated but removed from the final dataset.
-            Useful for intermediate columns that are dependencies for other columns.
-        column_type: Discriminator field that identifies the specific column type.
-            Subclasses must override this field to specify the column type with a `Literal` value.
-    """
-
-    name: str
-    drop: bool = False
-    column_type: str
-
-    @staticmethod
-    def get_column_emoji() -> str:
-        return "🎨"
-
-    @property
-    @abstractmethod
-    def required_columns(self) -> list[str]:
-        """Returns a list of column names that must exist before this column can be generated.
-
-        Returns:
-            List of column names that this column depends on. Empty list indicates
-            no dependencies. Override in subclasses to specify dependencies.
-        """
-
-    @property
-    @abstractmethod
-    def side_effect_columns(self) -> list[str]:
-        """Returns a list of additional columns that this column will create as a side effect.
-
-        Some column types generate additional metadata or auxiliary columns alongside
-        the primary column (e.g., reasoning traces for LLM columns).
-
-        Returns:
-            List of column names that this column will create as a side effect. Empty list
-            indicates no side effect columns. Override in subclasses to specify side effects.
-        """
+    CELL_BY_CELL = "cell_by_cell"
+    FULL_COLUMN = "full_column"
 
 
 class SamplerColumnConfig(SingleColumnConfig):
@@ -143,8 +105,8 @@ class LLMTextColumnConfig(SingleColumnConfig):
 
     LLM text columns generate free-form text content using language models via LiteLLM.
     Prompts support Jinja2 templating to reference values from other columns, enabling
-    context-aware generation. The generated text can optionally include reasoning traces
-    when models support extended thinking.
+    context-aware generation. The generated text can optionally include message traces
+    capturing the full conversation history.
 
     Attributes:
         prompt: Prompt template for text generation. Supports Jinja2 syntax to
@@ -159,6 +121,18 @@ class LLMTextColumnConfig(SingleColumnConfig):
             `LLMStructuredColumnConfig` for structured output, `LLMCodeColumnConfig` for code.
         multi_modal_context: Optional list of image contexts for multi-modal generation.
             Enables vision-capable models to generate text based on image inputs.
+        tool_alias: Optional alias of the tool configuration to use for MCP tool calls.
+            Must match a tool alias defined when initializing the DataDesignerConfigBuilder.
+            When provided, the model may call permitted tools during generation.
+        with_trace: Specifies what trace information to capture in a `{column_name}__trace`
+            column. Options are:
+            - `TraceType.NONE` (default): No trace is captured.
+            - `TraceType.LAST_MESSAGE`: Only the final assistant message is captured.
+            - `TraceType.ALL_MESSAGES`: Full conversation history (system/user/assistant/tool).
+        extract_reasoning_content: If True, creates a `{column_name}__reasoning_content` column
+            containing only the reasoning_content from the final assistant response. This is
+            useful for models that expose chain-of-thought reasoning separately from the main
+            response. Defaults to False.
         column_type: Discriminator field, always "llm-text" for this configuration type.
     """
 
@@ -166,6 +140,9 @@ class LLMTextColumnConfig(SingleColumnConfig):
     model_alias: str
     system_prompt: str | None = None
     multi_modal_context: list[ImageContext] | None = None
+    tool_alias: str | None = None
+    with_trace: TraceType = TraceType.NONE
+    extract_reasoning_content: bool = False
     column_type: Literal["llm-text"] = "llm-text"
 
     @staticmethod
@@ -186,14 +163,20 @@ class LLMTextColumnConfig(SingleColumnConfig):
 
     @property
     def side_effect_columns(self) -> list[str]:
-        """Returns the reasoning trace column, which may be generated alongside the main column.
+        """Returns side-effect columns that may be generated alongside the main column.
 
-        Reasoning traces are only returned if the served model parses and returns reasoning content.
+        Side-effect columns include:
+        - `{name}__trace`: Generated when `with_trace` is not `TraceType.NONE` on the column
+          config.
+        - `{name}__reasoning_content`: Generated when `extract_reasoning_content=True`.
 
         Returns:
-            List containing the reasoning trace column name.
+            List of side-effect column names.
         """
-        return [f"{self.name}{REASONING_TRACE_COLUMN_POSTFIX}"]
+        return [
+            *([f"{self.name}{TRACE_COLUMN_POSTFIX}"] if self.with_trace != TraceType.NONE else []),
+            *([f"{self.name}{REASONING_CONTENT_COLUMN_POSTFIX}"] if self.extract_reasoning_content else []),
+        ]
 
     @model_validator(mode="after")
     def assert_prompt_valid_jinja(self) -> Self:
@@ -216,7 +199,7 @@ class LLMCodeColumnConfig(LLMTextColumnConfig):
 
     Extends LLMTextColumnConfig to generate code snippets in specific programming languages
     or SQL dialects. The generated code is automatically extracted from markdown code blocks
-    for the specified language. Inherits all prompt templating capabilities.
+    for the specified language. Inherits all prompt templating capabilities from LLMTextColumnConfig.
 
     Attributes:
         code_lang: Programming language or SQL dialect for code generation. Supported
@@ -224,6 +207,16 @@ class LLMCodeColumnConfig(LLMTextColumnConfig):
             "rust", "ruby", "scala", "swift", "sql:sqlite", "sql:postgres", "sql:mysql",
             "sql:tsql", "sql:bigquery", "sql:ansi". See CodeLang enum for complete list.
         column_type: Discriminator field, always "llm-code" for this configuration type.
+
+    Inherited Attributes:
+        prompt: Prompt template for code generation (supports Jinja2).
+        model_alias: Alias of the model configuration to use.
+        system_prompt: Optional system prompt (supports Jinja2).
+        multi_modal_context: Optional image contexts for multi-modal generation.
+        tool_alias: Optional tool configuration alias for MCP tool calls.
+        with_trace: If True, creates a `{column_name}__trace` column with message history.
+        extract_reasoning_content: If True, creates a `{column_name}__reasoning_content`
+            column containing the reasoning content from the final assistant response.
     """
 
     code_lang: CodeLang
@@ -239,13 +232,24 @@ class LLMStructuredColumnConfig(LLMTextColumnConfig):
 
     Extends LLMTextColumnConfig to generate structured data conforming to a specified schema.
     Uses JSON schema or Pydantic models to define the expected output structure, enabling
-    type-safe and validated structured output generation. Inherits prompt templating capabilities.
+    type-safe and validated structured output generation. Inherits prompt templating capabilities
+    from LLMTextColumnConfig.
 
     Attributes:
         output_format: The schema defining the expected output structure. Can be either:
             - A Pydantic BaseModel class (recommended)
             - A JSON schema dictionary
         column_type: Discriminator field, always "llm-structured" for this configuration type.
+
+    Inherited Attributes:
+        prompt: Prompt template for structured generation (supports Jinja2).
+        model_alias: Alias of the model configuration to use.
+        system_prompt: Optional system prompt (supports Jinja2).
+        multi_modal_context: Optional image contexts for multi-modal generation.
+        tool_alias: Optional tool configuration alias for MCP tool calls.
+        with_trace: If True, creates a `{column_name}__trace` column with message history.
+        extract_reasoning_content: If True, creates a `{column_name}__reasoning_content`
+            column containing the reasoning content from the final assistant response.
     """
 
     output_format: dict | type[BaseModel]
@@ -293,13 +297,24 @@ class LLMJudgeColumnConfig(LLMTextColumnConfig):
 
     Extends LLMTextColumnConfig to create judge columns that evaluate and score other
     generated content based on the defined criteria. Useful for quality assessment, preference
-    ranking, and multi-dimensional evaluation of generated data.
+    ranking, and multi-dimensional evaluation of generated data. Inherits prompt templating
+    capabilities from LLMTextColumnConfig.
 
     Attributes:
         scores: List of Score objects defining the evaluation dimensions. Each score
             represents a different aspect to evaluate (e.g., accuracy, relevance, fluency).
             Must contain at least one score.
         column_type: Discriminator field, always "llm-judge" for this configuration type.
+
+    Inherited Attributes:
+        prompt: Prompt template for the judge evaluation (supports Jinja2).
+        model_alias: Alias of the model configuration to use.
+        system_prompt: Optional system prompt (supports Jinja2).
+        multi_modal_context: Optional image contexts for multi-modal generation.
+        tool_alias: Optional tool configuration alias for MCP tool calls.
+        with_trace: If True, creates a `{column_name}__trace` column with message history.
+        extract_reasoning_content: If True, creates a `{column_name}__reasoning_content`
+            column containing the reasoning content from the final assistant response.
     """
 
     scores: list[Score] = Field(..., min_length=1)
@@ -468,3 +483,80 @@ class EmbeddingColumnConfig(SingleColumnConfig):
     @property
     def side_effect_columns(self) -> list[str]:
         return []
+
+
+class CustomColumnConfig(SingleColumnConfig):
+    """Configuration for custom user-defined column generators.
+
+    Custom columns allow users to provide their own generation logic via a callable function
+    decorated with `@custom_column_generator`. Two strategies are supported: cell_by_cell
+    (default, row-based) and full_column (batch-based with DataFrame access).
+
+    Attributes:
+        generator_function: A callable decorated with @custom_column_generator.
+        generation_strategy: "cell_by_cell" (row-based) or "full_column" (batch-based).
+        generator_params: Optional typed configuration object (Pydantic BaseModel) passed
+            as the second argument to the generator function.
+        column_type: Discriminator field, always "custom" for this configuration type.
+    """
+
+    generator_function: Any = Field(description="Function decorated with @custom_column_generator")
+    generation_strategy: GenerationStrategy = Field(
+        default=GenerationStrategy.CELL_BY_CELL,
+        description="Generation strategy: 'cell_by_cell' for row-based or 'full_column' for batch-based",
+    )
+    generator_params: BaseModel | None = Field(
+        default=None,
+        description="Optional typed configuration object passed as second argument to generator function",
+    )
+    column_type: Literal["custom"] = "custom"
+
+    @field_validator("generator_function")
+    @classmethod
+    def _validate_generator_function(cls, v: Any) -> Any:
+        if not callable(v):
+            raise ValueError("generator_function must be callable")
+        if not hasattr(v, "custom_column_metadata"):
+            raise ValueError("generator_function must be decorated with @custom_column_generator")
+        return v
+
+    @staticmethod
+    def get_column_emoji() -> str:
+        return "🔧"
+
+    @property
+    def required_columns(self) -> list[str]:
+        """Returns the columns required for custom generation (from decorator metadata)."""
+        metadata = getattr(self.generator_function, "custom_column_metadata", {})
+        return metadata.get("required_columns", [])
+
+    @property
+    def side_effect_columns(self) -> list[str]:
+        """Returns additional columns created by this generator (from decorator metadata)."""
+        metadata = getattr(self.generator_function, "custom_column_metadata", {})
+        return metadata.get("side_effect_columns", [])
+
+    @property
+    def model_aliases(self) -> list[str]:
+        """Returns model aliases for LLM access and health checks (from decorator metadata)."""
+        metadata = getattr(self.generator_function, "custom_column_metadata", {})
+        return metadata.get("model_aliases", [])
+
+    @field_serializer("generator_function")
+    def serialize_generator_function(self, v: Any) -> str:
+        return getattr(v, "__name__", repr(v))
+
+    @field_serializer("generator_params")
+    def serialize_generator_params(self, v: BaseModel | None) -> dict[str, Any] | None:
+        if v is None:
+            return None
+        return v.model_dump()
+
+    @model_validator(mode="after")
+    def validate_generator_function(self) -> Self:
+        if not callable(self.generator_function):
+            raise InvalidConfigError(
+                f"🛑 `generator_function` must be a callable for custom column '{self.name}'. "
+                f"Expected a function decorated with @custom_column_generator."
+            )
+        return self

{data_designer_config-0.4.0rc2 → data_designer_config-0.5.0rc1}/src/data_designer/config/column_types.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 from typing_extensions import TypeAlias
 
 from data_designer.config.column_configs import (
+    CustomColumnConfig,
     EmbeddingColumnConfig,
     ExpressionColumnConfig,
     LLMCodeColumnConfig,
@@ -28,7 +29,8 @@ from data_designer.plugin_manager import PluginManager
 plugin_manager = PluginManager()
 
 ColumnConfigT: TypeAlias = (
-    ExpressionColumnConfig
+    CustomColumnConfig
+    | ExpressionColumnConfig
     | LLMCodeColumnConfig
     | LLMJudgeColumnConfig
     | LLMStructuredColumnConfig
@@ -87,6 +89,7 @@ def get_column_display_order() -> list[DataDesignerColumnType]:
         DataDesignerColumnType.EMBEDDING,
         DataDesignerColumnType.VALIDATION,
         DataDesignerColumnType.EXPRESSION,
+        DataDesignerColumnType.CUSTOM,
     ]
     display_order.extend(plugin_manager.get_plugin_column_types(DataDesignerColumnType))
     return display_order
@@ -129,6 +132,7 @@ def _resolve_sampler_kwargs(name: str, kwargs: dict) -> dict:
 
 
 _COLUMN_TYPE_CONFIG_CLS_MAP = {
+    DataDesignerColumnType.CUSTOM: CustomColumnConfig,
     DataDesignerColumnType.LLM_TEXT: LLMTextColumnConfig,
     DataDesignerColumnType.LLM_CODE: LLMCodeColumnConfig,
     DataDesignerColumnType.LLM_STRUCTURED: LLMStructuredColumnConfig,