pydantic-fixturegen 1.0.0__py3-none-any.whl

pydantic_fixturegen/core/generate.py

@@ -0,0 +1,311 @@
+"""Instance generation engine using provider strategies."""
+
+from __future__ import annotations
+
+import dataclasses
+import enum
+import inspect
+import random
+from collections.abc import Iterable, Sized
+from dataclasses import dataclass, is_dataclass
+from dataclasses import fields as dataclass_fields
+from typing import Any, get_type_hints
+
+from faker import Faker
+from pydantic import BaseModel
+from pydantic.fields import FieldInfo
+
+from pydantic_fixturegen.core import schema as schema_module
+from pydantic_fixturegen.core.providers import ProviderRegistry, create_default_registry
+from pydantic_fixturegen.core.schema import FieldConstraints, FieldSummary, extract_constraints
+from pydantic_fixturegen.core.strategies import (
+    Strategy,
+    StrategyBuilder,
+    StrategyResult,
+    UnionStrategy,
+)
+from pydantic_fixturegen.plugins.loader import get_plugin_manager, load_entrypoint_plugins
+
+
+@dataclass(slots=True)
+class GenerationConfig:
+    max_depth: int = 5
+    max_objects: int = 100
+    enum_policy: str = "first"
+    union_policy: str = "first"
+    default_p_none: float = 0.0
+    optional_p_none: float = 0.0
+    seed: int | None = None
+
+
+class InstanceGenerator:
+    """Generate instances of Pydantic models with recursion guards."""
+
+    def __init__(
+        self,
+        registry: ProviderRegistry | None = None,
+        *,
+        config: GenerationConfig | None = None,
+    ) -> None:
+        self.config = config or GenerationConfig()
+        self.registry = registry or create_default_registry(load_plugins=False)
+        self.random = random.Random(self.config.seed)
+        self.faker = Faker()
+        if self.config.seed is not None:
+            Faker.seed(self.config.seed)
+            self.faker.seed_instance(self.config.seed)
+
+        load_entrypoint_plugins()
+        self._plugin_manager = get_plugin_manager()
+
+        if registry is None:
+            self.registry.load_entrypoint_plugins()
+
+        self.builder = StrategyBuilder(
+            self.registry,
+            enum_policy=self.config.enum_policy,
+            union_policy=self.config.union_policy,
+            default_p_none=self.config.default_p_none,
+            optional_p_none=self.config.optional_p_none,
+            plugin_manager=self._plugin_manager,
+        )
+        self._strategy_cache: dict[type[Any], dict[str, StrategyResult]] = {}
+
+    # ------------------------------------------------------------------ public API
+    def generate_one(self, model: type[BaseModel]) -> BaseModel | None:
+        self._objects_remaining = self.config.max_objects
+        return self._build_model_instance(model, depth=0)
+
+    def generate(self, model: type[BaseModel], count: int = 1) -> list[BaseModel]:
+        results: list[BaseModel] = []
+        for _ in range(count):
+            instance = self.generate_one(model)
+            if instance is None:
+                break
+            results.append(instance)
+        return results
+
+    # ------------------------------------------------------------------ internals
+    def _build_model_instance(self, model_type: type[Any], *, depth: int) -> Any | None:
+        if depth >= self.config.max_depth:
+            return None
+        if not self._consume_object():
+            return None
+
+        try:
+            strategies = self._get_model_strategies(model_type)
+        except TypeError:
+            return None
+
+        values: dict[str, Any] = {}
+        for field_name, strategy in strategies.items():
+            values[field_name] = self._evaluate_strategy(strategy, depth)
+
+        try:
+            if isinstance(model_type, type) and issubclass(model_type, BaseModel):
+                return model_type(**values)
+            if is_dataclass(model_type):
+                return model_type(**values)
+        except Exception:
+            return None
+        return None
+
+    def _evaluate_strategy(self, strategy: StrategyResult, depth: int) -> Any:
+        if isinstance(strategy, UnionStrategy):
+            return self._evaluate_union(strategy, depth)
+        return self._evaluate_single(strategy, depth)
+
+    def _evaluate_union(self, strategy: UnionStrategy, depth: int) -> Any:
+        choices = strategy.choices
+        if not choices:
+            return None
+
+        selected = self.random.choice(choices) if strategy.policy == "random" else choices[0]
+        return self._evaluate_single(selected, depth)
+
+    def _evaluate_single(self, strategy: Strategy, depth: int) -> Any:
+        if self._should_return_none(strategy):
+            return None
+
+        summary = strategy.summary
+        enum_values = strategy.enum_values or summary.enum_values
+
+        if enum_values:
+            return self._select_enum_value(strategy, enum_values)
+
+        annotation = strategy.annotation
+
+        if self._is_model_like(annotation):
+            return self._build_model_instance(annotation, depth=depth + 1)
+
+        if summary.type in {"list", "set", "tuple", "mapping"}:
+            return self._evaluate_collection(strategy, depth)
+
+        if strategy.provider_ref is None:
+            return None
+        return self._call_strategy_provider(strategy)
+
+    def _evaluate_collection(self, strategy: Strategy, depth: int) -> Any:
+        summary = strategy.summary
+        base_value = self._call_strategy_provider(strategy)
+
+        item_annotation = summary.item_annotation
+        if item_annotation is None or not self._is_model_like(item_annotation):
+            return base_value
+
+        if summary.type == "mapping":
+            return self._build_mapping_collection(base_value, item_annotation, depth)
+
+        length = self._collection_length_from_value(base_value)
+        count = max(1, length)
+        items: list[Any] = []
+        for _ in range(count):
+            nested = self._build_model_instance(item_annotation, depth=depth + 1)
+            if nested is not None:
+                items.append(nested)
+
+        if summary.type == "list":
+            return items
+        if summary.type == "tuple":
+            return tuple(items)
+        if summary.type == "set":
+            try:
+                return set(items)
+            except TypeError:
+                return set()
+        return base_value
+
+    def _build_mapping_collection(
+        self,
+        base_value: Any,
+        annotation: Any,
+        depth: int,
+    ) -> dict[str, Any]:
+        if isinstance(base_value, dict) and base_value:
+            keys: Iterable[str] = base_value.keys()
+        else:
+            length = self._collection_length_from_value(base_value)
+            count = max(1, length)
+            keys = (self.faker.pystr(min_chars=3, max_chars=6) for _ in range(count))
+
+        result: dict[str, Any] = {}
+        for key in keys:
+            nested = self._build_model_instance(annotation, depth=depth + 1)
+            if nested is not None:
+                result[str(key)] = nested
+        return result
+
+    def _consume_object(self) -> bool:
+        if getattr(self, "_objects_remaining", 0) <= 0:
+            return False
+        self._objects_remaining -= 1
+        return True
+
+    def _get_model_strategies(self, model_type: type[Any]) -> dict[str, StrategyResult]:
+        cached = self._strategy_cache.get(model_type)
+        if cached is not None:
+            return cached
+
+        if isinstance(model_type, type) and issubclass(model_type, BaseModel):
+            strategies = dict(self.builder.build_model_strategies(model_type))
+        elif is_dataclass(model_type):
+            strategies = self._build_dataclass_strategies(model_type)
+        else:
+            raise TypeError(f"Unsupported model type: {model_type!r}")
+
+        self._strategy_cache[model_type] = strategies
+        return strategies
+
+    def _build_dataclass_strategies(self, cls: type[Any]) -> dict[str, StrategyResult]:
+        strategies: dict[str, StrategyResult] = {}
+        type_hints = get_type_hints(cls)
+        for field in dataclass_fields(cls):
+            if not field.init:
+                continue
+            annotation = type_hints.get(field.name, field.type)
+            summary = self._summarize_dataclass_field(field, annotation)
+            strategies[field.name] = self.builder.build_field_strategy(
+                cls,
+                field.name,
+                annotation,
+                summary,
+            )
+        return strategies
+
+    def _summarize_dataclass_field(
+        self,
+        field: dataclasses.Field[Any],
+        annotation: Any,
+    ) -> FieldSummary:
+        field_info = self._extract_field_info(field)
+        if field_info is not None:
+            constraints = extract_constraints(field_info)
+        else:
+            constraints = FieldConstraints()
+        return schema_module._summarize_annotation(annotation, constraints)
+
+    @staticmethod
+    def _extract_field_info(field: dataclasses.Field[Any]) -> FieldInfo | None:
+        for meta in getattr(field, "metadata", ()):
+            if isinstance(meta, FieldInfo):
+                return meta
+        return None
+
+    def _should_return_none(self, strategy: Strategy) -> bool:
+        if strategy.p_none <= 0:
+            return False
+        return self.random.random() < strategy.p_none
+
+    def _select_enum_value(self, strategy: Strategy, enum_values: list[Any]) -> Any:
+        if not enum_values:
+            return None
+
+        policy = strategy.enum_policy or self.config.enum_policy
+        selection = self.random.choice(enum_values) if policy == "random" else enum_values[0]
+
+        annotation = strategy.annotation
+        if isinstance(annotation, type) and issubclass(annotation, enum.Enum):
+            try:
+                return annotation(selection)
+            except Exception:
+                return selection
+        return selection
+
+    @staticmethod
+    def _collection_length_from_value(value: Any) -> int:
+        if value is None:
+            return 0
+        if isinstance(value, Sized):
+            return len(value)
+        return 0
+
+    @staticmethod
+    def _is_model_like(annotation: Any) -> bool:
+        if not isinstance(annotation, type):
+            return False
+        try:
+            return issubclass(annotation, BaseModel) or is_dataclass(annotation)
+        except TypeError:
+            return False
+
+    def _call_strategy_provider(self, strategy: Strategy) -> Any:
+        if strategy.provider_ref is None:
+            return None
+
+        func = strategy.provider_ref.func
+        kwargs = {
+            "summary": strategy.summary,
+            "faker": self.faker,
+            "random_generator": self.random,
+        }
+        kwargs.update(strategy.provider_kwargs)
+
+        sig = inspect.signature(func)
+        applicable = {name: value for name, value in kwargs.items() if name in sig.parameters}
+        try:
+            return func(**applicable)
+        except Exception:
+            return None
+
+
+__all__ = ["InstanceGenerator", "GenerationConfig"]

pydantic_fixturegen/core/introspect.py

@@ -0,0 +1,141 @@
+"""High-level discovery orchestration combining AST and safe import approaches."""
+
+from __future__ import annotations
+
+import fnmatch
+from collections.abc import Iterable, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+from .ast_discover import AstModel
+from .ast_discover import discover_models as ast_discover
+from .safe_import import safe_import_models
+
+DiscoveryMethod = Literal["ast", "import", "hybrid"]
+
+
+@dataclass(slots=True)
+class IntrospectedModel:
+    module: str
+    name: str
+    qualname: str
+    locator: str
+    lineno: int | None
+    discovery: DiscoveryMethod
+    is_public: bool
+
+
+@dataclass(slots=True)
+class IntrospectionResult:
+    models: list[IntrospectedModel]
+    warnings: list[str]
+    errors: list[str]
+
+
+def discover(
+    paths: Iterable[Path | str],
+    *,
+    method: DiscoveryMethod = "hybrid",
+    include: Sequence[str] | None = None,
+    exclude: Sequence[str] | None = None,
+    public_only: bool = False,
+    safe_import_timeout: float = 5.0,
+    safe_import_memory_limit_mb: int = 256,
+) -> IntrospectionResult:
+    """Discover Pydantic models using AST, safe import, or both."""
+    include_patterns = tuple(include or [])
+    exclude_patterns = tuple(exclude or [])
+    normalized_paths = [Path(path) for path in paths]
+
+    models: dict[str, IntrospectedModel] = {}
+    warnings: list[str] = []
+    errors: list[str] = []
+
+    if method in {"ast", "hybrid"}:
+        ast_result = ast_discover(
+            normalized_paths,
+            infer_module=True,
+            public_only=public_only,
+        )
+        warnings.extend(ast_result.warnings)
+
+        for ast_model in ast_result.models:
+            entry = _to_introspection_model_from_ast(ast_model)
+            if _should_include(entry, include_patterns, exclude_patterns):
+                models.setdefault(entry.qualname, entry)
+
+        if method == "ast":
+            return IntrospectionResult(
+                models=sorted(models.values(), key=lambda m: m.qualname),
+                warnings=warnings,
+                errors=errors,
+            )
+
+    if method in {"import", "hybrid"}:
+        safe_result = safe_import_models(
+            normalized_paths,
+            timeout=safe_import_timeout,
+            memory_limit_mb=safe_import_memory_limit_mb,
+        )
+        if not safe_result.success and safe_result.error:
+            errors.append(safe_result.error)
+        if safe_result.stderr:
+            warnings.append(safe_result.stderr.strip())
+
+        for import_model in safe_result.models:
+            entry = _to_introspection_model_from_import(import_model)
+            if public_only and entry.name.startswith("_"):
+                continue
+            if _should_include(entry, include_patterns, exclude_patterns):
+                models[entry.qualname] = entry
+
+    return IntrospectionResult(
+        models=sorted(models.values(), key=lambda m: m.qualname),
+        warnings=warnings,
+        errors=errors,
+    )
+
+
+def _should_include(
+    model: IntrospectedModel,
+    include_patterns: Sequence[str],
+    exclude_patterns: Sequence[str],
+) -> bool:
+    identifier = model.qualname
+    if include_patterns and not any(
+        fnmatch.fnmatchcase(identifier, pattern) for pattern in include_patterns
+    ):
+        return False
+    return not (
+        exclude_patterns
+        and any(fnmatch.fnmatchcase(identifier, pattern) for pattern in exclude_patterns)
+    )
+
+
+def _to_introspection_model_from_ast(model: AstModel) -> IntrospectedModel:
+    return IntrospectedModel(
+        module=model.module,
+        name=model.name,
+        qualname=model.qualname,
+        locator=str(model.path),
+        lineno=model.lineno,
+        discovery="ast",
+        is_public=model.is_public,
+    )
+
+
+def _to_introspection_model_from_import(model: dict[str, object]) -> IntrospectedModel:
+    module = str(model.get("module"))
+    name = str(model.get("name"))
+    qualname = str(model.get("qualname") or f"{module}.{name}")
+    locator = str(model.get("path") or module)
+    return IntrospectedModel(
+        module=module,
+        name=name,
+        qualname=qualname,
+        locator=locator,
+        lineno=None,
+        discovery="import",
+        is_public=not name.startswith("_"),
+    )

