data-designer 0.1.0__py3-none-any.whl

data_designer/engine/validators/base.py

@@ -0,0 +1,36 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from abc import ABC, abstractmethod
+from typing import Iterator, Optional
+
+from pydantic import BaseModel, ConfigDict
+from typing_extensions import Self
+
+
+class ValidationOutput(BaseModel):
+    is_valid: Optional[bool]
+    model_config = ConfigDict(extra="allow")
+
+
+class ValidationResult(BaseModel):
+    data: list[ValidationOutput]
+
+    def __len__(self) -> int:
+        return len(self.data)
+
+    def __getitem__(self, index: int) -> ValidationOutput:
+        return self.data[index]
+
+    def __iter__(self) -> Iterator[ValidationOutput]:
+        return iter(self.data)
+
+    @classmethod
+    def empty(cls, size: int) -> Self:
+        return cls(data=[ValidationOutput(is_valid=None) for _ in range(size)])
+
+
+class BaseValidator(ABC):
+    @abstractmethod
+    def run_validation(self, data: list[dict]) -> ValidationResult:
+        pass

data_designer/engine/validators/local_callable.py

@@ -0,0 +1,34 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+
+import pandas as pd
+
+from data_designer.config.validator_params import LocalCallableValidatorParams
+from data_designer.engine.errors import LocalCallableValidationError
+from data_designer.engine.processing.gsonschema.validators import validate
+from data_designer.engine.validators.base import BaseValidator, ValidationOutput, ValidationResult
+
+logger = logging.getLogger(__name__)
+
+
+class LocalCallableValidator(BaseValidator):
+    def __init__(self, config: LocalCallableValidatorParams):
+        self.validation_function = config.validation_function
+        self.output_schema = config.output_schema
+
+    def run_validation(self, data: list[dict]) -> ValidationResult:
+        df = pd.DataFrame(data)
+
+        try:
+            result_as_df = self.validation_function(df)
+        except Exception as e:
+            logger.error(f"Callback validator failed: {e}")
+            raise LocalCallableValidationError(str(e))
+
+        records = result_as_df.to_dict(orient="records")
+        result = ValidationResult(data=[ValidationOutput.model_validate(record) for record in records])
+        if self.output_schema:
+            validate(result.model_dump(mode="json"), self.output_schema, no_extra_properties=True)
+        return result

data_designer/engine/validators/python.py

