figrecipe 0.7.4__py3-none-any.whl → 0.9.0__py3-none-any.whl

figrecipe/_cli/_crop.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""crop command - Crop image to content."""
+
+from pathlib import Path
+from typing import Optional
+
+import click
+
+
+@click.command()
+@click.argument("image", type=click.Path(exists=True))
+@click.option(
+    "-o",
+    "--output",
+    type=click.Path(),
+    help="Output path for cropped image.",
+)
+@click.option(
+    "--margin",
+    type=str,
+    default="1mm",
+    help="Margin around content (e.g., '2mm' or '10px'). Default: 1mm.",
+)
+@click.option(
+    "--overwrite",
+    is_flag=True,
+    help="Overwrite the input file.",
+)
+def crop(
+    image: str,
+    output: Optional[str],
+    margin: str,
+    overwrite: bool,
+) -> None:
+    """Crop an image to its content area.
+
+    IMAGE is the path to the image file (PNG, PDF, etc.).
+    """
+    try:
+        from .. import crop as fr_crop
+    except ImportError:
+        raise click.ClickException(
+            "Crop requires Pillow. Install with: pip install figrecipe[imaging]"
+        ) from None
+
+    image_path = Path(image)
+
+    # Parse margin
+    margin_mm = None
+    margin_px = None
+
+    if margin.endswith("mm"):
+        margin_mm = float(margin[:-2])
+    elif margin.endswith("px"):
+        margin_px = int(margin[:-2])
+    else:
+        # Default to mm
+        try:
+            margin_mm = float(margin)
+        except ValueError:
+            raise click.ClickException(f"Invalid margin format: {margin}") from None
+
+    # Determine output path
+    if output:
+        output_path = Path(output)
+    elif overwrite:
+        output_path = None  # Will overwrite in place
+    else:
+        output_path = image_path.with_stem(f"{image_path.stem}_cropped")
+
+    try:
+        result = fr_crop(
+            image_path,
+            output_path=output_path,
+            margin_mm=margin_mm,
+            margin_px=margin_px,
+            overwrite=overwrite,
+        )
+        click.echo(f"Cropped: {result}")
+    except Exception as e:
+        raise click.ClickException(f"Crop failed: {e}") from e

figrecipe/_cli/_edit.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""edit command - Launch GUI editor."""
+
+from pathlib import Path
+from typing import Optional
+
+import click
+
+
+@click.command()
+@click.argument("source", type=click.Path(exists=True), required=False)
+@click.option(
+    "--port",
+    type=int,
+    default=5050,
+    help="Server port (default: 5050).",
+)
+@click.option(
+    "--host",
+    type=str,
+    default="127.0.0.1",
+    help="Host to bind (default: 127.0.0.1).",
+)
+@click.option(
+    "--no-browser",
+    is_flag=True,
+    help="Don't auto-open browser.",
+)
+@click.option(
+    "--desktop",
+    is_flag=True,
+    help="Launch as native desktop window (requires pywebview).",
+)
+def edit(
+    source: Optional[str],
+    port: int,
+    host: str,
+    no_browser: bool,
+    desktop: bool,
+) -> None:
+    """Launch interactive GUI editor.
+
+    SOURCE is the optional path to a .yaml recipe file or bundle.
+    If not provided, creates a new blank figure.
+    """
+    try:
+        from .. import edit as fr_edit
+    except ImportError:
+        raise click.ClickException(
+            "Editor requires Flask. Install with: pip install figrecipe[editor]"
+        ) from None
+
+    source_path = Path(source) if source else None
+
+    if desktop:
+        click.echo("Starting editor in desktop mode...")
+    else:
+        click.echo(f"Starting editor on http://{host}:{port}")
+
+    try:
+        fr_edit(
+            source_path,
+            port=port,
+            host=host,
+            open_browser=not no_browser,
+            desktop=desktop,
+        )
+    except Exception as e:
+        raise click.ClickException(f"Editor failed: {e}") from e

