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

figrecipe/_dev/demo_plotters/plot_stem.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""stem: stem plot demo."""
+
+import numpy as np
+
+
+def plot_stem(plt, rng, ax=None):
+    """Stem plot demo.
+
+    Demonstrates: ax.stem()
+    """
+    if ax is None:
+        fig, ax = plt.subplots()
+    else:
+        fig = ax.get_figure() if hasattr(ax, "get_figure") else ax.fig
+
+    x = np.arange(10)
+    y = rng.uniform(0, 1, 10)
+    ax.stem(x, y, id="stem")
+    ax.set_xlabel("X")
+    ax.set_ylabel("Y")
+    ax.set_title("stem")
+    return fig, ax
+
+
+# EOF

figrecipe/_dev/demo_plotters/plot_step.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""step: step plot demo."""
+
+import numpy as np
+
+
+def plot_step(plt, rng, ax=None):
+    """Step plot demo.
+
+    Demonstrates: ax.step()
+    """
+    if ax is None:
+        fig, ax = plt.subplots()
+    else:
+        fig = ax.get_figure() if hasattr(ax, "get_figure") else ax.fig
+
+    x = np.arange(10)
+    y = rng.uniform(0, 1, 10)
+    ax.step(x, y, where="mid", id="step")
+    ax.set_xlabel("X")
+    ax.set_ylabel("Y")
+    ax.set_title("step")
+    return fig, ax
+
+
+# EOF

figrecipe/_dev/demo_plotters/plot_streamplot.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""streamplot: streamline plot demo."""
+
+import numpy as np
+
+
+def plot_streamplot(plt, rng, ax=None):
+    """Streamline plot demo.
+
+    Demonstrates: ax.streamplot()
+    """
+    if ax is None:
+        fig, ax = plt.subplots()
+    else:
+        fig = ax.get_figure() if hasattr(ax, "get_figure") else ax.fig
+
+    x = np.linspace(-3, 3, 30)
+    y = np.linspace(-3, 3, 30)
+    X, Y = np.meshgrid(x, y)
+    U = -Y
+    V = X
+    ax.streamplot(X, Y, U, V, id="streamplot")
+    ax.set_xlabel("X")
+    ax.set_ylabel("Y")
+    ax.set_title("streamplot")
+    return fig, ax
+
+
+# EOF

figrecipe/_dev/demo_plotters/plot_tricontour.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tricontour: triangular contour demo."""
+
+import numpy as np
+
+
+def plot_tricontour(plt, rng, ax=None):
+    """Triangular contour demo.
+
+    Demonstrates: ax.tricontour()
+    """
+    if ax is None:
+        fig, ax = plt.subplots()
+    else:
+        fig = ax.get_figure() if hasattr(ax, "get_figure") else ax.fig
+
+    x = rng.uniform(0, 1, 50)
+    y = rng.uniform(0, 1, 50)
+    z = np.sin(x * 2 * np.pi) * np.cos(y * 2 * np.pi)
+    ax.tricontour(x, y, z, id="tricontour")
+    ax.set_xlabel("X")
+    ax.set_ylabel("Y")
+    ax.set_title("tricontour")
+    return fig, ax
+
+
+# EOF

figrecipe/_dev/demo_plotters/plot_tricontourf.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tricontourf: filled triangular contour demo."""
+
+import numpy as np
+
+
+def plot_tricontourf(plt, rng, ax=None):
+    """Filled triangular contour demo.
+
+    Demonstrates: ax.tricontourf()
+    """
+    if ax is None:
+        fig, ax = plt.subplots()
+    else:
+        fig = ax.get_figure() if hasattr(ax, "get_figure") else ax.fig
+
+    x = rng.uniform(0, 1, 50)
+    y = rng.uniform(0, 1, 50)
+    z = np.sin(x * 2 * np.pi) * np.cos(y * 2 * np.pi)
+    ax.tricontourf(x, y, z, id="tricontourf")
+    ax.set_xlabel("X")
+    ax.set_ylabel("Y")
+    ax.set_title("tricontourf")
+    return fig, ax
+
+
+# EOF

figrecipe/_dev/demo_plotters/plot_tripcolor.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tripcolor: unstructured triangular grid demo."""
+
+import numpy as np
+
+
+def plot_tripcolor(plt, rng, ax=None):
+    """Unstructured triangular grid demo.
+
+    Demonstrates: ax.tripcolor()
+    """
+    if ax is None:
+        fig, ax = plt.subplots()
+    else:
+        fig = ax.get_figure() if hasattr(ax, "get_figure") else ax.fig
+
+    # Create random triangulation
+    x = rng.uniform(0, 1, 30)
+    y = rng.uniform(0, 1, 30)
+    z = np.sin(x * 2 * np.pi) * np.cos(y * 2 * np.pi)
+    ax.tripcolor(x, y, z, id="tripcolor")
+    ax.set_xlabel("X")
+    ax.set_ylabel("Y")
+    ax.set_title("tripcolor")
+    return fig, ax
+
+
+# EOF

