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

pydantic_fixturegen/cli/gen/json.py

@@ -3,27 +3,18 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Any
 
 import typer
-from pydantic import BaseModel
-
-from pydantic_fixturegen.core.config import AppConfig, ConfigError, load_config
-from pydantic_fixturegen.core.errors import DiscoveryError, EmitError, MappingError, PFGError
-from pydantic_fixturegen.core.generate import GenerationConfig, InstanceGenerator
-from pydantic_fixturegen.core.seed import SeedManager
-from pydantic_fixturegen.emitters.json_out import emit_json_samples
-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.api._runtime import generate_json_artifacts
+from pydantic_fixturegen.api.models import JsonGenerationResult
+from pydantic_fixturegen.core.config import ConfigError
+from pydantic_fixturegen.core.errors import DiscoveryError, EmitError, PFGError
+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
 
 TARGET_ARGUMENT = typer.Argument(
     ...,
@@ -91,6 +82,37 @@ SEED_OPTION = typer.Option(
     help="Seed override for deterministic generation.",
 )
 
+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 ensure deterministic regeneration.",
+)
+
+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("json")
@@ -105,33 +127,87 @@ def register(app: typer.Typer) -> None:
         include: str | None = INCLUDE_OPTION,
         exclude: str | None = EXCLUDE_OPTION,
         seed: int | None = SEED_OPTION,
+        now: str | None = NOW_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_json_command(
-                target=target,
-                out=out,
-                count=count,
-                jsonl=jsonl,
-                indent=indent,
-                use_orjson=use_orjson,
-                shard_size=shard_size,
-                include=include,
-                exclude=exclude,
-                seed=seed,
-            )
+            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_json_command(
+                    target=target,
+                    output_template=output_template,
+                    count=count,
+                    jsonl=jsonl,
+                    indent=indent,
+                    use_orjson=use_orjson,
+                    shard_size=shard_size,
+                    include=include,
+                    exclude=exclude,
+                    seed=seed,
+                    freeze_seeds=freeze_seeds,
+                    freeze_seeds_file=freeze_seeds_file,
+                    preset=preset,
+                    now=now,
+                )
+            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_json_command(
     *,
     target: str,
-    out: Path,
+    output_template: OutputTemplate,
     count: int,
     jsonl: bool,
     indent: int | None,
@@ -140,123 +216,138 @@ def _execute_json_command(
     include: str | None,
     exclude: str | None,
     seed: int | None,
+    now: 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})
-
-    clear_module_cache()
-    load_entrypoint_plugins()
-
-    cli_overrides: dict[str, Any] = {}
-    if seed is not None:
-        cli_overrides["seed"] = seed
-    json_overrides: dict[str, Any] = {}
-    if indent is not None:
-        json_overrides["indent"] = indent
-    if use_orjson is not None:
-        json_overrides["orjson"] = use_orjson
-    if json_overrides:
-        cli_overrides["json"] = json_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,
-    )
-
-    if discovery.errors:
-        raise DiscoveryError("; ".join(discovery.errors))
-
-    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.")
+    logger = get_logger()
 
-    if len(discovery.models) > 1:
-        names = ", ".join(model.qualname for model in discovery.models)
-        raise DiscoveryError(
-            f"Multiple models discovered ({names}). Use --include/--exclude to narrow selection.",
-            details={"models": names},
-        )
-
-    target_model = discovery.models[0]
-
-    try:
-        model_cls = load_model_class(target_model)
-    except RuntimeError as exc:
-        raise DiscoveryError(str(exc)) from exc
-
-    generator = _build_instance_generator(app_config)
-
-    def sample_factory() -> BaseModel:
-        instance = generator.generate_one(model_cls)
-        if instance is None:
-            raise MappingError(
-                f"Failed to generate instance for {target_model.qualname}.",
-                details={"model": target_model.qualname},
-            )
-        return instance
-
-    indent_value = indent if indent is not None else app_config.json.indent
-    use_orjson_value = use_orjson if use_orjson is not None else app_config.json.orjson
-
-    context = EmitterContext(
-        models=(model_cls,),
-        output=out,
-        parameters={
-            "count": count,
-            "jsonl": jsonl,
-            "indent": indent_value,
-            "shard_size": shard_size,
-            "use_orjson": use_orjson_value,
-        },
-    )
-    if emit_artifact("json", context):
-        return
+    include_patterns = [include] if include else None
+    exclude_patterns = [exclude] if exclude else None
 
     try:
-        paths = emit_json_samples(
-            sample_factory,
-            output_path=out,
+        result = generate_json_artifacts(
+            target=target,
+            output_template=output_template,
             count=count,
             jsonl=jsonl,
-            indent=indent_value,
+            indent=indent,
+            use_orjson=use_orjson,
             shard_size=shard_size,
-            use_orjson=use_orjson_value,
-            ensure_ascii=False,
+            include=include_patterns,
+            exclude=exclude_patterns,
+            seed=seed,
+            now=now,
+            freeze_seeds=freeze_seeds,
+            freeze_seeds_file=freeze_seeds_file,
+            preset=preset,
+            logger=logger,
         )
-    except RuntimeError as exc:
+    except PFGError as exc:
+        _handle_generation_error(logger, exc)
+        raise
+    except Exception as exc:  # pragma: no cover - defensive
+        if isinstance(exc, ConfigError):
+            raise
         raise EmitError(str(exc)) from exc
 
-    for emitted_path in paths:
+    if _log_generation_snapshot(logger, result, count):
+        return
+
+    emit_constraint_summary(
+        result.constraint_summary,
+        logger=logger,
+        json_mode=logger.config.json,
+    )
+
+    for emitted_path in result.paths:
         typer.echo(str(emitted_path))
 
 
-def _build_instance_generator(app_config: AppConfig) -> InstanceGenerator:
-    seed_value: int | None = None
-    if app_config.seed is not None:
-        seed_value = SeedManager(seed=app_config.seed).normalized_seed
+def _log_generation_snapshot(logger: Logger, result: JsonGenerationResult, count: int) -> bool:
+    config_snapshot = result.config
+    anchor_iso = config_snapshot.time_anchor.isoformat() if config_snapshot.time_anchor else 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,
+    )
+
+    if anchor_iso:
+        logger.info(
+            "Using temporal anchor",
+            event="temporal_anchor_set",
+            time_anchor=anchor_iso,
+        )
 
-    p_none = app_config.p_none if app_config.p_none is not None else 0.0
-    gen_config = GenerationConfig(
-        seed=seed_value,
-        enum_policy=app_config.enum_policy,
-        union_policy=app_config.union_policy,
-        default_p_none=p_none,
-        optional_p_none=p_none,
+    for warning in result.warnings:
+        logger.warn(
+            warning,
+            event="discovery_warning",
+            warning=warning,
+        )
+
+    if result.delegated:
+        logger.info(
+            "JSON generation handled by plugin",
+            event="json_generation_delegated",
+            output=str(result.base_output),
+            time_anchor=anchor_iso,
+        )
+        return True
+
+    logger.info(
+        "JSON generation complete",
+        event="json_generation_complete",
+        files=[str(path) for path in result.paths],
+        count=count,
+        time_anchor=anchor_iso,
     )
-    return InstanceGenerator(config=gen_config)
+    return False
+
+
+def _handle_generation_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,
+        )
 
 
 __all__ = ["register"]