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

figrecipe/_editor/_plot_types_registry.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Registry for plot types using existing figrecipe infrastructure.
+
+Uses:
+- figrecipe._signatures for signature introspection
+- figrecipe._dev.demo_plotters._categories for plot type organization
+"""
+
+from typing import Any, Dict, List
+
+from .._dev.demo_plotters._categories import CATEGORIES as _PLOT_CATEGORIES
+from .._dev.demo_plotters._categories import (
+    CATEGORY_DISPLAY_NAMES as _PLOT_DISPLAY_NAMES,
+)
+from .._signatures import get_signature
+
+# Decoration methods to add to the selector
+DECORATION_METHODS: List[str] = [
+    "text",
+    "annotate",
+    "arrow",
+    "axhline",
+    "axvline",
+    "axhspan",
+    "axvspan",
+]
+
+# Combined categories: plots + decorations
+CATEGORIES: Dict[str, List[str]] = {
+    **_PLOT_CATEGORIES,
+    "decoration": DECORATION_METHODS,
+}
+
+CATEGORY_DISPLAY_NAMES: Dict[str, str] = {
+    **_PLOT_DISPLAY_NAMES,
+    "decoration": "Decoration & Annotation",
+}
+
+
+def _get_docstring(method_name: str) -> str:
+    """Get first line of docstring for a matplotlib method."""
+    try:
+        import matplotlib.pyplot as plt
+        from matplotlib.axes import Axes
+
+        # Try Axes method first, then plt
+        fn = getattr(Axes, method_name, None) or getattr(plt, method_name, None)
+        if fn and fn.__doc__:
+            # Get first non-empty line of docstring
+            first_line = fn.__doc__.strip().split("\n")[0].strip()
+            # Clean up and truncate if needed
+            if len(first_line) > 100:
+                first_line = first_line[:97] + "..."
+            return first_line
+    except Exception:
+        pass
+    return ""
+
+
+def get_plot_type_info(method_name: str) -> Dict[str, Any]:
+    """Get plot type information from existing signature infrastructure."""
+    sig = get_signature(method_name)
+
+    args = sig.get("args", [])
+    kwargs = sig.get("kwargs", {})
+
+    # Args that also exist in kwargs with defaults are actually optional
+    kwargs_with_defaults = {
+        k for k, v in kwargs.items() if v.get("default") is not None or "default" in v
+    }
+
+    # Format required and optional args
+    required_parts = []
+    optional_parts = []
+
+    for arg in args:
+        name = arg.get("name", "")
+        if name.startswith("*"):
+            continue
+        # Arg is optional if marked optional OR has a default in kwargs
+        is_optional = arg.get("optional", False) or name in kwargs_with_defaults
+        if is_optional:
+            optional_parts.append(name)
+        else:
+            required_parts.append(name)
+
+    required_str = ", ".join(required_parts) if required_parts else "data"
+    # Only show first 2 optional vars, deduplicated
+    optional_str = ", ".join(optional_parts[:2]) if optional_parts else ""
+
+    # Build hint string showing signature
+    hint_parts = []
+    for arg in args[:4]:
+        name = arg.get("name", "")
+        if name.startswith("*"):
+            continue
+        is_optional = arg.get("optional", False) or name in kwargs_with_defaults
+        if is_optional:
+            hint_parts.append(f"[{name}]")
+        else:
+            hint_parts.append(name)
+
+    if hint_parts:
+        hint = f"{method_name}({', '.join(hint_parts)})"
+    else:
+        hint = f"{method_name}(data)"
+
+    # Get docstring for tooltip
+    docstring = _get_docstring(method_name)
+
+    return {
+        "name": method_name,
+        "required": required_str,
+        "optional": optional_str,
+        "hint": hint,
+        "docstring": docstring,
+    }
+
+
+def get_all_plot_types() -> Dict[str, Dict[str, Any]]:
+    """Get all plot types organized by category."""
+    result = {}
+    for cat_key, plots in CATEGORIES.items():
+        label = CATEGORY_DISPLAY_NAMES.get(cat_key, cat_key)
+        result[cat_key] = {
+            "label": label,
+            "types": [get_plot_type_info(m) for m in plots],
+        }
+    return result
+
+
+def generate_html_options() -> str:
+    """Generate HTML <optgroup> and <option> elements for plot type selector.
+
+    Shows required and optional arguments with brackets around optional.
+    e.g., "fill_between (x, y1, [y2], [where])"
+    Includes docstring as tooltip on hover.
+    """
+    import html
+
+    html_parts = []
+    first = True
+    for cat_key, plots in CATEGORIES.items():
+        label = CATEGORY_DISPLAY_NAMES.get(cat_key, cat_key)
+        html_parts.append(f'                    <optgroup label="{label}">')
+        for method in plots:
+            info = get_plot_type_info(method)
+            # Use hint which has correct bracket notation
+            # hint format: "method(x, y, [opt1], [opt2])"
+            display_text = info["hint"]
+            selected = " selected" if first else ""
+            first = False
+            # Add docstring as title for tooltip
+            docstring = info.get("docstring", "")
+            title_attr = f' title="{html.escape(docstring)}"' if docstring else ""
+            html_parts.append(
+                f'                        <option value="{method}"{selected}{title_attr}>{display_text}</option>'
+            )
+        html_parts.append("                    </optgroup>")
+    return "\n".join(html_parts)
+
+
+def generate_js_hints() -> str:
+    """Generate JavaScript PLOT_TYPE_HINTS object from signature infrastructure."""
+    lines = ["const PLOT_TYPE_HINTS = {"]
+    for plots in CATEGORIES.values():
+        for method in plots:
+            info = get_plot_type_info(method)
+            req = info["required"].replace("'", "\\'")
+            opt = info["optional"].replace("'", "\\'")
+            hint = info["hint"].replace("'", "\\'")
+            doc = info.get("docstring", "").replace("'", "\\'")
+            lines.append(
+                f"    {method}: {{ required: '{req}', optional: '{opt}', hint: '{hint}', doc: '{doc}' }},"
+            )
+    lines.append("};")
+    return "\n".join(lines)
+
+
+__all__ = [
+    "CATEGORIES",
+    "CATEGORY_DISPLAY_NAMES",
+    "get_plot_type_info",
+    "get_all_plot_types",
+    "generate_html_options",
+    "generate_js_hints",
+]
+
+# EOF

figrecipe/_editor/_render_overrides.py

@@ -23,11 +23,18 @@ def apply_overrides(
         - axes_width_mm, axes_height_mm
         - fonts_axis_label_pt, fonts_tick_label_pt
         - lines_trace_mm
+        - spacing_horizontal_mm, spacing_vertical_mm
+        - margins_left_mm, margins_right_mm, margins_bottom_mm, margins_top_mm
+        - call_overrides: dict mapping call_id -> {param: value}
         - etc.
     record : FigureRecord, optional
         Recording record to access call IDs for grouping elements.
     """
     from ..styles._style_applier import apply_style_mm