@@ -0,0 +1,245 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+import ast
+from collections import defaultdict
+import logging
+from pathlib import Path
+import re
+import subprocess
+import tempfile
+from uuid import uuid4
+
+import pandas as pd
+from pydantic import BaseModel
+from ruff.__main__ import find_ruff_bin
+
+from data_designer.config.validator_params import CodeValidatorParams
+from data_designer.engine.validators.base import BaseValidator, ValidationOutput, ValidationResult
+
+logger = logging.getLogger(__name__)
+
+PYLINT_ERROR_CATEGORIES_ORDERED = [
+    "fatal",
+    "error",
+    "warning",
+    "convention",
+    "refactor",
+]
+PYLINT_VALID_LEVELS = {"none", "warning", "convention", "refactor"}
+
+TYPE_FROM_SYMBOL = {
+    "E": "refactor",
+    "F": "error",
+    "SIM": "refactor",
+    "PLC": "convention",
+    "PLE": "error",
+    "PLR": "refactor",
+    "PLW": "warning",
+    "SyntaxError": "fatal",
+}
+
+PYTHON_MESSAGES_FIELD = "python_linter_messages"
+RECORD_ID_COLUMN_NAME = "internal_code_record_id"
+
+
+class PythonValidationStat(BaseModel):
+    fatal: int = 0
+    error: int = 0
+    warning: int = 0
+    refactor: int = 0
+    convention: int = 0
+    statement: int = 0
+
+    @property
+    def score(self) -> float:
+        # https://pylint.pycqa.org/en/latest/user_guide/configuration/all-options.html#evaluation
+        if self.statement == 0:  # prevent division by zero down below
+            self.statement = max(1, self.statement)
+        return max(
+            0,
+            (
+                0
+                if self.fatal
+                else 10.0
+                - ((float(5 * self.error + self.warning + self.refactor + self.convention) / self.statement) * 10)
+            ),
+        )
+
+
+class PythonLinterMessage(BaseModel):
+    type: str
+    symbol: str
+    line: int
+    column: int
+    message: str
+
+    @property
+    def type_sort_order(self) -> int:
+        return PYLINT_ERROR_CATEGORIES_ORDERED.index(self.type)
+
+
+class PythonLinterMessages(BaseModel):
+    _messages: list[PythonLinterMessage] = []
+
+    @property
+    def messages(self) -> list[PythonLinterMessage]:
+        # Ordered by severity first then by line number
+        return sorted(self._messages, key=lambda msg: (msg.type_sort_order, msg.line))
+
+    def add(self, message: PythonLinterMessage) -> None:
+        self._messages.append(message)
+
+    def get_count_by_type(self) -> dict[str, int]:
+        count_by_type = defaultdict(int)
+        for message in self.messages:
+            count_by_type[message.type] += 1
+        return dict(count_by_type)
+
+    @property
+    def is_empty(self) -> bool:
+        return len(self.messages) == 0
+
+    @property
+    def severity(self) -> str:
+        if self.is_empty:
+            return "none"
+        return self.messages[0].type
+
+    @property
+    def is_valid(self) -> bool:
+        return self.is_empty or self.messages[0].type in PYLINT_VALID_LEVELS
+
+
+class PythonValidator(BaseValidator):
+    def __init__(self, config: CodeValidatorParams):
+        self.config = config
+
+    def run_validation(self, data: list[dict]) -> ValidationResult:
+        df = pd.DataFrame(data)
+
+        if len(df.columns) > 1:
+            raise ValueError("Python validator assumes single column input")
+        target_column = df.columns[0]
+
+        df.loc[:, RECORD_ID_COLUMN_NAME] = [uuid4() for _ in range(df.shape[0])]
+        with tempfile.TemporaryDirectory() as temp_dir:
+            _ = df.apply(
+                self._write_code_to_file,
+                args=(target_column, temp_dir),
+                axis=1,
+            )
+            results = self._validate_files_in_path(path=temp_dir)
+
+            records = df.to_dict(orient="records")
+
+            ordered_results = []
+            for record in records:
+                module_id = self._get_module_name(record[RECORD_ID_COLUMN_NAME], target_column)
+                result = results.get(module_id)
+                if result is not None:
+                    ordered_results.append(result)
+
+        return ValidationResult(data=ordered_results)
+
+    def _validate_files_in_path(self, path: str) -> dict[str, ValidationOutput]:
+        lint_results = self._run_linter(path)
+
+        scores_by_module = self._get_scores(
+            {
+                module: messages.get_count_by_type()
+                | {"statement": self._count_python_statements(f"{path}/{module}.py")}
+                for module, messages in lint_results.items()
+            }
+        )
+
+        validation_result = {}
+        for module, score in scores_by_module.items():
+            messages = lint_results.get(module, PythonLinterMessages())
+            metadata = {
+                "python_linter_score": score,
+                "python_linter_severity": messages.severity,
+                PYTHON_MESSAGES_FIELD: [m.model_dump() for m in messages.messages],
+            }
+            validation_result[module] = ValidationOutput(is_valid=messages.is_valid, **metadata)
+        return validation_result
+
+    def _write_code_to_file(self, row: pd.Series, code_column: str, path: str) -> None:
+        with open(f"{path}/{self._get_module_name(row[RECORD_ID_COLUMN_NAME], code_column)}.py", "w") as file:
+            file.write(row[code_column])
+
+    @staticmethod
+    def _get_module_name(record_id: str, column_name: str) -> str:
+        return f"{record_id}_{column_name}"
+
+    @staticmethod
+    def _run_linter(codebase_path: str) -> dict[str, PythonLinterMessages]:
+        # Create empty dict for output
+        processed = {}
+        for file in Path(codebase_path).glob("*.py"):
+            processed[file.stem] = PythonLinterMessages()
+
+        # Run ruff linter
+        ruff_bin = find_ruff_bin()
+        env = {"NO_COLOR": "1"}
+
+        ruff_exec = subprocess.run(
+            [
+                ruff_bin,
+                "check",
+                "--select",
+                "E,F6,F7,F8,SIM,PLC,PLE,PLR,PLW",
+                codebase_path,
+            ],
+            env=env,
+            text=True,
+            capture_output=True,
+            check=False,
+            cwd=Path.cwd(),
+        )
+        ruff_output = ruff_exec.stdout
+
+        # Parse ruff output
+        if "All checks passed!" in ruff_output:
+            return processed  # no errors or warnings
+
+        pattern = r"(.*):([0-9]*):([0-9]*): ([A-Za-z0-9]*):? (?:\[\*\] )?(.*)\n"
+        errors = re.findall(pattern, ruff_output)
+
+        if errors == []:  # output could not be parsed
+            raise RuntimeError("ruff's output could not be parsed")
+
+        try:
+            for error in errors:
+                filename, line, column, symbol, message = error
+                processed[Path(filename).stem].add(
+                    PythonLinterMessage(
+                        type=TYPE_FROM_SYMBOL[re.sub(r"[^A-Za-z]+", "", symbol)],
+                        symbol=symbol,
+                        line=int(line),
+                        column=int(column),
+                        message=message,
+                    )
+                )
+        except Exception:  # output not in expected format
+            raise RuntimeError("ruff's output not in expected format")
+
+        return processed
+
+    @staticmethod
+    def _get_scores(stats_by_module: dict[str, dict[str, int]]) -> dict[str, float]:
+        scores = {}
+        for key, item in stats_by_module.items():
+            stat = PythonValidationStat(**item)
+            scores[key] = stat.score
+        return scores
+
+    @staticmethod
+    def _count_python_statements(file_path: str) -> int:
+        """Count the number of statements in a Python file."""
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                tree = ast.parse(f.read())
+            return sum(1 for node in ast.walk(tree) if isinstance(node, ast.stmt))
+        except Exception:
+            return 0

data_designer/engine/validators/remote.py

@@ -0,0 +1,83 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+
+import httpx
+from httpx_retries import Retry, RetryTransport
+
+from data_designer.config.validator_params import RemoteValidatorParams
+from data_designer.engine.errors import RemoteValidationSchemaError
+from data_designer.engine.processing.gsonschema.exceptions import JSONSchemaValidationError
+from data_designer.engine.processing.gsonschema.validators import validate
+from data_designer.engine.validators.base import BaseValidator, ValidationResult
+
+logger = logging.getLogger(__name__)
+
+
+class RemoteEndpointClient:
+    """Client for making parallel HTTP requests to remote endpoints with retry, timeout, and auth support."""
+
+    def __init__(
+        self,
+        config: RemoteValidatorParams,
+    ):
+        """
+        Initialize the remote endpoint client.
+
+        Args:
+            config: Remote validator parameters
+        """
+        self.endpoint_url = config.endpoint_url
+        self.output_schema = config.output_schema
+        self.timeout = config.timeout
+        self.max_retries = config.max_retries
+        self.retry_backoff = config.retry_backoff
+
+    def post_to_remote_endpoint(self, content: dict) -> dict:
+        """
+        Make a single HTTP request with retry logic.
+
+        Args:
+            content: The content to be posted to the remote endpoint
+
+        Returns:
+            The JSON response from the remote endpoint
+
+        Raises:
+            httpx.RequestError: If all retry attempts fail
+            httpx.HTTPStatusError: If the server returns an error status
+        """
+        retry = Retry(
+            total=self.max_retries,
+            backoff_factor=self.retry_backoff,
+            status_forcelist=[429, 500, 502, 503, 504],
+        )
+        transport = RetryTransport(retry=retry)
+
+        with httpx.Client(
+            timeout=httpx.Timeout(self.timeout),
+            transport=transport,
+        ) as http_client:
+            response = http_client.post(
+                self.endpoint_url,
+                json=content,
+            )
+            response.raise_for_status()
+
+            response_json = response.json()
+            if self.output_schema:
+                try:
+                    validate(response_json, self.output_schema, no_extra_properties=True)
+                except JSONSchemaValidationError as exc:
+                    raise RemoteValidationSchemaError(str(exc)) from exc
+            return response_json
+
+
+class RemoteValidator(BaseValidator):
+    def __init__(self, config: RemoteValidatorParams):
+        self.remote_endpoint_client = RemoteEndpointClient(config=config)
+
+    def run_validation(self, data: list[dict]) -> ValidationResult:
+        result = self.remote_endpoint_client.post_to_remote_endpoint(content={"data": data})
+        return ValidationResult.model_validate(result)

