TestDataX 0.1.0__py3-none-any.whl

src/exporters/utils/exporter_config.py

@@ -0,0 +1,17 @@
+from ..csv_exporter import CsvExporter
+from ..json_exporter import JsonExporter
+from ..mssql_exporter import MssqlExporter
+from ..mysql_exporter import MysqlExporter
+from ..oracle_exporter import OracleExporter
+from ..orc_exporter import OrcExporter
+from ..parquet_exporter import ParquetExporter
+
+EXPORTER_CLASSES = {
+    "csv": CsvExporter(),
+    "json": JsonExporter(),
+    "parquet": ParquetExporter(),
+    "orc": OrcExporter(),
+    "mysql": MysqlExporter(),
+    "mssql": MssqlExporter(),
+    "oracle": OracleExporter(),
+}

src/exporters/utils/formatters.py

@@ -0,0 +1,165 @@
+import json
+import uuid
+from abc import abstractmethod
+from datetime import date, datetime
+from decimal import Decimal
+from typing import Any
+
+
+class BaseFormatter:
+    """Base class for handling data type formatting across exporters."""
+
+    @staticmethod
+    def format_none() -> str | None:
+        """Format None values."""
+        return None
+
+    @staticmethod
+    def format_datetime(value: datetime | date) -> str:
+        """Format datetime and date values."""
+        return value.isoformat()
+
+    @staticmethod
+    def format_uuid(value: uuid.UUID) -> str:
+        """Format UUID values."""
+        return str(value)
+
+    @staticmethod
+    def format_bytes(value: bytes) -> str:
+        """Format bytes values."""
+        return value.hex()
+
+    @staticmethod
+    def format_decimal(value: Decimal) -> float:
+        """Format Decimal values."""
+        return float(value)
+
+    @staticmethod
+    def format_string(value: str) -> str:
+        """Format string values, removing null bytes."""
+        return str(value).replace("\x00", "")
+
+    @abstractmethod
+    def format_value(
+        self,
+        value: (
+            None
+            | datetime
+            | date
+            | uuid.UUID
+            | bytes
+            | Decimal
+            | dict
+            | list
+            | int
+            | float
+            | str
+        ),
+    ) -> None | str | float | dict | list | int:
+        """Format a single value according to export format requirements.
+
+        Args:
+            value: The value to format
+
+        Returns:
+            Formatted value suitable for the target format
+
+        """
+        pass
+
+    def format_row(
+        self, row: dict[str, Any], **kwargs: dict[str, str | int | float]
+    ) -> dict[str, Any]:
+        """Format the provided rows with the correct format_value.
+
+        Args:
+            row: Dictionary containing row data
+            **kwargs: Additional format-specific parameters
+
+        Returns:
+            Formatted row dictionary
+
+        """
+        formatted_row: dict[str, Any] = {}
+        for key, value in row.items():
+            try:
+                formatted_row[key] = self.format_value(value)
+            except Exception as e:
+                formatted_row[key] = f"ERROR: {str(e)}"
+        return formatted_row
+
+
+class JSONFormatter(BaseFormatter):
+    """Formatter for JSON exports."""
+
+    @classmethod
+    def format_value(
+        cls,
+        value: (
+            datetime
+            | date
+            | uuid.UUID
+            | bytes
+            | Decimal
+            | dict
+            | list
+            | int
+            | float
+            | str
+            | None
+        ),
+    ) -> str | float | dict | list | int | None:
+        """Format the provided values."""
+        if value is None:
+            return cls.format_none()
+        elif isinstance(value, (datetime | date)):
+            return cls.format_datetime(value)
+        elif isinstance(value, uuid.UUID):
+            return cls.format_uuid(value)
+        elif isinstance(value, bytes):
+            return cls.format_bytes(value)
+        elif isinstance(value, Decimal):
+            return cls.format_decimal(value)
+        elif isinstance(value, (dict | list | int | float)):
+            return value
+        else:
+            return cls.format_string(str(value))
+
+
+class CSVFormatter(BaseFormatter):
+    """Formatter for CSV exports."""
+
+    @classmethod
+    def format_value(
+        cls,
+        value: (
+            datetime
+            | date
+            | uuid.UUID
+            | bytes
+            | Decimal
+            | dict
+            | list
+            | int
+            | float
+            | str
+            | None
+        ),
+    ) -> str | float | dict | list | int | None:
+        """Format the provided values."""
+        if value is None:
+            return cls.format_none()
+        elif isinstance(value, (datetime | date)):
+            return cls.format_datetime(value)
+        elif isinstance(value, uuid.UUID):
+            return cls.format_uuid(value)
+        elif isinstance(value, bytes):
+            return cls.format_bytes(value)
+        elif isinstance(value, Decimal):
+            return cls.format_decimal(value)
+        elif isinstance(value, (dict | list)):
+            return json.dumps(value)
+        elif isinstance(value, (int | float)):
+            return value
+        else:
+            return cls.format_string(str(value))

src/generator.py

@@ -0,0 +1,117 @@
+from datetime import date, datetime
+from decimal import Decimal
+from typing import Any
+from uuid import UUID
+
+from faker import Faker
+
+from .providers import DataProvider, FakerProvider
+from .schemas import DataType, FieldSchema
+
+
+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
+
+    """  # noqa: E501
+
+    def __init__(self, provider: DataProvider | None = None) -> None:
+        """Initialize the DataGenerator with Faker instance and type generator mappings.
+
+        The constructor initializes the Faker instance and creates a mapping of DataType
+        enums to their corresponding generator methods.
+        """
+        self.provider = provider or FakerProvider()
+        self.faker = Faker()
+        self.type_generators = {
+            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."""
+        data = []
+        for _ in range(count):
+            row = {}
+            for field in fields:
+                generator = self.type_generators[field.type]
+                row[field.name] = generator(field)
+            data.append(row)
+        return data
+
+    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)
+
+    def _generate_text(self, field: FieldSchema) -> str:
+        return self.provider.generate_text()
+
+    def _generate_integer(self, field: FieldSchema) -> int:
+        min_val = (
+            int(field.min_value)
+            if hasattr(field, "min_value") and field.min_value is not None
+            else 0
+        )
+        max_val = (
+            int(field.max_value)
+            if hasattr(field, "max_value") and 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:
+        return self.faker.random_int(min=0, max=9999999999)
+
+    def _generate_float(self, field: FieldSchema) -> float:
+        return self.faker.pyfloat(right_digits=2)
+
+    def _generate_decimal(self, field: FieldSchema) -> Decimal:
+        return self.provider.generate_decimal()
+
+    def _generate_boolean(self, field: FieldSchema) -> bool:
+        return self.provider.generate_boolean()
+
+    def _generate_date(self, field: FieldSchema) -> date:
+        return self.provider.generate_date()
+
+    def _generate_datetime(self, field: FieldSchema) -> datetime:
+        return self.provider.generate_datetime()
+
+    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)

src/providers/__init__.py

@@ -0,0 +1,4 @@
+from .base import DataProvider
+from .faker_provider import FakerProvider
+
+__all__ = ["DataProvider", "FakerProvider"]

src/providers/base.py

@@ -0,0 +1,58 @@
+from abc import ABC, abstractmethod
+from datetime import date, datetime
+from decimal import Decimal
+from uuid import UUID
+
+
+class DataProvider(ABC):
+    """Abstract base class for data providers that generate test data values."""
+
+    @abstractmethod
+    def generate_string(self, **kwargs: str) -> str:
+        """Generate a string value."""
+        pass
+
+    @abstractmethod
+    def generate_text(self, **kwargs: str) -> str:
+        """Generate a text value."""
+        pass
+
+    @abstractmethod
+    def generate_integer(self, min_value: int = 0, max_value: int = 100) -> int:
+        """Generate an integer value."""
+        pass
+
+    @abstractmethod
+    def generate_decimal(self, **kwargs: Decimal) -> Decimal:
+        """Generate a decimal value."""
+        pass
+
+    @abstractmethod
+    def generate_boolean(self) -> bool:
+        """Generate a boolean value."""
+        pass
+
+    @abstractmethod
+    def generate_date(self) -> date:
+        """Generate a date value."""
+        pass
+
+    @abstractmethod
+    def generate_datetime(self) -> datetime:
+        """Generate a datetime value."""
+        pass
+
+    @abstractmethod
+    def generate_binary(self, length: int = 64) -> bytes:
+        """Generate binary data."""
+        pass
+
+    @abstractmethod
+    def generate_uuid(self) -> UUID:
+        """Generate a UUID."""
+        pass
+
+    @abstractmethod
+    def generate_enum(self, values: list[str]) -> str:
+        """Generate an enum value from the given choices."""
+        pass

src/providers/faker_provider.py

