pydantic-fixturegen 1.0.0__py3-none-any.whl

pydantic_fixturegen/cli/list.py

@@ -0,0 +1,164 @@
+"""CLI command for listing Pydantic models."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from pydantic_fixturegen.core.errors import DiscoveryError, PFGError, UnsafeImportError
+from pydantic_fixturegen.core.introspect import DiscoveryMethod, IntrospectionResult, discover
+
+from .gen._common import JSON_ERRORS_OPTION, render_cli_error, split_patterns
+
+PATH_ARGUMENT = typer.Argument(
+    ...,
+    help="Python module file to inspect.",
+)
+
+INCLUDE_OPTION = typer.Option(
+    None,
+    "--include",
+    "-i",
+    help="Comma-separated glob pattern(s) of fully-qualified model names to include.",
+)
+
+EXCLUDE_OPTION = typer.Option(
+    None,
+    "--exclude",
+    "-e",
+    help="Comma-separated glob pattern(s) of fully-qualified model names to exclude.",
+)
+
+PUBLIC_OPTION = typer.Option(
+    False,
+    "--public-only",
+    help="Only list public models (respects __all__).",
+)
+
+AST_OPTION = typer.Option(
+    False,
+    "--ast",
+    help="Use AST discovery only (no imports executed).",
+)
+
+HYBRID_OPTION = typer.Option(
+    False,
+    "--hybrid",
+    help="Combine AST and safe import discovery.",
+)
+
+TIMEOUT_OPTION = typer.Option(
+    5.0,
+    "--timeout",
+    min=0.1,
+    help="Timeout in seconds for safe import execution.",
+)
+
+MEMORY_LIMIT_OPTION = typer.Option(
+    256,
+    "--memory-limit-mb",
+    min=1,
+    help="Memory limit in megabytes for safe import subprocess.",
+)
+
+
+app = typer.Typer(invoke_without_command=True, subcommand_metavar="")
+
+
+def _resolve_method(ast_mode: bool, hybrid_mode: bool) -> DiscoveryMethod:
+    if ast_mode and hybrid_mode:
+        raise DiscoveryError("Choose only one of --ast or --hybrid.")
+    if hybrid_mode:
+        return "hybrid"
+    if ast_mode:
+        return "ast"
+    return "import"
+
+
+def list_models(  # noqa: D401 - Typer callback
+    ctx: typer.Context,
+    path: str = PATH_ARGUMENT,
+    include: str | None = INCLUDE_OPTION,
+    exclude: str | None = EXCLUDE_OPTION,
+    public_only: bool = PUBLIC_OPTION,
+    ast_mode: bool = AST_OPTION,
+    hybrid_mode: bool = HYBRID_OPTION,
+    timeout: float = TIMEOUT_OPTION,
+    memory_limit_mb: int = MEMORY_LIMIT_OPTION,
+    json_errors: bool = JSON_ERRORS_OPTION,
+) -> None:
+    _ = ctx  # unused
+    try:
+        _execute_list_command(
+            target=path,
+            include=include,
+            exclude=exclude,
+            public_only=public_only,
+            ast_mode=ast_mode,
+            hybrid_mode=hybrid_mode,
+            timeout=timeout,
+            memory_limit_mb=memory_limit_mb,
+        )
+    except PFGError as exc:
+        render_cli_error(exc, json_errors=json_errors)
+
+
+app.callback(invoke_without_command=True)(list_models)
+
+
+def _execute_list_command(
+    *,
+    target: str,
+    include: str | None,
+    exclude: str | None,
+    public_only: bool,
+    ast_mode: bool,
+    hybrid_mode: bool,
+    timeout: float,
+    memory_limit_mb: int,
+) -> 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})
+
+    method = _resolve_method(ast_mode, hybrid_mode)
+
+    result = discover(
+        [path],
+        method=method,
+        include=_split_patterns(include),
+        exclude=_split_patterns(exclude),
+        public_only=public_only,
+        safe_import_timeout=timeout,
+        safe_import_memory_limit_mb=memory_limit_mb,
+    )
+    _render_result(result)
+
+
+def _render_result(result: IntrospectionResult) -> None:
+    for warning in result.warnings:
+        if warning.strip():
+            typer.secho(f"warning: {warning.strip()}", err=True, fg=typer.colors.YELLOW)
+
+    if result.errors:
+        message = "; ".join(result.errors)
+        if any("network" in error.lower() for error in result.errors):
+            raise UnsafeImportError(message)
+        raise DiscoveryError(message)
+
+    if not result.models:
+        typer.echo("No models discovered.")
+        return
+
+    for model in result.models:
+        typer.echo(f"{model.qualname} [{model.discovery}]")
+
+
+def _split_patterns(option_value: str | None) -> list[str]:
+    return split_patterns(option_value)
+
+
+__all__ = ["app"]

pydantic_fixturegen/core/__init__.py

@@ -0,0 +1,103 @@
+"""Core utilities for pydantic-fixturegen."""
+
+from .ast_discover import AstDiscoveryResult, AstModel, discover_models
+from .config import (
+    AppConfig,
+    ConfigError,
+    EmittersConfig,
+    JsonConfig,
+    PytestEmitterConfig,
+    load_config,
+)
+from .errors import (
+    DiscoveryError,
+    EmitError,
+    ErrorCode,
+    MappingError,
+    PFGError,
+    UnsafeImportError,
+)
+from .generate import GenerationConfig, InstanceGenerator
+from .introspect import IntrospectedModel, IntrospectionResult
+from .introspect import discover as introspect
+from .io_utils import WriteResult, write_atomic_bytes, write_atomic_text
+from .providers import (
+    ProviderRef,
+    ProviderRegistry,
+    create_default_registry,
+    register_collection_providers,
+    register_identifier_providers,
+    register_numeric_providers,
+    register_string_providers,
+    register_temporal_providers,
+)
+from .providers.collections import generate_collection
+from .providers.identifiers import generate_identifier
+from .providers.numbers import generate_numeric
+from .providers.strings import generate_string
+from .providers.temporal import generate_temporal
+from .safe_import import SafeImportResult, safe_import_models
+from .schema import (
+    FieldConstraints,
+    FieldSummary,
+    extract_constraints,
+    extract_model_constraints,
+    summarize_field,
+    summarize_model_fields,
+)
+from .seed import SeedManager
+from .strategies import Strategy, StrategyBuilder, UnionStrategy
+from .version import build_artifact_header, get_tool_version
+
+__all__ = [
+    "AppConfig",
+    "AstDiscoveryResult",
+    "AstModel",
+    "ConfigError",
+    "EmittersConfig",
+    "JsonConfig",
+    "PytestEmitterConfig",
+    "SafeImportResult",
+    "SeedManager",
+    "WriteResult",
+    "FieldConstraints",
+    "FieldSummary",
+    "ProviderRef",
+    "ProviderRegistry",
+    "Strategy",
+    "StrategyBuilder",
+    "UnionStrategy",
+    "create_default_registry",
+    "generate_collection",
+    "generate_identifier",
+    "generate_numeric",
+    "generate_string",
+    "generate_temporal",
+    "GenerationConfig",
+    "InstanceGenerator",
+    "register_string_providers",
+    "register_numeric_providers",
+    "register_collection_providers",
+    "register_identifier_providers",
+    "register_temporal_providers",
+    "build_artifact_header",
+    "discover_models",
+    "introspect",
+    "IntrospectedModel",
+    "IntrospectionResult",
+    "get_tool_version",
+    "load_config",
+    "extract_constraints",
+    "extract_model_constraints",
+    "summarize_field",
+    "summarize_model_fields",
+    "safe_import_models",
+    "write_atomic_text",
+    "write_atomic_bytes",
+    "PFGError",
+    "DiscoveryError",
+    "MappingError",
+    "EmitError",
+    "UnsafeImportError",
+    "ErrorCode",
+]

pydantic_fixturegen/core/ast_discover.py

@@ -0,0 +1,169 @@
+"""AST-based discovery of Pydantic model classes without executing modules."""
+
+from __future__ import annotations
+
+import ast
+from collections.abc import Iterable
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(slots=True)
+class AstModel:
+    module: str
+    name: str
+    qualname: str
+    path: Path
+    lineno: int
+    is_public: bool
+
+
+@dataclass(slots=True)
+class AstDiscoveryResult:
+    models: list[AstModel]
+    warnings: list[str]
+
+
+PYDANTIC_BASES = {
+    ("pydantic", "BaseModel"),
+    ("pydantic", "RootModel"),
+    ("pydantic.v1", "BaseModel"),
+    ("pydantic.v1", "RootModel"),
+}
+
+
+def discover_models(
+    paths: Iterable[Path | str],
+    *,
+    infer_module: bool = False,
+    public_only: bool = False,
+) -> AstDiscoveryResult:
+    """Discover Pydantic models from the given Python source files using AST parsing."""
+    models: list[AstModel] = []
+    warnings: list[str] = []
+
+    for raw_path in paths:
+        path = Path(raw_path)
+        try:
+            source = path.read_text(encoding="utf-8")
+        except OSError as exc:
+            warnings.append(f"Failed to read {path}: {exc}")
+            continue
+
+        try:
+            tree = ast.parse(source, filename=str(path))
+        except SyntaxError as exc:
+            warnings.append(f"Failed to parse {path}: {exc}")
+            continue
+
+        resolver = _ImportResolver()
+        resolver.visit(tree)
+
+        module_name = path.stem if infer_module else "unknown"
+        public_names = _extract_public_names(tree)
+
+        for class_node in [node for node in ast.walk(tree) if isinstance(node, ast.ClassDef)]:
+            if not _is_pydantic_model(class_node, resolver):
+                continue
+
+            if public_names is not None:
+                is_public = class_node.name in public_names
+            else:
+                is_public = not class_node.name.startswith("_")
+            if public_only and not is_public:
+                continue
+
+            model = AstModel(
+                module=module_name,
+                name=class_node.name,
+                qualname=f"{module_name}.{class_node.name}",
+                path=path,
+                lineno=class_node.lineno,
+                is_public=is_public,
+            )
+            models.append(model)
+
+    models.sort(key=lambda m: (m.module, m.name))
+    return AstDiscoveryResult(models=models, warnings=warnings)
+
+
+class _ImportResolver(ast.NodeVisitor):
+    def __init__(self) -> None:
+        self.aliases: dict[str, tuple[str, str]] = {}
+
+    def visit_Import(self, node: ast.Import) -> None:
+        for alias in node.names:
+            name = alias.asname or alias.name
+            base_name = alias.name.split(".")[0]
+            for module, _ in PYDANTIC_BASES:
+                if base_name == module:
+                    self.aliases[name] = (module, "*")
+
+    def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
+        module = node.module
+        if module is None:
+            return
+        base_module = module.split(".")[0]
+        for alias in node.names:
+            target_name = alias.asname or alias.name
+            qual = alias.name
+            if module in {"pydantic", "pydantic.v1"} and qual in {"BaseModel", "RootModel"}:
+                self.aliases[target_name] = (module, qual)
+            elif base_module in {"pydantic", "pydantic.v1"}:
+                self.aliases[target_name] = (base_module, "*")
+
+
+def _extract_public_names(tree: ast.AST) -> set[str] | None:
+    for node in tree.body if isinstance(tree, ast.Module) else []:
+        if isinstance(node, ast.Assign):
+            for target in node.targets:
+                if (
+                    isinstance(target, ast.Name)
+                    and target.id == "__all__"
+                    and isinstance(node.value, (ast.List, ast.Tuple))
+                ):
+                    names: set[str] = set()
+                    for element in node.value.elts:
+                        if isinstance(element, ast.Constant) and isinstance(element.value, str):
+                            names.add(element.value)
+                    return names
+    return None
+
+
+def _is_pydantic_model(node: ast.ClassDef, resolver: _ImportResolver) -> bool:
+    for base in node.bases:
+        module_class = _resolve_base(base, resolver)
+        if module_class is None:
+            continue
+        module, class_name = module_class
+        if (module, class_name) in PYDANTIC_BASES:
+            return True
+    return False
+
+
+def _resolve_base(base: ast.expr, resolver: _ImportResolver) -> tuple[str, str] | None:
+    if isinstance(base, ast.Name):
+        return resolver.aliases.get(base.id)
+    if isinstance(base, ast.Attribute):
+        parts = _flatten_attribute(base)
+        if len(parts) >= 2:
+            module_candidate = parts[0]
+            class_candidate = parts[-1]
+            alias = resolver.aliases.get(module_candidate)
+            if alias:
+                module, _ = alias
+                return (module, class_candidate)
+            if module_candidate in {"pydantic", "pydantic.v1"}:
+                return (module_candidate, class_candidate)
+    return None
+
+
+def _flatten_attribute(attr: ast.Attribute) -> list[str]:
+    parts: list[str] = []
+    current: ast.AST | None = attr
+    while isinstance(current, ast.Attribute):
+        parts.insert(0, current.attr)
+        current = current.value
+    if isinstance(current, ast.Name):
+        parts.insert(0, current.id)
+    return parts