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

figrecipe/_editor/_bbox/_transforms.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Coordinate transformation utilities for bbox extraction.
+
+This module handles the transformation from matplotlib display coordinates
+to image pixel coordinates for hit detection.
+"""
+
+from typing import Dict, List, Optional
+
+from matplotlib.figure import Figure
+from matplotlib.transforms import Bbox
+
+
+def transform_bbox(
+    window_extent: Bbox,
+    fig: Figure,
+    tight_bbox: Bbox,
+    img_width: int,
+    img_height: int,
+    scale_x: float,
+    scale_y: float,
+    pad_inches: float,
+    saved_height_inches: float,
+) -> Optional[Dict[str, float]]:
+    """
+    Transform matplotlib window extent to image pixel coordinates.
+
+    Parameters
+    ----------
+    window_extent : Bbox
+        Bbox in display coordinates (points).
+    fig : Figure
+        Matplotlib figure.
+    tight_bbox : Bbox
+        Tight bbox of figure in inches.
+    img_width, img_height : int
+        Output image dimensions.
+    scale_x, scale_y : float
+        Scale factors from inches to pixels.
+    pad_inches : float
+        Padding added by bbox_inches='tight' (default 0.1).
+    saved_height_inches : float
+        Total saved image height including padding.
+
+    Returns
+    -------
+    dict or None
+        {x, y, width, height} in image pixels.
+    """
+    try:
+        dpi = fig.dpi
+
+        # Convert display coords to inches
+        x0_inches = window_extent.x0 / dpi
+        y0_inches = window_extent.y0 / dpi
+        x1_inches = window_extent.x1 / dpi
+        y1_inches = window_extent.y1 / dpi
+
+        # Transform to saved image coordinates
+        # Account for tight bbox origin and padding
+        x0_rel = x0_inches - tight_bbox.x0 + pad_inches
+        x1_rel = x1_inches - tight_bbox.x0 + pad_inches
+
+        # Y coordinate flip: matplotlib Y=0 at bottom, image Y=0 at top
+        y0_rel = saved_height_inches - (y1_inches - tight_bbox.y0 + pad_inches)
+        y1_rel = saved_height_inches - (y0_inches - tight_bbox.y0 + pad_inches)
+
+        # Scale to image pixels
+        x0_px = x0_rel * scale_x
+        y0_px = y0_rel * scale_y
+        x1_px = x1_rel * scale_x
+        y1_px = y1_rel * scale_y
+
+        # Clamp to bounds
+        x0_px = max(0, min(x0_px, img_width))
+        x1_px = max(0, min(x1_px, img_width))
+        y0_px = max(0, min(y0_px, img_height))
+        y1_px = max(0, min(y1_px, img_height))
+
+        width = x1_px - x0_px
+        height = y1_px - y0_px
+
+        if width <= 0 or height <= 0:
+            return None
+
+        return {
+            "x": float(x0_px),
+            "y": float(y0_px),
+            "width": float(width),
+            "height": float(height),
+        }
+
+    except Exception:
+        return None
+
+
+def display_to_image(
+    display_x: float,
+    display_y: float,
+    fig: Figure,
+    tight_bbox: Bbox,
+    img_width: int,
+    img_height: int,
+    scale_x: float,
+    scale_y: float,
+    pad_inches: float,
+    saved_height_inches: float,
+) -> Optional[List[float]]:
+    """
+    Transform display coordinates to image pixel coordinates.
+
+    Returns
+    -------
+    list or None
+        [x, y] in image pixels.
+    """
+    try:
+        dpi = fig.dpi
+
+        # Convert to inches
+        x_inches = display_x / dpi
+        y_inches = display_y / dpi
+
+        # Transform to saved image coordinates with padding
+        x_rel = x_inches - tight_bbox.x0 + pad_inches
+
+        # Y coordinate flip: matplotlib Y=0 at bottom, image Y=0 at top
+        y_rel = saved_height_inches - (y_inches - tight_bbox.y0 + pad_inches)
+
+        # Scale to image pixels
+        x_px = x_rel * scale_x
+        y_px = y_rel * scale_y
+
+        # Clamp
+        x_px = max(0, min(x_px, img_width))
+        y_px = max(0, min(y_px, img_height))
+
+        return [float(x_px), float(y_px)]
+
+    except Exception:
+        return None
+
+
+__all__ = ["transform_bbox", "display_to_image"]

figrecipe/_editor/_call_overrides.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Call-specific override application for element properties.
+
+This is the SINGLE SOURCE OF TRUTH for applying element-level changes.
+Both initial render and re-render use this same function through apply_overrides().
+"""
+
+from typing import Any, Dict
+
+from matplotlib.figure import Figure
+
+
+def apply_call_overrides(
+    fig: Figure, call_overrides: Dict[str, Dict[str, Any]], record: Any
+) -> None:
+    """Apply call-specific overrides to figure elements.
+
+    Parameters
+    ----------
+    fig : Figure
+        Matplotlib figure.
+    call_overrides : dict
+        Mapping from call_id to {param: value} overrides.
+    record : FigureRecord
+        Recording record to find call metadata.
+    """
+    from matplotlib.patches import Wedge
+
+    axes_list = fig.get_axes()
+
+    # Build mapping from ax_key to axes index
+    # ax_keys are in format "ax_{row}_{col}", need to map to actual axes indices
+    ax_keys_sorted = sorted(record.axes.keys())
+    ax_key_to_index = {key: idx for idx, key in enumerate(ax_keys_sorted)}
+
+    for call_id, params in call_overrides.items():
+        # Find the call in record to get function type, ax_index, and call position
+        call_function = None
+        ax_index = None
+        ax_record_found = None
+        for ax_key, ax_record in record.axes.items():
+            for call in ax_record.calls:
+                if call.id == call_id:
+                    call_function = call.function
+                    ax_record_found = ax_record
+                    # Use sorted key order to get correct axes index
+                    ax_index = ax_key_to_index.get(ax_key, 0)
+                    break
+            if call_function:
+                break
+
+        if call_function is None or ax_index is None or ax_index >= len(axes_list):
+            continue
+
+        ax = axes_list[ax_index]
+
+        # Apply overrides based on plot type
+        for param, value in params.items():
+            if call_function in ("bar", "barh", "hist"):
+                # Bar/hist creates multiple patches per call - apply to ALL
+                _apply_bar_override(ax, ax_record_found, call_id, param, value)
+            elif call_function == "plot":
+                _apply_line_override(ax, ax_record_found, call_id, param, value)
+            elif call_function == "scatter":
+                _apply_scatter_override(ax, ax_record_found, call_id, param, value)
+            elif call_function == "pie":
+                # Pie wedges - apply to all wedges for this call
+                wedges = [p for p in ax.patches if isinstance(p, Wedge)]
+                for wedge in wedges:
+                    _apply_patch_param(wedge, param, value)
+            elif call_function in ("fill_between", "fill_betweenx"):
+                _apply_fill_override(ax, ax_record_found, call_id, param, value)
+
+
+def _apply_bar_override(ax, ax_record, call_id, param, value):
+    """Apply override to bar/hist patches for a specific call."""
+    from matplotlib.patches import Rectangle
+
+    rectangles = [p for p in ax.patches if isinstance(p, Rectangle)]
+    if not rectangles:
+        return
+
+    # Find all bar/hist calls to determine grouping
+    bar_calls = [c for c in ax_record.calls if c.function in ("bar", "barh", "hist")]
+    if not bar_calls:
+        return
+
+    # Find which call index this is
+    call_idx = next((i for i, c in enumerate(bar_calls) if c.id == call_id), None)
+    if call_idx is None:
+        return
+
+    # Distribute patches among calls
+    patches_per_call = len(rectangles) // len(bar_calls) if bar_calls else 1
+    start_idx = call_idx * patches_per_call
+    end_idx = start_idx + patches_per_call
+
+    # Apply to all patches for this call
+    for patch in rectangles[start_idx:end_idx]:
+        _apply_patch_param(patch, param, value)
+
+
+def _apply_line_override(ax, ax_record, call_id, param, value):
+    """Apply override to line for a specific call."""
+    lines = [line for line in ax.get_lines() if not line.get_label().startswith("_")]
+    line_calls = [c for c in ax_record.calls if c.function == "plot"]
+
+    call_idx = next((i for i, c in enumerate(line_calls) if c.id == call_id), None)
+    if call_idx is not None and call_idx < len(lines):
+        _apply_line_param(lines[call_idx], param, value)
+
+
+def _apply_scatter_override(ax, ax_record, call_id, param, value):
+    """Apply override to scatter collection for a specific call."""
+    from matplotlib.collections import PathCollection
+
+    collections = [c for c in ax.collections if isinstance(c, PathCollection)]
+    scatter_calls = [c for c in ax_record.calls if c.function == "scatter"]
+
+    call_idx = next((i for i, c in enumerate(scatter_calls) if c.id == call_id), None)
+    if call_idx is not None and call_idx < len(collections):
+        _apply_collection_param(collections[call_idx], param, value)
+
+
+def _apply_fill_override(ax, ax_record, call_id, param, value):
+    """Apply override to fill_between for a specific call."""
+    from matplotlib.collections import PolyCollection
+
+    fills = [c for c in ax.collections if isinstance(c, PolyCollection)]
+    fill_calls = [
+        c for c in ax_record.calls if c.function in ("fill_between", "fill_betweenx")
+    ]
+
+    call_idx = next((i for i, c in enumerate(fill_calls) if c.id == call_id), None)
+    if call_idx is not None and call_idx < len(fills):
+        _apply_collection_param(fills[call_idx], param, value)
+
+
+def _apply_patch_param(patch: Any, param: str, value: Any) -> None:
+    """Apply parameter to a patch (bar, wedge, etc.)."""
+    if param == "color":
+        patch.set_facecolor(value)
+    elif param == "edgecolor":
+        patch.set_edgecolor(value)
+    elif param == "linewidth":
+        patch.set_linewidth(value)
+    elif param == "alpha":
+        patch.set_alpha(value)
+
+
+def _apply_line_param(line: Any, param: str, value: Any) -> None:
+    """Apply parameter to a line."""
+    if param == "color":
+        line.set_color(value)
+    elif param == "linewidth":
+        line.set_linewidth(value)
+    elif param == "linestyle":
+        line.set_linestyle(value)
+    elif param == "alpha":
+        line.set_alpha(value)
+    elif param == "marker":
+        line.set_marker(value)
+    elif param == "markersize":
+        line.set_markersize(value)
+
+
+def _apply_collection_param(coll: Any, param: str, value: Any) -> None:
+    """Apply parameter to a collection (scatter, fill)."""
+    if param in ("color", "c"):
+        coll.set_facecolors(value)
+    elif param == "edgecolor":
+        coll.set_edgecolors(value)
+    elif param == "s":
+        coll.set_sizes([value] if not hasattr(value, "__len__") else value)
+    elif param == "alpha":
+        coll.set_alpha(value)
+
+
+__all__ = ["apply_call_overrides"]
+
+# EOF