+    from ._figure_layout import apply_figure_layout_overrides
+
+    # Apply figure-level layout overrides (spacing, margins)
+    apply_figure_layout_overrides(fig, overrides, record)
 
     axes_list = fig.get_axes()
 
@@ -49,6 +56,14 @@ def apply_overrides(
             ax_record = _find_ax_record(ax, axes_list, record)
             apply_color_palette(ax, color_palette, ax_record)
 
+    # Apply call-specific overrides (from Element tab edits)
+    # Single source of truth - same function for initial and re-render
+    call_overrides = overrides.get("call_overrides", {})
+    if call_overrides and record:
+        from ._call_overrides import apply_call_overrides
+
+        apply_call_overrides(fig, call_overrides, record)
+
 
 def _apply_font_overrides(ax: Axes, overrides: Dict[str, Any]) -> None:
     """Apply font-related overrides to axes."""
@@ -100,16 +115,13 @@ def _apply_behavior_overrides(ax: Axes, overrides: Dict[str, Any]) -> None:
         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)
+    # Spines visibility (all four directions)
+    for side in ["top", "right", "bottom", "left"]:
+        key = f"behavior_hide_{side}_spine"
+        legacy_key = f"hide_{side}_spine"
+        hide_value = overrides.get(key, overrides.get(legacy_key))
+        if hide_value is not None:
+            ax.spines[side].set_visible(not hide_value)
 
 
 def _apply_legend_overrides(ax: Axes, overrides: Dict[str, Any]) -> None:
@@ -274,7 +286,10 @@ def _apply_colors_to_bars(
     ax_record: Optional[Any],
     call_color_map: Dict[str, int],
 ) -> None:
-    """Apply colors to bar and histogram elements."""
+    """Apply colors to bar and histogram elements.
+
+    Skips bars that have an explicit 'color' kwarg set (from Element tab edits).
+    """
     from matplotlib.patches import Rectangle
 
     rectangles = [p for p in ax.patches if isinstance(p, Rectangle)]
@@ -292,6 +307,9 @@ def _apply_colors_to_bars(
             call_idx = (
                 min(i // rect_per_call, len(bar_calls) - 1) if rect_per_call > 0 else 0
             )
+            # Skip if this call has an explicit color set (user override)
+            if call_idx < len(bar_calls) and "color" in bar_calls[call_idx].kwargs:
+                continue
             if call_idx < len(bar_calls) and bar_calls[call_idx].id in call_color_map:
                 color_idx = call_color_map[bar_calls[call_idx].id]
             else:
@@ -461,6 +479,15 @@ def _apply_dark_mode_to_axes(ax: Axes, bg_color: str, text_color: str) -> None:
     for text in ax.texts:
         text.set_color(text_color)
 
+    # Stat annotation bracket lines (Line2D with clip_on=False)
+    for line in ax.get_lines():
+        # Bracket lines have clip_on=False and are typically black
+        if not line.get_clip_on():
+            current_color = line.get_color()
+            # Only update if it's a dark color (black or near-black)
+            if current_color in ["black", "k", "#000000", (0, 0, 0), (0.0, 0.0, 0.0)]:
+                line.set_color(text_color)
+
     # Legend
     legend = ax.get_legend()
     if legend is not None:

figrecipe/_editor/_renderer.py

@@ -15,6 +15,48 @@ 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(
     fig: RecordingFigure,
     overrides: Optional[Dict[str, Any]] = None,
@@ -54,9 +96,12 @@ def render_preview(
     if 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)
+    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)

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

figrecipe/_editor/_routes_axis.py

@@ -401,6 +401,12 @@ def register_axis_routes(app, editor):
 
         try:
             ax = axes[ax_index]
+
+            # CRITICAL: Get current position BEFORE changing it
+            # We need this to find the correct ax_record to update
+            current_pos = ax.get_position()
+
+            # Now set the new position
             ax.set_position([left, bottom, width, height])
 
             # Store position override in manual_overrides (mm values with upper-left origin)
@@ -412,13 +418,36 @@ def register_axis_routes(app, editor):
                 "height_mm": height_mm,
             }
 
-            # Update record if available
+            # Update record if available - find ax_record by matching CURRENT position
             if hasattr(editor.fig, "record"):
-                # Find the axes record key
+                matched_ax_key = None
                 ax_keys = sorted(editor.fig.record.axes.keys())
-                if ax_index < len(ax_keys):
-                    ax_key = ax_keys[ax_index]
+
+                # First, try to match by position_override (for previously dragged panels)
+                for ax_key in ax_keys:
                     ax_record = editor.fig.record.axes[ax_key]
+                    if (
+                        hasattr(ax_record, "position_override")
+                        and ax_record.position_override
+                    ):
+                        rec_pos = ax_record.position_override
+                        if len(rec_pos) >= 4:
+                            if (
+                                abs(rec_pos[0] - current_pos.x0) < 0.01
+                                and abs(rec_pos[1] - current_pos.y0) < 0.01
+                                and abs(rec_pos[2] - current_pos.width) < 0.01
+                                and abs(rec_pos[3] - current_pos.height) < 0.01
+                            ):
+                                matched_ax_key = ax_key
+                                break
+
+                # If no position_override match, fall back to index-based matching
+                if matched_ax_key is None and ax_index < len(ax_keys):
+                    matched_ax_key = ax_keys[ax_index]
+
+                # Update the matched ax_record with new position
+                if matched_ax_key:
+                    ax_record = editor.fig.record.axes[matched_ax_key]
                     ax_record.position_override = [left, bottom, width, height]
 
             # Re-render
@@ -428,8 +457,8 @@ def register_axis_routes(app, editor):
                 editor.dark_mode,
             )
 
-            # Regenerate hitmap
-            hitmap_img, color_map = generate_hitmap(mpl_fig, img_size[0], img_size[1])
+            # Regenerate hitmap - use editor.fig to preserve record access
+            hitmap_img, color_map = generate_hitmap(editor.fig, dpi=150)
             editor._color_map = color_map
             editor._hitmap_base64 = hitmap_to_base64(hitmap_img)
             editor._hitmap_generated = True

