TestDataX 0.1.3__tar.gz → 0.2.0__tar.gz

{testdatax-0.1.3 → testdatax-0.2.0}/PKG-INFO

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: TestDataX
-Version: 0.1.3
+Version: 0.2.0
 Summary: A flexible test data generation toolkit
 License: MIT
+License-File: LICENSE
 Author: JamesPBrett
 Requires-Python: >=3.11,<4.0
 Classifier: License :: OSI Approved :: MIT License
@@ -10,10 +11,10 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: faker (>=33.1.0,<34.0.0)
 Requires-Dist: mimesis (>=18.0.0,<19.0.0)
 Requires-Dist: mysql-connector-python (>=9.1.0,<10.0.0)
-Requires-Dist: orjson (>=3.10.12,<4.0.0)
 Requires-Dist: pandas (>=2.2.3,<3.0.0)
 Requires-Dist: pyarrow (>=18.1.0,<19.0.0)
 Requires-Dist: pydantic (>=2.10.4,<3.0.0)
@@ -22,8 +23,6 @@ Description-Content-Type: text/markdown
 
 # TestDataX
 
-# TestDataX
-
 ![Build Status](https://github.com/JamesPBrett/testdatax/actions/workflows/publish.yml/badge.svg)
 [![codecov](https://codecov.io/gh/JamesPBrett/testdatax/branch/main/graph/badge.svg?token=6VX62CI6U9)](https://codecov.io/gh/JamesPBrett/testdatax)
 ![Python Version](https://img.shields.io/badge/python-3.11%2B-blue)
@@ -42,7 +41,7 @@ pip install testdatax
 
 # Generate sample data
 testdatax --rows 1000 --format json --output data.json
-
+```
 
 ## Features
 
@@ -118,7 +117,7 @@ testdatax -o mstest.sql -f mssql -r 1000
 
 Generate Oracle with default row count (1000), table_name as 'oracle':
 ```bash
-datagen -o oracle.sql -f oracle -r 1000
+testdatax -o oracle.sql -f oracle -r 1000
 ```
 
 Each command consists of:
@@ -224,6 +223,12 @@ The schema file defines the structure and constraints of your generated data. Ea
 }
 ```
 
+> **Note:** `start_date`/`end_date` bound the generated range (inclusive). When
+> `format` is set, date/datetime values are rendered to a string with
+> `strftime`; for the SQL exporters this means the column receives a formatted
+> string literal rather than a native date, so `format` is best suited to the
+> CSV/JSON formats.
+
 #### Enum Fields
 ```json
 {

{testdatax-0.1.3 → testdatax-0.2.0}/README.md

@@ -1,7 +1,5 @@
 # TestDataX
 
-# TestDataX
-
 ![Build Status](https://github.com/JamesPBrett/testdatax/actions/workflows/publish.yml/badge.svg)
 [![codecov](https://codecov.io/gh/JamesPBrett/testdatax/branch/main/graph/badge.svg?token=6VX62CI6U9)](https://codecov.io/gh/JamesPBrett/testdatax)
 ![Python Version](https://img.shields.io/badge/python-3.11%2B-blue)
@@ -20,7 +18,7 @@ pip install testdatax
 
 # Generate sample data
 testdatax --rows 1000 --format json --output data.json
-
+```
 
 ## Features
 
@@ -96,7 +94,7 @@ testdatax -o mstest.sql -f mssql -r 1000
 
 Generate Oracle with default row count (1000), table_name as 'oracle':
 ```bash
-datagen -o oracle.sql -f oracle -r 1000
+testdatax -o oracle.sql -f oracle -r 1000
 ```
 
 Each command consists of:
@@ -202,6 +200,12 @@ The schema file defines the structure and constraints of your generated data. Ea
 }
 ```
 
+> **Note:** `start_date`/`end_date` bound the generated range (inclusive). When
+> `format` is set, date/datetime values are rendered to a string with
+> `strftime`; for the SQL exporters this means the column receives a formatted
+> string literal rather than a native date, so `format` is best suited to the
+> CSV/JSON formats.
+
 #### Enum Fields
 ```json
 {

{testdatax-0.1.3 → testdatax-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "TestDataX"
-version = "0.1.3"
+version = "0.2.0"
 description = "A flexible test data generation toolkit"
 authors = ["JamesPBrett"]
 license = "MIT"
@@ -12,7 +12,6 @@ python = "^3.11"
 typer = "^0.15.1"
 faker = "^33.1.0"
 pydantic = "^2.10.4"
-orjson = "^3.10.12"
 pyarrow = "^18.1.0"
 pandas = "^2.2.3"
 mysql-connector-python = "^9.1.0"
@@ -39,13 +38,11 @@ types-psutil = "^6.1.0.20241221"
 commitizen = "^3.13.0"
 python-semantic-release = "^9.17.0"
 
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"
 
 [tool.poetry.scripts]
 testdatax = "src.cli:app"
 
+
 [tool.ruff]
 # Same as Black
 line-length = 88
@@ -85,6 +82,7 @@ exclude = [
 [tool.ruff.lint.isort]
 known-first-party = ["src"]
 
+
 [tool.black]
 line-length = 88
 target-version = ['py311']
@@ -128,6 +126,7 @@ ignore_missing_imports = true
 module = "src.providers.mimesis_provider"
 warn_return_any = false
 
+
 [tool.coverage.run]
 source = ["src"]
 branch = true
@@ -141,15 +140,17 @@ exclude_lines = [
     "pass",
 ]
 
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 python_files = ["test_*.py"]
 python_classes = ["Test*"]
 python_functions = ["test_*"]
 
+
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "0.1.0"
+version = "0.1.3"
 tag_format = "v$version"
 version_files = [
     "src/__init__.py:__version__",
@@ -223,3 +224,8 @@ allowed_tags = [
     "chore",    # Maintenance tasks
     "refactor", # Code changes without fixing bugs or adding features
 ]
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+

{testdatax-0.1.3 → testdatax-0.2.0}/src/__init__.py

@@ -1,6 +1,6 @@
 """TestDataX package initialization."""
 
-__version__ = "0.1.3"
+__version__ = "0.2.0"
 
 from src.cli import app  # noqa
 

{testdatax-0.1.3 → testdatax-0.2.0}/src/cli.py

@@ -102,16 +102,30 @@ def generate(
                             f"{min_value}, {max_value}"
                         )
 
+                # Accept "precision" as an alias for "right_digits"; use an
+                # explicit None check so an intentional 0 is not dropped.
+                right_digits = field_def.get("right_digits")
+                if right_digits is None:
+                    right_digits = field_def.get("precision")
+
                 field_schema = FieldSchema(
                     name=name,
                     type=field_type,
                     enum_values=field_def.get("values"),
                     min_value=min_value,
                     max_value=max_value,
-                    right_digits=field_def.get("right_digits"),
+                    right_digits=right_digits,
                     value_provider=field_def.get("provider_field")
                     or field_def.get("faker"),
                     pattern=field_def.get("pattern"),
+                    nullable=field_def.get("nullable", False),
+                    unique=field_def.get("unique", False),
+                    weights=field_def.get("weights"),
+                    min_length=field_def.get("min_length"),
+                    max_length=field_def.get("max_length"),
+                    start_date=field_def.get("start_date"),
+                    end_date=field_def.get("end_date"),
+                    format=field_def.get("format"),
                 )
                 fields.append(field_schema.model_dump())
             else:
@@ -163,9 +177,10 @@ def generate(
         raise typer.Exit(code=1) from e
     except Exception as e:
         typer.echo(f"Error: {str(e)}", err=True)
-        typer.echo(f"Exception type: {type(e).__name__}", err=True)
-        typer.echo(f"Exception args: {e.args}", err=True)
-        typer.echo(f"Traceback: {traceback.format_exc()}", err=True)
+        if debug:
+            typer.echo(f"Exception type: {type(e).__name__}", err=True)
+            typer.echo(f"Exception args: {e.args}", err=True)
+            typer.echo(f"Traceback: {traceback.format_exc()}", err=True)
         raise typer.Exit(code=1) from e
 
 

{testdatax-0.1.3 → testdatax-0.2.0}/src/exporters/csv_exporter.py

@@ -77,10 +77,8 @@ class CsvExporter(BaseExporter):
                 fieldnames = list(data[0].keys())
 
             first_chunk = True
-            formatted_rows = []
             for chunk in self.chunker.chunk_data(data):
                 formatted_chunk = [self.formatter.format_row(row) for row in chunk]
-                formatted_rows.extend(formatted_chunk)
                 df = pd.DataFrame(formatted_chunk, columns=fieldnames)
 
                 # Write the data to CSV in chunks

{testdatax-0.1.3 → testdatax-0.2.0}/src/exporters/json_exporter.py

@@ -62,16 +62,22 @@ class JsonExporter(BaseExporter):
                         raise ValueError(
                             f"Field '{field}' in schema is not present in data."
                         )
-            # Format the data and write it in chunks to the output file
-            all_formatted_rows = []
-            for chunk in self.chunker.chunk_data(data):
-                formatted_chunk = [self.formatter.format_row(row) for row in chunk]
-                all_formatted_rows.extend(formatted_chunk)
 
-            # Write the complete file with proper formatting using json.dumps
+            # Stream a valid JSON array to disk one chunk at a time so the whole
+            # dataset is never held in memory at once.
             with open(output_path, "w", encoding="utf-8") as f:
-                json_str = json.dumps(all_formatted_rows, indent=4)
-                f.write(json_str)
+                f.write("[")
+                first = True
+                for chunk in self.chunker.chunk_data(data):
+                    for row in chunk:
+                        formatted = self.formatter.format_row(row)
+                        block = json.dumps(formatted, indent=4)
+                        indented = "\n".join(
+                            "    " + line for line in block.splitlines()
+                        )
+                        f.write(("\n" if first else ",\n") + indented)
+                        first = False
+                f.write("\n]" if not first else "]")
 
             logger.info(f"Successfully exported {len(data)} rows to {output_path}.")
 

{testdatax-0.1.3 → testdatax-0.2.0}/src/exporters/mssql_exporter.py

@@ -1,10 +1,12 @@
 import decimal
 from datetime import date, datetime
+from pathlib import Path
 from typing import Any
 from uuid import UUID
 
 from .base_exporter import BaseExporter
 from .utils.constants import DEFAULT_SCHEMA
+from .utils.sql import escape_ansi_quotes
 
 MSSQL_TYPE_MAPPING = {
     "string": "NVARCHAR(255)",  # Unicode string support
@@ -25,6 +27,11 @@ MSSQL_TYPE_MAPPING = {
 class MssqlExporter(BaseExporter):
     """Exports data to MSSQL compatible SQL file."""
 
+    @staticmethod
+    def _escape(value: str) -> str:
+        """Escape a string for a T-SQL single-quoted literal (quote doubling)."""
+        return escape_ansi_quotes(value)
+
     def _format_value(
         self,
         value: (
@@ -69,7 +76,7 @@ class MssqlExporter(BaseExporter):
         if value is None:
             return "NULL"
         elif isinstance(value, (str | UUID)):
-            return "'" + str(value).replace("'", "\\'").replace("\n", "\\n") + "'"
+            return "'" + self._escape(str(value)) + "'"
         elif isinstance(value, (datetime | date)):
             return f"'{value.isoformat()}'"
         elif isinstance(value, bool):
@@ -141,7 +148,7 @@ class MssqlExporter(BaseExporter):
                 and field_def.get("type") == "enum"
                 and "values" in field_def
             ):
-                values = "','".join(field_def["values"])
+                values = "','".join(self._escape(v) for v in field_def["values"])
                 check_constraints.append(f"CHECK ({field_name} IN ('{values}'))")
 
             columns.append(f"    {field_name} {sql_type} NULL")
@@ -188,7 +195,7 @@ class MssqlExporter(BaseExporter):
         if not data:
             return
 
-        table_name = output_path.split("/")[-1].split(".")[0]
+        table_name = Path(output_path).name.split(".")[0]
 
         with open(output_path, "w") as f:
             # Always write CREATE TABLE using DEFAULT_SCHEMA if no schema provided

{testdatax-0.1.3 → testdatax-0.2.0}/src/exporters/mysql_exporter.py

@@ -1,10 +1,12 @@
 import decimal
 from datetime import date, datetime
+from pathlib import Path
 from typing import Any
 from uuid import UUID
 
 from .base_exporter import BaseExporter
 from .utils.constants import DEFAULT_SCHEMA
+from .utils.sql import escape_mysql_literal
 
 MYSQL_TYPE_MAPPING = {
     "string": "VARCHAR(255)",
@@ -25,6 +27,11 @@ MYSQL_TYPE_MAPPING = {
 class MysqlExporter(BaseExporter):
     """Exports data to MySQL compatible SQL file."""
 
+    @staticmethod
+    def _escape(value: str) -> str:
+        """Escape a string for a MySQL single-quoted literal."""
+        return escape_mysql_literal(value)
+
     def _format_value(
         self,
         value: (
@@ -69,7 +76,7 @@ class MysqlExporter(BaseExporter):
         if value is None:
             return "NULL"
         elif isinstance(value, (str | UUID)):
-            return "'" + str(value).replace("'", "\\'").replace("\n", "\\n") + "'"
+            return "'" + self._escape(str(value)) + "'"
         elif isinstance(value, (datetime | date)):
             return f"'{value.isoformat()}'"
         elif isinstance(value, bool):
@@ -138,7 +145,7 @@ class MysqlExporter(BaseExporter):
                 and field_def.get("type") == "enum"
                 and "values" in field_def
             ):
-                values = "','".join(field_def["values"])
+                values = "','".join(self._escape(v) for v in field_def["values"])
                 sql_type = f"ENUM('{values}')"
             columns.append(f"    {field_name} {sql_type} NULL")
 
@@ -174,7 +181,7 @@ class MysqlExporter(BaseExporter):
         if not data:
             return
 
-        table_name = output_path.split("/")[-1].split(".")[0]
+        table_name = Path(output_path).name.split(".")[0]
 
         with open(output_path, "w") as f:
             # Always write CREATE TABLE using DEFAULT_SCHEMA if no schema provided

{testdatax-0.1.3 → testdatax-0.2.0}/src/exporters/oracle_exporter.py

@@ -1,10 +1,12 @@
 import decimal
 from datetime import date, datetime
+from pathlib import Path
 from typing import Any
 from uuid import UUID
 
 from .base_exporter import BaseExporter
 from .utils.constants import DEFAULT_SCHEMA
+from .utils.sql import escape_ansi_quotes
 
 ORACLE_TYPE_MAPPING = {
     "string": "VARCHAR2(255)",  # Oracle's Unicode string type
@@ -25,6 +27,11 @@ ORACLE_TYPE_MAPPING = {
 class OracleExporter(BaseExporter):
     """Exports data to ORACLE compatible SQL file."""
 
+    @staticmethod
+    def _escape(value: str) -> str:
+        """Escape a string for an Oracle single-quoted literal (quote doubling)."""
+        return escape_ansi_quotes(value)
+
     def _format_value(
         self,
         value: (
@@ -69,7 +76,7 @@ class OracleExporter(BaseExporter):
         if value is None:
             return "NULL"
         elif isinstance(value, (str)):
-            return "'" + str(value).replace("'", "''") + "'"  # uses '' for escaping
+            return "'" + self._escape(str(value)) + "'"  # uses '' for escaping
         elif isinstance(value, UUID):
             return f"'{str(value)}'"
         elif isinstance(value, datetime):
@@ -148,7 +155,7 @@ class OracleExporter(BaseExporter):
                 and field_def.get("type") == "enum"
                 and "values" in field_def
             ):
-                values = "','".join(field_def["values"])
+                values = "','".join(self._escape(v) for v in field_def["values"])
                 check_constraints.append(f"CHECK ({field_name} IN ('{values}'))")
 
             columns.append(f"    {field_name} {sql_type} NULL")
@@ -195,7 +202,7 @@ class OracleExporter(BaseExporter):
         if not data:
             return
 
-        table_name = output_path.split("/")[-1].split(".")[0]
+        table_name = Path(output_path).name.split(".")[0]
 
         with open(output_path, "w") as f:
             # Always write CREATE TABLE using DEFAULT_SCHEMA if no schema provided

{testdatax-0.1.3 → testdatax-0.2.0}/src/exporters/utils/constants.py

@@ -11,6 +11,12 @@ CHUNK_SIZE_CSV = CHUNK_SIZE
 CHUNK_SIZE_PARQUET = CHUNK_SIZE
 CHUNK_SIZE_ORC = CHUNK_SIZE
 
+# Probability that a nullable field emits NULL instead of a value
+NULL_PROBABILITY = 0.1
+
+# Maximum attempts to generate a unique value before giving up
+MAX_UNIQUE_RETRIES = 1000
+
 # ORC compression types
 OrcCompression = Literal["UNCOMPRESSED", "SNAPPY", "ZLIB", "LZ4", "ZSTD"]
 OrcStrategy = Literal["SPEED", "COMPRESSION"]

testdatax-0.2.0/src/exporters/utils/sql.py

@@ -0,0 +1,18 @@
+"""Shared SQL string-escaping helpers for the SQL exporters."""
+
+
+def escape_ansi_quotes(value: str) -> str:
+    """Escape an ANSI single-quoted SQL literal by doubling embedded quotes.
+
+    Used by dialects without backslash escaping (MSSQL, Oracle).
+    """
+    return value.replace("'", "''")
+
+
+def escape_mysql_literal(value: str) -> str:
+    """Escape a MySQL single-quoted literal.
+
+    The backslash is escaped first so a value containing a backslash cannot
+    terminate the literal early, then single quotes and newlines are escaped.
+    """
+    return value.replace("\\", "\\\\").replace("'", "\\'").replace("\n", "\\n")

testdatax-0.2.0/src/generator.py

@@ -0,0 +1,175 @@
+import random
+from datetime import date, datetime
+from decimal import Decimal
+from typing import TYPE_CHECKING, Any
+from uuid import UUID
+
+from .exporters.utils.constants import MAX_UNIQUE_RETRIES, NULL_PROBABILITY
+from .providers import DataProvider, FakerProvider
+from .schemas import DataType, FieldSchema
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+# Union of every value type the generator can produce for a single field.
+GeneratedValue = (
+    str | int | float | Decimal | bool | date | datetime | bytes | UUID | None
+)
+
+
+class DataGenerator:
+    """The DataGenerator class generates synthetic data based on the provided field schemas.
+
+    Supported data types:
+        - STRING: Generates usernames
+        - TEXT: Generates paragraphs of text
+        - INTEGER: Generates integers between 0 and 100
+        - BIGINT: Generates large integers between 0 and 9999999999
+        - FLOAT: Generates floating point numbers with 2 decimal places
+        - DECIMAL: Generates Decimal numbers with 2 decimal places
+        - BOOLEAN: Generates True/False values
+        - DATE: Generates date objects
+        - DATETIME: Generates datetime objects
+        - BLOB: Generates binary data
+        - UUID: Generates UUID objects
+        - ENUM: Generates values from provided enum_values list
+
+    Cross-cutting field options (``nullable``, ``unique`` and ``format``) are applied
+    uniformly across every type during :meth:`generate_data`.
+
+    """  # noqa: E501
+
+    def __init__(self, provider: DataProvider | None = None) -> None:
+        """Initialize the DataGenerator with a provider and type generator map.
+
+        Args:
+            provider: The data provider used to generate values. Defaults to
+                :class:`FakerProvider` when not supplied.
+
+        """
+        self.provider = provider or FakerProvider()
+        self.type_generators: dict[
+            DataType, Callable[[FieldSchema], GeneratedValue]
+        ] = {
+            DataType.STRING: self._generate_string,
+            DataType.TEXT: self._generate_text,
+            DataType.INTEGER: self._generate_integer,
+            DataType.BIGINT: self._generate_bigint,
+            DataType.FLOAT: self._generate_float,
+            DataType.DECIMAL: self._generate_decimal,
+            DataType.BOOLEAN: self._generate_boolean,
+            DataType.DATE: self._generate_date,
+            DataType.DATETIME: self._generate_datetime,
+            DataType.BLOB: self._generate_blob,
+            DataType.UUID: self._generate_uuid,
+            DataType.ENUM: self._generate_enum,
+        }
+
+    def generate_data(
+        self, fields: list[FieldSchema], count: int
+    ) -> list[dict[str, Any]]:
+        """Generate data based on the provided schema and count."""
+        unique_seen: dict[str, set[GeneratedValue]] = {
+            field.name: set() for field in fields if field.unique
+        }
+        data = []
+        for _ in range(count):
+            row = {}
+            for field in fields:
+                row[field.name] = self._generate_field_value(field, unique_seen)
+            data.append(row)
+        return data
+
+    def _generate_field_value(
+        self, field: FieldSchema, unique_seen: dict[str, set[GeneratedValue]]
+    ) -> GeneratedValue:
+        """Produce a single value, honoring nullable/unique/format options."""
+        if field.unique:
+            seen = unique_seen[field.name]
+            for _ in range(MAX_UNIQUE_RETRIES):
+                value = self._produce_value(field)
+                if value is None or value not in seen:
+                    if value is not None:
+                        seen.add(value)
+                    return self._apply_format(field, value)
+            raise ValueError(
+                f"Could not generate a unique value for field '{field.name}' "
+                f"after {MAX_UNIQUE_RETRIES} attempts"
+            )
+        return self._apply_format(field, self._produce_value(field))
+
+    def _produce_value(self, field: FieldSchema) -> GeneratedValue:
+        """Generate a raw value for a field, applying only the nullable option."""
+        if field.nullable and random.random() < NULL_PROBABILITY:
+            return None
+        return self.type_generators[field.type](field)
+
+    @staticmethod
+    def _apply_format(field: FieldSchema, value: GeneratedValue) -> GeneratedValue:
+        """Render date/datetime values via strftime when a format is set.
+
+        Applied after the uniqueness check so uniqueness is tracked on the raw
+        (high-cardinality) value rather than the formatted string.
+        """
+        if field.format and isinstance(value, (date | datetime)):
+            return value.strftime(field.format)
+        return value
+
+    def _generate_string(self, field: FieldSchema) -> str:
+        provider_value = str(field.value_provider) if field.value_provider else "name"
+        return self.provider.generate_string(
+            value_provider=provider_value,
+            min_length=field.min_length,
+            max_length=field.max_length,
+        )
+
+    def _generate_text(self, field: FieldSchema) -> str:
+        return self.provider.generate_text(
+            min_length=field.min_length, max_length=field.max_length
+        )
+
+    def _generate_integer(self, field: FieldSchema) -> int:
+        min_val = int(field.min_value) if field.min_value is not None else 0
+        max_val = int(field.max_value) if field.max_value is not None else 100
+        return self.provider.generate_integer(min_value=min_val, max_value=max_val)
+
+    def _generate_bigint(self, field: FieldSchema) -> int:
+        min_val = int(field.min_value) if field.min_value is not None else 0
+        max_val = int(field.max_value) if field.max_value is not None else 9999999999
+        return self.provider.generate_integer(min_value=min_val, max_value=max_val)
+
+    def _generate_float(self, field: FieldSchema) -> float:
+        return self.provider.generate_float(
+            min_value=field.min_value,
+            max_value=field.max_value,
+            right_digits=field.right_digits if field.right_digits is not None else 2,
+        )
+
+    def _generate_decimal(self, field: FieldSchema) -> Decimal:
+        return self.provider.generate_decimal(
+            min_value=field.min_value,
+            max_value=field.max_value,
+            right_digits=field.right_digits if field.right_digits is not None else 2,
+        )
+
+    def _generate_boolean(self, field: FieldSchema) -> bool:
+        return self.provider.generate_boolean()
+
+    def _generate_date(self, field: FieldSchema) -> date:
+        return self.provider.generate_date(start=field.start_date, end=field.end_date)
+
+    def _generate_datetime(self, field: FieldSchema) -> datetime:
+        return self.provider.generate_datetime(
+            start=field.start_date, end=field.end_date
+        )
+
+    def _generate_blob(self, field: FieldSchema) -> bytes:
+        return self.provider.generate_binary()
+
+    def _generate_uuid(self, field: FieldSchema) -> UUID:
+        return self.provider.generate_uuid()
+
+    def _generate_enum(self, field: FieldSchema) -> str:
+        if not field.enum_values:
+            raise ValueError(f"Enum field {field.name} must have values defined")
+        return self.provider.generate_enum(field.enum_values, weights=field.weights)