figrecipe/_editor/_datatable_plot_handlers.py

@@ -0,0 +1,249 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Plot handlers for datatable plotting functionality."""
+
+import numpy as np
+
+
+def dispatch_plot(ax, plot_type, plot_data, columns):
+    """Dispatch plot based on type and data.
+
+    Args:
+        ax: Matplotlib axes object
+        plot_type: Frontend plot type name
+        plot_data: Dict mapping column names to data arrays
+        columns: List of column names in order
+
+    Returns:
+        True on success
+
+    Raises:
+        ValueError: If plot type is unknown
+    """
+    # Map frontend names to matplotlib method names
+    method_name = plot_type
+    if plot_type == "line":
+        method_name = "plot"
+    elif plot_type == "histogram":
+        method_name = "hist"
+
+    # Get the plotting method
+    plot_method = getattr(ax, method_name, None)
+    if plot_method is None:
+        raise ValueError(f"Unknown plot type: {plot_type}")
+
+    # Prepare data arrays
+    data_arrays = [np.array(plot_data.get(c, [])) for c in columns]
+
+    # Handle decoration methods
+    if _handle_decoration(ax, method_name, data_arrays):
+        return True
+
+    # Handle specialized plot types
+    if _handle_specialized(ax, plot_method, method_name, data_arrays, columns):
+        return True
+
+    # Handle standard xy plots
+    _handle_standard_xy(ax, plot_method, method_name, data_arrays, columns)
+    return True
+
+
+def _handle_decoration(ax, method_name, data_arrays):
+    """Handle decoration methods (scalar-based, iterate over rows)."""
+    decoration_methods = {
+        "text",
+        "annotate",
+        "arrow",
+        "axhline",
+        "axvline",
+        "axhspan",
+        "axvspan",
+    }
+
+    if method_name not in decoration_methods:
+        return False
+
+    n_rows = len(data_arrays[0]) if data_arrays else 0
+
+    for row_idx in range(n_rows):
+        row_vals = [arr[row_idx] for arr in data_arrays]
+
+        if method_name == "text" and len(row_vals) >= 2:
+            s = str(row_vals[2]) if len(row_vals) >= 3 else ""
+            ax.text(row_vals[0], row_vals[1], s)
+
+        elif method_name == "annotate":
+            if len(row_vals) >= 3:
+                ax.annotate(str(row_vals[0]), xy=(row_vals[1], row_vals[2]))
+            elif len(row_vals) == 2:
+                ax.annotate("", xy=(row_vals[0], row_vals[1]))
+
+        elif method_name == "arrow" and len(row_vals) >= 4:
+            ax.arrow(
+                row_vals[0],
+                row_vals[1],
+                row_vals[2],
+                row_vals[3],
+                head_width=0.1,
+                head_length=0.05,
+            )
+
+        elif method_name == "axhline" and len(row_vals) >= 1:
+            ax.axhline(y=row_vals[0])
+
+        elif method_name == "axvline" and len(row_vals) >= 1:
+            ax.axvline(x=row_vals[0])
+
+        elif method_name == "axhspan" and len(row_vals) >= 2:
+            ax.axhspan(row_vals[0], row_vals[1], alpha=0.3)
+
+        elif method_name == "axvspan" and len(row_vals) >= 2:
+            ax.axvspan(row_vals[0], row_vals[1], alpha=0.3)
+
+    return True
+
+
+def _handle_specialized(ax, plot_method, method_name, data_arrays, columns):
+    """Handle specialized plot types that need custom argument handling."""
+    if method_name in ("boxplot", "violinplot"):
+        if method_name == "boxplot":
+            plot_method(data_arrays, labels=columns)
+        else:
+            plot_method(data_arrays)
+            ax.set_xticks(range(1, len(columns) + 1))
+            ax.set_xticklabels(columns)
+        return True
+
+    if method_name == "pie":
+        labels = columns[1:] if len(columns) > 1 else None
+        plot_method(data_arrays[0], labels=labels, autopct="%1.1f%%")
+        return True
+
+    if method_name in (
+        "hist",
+        "acorr",
+        "psd",
+        "specgram",
+        "angle_spectrum",
+        "phase_spectrum",
+        "magnitude_spectrum",
+    ):
+        for i, arr in enumerate(data_arrays):
+            plot_method(arr, label=columns[i])
+        return True
+
+    if method_name in ("hist2d", "hexbin", "xcorr", "csd", "cohere"):
+        if len(data_arrays) >= 2:
+            plot_method(data_arrays[0], data_arrays[1])
+        return True
+
+    if method_name in ("fill_between", "fill_betweenx"):
+        if len(data_arrays) >= 3:
+            plot_method(data_arrays[0], data_arrays[1], data_arrays[2], alpha=0.5)
+        elif len(data_arrays) >= 2:
+            plot_method(data_arrays[0], data_arrays[1], alpha=0.5)
+        return True
+
+    if method_name == "errorbar" and len(data_arrays) >= 3:
+        plot_method(
+            data_arrays[0], data_arrays[1], yerr=data_arrays[2], fmt="o-", capsize=3
+        )
+        return True
+
+    if method_name in ("imshow", "matshow"):
+        if len(data_arrays) == 1:
+            arr = data_arrays[0]
+            plot_method(arr.reshape(-1, 1) if arr.ndim == 1 else arr)
+        else:
+            plot_method(np.column_stack(data_arrays))
+        return True
+
+    if method_name in ("contour", "contourf", "pcolor", "pcolormesh"):
+        if len(data_arrays) == 1:
+            arr = data_arrays[0]
+            plot_method(arr.reshape(-1, 1) if arr.ndim == 1 else arr)
+        else:
+            plot_method(np.column_stack(data_arrays))
+        return True
+
+    if method_name in ("quiver", "barbs", "streamplot"):
+        if len(data_arrays) >= 4:
+            plot_method(data_arrays[0], data_arrays[1], data_arrays[2], data_arrays[3])
+        elif len(data_arrays) >= 2:
+            x = np.arange(len(data_arrays[0]))
+            y = np.arange(len(data_arrays[0]))
+            plot_method(x, y, data_arrays[0], data_arrays[1])
+        return True
+
+    if method_name == "eventplot":
+        plot_method(data_arrays)
+        return True
+
+    return False
+
+
+def _handle_standard_xy(ax, plot_method, method_name, data_arrays, columns):
+    """Handle standard x, y plots."""
+    # Detect x and y columns
+    x_idx = None
+    y_indices = []
+    for i, col in enumerate(columns):
+        if col.endswith("_x") or col.lower() == "x":
+            x_idx = i
+        else:
+            y_indices.append(i)
+
+    if x_idx is not None and y_indices:
+        x_data = data_arrays[x_idx]
+        y_arrays = [data_arrays[i] for i in y_indices]
+        y_cols = [columns[i] for i in y_indices]
+    elif len(data_arrays) >= 2:
+        x_data = data_arrays[0]
+        y_arrays = data_arrays[1:]
+        y_cols = columns[1:]
+    else:
+        x_data = np.arange(len(data_arrays[0]))
+        y_arrays = data_arrays
+        y_cols = columns
+
+    for i, y_data in enumerate(y_arrays):
+        if method_name == "bar" and len(y_arrays) > 1:
+            width = 0.8 / len(y_arrays)
+            offset = (i - len(y_arrays) / 2 + 0.5) * width
+            plot_method(x_data + offset, y_data, width=width, label=y_cols[i])
+        elif method_name == "barh":
+            plot_method(x_data, y_data, label=y_cols[i])
+        elif method_name in (
+            "plot",
+            "scatter",
+            "step",
+            "loglog",
+            "semilogx",
+            "semilogy",
+        ):
+            plot_method(x_data, y_data, label=y_cols[i])
+        elif method_name == "stem":
+            plot_method(x_data, y_data, label=y_cols[i])
+        elif method_name == "fill":
+            plot_method(x_data, y_data, alpha=0.5, label=y_cols[i])
+        elif method_name == "stairs":
+            plot_method(y_data, label=y_cols[i])
+        elif method_name == "stackplot":
+            plot_method(x_data, *y_arrays, labels=y_cols)
+            break
+        else:
+            try:
+                plot_method(x_data, y_data, label=y_cols[i])
+            except TypeError:
+                plot_method(y_data, label=y_cols[i])
+
+    # Set labels
+    if len(columns) >= 2:
+        ax.set_xlabel(columns[0])
+    if len(y_cols) == 1:
+        ax.set_ylabel(y_cols[0])
+    if len(y_cols) > 1:
+        ax.legend()
+
+
+__all__ = ["dispatch_plot"]