pydantic_fixturegen/core/io_utils.py

@@ -0,0 +1,77 @@
+"""Filesystem utilities for atomic, hash-aware writes."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+
+__all__ = ["WriteResult", "write_atomic_text", "write_atomic_bytes"]
+
+
+@dataclass(slots=True)
+class WriteResult:
+    """Metadata describing the outcome of an atomic write."""
+
+    path: Path
+    wrote: bool
+    skipped: bool
+    reason: str | None = None
+
+
+def write_atomic_text(
+    path: str | Path,
+    content: str,
+    *,
+    encoding: str = "utf-8",
+    hash_compare: bool = False,
+) -> WriteResult:
+    """Atomically write text content to ``path``."""
+
+    data = content.encode(encoding)
+    return _write_atomic(Path(path), data, hash_compare=hash_compare)
+
+
+def write_atomic_bytes(
+    path: str | Path,
+    data: bytes,
+    *,
+    hash_compare: bool = False,
+) -> WriteResult:
+    """Atomically write binary content to ``path``."""
+
+    return _write_atomic(Path(path), data, hash_compare=hash_compare)
+
+
+def _write_atomic(path: Path, data: bytes, *, hash_compare: bool) -> WriteResult:
+    path = path.expanduser()
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    digest = _hash_bytes(data) if hash_compare else None
+    if hash_compare and path.exists():
+        existing = path.read_bytes()
+        if _hash_bytes(existing) == digest:
+            return WriteResult(path=path, wrote=False, skipped=True, reason="unchanged")
+
+    with tempfile.NamedTemporaryFile(
+        delete=False,
+        dir=path.parent,
+        prefix=f".{path.name}.",
+        suffix=".tmp",
+    ) as temp_file:
+        temp_path = Path(temp_file.name)
+
+    try:
+        temp_path.write_bytes(data)
+        os.replace(temp_path, path)
+    except Exception as exc:
+        temp_path.unlink(missing_ok=True)
+        raise exc
+
+    return WriteResult(path=path, wrote=True, skipped=False, reason=None)
+
+
+def _hash_bytes(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()

pydantic_fixturegen/core/providers/__init__.py

@@ -0,0 +1,32 @@
+"""Provider registry and built-in providers."""
+
+from .collections import register_collection_providers
+from .identifiers import register_identifier_providers
+from .numbers import register_numeric_providers
+from .registry import ProviderRef, ProviderRegistry
+from .strings import register_string_providers
+from .temporal import register_temporal_providers
+
+
+def create_default_registry(load_plugins: bool = True) -> ProviderRegistry:
+    registry = ProviderRegistry()
+    register_numeric_providers(registry)
+    register_string_providers(registry)
+    register_collection_providers(registry)
+    register_temporal_providers(registry)
+    register_identifier_providers(registry)
+    if load_plugins:
+        registry.load_entrypoint_plugins()
+    return registry
+
+
+__all__ = [
+    "ProviderRef",
+    "ProviderRegistry",
+    "create_default_registry",
+    "register_string_providers",
+    "register_numeric_providers",
+    "register_collection_providers",
+    "register_temporal_providers",
+    "register_identifier_providers",
+]

pydantic_fixturegen/core/providers/collections.py

@@ -0,0 +1,74 @@
+"""Collection providers for lists, sets, tuples, and mappings."""
+
+from __future__ import annotations
+
+import random
+from typing import Any
+
+from faker import Faker
+
+from pydantic_fixturegen.core.providers.registry import ProviderRegistry
+from pydantic_fixturegen.core.schema import FieldConstraints, FieldSummary
+
+DEFAULT_COLLECTION_SIZE = 3
+
+
+def generate_collection(
+    summary: FieldSummary,
+    *,
+    faker: Faker | None = None,
+    random_generator: random.Random | None = None,
+) -> Any:
+    rng = random_generator or random.Random()
+    faker = faker or Faker()
+
+    length = _collection_length(summary.constraints, rng)
+    item_values = [_basic_value(summary.item_type, faker, rng) for _ in range(length)]
+
+    if summary.type == "list":
+        return item_values
+    if summary.type == "set":
+        return set(item_values)
+    if summary.type == "tuple":
+        return tuple(item_values)
+    if summary.type == "mapping":
+        return {faker.pystr(min_chars=3, max_chars=6): value for value in item_values}
+
+    raise ValueError(f"Unsupported collection type: {summary.type}")
+
+
+def register_collection_providers(registry: ProviderRegistry) -> None:
+    for collection_type in ("list", "set", "tuple", "mapping"):
+        registry.register(
+            collection_type,
+            generate_collection,
+            name=f"collection.{collection_type}",
+            metadata={"type": collection_type},
+        )
+
+
+def _collection_length(constraints: FieldConstraints, rng: random.Random) -> int:
+    minimum = constraints.min_length or 1
+    maximum = constraints.max_length or max(minimum, DEFAULT_COLLECTION_SIZE)
+    if minimum > maximum:
+        minimum = maximum
+    return rng.randint(minimum, maximum)
+
+
+def _basic_value(item_type: str | None, faker: Faker, rng: random.Random) -> Any:
+    if item_type == "int":
+        return rng.randint(-10, 10)
+    if item_type == "float":
+        return rng.uniform(-10, 10)
+    if item_type == "bool":
+        return rng.choice([True, False])
+    if item_type == "string" or item_type is None:
+        return faker.pystr(min_chars=1, max_chars=8)
+    if item_type == "decimal":
+        return faker.pydecimal(left_digits=3, right_digits=2)
+    if item_type == "model":
+        return {}
+    return faker.pystr(min_chars=1, max_chars=8)
+
+
+__all__ = ["generate_collection", "register_collection_providers"]

pydantic_fixturegen/core/providers/identifiers.py

@@ -0,0 +1,68 @@
+"""Identifier providers for emails, URLs, UUIDs, IPs, secrets, and payment cards."""
+
+from __future__ import annotations
+
+import ipaddress
+import uuid
+from typing import Any
+
+from faker import Faker
+from pydantic import SecretBytes, SecretStr
+
+from pydantic_fixturegen.core.providers.registry import ProviderRegistry
+from pydantic_fixturegen.core.schema import FieldSummary
+
+
+def generate_identifier(
+    summary: FieldSummary,
+    *,
+    faker: Faker | None = None,
+) -> Any:
+    faker = faker or Faker()
+    type_name = summary.type
+
+    if type_name == "email":
+        return faker.unique.email()
+    if type_name == "url":
+        return faker.unique.url()
+    if type_name == "uuid":
+        return uuid.uuid4()
+    if type_name == "payment-card":
+        return faker.credit_card_number()
+    if type_name == "secret-str":
+        return SecretStr(faker.password())
+    if type_name == "secret-bytes":
+        return SecretBytes(faker.binary(length=16))
+    if type_name == "ip-address":
+        return faker.ipv4()
+    if type_name == "ip-interface":
+        address = faker.ipv4()
+        return str(ipaddress.ip_interface(f"{address}/24"))
+    if type_name == "ip-network":
+        address = faker.ipv4()
+        return str(ipaddress.ip_network(f"{address}/24", strict=False))
+
+    raise ValueError(f"Unsupported identifier type: {type_name}")
+
+
+def register_identifier_providers(registry: ProviderRegistry) -> None:
+    for identifier_type in (
+        "email",
+        "url",
+        "uuid",
+        "payment-card",
+        "secret-str",
+        "secret-bytes",
+        "ip-address",
+        "ip-interface",
+        "ip-network",
+    ):
+        registry.register(
+            identifier_type,
+            generate_identifier,
+            name=f"identifier.{identifier_type}",
+            metadata={"type": identifier_type},
+        )
+
+
+__all__ = ["generate_identifier", "register_identifier_providers"]