@@ -0,0 +1,65 @@
+from datetime import date, datetime
+from decimal import Decimal
+from uuid import UUID
+
+from faker import Faker
+
+from .base import DataProvider
+
+
+class FakerProvider(DataProvider):
+    """FakerProvider generates fake data using the Faker library."""
+
+    def __init__(self) -> None:
+        """Initialize the FakerProvider with a Faker instance."""
+        self.faker = Faker()
+
+    def generate_string(self, **kwargs: str) -> str:
+        """Generate a fake string using the specified Faker provider."""
+        provider = kwargs.get("value_provider") or "name"
+        return str(getattr(self.faker, provider)())
+
+    def generate_text(self, **kwargs: str) -> str:
+        """Generate a fake text string."""
+        return self.faker.text()
+
+    def generate_integer(
+        self, min_value: int | None = None, max_value: int | None = None
+    ) -> int:
+        """Generate a fake integer within the specified range."""
+        min_val = min_value if min_value is not None else 0
+        max_val = max_value if max_value is not None else 100
+        return self.faker.pyint(min_value=min_val, max_value=max_val)
+
+    def generate_decimal(self, **kwargs: Decimal) -> Decimal:
+        """Generate a fake decimal number."""
+        return Decimal(str(self.faker.pyfloat(right_digits=2)))
+
+    def generate_boolean(self) -> bool:
+        """Generate a fake boolean value."""
+        return self.faker.boolean()
+
+    def generate_date(self) -> date:
+        """Generate a fake date object."""
+        return self.faker.date_object()
+
+    def generate_datetime(self) -> datetime:
+        """Generate a fake datetime object."""
+        return self.faker.date_time()
+
+    def generate_binary(self, length: int = 64) -> bytes:
+        """Generate a fake binary string of the specified length."""
+        return self.faker.binary(length=length)
+
+    def generate_uuid(self) -> UUID:
+        """Generate a fake UUID."""
+        uuid_value = self.faker.uuid4()
+        if isinstance(uuid_value, UUID):
+            return uuid_value
+        return UUID(str(uuid_value))
+
+    def generate_enum(self, values: list[str]) -> str:
+        """Generate a fake value from the given list of values."""
+        if not values:
+            raise ValueError("Enum values cannot be empty")
+        return self.faker.random_element(values)

src/schemas.py

@@ -0,0 +1,81 @@
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from .exporters.utils.constants import EXPORT_PATTERNS
+
+
+class DataType(str, Enum):
+    """An enumeration class for different data types commonly used in database schemas.
+
+    A comprehensive set of data types that can be used to define the structure of
+    generated data in various database contexts.
+
+    Attributes:
+        STRING: Represents a string data type for short character sequences
+        TEXT: Represents a text data type for longer character sequences
+        INTEGER: Represents a standard integer data type
+        BIGINT: Represents a large integer data type
+        FLOAT: Represents a floating-point number data type
+        DECIMAL: Represents a precise decimal number data type
+        BOOLEAN: Represents a boolean (True/False) data type
+        DATE: Represents a date data type
+        DATETIME: Represents a date and time data type
+        BLOB: Represents a binary large object data type
+        UUID: Represents a universally unique identifier data type
+        ENUM: Represents an enumerated data type
+
+    """
+
+    STRING = "string"
+    TEXT = "text"
+    INTEGER = "integer"
+    BIGINT = "bigint"
+    FLOAT = "float"
+    DECIMAL = "decimal"
+    BOOLEAN = "boolean"
+    DATE = "date"
+    DATETIME = "datetime"
+    BLOB = "blob"
+    UUID = "uuid"
+    ENUM = "enum"
+
+
+class FieldSchema(BaseModel):
+    """Defines the schema for a single field in the data generation configuration.
+
+    This class represents the structure and constraints for generating field values.
+    """
+
+    name: str
+    type: DataType
+    enum_values: list[str] | None = None
+    min_value: Any | None = None
+    max_value: Any | None = None
+    right_digits: int | None = None
+    value_provider: str | None = None
+    pattern: str | None = None
+
+
+class GeneratorConfig(BaseModel):
+    """A configuration class for data generation.
+
+    This class defines the structure and parameters needed for generating synthetic
+    data.
+
+    Attributes:
+        fields (list[FieldSchema]): List of field schemas defining the structure of
+        data to generate.
+
+        row_count (int): Number of rows/records to generate.
+        export_format (str): Format for exporting generated data. Must match defined
+        export patterns.
+        output_path (str): File path where the generated data will be saved.
+
+    """
+
+    fields: list[FieldSchema]
+    row_count: int
+    export_format: str = Field(..., pattern=EXPORT_PATTERNS)
+    output_path: str

testdatax-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 JamesPBrett
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.