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

figrecipe/_cli/_convert.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""convert command - Convert between formats."""
+
+from pathlib import Path
+from typing import Optional
+
+import click
+
+
+@click.command()
+@click.argument("source", type=click.Path(exists=True))
+@click.option(
+    "-f",
+    "--format",
+    "fmt",
+    type=click.Choice(["png", "pdf", "svg", "yaml"]),
+    required=True,
+    help="Target format.",
+)
+@click.option(
+    "-o",
+    "--output",
+    type=click.Path(),
+    help="Output path.",
+)
+@click.option(
+    "--dpi",
+    type=int,
+    default=300,
+    help="DPI for raster output (default: 300).",
+)
+def convert(
+    source: str,
+    fmt: str,
+    output: Optional[str],
+    dpi: int,
+) -> None:
+    """Convert between figure formats.
+
+    SOURCE is a .yaml recipe or image file.
+    """
+    source_path = Path(source)
+
+    # Determine output path
+    if output:
+        output_path = Path(output)
+    else:
+        output_path = source_path.with_suffix(f".{fmt}")
+
+    # Handle different source types
+    if source_path.suffix in [".yaml", ".yml"]:
+        _convert_from_recipe(source_path, output_path, fmt, dpi)
+    elif source_path.suffix in [".png", ".pdf", ".svg"]:
+        _convert_image(source_path, output_path, fmt, dpi)
+    else:
+        raise click.ClickException(f"Unsupported source format: {source_path.suffix}")
+
+
+def _convert_from_recipe(source: Path, output: Path, fmt: str, dpi: int) -> None:
+    """Convert from YAML recipe to image format."""
+    import matplotlib.pyplot as plt
+
+    from .. import reproduce
+
+    try:
+        fig, _ = reproduce(source)
+
+        if fmt == "yaml":
+            # Already have YAML, just copy
+            import shutil
+
+            shutil.copy(source, output)
+        else:
+            fig.savefig(output, dpi=dpi, format=fmt)
+
+        # Close the figure (handle both regular and Recording figures)
+        try:
+            plt.close(fig)
+        except TypeError:
+            plt.close("all")
+
+        click.echo(f"Converted: {output}")
+
+    except Exception as e:
+        raise click.ClickException(f"Conversion failed: {e}") from e
+
+
+def _convert_image(source: Path, output: Path, fmt: str, dpi: int) -> None:
+    """Convert between image formats."""
+    if fmt == "yaml":
+        raise click.ClickException(
+            "Cannot convert image to YAML. Use a recipe file instead."
+        )
+
+    try:
+        from PIL import Image
+
+        img = Image.open(source)
+
+        if fmt == "pdf":
+            img.save(output, "PDF", resolution=dpi)
+        elif fmt == "svg":
+            raise click.ClickException(
+                "Cannot convert raster image to SVG. Use a recipe file instead."
+            )
+        else:
+            img.save(output, fmt.upper())
+
+        click.echo(f"Converted: {output}")
+
+    except ImportError:
+        raise click.ClickException(
+            "Image conversion requires Pillow. Install with: pip install figrecipe[imaging]"
+        ) from None
+    except Exception as e:
+        raise click.ClickException(f"Conversion failed: {e}") from e

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")