pydantic-fixturegen 1.0.0__py3-none-any.whl

pydantic_fixturegen/core/providers/numbers.py

@@ -0,0 +1,133 @@
+"""Numeric providers for ints, floats, decimals, and booleans."""
+
+from __future__ import annotations
+
+import decimal
+import random
+from typing import Any
+
+from pydantic_fixturegen.core.providers.registry import ProviderRegistry
+from pydantic_fixturegen.core.schema import FieldConstraints, FieldSummary
+
+INT_DEFAULT_MIN = -10
+INT_DEFAULT_MAX = 10
+FLOAT_DEFAULT_MIN = -10.0
+FLOAT_DEFAULT_MAX = 10.0
+DECIMAL_DEFAULT_PLACES = decimal.Decimal("0.01")
+
+
+def generate_numeric(
+    summary: FieldSummary,
+    *,
+    random_generator: random.Random | None = None,
+) -> Any:
+    rng = random_generator or random.Random()
+
+    if summary.type == "bool":
+        return rng.choice([True, False])
+
+    if summary.type == "int":
+        return _generate_int(summary.constraints, rng)
+
+    if summary.type == "float":
+        return _generate_float(summary.constraints, rng)
+
+    if summary.type == "decimal":
+        return _generate_decimal(summary.constraints, rng)
+
+    raise ValueError(f"Unsupported numeric type: {summary.type}")
+
+
+def register_numeric_providers(registry: ProviderRegistry) -> None:
+    registry.register(
+        "int",
+        generate_numeric,
+        name="number.int",
+        metadata={"type": "int"},
+    )
+    registry.register(
+        "float",
+        generate_numeric,
+        name="number.float",
+        metadata={"type": "float"},
+    )
+    registry.register(
+        "decimal",
+        generate_numeric,
+        name="number.decimal",
+        metadata={"type": "decimal"},
+    )
+    registry.register(
+        "bool",
+        generate_numeric,
+        name="number.bool",
+        metadata={"type": "bool"},
+    )
+
+
+def _generate_int(constraints: FieldConstraints, rng: random.Random) -> int:
+    minimum = INT_DEFAULT_MIN
+    maximum = INT_DEFAULT_MAX
+
+    if constraints.ge is not None:
+        minimum = int(constraints.ge)
+    if constraints.gt is not None:
+        minimum = int(constraints.gt) + 1
+    if constraints.le is not None:
+        maximum = int(constraints.le)
+    if constraints.lt is not None:
+        maximum = int(constraints.lt) - 1
+
+    if minimum > maximum:
+        minimum = maximum
+
+    return rng.randint(minimum, maximum)
+
+
+def _generate_float(constraints: FieldConstraints, rng: random.Random) -> float:
+    minimum = FLOAT_DEFAULT_MIN
+    maximum = FLOAT_DEFAULT_MAX
+
+    if constraints.ge is not None:
+        minimum = float(constraints.ge)
+    if constraints.gt is not None:
+        minimum = float(constraints.gt) + 1e-6
+    if constraints.le is not None:
+        maximum = float(constraints.le)
+    if constraints.lt is not None:
+        maximum = float(constraints.lt) - 1e-6
+
+    if minimum > maximum:
+        minimum = maximum
+
+    return rng.uniform(minimum, maximum)
+
+
+def _generate_decimal(constraints: FieldConstraints, rng: random.Random) -> decimal.Decimal:
+    minimum = decimal.Decimal(FLOAT_DEFAULT_MIN)
+    maximum = decimal.Decimal(FLOAT_DEFAULT_MAX)
+
+    if constraints.ge is not None:
+        minimum = decimal.Decimal(str(constraints.ge))
+    if constraints.gt is not None:
+        minimum = decimal.Decimal(str(constraints.gt)) + decimal.Decimal("0.0001")
+    if constraints.le is not None:
+        maximum = decimal.Decimal(str(constraints.le))
+    if constraints.lt is not None:
+        maximum = decimal.Decimal(str(constraints.lt)) - decimal.Decimal("0.0001")
+
+    if minimum > maximum:
+        minimum = maximum
+
+    raw = decimal.Decimal(str(rng.uniform(float(minimum), float(maximum))))
+    quantizer = _quantizer(constraints)
+    return raw.quantize(quantizer, rounding=decimal.ROUND_HALF_UP)
+
+
+def _quantizer(constraints: FieldConstraints) -> decimal.Decimal:
+    if constraints.decimal_places is not None:
+        return decimal.Decimal("1").scaleb(-constraints.decimal_places)
+    return DECIMAL_DEFAULT_PLACES
+
+
+__all__ = ["generate_numeric", "register_numeric_providers"]

pydantic_fixturegen/core/providers/registry.py

@@ -0,0 +1,98 @@
+"""Provider registry for mapping types to value generators."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable, Mapping
+from dataclasses import dataclass, field
+from typing import Any
+
+from pydantic_fixturegen.plugins.loader import (
+    get_plugin_manager,
+    load_entrypoint_plugins,
+    register_plugin,
+)
+
+ProviderFunc = Callable[..., Any]
+
+
+@dataclass(slots=True)
+class ProviderRef:
+    """Descriptor for a registered provider."""
+
+    type_id: str
+    format: str | None
+    name: str
+    func: ProviderFunc
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+
+
+class ProviderRegistry:
+    """Registry of provider functions addressable by type identifier and format."""
+
+    def __init__(self) -> None:
+        self._providers: dict[tuple[str, str | None], ProviderRef] = {}
+        self._plugin_manager = get_plugin_manager()
+
+    # ------------------------------------------------------------------ registration
+    def register(
+        self,
+        type_id: str,
+        provider: ProviderFunc,
+        *,
+        format: str | None = None,
+        name: str | None = None,
+        metadata: Mapping[str, Any] | None = None,
+        override: bool = False,
+    ) -> ProviderRef:
+        key = (type_id, format)
+        if not override and key in self._providers:
+            raise ValueError(f"Provider already registered for {type_id!r} with format {format!r}.")
+        ref = ProviderRef(
+            type_id=type_id,
+            format=format,
+            name=name or provider.__name__,
+            func=provider,
+            metadata=metadata or {},
+        )
+        self._providers[key] = ref
+        return ref
+
+    def unregister(self, type_id: str, format: str | None = None) -> None:
+        self._providers.pop((type_id, format), None)
+
+    # ------------------------------------------------------------------ lookup
+    def get(self, type_id: str, format: str | None = None) -> ProviderRef | None:
+        key = (type_id, format)
+        if key in self._providers:
+            return self._providers[key]
+        fallback_key = (type_id, None)
+        return self._providers.get(fallback_key)
+
+    def available(self) -> Iterable[ProviderRef]:
+        return self._providers.values()
+
+    def clear(self) -> None:
+        self._providers.clear()
+
+    # ------------------------------------------------------------------ plugins
+    def register_plugin(self, plugin: Any) -> None:
+        """Register a plugin object and invoke its provider hook."""
+
+        register_plugin(plugin)
+        self._plugin_manager.hook.pfg_register_providers(registry=self)
+
+    def load_entrypoint_plugins(
+        self,
+        group: str = "pydantic_fixturegen",
+        *,
+        force: bool = False,
+    ) -> None:
+        """Load plugins defined via Python entry points and invoke hooks."""
+
+        plugins = load_entrypoint_plugins(group, force=force)
+        if not plugins:
+            return
+        self._plugin_manager.hook.pfg_register_providers(registry=self)
+
+
+__all__ = ["ProviderRegistry", "ProviderRef", "ProviderFunc"]

pydantic_fixturegen/core/providers/strings.py

@@ -0,0 +1,109 @@
+"""String-related providers for pydantic-fixturegen."""
+
+from __future__ import annotations
+
+import os
+import random
+from types import ModuleType
+
+try:  # Optional dependency for regex generation
+    import rstr as _rstr
+except ImportError:  # pragma: no cover - optional extra not installed
+    rstr: ModuleType | None = None
+else:
+    rstr = _rstr
+
+from faker import Faker
+
+from pydantic_fixturegen.core.providers import ProviderRegistry
+from pydantic_fixturegen.core.schema import FieldSummary
+
+DEFAULT_MIN_CHARS = 1
+DEFAULT_MAX_CHARS = 16
+
+
+def generate_string(
+    summary: FieldSummary,
+    *,
+    faker: Faker | None = None,
+    random_generator: random.Random | None = None,
+) -> str | bytes:
+    """Generate a string that satisfies the provided constraints."""
+
+    if summary.type not in {"string", "secret-str", "secret-bytes"}:
+        raise ValueError(f"Unsupported string type: {summary.type}")
+
+    faker = faker or Faker()
+    rng = random_generator or random.Random()
+
+    if summary.type == "secret-str":
+        return _random_string(rng, summary, faker=faker)
+    if summary.type == "secret-bytes":
+        length = _determine_length(summary)
+        return os.urandom(length)
+
+    if summary.constraints.pattern:
+        return _regex_string(summary, faker=faker)
+    return _random_string(rng, summary, faker=faker)
+
+
+def register_string_providers(registry: ProviderRegistry) -> None:
+    registry.register(
+        "string",
+        generate_string,
+        name="string.default",
+        metadata={"description": "Faker-backed string provider"},
+    )
+
+
+def _regex_string(summary: FieldSummary, *, faker: Faker) -> str:
+    pattern = summary.constraints.pattern or ".*"
+    candidate: str
+    candidate = (
+        rstr.xeger(pattern)
+        if rstr is not None
+        else _fallback_regex(pattern, faker)  # pragma: no cover - fallback path without regex extra
+    )
+    return _apply_length(candidate, summary, faker=faker)
+
+
+def _fallback_regex(pattern: str, faker: Faker) -> str:
+    stripped = pattern.strip("^$")
+    if not stripped:
+        return faker.pystr(min_chars=DEFAULT_MIN_CHARS, max_chars=DEFAULT_MAX_CHARS)
+    # crude fallback: ensure prefix matches stripped text ignoring regex tokens
+    prefix = "".join(ch for ch in stripped if ch.isalnum())
+    remainder = faker.pystr(min_chars=0, max_chars=max(DEFAULT_MIN_CHARS, len(prefix)))
+    return prefix + remainder
+
+
+def _random_string(rng: random.Random, summary: FieldSummary, *, faker: Faker) -> str:
+    min_chars, max_chars = _length_bounds(summary)
+    # Faker's pystr respects min/max characters
+    return faker.pystr(min_chars=min_chars, max_chars=max_chars)
+
+
+def _apply_length(value: str, summary: FieldSummary, *, faker: Faker) -> str:
+    min_chars, max_chars = _length_bounds(summary)
+    if len(value) < min_chars:
+        padding = faker.pystr(min_chars=min_chars - len(value), max_chars=min_chars - len(value))
+        value = value + padding
+    if len(value) > max_chars:
+        value = value[:max_chars]
+    return value
+
+
+def _length_bounds(summary: FieldSummary) -> tuple[int, int]:
+    min_chars = summary.constraints.min_length or DEFAULT_MIN_CHARS
+    max_chars = summary.constraints.max_length or max(min_chars, DEFAULT_MAX_CHARS)
+    if min_chars > max_chars:
+        min_chars = max_chars
+    return min_chars, max_chars
+
+
+def _determine_length(summary: FieldSummary) -> int:
+    min_chars, max_chars = _length_bounds(summary)
+    return max(min_chars, min(max_chars, DEFAULT_MAX_CHARS))
+
+
+__all__ = ["generate_string", "register_string_providers"]

pydantic_fixturegen/core/providers/temporal.py

@@ -0,0 +1,42 @@
+"""Temporal providers for datetime, date, and time types."""
+
+from __future__ import annotations
+
+import datetime
+from typing import Any
+
+from faker import Faker
+
+from pydantic_fixturegen.core.providers.registry import ProviderRegistry
+from pydantic_fixturegen.core.schema import FieldSummary
+
+
+def generate_temporal(
+    summary: FieldSummary,
+    *,
+    faker: Faker | None = None,
+) -> Any:
+    faker = faker or Faker()
+    type_name = summary.type
+
+    if type_name == "datetime":
+        return faker.date_time(tzinfo=datetime.timezone.utc)
+    if type_name == "date":
+        return faker.date_object()
+    if type_name == "time":
+        return faker.time_object()
+
+    raise ValueError(f"Unsupported temporal type: {type_name}")
+
+
+def register_temporal_providers(registry: ProviderRegistry) -> None:
+    for temporal_type in ("datetime", "date", "time"):
+        registry.register(
+            temporal_type,
+            generate_temporal,
+            name=f"temporal.{temporal_type}",
+            metadata={"type": temporal_type},
+        )
+
+
+__all__ = ["generate_temporal", "register_temporal_providers"]