data-designer-engine 0.4.0__tar.gz

data_designer_engine-0.4.0/.gitignore

@@ -0,0 +1,100 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.coverage
+.coverage.*
+.cache
+coverage.xml
+.pytest_cache/
+
+# mkdocs documentation
+/site
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# uv
+.venv/
+.uv/
+
+# Environments
+.env
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Ruff
+.ruff_cache/
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Build artifacts
+*.whl
+*.tar.gz
+*.zip
+
+# Auto-generated version files
+**/_version.py
+
+# Local scratch space
+.scratch/
+
+docs/notebooks/
+docs/notebook_source/*.ipynb
+docs/notebook_source/*.csv
+docs/**/artifacts/
+
+tests_e2e/uv.lock
+
+# Performance profiling
+perf_*.txt
+NOTEPAD.md
+
+# Build-time copy of README for data-designer package (copied from top-level during build)
+packages/data-designer/README.md

data_designer_engine-0.4.0/PKG-INFO

@@ -0,0 +1,50 @@
+Metadata-Version: 2.4
+Name: data-designer-engine
+Version: 0.4.0
+Summary: Generation engine for DataDesigner synthetic data generation
+License-Expression: Apache-2.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: anyascii<1,>=0.3.3
+Requires-Dist: data-designer-config
+Requires-Dist: duckdb<2,>=1.1.3
+Requires-Dist: faker<21,>=20.1.0
+Requires-Dist: httpx-retries<1,>=0.4.2
+Requires-Dist: httpx<1,>=0.27.2
+Requires-Dist: huggingface-hub<2,>=1.0.1
+Requires-Dist: json-repair<1,>=0.48.0
+Requires-Dist: jsonpath-rust-bindings<2,>=1.0
+Requires-Dist: jsonschema<5,>=4.0.0
+Requires-Dist: litellm<1.80.12,>=1.73.6
+Requires-Dist: lxml<7,>=6.0.2
+Requires-Dist: marko<3,>=2.1.2
+Requires-Dist: networkx<4,>=3.0
+Requires-Dist: ruff<1,>=0.14.10
+Requires-Dist: scipy<2,>=1.11.0
+Requires-Dist: sqlfluff<4,>=3.2.0
+Requires-Dist: tiktoken<1,>=0.8.0
+Description-Content-Type: text/markdown
+
+# data-designer-engine
+
+Generation engine for NeMo Data Designer synthetic data generation framework.
+
+This package contains the execution engine that powers Data Designer. It depends on `data-designer-config` and includes heavy dependencies like pandas, numpy, and LLM integration via litellm.
+
+## Installation
+
+```bash
+pip install data-designer-engine
+```
+
+This automatically installs `data-designer-config` as a dependency.
+
+See main [README.md](https://github.com/NVIDIA-NeMo/DataDesigner/blob/main/README.md) for more information.

data_designer_engine-0.4.0/README.md

@@ -0,0 +1,15 @@
+# data-designer-engine
+
+Generation engine for NeMo Data Designer synthetic data generation framework.
+
+This package contains the execution engine that powers Data Designer. It depends on `data-designer-config` and includes heavy dependencies like pandas, numpy, and LLM integration via litellm.
+
+## Installation
+
+```bash
+pip install data-designer-engine
+```
+
+This automatically installs `data-designer-config` as a dependency.
+
+See main [README.md](https://github.com/NVIDIA-NeMo/DataDesigner/blob/main/README.md) for more information.

data_designer_engine-0.4.0/pyproject.toml

@@ -0,0 +1,64 @@
+[project]
+name = "data-designer-engine"
+dynamic = ["version"]
+description = "Generation engine for DataDesigner synthetic data generation"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "Apache-2.0"
+
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+
+dependencies = [
+    "anyascii>=0.3.3,<1",
+    "data-designer-config",
+    "duckdb>=1.1.3,<2",
+    "faker>=20.1.0,<21",
+    "httpx>=0.27.2,<1",
+    "httpx-retries>=0.4.2,<1",
+    "huggingface-hub>=1.0.1,<2",
+    "json-repair>=0.48.0,<1",
+    "jsonpath-rust-bindings>=1.0,<2",
+    "jsonschema>=4.0.0,<5",
+    "litellm>=1.73.6,<1.80.12",
+    "lxml>=6.0.2,<7",
+    "marko>=2.1.2,<3",
+    "networkx>=3.0,<4",
+    "ruff>=0.14.10,<1",
+    "scipy>=1.11.0,<2",
+    "sqlfluff>=3.2.0,<4",
+    "tiktoken>=0.8.0,<1",
+]
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "vcs"
+fallback-version = "0.1.0.dev0"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "src/data_designer/engine/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/data_designer"]
+
+[tool.ruff]
+extend = "../../pyproject.toml"
+
+[tool.uv]
+package = true
+
+[tool.uv.sources]
+data-designer-config = { workspace = true }

data_designer_engine-0.4.0/src/data_designer/engine/__init__.py

@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0

data_designer_engine-0.4.0/src/data_designer/engine/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.4.0'
+__version_tuple__ = version_tuple = (0, 4, 0)
+
+__commit_id__ = commit_id = None

data_designer_engine-0.4.0/src/data_designer/engine/analysis/column_profilers/base.py

@@ -0,0 +1,49 @@
+# 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 abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel, model_validator
+from typing_extensions import Self
+
+from data_designer.config.base import ConfigBase
+from data_designer.config.column_configs import SingleColumnConfig
+from data_designer.config.column_types import DataDesignerColumnType
+from data_designer.engine.configurable_task import ConfigurableTask, TaskConfigT
+from data_designer.lazy_heavy_imports import pd
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+
+class ColumnConfigWithDataFrame(ConfigBase):
+    column_config: SingleColumnConfig
+    df: pd.DataFrame
+
+    @model_validator(mode="after")
+    def validate_column_exists(self) -> Self:
+        if self.column_config.name not in self.df.columns:
+            raise ValueError(f"Column {self.column_config.name!r} not found in DataFrame")
+        return self
+
+    def as_tuple(self) -> tuple[SingleColumnConfig, pd.DataFrame]:
+        return (self.column_config, self.df)
+
+
+class ColumnProfiler(ConfigurableTask[TaskConfigT], ABC):
+    @staticmethod
+    @abstractmethod
+    def get_applicable_column_types() -> list[DataDesignerColumnType]:
+        """Returns a list of column types that this profiler can be applied to during dataset profiling."""
+
+    @abstractmethod
+    def profile(self, column_config_with_df: ColumnConfigWithDataFrame) -> BaseModel: ...
+
+    def _initialize(self) -> None:
+        logger.info(f"💫 Initializing column profiler: '{self.name}'")

data_designer_engine-0.4.0/src/data_designer/engine/analysis/column_profilers/judge_score_profiler.py

@@ -0,0 +1,153 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import logging
+import random
+from typing import TYPE_CHECKING
+
+from data_designer.config.analysis.column_profilers import (
+    JudgeScoreProfilerConfig,
+    JudgeScoreProfilerResults,
+    JudgeScoreSummary,
+)
+from data_designer.config.analysis.column_statistics import (
+    ColumnDistributionType,
+    MissingValue,
+)
+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.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 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)
+
+    def profile(self, column_config_with_df: ColumnConfigWithDataFrame) -> JudgeScoreProfilerResults:
+        column_config, df = column_config_with_df.as_tuple()
+
+        logger.info(
+            f"{column_config.get_column_emoji()} Analyzing LLM-as-judge scores for column: '{column_config.name}'"
+        )
+
+        score_summaries = {}
+        score_distributions = extract_judge_score_distributions(column_config, df)
+
+        if self.config.summary_score_sample_size is None or isinstance(score_distributions, MissingValue):
+            return JudgeScoreProfilerResults(
+                summaries={},
+                column_name=column_config.name,
+                score_distributions=score_distributions,
+            )
+
+        for score in column_config.scores:
+            score_name = score.name
+            logger.info(f"{random.choice(['👩‍⚖️', '👨‍⚖️'])} Summarizing LLM-as-judge score: '{score_name}'")
+            score_sample = sample_scores_and_reasoning(
+                scores=score_distributions.scores[score_name],
+                reasoning=score_distributions.reasoning[score_name],
+                num_samples=self.config.summary_score_sample_size,
+            )
+
+            score_summaries[score_name] = self._summarize_score_sample(
+                name=score_name,
+                sample=score_sample,
+                histogram=score_distributions.histograms[score_name],
+                distribution=score_distributions.distributions[score_name],
+                distribution_type=score_distributions.distribution_types[score_name],
+            )
+
+        return JudgeScoreProfilerResults(
+            column_name=column_config.name,
+            summaries=score_summaries,
+            score_distributions=score_distributions,
+        )
+
+    def _summarize_score_sample(
+        self,
+        name: str,
+        sample: list[JudgeScoreSample],
+        histogram: CategoricalHistogramData,
+        distribution: CategoricalDistribution | NumericalDistribution | MissingValue,
+        distribution_type: ColumnDistributionType,
+    ) -> JudgeScoreSummary:
+        if isinstance(distribution, MissingValue) or not sample:
+            return JudgeScoreSummary(
+                score_name=name,
+                summary="No judge score information available to summarize.",
+                score_samples=sample,
+            )
+
+        category_info = []
+        total_count = sum(histogram.counts)
+        for cat, count in zip(histogram.categories, histogram.counts):
+            percentage = (count / total_count) * 100
+            category_info.append(f"{cat}: {count} records ({percentage:.1f}%)")
+
+        distribution_context = f"Score distribution - {', '.join(category_info)}, "
+        if distribution_type == ColumnDistributionType.CATEGORICAL:
+            distribution_context += f"Most common value: {distribution.most_common_value}. "
+        if distribution_type == ColumnDistributionType.NUMERICAL:
+            distribution_context += f"Mean score: {distribution.mean:.2f}. "
+
+        logger.info(f"  |-- number of score samples: {len(sample)}")
+        logger.info(f"  |-- {distribution_context.lower()}")
+
+        combined_reasoning = "\n".join([r.reasoning for r in sample])
+        prompt = (
+            f"Based on the following evaluator reasoning for the '{name}' criterion, "
+            "provide a concise summary that captures both the strengths and areas for improvement mentioned. "
+            "Be specific about what worked well and what needs improvement.\n\n"
+            f"Overall distribution of scores: {distribution_context}"
+            f"\nA sample of reasoning:\n{combined_reasoning}\n\n"
+            "Do not include any titles like `Summary` or `Summary:`. "
+            "Do not wrap the summary in quotation marks. "
+            "YOU WILL PRODUCE LESS THAN 75 WORDS in a readable sentence format. "
+            "No need to use bullets or headers. Write naturally."
+        )
+
+        system_prompt = (
+            "You are an expert at distilling complex feedback into concise summaries. "
+            "Focus on specificity and balance, incorporating both the distribution context and individual reasoning examples."
+        )
+
+        try:
+            model = self.get_model(self.config.model_alias)
+            recipe = TextResponseRecipe()
+            summary, _ = model.generate(
+                prompt=recipe.apply_recipe_to_user_prompt(prompt),
+                system_prompt=recipe.apply_recipe_to_system_prompt(system_prompt),
+                parser=recipe.parse,
+            )
+            return JudgeScoreSummary(
+                score_name=name,
+                summary=summary.strip(),
+                score_samples=sample,
+            )
+        except Exception as e:
+            return JudgeScoreSummary(
+                score_name=name,
+                summary=f"Score summarization failed: {e}",
+                score_samples=sample,
+            )