figrecipe/_dev/demo_plotters/plot_triplot.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""triplot: triangular mesh plot demo."""
+
+
+def plot_triplot(plt, rng, ax=None):
+    """Triangular mesh plot demo.
+
+    Demonstrates: ax.triplot()
+    """
+    if ax is None:
+        fig, ax = plt.subplots()
+    else:
+        fig = ax.get_figure() if hasattr(ax, "get_figure") else ax.fig
+
+    x = rng.uniform(0, 1, 20)
+    y = rng.uniform(0, 1, 20)
+    ax.triplot(x, y, id="triplot")
+    ax.set_xlabel("X")
+    ax.set_ylabel("Y")
+    ax.set_title("triplot")
+    return fig, ax
+
+
+# EOF

figrecipe/_dev/demo_plotters/plot_violinplot.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""violinplot: violin plot demo."""
+
+
+def plot_violinplot(plt, rng, ax=None):
+    """Violin plot demo.
+
+    Demonstrates: ax.violinplot()
+    """
+    if ax is None:
+        fig, ax = plt.subplots()
+    else:
+        fig = ax.get_figure() if hasattr(ax, "get_figure") else ax.fig
+
+    data = [rng.normal(i, 1, 100) for i in range(4)]
+    # Modern style: show box inside (default from SCITEX style)
+    ax.violinplot(data, id="violinplot")
+    ax.set_xlabel("Group")
+    ax.set_ylabel("Value")
+    ax.set_title("violinplot")
+    return fig, ax
+
+
+# EOF

