data-designer 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

data_designer/engine/analysis/column_profilers/judge_score_profiler.py

@@ -5,44 +5,41 @@ from __future__ import annotations
 
 import logging
 import random
+from typing import TYPE_CHECKING
 
 from data_designer.config.analysis.column_profilers import (
     JudgeScoreProfilerConfig,
     JudgeScoreProfilerResults,
-    JudgeScoreSample,
     JudgeScoreSummary,
 )
 from data_designer.config.analysis.column_statistics import (
-    CategoricalDistribution,
-    CategoricalHistogramData,
     ColumnDistributionType,
     MissingValue,
-    NumericalDistribution,
-)
-from data_designer.config.column_types import COLUMN_TYPE_EMOJI_MAP, DataDesignerColumnType
-from data_designer.engine.analysis.column_profilers.base import (
-    ColumnConfigWithDataFrame,
-    ColumnProfiler,
-    ColumnProfilerMetadata,
 )
+from data_designer.config.column_types import DataDesignerColumnType
+from data_designer.engine.analysis.column_profilers.base import ColumnConfigWithDataFrame, ColumnProfiler
 from data_designer.engine.analysis.utils.judge_score_processing import (
     extract_judge_score_distributions,
     sample_scores_and_reasoning,
 )
-from data_designer.engine.models.facade import ModelFacade
 from data_designer.engine.models.recipes.response_recipes import TextResponseRecipe
 
+if TYPE_CHECKING:
+    from data_designer.config.analysis.column_profilers import JudgeScoreSample
+    from data_designer.config.analysis.column_statistics import (
+        CategoricalDistribution,
+        CategoricalHistogramData,
+        NumericalDistribution,
+    )
+    from data_designer.engine.models.facade import ModelFacade
+
 logger = logging.getLogger(__name__)
 
 
 class JudgeScoreProfiler(ColumnProfiler[JudgeScoreProfilerConfig]):
     @staticmethod
-    def metadata() -> ColumnProfilerMetadata:
-        return ColumnProfilerMetadata(
-            name="judge_score_profiler",
-            description="Analyzes LLM-as-judge score distributions in a Data Designer dataset.",
-            applicable_column_types=[DataDesignerColumnType.LLM_JUDGE],
-        )
+    def get_applicable_column_types() -> list[DataDesignerColumnType]:
+        return [DataDesignerColumnType.LLM_JUDGE]
 
     def get_model(self, model_alias: str) -> ModelFacade:
         return self.resource_provider.model_registry.get_model(model_alias=model_alias)
@@ -51,8 +48,7 @@ class JudgeScoreProfiler(ColumnProfiler[JudgeScoreProfilerConfig]):
         column_config, df = column_config_with_df.as_tuple()
 
         logger.info(
-            f"{COLUMN_TYPE_EMOJI_MAP[column_config.column_type]} Analyzing LLM-as-judge "
-            f"scores for column: '{column_config.name}'"
+            f"{column_config.get_column_emoji()} Analyzing LLM-as-judge scores for column: '{column_config.name}'"
         )
 
         score_summaries = {}

data_designer/engine/analysis/column_profilers/registry.py

@@ -1,6 +1,8 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
+from __future__ import annotations
+
 from data_designer.config.analysis.column_profilers import ColumnProfilerType
 from data_designer.config.base import ConfigBase
 from data_designer.engine.analysis.column_profilers.base import ColumnProfiler

data_designer/engine/analysis/column_statistics.py

@@ -4,9 +4,8 @@
 from __future__ import annotations
 
 import logging
-from typing import Any, TypeAlias
+from typing import TYPE_CHECKING, Any, TypeAlias
 
-import pandas as pd
 from pydantic import BaseModel
 from typing_extensions import Self
 
@@ -25,6 +24,10 @@ from data_designer.engine.analysis.utils.column_statistics_calculations import (
     calculate_token_stats,
     calculate_validation_column_info,
 )
+from data_designer.lazy_heavy_imports import pd
+
+if TYPE_CHECKING:
+    import pandas as pd
 
 logger = logging.getLogger(__name__)
 

data_designer/engine/analysis/dataset_profiler.py

@@ -1,22 +1,20 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
+from __future__ import annotations
+
 import logging
 from collections.abc import Sequence
 from functools import cached_property
+from typing import TYPE_CHECKING
 
-import pandas as pd
-import pyarrow as pa
 from pydantic import Field, field_validator
 
 from data_designer.config.analysis.column_profilers import ColumnProfilerConfigT
 from data_designer.config.analysis.dataset_profiler import DatasetProfilerResults
 from data_designer.config.base import ConfigBase
 from data_designer.config.column_configs import SingleColumnConfig