data_designer_engine-0.4.0/src/data_designer/engine/analysis/column_profilers/registry.py

@@ -0,0 +1,22 @@
+# 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
+from data_designer.engine.analysis.column_profilers.judge_score_profiler import (
+    JudgeScoreProfiler,
+    JudgeScoreProfilerConfig,
+)
+from data_designer.engine.registry.base import TaskRegistry
+
+
+class ColumnProfilerRegistry(TaskRegistry[ColumnProfilerType, ColumnProfiler, ConfigBase]): ...
+
+
+def create_default_column_profiler_registry() -> ColumnProfilerRegistry:
+    registry = ColumnProfilerRegistry()
+    registry.register(ColumnProfilerType.JUDGE_SCORE, JudgeScoreProfiler, JudgeScoreProfilerConfig, False)
+    return registry

data_designer_engine-0.4.0/src/data_designer/engine/analysis/column_statistics.py

@@ -0,0 +1,145 @@
+# 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 typing import TYPE_CHECKING, Any, TypeAlias
+
+from pydantic import BaseModel
+from typing_extensions import Self
+
+from data_designer.config.analysis.column_statistics import (
+    DEFAULT_COLUMN_STATISTICS_MAP,
+    ColumnStatisticsT,
+    GeneralColumnStatistics,
+)
+from data_designer.config.column_types import ColumnConfigT, DataDesignerColumnType
+from data_designer.config.sampler_params import SamplerType, is_numerical_sampler_type
+from data_designer.engine.analysis.column_profilers.base import ColumnConfigWithDataFrame
+from data_designer.engine.analysis.utils.column_statistics_calculations import (
+    ColumnDistributionType,
+    calculate_column_distribution,
+    calculate_general_column_info,
+    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__)
+
+
+class GeneralColumnStatisticsCalculator(BaseModel):
+    column_config_with_df: ColumnConfigWithDataFrame
+
+    @property
+    def column_config(self) -> ColumnConfigT:
+        return self.column_config_with_df.column_config
+
+    @property
+    def df(self) -> pd.DataFrame:
+        return self.column_config_with_df.df
+
+    @property
+    def column_statistics_type(self) -> type[ColumnStatisticsT]:
+        return DEFAULT_COLUMN_STATISTICS_MAP.get(self.column_config.column_type, GeneralColumnStatistics)
+
+    def calculate(self) -> Self:
+        """Calculate all the column statistics fields for the given column configuration and dataset profiler.
+
+        This method dynamically collects all class methods prefixed with 'calculate_' and invokes them to
+        compute various column statistics, aggregating their results into a single statistics object.
+        """
+        calculate_methods = [
+            name for name in dir(self) if name.startswith("calculate_") and callable(getattr(self, name))
+        ]
+        return self.column_statistics_type(
+            column_name=self.column_config.name,
+            **{k: v for name in calculate_methods for k, v in getattr(self, name)().items()},
+        )
+
+    def calculate_general_column_info(self) -> dict[str, Any]:
+        return calculate_general_column_info(self.column_config.name, self.df)
+
+    def __repr__(self) -> str:
+        params = []
+        for field, value in self.model_dump(mode="json").items():
+            params.append(f"    {field}: {value}")
+        params_str = "\n".join(params)
+        return f"{self.__class__.__name__}(\n{params_str}\n)"
+
+
+class LLMTextColumnStatisticsCalculator(GeneralColumnStatisticsCalculator):
+    def calculate_token_stats(self) -> dict[str, Any]:
+        return calculate_token_stats(self.column_config, self.df)
+
+
+class LLMCodeColumnStatisticsCalculator(LLMTextColumnStatisticsCalculator): ...
+
+
+class LLMStructuredColumnStatisticsCalculator(LLMTextColumnStatisticsCalculator): ...
+
+
+class LLMJudgedColumnStatisticsCalculator(LLMTextColumnStatisticsCalculator): ...
+
+
+class SamplerColumnStatisticsCalculator(GeneralColumnStatisticsCalculator):
+    def calculate_sampler_distribution(self) -> dict[str, Any]:
+        make_dist, dist_type = False, ColumnDistributionType.OTHER
+        if self.column_config.sampler_type in [SamplerType.CATEGORY, SamplerType.SUBCATEGORY]:
+            make_dist, dist_type = True, ColumnDistributionType.CATEGORICAL
+        elif is_numerical_sampler_type(self.column_config.sampler_type):
+            make_dist, dist_type = True, ColumnDistributionType.NUMERICAL
+        return (
+            {
+                "sampler_type": SamplerType(self.column_config.sampler_type),
+                **calculate_column_distribution(self.column_config.name, self.df, dist_type),
+            }
+            if make_dist
+            else {
+                "sampler_type": SamplerType(self.column_config.sampler_type),
+                "distribution_type": dist_type,
+                "distribution": None,
+            }
+        )
+
+
+class SeedDatasetColumnStatisticsCalculator(GeneralColumnStatisticsCalculator): ...
+
+
+class ValidationColumnStatisticsCalculator(GeneralColumnStatisticsCalculator):
+    def calculate_validation_column_info(self) -> dict[str, Any]:
+        return calculate_validation_column_info(self.column_config.name, self.df)
+
+
+class ExpressionColumnStatisticsCalculator(GeneralColumnStatisticsCalculator): ...
+
+
+ColumnStatisticsCalculatorT: TypeAlias = (
+    ExpressionColumnStatisticsCalculator
+    | ValidationColumnStatisticsCalculator
+    | GeneralColumnStatisticsCalculator
+    | LLMCodeColumnStatisticsCalculator
+    | LLMJudgedColumnStatisticsCalculator
+    | LLMStructuredColumnStatisticsCalculator
+    | LLMTextColumnStatisticsCalculator
+    | SamplerColumnStatisticsCalculator
+    | SeedDatasetColumnStatisticsCalculator
+)
+DEFAULT_COLUMN_STATISTICS_CALCULATOR_MAP = {
+    DataDesignerColumnType.EXPRESSION: ExpressionColumnStatisticsCalculator,
+    DataDesignerColumnType.VALIDATION: ValidationColumnStatisticsCalculator,
+    DataDesignerColumnType.LLM_CODE: LLMCodeColumnStatisticsCalculator,
+    DataDesignerColumnType.LLM_JUDGE: LLMJudgedColumnStatisticsCalculator,
+    DataDesignerColumnType.LLM_STRUCTURED: LLMStructuredColumnStatisticsCalculator,
+    DataDesignerColumnType.LLM_TEXT: LLMTextColumnStatisticsCalculator,
+    DataDesignerColumnType.SAMPLER: SamplerColumnStatisticsCalculator,
+    DataDesignerColumnType.SEED_DATASET: SeedDatasetColumnStatisticsCalculator,
+}
+
+
+def get_column_statistics_calculator(column_type: DataDesignerColumnType) -> ColumnStatisticsCalculatorT:
+    return DEFAULT_COLUMN_STATISTICS_CALCULATOR_MAP.get(column_type, GeneralColumnStatisticsCalculator)