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

figrecipe/_editor/_renderer.py

@@ -10,10 +10,51 @@ applied, enabling real-time preview updates in the GUI editor.
 import io
 from typing import Any, Dict, Optional, Tuple
 
-from matplotlib.figure import Figure
-
 from .._wrappers import RecordingFigure
 from ._bbox import extract_bboxes
+from ._render_overrides import apply_dark_mode, apply_overrides
+
+
+def _restore_light_mode(fig) -> None:
+    """Restore light mode colors to figure (undo dark mode changes)."""
+    text_color = "black"
+
+    # Figure background (transparent)
+    fig.patch.set_facecolor("none")
+
+    # Figure-level text
+    if hasattr(fig, "_suptitle") and fig._suptitle is not None:
+        fig._suptitle.set_color(text_color)
+    if hasattr(fig, "_supxlabel") and fig._supxlabel is not None:
+        fig._supxlabel.set_color(text_color)
+    if hasattr(fig, "_supylabel") and fig._supylabel is not None:
+        fig._supylabel.set_color(text_color)
+
+    for ax in fig.get_axes():
+        # Axes background (transparent)
+        ax.set_facecolor("none")
+        # Text colors
+        ax.xaxis.label.set_color(text_color)
+        ax.yaxis.label.set_color(text_color)
+        ax.title.set_color(text_color)
+        ax.tick_params(colors=text_color)
+        # Spines
+        for spine in ax.spines.values():
+            spine.set_edgecolor(text_color)
+        # Text objects (panel labels, annotations)
+        for text in ax.texts:
+            text.set_color(text_color)
+        # Bracket lines (Line2D with clip_on=False)
+        for line in ax.get_lines():
+            if not line.get_clip_on():
+                line.set_color(text_color)
+        # Legend
+        legend = ax.get_legend()
+        if legend is not None:
+            legend.get_frame().set_facecolor("none")
+            legend.get_frame().set_edgecolor(text_color)
+            for text in legend.get_texts():
+                text.set_color(text_color)
 
 
 def render_preview(
@@ -48,13 +89,22 @@ def render_preview(
     # Get underlying matplotlib figure
     mpl_fig = fig.fig if hasattr(fig, "fig") else fig
 
+    # Get record for call_id grouping (if fig is a RecordingFigure)
+    record = fig.record if hasattr(fig, "record") else None
+
     # Apply style overrides
     if overrides:
-        _apply_overrides(mpl_fig, overrides)
+        apply_overrides(mpl_fig, overrides, record)
 
-    # Apply dark mode if requested
+    # Apply dark mode if requested, or restore light mode colors
     if dark_mode:
-        _apply_dark_mode(mpl_fig)
+        apply_dark_mode(mpl_fig)
+    else:
+        # Restore light mode colors (needed because figure is reused)
+        _restore_light_mode(mpl_fig)
+
+    # Finalize ticks and special plots (must be done after all plotting)
+    _finalize_figure(fig, mpl_fig)
 
     # Render to buffer first
     buf = io.BytesIO()
@@ -120,185 +170,6 @@ def render_to_base64(
     return base64_str, bboxes, img_size
 
 
-def _apply_overrides(fig: Figure, overrides: Dict[str, Any]) -> None:
-    """
-    Apply style overrides to figure.
-
-    Parameters
-    ----------
-    fig : Figure
-        Matplotlib figure.
-    overrides : dict
-        Style overrides with keys like:
-        - axes_width_mm, axes_height_mm
-        - fonts_axis_label_pt, fonts_tick_label_pt
-        - lines_trace_mm
-        - etc.
-    """
-    from ..styles._style_applier import apply_style_mm
-
-    axes_list = fig.get_axes()
-
-    for ax in axes_list:
-        # Apply mm-based styling
-        apply_style_mm(ax, overrides)
-
-        # Apply specific overrides that aren't handled by apply_style_mm
-        # YAML-compatible keys are canonical, legacy keys supported for backwards compatibility
-
-        # Font sizes (YAML: fonts_axis_label_pt, legacy: axis_font_size_pt)
-        axis_fs = overrides.get(
-            "fonts_axis_label_pt", overrides.get("axis_font_size_pt")
-        )
-        if axis_fs is not None:
-            ax.xaxis.label.set_fontsize(axis_fs)
-            ax.yaxis.label.set_fontsize(axis_fs)
-
-        tick_fs = overrides.get(
-            "fonts_tick_label_pt", overrides.get("tick_font_size_pt")
-        )
-        if tick_fs is not None:
-            ax.tick_params(labelsize=tick_fs)
-
-        title_fs = overrides.get("fonts_title_pt", overrides.get("title_font_size_pt"))
-        if title_fs is not None:
-            ax.title.set_fontsize(title_fs)
-
-        family = overrides.get("fonts_family", overrides.get("font_family"))
-        if family is not None:
-            ax.xaxis.label.set_fontfamily(family)
-            ax.yaxis.label.set_fontfamily(family)
-            ax.title.set_fontfamily(family)
-            for label in ax.get_xticklabels() + ax.get_yticklabels():
-                label.set_fontfamily(family)
-
-        # Ticks (YAML: ticks_direction, legacy: tick_direction)
-        tick_dir = overrides.get("ticks_direction", overrides.get("tick_direction"))
-        if tick_dir is not None and tick_dir in ("in", "out", "inout"):
-            ax.tick_params(direction=tick_dir)
-
-        tick_len = overrides.get("ticks_length_mm", overrides.get("tick_length_mm"))
-        if tick_len is not None:
-            from .._utils._units import mm_to_pt
-
-            length = mm_to_pt(tick_len)
-            ax.tick_params(length=length)
-
-        # Grid (YAML: behavior_grid, legacy: grid)
-        grid_value = overrides.get("behavior_grid", overrides.get("grid"))
-        if grid_value is not None:
-            if grid_value:
-                ax.grid(True, alpha=0.3)
-            else:
-                ax.grid(False)
-
-        # Spines (YAML: behavior_hide_top_spine, legacy: hide_top_spine)
-        hide_top = overrides.get(
-            "behavior_hide_top_spine", overrides.get("hide_top_spine")
-        )
-        if hide_top is not None:
-            ax.spines["top"].set_visible(not hide_top)
-
-        hide_right = overrides.get(
-            "behavior_hide_right_spine", overrides.get("hide_right_spine")
-        )
-        if hide_right is not None:
-            ax.spines["right"].set_visible(not hide_right)
-
-        # Legend
-        legend = ax.get_legend()
-        if legend is not None:
-            if "legend_frameon" in overrides:
-                legend.set_frame_on(overrides["legend_frameon"])
-
-            if "legend_alpha" in overrides:
-                frame = legend.get_frame()
-                fc = frame.get_facecolor()
-                frame.set_facecolor((*fc[:3], overrides["legend_alpha"]))
-
-        # Line widths (YAML: lines_trace_mm, legacy: trace_thickness_mm)
-        trace_mm = overrides.get("lines_trace_mm", overrides.get("trace_thickness_mm"))
-        if trace_mm is not None:
-            from .._utils._units import mm_to_pt
-
-            lw = mm_to_pt(trace_mm)
-            for line in ax.get_lines():
-                line.set_linewidth(lw)
-
-        # Marker sizes (YAML: markers_scatter_mm, legacy: marker_size_mm)
-        # Only apply to PathCollection (scatter), not PolyCollection (violin/fill)
-        scatter_mm = overrides.get(
-            "markers_scatter_mm",
-            overrides.get("markers_size_mm", overrides.get("marker_size_mm")),
-        )
-        if scatter_mm is not None:
-            from matplotlib.collections import PathCollection
-
-            from .._utils._units import mm_to_scatter_size
-
-            size = mm_to_scatter_size(scatter_mm)
-            for coll in ax.collections:
-                # Only apply to scatter plots (PathCollection), not violin/fill (PolyCollection)
-                if isinstance(coll, PathCollection):
-                    try:
-                        coll.set_sizes([size])
-                    except Exception:
-                        pass
-
-
-def _apply_dark_mode(fig: Figure) -> None:
-    """
-    Apply dark mode colors to figure.
-
-    Parameters
-    ----------
-    fig : Figure
-        Matplotlib figure.
-    """
-    # Dark theme colors
-    bg_color = "#1a1a1a"
-    text_color = "#e8e8e8"
-
-    # Figure background
-    fig.patch.set_facecolor(bg_color)
-
-    # Figure-level text elements (suptitle, supxlabel, supylabel)
-    if hasattr(fig, "_suptitle") and fig._suptitle is not None:
-        fig._suptitle.set_color(text_color)
-    if hasattr(fig, "_supxlabel") and fig._supxlabel is not None:
-        fig._supxlabel.set_color(text_color)
-    if hasattr(fig, "_supylabel") and fig._supylabel is not None:
-        fig._supylabel.set_color(text_color)
-
-    for ax in fig.get_axes():
-        # Axes background
-        ax.set_facecolor(bg_color)
-
-        # Text colors
-        ax.xaxis.label.set_color(text_color)
-        ax.yaxis.label.set_color(text_color)
-        ax.title.set_color(text_color)
-
-        # Tick labels
-        ax.tick_params(colors=text_color)
-
-        # Spines
-        for spine in ax.spines.values():
-            spine.set_color(text_color)
-
-        # Grid
-        ax.tick_params(color=text_color)
-
-        # Legend
-        legend = ax.get_legend()
-        if legend is not None:
-            frame = legend.get_frame()
-            frame.set_facecolor(bg_color)
-            frame.set_edgecolor(text_color)
-            for text in legend.get_texts():
-                text.set_color(text_color)
-
-
 def render_download(
     fig: RecordingFigure,
     fmt: str = "png",
@@ -329,11 +200,17 @@ def render_download(
     """
     mpl_fig = fig.fig if hasattr(fig, "fig") else fig
 
+    # Get record for call_id grouping (if fig is a RecordingFigure)
+    record = fig.record if hasattr(fig, "record") else None
+
     if overrides:
-        _apply_overrides(mpl_fig, overrides)
+        apply_overrides(mpl_fig, overrides, record)
 
     if dark_mode:
-        _apply_dark_mode(mpl_fig)
+        apply_dark_mode(mpl_fig)
+
+    # Finalize ticks and special plots (must be done after all plotting)
+    _finalize_figure(fig, mpl_fig)
 
     buf = io.BytesIO()
     mpl_fig.savefig(buf, format=fmt, dpi=dpi, bbox_inches="tight")
@@ -342,8 +219,26 @@ def render_download(
     return buf.read()
 
 
+def _finalize_figure(fig: RecordingFigure, mpl_fig: Any) -> None:
+    """Finalize ticks and special plots for all axes in the figure."""
+    from ..styles._style_applier import finalize_special_plots, finalize_ticks
+
+    # Get style dict for finalization
+    style_dict = {}
+    if hasattr(fig, "style") and fig.style:
+        from ..styles import get_style
+
+        style_dict = get_style(fig.style)
+
+    for ax in mpl_fig.get_axes():
+        finalize_ticks(ax)
+        finalize_special_plots(ax, style_dict)
+
+
 __all__ = [
     "render_preview",
     "render_to_base64",
     "render_download",
 ]
+
+# EOF

figrecipe/_editor/_routes_annotation.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Annotation-related Flask route handlers for the figure editor.
+
+Handles updating positions of decorative elements like panel labels,
+text annotations, and arrows.
+"""
+
+from flask import jsonify, request
+
+from ._helpers import render_with_overrides
+
+
+def register_annotation_routes(app, editor):
+    """Register annotation-related routes with the Flask app."""
+
+    @app.route("/update_annotation_position", methods=["POST"])
+    def update_annotation_position():
+        """Update annotation position (panel label, text, arrow).
+
+        Expects JSON: {
+            ax_index: int,
+            annotation_type: str ('panel_label', 'text', 'arrow'),
+            text_index: int,
+            x: float (axes-relative 0-1),
+            y: float (axes-relative 0-1)
+        }
+        """
+        data = request.get_json() or {}
+        ax_index = data.get("ax_index", 0)
+        annotation_type = data.get("annotation_type", "text")
+        text_index = data.get("text_index", 0)
+        new_x = data.get("x")
+        new_y = data.get("y")
+
+        if new_x is None or new_y is None:
+            return jsonify({"error": "Missing x or y coordinate"}), 400
+
+        try:
+            # Get the matplotlib figure
+            mpl_fig = editor.fig.fig if hasattr(editor.fig, "fig") else editor.fig
+            axes_list = mpl_fig.get_axes()
+
+            if ax_index >= len(axes_list):
+                return jsonify({"error": f"Invalid axis index: {ax_index}"}), 400
+
+            ax = axes_list[ax_index]
+
+            if annotation_type in ("panel_label", "text"):
+                # Update text position
+                if text_index >= len(ax.texts):
+                    return jsonify({"error": f"Invalid text index: {text_index}"}), 400
+
+                text_obj = ax.texts[text_index]
+
+                # Set new position (in axes coordinates for transAxes transform)
+                if text_obj.get_transform() == ax.transAxes:
+                    text_obj.set_position((new_x, new_y))
+                else:
+                    # For data coordinates, convert from axes-relative
+                    xlim = ax.get_xlim()
+                    ylim = ax.get_ylim()
+                    data_x = xlim[0] + new_x * (xlim[1] - xlim[0])
+                    data_y = ylim[0] + new_y * (ylim[1] - ylim[0])
+                    text_obj.set_position((data_x, data_y))
+
+                # Store in manual_overrides for persistence and undo support
+                override_key = f"annotation_pos_ax{ax_index}_text{text_index}"
+                editor.style_overrides.manual_overrides[override_key] = {
+                    "x": new_x,
+                    "y": new_y,
+                    "type": annotation_type,
+                }
+
+            elif annotation_type == "arrow":
+                # Update arrow position (FancyArrowPatch)
+                from matplotlib.patches import FancyArrowPatch
+
+                arrow_patches = [
+                    p for p in ax.patches if isinstance(p, FancyArrowPatch)
+                ]
+                arrow_index = data.get("arrow_index", 0)
+
+                if arrow_index >= len(arrow_patches):
+                    return jsonify(
+                        {"error": f"Invalid arrow index: {arrow_index}"}
+                    ), 400
+
+                # Arrow position update is more complex - skip for now
+                return jsonify({"error": "Arrow drag not yet implemented"}), 501
+
+            # Re-render the figure
+            base64_img, bboxes, img_size = render_with_overrides(
+                editor.fig,
+                editor.get_effective_style(),
+                editor.dark_mode,
+            )
+
+            return jsonify(
+                {
+                    "success": True,
+                    "image": base64_img,
+                    "bboxes": bboxes,
+                }
+            )
+
+        except Exception as e:
+            import traceback
+
+            traceback.print_exc()
+            return jsonify({"error": str(e)}), 500
+
+
+__all__ = ["register_annotation_routes"]