data_designer/engine/validators/sql.py

@@ -0,0 +1,60 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+import re
+
+import pandas as pd
+import sqlfluff
+
+from data_designer.config.utils.code_lang import CodeLang
+from data_designer.config.validator_params import CodeValidatorParams
+from data_designer.engine.validators.base import BaseValidator, ValidationOutput, ValidationResult
+
+sqlfluff_logger = logging.getLogger("sqlfluff")
+sqlfluff_logger.setLevel(logging.WARNING)
+
+
+class SQLValidator(BaseValidator):
+    def __init__(self, config: CodeValidatorParams):
+        self.config = config
+
+    def run_validation(self, data: list[dict]) -> ValidationResult:
+        df = pd.DataFrame(data)
+
+        if len(df.columns) > 1:
+            raise ValueError("SQL validator assumes single column input")
+        target_column = df.columns[0]
+
+        records = df.to_dict(orient="records")
+
+        results = []
+        for record in records:
+            result = self._validate_query(record[target_column])
+            results.append(result)
+
+        return ValidationResult(data=results)
+
+    def _validate_query(self, content: str) -> ValidationResult:
+        try:
+            result = sqlfluff.lint(
+                content,
+                dialect=CodeLang.parse_dialect(self.config.code_lang),
+            )
+            prs_errors = [res for res in result if res["code"].startswith("PRS")]
+            error_messages = "\n".join([f"{error['code']}: {error['description']}" for error in prs_errors])
+            decimal_pattern = re.compile(r"DECIMAL\(\d+\)")
+            decimal_issues = decimal_pattern.findall(content)
+            if decimal_issues:
+                error_messages += "\nCustom Check: Found DECIMAL definitions without a scale, which may be incorrect."
+            if error_messages:
+                return ValidationOutput(
+                    is_valid=False,
+                    error_messages=error_messages,
+                )
+            return ValidationOutput(is_valid=True, error_messages="")
+        except Exception as e:
+            return ValidationOutput(
+                is_valid=False,
+                error_messages=f"Exception during SQL parsing: {e}",
+            )

data_designer/errors.py

@@ -0,0 +1,5 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+
+class DataDesignerError(Exception): ...

data_designer/essentials/__init__.py