figrecipe/_dev/demo_plotters/plot_xcorr.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""xcorr: cross-correlation demo."""
+
+
+def plot_xcorr(plt, rng, ax=None):
+    """Cross-correlation demo.
+
+    Demonstrates: ax.xcorr()
+    """
+    if ax is None:
+        fig, ax = plt.subplots()
+    else:
+        fig = ax.get_figure() if hasattr(ax, "get_figure") else ax.fig
+
+    x = rng.normal(0, 1, 100)
+    y = rng.normal(0, 1, 100)
+    ax.xcorr(x, y, maxlags=50, id="xcorr")
+    ax.set_xlabel("Lag")
+    ax.set_ylabel("Cross-correlation")
+    ax.set_title("xcorr")
+    return fig, ax
+
+
+# EOF

figrecipe/_editor/__init__.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+figrecipe GUI Editor - Interactive figure styling with hitmap-based element selection.
+
+This module provides a Flask-based web editor for interactively adjusting
+figure styles. It supports both live RecordingFigure objects and saved
+recipe files (.yaml).
+
+Usage
+-----
+>>> import figrecipe as fr
+>>> fig, ax = fr.subplots()
+>>> ax.plot(x, y, id='data')
+>>> fr.edit(fig)  # Opens browser with interactive editor
+
+>>> # Or from saved recipe
+>>> fr.edit('recipe.yaml')
+"""
+
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+
+from .._wrappers import RecordingFigure
+from ._flask_app import FigureEditor
+
+
+def edit(
+    source: Union[RecordingFigure, str, Path],
+    style: Optional[Union[str, Dict[str, Any]]] = None,
+    port: int = 5050,
+    open_browser: bool = True,
+) -> Dict[str, Any]:
+    """
+    Launch interactive GUI editor for figure styling.
+
+    Opens a browser-based editor that allows interactive adjustment of
+    figure styles using hitmap-based element selection.
+
+    Parameters
+    ----------
+    source : RecordingFigure, str, or Path
+        Either a live RecordingFigure object or path to a .yaml recipe file.
+    style : str or dict, optional
+        Style preset name (e.g., 'SCITEX', 'SCITEX_DARK') or style dict.
+        If None, uses the currently loaded global style.
+    port : int, optional
+        Flask server port (default: 5050). Auto-finds available port if occupied.
+    open_browser : bool, optional
+        Whether to open browser automatically (default: True).
+
+    Returns
+    -------
+    dict
+        Final style overrides after editing session.
+
+    Raises
+    ------
+    ImportError
+        If Flask is not installed.
+    TypeError
+        If source is neither RecordingFigure nor valid path.
+    FileNotFoundError
+        If recipe file path does not exist.
+
+    Examples
+    --------
+    Edit a live figure:
+
+    >>> import figrecipe as fr
+    >>> fig, ax = fr.subplots()
+    >>> ax.plot([1, 2, 3], [1, 4, 9], id='quadratic')
+    >>> overrides = fr.edit(fig)
+
+    Edit a saved recipe:
+
+    >>> overrides = fr.edit('my_figure.yaml')
+
+    With explicit style:
+
+    >>> overrides = fr.edit(fig, style='SCITEX_DARK')
+    """
+    import importlib.util
+
+    if importlib.util.find_spec("flask") is None:
+        raise ImportError(
+            "Flask is required for the GUI editor. "
+            "Install with: pip install figrecipe[editor] or pip install flask"
+        )
+
+    import tempfile
+
+    from ._flask_app import FigureEditor
+    from ._hitmap import generate_hitmap, hitmap_to_base64
+
+    # Handle different input types
+    fig, recipe_path = _resolve_source(source)
+
+    # Load style if string preset name provided
+    style_dict = _resolve_style(style)
+
+    # Save static PNG FIRST - this is the source of truth for initial display
+    mpl_fig = fig.fig if hasattr(fig, "fig") else fig
+    static_png_path = Path(tempfile.mktemp(suffix="_figrecipe_static.png"))
+    mpl_fig.savefig(static_png_path, format="png", dpi=150, bbox_inches="tight")
+
+    # Generate hitmap ONCE at this point
+    # Pass RecordingFigure to preserve record for plot type detection
+    hitmap, color_map = generate_hitmap(fig)
+    hitmap_base64 = hitmap_to_base64(hitmap)
+
+    # Create and run editor with pre-rendered static PNG
+    editor = FigureEditor(
+        fig=fig,
+        recipe_path=recipe_path,
+        style=style_dict,
+        port=port,
+        static_png_path=static_png_path,
+        hitmap_base64=hitmap_base64,
+        color_map=color_map,
+    )
+
+    return editor.run(open_browser=open_browser)
+
+
+def _resolve_source(source: Union[RecordingFigure, str, Path]):
+    """
+    Resolve source to figure and optional recipe path.
+
+    Parameters
+    ----------
+    source : RecordingFigure, str, or Path
+        Input source.
+
+    Returns
+    -------
+    tuple
+        (RecordingFigure or None, Path or None)
+    """
+    if isinstance(source, RecordingFigure):
+        return source, None
+
+    # Handle matplotlib Figure (e.g., from reproduce())
+    from matplotlib.figure import Figure
+
+    if isinstance(source, Figure):
+        from .._recorder import FigureRecord, Recorder
+        from .._wrappers._figure import RecordingFigure as RF
+
+        wrapped_fig = RF.__new__(RF)
+        wrapped_fig._fig = source
+        wrapped_fig._axes = [[ax] for ax in source.axes]  # 2D list format
+        wrapped_fig._recorder = Recorder()
+        wrapped_fig._recorder._figure_record = FigureRecord(
+            figsize=tuple(source.get_size_inches()),
+            dpi=int(source.dpi),
+        )
+        return wrapped_fig, None
+
+    # Assume it's a path
+    path = Path(source)
+    if not path.exists():
+        raise FileNotFoundError(f"Recipe file not found: {path}")
+
+    if path.suffix.lower() not in (".yaml", ".yml"):
+        raise ValueError(f"Expected .yaml or .yml file, got: {path.suffix}")
+
+    # Load recipe and reproduce figure
+    from .._reproducer import reproduce
+
+    fig, axes = reproduce(path)
+
+    # Wrap in RecordingFigure if needed
+    if not isinstance(fig, RecordingFigure):
+        from .._wrappers._figure import RecordingFigure as RF
+
+        # Create a minimal wrapper
+        wrapped_fig = RF.__new__(RF)
+        wrapped_fig.fig = fig
+        wrapped_fig._axes = axes if isinstance(axes, list) else [axes]
+        from .._recorder import FigureRecord
+
+        wrapped_fig.record = FigureRecord(
+            figsize=fig.get_size_inches().tolist(),
+            dpi=fig.dpi,
+        )
+        fig = wrapped_fig
+
+    return fig, path
+
+
+def _resolve_style(
+    style: Optional[Union[str, Dict[str, Any]]],
+) -> Optional[Dict[str, Any]]:
+    """
+    Resolve style to dictionary.
+
+    Parameters
+    ----------
+    style : str, dict, or None
+        Style preset name or dict.
+
+    Returns
+    -------
+    dict or None
+        Style dictionary.
+    """
+    if style is None:
+        # Use global style if loaded
+        from ..styles._style_loader import _STYLE_CACHE
+
+        if _STYLE_CACHE is not None:
+            from ..styles import to_subplots_kwargs
+
+            return to_subplots_kwargs(_STYLE_CACHE)
+        return None
+
+    if isinstance(style, dict):
+        return style
+
+    if isinstance(style, str):
+        from ..styles import load_style, to_subplots_kwargs
+
+        loaded = load_style(style)
+        return to_subplots_kwargs(loaded) if loaded else None
+
+    raise TypeError(f"style must be str, dict, or None, got {type(style)}")
+
+
+__all__ = ["edit", "FigureEditor"]