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

figrecipe/_editor/_helpers.py

@@ -0,0 +1,242 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Helper functions for the figure editor.
+"""
+
+from typing import Any, Dict, Optional
+
+
+def get_form_values_from_style(style: Dict[str, Any]) -> Dict[str, Any]:
+    """Extract form field values from a style dictionary.
+
+    Maps style dictionary values to HTML form input IDs.
+
+    Parameters
+    ----------
+    style : dict
+        Style configuration dictionary
+
+    Returns
+    -------
+    dict
+        Mapping of form input IDs to values
+    """
+    values = {}
+
+    # Axes dimensions
+    if "axes" in style:
+        values["axes_width_mm"] = style["axes"].get("width_mm", 80)
+        values["axes_height_mm"] = style["axes"].get("height_mm", 55)
+        values["axes_thickness_mm"] = style["axes"].get("thickness_mm", 0.2)
+
+    # Margins
+    if "margins" in style:
+        values["margins_left_mm"] = style["margins"].get("left_mm", 12)
+        values["margins_right_mm"] = style["margins"].get("right_mm", 3)
+        values["margins_bottom_mm"] = style["margins"].get("bottom_mm", 10)
+        values["margins_top_mm"] = style["margins"].get("top_mm", 3)
+
+    # Spacing
+    if "spacing" in style:
+        values["spacing_horizontal_mm"] = style["spacing"].get("horizontal_mm", 8)
+        values["spacing_vertical_mm"] = style["spacing"].get("vertical_mm", 8)
+
+    # Fonts
+    if "fonts" in style:
+        values["fonts_family"] = style["fonts"].get("family", "Arial")
+        values["fonts_axis_label_pt"] = style["fonts"].get("axis_label_pt", 7)
+        values["fonts_tick_label_pt"] = style["fonts"].get("tick_label_pt", 6)
+        values["fonts_title_pt"] = style["fonts"].get("title_pt", 8)
+        values["fonts_legend_pt"] = style["fonts"].get("legend_pt", 6)
+
+    # Ticks
+    if "ticks" in style:
+        values["ticks_length_mm"] = style["ticks"].get("length_mm", 1.0)
+        values["ticks_thickness_mm"] = style["ticks"].get("thickness_mm", 0.2)
+        values["ticks_direction"] = style["ticks"].get("direction", "out")
+
+    # Lines
+    if "lines" in style:
+        values["lines_trace_mm"] = style["lines"].get("trace_mm", 0.2)
+
+    # Markers
+    if "markers" in style:
+        values["markers_size_mm"] = style["markers"].get("size_mm", 0.8)
+
+    # Output
+    if "output" in style:
+        values["output_dpi"] = style["output"].get("dpi", 300)
+
+    # Behavior
+    if "behavior" in style:
+        values["behavior_hide_top_spine"] = style["behavior"].get(
+            "hide_top_spine", True
+        )
+        values["behavior_hide_right_spine"] = style["behavior"].get(
+            "hide_right_spine", True
+        )
+        values["behavior_grid"] = style["behavior"].get("grid", False)
+
+    # Legend
+    if "legend" in style:
+        values["legend_frameon"] = style["legend"].get("frameon", True)
+
+    return values
+
+
+def render_with_overrides(
+    fig, overrides: Optional[Dict[str, Any]], dark_mode: bool = False
+):
+    """
+    Re-render figure with overrides applied directly.
+
+    Applies style overrides directly to the existing figure for reliable rendering.
+    """
+    import base64
+    import io
+    import warnings
+
+    from matplotlib.backends.backend_agg import FigureCanvasAgg
+    from PIL import Image
+
+    from ._bbox import extract_bboxes
+
+    # Get the underlying matplotlib figure
+    new_fig = fig.fig if hasattr(fig, "fig") else fig
+
+    # Safety check: validate figure size before rendering
+    fig_width, fig_height = new_fig.get_size_inches()
+    dpi = 150
+    pixel_width = fig_width * dpi
+    pixel_height = fig_height * dpi
+
+    # Sanity check: prevent enormous figures (max 10000x10000 pixels)
+    MAX_PIXELS = 10000
+    if pixel_width > MAX_PIXELS or pixel_height > MAX_PIXELS:
+        # Reset to reasonable size
+        new_fig.set_size_inches(
+            min(fig_width, MAX_PIXELS / dpi), min(fig_height, MAX_PIXELS / dpi)
+        )
+
+    # Switch to Agg backend to avoid Tkinter thread issues
+    new_fig.set_canvas(FigureCanvasAgg(new_fig))
+
+    # Disable constrained_layout if present (can cause rendering issues)
+    layout_engine = new_fig.get_layout_engine()
+    if layout_engine is not None and hasattr(layout_engine, "__class__"):
+        layout_name = layout_engine.__class__.__name__
+        if "Constrained" in layout_name:
+            new_fig.set_layout_engine("none")
+
+    # Apply overrides directly to existing figure
+    # Get record for call_id grouping (if fig is a RecordingFigure)
+    record = fig.record if hasattr(fig, "record") else None
+    if overrides:
+        from ._render_overrides import apply_overrides
+
+        apply_overrides(new_fig, overrides, record)
+
+    # Apply dark mode if requested
+    if dark_mode:
+        from ._render_overrides import apply_dark_mode
+
+        apply_dark_mode(new_fig)
+
+    # Validate axes bounds before rendering (prevent infinite/invalid extents)
+    for ax in new_fig.get_axes():
+        xlim = ax.get_xlim()
+        ylim = ax.get_ylim()
+        # Check for invalid limits (inf, nan, or extremely large)
+        if any(not (-1e10 < v < 1e10) for v in xlim + ylim):
+            ax.set_xlim(-1, 1)
+            ax.set_ylim(-1, 1)
+
+    # Save to PNG using same params as static save
+    # Re-create canvas to ensure clean state (avoids matplotlib renderer issues)
+    # Also save/restore the figure's draw method which can get corrupted by _get_renderer
+    original_draw = getattr(new_fig, "draw", None)
+    new_fig.set_canvas(FigureCanvasAgg(new_fig))
+
+    buf = io.BytesIO()
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", "constrained_layout not applied")
+        warnings.filterwarnings("ignore", category=UserWarning)
+        try:
+            new_fig.savefig(buf, format="png", dpi=150, bbox_inches="tight")
+        except Exception:
+            # Fall back to saving without bbox_inches="tight"
+            # Catches matplotlib internal exceptions (e.g., Done from _get_renderer)
+            buf = io.BytesIO()
+            # Reset canvas and draw method to clean state
+            new_fig.set_canvas(FigureCanvasAgg(new_fig))
+            if original_draw is not None:
+                new_fig.draw = original_draw
+            try:
+                new_fig.savefig(buf, format="png", dpi=150)
+            except Exception:
+                # Last resort: create empty placeholder
+                from PIL import Image as PILImage
+
+                placeholder = PILImage.new("RGB", (400, 300), color=(240, 240, 240))
+                placeholder.save(buf, format="PNG")
+                buf.seek(0)
+        finally:
+            # Always restore original draw method to prevent corruption
+            if original_draw is not None and hasattr(new_fig, "draw"):
+                try:
+                    new_fig.draw = original_draw
+                except AttributeError:
+                    pass
+    buf.seek(0)
+    png_bytes = buf.read()
+    base64_str = base64.b64encode(png_bytes).decode("utf-8")
+
+    # Get image size
+    buf.seek(0)
+    img = Image.open(buf)
+    img_size = img.size
+
+    # Extract bboxes
+    # Ensure clean canvas state before drawing
+    new_fig.set_canvas(FigureCanvasAgg(new_fig))
+    original_dpi = new_fig.dpi
+    new_fig.set_dpi(150)
+    try:
+        new_fig.canvas.draw()
+    except Exception:
+        # Canvas draw failed, likely due to corrupted state - reset and retry
+        new_fig.set_canvas(FigureCanvasAgg(new_fig))
+        try:
+            new_fig.canvas.draw()
+        except Exception:
+            pass  # If still fails, proceed with possibly stale bboxes
+    bboxes = extract_bboxes(new_fig, img_size[0], img_size[1])
+    new_fig.set_dpi(original_dpi)
+
+    return base64_str, bboxes, img_size
+
+
+def to_json_serializable(obj):
+    """Convert numpy arrays and other non-serializable objects to JSON-safe types."""
+    import numpy as np
+
+    if isinstance(obj, np.ndarray):
+        return obj.tolist()
+    elif isinstance(obj, (np.integer, np.floating)):
+        return obj.item()
+    # Handle pandas Series
+    elif hasattr(obj, "values") and hasattr(obj, "tolist"):
+        return obj.tolist()
+    elif isinstance(obj, dict):
+        return {k: to_json_serializable(v) for k, v in obj.items()}
+    elif isinstance(obj, (list, tuple)):
+        return [to_json_serializable(item) for item in obj]
+    return obj
+
+
+__all__ = [
+    "get_form_values_from_style",
+    "render_with_overrides",
+    "to_json_serializable",
+]

figrecipe/_editor/_hitmap/__init__.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Hitmap generation package.
+
+This package provides hitmap generation for interactive element selection.
+The main entry point is `generate_hitmap`.
+"""
+
+# Re-export main functions from _hitmap_main
+from .._hitmap_main import generate_hitmap, hitmap_to_base64
+
+# Re-export from artist processing
+from ._artists import (
+    process_collections,
+    process_figure_text,
+    process_images,
+    process_legend,
+    process_lines,
+    process_patches,
+    process_text,
+)
+
+# Re-export from color utilities
+from ._colors import (
+    AXES_COLOR,
+    BACKGROUND_COLOR,
+    DISTINCT_COLORS,
+    hsv_to_rgb,
+    id_to_rgb,
+    mpl_color_to_hex,
+    normalize_color,
+    rgb_to_id,
+)
+
+# Re-export from detection utilities
+from ._detect import detect_plot_types, is_boxplot_element, is_violin_element
+
+# Re-export from restoration utilities
+from ._restore import (
+    restore_axes_properties,
+    restore_backgrounds,
+    restore_figure_text,
+)
+
+__all__ = [
+    # Main functions
+    "generate_hitmap",
+    "hitmap_to_base64",
+    # Color utilities
+    "id_to_rgb",
+    "rgb_to_id",
+    "DISTINCT_COLORS",
+    "BACKGROUND_COLOR",
+    "AXES_COLOR",
+    "hsv_to_rgb",
+    "normalize_color",
+    "mpl_color_to_hex",
+    # Detection utilities
+    "detect_plot_types",
+    "is_boxplot_element",
+    "is_violin_element",
+    # Artist processing
+    "process_collections",
+    "process_figure_text",
+    "process_images",
+    "process_legend",
+    "process_lines",
+    "process_patches",
+    "process_text",
+    # Restoration utilities
+    "restore_axes_properties",
+    "restore_backgrounds",
+    "restore_figure_text",
+]
+
+# EOF

