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

pydantic_fixturegen/cli/gen/fixtures.py

@@ -3,25 +3,19 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Any, Literal, cast
+from typing import Literal, cast
 
 import typer
 
-from pydantic_fixturegen.core.config import ConfigError, load_config
+from pydantic_fixturegen.api._runtime import generate_fixtures_artifacts
+from pydantic_fixturegen.api.models import FixturesGenerationResult
+from pydantic_fixturegen.core.config import ConfigError
 from pydantic_fixturegen.core.errors import DiscoveryError, EmitError, PFGError
-from pydantic_fixturegen.core.seed import SeedManager
-from pydantic_fixturegen.emitters.pytest_codegen import PytestEmitConfig, emit_pytest_fixtures
-from pydantic_fixturegen.plugins.hookspecs import EmitterContext
-from pydantic_fixturegen.plugins.loader import emit_artifact, load_entrypoint_plugins
-
-from ._common import (
-    JSON_ERRORS_OPTION,
-    clear_module_cache,
-    discover_models,
-    load_model_class,
-    render_cli_error,
-    split_patterns,
-)
+from pydantic_fixturegen.core.path_template import OutputTemplate
+
+from ...logging import Logger, get_logger
+from ..watch import gather_default_watch_paths, run_with_watch
+from ._common import JSON_ERRORS_OPTION, NOW_OPTION, emit_constraint_summary, render_cli_error
 
 STYLE_CHOICES = {"functions", "factory", "class"}
 SCOPE_CHOICES = {"function", "module", "session"}
@@ -96,6 +90,37 @@ EXCLUDE_OPTION = typer.Option(
     help="Comma-separated pattern(s) of fully-qualified model names to exclude.",
 )
 
+WATCH_OPTION = typer.Option(
+    False,
+    "--watch",
+    help="Watch source files and regenerate when changes are detected.",
+)
+
+WATCH_DEBOUNCE_OPTION = typer.Option(
+    0.5,
+    "--watch-debounce",
+    min=0.1,
+    help="Debounce interval in seconds for filesystem events.",
+)
+
+FREEZE_SEEDS_OPTION = typer.Option(
+    False,
+    "--freeze-seeds/--no-freeze-seeds",
+    help="Read/write per-model seeds using a freeze file to stabilize fixture output.",
+)
+
+FREEZE_FILE_OPTION = typer.Option(
+    None,
+    "--freeze-seeds-file",
+    help="Seed freeze file path (defaults to `.pfg-seeds.json` in the project root).",
+)
+
+PRESET_OPTION = typer.Option(
+    None,
+    "--preset",
+    help="Apply a curated generation preset (e.g. 'boundary', 'boundary-max').",
+)
+
 
 def register(app: typer.Typer) -> None:
     @app.command("fixtures")
@@ -107,146 +132,253 @@ def register(app: typer.Typer) -> None:
         cases: int = CASES_OPTION,
         return_type: str | None = RETURN_OPTION,
         seed: int | None = SEED_OPTION,
+        now: str | None = NOW_OPTION,
         p_none: float | None = P_NONE_OPTION,
         include: str | None = INCLUDE_OPTION,
         exclude: str | None = EXCLUDE_OPTION,
         json_errors: bool = JSON_ERRORS_OPTION,
+        watch: bool = WATCH_OPTION,
+        watch_debounce: float = WATCH_DEBOUNCE_OPTION,
+        freeze_seeds: bool = FREEZE_SEEDS_OPTION,
+        freeze_seeds_file: Path | None = FREEZE_FILE_OPTION,
+        preset: str | None = PRESET_OPTION,
     ) -> None:
+        logger = get_logger()
+
         try:
-            _execute_fixtures_command(
-                target=target,
-                out=out,
-                style=style,
-                scope=scope,
-                cases=cases,
-                return_type=return_type,
-                seed=seed,
-                p_none=p_none,
-                include=include,
-                exclude=exclude,
-            )
+            output_template = OutputTemplate(str(out))
         except PFGError as exc:
             render_cli_error(exc, json_errors=json_errors)
