data-designer-engine 0.4.0__py3-none-any.whl

data_designer/engine/validators/base.py

@@ -0,0 +1,38 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Iterator
+
+from pydantic import BaseModel, ConfigDict
+from typing_extensions import Self
+
+
+class ValidationOutput(BaseModel):
+    is_valid: bool | None
+    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,39 @@
+# 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
+
+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
+from data_designer.lazy_heavy_imports import pd
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+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,254 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import ast
+import json
+import logging
+import subprocess
+import tempfile
+from collections import defaultdict
+from pathlib import Path
+from typing import TYPE_CHECKING
+from uuid import uuid4
+
+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
+from data_designer.lazy_heavy_imports import pd
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+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 with JSON output
+        ruff_bin = find_ruff_bin()
+
+        ruff_exec = subprocess.run(
+            [
+                ruff_bin,
+                "check",
+                "--select",
+                "E,F6,F7,F8,SIM,PLC,PLE,PLR,PLW",
+                "--output-format=json",
+                codebase_path,
+            ],
+            text=True,
+            capture_output=True,
+            check=False,
+            cwd=Path.cwd(),
+        )
+        ruff_output = ruff_exec.stdout
+
+        # Parse JSON output
+        try:
+            diagnostics = json.loads(ruff_output)
+        except json.JSONDecodeError as e:
+            raise RuntimeError(f"Failed to parse ruff JSON output: {e}")
+
+        if not diagnostics:
+            return processed  # no errors or warnings
+
+        for diagnostic in diagnostics:
+            filename = diagnostic["filename"]
+            code = diagnostic["code"]
+            location = diagnostic["location"]
+            message = diagnostic["message"]
+
+            # Extract alphabetic prefix from code for type mapping
+            alpha_prefix = "".join(c for c in code if c.isalpha())
+            error_type = TYPE_FROM_SYMBOL.get(alpha_prefix, "warning")
+
+            processed[Path(filename).stem].add(
+                PythonLinterMessage(
+                    type=error_type,
+                    symbol=code,
+                    line=location["row"],
+                    column=location["column"],
+                    message=message,
+                )
+            )
+
+        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,89 @@
+# 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
+
+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
+from data_designer.lazy_heavy_imports import httpx
+
+if TYPE_CHECKING:
+    import httpx
+
+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,65 @@
+# 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 re
+from typing import TYPE_CHECKING
+
+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
+from data_designer.lazy_heavy_imports import pd, sqlfluff
+
+if TYPE_CHECKING:
+    import pandas as pd
+    import sqlfluff
+
+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_engine-0.4.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,114 @@
+data_designer/engine/__init__.py,sha256=ObZ6NUPeEvvpGTJ5WIGKUyIrIjaI747OM6ErweRtHxQ,137
+data_designer/engine/_version.py,sha256=2_0GUP7yBCXRus-qiJKxQD62z172WSs1sQ6DVpPsbmM,704
+data_designer/engine/compiler.py,sha256=4QAeCJjINtH0afSXygdhiKMyq2KIfaDthK3ApZLgrQ0,4152
+data_designer/engine/configurable_task.py,sha256=6R4FPXPzIeK0lqNVSEXzRDtK14B3dFz38lplr-nkvRE,2539
+data_designer/engine/errors.py,sha256=YXI7ny83BQ16sOK43CpTm384hJTKuZkPTEAjlHlDIfA,1303
+data_designer/engine/model_provider.py,sha256=_uU5Bw7yrGlMROjHL4dN1mMTg1eN-LVW5JWcQxovhAA,2823
+data_designer/engine/secret_resolver.py,sha256=srIAnwbTfsDfgzhWojGTR1u8Vx6SY4vSp0_hJU0_i9A,2468
+data_designer/engine/validation.py,sha256=q9wZqCcRAFoW8p1BtkblFQ3CWgeBHT5JTKVCoYlqZeA,14544
+data_designer/engine/analysis/column_statistics.py,sha256=UW14ooahDgeEdkurgj2d0L6DIX4qce1faWSss_2IR6M,5843
+data_designer/engine/analysis/dataset_profiler.py,sha256=DB-c4m4R39PXapY3CsUZvMGM_E-LByRMQMZBrDfIQY0,7323
+data_designer/engine/analysis/errors.py,sha256=QRmvkNjcMpQ5QDlM7YOSbR2key4d6dsiknk994Ewvv4,296
+data_designer/engine/analysis/column_profilers/base.py,sha256=jgUfoR0fQYG5JMo7KaJktNKao0YSQbgO-ge214popd8,1711
+data_designer/engine/analysis/column_profilers/judge_score_profiler.py,sha256=nSkdb7OumaOWFRq64Abiii43G9MgF3OeOvOH9XpdqFg,6572
+data_designer/engine/analysis/column_profilers/registry.py,sha256=yFEE3gwNUzPI8WMGKfNcObtJSs1b3a87GKrL_ksIqBs,923
+data_designer/engine/analysis/utils/column_statistics_calculations.py,sha256=ry0QxRqLFRn7N4OAn6z7TqSAPEGwxiiUEUtsG_bI-98,8958
+data_designer/engine/analysis/utils/judge_score_processing.py,sha256=QkFMHp0WFhxW3YwwmAnKoEFTULSCxnJ2DSkq8v9kiaE,4884
+data_designer/engine/column_generators/__init__.py,sha256=ObZ6NUPeEvvpGTJ5WIGKUyIrIjaI747OM6ErweRtHxQ,137
+data_designer/engine/column_generators/registry.py,sha256=c4WKk1XwXCasDd4sR0EJqM0Lb1T1UP87rI3LPgbNaUQ,3101
+data_designer/engine/column_generators/generators/__init__.py,sha256=ObZ6NUPeEvvpGTJ5WIGKUyIrIjaI747OM6ErweRtHxQ,137
+data_designer/engine/column_generators/generators/base.py,sha256=QElk5KsaUQ3EYwlv40NcZgQsw3HIkX3YQV_0S3erl7Q,4209
+data_designer/engine/column_generators/generators/embedding.py,sha256=uB0jgHlCgctgIUf9ZfMqG1YThbJ0g-GCX3VdNbdDSko,1407
+data_designer/engine/column_generators/generators/expression.py,sha256=BiQcfVTinvQl3OI9nkdhB9B7FGBueWiHJwxTA8uNVuY,2330
+data_designer/engine/column_generators/generators/llm_completion.py,sha256=gMOOdd0_BY-RLXrArx1u8GL7YJfVvKceTqn_Zg1xHPI,4897
+data_designer/engine/column_generators/generators/samplers.py,sha256=gNzURmu9K8Zb5MHamKvZPIxmWlFgl2W4FIVgaFcy4f0,3371
+data_designer/engine/column_generators/generators/seed_dataset.py,sha256=CoQPbz4Ww7pBLaGw8-CYqIk1sjfkBaoRMKZQexdfgKY,6824
+data_designer/engine/column_generators/generators/validation.py,sha256=YfYbk-8_ZUye0No6_Q7hIqpZv_tunnEZ6HkLSMFXlDE,6659
+data_designer/engine/column_generators/utils/errors.py,sha256=NSAOupF13NU20qRN9_Is5AwiL_8l1IJur0TnuQEiJhw,406
+data_designer/engine/column_generators/utils/generator_classification.py,sha256=XBA_vagEXKBQK54OHANKeHw6Mm2B4RuAmXu0QrRdEEo,1958
+data_designer/engine/column_generators/utils/judge_score_factory.py,sha256=gESiqMrQzbbcFpZas0sAAAkrH2DL0Z4Nq5ywBO-pQ6k,2141
+data_designer/engine/column_generators/utils/prompt_renderer.py,sha256=LATVAlDYwL7HyM7Nogd6n9XTTk-j9s64o4z0LpKHMhQ,4819
+data_designer/engine/dataset_builders/artifact_storage.py,sha256=CKpTBtJTde7OQvsFZQa1v1autVz5yUxlBHkIKeATFnE,10999
+data_designer/engine/dataset_builders/column_wise_builder.py,sha256=UAfl-iejVYqvmVx2anGmtPKfmqztM5o8nvyVzxYrM_0,16581
+data_designer/engine/dataset_builders/errors.py,sha256=gLXtPcGSMBG10PzQ85dOXskdA0mKbBQrHa_VtP9sbVY,400
+data_designer/engine/dataset_builders/multi_column_configs.py,sha256=U4Pg0ETCBq5phRhb2zt8IFa4fRx-aTMakomKOBnrs0U,1660
+data_designer/engine/dataset_builders/utils/__init__.py,sha256=ObZ6NUPeEvvpGTJ5WIGKUyIrIjaI747OM6ErweRtHxQ,137
+data_designer/engine/dataset_builders/utils/concurrency.py,sha256=Lga_xd8i3ZAPqJlKCB4GHG7uxWxws1m-UGAz9UeqU_8,8283
+data_designer/engine/dataset_builders/utils/config_compiler.py,sha256=NGI6U0vgG88d5YKj7oW_SIJ4-_fhA6VFhPbjqGRHea4,2441
+data_designer/engine/dataset_builders/utils/dag.py,sha256=RIEI75OtiphkuDl1vfI_MQC1xMiiIg29s-0C_fNZkWQ,2613
+data_designer/engine/dataset_builders/utils/dataset_batch_manager.py,sha256=IfWd_HcfEzIPhgFp2dJaxNIKRlrPsHqYATFXauvCfaw,8133
+data_designer/engine/dataset_builders/utils/errors.py,sha256=G1MIkQDXguSqHK1EP-60FkG_bys7bJ1UgJnSvcNgtt8,411
+data_designer/engine/dataset_builders/utils/progress_tracker.py,sha256=3zSljzDHwhqgP9IqPUR3XbwC231JvLNWslpmhqKIbUg,4255
+data_designer/engine/models/__init__.py,sha256=ObZ6NUPeEvvpGTJ5WIGKUyIrIjaI747OM6ErweRtHxQ,137
+data_designer/engine/models/errors.py,sha256=k9oZnmk8DRD8U2SVKJJRLwrcdsCcVoJiOb_Q7ZyEdvg,12271
+data_designer/engine/models/facade.py,sha256=ckwFxcMHC23-qKU8bdBC0eWKYx6vfVjvp9-0AtCXMX0,12497
+data_designer/engine/models/factory.py,sha256=2NjI0iiGv8ayQ1c249lsJtha4pDmvmtSjdwvlvitRds,1581
+data_designer/engine/models/litellm_overrides.py,sha256=e9IZCFQ6BhNWlOTncm8ErL8w4rtE1_4USh2mtUYxCZI,6207
+data_designer/engine/models/registry.py,sha256=Bid7Mv_ebzbTrlfzN-1wbcFxp_qQwilL0h2iwN5UPJ0,7099
+data_designer/engine/models/telemetry.py,sha256=_VZR6Iatr6-5Hypw3bes5Jr4y7Y3VagxFEVAv36eHcE,12733
+data_designer/engine/models/usage.py,sha256=A0LV9Ycuj_7snOsaqnirs4mlkAjozv2mzj2om2FpDoU,2410
+data_designer/engine/models/utils.py,sha256=Szy3lOg_E14DRAx6U2Dpr3HXPg09xIr3VUnoREiZ1mw,3807
+data_designer/engine/models/parsers/__init__.py,sha256=ObZ6NUPeEvvpGTJ5WIGKUyIrIjaI747OM6ErweRtHxQ,137
+data_designer/engine/models/parsers/errors.py,sha256=ODcZ4TOsmZyH4-MoNkKXhjiMm_4gLWPsz90qKtNF9_Q,1053
+data_designer/engine/models/parsers/parser.py,sha256=XkdDt2WEnolvsv2bArq4hhujfJ3kLmG6G2jkRXMYA8c,9489
+data_designer/engine/models/parsers/postprocessors.py,sha256=GwgPAdaz8GNahnXbyzQmvo_fpHZDK8ddmrM7-dn9X48,2896
+data_designer/engine/models/parsers/tag_parsers.py,sha256=HNAIBfXW1Wjdkw4IX-P9sHodir1UUt-4Lp91Tz0XWPA,2036
+data_designer/engine/models/parsers/types.py,sha256=wEt80al1FykbMplZVjJ5uXFtacMx-a9GE4_QoqDJ6Us,2631
+data_designer/engine/models/recipes/base.py,sha256=AQg3Ay_E0hBEVg-sqSNVVZNMJfJ3r1eT14-b9yqymnQ,2630
+data_designer/engine/models/recipes/response_recipes.py,sha256=UX9m-8RTDj3sXkzEdKpkSj5z7jO-fQhdca3MSByb_Js,10189
+data_designer/engine/processing/utils.py,sha256=g82KsdDR20g_isadpmgHnneQSX0W21aCVhkp5TIWEhw,5443
+data_designer/engine/processing/ginja/__init__.py,sha256=ObZ6NUPeEvvpGTJ5WIGKUyIrIjaI747OM6ErweRtHxQ,137
+data_designer/engine/processing/ginja/ast.py,sha256=w62yt434RDnJYrcfofIDThGv0C5H9XJE3VHOnxEzJVM,1964
+data_designer/engine/processing/ginja/environment.py,sha256=wJRbzPuUCQGvCi4zS4g8sYzihgu_6fn-tE_nYSL1AoU,18974
+data_designer/engine/processing/ginja/exceptions.py,sha256=o1ogMKtItC336cu_sBWHAGSVhWCKNHEIqd7dNN_13DA,1926
+data_designer/engine/processing/ginja/record.py,sha256=eD6M0CUbEtElYLEtxjyYFlx3yuwHFSgJVWDmsGbTlBQ,1100
+data_designer/engine/processing/gsonschema/__init__.py,sha256=ObZ6NUPeEvvpGTJ5WIGKUyIrIjaI747OM6ErweRtHxQ,137
+data_designer/engine/processing/gsonschema/exceptions.py,sha256=iiWHnOtrRs1sEsQ8K5HQUl_M_IS0rTAelHkCgKKKQ3A,425
+data_designer/engine/processing/gsonschema/schema_transformers.py,sha256=P2qmeVBF385Dz2GSbMuQYTGMCIbXgw_R4I7ZqB0wcjQ,3107
+data_designer/engine/processing/gsonschema/types.py,sha256=nCrs0d7NADz0YzflhYmWpmKpq-F3ukUWFIISc_q1Kso,354
+data_designer/engine/processing/gsonschema/validators.py,sha256=ui3PzGjIclI6Hlw48GUDuAJ3_cgyQr4NANMn4NVxBKE,6960
+data_designer/engine/processing/processors/base.py,sha256=bkAQO0yK6ATJ3zTwS7F9FXobenJqydCyfijSP2MM-70,472
+data_designer/engine/processing/processors/drop_columns.py,sha256=xT7ym2pQc-R0-YHIuYDQGFn2uAf74309-pV4H878Wlk,1866
+data_designer/engine/processing/processors/registry.py,sha256=ewuFY8QeXpql5CNTZZa_87aYPGPNv1H0hpJR7CBVuzI,1097
+data_designer/engine/processing/processors/schema_transform.py,sha256=cpN5XAg_YNKpne_Ed3Vhk8_yuoTUiUy_pINgPZF2ASk,2822
+data_designer/engine/registry/base.py,sha256=eACpE7o_c2btiiXrOFJw7o0VvACo7DSqhj8AntkNkCQ,3579
+data_designer/engine/registry/data_designer_registry.py,sha256=mz8ksE49pS1JRVDNubYSxTs0j-8Q6sd08F_dYyTCWSE,1528
+data_designer/engine/registry/errors.py,sha256=k1EaV7egNQwNmRsI8EfymTfeNprcDutPf2M6Vc1nbn8,350
+data_designer/engine/resources/managed_dataset_generator.py,sha256=2wGc-tH5usXAPXgDkXzslLsCkAsAQgYa3uIYJC5_Oa0,1495
+data_designer/engine/resources/managed_dataset_repository.py,sha256=lx8NTtAPxheZdqkgilYSmqZv4Nd_CeHXXUaXHzGLLVk,7684
+data_designer/engine/resources/managed_storage.py,sha256=8tLJjKGvDbuHnsESL2VZVu9vfEH3--OLZaiZe-LZo_8,2120
+data_designer/engine/resources/resource_provider.py,sha256=1D-a4g1s5r_ECZE5-mR4TwFLxWPH8GLcaBZnd-j51E8,3047
+data_designer/engine/resources/seed_reader.py,sha256=GQiOqf9t-yRag2g5Io3-kQPhpyKJbXgHn2YTUoAgftI,5717
+data_designer/engine/sampling_gen/column.py,sha256=0aQzeJtcM0DNEaarG1ybXV4LLJH0iiOaXvi46Ay4qOE,3987
+data_designer/engine/sampling_gen/constraints.py,sha256=AvFoyZ1QU--R9kGyIaPHClm3mG_ZoPuOE3IQQqYUPqw,3157
+data_designer/engine/sampling_gen/errors.py,sha256=42shYMUNk5bd3FxTOCsBWXa7jlgMZ1ZyE9yyhFzwE7g,869
+data_designer/engine/sampling_gen/generator.py,sha256=olwpzBwSNEerppReBzRXlcoO3Ts3fZxEwVki5Hem50Y,5501
+data_designer/engine/sampling_gen/jinja_utils.py,sha256=DMMunGEonyXUaKd_WyAg9yo39RL65346DYTUJKp7dP4,2136
+data_designer/engine/sampling_gen/people_gen.py,sha256=vplDwZ66VnjMM7AGX0odKPXY__cktlC-nW-z6aMHCKc,8417
+data_designer/engine/sampling_gen/person_constants.py,sha256=jp6SJ9NwAObu31wqE7WC6hBRUGEAOelaDUmqbxkLpcs,1202
+data_designer/engine/sampling_gen/schema.py,sha256=qdgKGNFwdiHvYl4ZhjRv0P8857wAdDKiekpTH8nL43Y,6240
+data_designer/engine/sampling_gen/schema_builder.py,sha256=PvVyWbo3T8zgiVonecD1ST10uwNGO02KtDcczonhCRE,2313
+data_designer/engine/sampling_gen/utils.py,sha256=wdgTQgsKoQWCqE3rnocCZdzHXWWCkD7nR3n9rmQ6C9w,1500
+data_designer/engine/sampling_gen/data_sources/base.py,sha256=zUG5XTplD5pgHh4ytCMFumeuU2O8jr39bxgpGaA3oVc,7447
+data_designer/engine/sampling_gen/data_sources/errors.py,sha256=_9rbwUpaz0Pd2Ods4AVDQ7Uq4JvPyfHhTp51BdtJDto,367
+data_designer/engine/sampling_gen/data_sources/sources.py,sha256=53KVPp7REjNKA0rajGmT_tBkxwQqwrcIKhcijBGcfcs,13647
+data_designer/engine/sampling_gen/entities/__init__.py,sha256=ObZ6NUPeEvvpGTJ5WIGKUyIrIjaI747OM6ErweRtHxQ,137
+data_designer/engine/sampling_gen/entities/dataset_based_person_fields.py,sha256=r8qXWe8EquJognihPNGzma4fFuSQAAZHlkYVsGmcX2w,2006
+data_designer/engine/sampling_gen/entities/email_address_utils.py,sha256=THfD7muq5tMHkRWOATN-N3iSFgkKjT4e8hKquDFMTlU,5272
+data_designer/engine/sampling_gen/entities/errors.py,sha256=SbtwwG6JgoY4k6pq2-y-lD60nX_pqjf5QftmwgXt0us,352
+data_designer/engine/sampling_gen/entities/national_id_utils.py,sha256=XUFB6RhfLGFQUNyy0B6BSgtrG9NdEnIjfSALBwJplho,2652
+data_designer/engine/sampling_gen/entities/person.py,sha256=9S-xAj6_8ZaFX4G_I7CMMKN2Ju_0YeDSnq1ajIIAdhE,5719
+data_designer/engine/sampling_gen/entities/phone_number.py,sha256=dGY5LRwCz19RBH0mJDTpnBb0a98piDSNgkQRemgwqV0,4818
+data_designer/engine/sampling_gen/entities/assets/zip_area_code_map.parquet,sha256=L6G4laXExB7uRCWHlF4XGDk0yMh41jbDnp9LIy7jNHM,576064
+data_designer/engine/testing/__init__.py,sha256=ICYoOcewhvzZmuaF4A8fn-LDaaOBGhBQf-RQ9QyNdhs,396
+data_designer/engine/testing/stubs.py,sha256=_fmsaqIVY3BLlXHZg3oJ-yqhM61bPWcjgXE5SQSZrvU,3917
+data_designer/engine/testing/utils.py,sha256=a9LEgK827cnIzHEkgXOdgywrKDLBE36cyttrpG1ctT4,973
+data_designer/engine/validators/__init__.py,sha256=uT0CTJF9Ce97zoAdMSWvfYn7mO5ja0lIgyPRKJLcsOU,693
+data_designer/engine/validators/base.py,sha256=XfDDMMP0PusoKAjM9rXdIYkyWlLiQPAJChMgtkcdspw,1005
+data_designer/engine/validators/local_callable.py,sha256=JaL-yOXrTFpubiO2QlSt4QbiJzD_ddChmfcHyMhbgaQ,1531
+data_designer/engine/validators/python.py,sha256=omXjwMaomQYiyq4g6XqKt2wexVuI_rWue9Dk-CYc-do,8039
+data_designer/engine/validators/remote.py,sha256=rythhIrH2GvqncMQeF3FiJa9Om0KZWeK3cWjW-ZubaM,3077
+data_designer/engine/validators/sql.py,sha256=AMaEdA-gj9j0zwVp809x3ycKltd51wVEhI8mMYGyxd4,2408
+data_designer_engine-0.4.0.dist-info/METADATA,sha256=hHuNlKxfNErQUPbmwmBkux0M2q9ebuFna97Xoe8y2lc,1873
+data_designer_engine-0.4.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+data_designer_engine-0.4.0.dist-info/RECORD,,

data_designer_engine-0.4.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any