figrecipe/_editor/_routes_captions.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Caption-related Flask route handlers for the figure editor.
+Handles scientific figure captions and panel captions.
+"""
+
+from flask import jsonify, request
+
+
+def register_caption_routes(app, editor):
+    """Register caption-related routes with the Flask app."""
+
+    @app.route("/get_captions")
+    def get_captions():
+        """Get current captions (figure and panel)."""
+        captions = {
+            "figure_number": 1,
+            "figure_caption": "",
+            "panel_captions": [],  # List of panel captions
+        }
+
+        # Try to get caption from RecordingFigure's recorder
+        fig = editor.fig
+        if hasattr(fig, "caption") and fig.caption:
+            captions["figure_caption"] = fig.caption
+
+        # Get panel captions from axes
+        if hasattr(fig, "flat"):
+            for ax in fig.flat:
+                if hasattr(ax, "caption") and ax.caption:
+                    captions["panel_captions"].append(ax.caption)
+                else:
+                    captions["panel_captions"].append("")
+
+        # Check if we have recipe metadata (fallback)
+        if not captions["figure_caption"] and hasattr(fig, "_recipe_metadata"):
+            metadata = fig._recipe_metadata
+            if hasattr(metadata, "caption") and metadata.caption:
+                captions["figure_caption"] = metadata.caption
+            if hasattr(metadata, "figure_number") and metadata.figure_number:
+                captions["figure_number"] = metadata.figure_number
+
+        # Check editor's manual overrides for captions (highest priority)
+        if hasattr(editor, "style_overrides"):
+            manual = getattr(editor.style_overrides, "manual_overrides", {})
+            if "caption_figure_number" in manual:
+                captions["figure_number"] = manual["caption_figure_number"]
+            if "caption_figure_text" in manual:
+                captions["figure_caption"] = manual["caption_figure_text"]
+            # Load individual panel overrides
+            for i in range(len(captions["panel_captions"])):
+                key = f"caption_panel_{i}_text"
+                if key in manual:
+                    captions["panel_captions"][i] = manual[key]
+
+        return jsonify(captions)
+
+    @app.route("/update_caption", methods=["POST"])
+    def update_caption():
+        """Update figure or panel caption."""
+        data = request.get_json() or {}
+        caption_type = data.get("type")  # 'figure' or 'panel'
+
+        if not caption_type:
+            return jsonify({"error": "Missing caption type"}), 400
+
+        try:
+            if caption_type == "figure":
+                figure_number = data.get("figure_number", 1)
+                text = data.get("text", "")
+
+                # Store in manual overrides
+                editor.style_overrides.manual_overrides["caption_figure_number"] = (
+                    figure_number
+                )
+                editor.style_overrides.manual_overrides["caption_figure_text"] = text
+
+                # Also store in recipe metadata if available
+                if hasattr(editor.fig, "_recipe_metadata"):
+                    editor.fig._recipe_metadata.caption = text
+                    editor.fig._recipe_metadata.figure_number = figure_number
+
+                return jsonify(
+                    {
+                        "success": True,
+                        "caption_type": "figure",
+                        "figure_number": figure_number,
+                        "text": text,
+                    }
+                )
+
+            elif caption_type == "panel":
+                panel_index = data.get("panel_index", 0)
+                text = data.get("text", "")
+
+                # Store in manual overrides
+                key = f"caption_panel_{panel_index}_text"
+                editor.style_overrides.manual_overrides[key] = text
+                # Also store general panel caption for current selection
+                editor.style_overrides.manual_overrides["caption_panel_text"] = text
+
+                # Store in axes metadata if available
+                if hasattr(editor.fig, "_axes_metadata"):
+                    axes_meta = editor.fig._axes_metadata
+                    if panel_index < len(axes_meta):
+                        axes_meta[panel_index].caption = text
+
+                return jsonify(
+                    {
+                        "success": True,
+                        "caption_type": "panel",
+                        "panel_index": panel_index,
+                        "text": text,
+                    }
+                )
+
+            else:
+                return jsonify({"error": f"Unknown caption type: {caption_type}"}), 400
+
+        except Exception as e:
+            import traceback
+
+            traceback.print_exc()
+            return jsonify({"error": f"Caption update failed: {str(e)}"}), 500
+
+
+__all__ = ["register_caption_routes"]
+
+# EOF