schematico 0.1.0__py3-none-any.whl

schematico/__init__.py

@@ -0,0 +1,27 @@
+from importlib.metadata import PackageNotFoundError, version as _version
+
+from schematico.generator import run_generation
+from schematico.discovery import run_discovery
+from schematico.models import build_batch_model, model_from_dict, model_from_json
+from schematico.providers import (
+    DEFAULT_MODEL,
+    SchematicoModel,
+    get_llm_model,
+)
+
+try:
+    __version__ = _version("schematico")
+except PackageNotFoundError:  # running from a source tree without an install
+    __version__ = "0.0.0+unknown"
+
+__all__ = [
+    "__version__",
+    "DEFAULT_MODEL",
+    "SchematicoModel",
+    "build_batch_model",
+    "get_llm_model",
+    "model_from_dict",
+    "model_from_json",
+    "run_generation",
+    "run_discovery",
+]

schematico/cli/main.py

@@ -0,0 +1,375 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from dotenv import load_dotenv
+
+from schematico import __version__
+from schematico.cli import runner
+from schematico.cli.projects import (
+    Mode,
+    ProjectNotFoundError,
+    config_path,
+    delete_project,
+    find_projects_by_name,
+    get_default,
+    list_projects,
+    parse_config_filename,
+    resolve_active_project,
+    save_project,
+    set_default,
+)
+from schematico.cli.wizard import run_wizard
+from schematico.logging import get_logger
+
+load_dotenv()
+logger = get_logger("cli.main")
+
+app = typer.Typer(
+    name="schematico",
+    help=(
+        "Generate or discover synthetic data from a JSON schema.\n\n"
+        "Run `schematico help` to see every command and flag in one place."
+    ),
+    no_args_is_help=True,
+    add_completion=False,
+)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"schematico {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def _root(
+    version: bool = typer.Option(
+        False,
+        "--version",
+        "-V",
+        help="Show the version and exit.",
+        callback=_version_callback,
+        is_eager=True,
+    ),
+) -> None:
+    """schematico — generate or discover data from a JSON schema."""
+
+
+def _make_mode_app(mode: Mode) -> typer.Typer:
+    sub = typer.Typer(
+        name=mode,
+        help=f"{mode.capitalize()} records using a project config.",
+        invoke_without_command=True,
+        no_args_is_help=False,
+    )
+
+    @sub.callback()
+    def _default(
+        ctx: typer.Context,
+        config: str | None = typer.Option(
+            None,
+            "--config",
+            "-c",
+            help="Project config name to use (overrides default).",
+        ),
+        output_path: str | None = typer.Option(
+            None, "--output", "-o", help="Override output path."
+        ),
+        count: int | None = typer.Option(
+            None, "--count", "-n", help="Override record count."
+        ),
+        model: str | None = typer.Option(
+            None, "--model", "-m", help="Override AI model."
+        ),
+    ) -> None:
+        if ctx.invoked_subcommand is not None:
+            ctx.obj = {"config": config}
+            return
+        try:
+            cfg = resolve_active_project(mode, name_override=config)
+        except ProjectNotFoundError as e:
+            typer.echo(f"schematico: error: {e}", err=True)
+            raise typer.Exit(1)
+        runner.run(
+            cfg,
+            output_override=output_path,
+            count_override=count,
+            model_override=model,
+        )
+
+    @sub.command("list", help=f"List {mode} configs.")
+    def _list() -> None:
+        default_name = get_default(mode)
+        paths = list_projects(mode)
+        if not paths:
+            typer.echo(f"No {mode} configs found in ./.schematico/.")
+            typer.echo("Run `schematico new` to create one.")
+            return
+        for p in paths:
+            parsed = parse_config_filename(p.name)
+            name = parsed[0] if parsed else p.name
+            marker = "*" if name == default_name else " "
+            typer.echo(f"{marker} {name}  ({p})")
+
+    @sub.command(
+        "use",
+        help=f"Select default {mode} config (`use <name>`) or set model (`use model <id>`).",
+    )
+    def _use(args: list[str] = typer.Argument(None)) -> None:
+        if not args:
+            typer.echo(
+                f"Usage: schematico {mode} use <name> | use model <id>", err=True
+            )
+            raise typer.Exit(2)
+        if args[0] == "model":
+            if len(args) != 2:
+                typer.echo(f"Usage: schematico {mode} use model <id>", err=True)
+                raise typer.Exit(2)
+            try:
+                cfg = resolve_active_project(mode)
+            except ProjectNotFoundError as e:
+                typer.echo(f"schematico: error: {e}", err=True)
+                raise typer.Exit(1)
+            cfg.model = args[1]
+            save_project(cfg)
+            typer.echo(f"Set model={args[1]} in '{cfg.name}.{mode}.toml'.")
+            return
+        if len(args) != 1:
+            typer.echo(f"Usage: schematico {mode} use <name>", err=True)
+            raise typer.Exit(2)
+        name = args[0]
+        if not config_path(name, mode).exists():
+            typer.echo(
+                f"schematico: error: config '{name}.{mode}.toml' not found.", err=True
+            )
+            raise typer.Exit(1)
+        set_default(mode, name)
+        typer.echo(f"Default {mode} config set to '{name}'.")
+
+    @sub.command("delete", help=f"Delete a {mode} config.")
+    def _delete(
+        name: str = typer.Argument(...),
+        yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation."),
+    ) -> None:
+        p = config_path(name, mode)
+        if not p.exists():
+            typer.echo(
+                f"schematico: error: config '{name}.{mode}.toml' not found.",
+                err=True,
+            )
+            raise typer.Exit(1)
+        if not yes and not typer.confirm(f"Delete {p}?", default=False):
+            typer.echo("Aborted.")
+            raise typer.Exit(0)
+        was_default = delete_project(name, mode)
+        msg = f"Deleted '{name}.{mode}.toml'."
+        if was_default:
+            msg += f" Cleared default for `schematico {mode}`."
+        typer.echo(msg)
+
+    @sub.command("output")
+    def _set_output(path: str = typer.Argument(...)) -> None:
+        try:
+            cfg = resolve_active_project(mode)
+        except ProjectNotFoundError as e:
+            typer.echo(f"schematico: error: {e}", err=True)
+            raise typer.Exit(1)
+        cfg.output_path = path
+        save_project(cfg)
+        typer.echo(f"Set output_path={path} in '{cfg.name}.{mode}.toml'.")
+
+    schema_app = typer.Typer(
+        help="Manage the schema for the active config (`import` or `path`).",
+        no_args_is_help=True,
+    )
+
+    @schema_app.command("import")
+    def _schema_import(
+        file: str = typer.Argument(..., help="Path to a JSON schema file.")
+    ) -> None:
+        """Embed a JSON schema file into the active config's [schema] table."""
+        import json as _json
+
+        from schematico.models import model_from_dict
+
+        try:
+            cfg = resolve_active_project(mode)
+        except ProjectNotFoundError as e:
+            typer.echo(f"schematico: error: {e}", err=True)
+            raise typer.Exit(1)
+        p = Path(file)
+        if not p.exists():
+            typer.echo(f"schematico: error: file '{file}' not found.", err=True)
+            raise typer.Exit(1)
+        try:
+            raw = _json.loads(p.read_text(encoding="utf-8"))
+        except _json.JSONDecodeError as e:
+            typer.echo(f"schematico: error: invalid JSON in '{file}': {e}", err=True)
+            raise typer.Exit(1)
+        try:
+            model_from_dict(raw)
+        except ValueError as e:
+            typer.echo(f"schematico: error: {e}", err=True)
+            raise typer.Exit(1)
+        cfg.record_schema = raw
+        cfg.schema_path = ""
+        save_project(cfg)
+        typer.echo(
+            f"Imported schema from '{file}' into '{cfg.name}.{mode}.toml' "
+            f"({len(raw.get('fields', []))} fields)."
+        )
+
+    @schema_app.command("path")
+    def _schema_path(
+        file: str = typer.Argument(..., help="Path to a JSON schema file to reference.")
+    ) -> None:
+        """Reference an external JSON schema file (not embedded)."""
+        from schematico.models import model_from_json
+
+        try:
+            cfg = resolve_active_project(mode)
+        except ProjectNotFoundError as e:
+            typer.echo(f"schematico: error: {e}", err=True)
+            raise typer.Exit(1)
+        try:
+            model_from_json(file)
+        except (FileNotFoundError, ValueError) as e:
+            typer.echo(f"schematico: error: {e}", err=True)
+            raise typer.Exit(1)
+        cfg.schema_path = file
+        cfg.record_schema = {}
+        save_project(cfg)
+        typer.echo(f"Set schema_path={file} in '{cfg.name}.{mode}.toml'.")
+
+    sub.add_typer(schema_app, name="schema")
+
+    return sub
+
+
+app.add_typer(_make_mode_app("generate"), name="generate")
+app.add_typer(_make_mode_app("discover"), name="discover")
+
+
+@app.command("new")
+def new_cmd() -> None:
+    """Interactively create a new project config."""
+    run_wizard()
+
+
+@app.command("delete", help="Delete a project config by name (auto-detects mode).")
+def delete_cmd(
+    name: str = typer.Argument(..., help="Project name (without .toml suffix)."),
+    mode: str | None = typer.Option(
+        None,
+        "--mode",
+        "-m",
+        help="Required when the name exists for both `generate` and `discover`.",
+    ),
+    all_modes: bool = typer.Option(
+        False, "--all", "-a", help="Delete the project for every mode it exists in."
+    ),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation."),
+) -> None:
+    matches = find_projects_by_name(name)
+    if not matches:
+        typer.echo(f"schematico: error: no project named '{name}'.", err=True)
+        raise typer.Exit(1)
+
+    if mode is not None:
+        if mode not in ("generate", "discover"):
+            typer.echo(
+                f"schematico: error: --mode must be 'generate' or 'discover'.",
+                err=True,
+            )
+            raise typer.Exit(2)
+        if mode not in matches:
+            typer.echo(
+                f"schematico: error: no {mode} project named '{name}'.", err=True
+            )
+            raise typer.Exit(1)
+        targets: list[Mode] = [mode]  # type: ignore[list-item]
+    elif all_modes:
+        targets = matches
+    elif len(matches) == 1:
+        targets = matches
+    else:
+        typer.echo(
+            f"schematico: error: '{name}' exists for both modes "
+            f"({', '.join(matches)}). Pass --mode <generate|discover> or --all.",
+            err=True,
+        )
+        raise typer.Exit(1)
+
+    paths = [config_path(name, m) for m in targets]
+    if not yes:
+        typer.echo("About to delete:")
+        for p in paths:
+            typer.echo(f"  - {p}")
+        if not typer.confirm("Proceed?", default=False):
+            typer.echo("Aborted.")
+            raise typer.Exit(0)
+
+    for m in targets:
+        was_default = delete_project(name, m)
+        msg = f"Deleted '{name}.{m}.toml'."
+        if was_default:
+            msg += f" Cleared default for `schematico {m}`."
+        typer.echo(msg)
+
+
+@app.command("list")
+def list_cmd() -> None:
+    """List all schematico project configs (both discover and generate)."""
+    rows: list[tuple[str, str, str, str]] = []  # (marker, mode, name, path)
+    for mode in ("discover", "generate"):
+        default_name = get_default(mode)  # type: ignore[arg-type]
+        for p in list_projects(mode):  # type: ignore[arg-type]
+            parsed = parse_config_filename(p.name)
+            name = parsed[0] if parsed else p.name
+            marker = "*" if name == default_name else " "
+            rows.append((marker, mode, name, str(p)))
+
+    if not rows:
+        typer.echo("No project configs found in ./.schematico/.")
+        typer.echo("Run `schematico new` to create one.")
+        return
+
+    mode_w = max(len(r[1]) for r in rows)
+    name_w = max(len(r[2]) for r in rows)
+    for marker, mode, name, path in rows:
+        typer.echo(f"{marker} [{mode:<{mode_w}}]  {name:<{name_w}}  ({path})")
+
+
+def _walk_help(cmd, ctx, path: str) -> None:
+    import click
+
+    typer.echo("")
+    typer.echo("=" * 72)
+    typer.echo(path)
+    typer.echo("=" * 72)
+    typer.echo(cmd.get_help(ctx))
+    if isinstance(cmd, click.Group):
+        for name, sub in cmd.commands.items():
+            sub_ctx = click.Context(sub, info_name=name, parent=ctx)
+            _walk_help(sub, sub_ctx, f"{path} {name}")
+
+
+@app.command("help")
+def help_cmd() -> None:
+    """Show help for every command and subcommand (full tree)."""
+    import click
+    from typer.main import get_command
+
+    cli = get_command(app)
+    ctx = click.Context(cli, info_name="schematico")
+    _walk_help(cli, ctx, "schematico")
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()

