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

pydantic_fixturegen/emitters/pytest_codegen.py

@@ -2,11 +2,12 @@
 
 from __future__ import annotations
 
+import datetime
 import json
 import re
 import shutil
 import subprocess
-from collections.abc import Iterable, Sequence
+from collections.abc import Iterable, Mapping, Sequence
 from dataclasses import dataclass
 from pathlib import Path
 from pprint import pformat
@@ -14,8 +15,11 @@ from typing import Any, Literal, cast
 
 from pydantic import BaseModel
 
+from pydantic_fixturegen.core.constraint_report import ConstraintReporter
+from pydantic_fixturegen.core.field_policies import FieldPolicy
 from pydantic_fixturegen.core.generate import GenerationConfig, InstanceGenerator
 from pydantic_fixturegen.core.io_utils import WriteResult, write_atomic_text
+from pydantic_fixturegen.core.path_template import OutputTemplate, OutputTemplateContext
 from pydantic_fixturegen.core.version import build_artifact_header
 
 DEFAULT_SCOPE = "function"
@@ -36,6 +40,9 @@ class PytestEmitConfig:
     optional_p_none: float | None = None
     model_digest: str | None = None
     hash_compare: bool = True
+    per_model_seeds: Mapping[str, int] | None = None
+    field_policies: tuple[FieldPolicy, ...] = ()
+    time_anchor: datetime.datetime | None = None
 
 
 def emit_pytest_fixtures(
@@ -43,6 +50,8 @@ def emit_pytest_fixtures(
     *,
     output_path: str | Path,
     config: PytestEmitConfig | None = None,
+    template: OutputTemplate | None = None,
+    template_context: OutputTemplateContext | None = None,
 ) -> WriteResult:
     """Generate pytest fixture code for ``models`` and write it atomically."""
 
@@ -59,21 +68,42 @@ def emit_pytest_fixtures(
     if cfg.return_type not in {"model", "dict"}:
         raise ValueError(f"Unsupported return_type: {cfg.return_type!r}")
 
-    generation_config = GenerationConfig(seed=cfg.seed)
-    if cfg.optional_p_none is not None:
-        generation_config.optional_p_none = cfg.optional_p_none
-    generator = InstanceGenerator(config=generation_config)
+    def _build_generator(seed_value: int | None) -> InstanceGenerator:
+        generation_config = GenerationConfig(
+            seed=seed_value,
+            time_anchor=cfg.time_anchor,
+            field_policies=cfg.field_policies,
+        )
+        if cfg.optional_p_none is not None:
+            generation_config.optional_p_none = cfg.optional_p_none
+        return InstanceGenerator(config=generation_config)
+
+    shared_generator: InstanceGenerator | None = None
 
     model_entries: list[_ModelEntry] = []
     fixture_names: dict[str, int] = {}
     helper_names: dict[str, int] = {}
 
+    per_model_seeds = cfg.per_model_seeds or {}
+    constraint_reporters: list[ConstraintReporter] = []
+
     for model in models:
+        model_id = f"{model.__module__}.{model.__qualname__}"
+        if per_model_seeds:
+            seed_value = per_model_seeds.get(model_id, cfg.seed)
+            generator = _build_generator(seed_value)
+        else:
+            if shared_generator is None:
+                shared_generator = _build_generator(cfg.seed)
+            generator = shared_generator
+
         instances = generator.generate(model, count=cfg.cases)
         if len(instances) < cfg.cases:
             raise RuntimeError(
                 f"Failed to generate {cfg.cases} instance(s) for {model.__qualname__}."
             )
+        if per_model_seeds:
+            constraint_reporters.append(generator.constraint_report)
         data = [_model_to_literal(instance) for instance in instances]
         base_name = model.__name__
         if cfg.style in {"factory", "class"}:
@@ -96,11 +126,32 @@ def emit_pytest_fixtures(
         entries=model_entries,
         config=cfg,
     )
+    template_obj = template or OutputTemplate(output_path)
+    context = template_context or OutputTemplateContext()
+    resolved_path = template_obj.render(
+        context=context,
+        case_index=1 if template_obj.uses_case_index() else None,
+    )
     result = write_atomic_text(
-        output_path,
+        resolved_path,
         rendered,
         hash_compare=cfg.hash_compare,
     )
+    aggregate_report = ConstraintReporter()
+    if shared_generator is not None and not per_model_seeds:
+        aggregate_report.merge_from(shared_generator.constraint_report)
+    else:
+        for reporter in constraint_reporters:
+            aggregate_report.merge_from(reporter)
+
+    if cfg.time_anchor is not None:
+        result.metadata = result.metadata or {}
+        result.metadata["time_anchor"] = cfg.time_anchor.isoformat()
+
+    summary = aggregate_report.summary()
+    if summary.get("models"):
+        result.metadata = result.metadata or {}
+        result.metadata["constraints"] = summary
     return result
 
 
@@ -118,16 +169,20 @@ def _render_module(*, entries: Iterable[_ModelEntry], config: PytestEmitConfig)
     models_metadata = ", ".join(
         f"{entry.model.__module__}.{entry.model.__name__}" for entry in entries_list
     )
+    header_extras = {
+        "style": config.style,
+        "scope": config.scope,
+        "return": config.return_type,
+        "cases": config.cases,
+        "models": models_metadata,
+    }
+    if config.time_anchor is not None:
+        header_extras["time_anchor"] = config.time_anchor.isoformat()
+
     header = build_artifact_header(
         seed=config.seed,
         model_digest=config.model_digest,
-        extras={
-            "style": config.style,
-            "scope": config.scope,
-            "return": config.return_type,
-            "cases": config.cases,
-            "models": models_metadata,
-        },
+        extras=header_extras,
     )
 
     needs_any = config.return_type == "dict" or config.style in {"factory", "class"}

pydantic_fixturegen/emitters/schema_out.py

@@ -10,6 +10,8 @@ from typing import Any
 
 from pydantic import BaseModel
 
+from pydantic_fixturegen.core.path_template import OutputTemplate, OutputTemplateContext
+
 
 @dataclass(slots=True)
 class SchemaEmitConfig:
@@ -24,11 +26,20 @@ def emit_model_schema(
     output_path: str | Path,
     indent: int | None = 2,
     ensure_ascii: bool = False,
+    template: OutputTemplate | None = None,
+    template_context: OutputTemplateContext | None = None,
 ) -> Path:
     """Write the model JSON schema to ``output_path``."""
 
+    template_obj = template or OutputTemplate(output_path)
+    context = template_context or OutputTemplateContext()
+    resolved_path = template_obj.render(
+        context=context,
+        case_index=1 if template_obj.uses_case_index() else None,
+    )
+
     config = SchemaEmitConfig(
-        output_path=Path(output_path),
+        output_path=resolved_path,
         indent=_normalise_indent(indent),
         ensure_ascii=ensure_ascii,
     )
@@ -40,6 +51,8 @@ def emit_model_schema(
         sort_keys=True,
     )
     config.output_path.parent.mkdir(parents=True, exist_ok=True)
+    if payload and not payload.endswith("\n"):
+        payload += "\n"
     config.output_path.write_text(payload, encoding="utf-8")
     return config.output_path
 
@@ -50,16 +63,25 @@ def emit_models_schema(
     output_path: str | Path,
     indent: int | None = 2,
     ensure_ascii: bool = False,
+    template: OutputTemplate | None = None,
+    template_context: OutputTemplateContext | None = None,
 ) -> Path:
     """Emit a combined schema referencing each model by its qualified name."""
 
+    template_obj = template or OutputTemplate(output_path)
+    context = template_context or OutputTemplateContext()
+    resolved_path = template_obj.render(
+        context=context,
+        case_index=1 if template_obj.uses_case_index() else None,
+    )
+
     config = SchemaEmitConfig(
-        output_path=Path(output_path),
+        output_path=resolved_path,
         indent=_normalise_indent(indent),
         ensure_ascii=ensure_ascii,
     )
     combined: dict[str, Any] = {}
-    for model in models:
+    for model in sorted(models, key=lambda m: m.__name__):
         combined[model.__name__] = model.model_json_schema()
 
     payload = json.dumps(
@@ -69,6 +91,8 @@ def emit_models_schema(
         sort_keys=True,
     )
     config.output_path.parent.mkdir(parents=True, exist_ok=True)
+    if payload and not payload.endswith("\n"):
+        payload += "\n"
     config.output_path.write_text(payload, encoding="utf-8")
     return config.output_path
 

pydantic_fixturegen/logging.py

@@ -0,0 +1,114 @@
+"""Application-level logging helpers with CLI-friendly formatting."""
+
+from __future__ import annotations
+
+import json
+import sys
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Final
+
+import typer
+
+LOG_LEVEL_ORDER: Final[tuple[str, ...]] = ("silent", "error", "warn", "info", "debug")
+LOG_LEVELS: Final[dict[str, int]] = {
+    "silent": 100,
+    "error": 40,
+    "warn": 30,
+    "info": 20,
+    "debug": 10,
+}
+
+
+# Index in LOG_LEVEL_ORDER representing the default "info" verbosity tier
+DEFAULT_VERBOSITY_INDEX: Final[int] = LOG_LEVEL_ORDER.index("info")
+
+
+_COLOR_BY_LEVEL: Final[dict[str, str]] = {
+    "debug": typer.colors.BLUE,
+    "info": typer.colors.GREEN,
+    "warn": typer.colors.YELLOW,
+    "error": typer.colors.RED,
+}
+
+
+@dataclass(slots=True)
+class LoggerConfig:
+    level: int = LOG_LEVELS["info"]
+    json: bool = False
+
+
+class Logger:
+    def __init__(self, config: LoggerConfig | None = None) -> None:
+        self.config = config or LoggerConfig()
+
+    def configure(self, *, level: str | None = None, json_mode: bool | None = None) -> None:
+        if level is not None:
+            canonical = level.lower()
+            if canonical not in LOG_LEVELS:
+                raise ValueError(f"Unknown log level: {level}")
+            self.config.level = LOG_LEVELS[canonical]
+        if json_mode is not None:
+            self.config.json = json_mode
+
+    def debug(self, message: str, **extras: Any) -> None:
+        self._emit("debug", message, **extras)
+
+    def info(self, message: str, **extras: Any) -> None:
+        self._emit("info", message, **extras)
+
+    def warn(self, message: str, **extras: Any) -> None:
+        self._emit("warn", message, **extras)
+
+    def error(self, message: str, **extras: Any) -> None:
+        self._emit("error", message, **extras)
+
+    def _emit(self, level_name: str, message: str, **extras: Any) -> None:
+        level_value = LOG_LEVELS.get(level_name)
+        if level_value is None:
+            raise ValueError(f"Unknown log level: {level_name}")
+
+        if level_value < self.config.level:
+            return
+
+        payload_context = dict(extras)
+        event_name = payload_context.pop("event", message)
+
+        if self.config.json:
+            payload = {
+                "timestamp": datetime.now().isoformat(timespec="seconds"),
+                "level": level_name,
+                "event": event_name,
+                "message": message,
+                "context": payload_context or None,
+            }
+            sys.stdout.write(json.dumps(payload, sort_keys=True) + "\n")
+            return
+
+        stream_to_err = level_name in {"warn", "error"}
+        color = _COLOR_BY_LEVEL.get(level_name, typer.colors.WHITE)
+
+        typer.secho(message, fg=color, err=stream_to_err)
+        if payload_context and self.config.level <= LOG_LEVELS["debug"]:
+            typer.secho(
+                json.dumps(payload_context, sort_keys=True, indent=2),
+                fg=_COLOR_BY_LEVEL["debug"],
+                err=stream_to_err,
+            )
+
+
+_GLOBAL_LOGGER = Logger()
+
+
+def get_logger() -> Logger:
+    return _GLOBAL_LOGGER
+
+
+__all__ = [
+    "Logger",
+    "LoggerConfig",
+    "LOG_LEVELS",
+    "LOG_LEVEL_ORDER",
+    "DEFAULT_VERBOSITY_INDEX",
+    "get_logger",
+]

pydantic_fixturegen/schemas/config.schema.json

@@ -0,0 +1,244 @@
+{
+  "$defs": {
+    "EmittersSchema": {
+      "additionalProperties": false,
+      "description": "Schema for emitter configuration sections.",
+      "properties": {
+        "pytest": {
+          "$ref": "#/$defs/PytestEmitterSchema",
+          "description": "Configuration for the built-in pytest fixture emitter."
+        }
+      },
+      "title": "EmittersSchema",
+      "type": "object"
+    },
+    "FieldPolicyOptionsSchema": {
+      "additionalProperties": false,
+      "description": "Schema describing supported field policy overrides.",
+      "properties": {
+        "enum_policy": {
+          "anyOf": [
+            {
+              "enum": [
+                "first",
+                "random"
+              ],
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "description": "Enum selection policy for matching fields.",
+          "title": "Enum Policy"
+        },
+        "p_none": {
+          "anyOf": [
+            {
+              "maximum": 1.0,
+              "minimum": 0.0,
+              "type": "number"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "description": "Probability override for returning None on optional fields.",
+          "title": "P None"
+        },
+        "union_policy": {
+          "anyOf": [
+            {
+              "enum": [
+                "first",
+                "random"
+              ],
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "description": "Union selection policy for matching fields.",
+          "title": "Union Policy"
+        }
+      },
+      "title": "FieldPolicyOptionsSchema",
+      "type": "object"
+    },
+    "JsonSchema": {
+      "additionalProperties": false,
+      "description": "Schema for JSON emitter settings.",
+      "properties": {
+        "indent": {
+          "default": 2,
+          "description": "Indentation level for JSON output (0 for compact).",
+          "minimum": 0,
+          "title": "Indent",
+          "type": "integer"
+        },
+        "orjson": {
+          "default": false,
+          "description": "Use orjson for serialization when available.",
+          "title": "Orjson",
+          "type": "boolean"
+        }
+      },
+      "title": "JsonSchema",
+      "type": "object"
+    },
+    "PytestEmitterSchema": {
+      "additionalProperties": false,
+      "description": "Schema for pytest emitter settings.",
+      "properties": {
+        "scope": {
+          "default": "function",
+          "description": "Default pytest fixture scope.",
+          "enum": [
+            "function",
+            "module",
+            "session"
+          ],
+          "title": "Scope",
+          "type": "string"
+        },
+        "style": {
+          "default": "functions",
+          "description": "How emitted pytest fixtures are structured.",
+          "enum": [
+            "functions",
+            "factory",
+            "class"
+          ],
+          "title": "Style",
+          "type": "string"
+        }
+      },
+      "title": "PytestEmitterSchema",
+      "type": "object"
+    }
+  },
+  "$id": "https://raw.githubusercontent.com/CasperKristiansson/pydantic-fixturegen/main/pydantic_fixturegen/schemas/config.schema.json",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "additionalProperties": true,
+  "description": "Authoritative schema for `[tool.pydantic_fixturegen]` configuration.",
+  "properties": {
+    "emitters": {
+      "$ref": "#/$defs/EmittersSchema",
+      "description": "Emitter-specific configuration sections."
+    },
+    "enum_policy": {
+      "default": "first",
+      "description": "Strategy for selecting enum members.",
+      "enum": [
+        "first",
+        "random"
+      ],
+      "title": "Enum Policy",
+      "type": "string"
+    },
+    "exclude": {
+      "description": "Glob patterns of fully-qualified model names to exclude by default.",
+      "items": {
+        "type": "string"
+      },
+      "title": "Exclude",
+      "type": "array"
+    },
+    "field_policies": {
+      "additionalProperties": {
+        "$ref": "#/$defs/FieldPolicyOptionsSchema"
+      },
+      "description": "Field policy definitions keyed by glob or regex patterns that may target model names or dotted field paths.",
+      "title": "Field Policies",
+      "type": "object"
+    },
+    "include": {
+      "description": "Glob patterns of fully-qualified model names to include by default.",
+      "items": {
+        "type": "string"
+      },
+      "title": "Include",
+      "type": "array"
+    },
+    "json": {
+      "$ref": "#/$defs/JsonSchema",
+      "description": "Settings shared by JSON-based emitters."
+    },
+    "locale": {
+      "default": "en_US",
+      "description": "Default Faker locale used when generating data.",
+      "title": "Locale",
+      "type": "string"
+    },
+    "overrides": {
+      "additionalProperties": {
+        "additionalProperties": true,
+        "type": "object"
+      },
+      "description": "Per-model overrides keyed by fully-qualified model name.",
+      "title": "Overrides",
+      "type": "object"
+    },
+    "p_none": {
+      "anyOf": [
+        {
+          "maximum": 1.0,
+          "minimum": 0.0,
+          "type": "number"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": null,
+      "description": "Probability of sampling `None` for optional fields when unspecified.",
+      "title": "P None"
+    },
+    "preset": {
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": null,
+      "description": "Curated preset name applied before other configuration (e.g., 'boundary').",
+      "title": "Preset"
+    },
+    "seed": {
+      "anyOf": [
+        {
+          "type": "integer"
+        },
+        {
+          "type": "string"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": null,
+      "description": "Global seed controlling deterministic generation. Accepts int or string.",
+      "title": "Seed"
+    },
+    "union_policy": {
+      "default": "first",
+      "description": "Strategy for selecting branches of `typing.Union`.",
+      "enum": [
+        "first",
+        "random",
+        "weighted"
+      ],
+      "title": "Union Policy",
+      "type": "string"
+    }
+  },
+  "title": "pydantic-fixturegen configuration",
+  "type": "object"
+}