pydantic-fixturegen 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

pydantic_fixturegen/cli/watch.py

@@ -0,0 +1,126 @@
+"""Helpers for implementing watch mode across CLI commands."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable, Iterator
+from pathlib import Path
+from typing import cast
+
+from pydantic_fixturegen.core.errors import WatchError
+from pydantic_fixturegen.logging import get_logger
+
+_CONFIG_FILENAMES = (
+    Path("pyproject.toml"),
+    Path("pydantic-fixturegen.yaml"),
+    Path("pydantic-fixturegen.yml"),
+)
+
+
+def gather_default_watch_paths(
+    target: Path,
+    *,
+    output: Path | None = None,
+    extra: Iterable[Path] | None = None,
+) -> list[Path]:
+    """Collect filesystem locations to monitor for change events."""
+
+    paths: set[Path] = set()
+    target = target.resolve()
+    paths.add(target)
+    paths.add(target.parent)
+
+    cwd = Path.cwd()
+    for candidate in _CONFIG_FILENAMES:
+        path = (cwd / candidate).resolve()
+        if path.exists():
+            paths.add(path)
+
+    if output is not None:
+        out_path = output.resolve()
+        if out_path.exists():
+            paths.add(out_path)
+        parent = out_path.parent
+        parent.mkdir(parents=True, exist_ok=True)
+        paths.add(parent)
+
+    if extra:
+        for candidate in extra:
+            resolved = candidate.resolve()
+            if resolved.exists():
+                paths.add(resolved)
+            parent = resolved.parent
+            if parent.exists():
+                paths.add(parent)
+
+    normalized = _normalize_watch_paths(paths)
+    if not normalized:
+        raise WatchError("No valid paths available for watch mode.")
+    return normalized
+
+
+WatchIterator = Iterator[set[tuple[int, Path]]]
+WatchBackend = Callable[..., WatchIterator]
+
+
+def run_with_watch(
+    run_once: Callable[[], None],
+    watch_paths: Iterable[Path],
+    *,
+    debounce: float,
+) -> None:
+    """Execute ``run_once`` immediately and re-run when filesystem changes occur."""
+
+    watch_fn: WatchBackend = _import_watch_backend()
+    normalized = _normalize_watch_paths(watch_paths)
+    if not normalized:
+        raise WatchError("No valid paths available for watch mode.")
+
+    run_once()
+    logger = get_logger()
+    logger.info(
+        "Watch mode active. Press Ctrl+C to stop.",
+        event="watch_started",
+        paths=[str(path) for path in normalized],
+        debounce=debounce,
+    )
+
+    try:
+        for changes in watch_fn(*normalized, debounce=debounce):
+            changed_paths = sorted({str(path) for _, path in changes})
+            logger.info(
+                "Detected changes",
+                event="watch_change_detected",
+                paths=changed_paths,
+            )
+            run_once()
+    except KeyboardInterrupt:
+        logger.warn("Watch mode stopped.", event="watch_stopped")
+
+
+def _normalize_watch_paths(paths: Iterable[Path]) -> list[Path]:
+    normalized: list[Path] = []
+    seen: set[Path] = set()
+
+    for path in paths:
+        candidate = path.resolve()
+        monitor = candidate if candidate.exists() else candidate.parent
+        if not monitor.exists():
+            continue
+        if monitor not in seen:
+            normalized.append(monitor)
+            seen.add(monitor)
+    return normalized
+
+
+def _import_watch_backend() -> WatchBackend:
+    try:
+        from watchfiles import watch as watch_fn
+    except ModuleNotFoundError as exc:  # pragma: no cover - depends on optional extra
+        raise WatchError(
+            "Watch mode requires the optional 'watchfiles' dependency. Install it via"
+            " `pip install pydantic-fixturegen[watch]`."
+        ) from exc
+    return cast(WatchBackend, watch_fn)
+
+
+__all__ = ["gather_default_watch_paths", "run_with_watch"]

pydantic_fixturegen/core/config.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import datetime
 import os
 from collections.abc import Mapping, MutableMapping, Sequence
 from dataclasses import dataclass, field, replace
@@ -9,6 +10,8 @@ from importlib import import_module
 from pathlib import Path
 from typing import Any, TypeVar, cast
 
+from .field_policies import FieldPolicy
+from .presets import get_preset_spec, normalize_preset_name
 from .seed import DEFAULT_LOCALE
 
 
@@ -62,6 +65,7 @@ class EmittersConfig:
 
 @dataclass(frozen=True)
 class AppConfig:
+    preset: str | None = None
     seed: int | str | None = None
     locale: str = DEFAULT_LOCALE
     include: tuple[str, ...] = ()
@@ -69,7 +73,9 @@ class AppConfig:
     p_none: float | None = None
     union_policy: str = "first"
     enum_policy: str = "first"
+    now: datetime.datetime | None = None
     overrides: Mapping[str, Mapping[str, Any]] = field(default_factory=dict)
+    field_policies: tuple[FieldPolicy, ...] = ()
     emitters: EmittersConfig = field(default_factory=EmittersConfig)
     json: JsonConfig = field(default_factory=JsonConfig)
 
@@ -96,19 +102,20 @@ def load_config(
     _deep_merge(data, _config_defaults_dict())
 
     file_config = _load_file_config(pyproject, yaml_file)
-    _deep_merge(data, file_config)
+    _merge_source_with_preset(data, file_config)
 
     env_config = _load_env_config(env or os.environ)
-    _deep_merge(data, env_config)
+    _merge_source_with_preset(data, env_config)
 
     if cli:
-        _deep_merge(data, cli)
+        _merge_source_with_preset(data, cli)
 
     return _build_app_config(data)
 
 
 def _config_defaults_dict() -> dict[str, Any]:
     return {
+        "preset": DEFAULT_CONFIG.preset,
         "seed": DEFAULT_CONFIG.seed,
         "locale": DEFAULT_CONFIG.locale,
         "include": list(DEFAULT_CONFIG.include),
@@ -116,6 +123,8 @@ def _config_defaults_dict() -> dict[str, Any]:
         "p_none": DEFAULT_CONFIG.p_none,
         "union_policy": DEFAULT_CONFIG.union_policy,
         "enum_policy": DEFAULT_CONFIG.enum_policy,
+        "now": DEFAULT_CONFIG.now,
+        "field_policies": {},
         "overrides": {},
         "emitters": {
             "pytest": {
@@ -233,6 +242,8 @@ def _coerce_env_value(value: str) -> Any:
 
 
 def _build_app_config(data: Mapping[str, Any]) -> AppConfig:
+    preset_value = _coerce_preset_value(data.get("preset"))
+
     seed = data.get("seed")
     locale = _coerce_str(data.get("locale"), "locale")
     include = _normalize_sequence(data.get("include"))
@@ -257,6 +268,8 @@ def _build_app_config(data: Mapping[str, Any]) -> AppConfig:
 
     emitters_value = _normalize_emitters(data.get("emitters"))
     json_value = _normalize_json(data.get("json"))
+    field_policies_value = _normalize_field_policies(data.get("field_policies"))
+    now_value = _coerce_datetime(data.get("now"), "now")
 
     seed_value: int | str | None
     if isinstance(seed, (int, str)) or seed is None:
@@ -265,6 +278,7 @@ def _build_app_config(data: Mapping[str, Any]) -> AppConfig:
         raise ConfigError("seed must be an int, str, or null.")
 
     config = AppConfig(
+        preset=preset_value,
         seed=seed_value,
         locale=locale,
         include=include,
@@ -272,7 +286,9 @@ def _build_app_config(data: Mapping[str, Any]) -> AppConfig:
         p_none=p_none_value,
         union_policy=union_policy,
         enum_policy=enum_policy,
+        now=now_value,
         overrides=overrides_value,
+        field_policies=field_policies_value,
         emitters=emitters_value,
         json=json_value,
     )
@@ -315,6 +331,30 @@ def _coerce_policy(value: Any, allowed: set[str], field_name: str) -> str:
     return value
 
 
+def _coerce_datetime(value: Any, field_name: str) -> datetime.datetime | None:
+    if value is None:
+        return None
+    if isinstance(value, datetime.datetime):
+        if value.tzinfo is None:
+            return value.replace(tzinfo=datetime.timezone.utc)
+        return value
+    if isinstance(value, datetime.date):
+        return datetime.datetime.combine(value, datetime.time(), tzinfo=datetime.timezone.utc)
+    if isinstance(value, str):
+        text = value.strip()
+        if not text or text.lower() == "none":
+            return None
+        normalized = text.replace("Z", "+00:00")
+        try:
+            parsed = datetime.datetime.fromisoformat(normalized)
+        except ValueError as exc:
+            raise ConfigError(f"{field_name} must be an ISO 8601 datetime string.") from exc
+        if parsed.tzinfo is None:
+            parsed = parsed.replace(tzinfo=datetime.timezone.utc)
+        return parsed
+    raise ConfigError(f"{field_name} must be an ISO 8601 datetime string or datetime object.")
+
+
 def _normalize_overrides(value: Any) -> Mapping[str, Mapping[str, Any]]:
     if value is None:
         return {}
@@ -335,6 +375,59 @@ def _normalize_overrides(value: Any) -> Mapping[str, Mapping[str, Any]]:
     return overrides
 
 
+def _normalize_field_policies(value: Any) -> tuple[FieldPolicy, ...]:
+    if value is None:
+        return ()
+    if not isinstance(value, Mapping):
+        raise ConfigError("field_policies must be a mapping of pattern to policy settings.")
+
+    policies: list[FieldPolicy] = []
+    for index, (pattern, raw_options) in enumerate(value.items()):
+        if not isinstance(pattern, str) or not pattern.strip():
+            raise ConfigError("field policy keys must be non-empty strings.")
+        if not isinstance(raw_options, Mapping):
+            raise ConfigError(f"Field policy '{pattern}' must be a mapping of options.")
+
+        p_none = raw_options.get("p_none")
+        if p_none is not None:
+            try:
+                p_none = float(p_none)
+            except (TypeError, ValueError) as exc:
+                raise ConfigError(
+                    f"Field policy '{pattern}' p_none must be a float value."
+                ) from exc
+            if not (0.0 <= p_none <= 1.0):
+                raise ConfigError(f"Field policy '{pattern}' p_none must be between 0.0 and 1.0.")
+
+        enum_policy = raw_options.get("enum_policy")
+        if enum_policy is not None and (
+            not isinstance(enum_policy, str) or enum_policy not in ENUM_POLICIES
+        ):
+            raise ConfigError(
+                f"Field policy '{pattern}' enum_policy must be one of {sorted(ENUM_POLICIES)}."
+            )
+
+        union_policy = raw_options.get("union_policy")
+        if union_policy is not None and (
+            not isinstance(union_policy, str) or union_policy not in UNION_POLICIES
+        ):
+            raise ConfigError(
+                f"Field policy '{pattern}' union_policy must be one of {sorted(UNION_POLICIES)}."
+            )
+
+        allowed_keys = {"p_none", "enum_policy", "union_policy"}
+        for option_key in raw_options:
+            if option_key not in allowed_keys:
+                raise ConfigError(
+                    f"Field policy '{pattern}' contains unsupported option '{option_key}'."
+                )
+
+        options = {"p_none": p_none, "enum_policy": enum_policy, "union_policy": union_policy}
+        policies.append(FieldPolicy(pattern=pattern, options=options, index=index))
+
+    return tuple(policies)
+
+
 def _normalize_emitters(value: Any) -> EmittersConfig:
     pytest_config = PytestEmitterConfig()
 
@@ -409,6 +502,22 @@ def _coerce_optional_str(value: Any, field_name: str) -> str:
     return value
 
 
+def _coerce_preset_value(value: Any) -> str | None:
+    if value is None:
+        return None
+    if not isinstance(value, str):
+        raise ConfigError("preset must be a string when specified.")
+    stripped = value.strip()
+    if not stripped:
+        return None
+    normalized = normalize_preset_name(stripped)
+    try:
+        spec = get_preset_spec(normalized)
+    except KeyError as exc:
+        raise ConfigError(f"Unknown preset '{value}'.") from exc
+    return spec.name
+
+
 def _ensure_mutable(mapping: Mapping[str, Any]) -> dict[str, Any]:
     mutable: dict[str, Any] = {}
     for key, value in mapping.items():
@@ -438,3 +547,28 @@ def _deep_merge(target: MutableMapping[str, Any], source: Mapping[str, Any]) ->
                 target[key] = list(value)
             else:
                 target[key] = value
+
+
+def _merge_source_with_preset(data: MutableMapping[str, Any], source: Mapping[str, Any]) -> None:
+    if not source:
+        return
+
+    mutable = _ensure_mutable(source)
+
+    if "preset" in mutable:
+        preset_raw = mutable.pop("preset")
+        if preset_raw is None:
+            data["preset"] = None
+        else:
+            if not isinstance(preset_raw, str):
+                raise ConfigError("preset must be a string when specified.")
+            preset_name = normalize_preset_name(preset_raw)
+            try:
+                preset_spec = get_preset_spec(preset_name)
+            except KeyError as exc:
+                raise ConfigError(f"Unknown preset '{preset_raw}'.") from exc
+
+            _deep_merge(data, _ensure_mutable(preset_spec.settings))
+            data["preset"] = preset_spec.name
+
+    _deep_merge(data, mutable)

pydantic_fixturegen/core/config_schema.py

@@ -0,0 +1,178 @@
+"""JSON Schema generation for pydantic-fixturegen configuration."""
+
+from __future__ import annotations
+
+from typing import Any, Literal, cast
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from .config import DEFAULT_CONFIG
+from .seed import DEFAULT_LOCALE
+
+SCHEMA_ID = "https://raw.githubusercontent.com/CasperKristiansson/pydantic-fixturegen/main/pydantic_fixturegen/schemas/config.schema.json"
+SCHEMA_DRAFT = "https://json-schema.org/draft/2020-12/schema"
+
+
+UnionPolicyLiteral = Literal["first", "random", "weighted"]
+EnumPolicyLiteral = Literal["first", "random"]
+
+DEFAULT_PYTEST_STYLE = cast(
+    Literal["functions", "factory", "class"],
+    DEFAULT_CONFIG.emitters.pytest.style,
+)
+DEFAULT_PYTEST_SCOPE = cast(
+    Literal["function", "module", "session"],
+    DEFAULT_CONFIG.emitters.pytest.scope,
+)
+DEFAULT_UNION_POLICY = cast(UnionPolicyLiteral, DEFAULT_CONFIG.union_policy)
+DEFAULT_ENUM_POLICY = cast(EnumPolicyLiteral, DEFAULT_CONFIG.enum_policy)
+
+
+class PytestEmitterSchema(BaseModel):
+    """Schema for pytest emitter settings."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    style: Literal["functions", "factory", "class"] = Field(
+        default=DEFAULT_PYTEST_STYLE,
+        description="How emitted pytest fixtures are structured.",
+    )
+    scope: Literal["function", "module", "session"] = Field(
+        default=DEFAULT_PYTEST_SCOPE,
+        description="Default pytest fixture scope.",
+    )
+
+
+class EmittersSchema(BaseModel):
+    """Schema for emitter configuration sections."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    pytest: PytestEmitterSchema = Field(
+        default_factory=PytestEmitterSchema,
+        description="Configuration for the built-in pytest fixture emitter.",
+    )
+
+
+class JsonSchema(BaseModel):
+    """Schema for JSON emitter settings."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    indent: int = Field(
+        default=DEFAULT_CONFIG.json.indent,
+        ge=0,
+        description="Indentation level for JSON output (0 for compact).",
+    )
+    orjson: bool = Field(
+        default=DEFAULT_CONFIG.json.orjson,
+        description="Use orjson for serialization when available.",
+    )
+
+
+class FieldPolicyOptionsSchema(BaseModel):
+    """Schema describing supported field policy overrides."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    p_none: float | None = Field(
+        default=None,
+        ge=0.0,
+        le=1.0,
+        description="Probability override for returning None on optional fields.",
+    )
+    enum_policy: EnumPolicyLiteral | None = Field(
+        default=None,
+        description="Enum selection policy for matching fields.",
+    )
+    union_policy: Literal["first", "random"] | None = Field(
+        default=None,
+        description="Union selection policy for matching fields.",
+    )
+
+
+class ConfigSchemaModel(BaseModel):
+    """Authoritative schema for `[tool.pydantic_fixturegen]` configuration."""
+
+    model_config = ConfigDict(
+        extra="allow",
+        populate_by_name=True,
+        title="pydantic-fixturegen configuration",
+    )
+
+    preset: str | None = Field(
+        default=DEFAULT_CONFIG.preset,
+        description="Curated preset name applied before other configuration (e.g., 'boundary').",
+    )
+    seed: int | str | None = Field(
+        default=DEFAULT_CONFIG.seed,
+        description="Global seed controlling deterministic generation. Accepts int or string.",
+    )
+    locale: str = Field(
+        default=DEFAULT_LOCALE,
+        description="Default Faker locale used when generating data.",
+    )
+    include: list[str] = Field(
+        default_factory=list,
+        description="Glob patterns of fully-qualified model names to include by default.",
+    )
+    exclude: list[str] = Field(
+        default_factory=list,
+        description="Glob patterns of fully-qualified model names to exclude by default.",
+    )
+    p_none: float | None = Field(
+        default=DEFAULT_CONFIG.p_none,
+        ge=0.0,
+        le=1.0,
+        description="Probability of sampling `None` for optional fields when unspecified.",
+    )
+    union_policy: UnionPolicyLiteral = Field(
+        default=DEFAULT_UNION_POLICY,
+        description="Strategy for selecting branches of `typing.Union`.",
+    )
+    enum_policy: EnumPolicyLiteral = Field(
+        default=DEFAULT_ENUM_POLICY,
+        description="Strategy for selecting enum members.",
+    )
+    overrides: dict[str, dict[str, Any]] = Field(
+        default_factory=dict,
+        description="Per-model overrides keyed by fully-qualified model name.",
+    )
+    emitters: EmittersSchema = Field(
+        default_factory=EmittersSchema,
+        description="Emitter-specific configuration sections.",
+    )
+    json_settings: JsonSchema = Field(
+        default_factory=JsonSchema,
+        alias="json",
+        description="Settings shared by JSON-based emitters.",
+    )
+    field_policies: dict[str, FieldPolicyOptionsSchema] = Field(
+        default_factory=dict,
+        description=(
+            "Field policy definitions keyed by glob or regex patterns that may target model "
+            "names or dotted field paths."
+        ),
+    )
+
+
+def build_config_schema() -> dict[str, Any]:
+    """Return the JSON schema describing the project configuration."""
+
+    schema = ConfigSchemaModel.model_json_schema(by_alias=True)
+    schema["$schema"] = SCHEMA_DRAFT
+    schema["$id"] = SCHEMA_ID
+    schema.setdefault("description", "Configuration options for pydantic-fixturegen")
+    return schema
+
+
+def get_config_schema_json(*, indent: int | None = 2) -> str:
+    """Return the configuration schema serialized to JSON."""
+
+    import json
+
+    schema = build_config_schema()
+    return json.dumps(schema, indent=indent, sort_keys=True) + ("\n" if indent else "")
+
+
+__all__ = ["build_config_schema", "get_config_schema_json", "SCHEMA_ID", "SCHEMA_DRAFT"]