figrecipe/_cli/_extract.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""extract command - Extract plotted data from recipes."""
+
+import json
+from pathlib import Path
+from typing import Optional
+
+import click
+
+
+@click.command()
+@click.argument("source", type=click.Path(exists=True))
+@click.option(
+    "-o",
+    "--output",
+    type=click.Path(),
+    help="Output directory for extracted data.",
+)
+@click.option(
+    "-f",
+    "--format",
+    "fmt",
+    type=click.Choice(["csv", "npz", "json"]),
+    default="csv",
+    help="Data format (default: csv).",
+)
+@click.option(
+    "--axes",
+    type=str,
+    help="Specific axes to extract (e.g., ax_0_0).",
+)
+def extract(
+    source: str,
+    output: Optional[str],
+    fmt: str,
+    axes: Optional[str],
+) -> None:
+    """Extract plotted data arrays from a recipe.
+
+    SOURCE is the path to a .yaml recipe file.
+    """
+
+    from .. import extract_data
+
+    source_path = Path(source)
+
+    try:
+        data = extract_data(source_path)
+    except Exception as e:
+        raise click.ClickException(f"Failed to extract data: {e}") from e
+
+    if not data:
+        click.echo("No data found in recipe.")
+        return
+
+    # Determine output directory
+    if output:
+        output_dir = Path(output)
+    else:
+        output_dir = source_path.parent / f"{source_path.stem}_data"
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Export data
+    for call_id, call_data in data.items():
+        if axes and not call_id.startswith(axes):
+            continue
+
+        if fmt == "json":
+            _save_json(output_dir / f"{call_id}.json", call_data)
+        elif fmt == "npz":
+            _save_npz(output_dir / f"{call_id}.npz", call_data)
+        else:  # csv
+            _save_csv(output_dir / f"{call_id}.csv", call_data)
+
+        click.echo(f"Extracted: {call_id}")
+
+    click.echo(f"\nData saved to: {output_dir}")
+
+
+def _save_json(path: Path, data: dict) -> None:
+    """Save data as JSON."""
+    import numpy as np
+
+    def convert(obj):
+        if isinstance(obj, np.ndarray):
+            return obj.tolist()
+        return obj
+
+    with open(path, "w") as f:
+        json.dump({k: convert(v) for k, v in data.items()}, f, indent=2)
+
+
+def _save_npz(path: Path, data: dict) -> None:
+    """Save data as NPZ."""
+    import numpy as np
+
+    np.savez(path, **data)
+
+
+def _save_csv(path: Path, data: dict) -> None:
+    """Save data as CSV."""
+    import numpy as np
+
+    # Try to create a table from the data
+    arrays = {k: np.asarray(v) for k, v in data.items() if hasattr(v, "__len__")}
+
+    if not arrays:
+        return
+
+    # Find max length
+    max_len = max(len(a.flatten()) for a in arrays.values())
+
+    with open(path, "w") as f:
+        # Header
+        f.write(",".join(arrays.keys()) + "\n")
+
+        # Data rows
+        for i in range(max_len):
+            row = []
+            for arr in arrays.values():
+                flat = arr.flatten()
+                if i < len(flat):
+                    row.append(str(flat[i]))
+                else:
+                    row.append("")
+            f.write(",".join(row) + "\n")

figrecipe/_cli/_fonts.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""fonts command - Font management."""
+
+from typing import Optional
+
+import click
+
+
+@click.command()
+@click.option(
+    "--check",
+    type=str,
+    help="Check if a specific font is available.",
+)
+@click.option(
+    "--search",
+    type=str,
+    help="Search for fonts matching a pattern.",
+)
+def fonts(check: Optional[str], search: Optional[str]) -> None:
+    """List or check available fonts."""
+    from .. import check_font, list_available_fonts
+
+    if check:
+        available = check_font(check)
+        if available:
+            click.echo(f"Font '{check}' is available.")
+        else:
+            click.echo(f"Font '{check}' is NOT available.")
+            raise SystemExit(1)
+        return
+
+    all_fonts = list_available_fonts()
+
+    if search:
+        pattern = search.lower()
+        matching = [f for f in all_fonts if pattern in f.lower()]
+        click.echo(f"Fonts matching '{search}':")
+        for font in sorted(matching):
+            click.echo(f"  {font}")
+        click.echo(f"\nFound {len(matching)} matching fonts.")
+    else:
+        click.echo("Available fonts:")
+        for font in sorted(all_fonts):
+            click.echo(f"  {font}")
+        click.echo(f"\nTotal: {len(all_fonts)} fonts.")