-        except ConfigError as exc:
-            render_cli_error(DiscoveryError(str(exc)), json_errors=json_errors)
-        except Exception as exc:  # pragma: no cover - defensive
-            render_cli_error(EmitError(str(exc)), json_errors=json_errors)
+            return
+
+        watch_output: Path | None = None
+        watch_extra: list[Path] | None = None
+        if output_template.has_dynamic_directories():
+            watch_extra = [output_template.watch_parent()]
+        else:
+            watch_output = output_template.preview_path()
+
+        def invoke(exit_app: bool) -> None:
+            try:
+                _execute_fixtures_command(
+                    target=target,
+                    output_template=output_template,
+                    style=style,
+                    scope=scope,
+                    cases=cases,
+                    return_type=return_type,
+                    seed=seed,
+                    now=now,
+                    p_none=p_none,
+                    include=include,
+                    exclude=exclude,
+                    freeze_seeds=freeze_seeds,
+                    freeze_seeds_file=freeze_seeds_file,
+                    preset=preset,
+                )
+            except PFGError as exc:
+                render_cli_error(exc, json_errors=json_errors, exit_app=exit_app)
+            except ConfigError as exc:
+                render_cli_error(
+                    DiscoveryError(str(exc)),
+                    json_errors=json_errors,
+                    exit_app=exit_app,
+                )
+            except Exception as exc:  # pragma: no cover - defensive
+                render_cli_error(
+                    EmitError(str(exc)),
+                    json_errors=json_errors,
+                    exit_app=exit_app,
+                )
+
+        if watch:
+            watch_paths = gather_default_watch_paths(
+                Path(target),
+                output=watch_output,
+                extra=watch_extra,
+            )
+            try:
+                logger.debug(
+                    "Entering watch loop",
+                    event="watch_loop_enter",
+                    target=str(target),
+                    output=str(watch_output or output_template.preview_path()),
+                    debounce=watch_debounce,
+                )
+                run_with_watch(lambda: invoke(exit_app=False), watch_paths, debounce=watch_debounce)
+            except PFGError as exc:
+                render_cli_error(exc, json_errors=json_errors)
+        else:
+            invoke(exit_app=True)
 
 
 def _execute_fixtures_command(
     *,
     target: str,
-    out: Path,
+    output_template: OutputTemplate,
     style: str | None,
     scope: str | None,
     cases: int,
     return_type: str | None,
     seed: int | None,
+    now: str | None,
     p_none: float | None,
     include: str | None,
     exclude: str | None,
+    freeze_seeds: bool,
+    freeze_seeds_file: Path | None,
+    preset: str | None,
 ) -> None:
-    path = Path(target)
-    if not path.exists():
-        raise DiscoveryError(f"Target path '{target}' does not exist.", details={"path": target})
-    if not path.is_file():
-        raise DiscoveryError("Target must be a Python module file.", details={"path": target})
+    logger = get_logger()
 
     style_value = _coerce_style(style)
     scope_value = _coerce_scope(scope)
     return_type_value = _coerce_return_type(return_type)
 
-    clear_module_cache()
-    load_entrypoint_plugins()
-
-    cli_overrides: dict[str, Any] = {}
-    if seed is not None:
-        cli_overrides["seed"] = seed
-    if p_none is not None:
-        cli_overrides["p_none"] = p_none
-    emitter_overrides: dict[str, Any] = {}
-    if style_value is not None:
-        emitter_overrides["style"] = style_value
-    if scope_value is not None:
-        emitter_overrides["scope"] = scope_value
-    if emitter_overrides:
-        cli_overrides["emitters"] = {"pytest": emitter_overrides}
-    if include:
-        cli_overrides["include"] = split_patterns(include)
-    if exclude:
-        cli_overrides["exclude"] = split_patterns(exclude)
-
-    app_config = load_config(root=Path.cwd(), cli=cli_overrides if cli_overrides else None)
-
-    discovery = discover_models(
-        path,
-        include=app_config.include,
-        exclude=app_config.exclude,
+    include_patterns = [include] if include else None
+    exclude_patterns = [exclude] if exclude else None
+
+    try:
+        result = generate_fixtures_artifacts(
+            target=target,
+            output_template=output_template,
+            style=style_value,
+            scope=scope_value,
+            cases=cases,
+            return_type=return_type_value,
+            seed=seed,
+            now=now,
+            p_none=p_none,
+            include=include_patterns,
+            exclude=exclude_patterns,
+            freeze_seeds=freeze_seeds,
+            freeze_seeds_file=freeze_seeds_file,
+            preset=preset,
+            logger=logger,
+        )
+    except PFGError as exc:
+        _handle_fixtures_error(logger, exc)
+        raise
+    except Exception as exc:  # pragma: no cover - defensive
+        if isinstance(exc, ConfigError):
+            raise
+        raise EmitError(str(exc)) from exc
+
+    if _log_fixtures_snapshot(logger, result):
+        return
+
+    emit_constraint_summary(
+        result.constraint_summary,
+        logger=logger,
+        json_mode=logger.config.json,
     )
 
-    if discovery.errors:
-        raise DiscoveryError("; ".join(discovery.errors))
+    output_path = result.path or result.base_output
+    message = str(output_path)
+    if result.skipped:
+        message += " (unchanged)"
+    typer.echo(message)
 
-    for warning in discovery.warnings:
-        if warning.strip():
-            typer.secho(warning.strip(), err=True, fg=typer.colors.YELLOW)
 
-    if not discovery.models:
-        raise DiscoveryError("No models discovered.")
+def _log_fixtures_snapshot(logger: Logger, result: FixturesGenerationResult) -> bool:
+    config_snapshot = result.config
+    anchor_iso = config_snapshot.time_anchor.isoformat() if config_snapshot.time_anchor else None
 
-    try:
-        model_classes = [load_model_class(model) for model in discovery.models]
-    except RuntimeError as exc:
-        raise DiscoveryError(str(exc)) from exc
-
-    seed_value: int | None = None
-    if app_config.seed is not None:
-        seed_value = SeedManager(seed=app_config.seed).normalized_seed
-
-    style_final = style_value or cast(StyleLiteral, app_config.emitters.pytest.style)
-    scope_final = scope_value or app_config.emitters.pytest.scope
-    return_type_final = return_type_value or DEFAULT_RETURN
-
-    pytest_config = PytestEmitConfig(
-        scope=scope_final,
-        style=style_final,
-        return_type=return_type_final,
-        cases=cases,
-        seed=seed_value,
-        optional_p_none=app_config.p_none,
+    logger.debug(
+        "Loaded configuration",
+        event="config_loaded",
+        seed=config_snapshot.seed,
+        include=list(config_snapshot.include),
+        exclude=list(config_snapshot.exclude),
+        time_anchor=anchor_iso,
     )
 
-    context = EmitterContext(
-        models=tuple(model_classes),
-        output=out,
-        parameters={
-            "style": style_final,
-            "scope": scope_final,
-            "cases": cases,
-            "return_type": return_type_final,
-        },
-    )
-    if emit_artifact("fixtures", context):
-        return
+    if anchor_iso:
+        logger.info(
+            "Using temporal anchor",
+            event="temporal_anchor_set",
+            time_anchor=anchor_iso,
+        )
 
-    try:
-        result = emit_pytest_fixtures(
-            model_classes,
-            output_path=out,
-            config=pytest_config,
+    for warning in result.warnings:
+        logger.warn(
+            warning,
+            event="discovery_warning",
+            warning=warning,
         )
-    except Exception as exc:
-        raise EmitError(str(exc)) from exc
 
-    message = str(out)
+    if result.delegated:
+        logger.info(
+            "Fixtures generation handled by plugin",
+            event="fixtures_generation_delegated",
+            output=str(result.base_output),
+            style=result.style,
+            scope=result.scope,
+            time_anchor=anchor_iso,
+        )
+        return True
+
     if result.skipped:
-        message += " (unchanged)"
-    typer.echo(message)
+        logger.info(
+            "Fixtures unchanged",
+            event="fixtures_generation_unchanged",
+            output=str(result.path),
+            time_anchor=anchor_iso,
+        )
+    else:
+        logger.info(
+            "Fixtures generation complete",
+            event="fixtures_generation_complete",
+            output=str(result.path),
+            style=result.style,
+            scope=result.scope,
+            time_anchor=anchor_iso,
+        )
+    return False
 
 
 __all__ = ["register"]
 
 
+def _handle_fixtures_error(logger: Logger, exc: PFGError) -> None:
+    details = getattr(exc, "details", {}) or {}
+    config_info = details.get("config")
+    anchor_iso = None
+    if isinstance(config_info, dict):
+        anchor_iso = config_info.get("time_anchor")
+        logger.debug(
+            "Loaded configuration",
+            event="config_loaded",
+            seed=config_info.get("seed"),
+            include=config_info.get("include", []),
+            exclude=config_info.get("exclude", []),
+            time_anchor=anchor_iso,
+        )
+        if anchor_iso:
+            logger.info(
+                "Using temporal anchor",
+                event="temporal_anchor_set",
+                time_anchor=anchor_iso,
+            )
+
+    warnings = details.get("warnings") or []
+    for warning in warnings:
+        if isinstance(warning, str):
+            logger.warn(
+                warning,
+                event="discovery_warning",
+                warning=warning,
+            )
+
+    constraint_summary = details.get("constraint_summary")
+    if constraint_summary:
+        emit_constraint_summary(
+            constraint_summary,
+            logger=logger,
+            json_mode=logger.config.json,
+        )
+
+
 def _coerce_style(value: str | None) -> StyleLiteral | None:
     if value is None:
         return None