-from data_designer.config.column_types import (
-    COLUMN_TYPE_EMOJI_MAP,
-    ColumnConfigT,
-)
+from data_designer.config.column_types import ColumnConfigT
 from data_designer.engine.analysis.column_profilers.base import ColumnConfigWithDataFrame, ColumnProfiler
 from data_designer.engine.analysis.column_statistics import get_column_statistics_calculator
 from data_designer.engine.analysis.errors import DatasetProfilerConfigurationError
@@ -24,6 +22,11 @@ from data_designer.engine.analysis.utils.column_statistics_calculations import h
 from data_designer.engine.dataset_builders.multi_column_configs import DatasetBuilderColumnConfigT, MultiColumnConfig
 from data_designer.engine.registry.data_designer_registry import DataDesignerRegistry
 from data_designer.engine.resources.resource_provider import ResourceProvider
+from data_designer.lazy_heavy_imports import pa, pd
+
+if TYPE_CHECKING:
+    import pandas as pd
+    import pyarrow as pa
 
 logger = logging.getLogger(__name__)
 
@@ -71,7 +74,7 @@ class DataDesignerDatasetProfiler:
 
         column_statistics = []
         for c in self.config.column_configs:
-            logger.info(f"  |-- {COLUMN_TYPE_EMOJI_MAP[c.column_type]} column: '{c.name}'")
+            logger.info(f"  |-- {c.get_column_emoji()} column: '{c.name}'")
             column_statistics.append(
                 get_column_statistics_calculator(c.column_type)(
                     column_config_with_df=ColumnConfigWithDataFrame(column_config=c, df=dataset)
@@ -81,14 +84,14 @@ class DataDesignerDatasetProfiler:
         column_profiles = []
         for profiler_config in self.config.column_profiler_configs or []:
             profiler = self._create_column_profiler(profiler_config)
-            applicable_column_types = profiler.metadata().applicable_column_types
+            applicable_column_types = profiler.get_applicable_column_types()
             for c in self.config.column_configs:
                 if c.column_type in applicable_column_types:
                     params = ColumnConfigWithDataFrame(column_config=c, df=dataset)
                     column_profiles.append(profiler.profile(params))
             if len(column_profiles) == 0:
                 logger.warning(
-                    f"⚠️ No applicable column types found for the '{profiler.metadata().name}' profiler. "
+                    f"⚠️ No applicable column types found for the '{profiler.name}' profiler. "
                     f"This profiler is applicable to the following column types: {applicable_column_types}"
                 )
 

data_designer/engine/analysis/errors.py

@@ -1,6 +1,8 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
+from __future__ import annotations
+
 from data_designer.errors import DataDesignerError
 
 

data_designer/engine/analysis/utils/column_statistics_calculations.py

@@ -5,11 +5,8 @@ from __future__ import annotations
 
 import logging
 from numbers import Number
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
-import numpy as np
-import pandas as pd
-import pyarrow as pa
 import tiktoken
 
 from data_designer.config.analysis.column_statistics import (
@@ -26,6 +23,12 @@ from data_designer.engine.column_generators.utils.prompt_renderer import (
     RecordBasedPromptRenderer,
     create_response_recipe,
 )
+from data_designer.lazy_heavy_imports import np, pa, pd
+
+if TYPE_CHECKING:
+    import numpy as np
+    import pandas as pd
+    import pyarrow as pa
 
 RANDOM_SEED = 42
 MAX_PROMPT_SAMPLE_SIZE = 1000

data_designer/engine/analysis/utils/judge_score_processing.py

@@ -1,11 +1,11 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
+from __future__ import annotations
+
 import logging
 from collections import defaultdict
-from typing import Any
-
-import pandas as pd
+from typing import TYPE_CHECKING, Any
 
 from data_designer.config.analysis.column_profilers import JudgeScoreDistributions, JudgeScoreSample
 from data_designer.config.analysis.column_statistics import (
@@ -15,6 +15,10 @@ from data_designer.config.analysis.column_statistics import (
     NumericalDistribution,
 )
 from data_designer.config.column_configs import LLMJudgeColumnConfig
+from data_designer.lazy_heavy_imports import pd
+
+if TYPE_CHECKING:
+    import pandas as pd
 
 logger = logging.getLogger(__name__)
 

data_designer/engine/column_generators/generators/base.py

@@ -9,16 +9,16 @@ from abc import ABC, abstractmethod
 from enum import Enum
 from typing import TYPE_CHECKING, overload
 
-import pandas as pd
-
-from data_designer.engine.configurable_task import ConfigurableTask, ConfigurableTaskMetadata, DataT, TaskConfigT
+from data_designer.engine.configurable_task import ConfigurableTask, DataT, TaskConfigT
+from data_designer.lazy_heavy_imports import pd
 
 if TYPE_CHECKING:
+    import pandas as pd
+
     from data_designer.config.models import BaseInferenceParams, ModelConfig
     from data_designer.engine.models.facade import ModelFacade
     from data_designer.engine.models.registry import ModelRegistry
 
-
 logger = logging.getLogger(__name__)
 
 
@@ -27,22 +27,14 @@ class GenerationStrategy(str, Enum):
     FULL_COLUMN = "full_column"
 
 
-class GeneratorMetadata(ConfigurableTaskMetadata):
-    generation_strategy: GenerationStrategy
-
-
 class ColumnGenerator(ConfigurableTask[TaskConfigT], ABC):
     @property
     def can_generate_from_scratch(self) -> bool:
         return False
 
-    @property
-    def generation_strategy(self) -> GenerationStrategy:
-        return self.metadata().generation_strategy
-
     @staticmethod
     @abstractmethod
-    def metadata() -> GeneratorMetadata: ...
+    def get_generation_strategy() -> GenerationStrategy: ...
 
     @overload
     @abstractmethod
@@ -103,8 +95,28 @@ class ColumnGeneratorWithModel(ColumnGeneratorWithModelRegistry[TaskConfigT], AB
         return self.model_config.inference_parameters
 
     def log_pre_generation(self) -> None:
-        logger.info(f"{self.config.column_type} model configuration for generating column '{self.config.name}'")
+        logger.info(
+            f"{self.config.get_column_emoji()} {self.config.column_type} model config for column '{self.config.name}'"
+        )
         logger.info(f"  |-- model: {self.model_config.model!r}")
         logger.info(f"  |-- model alias: {self.config.model_alias!r}")
         logger.info(f"  |-- model provider: {self.get_model_provider_name(model_alias=self.config.model_alias)!r}")
         logger.info(f"  |-- inference parameters: {self.inference_parameters.format_for_display()}")
+
+
+class ColumnGeneratorCellByCell(ColumnGenerator[TaskConfigT], ABC):
+    @staticmethod
+    def get_generation_strategy() -> GenerationStrategy:
+        return GenerationStrategy.CELL_BY_CELL
+
+    @abstractmethod
+    def generate(self, data: dict) -> dict: ...
+
+
+class ColumnGeneratorFullColumn(ColumnGenerator[TaskConfigT], ABC):
+    @staticmethod
+    def get_generation_strategy() -> GenerationStrategy:
+        return GenerationStrategy.FULL_COLUMN
+
+    @abstractmethod
+    def generate(self, data: pd.DataFrame) -> pd.DataFrame: ...

data_designer/engine/column_generators/generators/embedding.py

@@ -1,15 +1,12 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
+from __future__ import annotations
 
 from pydantic import BaseModel, computed_field
 
 from data_designer.config.column_configs import EmbeddingColumnConfig
-from data_designer.engine.column_generators.generators.base import (
-    ColumnGeneratorWithModel,
-    GenerationStrategy,
-    GeneratorMetadata,
-)
+from data_designer.engine.column_generators.generators.base import ColumnGeneratorWithModel, GenerationStrategy
 from data_designer.engine.processing.utils import deserialize_json_values, parse_list_string
 
 
@@ -27,12 +24,8 @@ class EmbeddingGenerationResult(BaseModel):
 
 class EmbeddingCellGenerator(ColumnGeneratorWithModel[EmbeddingColumnConfig]):
     @staticmethod
-    def metadata() -> GeneratorMetadata:
-        return GeneratorMetadata(
-            name="embedding_cell_generator",
-            description="Generate embeddings for a text column.",
-            generation_strategy=GenerationStrategy.CELL_BY_CELL,
-        )
+    def get_generation_strategy() -> GenerationStrategy:
+        return GenerationStrategy.CELL_BY_CELL
 
     def generate(self, data: dict) -> dict:
         deserialized_record = deserialize_json_values(data)

data_designer/engine/column_generators/generators/expression.py

@@ -4,31 +4,22 @@
 from __future__ import annotations
 
 import logging
-
-import pandas as pd
+from typing import TYPE_CHECKING
 
 from data_designer.config.column_configs import ExpressionColumnConfig
-from data_designer.engine.column_generators.generators.base import (
-    ColumnGenerator,
-    GenerationStrategy,
-    GeneratorMetadata,
-)
+from data_designer.engine.column_generators.generators.base import ColumnGeneratorFullColumn
 from data_designer.engine.column_generators.utils.errors import ExpressionTemplateRenderError
 from data_designer.engine.processing.ginja.environment import WithJinja2UserTemplateRendering
 from data_designer.engine.processing.utils import deserialize_json_values
+from data_designer.lazy_heavy_imports import pd
 
-logger = logging.getLogger(__name__)
+if TYPE_CHECKING:
+    import pandas as pd
 
+logger = logging.getLogger(__name__)
 
-class ExpressionColumnGenerator(WithJinja2UserTemplateRendering, ColumnGenerator[ExpressionColumnConfig]):
-    @staticmethod
-    def metadata() -> GeneratorMetadata:
-        return GeneratorMetadata(
-            name="expression_generator",
-            description="Generate a column from a jinja2 expression.",
-            generation_strategy=GenerationStrategy.FULL_COLUMN,
-        )
 
+class ExpressionColumnGenerator(WithJinja2UserTemplateRendering, ColumnGeneratorFullColumn[ExpressionColumnConfig]):
     def generate(self, data: pd.DataFrame) -> pd.DataFrame:
         logger.info(f"🧩 Generating column `{self.config.name}` from expression")
 

data_designer/engine/column_generators/generators/llm_completion.py

@@ -1,6 +1,8 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
+from __future__ import annotations
+
 import functools
 import logging
 
@@ -11,11 +13,7 @@ from data_designer.config.column_configs import (
     LLMTextColumnConfig,
 )
 from data_designer.config.utils.constants import REASONING_TRACE_COLUMN_POSTFIX
-from data_designer.engine.column_generators.generators.base import (
-    ColumnGeneratorWithModel,
-    GenerationStrategy,
-    GeneratorMetadata,
-)
+from data_designer.engine.column_generators.generators.base import ColumnGeneratorWithModel, GenerationStrategy
 from data_designer.engine.column_generators.utils.prompt_renderer import (
     PromptType,
     RecordBasedPromptRenderer,
@@ -28,22 +26,22 @@ from data_designer.engine.processing.utils import deserialize_json_values
 logger = logging.getLogger(__name__)
 
 
-DEFAULT_MAX_CONVERSATION_RESTARTS = 5
-DEFAULT_MAX_CONVERSATION_CORRECTION_STEPS = 0
-
-
 class ColumnGeneratorWithModelChatCompletion(ColumnGeneratorWithModel[TaskConfigT]):
+    @staticmethod
+    def get_generation_strategy() -> GenerationStrategy:
+        return GenerationStrategy.CELL_BY_CELL
+
     @functools.cached_property
     def response_recipe(self) -> ResponseRecipe:
         return create_response_recipe(self.config, self.model_config)
 
     @property
     def max_conversation_correction_steps(self) -> int:
-        return DEFAULT_MAX_CONVERSATION_CORRECTION_STEPS
+        return self.resource_provider.run_config.max_conversation_correction_steps
 
     @property
     def max_conversation_restarts(self) -> int:
-        return DEFAULT_MAX_CONVERSATION_RESTARTS
+        return self.resource_provider.run_config.max_conversation_restarts
 
     @functools.cached_property
     def prompt_renderer(self) -> RecordBasedPromptRenderer:
@@ -91,45 +89,13 @@ class ColumnGeneratorWithModelChatCompletion(ColumnGeneratorWithModel[TaskConfig
         return data
 
 
-class LLMTextCellGenerator(ColumnGeneratorWithModelChatCompletion[LLMTextColumnConfig]):
-    @staticmethod
-    def metadata() -> GeneratorMetadata:
-        return GeneratorMetadata(
-            name="llm_text_generator",
-            description="Generate a new dataset cell from a prompt template",
-            generation_strategy=GenerationStrategy.CELL_BY_CELL,
-        )
+class LLMTextCellGenerator(ColumnGeneratorWithModelChatCompletion[LLMTextColumnConfig]): ...
 
 
-class LLMCodeCellGenerator(ColumnGeneratorWithModelChatCompletion[LLMCodeColumnConfig]):
-    @staticmethod
-    def metadata() -> GeneratorMetadata:
-        return GeneratorMetadata(
-            name="llm_code_generator",
-            description="Generate a new dataset cell from a prompt template",
-            generation_strategy=GenerationStrategy.CELL_BY_CELL,
-        )
-
+class LLMCodeCellGenerator(ColumnGeneratorWithModelChatCompletion[LLMCodeColumnConfig]): ...
 
-class LLMStructuredCellGenerator(ColumnGeneratorWithModelChatCompletion[LLMStructuredColumnConfig]):
-    @staticmethod
-    def metadata() -> GeneratorMetadata:
-        return GeneratorMetadata(
-            name="llm_structured_generator",
-            description="Generate a new dataset cell from a prompt template",
-            generation_strategy=GenerationStrategy.CELL_BY_CELL,
-        )
 
+class LLMStructuredCellGenerator(ColumnGeneratorWithModelChatCompletion[LLMStructuredColumnConfig]): ...
 
-class LLMJudgeCellGenerator(ColumnGeneratorWithModelChatCompletion[LLMJudgeColumnConfig]):
-    @staticmethod
-    def metadata() -> GeneratorMetadata:
-        return GeneratorMetadata(
-            name="llm_judge_generator",
-            description="Judge a new dataset cell based on a set of rubrics",
-            generation_strategy=GenerationStrategy.CELL_BY_CELL,
-        )
 
-    @property
-    def max_conversation_restarts(self) -> int:
-        return 2 * DEFAULT_MAX_CONVERSATION_RESTARTS
+class LLMJudgeCellGenerator(ColumnGeneratorWithModelChatCompletion[LLMJudgeColumnConfig]): ...

data_designer/engine/column_generators/generators/samplers.py

@@ -6,34 +6,28 @@ from __future__ import annotations
 import logging
 import random
 from functools import partial
-from typing import Callable
-
-import pandas as pd
+from typing import TYPE_CHECKING, Callable
 
 from data_designer.config.utils.constants import LOCALES_WITH_MANAGED_DATASETS
-from data_designer.engine.column_generators.generators.base import (
-    FromScratchColumnGenerator,
-    GenerationStrategy,
-    GeneratorMetadata,
-)
+from data_designer.engine.column_generators.generators.base import FromScratchColumnGenerator, GenerationStrategy
 from data_designer.engine.dataset_builders.multi_column_configs import SamplerMultiColumnConfig
 from data_designer.engine.processing.utils import concat_datasets
 from data_designer.engine.resources.managed_dataset_generator import ManagedDatasetGenerator
 from data_designer.engine.sampling_gen.data_sources.sources import SamplerType
 from data_designer.engine.sampling_gen.entities.person import load_person_data_sampler
 from data_designer.engine.sampling_gen.generator import DatasetGenerator as SamplingDatasetGenerator
+from data_designer.lazy_heavy_imports import pd
+
+if TYPE_CHECKING:
+    import pandas as pd
 
 logger = logging.getLogger(__name__)
 
 
 class SamplerColumnGenerator(FromScratchColumnGenerator[SamplerMultiColumnConfig]):
     @staticmethod
-    def metadata() -> GeneratorMetadata:
-        return GeneratorMetadata(
-            name="sampler_column_generator",
-            description="Generate columns using sampling-based method.",
-            generation_strategy=GenerationStrategy.FULL_COLUMN,
-        )
+    def get_generation_strategy() -> GenerationStrategy:
+        return GenerationStrategy.FULL_COLUMN
 
     def generate(self, data: pd.DataFrame) -> pd.DataFrame:
         df_samplers = self.generate_from_scratch(len(data))

data_designer/engine/column_generators/generators/seed_dataset.py

@@ -1,24 +1,22 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-
 from __future__ import annotations
 
 import functools
 import logging
-
-import duckdb
-import pandas as pd
+from typing import TYPE_CHECKING
 
 from data_designer.config.seed import IndexRange, PartitionBlock, SamplingStrategy
-from data_designer.engine.column_generators.generators.base import (
-    FromScratchColumnGenerator,
-    GenerationStrategy,
-    GeneratorMetadata,
-)
+from data_designer.engine.column_generators.generators.base import FromScratchColumnGenerator, GenerationStrategy
 from data_designer.engine.column_generators.utils.errors import SeedDatasetError
 from data_designer.engine.dataset_builders.multi_column_configs import SeedDatasetMultiColumnConfig
 from data_designer.engine.processing.utils import concat_datasets
+from data_designer.lazy_heavy_imports import duckdb, pd
+
+if TYPE_CHECKING:
+    import duckdb
+    import pandas as pd
 
 MAX_ZERO_RECORD_RESPONSE_FACTOR = 2
 
@@ -27,12 +25,8 @@ logger = logging.getLogger(__name__)
 
 class SeedDatasetColumnGenerator(FromScratchColumnGenerator[SeedDatasetMultiColumnConfig]):
     @staticmethod
-    def metadata() -> GeneratorMetadata:
-        return GeneratorMetadata(
-            name="seed_dataset_column_generator",
-            description="Sample columns from a seed dataset.",
-            generation_strategy=GenerationStrategy.FULL_COLUMN,
-        )
+    def get_generation_strategy() -> GenerationStrategy:
+        return GenerationStrategy.FULL_COLUMN
 
     @property
     def num_records_sampled(self) -> int:

data_designer/engine/column_generators/generators/validation.py

@@ -4,21 +4,13 @@
 from __future__ import annotations
 
 import logging
-
-import pandas as pd
+from typing import TYPE_CHECKING
 
 from data_designer.config.column_configs import ValidationColumnConfig
 from data_designer.config.errors import InvalidConfigError
 from data_designer.config.utils.code_lang import SQL_DIALECTS, CodeLang
-from data_designer.config.validator_params import (
-    ValidatorParamsT,
-    ValidatorType,
-)
-from data_designer.engine.column_generators.generators.base import (
-    ColumnGenerator,
-    GenerationStrategy,
-    GeneratorMetadata,
-)
+from data_designer.config.validator_params import ValidatorParamsT, ValidatorType
+from data_designer.engine.column_generators.generators.base import ColumnGeneratorFullColumn
 from data_designer.engine.dataset_builders.utils.concurrency import ConcurrentThreadExecutor
 from data_designer.engine.errors import DataDesignerRuntimeError
 from data_designer.engine.validators import (
@@ -29,6 +21,10 @@ from data_designer.engine.validators import (
     SQLValidator,
     ValidationResult,
 )
+from data_designer.lazy_heavy_imports import pd
+
+if TYPE_CHECKING:
+    import pandas as pd
 
 logger = logging.getLogger(__name__)
 
@@ -45,15 +41,7 @@ def get_validator_from_params(validator_type: ValidatorType, validator_params: V
         return LocalCallableValidator(validator_params)
 
 
-class ValidationColumnGenerator(ColumnGenerator[ValidationColumnConfig]):
-    @staticmethod
-    def metadata() -> GeneratorMetadata:
-        return GeneratorMetadata(
-            name="validate",
-            description="Validate data.",
-            generation_strategy=GenerationStrategy.FULL_COLUMN,
-        )
-
+class ValidationColumnGenerator(ColumnGeneratorFullColumn[ValidationColumnConfig]):
     def generate(self, data: pd.DataFrame) -> pd.DataFrame:
         logger.info(f"🔍 Validating column {self.config.name!r} with {len(data)} records")
         logger.info(f"  |-- target columns: {self.config.target_columns}")
@@ -132,6 +120,7 @@ class ValidationColumnGenerator(ColumnGenerator[ValidationColumnConfig]):
             error_callback=error_callback,
             shutdown_error_rate=settings.shutdown_error_rate,
             shutdown_error_window=settings.shutdown_error_window,
+            disable_early_shutdown=settings.disable_early_shutdown,
         ) as executor:
             for i, batch in enumerate(batched_records):
                 executor.submit(lambda batch: self._validate_batch(validator, batch), batch, context={"index": i})

data_designer/engine/column_generators/registry.py

@@ -1,6 +1,8 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
+from __future__ import annotations
+
 from data_designer.config.base import ConfigBase
 from data_designer.config.column_configs import (
     EmbeddingColumnConfig,

data_designer/engine/column_generators/utils/errors.py

@@ -1,6 +1,8 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
+from __future__ import annotations
+
 from data_designer.engine.errors import DataDesignerError
 
 

data_designer/engine/column_generators/utils/generator_classification.py

@@ -1,6 +1,8 @@
 # SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
+from __future__ import annotations
+
 from data_designer.config.column_types import DataDesignerColumnType
 from data_designer.config.utils.type_helpers import resolve_string_enum
 from data_designer.engine.column_generators.generators.base import ColumnGeneratorWithModelRegistry

data_designer/engine/column_generators/utils/judge_score_factory.py

@@ -1,6 +1,8 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
+from __future__ import annotations
+
 from enum import Enum
 
 from pydantic import BaseModel, ConfigDict, Field, create_model