figrecipe/_editor/_hitmap/_artists/__init__.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Artist processing package for hitmap generation."""
+
+from ._collections import process_collections
+from ._images import process_images
+from ._lines import process_lines
+from ._patches import process_patches
+from ._text import process_figure_text, process_legend, process_text
+
+__all__ = [
+    "process_lines",
+    "process_collections",
+    "process_patches",
+    "process_images",
+    "process_text",
+    "process_legend",
+    "process_figure_text",
+]
+
+# EOF

figrecipe/_editor/_hitmap/_artists/_collections.py

@@ -0,0 +1,345 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Collection processing for hitmap generation."""
+
+from typing import Any, Dict
+
+from matplotlib.collections import (
+    LineCollection,
+    PathCollection,
+    PolyCollection,
+)
+
+from .._colors import id_to_rgb, mpl_color_to_hex, normalize_color
+from .._detect import is_violin_element
+
+
+def process_collections(
+    ax,
+    ax_idx: int,
+    element_id: int,
+    original_props: Dict[str, Any],
+    color_map: Dict[str, Any],
+    ax_info: Dict[str, Any],
+) -> int:
+    """Process collections (scatter, fills, etc.) on an axes.
+
+    Returns updated element_id.
+    """
+    from matplotlib.collections import QuadMesh
+    from matplotlib.contour import QuadContourSet
+    from matplotlib.quiver import Quiver
+
+    ax_plot_types = ax_info.get("types", set())
+    ax_call_ids = ax_info.get("call_ids", {})
+    has_violin = "violinplot" in ax_plot_types
+    has_record = len(ax_plot_types) > 0
+
+    violin_ids = list(ax_call_ids.get("violinplot", []))
+    scatter_ids = list(ax_call_ids.get("scatter", []))
+    quiver_ids = list(ax_call_ids.get("quiver", []))
+    fill_between_ids = list(ax_call_ids.get("fill_between", []))
+    pcolormesh_ids = list(ax_call_ids.get("pcolormesh", []))
+    contour_ids = list(ax_call_ids.get("contour", []))
+    contourf_ids = list(ax_call_ids.get("contourf", []))
+
+    violin_call_id = violin_ids[0] if violin_ids else None
+    pcolormesh_call_id = pcolormesh_ids[0] if pcolormesh_ids else None
+    contour_call_id = contour_ids[0] if contour_ids else None
+    contourf_call_id = contourf_ids[0] if contourf_ids else None
+    scatter_coll_idx = 0
+    fill_coll_idx = 0
+
+    for i, coll in enumerate(ax.collections):
+        if isinstance(coll, Quiver):
+            element_id = _process_quiver(
+                coll, i, ax_idx, element_id, original_props, color_map, quiver_ids
+            )
+        elif isinstance(coll, PathCollection):
+            element_id, scatter_coll_idx = _process_scatter(
+                coll,
+                i,
+                ax_idx,
+                element_id,
+                original_props,
+                color_map,
+                scatter_ids,
+                scatter_coll_idx,
+            )
+        elif isinstance(coll, PolyCollection):
+            element_id, fill_coll_idx = _process_polycoll(
+                coll,
+                i,
+                ax_idx,
+                element_id,
+                original_props,
+                color_map,
+                has_violin,
+                violin_call_id,
+                has_record,
+                ax,
+                fill_between_ids,
+                fill_coll_idx,
+            )
+        elif isinstance(coll, LineCollection):
+            element_id = _process_linecoll(
+                coll,
+                i,
+                ax_idx,
+                element_id,
+                original_props,
+                color_map,
+                has_violin,
+                violin_call_id,
+            )
+        elif isinstance(coll, QuadMesh):
+            element_id = _process_quadmesh(
+                coll, i, ax_idx, element_id, color_map, pcolormesh_call_id
+            )
+        elif isinstance(coll, QuadContourSet):
+            element_id = _process_contour(
+                coll,
+                i,
+                ax_idx,
+                element_id,
+                color_map,
+                contour_call_id,
+                contourf_call_id,
+            )
+
+    return element_id
+
+
+def _process_quiver(coll, i, ax_idx, element_id, original_props, color_map, quiver_ids):
+    """Process Quiver collection."""
+    if not coll.get_visible():
+        return element_id
+
+    key = f"ax{ax_idx}_quiver{i}"
+    rgb = id_to_rgb(element_id)
+
+    original_props[key] = {"color": coll.get_facecolor().copy()}
+    coll.set_color(normalize_color(rgb))
+
+    call_id = quiver_ids[0] if quiver_ids else None
+    label = call_id or f"quiver_{i}"
+
+    color_map[key] = {
+        "id": element_id,
+        "type": "quiver",
+        "label": label,
+        "ax_index": ax_idx,
+        "rgb": list(rgb),
+        "call_id": call_id,
+    }
+    return element_id + 1
+
+
+def _process_scatter(
+    coll,
+    i,
+    ax_idx,
+    element_id,
+    original_props,
+    color_map,
+    scatter_ids,
+    scatter_coll_idx,
+):
+    """Process PathCollection (scatter)."""
+    if not coll.get_visible():
+        return element_id, scatter_coll_idx
+
+    key = f"ax{ax_idx}_scatter{i}"
+    rgb = id_to_rgb(element_id)
+
+    original_props[key] = {
+        "facecolors": coll.get_facecolors().copy(),
+        "edgecolors": coll.get_edgecolors().copy(),
+    }
+
+    coll.set_facecolors([normalize_color(rgb)])
+    coll.set_edgecolors([normalize_color(rgb)])
+
+    orig_fc = original_props[key]["facecolors"]
+    orig_color = orig_fc[0] if len(orig_fc) > 0 else [0.5, 0.5, 0.5, 1]
+
+    orig_label = coll.get_label() or f"scatter_{i}"
+    if scatter_coll_idx < len(scatter_ids):
+        call_id = scatter_ids[scatter_coll_idx]
+        label = call_id
+    else:
+        call_id = f"scatter_{ax_idx}_{scatter_coll_idx}"
+        label = call_id if orig_label.startswith("_") else orig_label
+
+    color_map[key] = {
+        "id": element_id,
+        "type": "scatter",
+        "label": label,
+        "ax_index": ax_idx,
+        "rgb": list(rgb),
+        "original_color": mpl_color_to_hex(orig_color),
+        "call_id": call_id,
+    }
+    return element_id + 1, scatter_coll_idx + 1
+
+
+def _process_polycoll(
+    coll,
+    i,
+    ax_idx,
+    element_id,
+    original_props,
+    color_map,
+    has_violin,
+    violin_call_id,
+    has_record,
+    ax,
+    fill_between_ids=None,
+    fill_coll_idx=0,
+):
+    """Process PolyCollection (fills, violin bodies)."""
+    if fill_between_ids is None:
+        fill_between_ids = []
+
+    if not coll.get_visible():
+        return element_id, fill_coll_idx
+
+    orig_label = coll.get_label() or ""
+
+    # Check if this is a fill_between element (should NOT be skipped)
+    has_fill_between = len(fill_between_ids) > 0
+
+    if has_record and not has_fill_between:
+        # Only skip _child/_nolegend if NOT from fill_between
+        if orig_label.startswith("_child") or orig_label.startswith("_nolegend"):
+            return element_id, fill_coll_idx
+
+    key = f"ax{ax_idx}_fill{i}"
+    rgb = id_to_rgb(element_id)
+
+    original_props[key] = {
+        "facecolors": coll.get_facecolors().copy(),
+        "edgecolors": coll.get_edgecolors().copy(),
+    }
+
+    coll.set_facecolors([normalize_color(rgb)])
+    coll.set_edgecolors([normalize_color(rgb)])
+
+    orig_fc = original_props[key]["facecolors"]
+    orig_color = orig_fc[0] if len(orig_fc) > 0 else [0.5, 0.5, 0.5, 1]
+
+    if has_violin and is_violin_element(coll, ax):
+        elem_type = "violin"
+        label = violin_call_id or "violin"
+        call_id = violin_call_id
+    else:
+        elem_type = "fill"
+        # Try to get fill_between call_id
+        if fill_coll_idx < len(fill_between_ids):
+            call_id = fill_between_ids[fill_coll_idx]
+            label = call_id
+            fill_coll_idx += 1
+        else:
+            label = orig_label if not orig_label.startswith("_") else f"fill_{i}"
+            call_id = None
+
+    color_map[key] = {
+        "id": element_id,
+        "type": elem_type,
+        "label": label,
+        "ax_index": ax_idx,
+        "rgb": list(rgb),
+        "original_color": mpl_color_to_hex(orig_color),
+        "call_id": call_id,
+    }
+    return element_id + 1, fill_coll_idx
+
+
+def _process_linecoll(
+    coll, i, ax_idx, element_id, original_props, color_map, has_violin, violin_call_id
+):
+    """Process LineCollection (violin inner lines)."""
+    if not coll.get_visible():
+        return element_id
+
+    key = f"ax{ax_idx}_linecoll{i}"
+    rgb = id_to_rgb(element_id)
+
+    original_props[key] = {
+        "colors": coll.get_colors().copy() if hasattr(coll, "get_colors") else [],
+        "edgecolors": coll.get_edgecolors().copy(),
+    }
+
+    coll.set_color(normalize_color(rgb))
+
+    orig_colors = original_props[key]["colors"]
+    orig_color = orig_colors[0] if len(orig_colors) > 0 else [0.5, 0.5, 0.5, 1]
+
+    if has_violin:
+        elem_type = "violin"
+        label = violin_call_id or "violin"
+        call_id = violin_call_id
+    else:
+        elem_type = "linecollection"
+        label = f"linecoll_{i}"
+        call_id = None
+
+    color_map[key] = {
+        "id": element_id,
+        "type": elem_type,
+        "label": label,
+        "ax_index": ax_idx,
+        "rgb": list(rgb),
+        "original_color": mpl_color_to_hex(orig_color),
+        "call_id": call_id,
+    }
+    return element_id + 1
+
+
+def _process_quadmesh(coll, i, ax_idx, element_id, color_map, pcolormesh_call_id=None):
+    """Process QuadMesh (pcolormesh, hexbin, hist2d)."""
+    if not coll.get_visible():
+        return element_id
+
+    key = f"ax{ax_idx}_quadmesh{i}"
+    rgb = id_to_rgb(element_id)
+
+    call_id = pcolormesh_call_id
+    label = call_id or f"quadmesh_{i}"
+
+    color_map[key] = {
+        "id": element_id,
+        "type": "quadmesh",
+        "label": label,
+        "ax_index": ax_idx,
+        "rgb": list(rgb),
+        "call_id": call_id,
+    }
+    return element_id + 1
+
+
+def _process_contour(
+    coll, i, ax_idx, element_id, color_map, contour_call_id=None, contourf_call_id=None
+):
+    """Process QuadContourSet (contour, contourf)."""
+    key = f"ax{ax_idx}_contour{i}"
+    rgb = id_to_rgb(element_id)
+
+    # Try contourf first, then contour
+    call_id = contourf_call_id or contour_call_id
+    label = call_id or f"contour_{i}"
+
+    color_map[key] = {
+        "id": element_id,
+        "type": "contour",
+        "label": label,
+        "ax_index": ax_idx,
+        "rgb": list(rgb),
+        "call_id": call_id,
+    }
+    return element_id + 1
+
+
+__all__ = ["process_collections"]
+
+# EOF