@@ -0,0 +1,137 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+from ..logging import LoggingConfig, configure_logging
+
+configure_logging(LoggingConfig.default())
+
+from ..config.analysis.column_profilers import JudgeScoreProfilerConfig
+from ..config.column_configs import (
+    ExpressionColumnConfig,
+    LLMCodeColumnConfig,
+    LLMJudgeColumnConfig,
+    LLMStructuredColumnConfig,
+    LLMTextColumnConfig,
+    SamplerColumnConfig,
+    Score,
+    SeedDatasetColumnConfig,
+    ValidationColumnConfig,
+)
+from ..config.column_types import DataDesignerColumnType
+from ..config.config_builder import DataDesignerConfigBuilder
+from ..config.data_designer_config import DataDesignerConfig
+from ..config.dataset_builders import BuildStage
+from ..config.datastore import DatastoreSettings
+from ..config.models import (
+    ImageContext,
+    ImageFormat,
+    InferenceParameters,
+    ManualDistribution,
+    ManualDistributionParams,
+    Modality,
+    ModalityContext,
+    ModalityDataType,
+    ModelConfig,
+    UniformDistribution,
+    UniformDistributionParams,
+)
+from ..config.processors import DropColumnsProcessorConfig, ProcessorType
+from ..config.sampler_constraints import ColumnInequalityConstraint, ScalarInequalityConstraint
+from ..config.sampler_params import (
+    BernoulliMixtureSamplerParams,
+    BernoulliSamplerParams,
+    BinomialSamplerParams,
+    CategorySamplerParams,
+    DatetimeSamplerParams,
+    GaussianSamplerParams,
+    PersonFromFakerSamplerParams,
+    PersonSamplerParams,
+    PoissonSamplerParams,
+    SamplerType,
+    ScipySamplerParams,
+    SubcategorySamplerParams,
+    TimeDeltaSamplerParams,
+    UniformSamplerParams,
+    UUIDSamplerParams,
+)
+from ..config.seed import DatastoreSeedDatasetReference, IndexRange, PartitionBlock, SamplingStrategy, SeedConfig
+from ..config.utils.code_lang import CodeLang
+from ..config.utils.info import InfoType
+from ..config.utils.misc import can_run_data_designer_locally
+from ..config.validator_params import (
+    CodeValidatorParams,
+    RemoteValidatorParams,
+    ValidatorType,
+)
+
+local_library_imports = []
+try:
+    if can_run_data_designer_locally():
+        from ..config.validator_params import LocalCallableValidatorParams  # noqa: F401
+        from ..engine.model_provider import ModelProvider  # noqa: F401
+        from ..interface.data_designer import DataDesigner  # noqa: F401
+
+        local_library_imports = ["DataDesigner", "LocalCallableValidatorParams", "ModelProvider"]
+except ModuleNotFoundError:
+    pass
+
+__all__ = [
+    "BernoulliMixtureSamplerParams",
+    "BernoulliSamplerParams",
+    "BinomialSamplerParams",
+    "CategorySamplerParams",
+    "CodeLang",
+    "CodeValidatorParams",
+    "ColumnInequalityConstraint",
+    "configure_logging",
+    "DataDesignerColumnType",
+    "DataDesignerConfig",
+    "DataDesignerConfigBuilder",
+    "BuildStage",
+    "DatastoreSeedDatasetReference",
+    "DatastoreSettings",
+    "DatetimeSamplerParams",
+    "DropColumnsProcessorConfig",
+    "ExpressionColumnConfig",
+    "GaussianSamplerParams",
+    "IndexRange",
+    "InfoType",
+    "ImageContext",
+    "ImageFormat",
+    "InferenceParameters",
+    "JudgeScoreProfilerConfig",
+    "LLMCodeColumnConfig",
+    "LLMJudgeColumnConfig",
+    "LLMStructuredColumnConfig",
+    "LLMTextColumnConfig",
+    "LoggingConfig",
+    "ManualDistribution",
+    "ManualDistributionParams",
+    "Modality",
+    "ModalityContext",
+    "ModalityDataType",
+    "ModelConfig",
+    "PartitionBlock",
+    "PersonSamplerParams",
+    "PersonFromFakerSamplerParams",
+    "PoissonSamplerParams",
+    "ProcessorType",
+    "RemoteValidatorParams",
+    "SamplerColumnConfig",
+    "SamplerType",
+    "SamplingStrategy",
+    "ScalarInequalityConstraint",
+    "ScipySamplerParams",
+    "Score",
+    "SeedConfig",
+    "SeedDatasetColumnConfig",
+    "SubcategorySamplerParams",
+    "TimeDeltaSamplerParams",
+    "UniformDistribution",
+    "UniformDistributionParams",
+    "UniformSamplerParams",
+    "UUIDSamplerParams",
+    "ValidationColumnConfig",
+    "ValidatorType",
+]
+
+__all__.extend(local_library_imports)

data_designer/interface/__init__.py

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