schematico/cli/progress.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import sys
+
+
+class ProgressReporter:
+    def __init__(self, table: str) -> None:
+        self._table = table
+        self._last_len = 0
+        print(
+            f"Generating data for table: '{table}'...",
+            file=sys.stderr,
+            flush=True,
+        )
+
+    def update(self, found: int, total: int, event: str) -> None:
+        if event == "duplicate":
+            msg = f"\r  Found duplicate — retrying...         "
+        else:
+            msg = f"\r  {found} of {total} entries found        "
+
+        print(msg, end="", file=sys.stderr, flush=True)
+        self._last_len = len(msg)
+
+    def done(self, count: int) -> None:
+        print(
+            f"\r  Found data — {count} records generated.          ",
+            file=sys.stderr,
+            flush=True,
+        )
+        print("", file=sys.stderr)

schematico/cli/projects.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+import re
+import tomllib
+from pathlib import Path
+from typing import Any, Literal
+
+import tomli_w
+from pydantic import BaseModel, ConfigDict, Field
+
+Mode = Literal["generate", "discover"]
+MODES: tuple[Mode, ...] = ("generate", "discover")
+
+CONFIG_DIRNAME = ".schematico"
+STATE_FILENAME = "state.toml"
+DEFAULT_ENV_KEY = "PYDANTIC_AI_GATEWAY_API_KEY"
+DEFAULT_COUNT = 25
+
+
+class ProjectConfig(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, protected_namespaces=())
+
+    name: str
+    mode: Mode
+    model: str = ""
+    env_key: str = DEFAULT_ENV_KEY
+    base_url: str = ""
+    output_path: str = f"./{CONFIG_DIRNAME}/output"
+    count: int = DEFAULT_COUNT
+    logfire_token: str = ""
+    schema_path: str = ""
+    record_schema: dict[str, Any] = Field(default_factory=dict, alias="schema")
+
+
+def config_dir(cwd: Path | None = None) -> Path:
+    base = cwd if cwd is not None else Path.cwd()
+    return base / CONFIG_DIRNAME
+
+
+def ensure_config_dir(cwd: Path | None = None) -> Path:
+    d = config_dir(cwd)
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def config_filename(name: str, mode: Mode) -> str:
+    return f"{name}.{mode}.toml"
+
+
+def config_path(name: str, mode: Mode, cwd: Path | None = None) -> Path:
+    return config_dir(cwd) / config_filename(name, mode)
+
+
+def state_path(cwd: Path | None = None) -> Path:
+    return config_dir(cwd) / STATE_FILENAME
+
+
+def load_state(cwd: Path | None = None) -> dict[str, str]:
+    p = state_path(cwd)
+    if not p.exists():
+        return {}
+    with p.open("rb") as f:
+        return tomllib.load(f)
+
+
+def save_state(state: dict[str, str], cwd: Path | None = None) -> None:
+    ensure_config_dir(cwd)
+    p = state_path(cwd)
+    with p.open("wb") as f:
+        tomli_w.dump(state, f)
+
+
+def get_default(mode: Mode, cwd: Path | None = None) -> str | None:
+    return load_state(cwd).get(f"{mode}_default")
+
+
+def set_default(mode: Mode, name: str, cwd: Path | None = None) -> None:
+    state = load_state(cwd)
+    state[f"{mode}_default"] = name
+    save_state(state, cwd)
+
+
+def clear_default(mode: Mode, cwd: Path | None = None) -> bool:
+    state = load_state(cwd)
+    key = f"{mode}_default"
+    if key not in state:
+        return False
+    del state[key]
+    save_state(state, cwd)
+    return True
+
+
+def delete_project(name: str, mode: Mode, cwd: Path | None = None) -> bool:
+    """Delete the config file and clear the mode default if it pointed here.
+
+    Returns True if the deleted project was the current default for its mode.
+    Raises FileNotFoundError if no such config exists.
+    """
+    p = config_path(name, mode, cwd)
+    if not p.exists():
+        raise FileNotFoundError(p)
+    p.unlink()
+    if get_default(mode, cwd) == name:
+        clear_default(mode, cwd)
+        return True
+    return False
+
+
+def find_projects_by_name(name: str, cwd: Path | None = None) -> list[Mode]:
+    """Return modes that have a project with the given name."""
+    return [m for m in MODES if config_path(name, m, cwd).exists()]
+
+
+def load_project(path: Path) -> ProjectConfig:
+    with path.open("rb") as f:
+        raw = tomllib.load(f)
+    return ProjectConfig(**raw)
+
+
+def save_project(config: ProjectConfig, cwd: Path | None = None) -> Path:
+    ensure_config_dir(cwd)
+    p = config_path(config.name, config.mode, cwd)
+    data = config.model_dump(by_alias=True)
+    with p.open("wb") as f:
+        tomli_w.dump(data, f)
+    return p
+
+
+def list_projects(mode: Mode | None = None, cwd: Path | None = None) -> list[Path]:
+    d = config_dir(cwd)
+    if not d.exists():
+        return []
+    suffix = f".{mode}.toml" if mode else ".toml"
+    return sorted(
+        p for p in d.iterdir() if p.name.endswith(suffix) and p.name != STATE_FILENAME
+    )
+
+
+def parse_config_filename(filename: str) -> tuple[str, Mode] | None:
+    m = re.fullmatch(r"(.+)\.(generate|discover)\.toml", filename)
+    if not m:
+        return None
+    return m.group(1), m.group(2)  # type: ignore[return-value]
+
+
+def next_available_name(base: str, mode: Mode, cwd: Path | None = None) -> str:
+    if not config_path(base, mode, cwd).exists():
+        return base
+    n = 2
+    while config_path(f"{base}_{n}", mode, cwd).exists():
+        n += 1
+    return f"{base}_{n}"
+
+
+class ProjectNotFoundError(Exception):
+    pass
+
+
+def resolve_active_project(
+    mode: Mode,
+    name_override: str | None = None,
+    cwd: Path | None = None,
+) -> ProjectConfig:
+    name = name_override or get_default(mode, cwd)
+    if not name:
+        raise ProjectNotFoundError(
+            f"No active {mode} project. Run `schematico new` to create one, "
+            f"or `schematico {mode} use <name>` to select an existing config."
+        )
+    p = config_path(name, mode, cwd)
+    if not p.exists():
+        raise ProjectNotFoundError(f"Config '{p.name}' not found in {config_dir(cwd)}.")
+    return load_project(p)