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

pydantic_fixturegen/cli/gen/schema.py

@@ -3,24 +3,18 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Any
 
 import typer
 
-from pydantic_fixturegen.core.config import ConfigError, load_config
+from pydantic_fixturegen.api._runtime import generate_schema_artifacts
+from pydantic_fixturegen.api.models import SchemaGenerationResult
+from pydantic_fixturegen.core.config import ConfigError
 from pydantic_fixturegen.core.errors import DiscoveryError, EmitError, PFGError
-from pydantic_fixturegen.emitters.schema_out import emit_model_schema, emit_models_schema
-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, render_cli_error
 
 TARGET_ARGUMENT = typer.Argument(
     ...,
@@ -55,6 +49,19 @@ 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.",
+)
+
 
 def register(app: typer.Typer) -> None:
     @app.command("schema")
@@ -65,100 +72,178 @@ def register(app: typer.Typer) -> None:
         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,
     ) -> None:
+        logger = get_logger()
+
         try:
-            _execute_schema_command(
-                target=target,
-                out=out,
-                indent=indent,
-                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_schema_command(
+                    target=target,
+                    output_template=output_template,
+                    indent=indent,
+                    include=include,
+                    exclude=exclude,
+                )
+            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_schema_command(
     *,
     target: str,
-    out: Path,
+    output_template: OutputTemplate,
     indent: int | None,
     include: str | None,
     exclude: 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 indent is not None:
-        cli_overrides.setdefault("json", {})["indent"] = indent
-    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,
-    )
+    logger = get_logger()
 
-    if discovery.errors:
-        raise DiscoveryError("; ".join(discovery.errors))
+    include_patterns = [include] if include else None
+    exclude_patterns = [exclude] if exclude else None
 
-    for warning in discovery.warnings:
-        if warning.strip():
-            typer.secho(warning.strip(), err=True, fg=typer.colors.YELLOW)
+    try:
+        result = generate_schema_artifacts(
+            target=target,
+            output_template=output_template,
+            indent=indent,
+            include=include_patterns,
+            exclude=exclude_patterns,
+            logger=logger,
+        )
+    except PFGError as exc:
+        _handle_schema_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_schema_snapshot(logger, result):
+        return
 
-    if not discovery.models:
-        raise DiscoveryError("No models discovered.")
+    typer.echo(str(result.path))
 
-    try:
-        model_classes = [load_model_class(model) for model in discovery.models]
-    except RuntimeError as exc:
-        raise DiscoveryError(str(exc)) from exc
 
-    indent_value = indent if indent is not None else app_config.json.indent
+def _log_schema_snapshot(logger: Logger, result: SchemaGenerationResult) -> bool:
+    config_snapshot = result.config
+    anchor_iso = config_snapshot.time_anchor.isoformat() if config_snapshot.time_anchor else None
 
-    context = EmitterContext(
-        models=tuple(model_classes),
-        output=out,
-        parameters={"indent": indent_value},
+    logger.debug(
+        "Loaded configuration",
+        event="config_loaded",
+        include=list(config_snapshot.include),
+        exclude=list(config_snapshot.exclude),
+        time_anchor=anchor_iso,
     )
-    if emit_artifact("schema", context):
-        return
 
-    try:
-        if len(model_classes) == 1:
-            emitted_path = emit_model_schema(
-                model_classes[0],
-                output_path=out,
-                indent=indent_value,
-                ensure_ascii=False,
-            )
-        else:
-            emitted_path = emit_models_schema(
-                model_classes,
-                output_path=out,
-                indent=indent_value,
-                ensure_ascii=False,
+    if anchor_iso:
+        logger.info(
+            "Using temporal anchor",
+            event="temporal_anchor_set",
+            time_anchor=anchor_iso,
+        )
+
+    for warning in result.warnings:
+        logger.warn(
+            warning,
+            event="discovery_warning",
+            warning=warning,
+        )
+
+    if result.delegated:
+        logger.info(
+            "Schema generation handled by plugin",
+            event="schema_generation_delegated",
+            output=str(result.base_output),
+            time_anchor=anchor_iso,
+        )
+        return True
+
+    logger.info(
+        "Schema generation complete",
+        event="schema_generation_complete",
+        output=str(result.path),
+        models=[model.__name__ for model in result.models],
+        time_anchor=anchor_iso,
+    )
+    return False
+
+
+def _handle_schema_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",
+            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,
             )
-    except Exception as exc:
-        raise EmitError(str(exc)) from exc
 
-    typer.echo(str(emitted_path))
+    warnings = details.get("warnings") or []
+    for warning in warnings:
+        if isinstance(warning, str):
+            logger.warn(
+                warning,
+                event="discovery_warning",
+                warning=warning,
+            )
 
 
 __all__ = ["register"]

pydantic_fixturegen/cli/init.py

@@ -0,0 +1,333 @@
+"""CLI command for scaffolding configuration and directories."""
+
+from __future__ import annotations
+
+import textwrap
+from collections.abc import Iterable
+from dataclasses import dataclass
+from pathlib import Path
+
+import typer
+
+from pydantic_fixturegen.core.config import DEFAULT_CONFIG, ENUM_POLICIES, UNION_POLICIES
+from pydantic_fixturegen.core.io_utils import WriteResult, write_atomic_text
+from pydantic_fixturegen.core.seed import DEFAULT_LOCALE
+from pydantic_fixturegen.core.version import get_tool_version
+
+app = typer.Typer(help="Scaffold configuration and recommended directories.")
+
+DEFAULT_SEED = 42
+DEFAULT_UNION_POLICY = "weighted"
+DEFAULT_ENUM_POLICY = "random"
+DEFAULT_JSON_INDENT = 2
+DEFAULT_JSON_ORJSON = False
+DEFAULT_PYTEST_STYLE = DEFAULT_CONFIG.emitters.pytest.style
+DEFAULT_PYTEST_SCOPE = "module"
+DEFAULT_FIXTURE_DIR = Path("tests/fixtures")
+PYTEST_STYLES = {"functions", "factory", "class"}
+PYTEST_SCOPES = {"function", "module", "session"}
+
+
+DIRECTORY_ARGUMENT = typer.Argument(
+    Path("."),
+    exists=False,
+    file_okay=False,
+    dir_okay=True,
+    resolve_path=True,
+    help="Project root to scaffold.",
+)
+PYPROJECT_OPTION = typer.Option(
+    True,
+    "--pyproject/--no-pyproject",
+    help="Write or update pyproject.toml with recommended configuration.",
+)
+YAML_OPTION = typer.Option(
+    False,
+    "--yaml/--no-yaml",
+    help="Also emit pydantic-fixturegen.yaml alongside pyproject.toml.",
+)
+YAML_PATH_OPTION = typer.Option(
+    None,
+    help="Custom path for YAML configuration (defaults to ./pydantic-fixturegen.yaml).",
+)
+FORCE_OPTION = typer.Option(False, "--force", help="Overwrite existing configuration blocks.")
+SEED_OPTION = typer.Option(
+    DEFAULT_SEED,
+    help="Seed to set in generated configuration (use -1 to remove).",
+)
+LOCALE_OPTION = typer.Option(DEFAULT_LOCALE, help="Default Faker locale to configure.")
+UNION_OPTION = typer.Option(
+    DEFAULT_UNION_POLICY,
+    help="Union resolution policy to configure.",
+)
+ENUM_OPTION = typer.Option(
+    DEFAULT_ENUM_POLICY,
+    help="Enum sampling policy to configure.",
+)
+JSON_INDENT_OPTION = typer.Option(
+    DEFAULT_JSON_INDENT,
+    min=0,
+    help="Default JSON indentation for emitters.",
+)
+JSON_ORJSON_OPTION = typer.Option(
+    DEFAULT_JSON_ORJSON,
+    "--json-orjson/--no-json-orjson",
+    help="Enable or disable orjson for JSON emitter.",
+)
+PYTEST_STYLE_OPTION = typer.Option(
+    DEFAULT_PYTEST_STYLE,
+    help="Default pytest fixture style.",
+)
+PYTEST_SCOPE_OPTION = typer.Option(
+    DEFAULT_PYTEST_SCOPE,
+    help="Default pytest fixture scope.",
+)
+FIXTURES_DIR_OPTION = typer.Option(
+    str(DEFAULT_FIXTURE_DIR),
+    help="Directory to create for generated pytest fixtures.",
+)
+GITKEEP_OPTION = typer.Option(
+    True,
+    "--gitkeep/--no-gitkeep",
+    help="Create an empty .gitkeep in the fixtures directory.",
+)
+
+
+@dataclass(slots=True)
+class InitConfig:
+    seed: int | None
+    locale: str
+    union_policy: str
+    enum_policy: str
+    json_indent: int
+    json_orjson: bool
+    pytest_style: str
+    pytest_scope: str
+
+    def as_pyproject_snippet(self) -> str:
+        header = f"# Generated by pydantic-fixturegen {get_tool_version()} via `pfg init`"
+        lines: list[str] = [header, "", "[tool.pydantic_fixturegen]"]
+
+        if self.seed is not None:
+            lines.append(f"seed = {self.seed}")
+        lines.append(f'locale = "{self.locale}"')
+        lines.append(f'union_policy = "{self.union_policy}"')
+        lines.append(f'enum_policy = "{self.enum_policy}"')
+
+        lines.extend(
+            [
+                "",
+                "[tool.pydantic_fixturegen.json]",
+                f"indent = {self.json_indent}",
+                f"orjson = {'true' if self.json_orjson else 'false'}",
+            ]
+        )
+
+        lines.extend(
+            [
+                "",
+                "[tool.pydantic_fixturegen.emitters.pytest]",
+                f'style = "{self.pytest_style}"',
+                f'scope = "{self.pytest_scope}"',
+            ]
+        )
+
+        return "\n".join(lines).rstrip() + "\n"
+
+    def as_yaml(self) -> str:
+        content = textwrap.dedent(
+            f"""
+            seed: {self.seed if self.seed is not None else "null"}
+            locale: {self.locale}
+            union_policy: {self.union_policy}
+            enum_policy: {self.enum_policy}
+            json:
+              indent: {self.json_indent}
+              orjson: {"true" if self.json_orjson else "false"}
+            emitters:
+              pytest:
+                style: {self.pytest_style}
+                scope: {self.pytest_scope}
+            """
+        ).strip()
+        return content + "\n"
+
+
+def _strip_pyproject_section(content: str) -> str:
+    lines = content.splitlines()
+    kept: list[str] = []
+    skip = False
+
+    for line in lines:
+        stripped = line.strip()
+        if stripped.startswith("[") and stripped.endswith("]"):
+            header = stripped.strip("[]").strip()
+            skip = header.startswith("tool.pydantic_fixturegen")
+            if skip:
+                continue
+        if not skip:
+            kept.append(line)
+
+    cleaned = "\n".join(kept)
+    while "\n\n\n" in cleaned:
+        cleaned = cleaned.replace("\n\n\n", "\n\n")
+    return cleaned.rstrip()
+
+
+def _validate_choice(value: str, allowed: Iterable[str], name: str) -> str:
+    normalized = value.lower()
+    if normalized not in {item.lower() for item in allowed}:
+        choices = ", ".join(sorted(allowed))
+        raise typer.BadParameter(f"{name} must be one of: {choices}.")
+    return normalized
+
+
+def _ensure_directory(path: Path) -> bool:
+    if path.exists() and not path.is_dir():
+        raise typer.BadParameter(f"Cannot create directory: {path} already exists as a file.")
+    if path.exists():
+        return False
+    path.mkdir(parents=True, exist_ok=True)
+    return True
+
+
+def _format_relative(path: Path, root: Path) -> str:
+    try:
+        relative = path.relative_to(root)
+    except ValueError:
+        return str(path)
+    return relative.as_posix()
+
+
+def _write_pyproject(root: Path, config: InitConfig, *, force: bool) -> WriteResult | None:
+    path = root / "pyproject.toml"
+    snippet = config.as_pyproject_snippet()
+
+    if path.exists():
+        if not path.is_file():
+            raise typer.BadParameter("pyproject.toml exists but is not a file.")
+        existing = path.read_text(encoding="utf-8")
+        if "tool.pydantic_fixturegen" in existing and not force:
+            return WriteResult(
+                path=path,
+                wrote=False,
+                skipped=True,
+                reason="pyproject already contains configuration",
+            )
+        if force:
+            existing = _strip_pyproject_section(existing)
+        merged = existing.rstrip()
+        new_content = f"{merged}\n\n{snippet}" if merged else snippet
+    else:
+        new_content = snippet
+
+    return write_atomic_text(path, new_content, hash_compare=True)
+
+
+def _write_yaml(target_path: Path, config: InitConfig, *, force: bool) -> WriteResult | None:
+    if target_path.exists():
+        if not target_path.is_file():
+            raise typer.BadParameter(f"{target_path} exists but is not a file.")
+        if not force:
+            return WriteResult(
+                path=target_path,
+                wrote=False,
+                skipped=True,
+                reason="YAML configuration already exists",
+            )
+
+    content = config.as_yaml()
+    return write_atomic_text(target_path, content, hash_compare=True)
+
+
+@app.command()
+def init(  # noqa: PLR0913 - CLI surfaces configuration knobs
+    directory: Path = DIRECTORY_ARGUMENT,
+    pyproject: bool = PYPROJECT_OPTION,
+    yaml_config: bool = YAML_OPTION,
+    yaml_path: Path | None = YAML_PATH_OPTION,
+    force: bool = FORCE_OPTION,
+    seed: int | None = SEED_OPTION,
+    locale: str = LOCALE_OPTION,
+    union_policy: str = UNION_OPTION,
+    enum_policy: str = ENUM_OPTION,
+    json_indent: int = JSON_INDENT_OPTION,
+    json_orjson: bool = JSON_ORJSON_OPTION,
+    pytest_style: str = PYTEST_STYLE_OPTION,
+    pytest_scope: str = PYTEST_SCOPE_OPTION,
+    fixtures_dir: str = FIXTURES_DIR_OPTION,
+    gitkeep: bool = GITKEEP_OPTION,
+) -> None:
+    """Create baseline configuration files and fixture directories."""
+
+    if not pyproject and not yaml_config:
+        typer.secho("Nothing to scaffold: enable --pyproject and/or --yaml.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    normalized_union = _validate_choice(union_policy, UNION_POLICIES, "union_policy")
+    normalized_enum = _validate_choice(enum_policy, ENUM_POLICIES, "enum_policy")
+    normalized_style = _validate_choice(pytest_style, PYTEST_STYLES, "pytest_style")
+    normalized_scope = _validate_choice(pytest_scope, PYTEST_SCOPES, "pytest_scope")
+
+    seed_value: int | None = None if seed is not None and seed < 0 else seed
+
+    config = InitConfig(
+        seed=seed_value,
+        locale=locale,
+        union_policy=normalized_union,
+        enum_policy=normalized_enum,
+        json_indent=json_indent,
+        json_orjson=json_orjson,
+        pytest_style=normalized_style,
+        pytest_scope=normalized_scope,
+    )
+
+    actions: list[str] = []
+
+    if pyproject:
+        result = _write_pyproject(directory, config, force=force)
+        if result:
+            if result.wrote:
+                actions.append(f"Updated {_format_relative(result.path, directory)}")
+            elif result.skipped:
+                actions.append(
+                    f"Skipped {_format_relative(result.path, directory)} ({result.reason})"
+                )
+
+    if yaml_config:
+        if yaml_path and not yaml_path.is_absolute():
+            yaml_target = directory / yaml_path
+        elif yaml_path:
+            yaml_target = yaml_path
+        else:
+            yaml_target = directory / "pydantic-fixturegen.yaml"
+
+        result = _write_yaml(yaml_target, config, force=force)
+        if result:
+            if result.wrote:
+                actions.append(f"Updated {_format_relative(result.path, directory)}")
+            elif result.skipped:
+                actions.append(
+                    f"Skipped {_format_relative(result.path, directory)} ({result.reason})"
+                )
+
+    fixtures_path = Path(fixtures_dir)
+    fixtures_directory = fixtures_path if fixtures_path.is_absolute() else directory / fixtures_path
+    created = _ensure_directory(fixtures_directory)
+    if created:
+        actions.append(f"Created directory {_format_relative(fixtures_directory, directory)}")
+
+    if gitkeep:
+        gitkeep_path = fixtures_directory / ".gitkeep"
+        result = write_atomic_text(gitkeep_path, "", hash_compare=True)
+        if result.wrote:
+            actions.append(f"Created {_format_relative(gitkeep_path, directory)}")
+        else:
+            actions.append(f"Ensured {_format_relative(gitkeep_path, directory)}")
+
+    if not actions:
+        typer.secho("No changes were necessary.", fg=typer.colors.YELLOW)
+    else:
+        typer.secho("Scaffolding complete:", fg=typer.colors.GREEN)
+        for action in actions:
+            typer.echo(f"  - {action}")

pydantic_fixturegen/cli/schema.py

@@ -0,0 +1,45 @@
+"""Schema utilities exposed via the CLI."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from pydantic_fixturegen.core.config_schema import get_config_schema_json
+
+OUT_OPTION = typer.Option(None, "--out", "-o", help="File path to write the schema.")
+PRETTY_OPTION = typer.Option(
+    True,
+    "--pretty/--compact",
+    help="Pretty-print output with indentation.",
+)
+
+
+app = typer.Typer(help="Inspect and export JSON Schemas.")
+
+
+@app.callback()
+def schema_root() -> None:  # noqa: D401 - CLI callback
+    """Schema command group."""
+
+
+@app.command("config")
+def schema_config(  # noqa: D401 - CLI command
+    out: Path | None = OUT_OPTION,
+    pretty: bool = PRETTY_OPTION,
+) -> None:
+    """Emit the JSON Schema that describes project configuration."""
+
+    indent = 2 if pretty else None
+    payload = get_config_schema_json(indent=indent)
+
+    if out is not None:
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_text(payload, encoding="utf-8")
+        typer.echo(f"Wrote {out}")
+    else:
+        typer.echo(payload.rstrip())
+
+
+__all__ = ["app"]