figrecipe/_cli/_info.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""info command - Inspect recipe metadata."""
+
+import json
+from pathlib import Path
+
+import click
+
+
+@click.command()
+@click.argument("source", type=click.Path(exists=True))
+@click.option(
+    "--json",
+    "as_json",
+    is_flag=True,
+    help="Output as JSON.",
+)
+@click.option(
+    "-v",
+    "--verbose",
+    is_flag=True,
+    help="Show detailed information.",
+)
+def info(source: str, as_json: bool, verbose: bool) -> None:
+    """Show information about a recipe.
+
+    SOURCE is the path to a .yaml recipe file.
+    """
+    from .. import info as fr_info
+
+    source_path = Path(source)
+
+    try:
+        recipe_info = fr_info(source_path)
+    except Exception as e:
+        raise click.ClickException(f"Failed to load recipe: {e}") from e
+
+    if as_json:
+        click.echo(json.dumps(recipe_info, indent=2, default=str))
+    else:
+        _print_info(recipe_info, verbose)
+
+
+def _print_info(info: dict, verbose: bool) -> None:
+    """Print recipe info in human-readable format."""
+    click.echo(f"Recipe Version: {info.get('figrecipe_version', 'unknown')}")
+    click.echo(f"Figure ID: {info.get('id', 'unknown')}")
+    click.echo(f"Created: {info.get('created', 'unknown')}")
+    click.echo(f"Matplotlib: {info.get('matplotlib_version', 'unknown')}")
+
+    if "figure" in info:
+        fig = info["figure"]
+        click.echo(f"Figure Size: {fig.get('figsize', 'unknown')}")
+        click.echo(f"DPI: {fig.get('dpi', 'unknown')}")
+
+    if "axes" in info:
+        click.echo(f"Axes Count: {len(info['axes'])}")
+
+        if verbose:
+            for ax_key, ax_info in info["axes"].items():
+                click.echo(f"\n  {ax_key}:")
+                if "calls" in ax_info:
+                    for call in ax_info["calls"]:
+                        func = call.get("function", "unknown")
+                        call_id = call.get("id", "")
+                        click.echo(f"    - {func} ({call_id})")

figrecipe/_cli/_main.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Main CLI entry point for figrecipe."""
+
+import click
+
+from .. import __version__
+from ._compose import compose
+from ._convert import convert
+from ._crop import crop
+from ._edit import edit
+from ._extract import extract
+from ._fonts import fonts
+from ._info import info
+from ._reproduce import reproduce
+from ._style import style
+from ._validate import validate
+from ._version import version as version_cmd
+
+
+@click.group(
+    invoke_without_command=True,
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+@click.option("--version", "-V", is_flag=True, help="Show version and exit.")
+@click.pass_context
+def main(ctx: click.Context, version: bool) -> None:
+    """figrecipe - Reproducible matplotlib figures.
+
+    A command-line interface for creating, reproducing, and editing
+    matplotlib figures using YAML recipes.
+
+    When run without a subcommand, launches the GUI editor.
+    """
+    if version:
+        click.echo(f"figrecipe {__version__}")
+        ctx.exit(0)
+
+    if ctx.invoked_subcommand is None:
+        ctx.invoke(edit)
+
+
+# Register commands
+main.add_command(reproduce)
+main.add_command(info)
+main.add_command(extract)
+main.add_command(validate)
+main.add_command(edit)
+main.add_command(crop)
+main.add_command(compose)
+main.add_command(style)
+main.add_command(convert)
+main.add_command(fonts)
+main.add_command(version_cmd)
+
+
+if __name__ == "__main__":
+    main()

figrecipe/_cli/_reproduce.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""reproduce command - Recreate figure from recipe."""
+
+from pathlib import Path
+from typing import Optional
+
+import click
+
+
+@click.command()
+@click.argument("source", type=click.Path(exists=True))
+@click.option(
+    "-o",
+    "--output",
+    type=click.Path(),
+    help="Output path for the reproduced figure.",
+)
+@click.option(
+    "-f",
+    "--format",
+    "fmt",
+    type=click.Choice(["png", "pdf", "svg"]),
+    default="png",
+    help="Output format (default: png).",
+)
+@click.option(
+    "--dpi",
+    type=int,
+    default=300,
+    help="DPI for raster output (default: 300).",
+)
+@click.option(
+    "--show",
+    is_flag=True,
+    help="Display the figure interactively.",
+)
+def reproduce(
+    source: str,
+    output: Optional[str],
+    fmt: str,
+    dpi: int,
+    show: bool,
+) -> None:
+    """Reproduce a figure from a YAML recipe.
+
+    SOURCE is the path to a .yaml recipe file or bundle directory.
+    """
+    import matplotlib.pyplot as plt
+
+    from .. import reproduce as fr_reproduce
+
+    source_path = Path(source)
+
+    # Reproduce the figure
+    try:
+        fig, axes = fr_reproduce(source_path)
+    except Exception as e:
+        raise click.ClickException(f"Failed to reproduce: {e}") from e
+
+    # Determine output path
+    if output:
+        output_path = Path(output)
+    else:
+        output_path = source_path.with_suffix(f".reproduced.{fmt}")
+
+    # Save or show
+    if show:
+        plt.show()
+    else:
+        fig.savefig(output_path, dpi=dpi, format=fmt)
+        click.echo(f"Saved: {output_path}")
+
+    # Close the figure (handle both regular and Recording figures)
+    try:
+        plt.close(fig)
+    except TypeError:
+        # RecordingFigure wrapper - close all instead
+        plt.close("all")

figrecipe/_cli/_style.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""style command - Style management subcommands."""
+
+
+import click
+
+
+@click.group()
+def style() -> None:
+    """Manage figure styles and presets."""
+    pass
+
+
+@style.command("list")
+def list_styles() -> None:
+    """List available style presets."""
+    from .. import list_presets
+
+    presets = list_presets()
+
+    click.echo("Available style presets:")
+    for preset in presets:
+        click.echo(f"  - {preset}")
+
+
+@style.command("show")
+@click.argument("name")
+def show_style(name: str) -> None:
+    """Show details of a style preset.
+
+    NAME is the preset name (e.g., SCITEX, MATPLOTLIB).
+    """
+    from ruamel.yaml import YAML
+
+    from ..styles._style_loader import load_preset
+
+    try:
+        style_dict = load_preset(name)
+    except Exception as e:
+        raise click.ClickException(f"Failed to load preset '{name}': {e}") from e
+
+    yaml = YAML()
+    yaml.default_flow_style = False
+
+    click.echo(f"Style preset: {name}\n")
+
+    import io
+
+    stream = io.StringIO()
+    yaml.dump(style_dict, stream)
+    click.echo(stream.getvalue())
+
+
+@style.command("apply")
+@click.argument("name")
+def apply_style_cmd(name: str) -> None:
+    """Apply a style preset globally.
+
+    NAME is the preset name (e.g., SCITEX, MATPLOTLIB).
+    """
+    from .. import load_style
+
+    try:
+        load_style(name)
+        click.echo(f"Applied style: {name}")
+    except Exception as e:
+        raise click.ClickException(f"Failed to apply style: {e}") from e
+
+
+@style.command("reset")
+def reset_style() -> None:
+    """Reset to default matplotlib style."""
+    from .. import unload_style
+
+    unload_style()
+    click.echo("Style reset to defaults.")

figrecipe/_cli/_validate.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""validate command - Verify recipe reproducibility."""
+
+from pathlib import Path
+
+import click
+
+
+@click.command()
+@click.argument("source", type=click.Path(exists=True))
+@click.option(
+    "--threshold",
+    type=float,
+    default=100.0,
+    help="MSE threshold for validation (default: 100).",
+)
+@click.option(
+    "--strict",
+    is_flag=True,
+    help="Fail on any difference.",
+)
+@click.option(
+    "-q",
+    "--quiet",
+    is_flag=True,
+    help="Only output pass/fail status.",
+)
+def validate(
+    source: str,
+    threshold: float,
+    strict: bool,
+    quiet: bool,
+) -> None:
+    """Validate that a recipe reproduces its original figure.
+
+    SOURCE is the path to a .yaml recipe file.
+    """
+    from .. import validate as fr_validate
+
+    source_path = Path(source)
+
+    if strict:
+        threshold = 0.0
+
+    try:
+        result = fr_validate(source_path, mse_threshold=threshold)
+    except Exception as e:
+        raise click.ClickException(f"Validation failed: {e}") from e
+
+    if quiet:
+        if result.valid:
+            click.echo("PASS")
+        else:
+            click.echo("FAIL")
+            raise SystemExit(1)
+    else:
+        click.echo(f"Validation: {'PASS' if result.valid else 'FAIL'}")
+        click.echo(f"MSE: {result.mse:.6f}")
+        click.echo(f"Threshold: {threshold}")
+
+        if hasattr(result, "message") and result.message:
+            click.echo(f"Message: {result.message}")
+
+        if not result.valid:
+            raise SystemExit(1)