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

pydantic_fixturegen/core/providers/temporal.py

@@ -15,10 +15,20 @@ def generate_temporal(
     summary: FieldSummary,
     *,
     faker: Faker | None = None,
+    time_anchor: datetime.datetime | None = None,
 ) -> Any:
     faker = faker or Faker()
     type_name = summary.type
 
+    if time_anchor is not None:
+        anchor = time_anchor
+        if type_name == "datetime":
+            return anchor
+        if type_name == "date":
+            return anchor.date()
+        if type_name == "time":
+            return anchor.timetz() if anchor.tzinfo else anchor.time()
+
     if type_name == "datetime":
         return faker.date_time(tzinfo=datetime.timezone.utc)
     if type_name == "date":

pydantic_fixturegen/core/safe_import.py

@@ -45,6 +45,109 @@ class SafeImportResult:
     exit_code: int
 
 
+def _module_basename(path: Path) -> str:
+    """Return the module name portion for a Python file."""
+
+    if path.name == "__init__.py":
+        return path.parent.name or "module"
+    stem = path.stem
+    return stem if stem else "module"
+
+
+def _package_hierarchy(module_path: Path) -> list[Path]:
+    """Collect package directories (with __init__.py) from top to bottom."""
+
+    hierarchy: list[Path] = []
+    current = module_path.parent.resolve()
+    while True:
+        init_file = current / "__init__.py"
+        if not init_file.exists():
+            break
+        hierarchy.append(current)
+        parent = current.parent.resolve()
+        if parent == current:
+            break
+        current = parent
+    hierarchy.reverse()
+    return hierarchy
+
+
+def _resolve_module_name(module_path: Path, workdir: Path, index: int) -> str:
+    """Determine an importable module name for the module path."""
+
+    packages = _package_hierarchy(module_path)
+    if packages:
+        module_part = _module_basename(module_path)
+        if module_path.name == "__init__.py":
+            return ".".join(pkg.name for pkg in packages)
+        package_parts = [pkg.name for pkg in packages]
+        return ".".join(package_parts + [module_part])
+
+    try:
+        relative = module_path.relative_to(workdir)
+    except ValueError:
+        relative = None
+
+    if relative is not None:
+        parts = list(relative.parts)
+        if parts:
+            parts[-1] = _module_basename(module_path)
+        module_name = ".".join(part for part in parts if part not in ("", "."))
+        if module_name:
+            return module_name
+
+    fallback = _module_basename(module_path)
+    return fallback if index == 0 else f"{fallback}_{index}"
+
+
+def _candidate_python_paths(module_path: Path, workdir: Path) -> list[Path]:
+    """Return directories that should be added to PYTHONPATH for imports."""
+
+    candidates: list[Path] = []
+    packages = _package_hierarchy(module_path)
+    if packages:
+        highest_package = packages[0]
+        parent = highest_package.parent
+        if parent != highest_package:
+            candidates.append(parent)
+    candidates.append(module_path.parent)
+
+    if not candidates:
+        candidates.append(workdir)
+
+    return candidates
+
+
+def _build_module_entries(paths: Sequence[Path], workdir: Path) -> list[dict[str, str]]:
+    entries: list[dict[str, str]] = []
+    for index, module_path in enumerate(paths):
+        module_name = _resolve_module_name(module_path, workdir, index)
+        entries.append({"path": str(module_path), "name": module_name})
+    return entries
+
+
+def _build_pythonpath_entries(workdir: Path, paths: Sequence[Path]) -> list[Path]:
+    entries: list[Path] = []
+    seen: set[Path] = set()
+
+    def _add(path: Path) -> None:
+        resolved = path.resolve()
+        if not resolved.exists() or not resolved.is_dir():
+            return
+        if resolved in seen:
+            return
+        entries.append(resolved)
+        seen.add(resolved)
+
+    _add(workdir)
+
+    for module_path in paths:
+        for candidate in _candidate_python_paths(module_path, workdir):
+            _add(candidate)
+
+    return entries
+
+
 def safe_import_models(
     paths: Sequence[Path | str],
     *,
@@ -67,16 +170,22 @@ def safe_import_models(
     if not paths:
         return SafeImportResult(True, [], None, None, "", 0)
 
-    workdir = Path(cwd) if cwd else Path.cwd()
+    workdir = (Path(cwd) if cwd else Path.cwd()).resolve()
     python = python_executable or sys.executable
 
+    resolved_paths = [Path(path).resolve() for path in paths]
+    module_entries = _build_module_entries(resolved_paths, workdir)
+    pythonpath_entries = _build_pythonpath_entries(workdir, resolved_paths)
+
     request = {
-        "paths": [str(Path(path).resolve()) for path in paths],
+        "paths": [str(path) for path in resolved_paths],
+        "module_entries": module_entries,
+        "python_path_entries": [str(path) for path in pythonpath_entries],
         "memory_limit_mb": memory_limit_mb,
-        "workdir": str(workdir.resolve()),
+        "workdir": str(workdir),
     }
 
-    env = _build_env(workdir, extra_env)
+    env = _build_env(workdir, extra_env, pythonpath_entries)
 
     try:
         completed = subprocess.run(
@@ -146,10 +255,13 @@ def _safe_text(value: object) -> str:
     return value.decode("utf-8", "replace") if isinstance(value, bytes) else str(value or "")
 
 
-def _build_env(workdir: Path, extra_env: Mapping[str, str] | None) -> dict[str, str]:
+def _build_env(
+    workdir: Path,
+    extra_env: Mapping[str, str] | None,
+    pythonpath_entries: Sequence[Path],
+) -> dict[str, str]:
     base_env: dict[str, str] = {
         "PYTHONSAFEPATH": "1",
-        "PYTHONPATH": str(workdir),
         "NO_PROXY": "*",
         "no_proxy": "*",
         "http_proxy": "",
@@ -165,6 +277,9 @@ def _build_env(workdir: Path, extra_env: Mapping[str, str] | None) -> dict[str,
         "HOME": str(workdir),
     }
 
+    pythonpath_value = os.pathsep.join(str(entry) for entry in pythonpath_entries)
+    base_env["PYTHONPATH"] = pythonpath_value or str(workdir)
+
     allowed_passthrough = ["PATH", "SYSTEMROOT", "COMSPEC"]
     for key in allowed_passthrough:
         if key in os.environ:
@@ -335,8 +450,8 @@ _RUNNER_SNIPPET = textwrap.dedent(
         stem = module_path.stem or "module"
         return stem if index == 0 else f"{stem}_{index}"
 
-    def _load_module(module_path: Path, index: int):
-        module_name = _derive_module_name(module_path, index)
+    def _load_module(module_path: Path, index: int, explicit_name: str | None = None):
+        module_name = explicit_name or _derive_module_name(module_path, index)
         spec = importlib_util.spec_from_file_location(module_name, module_path)
         if spec is None or spec.loader is None:
             raise ImportError(f"Could not load module from {module_path}")
@@ -378,12 +493,31 @@ _RUNNER_SNIPPET = textwrap.dedent(
         _block_network()
         _restrict_filesystem(workdir)
 
-        paths = [Path(path) for path in request.get("paths", [])]
+        python_path_entries = request.get("python_path_entries") or []
+        for extra in reversed(python_path_entries):
+            if not extra:
+                continue
+            extra_path = str(Path(extra))
+            if extra_path not in sys.path:
+                sys.path.insert(0, extra_path)
+
+        module_entries = request.get("module_entries") or []
+        normalized_entries = []
+        if module_entries:
+            for entry in module_entries:
+                raw_path = entry.get("path")
+                if not raw_path:
+                    continue
+                module_path = Path(raw_path)
+                module_name = entry.get("name")
+                normalized_entries.append((module_path, module_name))
+        else:
+            fallback_paths = [Path(path) for path in request.get("paths", [])]
+            normalized_entries = [(path, None) for path in fallback_paths]
 
         collected = []
-        for idx, path in enumerate(paths):
-            module_path = Path(path)
-            module = _load_module(module_path, idx)
+        for idx, (module_path, module_name) in enumerate(normalized_entries):
+            module = _load_module(module_path, idx, module_name)
             collected.extend(_collect_models(module, module_path))
 
         payload = {"success": True, "models": collected}

pydantic_fixturegen/core/seed_freeze.py

@@ -0,0 +1,176 @@
+"""Helpers for managing seed freeze files used for deterministic generation."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel
+
+from .seed import SeedManager
+
+FREEZE_FILE_BASENAME = ".pfg-seeds.json"
+FREEZE_FILE_VERSION = 1
+
+
+class FreezeStatus(str, Enum):
+    """Status classification for freeze entries when resolving seeds."""
+
+    MISSING = "missing"
+    STALE = "stale"
+    VALID = "valid"
+
+
+@dataclass(slots=True)
+class SeedRecord:
+    """Stored seed metadata for a single model."""
+
+    seed: int
+    model_digest: str | None = None
+
+    def to_payload(self) -> dict[str, Any]:
+        payload: dict[str, Any] = {"seed": self.seed}
+        if self.model_digest is not None:
+            payload["model_digest"] = self.model_digest
+        return payload
+
+
+class SeedFreezeFile:
+    """Abstraction over the freeze file storing per-model deterministic seeds."""
+
+    def __init__(self, path: Path) -> None:
+        self.path = path
+        self.exists = False
+        self._records: dict[str, SeedRecord] = {}
+        self._dirty = False
+        self.messages: list[str] = []
+
+    @property
+    def records(self) -> dict[str, SeedRecord]:
+        return self._records
+
+    @classmethod
+    def load(cls, path: Path) -> SeedFreezeFile:
+        manager = cls(path)
+        if not path.exists():
+            return manager
+
+        manager.exists = True
+        try:
+            raw = json.loads(path.read_text(encoding="utf-8"))
+        except json.JSONDecodeError as exc:
+            manager.messages.append(f"Failed to parse seed freeze file: {exc}")
+            return manager
+
+        version = raw.get("version")
+        if version != FREEZE_FILE_VERSION:
+            manager.messages.append("Seed freeze file version mismatch; ignoring entries")
+            return manager
+
+        models = raw.get("models", {})
+        if not isinstance(models, dict):
+            manager.messages.append("Seed freeze file missing 'models' mapping; ignoring entries")
+            return manager
+
+        for identifier, payload in models.items():
+            if not isinstance(payload, dict):
+                continue
+            seed = payload.get("seed")
+            if not isinstance(seed, int):
+                continue
+            record = SeedRecord(
+                seed=seed,
+                model_digest=payload.get("model_digest"),
+            )
+            manager._records[identifier] = record
+        return manager
+
+    def resolve_seed(
+        self, identifier: str, *, model_digest: str | None
+    ) -> tuple[int | None, FreezeStatus]:
+        record = self._records.get(identifier)
+        if record is None:
+            return None, FreezeStatus.MISSING
+
+        if model_digest and record.model_digest and record.model_digest != model_digest:
+            return record.seed, FreezeStatus.STALE
+
+        if model_digest and record.model_digest is None:
+            return record.seed, FreezeStatus.STALE
+
+        return record.seed, FreezeStatus.VALID
+
+    def record_seed(self, identifier: str, seed: int, *, model_digest: str | None) -> None:
+        current = self._records.get(identifier)
+        new_record = SeedRecord(seed=seed, model_digest=model_digest)
+        if (
+            current
+            and current.seed == new_record.seed
+            and current.model_digest == new_record.model_digest
+        ):
+            return
+
+        self._records[identifier] = new_record
+        self._dirty = True
+
+    def save(self) -> None:
+        if not self._dirty:
+            return
+
+        output = {
+            "version": FREEZE_FILE_VERSION,
+            "models": {
+                identifier: record.to_payload()
+                for identifier, record in sorted(self._records.items())
+            },
+        }
+
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self.path.write_text(json.dumps(output, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+        self._dirty = False
+
+
+def resolve_freeze_path(path_option: Path | None, *, root: Path | None = None) -> Path:
+    base = root or Path.cwd()
+    if path_option is None:
+        return base / FREEZE_FILE_BASENAME
+
+    candidate = Path(path_option)
+    if candidate.is_absolute():
+        return candidate
+    return base / candidate
+
+
+def model_identifier(model: type[BaseModel]) -> str:
+    return f"{model.__module__}.{model.__qualname__}"
+
+
+def compute_model_digest(model: type[BaseModel]) -> str | None:
+    try:
+        schema = model.model_json_schema()
+    except Exception:  # pragma: no cover - defensive
+        return None
+
+    serialized = json.dumps(schema, sort_keys=True, separators=(",", ":"))
+    return hashlib.sha256(serialized.encode("utf-8")).hexdigest()
+
+
+def derive_default_model_seed(base_seed: int | str | None, identifier: str) -> int:
+    manager = SeedManager(seed=base_seed)
+    return manager.derive_child_seed(identifier)
+
+
+__all__ = [
+    "FREEZE_FILE_BASENAME",
+    "FREEZE_FILE_VERSION",
+    "FreezeStatus",
+    "SeedFreezeFile",
+    "compute_model_digest",
+    "derive_default_model_seed",
+    "model_identifier",
+    "resolve_freeze_path",
+]

pydantic_fixturegen/emitters/json_out.py

@@ -14,6 +14,8 @@ from typing import Any, cast
 
 from pydantic import BaseModel
 
+from pydantic_fixturegen.core.path_template import OutputTemplate, OutputTemplateContext
+
 orjson: ModuleType | None
 try:  # Optional dependency
     import orjson as _orjson
@@ -32,6 +34,8 @@ class JsonEmitConfig:
 
     output_path: Path
     count: int
+    template: OutputTemplate | None = None
+    template_context: OutputTemplateContext | None = None
     jsonl: bool = False
     indent: int | None = DEFAULT_INDENT
     shard_size: int | None = None
@@ -51,6 +55,8 @@ def emit_json_samples(
     use_orjson: bool = False,
     ensure_ascii: bool = False,
     max_workers: int | None = None,
+    template: OutputTemplate | None = None,
+    template_context: OutputTemplateContext | None = None,
 ) -> list[Path]:
     """Emit generated samples to JSON or JSONL files.
 
@@ -73,9 +79,20 @@ def emit_json_samples(
         List of ``Path`` objects for the created file(s), ordered by shard index.
     """
 
+    template_obj = template or OutputTemplate(output_path)
+    context = template_context or OutputTemplateContext()
+
+    if template_obj.fields:
+        initial_index = 1 if template_obj.uses_case_index() else None
+        resolved_path = template_obj.render(context=context, case_index=initial_index)
+    else:
+        resolved_path = template_obj.render(context=context)
+
     config = JsonEmitConfig(
-        output_path=Path(output_path),
+        output_path=resolved_path,
         count=count,
+        template=template_obj if template_obj.fields else None,
+        template_context=context,
         jsonl=jsonl,
         indent=_normalise_indent(indent, jsonl=jsonl),
         shard_size=_normalise_shard_size(shard_size, count),
@@ -95,13 +112,13 @@ def emit_json_samples(
         if config.jsonl:
             path = _stream_jsonl(
                 samples_iter,
-                config.output_path,
+                _resolve_base_path(config, index=1),
                 encoder,
             )
         else:
             path = _stream_json_array(
                 samples_iter,
-                config.output_path,
+                _resolve_base_path(config, index=1),
                 encoder,
                 indent=config.indent,
             )
@@ -167,7 +184,7 @@ def _write_empty_shard(
     path = _shard_path(base_path, 1, 1, jsonl)
     empty_payload = "" if jsonl else encoder.encode([])
     path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(empty_payload, encoding="utf-8")
+    path.write_text(empty_payload, encoding="utf-8", newline="\n")
     return path
 
 
@@ -179,14 +196,19 @@ def _prepare_payload(
     workers: int,
 ) -> str:
     if not jsonl:
-        return encoder.encode(list(chunk))
+        payload = encoder.encode(list(chunk))
+        if payload and not payload.endswith("\n"):
+            payload += "\n"
+        return payload
 
     if workers <= 1:
         lines = [encoder.encode(item) for item in chunk]
     else:
         with ThreadPoolExecutor(max_workers=workers) as executor:
             lines = list(executor.map(encoder.encode, chunk))
-    return "\n".join(lines) + ("\n" if lines else "")
+    if not lines:
+        return ""
+    return "\n".join(lines) + "\n"
 
 
 def _stream_jsonl(
@@ -196,7 +218,7 @@ def _stream_jsonl(
 ) -> Path:
     path = _ensure_suffix(base_path, ".jsonl")
     path.parent.mkdir(parents=True, exist_ok=True)
-    with path.open("w", encoding="utf-8") as stream:
+    with path.open("w", encoding="utf-8", newline="\n") as stream:
         for record in iterator:
             stream.write(encoder.encode(record))
             stream.write("\n")
@@ -214,7 +236,7 @@ def _stream_json_array(
     path.parent.mkdir(parents=True, exist_ok=True)
 
     if indent is None:
-        with path.open("w", encoding="utf-8") as stream:
+        with path.open("w", encoding="utf-8", newline="\n") as stream:
             first = True
             stream.write("[")
             for record in iterator:
@@ -222,11 +244,11 @@ def _stream_json_array(
                     stream.write(",")
                 stream.write(encoder.encode(record))
                 first = False
-            stream.write("]")
+            stream.write("]\n")
         return path
 
     spacing = " " * indent
-    with path.open("w", encoding="utf-8") as stream:
+    with path.open("w", encoding="utf-8", newline="\n") as stream:
         written = False
         for record in iterator:
             encoded = encoder.encode(record)
@@ -237,9 +259,9 @@ def _stream_json_array(
             stream.write(f"{spacing}{encoded}")
             written = True
         if not written:
-            stream.write("[]")
+            stream.write("[]\n")
         else:
-            stream.write("\n]")
+            stream.write("\n]\n")
     return path
 
 
@@ -253,7 +275,13 @@ def _write_chunked_samples(
 
     chunk = list(islice(iterator, chunk_size))
     if not chunk:
-        results.append(_write_empty_shard(config.output_path, config.jsonl, encoder))
+        results.append(
+            _write_empty_shard(
+                _resolve_base_path(config, index=1),
+                config.jsonl,
+                encoder,
+            )
+        )
         return results
 
     index = 1
@@ -261,7 +289,7 @@ def _write_chunked_samples(
         next_chunk = list(islice(iterator, chunk_size))
         is_last = not next_chunk
         path = _chunk_path(
-            config.output_path,
+            config,
             index=index,
             is_last=is_last,
             jsonl=config.jsonl,
@@ -273,7 +301,7 @@ def _write_chunked_samples(
             workers=_worker_count(config.max_workers, len(chunk)),
         )
         path.parent.mkdir(parents=True, exist_ok=True)
-        path.write_text(payload, encoding="utf-8")
+        path.write_text(payload, encoding="utf-8", newline="\n")
         results.append(path)
 
         chunk = next_chunk
@@ -283,13 +311,24 @@ def _write_chunked_samples(
 
 
 def _chunk_path(
-    base_path: Path,
+    config: JsonEmitConfig,
     *,
     index: int,
     is_last: bool,
     jsonl: bool,
 ) -> Path:
+    template = config.template
+    if template is not None:
+        base_path = template.render(
+            context=config.template_context,
+            case_index=index if template.uses_case_index() else None,
+        )
+    else:
+        base_path = config.output_path
+
     suffix = ".jsonl" if jsonl else ".json"
+    if template is not None and template.uses_case_index():
+        return _ensure_suffix(base_path, suffix)
     if is_last and index == 1:
         return _ensure_suffix(base_path, suffix)
 
@@ -297,6 +336,16 @@ def _chunk_path(
     return _shard_path(base_path, index, shard_total, jsonl)
 
 
+def _resolve_base_path(config: JsonEmitConfig, *, index: int) -> Path:
+    template = config.template
+    if template is None:
+        return config.output_path
+    return template.render(
+        context=config.template_context,
+        case_index=index if template.uses_case_index() else None,
+    )
+
+
 def _shard_path(base_path: Path, shard_index: int, shard_count: int, jsonl: bool) -> Path:
     suffix = ".jsonl" if jsonl else ".json"
     if shard_count <= 1: