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

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

figrecipe/_editor/_figure_layout.py

@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Figure-level layout handling for the editor.
+
+Applies spacing and margin overrides to figure layout via subplots_adjust.
+"""
+
+from typing import Any, Dict, Optional
+
+from matplotlib.figure import Figure
+
+
+def apply_figure_layout_overrides(
+    fig: Figure, overrides: Dict[str, Any], record: Optional[Any] = None
+) -> None:
+    """Apply figure-level layout overrides (spacing, margins).
+
+    Converts mm-based spacing and margin values to subplots_adjust parameters.
+
+    Parameters
+    ----------
+    fig : Figure
+        Matplotlib figure.
+    overrides : dict
+        Style overrides containing spacing_horizontal_mm, spacing_vertical_mm,
+        margins_left_mm, margins_right_mm, margins_bottom_mm, margins_top_mm.
+    record : FigureRecord, optional
+        Recording record to get original layout and axes dimensions.
+    """
+    # Check if any layout overrides are present
+    spacing_h = overrides.get("spacing_horizontal_mm")
+    spacing_v = overrides.get("spacing_vertical_mm")
+    margin_l = overrides.get("margins_left_mm")
+    margin_r = overrides.get("margins_right_mm")
+    margin_b = overrides.get("margins_bottom_mm")
+    margin_t = overrides.get("margins_top_mm")
+
+    has_layout_overrides = any(
+        v is not None
+        for v in [spacing_h, spacing_v, margin_l, margin_r, margin_b, margin_t]
+    )
+
+    if not has_layout_overrides:
+        return
+
+    # Skip if figure uses constrained_layout (incompatible with subplots_adjust)
+    layout_engine = fig.get_layout_engine()
+    if layout_engine is not None:
+        layout_name = getattr(layout_engine, "__class__", type(layout_engine)).__name__
+        if "Constrained" in layout_name:
+            return
+
+    # Get current figure size in inches
+    fig_width_inch, fig_height_inch = fig.get_size_inches()
+
+    # Convert to mm (1 inch = 25.4 mm)
+    fig_width_mm = fig_width_inch * 25.4
+    fig_height_mm = fig_height_inch * 25.4
+
+    # Determine grid dimensions from axes
+    axes_list = fig.get_axes()
+    if not axes_list:
+        return
+
+    nrows, ncols = _get_grid_dimensions(record, axes_list)
+
+    # Get current layout parameters
+    current_params = fig.subplotpars
+    current_left = current_params.left
+    current_right = current_params.right
+    current_bottom = current_params.bottom
+    current_top = current_params.top
+    current_wspace = current_params.wspace
+    current_hspace = current_params.hspace
+
+    # Calculate current mm values from figure layout
+    current_ml_mm = current_left * fig_width_mm
+    current_mr_mm = (1 - current_right) * fig_width_mm
+    current_mb_mm = current_bottom * fig_height_mm
+    current_mt_mm = (1 - current_top) * fig_height_mm
+
+    # Calculate axes dimensions
+    aw, ah = _calculate_axes_dimensions(
+        fig_width_mm,
+        fig_height_mm,
+        current_ml_mm,
+        current_mr_mm,
+        current_mb_mm,
+        current_mt_mm,
+        current_wspace,
+        current_hspace,
+        nrows,
+        ncols,
+    )
+
+    # Apply overrides (use current values as fallback)
+    ml = margin_l if margin_l is not None else current_ml_mm
+    mr = margin_r if margin_r is not None else current_mr_mm
+    mb = margin_b if margin_b is not None else current_mb_mm
+    mt = margin_t if margin_t is not None else current_mt_mm
+    sw = (
+        spacing_h
+        if spacing_h is not None
+        else (current_wspace * aw if ncols > 1 else 0)
+    )
+    sh = (
+        spacing_v
+        if spacing_v is not None
+        else (current_hspace * ah if nrows > 1 else 0)
+    )
+
+    # Calculate new layout parameters
+    left = ml / fig_width_mm
+    right = 1 - (mr / fig_width_mm)
+    bottom = mb / fig_height_mm
+    top = 1 - (mt / fig_height_mm)
+
+    # Calculate wspace/hspace as fraction of axes dimensions
+    wspace = sw / aw if ncols > 1 and aw > 0 else 0
+    hspace = sh / ah if nrows > 1 and ah > 0 else 0
+
+    # Apply the layout (suppress warning about layout engine incompatibility
+    # since we've already checked and skipped constrained_layout figures)
+    import warnings
+
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", "This figure was using a layout engine")
+        fig.subplots_adjust(
+            left=left,
+            right=right,
+            bottom=bottom,
+            top=top,
+            wspace=wspace,
+            hspace=hspace,
+        )
+
+
+def _get_grid_dimensions(record: Optional[Any], axes_list: list) -> tuple:
+    """Get grid dimensions from record or infer from axes.
+
+    Returns
+    -------
+    tuple
+        (nrows, ncols)
+    """
+    nrows, ncols = 1, 1
+
+    if record and hasattr(record, "axes"):
+        for ax_key in record.axes.keys():
+            parts = ax_key.split("_")
+            if len(parts) >= 3:
+                nrows = max(nrows, int(parts[1]) + 1)
+                ncols = max(ncols, int(parts[2]) + 1)
+    else:
+        # Infer from axes count (assume square-ish grid)
+        import math
+
+        n_axes = len(axes_list)
+        ncols = int(math.ceil(math.sqrt(n_axes)))
+        nrows = int(math.ceil(n_axes / ncols))
+
+    return nrows, ncols
+
+
+def _calculate_axes_dimensions(
+    fig_width_mm: float,
+    fig_height_mm: float,
+    ml_mm: float,
+    mr_mm: float,
+    mb_mm: float,
+    mt_mm: float,
+    wspace: float,
+    hspace: float,
+    nrows: int,
+    ncols: int,
+) -> tuple:
+    """Calculate single axes dimensions from figure layout.
+
+    Returns
+    -------
+    tuple
+        (axes_width_mm, axes_height_mm)
+    """
+    content_width_mm = fig_width_mm - ml_mm - mr_mm
+    content_height_mm = fig_height_mm - mb_mm - mt_mm
+
+    # wspace/hspace are fractions of axes width/height
+    # total_width = ncols * aw + (ncols-1) * sw = ncols * aw + (ncols-1) * wspace * aw
+    # total_width = aw * (ncols + (ncols-1) * wspace)
+    if ncols > 1:
+        aw = (
+            content_width_mm / (ncols + (ncols - 1) * wspace)
+            if ncols > 0
+            else content_width_mm
+        )
+    else:
+        aw = content_width_mm
+
+    if nrows > 1:
+        ah = (
+            content_height_mm / (nrows + (nrows - 1) * hspace)
+            if nrows > 0
+            else content_height_mm
+        )
+    else:
+        ah = content_height_mm
+
+    return aw, ah
+
+
+__all__ = ["apply_figure_layout_overrides"]