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

figrecipe/_reproducer/_custom_plots.py

@@ -0,0 +1,279 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Custom plot replay functions (joyplot, swarmplot) for figure reproduction."""
+
+from typing import Any, List
+
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.axes import Axes
+
+from .._recorder import CallRecord
+
+
+def replay_joyplot_call(ax: Axes, call: CallRecord) -> Any:
+    """Replay a joyplot call on an axes.
+
+    Parameters
+    ----------
+    ax : Axes
+        The matplotlib axes.
+    call : CallRecord
+        The joyplot call to replay.
+
+    Returns
+    -------
+    Any
+        Result of the joyplot call.
+    """
+    from scipy import stats
+
+    from ._core import _reconstruct_kwargs, _reconstruct_value
+
+    # Reconstruct args
+    arrays = []
+    for arg_data in call.args:
+        value = _reconstruct_value(arg_data)
+        if isinstance(value, list):
+            # Could be a list of arrays
+            arrays = [np.asarray(arr) for arr in value]
+        else:
+            arrays.append(np.asarray(value))
+
+    if not arrays:
+        return None
+
+    # Get kwargs
+    kwargs = _reconstruct_kwargs(call.kwargs)
+    overlap = kwargs.get("overlap", 0.5)
+    fill_alpha = kwargs.get("fill_alpha", 0.7)
+    line_alpha = kwargs.get("line_alpha", 1.0)
+    labels = kwargs.get("labels")
+
+    n_ridges = len(arrays)
+
+    # Get colors from style
+    from ..styles import get_style
+
+    style = get_style()
+    if style and "colors" in style and "palette" in style.colors:
+        palette = list(style.colors.palette)
+        colors = []
+        for c in palette:
+            if isinstance(c, (list, tuple)) and len(c) >= 3:
+                if all(v <= 1.0 for v in c):
+                    colors.append(tuple(c))
+                else:
+                    colors.append(tuple(v / 255.0 for v in c))
+            else:
+                colors.append(c)
+    else:
+        colors = [c["color"] for c in plt.rcParams["axes.prop_cycle"]]
+
+    # Calculate global x range
+    all_data = np.concatenate([np.asarray(arr) for arr in arrays])
+    x_min, x_max = np.min(all_data), np.max(all_data)
+    x_range = x_max - x_min
+    x_padding = x_range * 0.1
+    x = np.linspace(x_min - x_padding, x_max + x_padding, 200)
+
+    # Calculate KDEs and find max density for scaling
+    kdes = []
+    max_density = 0
+    for arr in arrays:
+        arr = np.asarray(arr)
+        if len(arr) > 1:
+            kde = stats.gaussian_kde(arr)
+            density = kde(x)
+            kdes.append(density)
+            max_density = max(max_density, np.max(density))
+        else:
+            kdes.append(np.zeros_like(x))
+
+    # Scale factor for ridge height
+    ridge_height = 1.0 / (1.0 - overlap * 0.5) if overlap < 1 else 2.0
+
+    # Get line width from style
+    from .._utils._units import mm_to_pt
+
+    lw = mm_to_pt(0.2)  # Default
+    if style and "lines" in style:
+        lw = mm_to_pt(style.lines.get("trace_mm", 0.2))
+
+    # Plot each ridge from back to front
+    for i in range(n_ridges - 1, -1, -1):
+        color = colors[i % len(colors)]
+        baseline = i * (1.0 - overlap)
+
+        # Scale density to fit nicely
+        scaled_density = (
+            kdes[i] / max_density * ridge_height if max_density > 0 else kdes[i]
+        )
+
+        # Fill
+        ax.fill_between(
+            x,
+            baseline,
+            baseline + scaled_density,
+            facecolor=color,
+            edgecolor="none",
+            alpha=fill_alpha,
+        )
+        # Line on top
+        ax.plot(
+            x, baseline + scaled_density, color=color, alpha=line_alpha, linewidth=lw
+        )
+
+    # Set y limits
+    ax.set_ylim(-0.1, n_ridges * (1.0 - overlap) + ridge_height)
+
+    # Set y-axis labels if provided
+    if labels:
+        y_positions = [(i * (1.0 - overlap)) + 0.3 for i in range(n_ridges)]
+        ax.set_yticks(y_positions)
+        ax.set_yticklabels(labels)
+    else:
+        ax.set_yticks([])
+
+    return ax
+
+
+def replay_swarmplot_call(ax: Axes, call: CallRecord) -> List[Any]:
+    """Replay a swarmplot call on an axes.
+
+    Parameters
+    ----------
+    ax : Axes
+        The matplotlib axes.
+    call : CallRecord
+        The swarmplot call to replay.
+
+    Returns
+    -------
+    list
+        List of PathCollection objects.
+    """
+    from ._core import _reconstruct_kwargs, _reconstruct_value
+
+    # Reconstruct args
+    data = []
+    for arg_data in call.args:
+        value = _reconstruct_value(arg_data)
+        if isinstance(value, list):
+            # Could be a list of arrays
+            data = [np.asarray(arr) for arr in value]
+        else:
+            data.append(np.asarray(value))
+
+    if not data:
+        return []
+
+    # Get kwargs
+    kwargs = _reconstruct_kwargs(call.kwargs)
+    positions = kwargs.get("positions")
+    size = kwargs.get("size", 0.8)
+    alpha = kwargs.get("alpha", 0.7)
+    jitter = kwargs.get("jitter", 0.3)
+
+    if positions is None:
+        positions = list(range(1, len(data) + 1))
+
+    # Get style
+    from .._utils._units import mm_to_pt
+    from ..styles import get_style
+
+    style = get_style()
+    size_pt = mm_to_pt(size) ** 2  # matplotlib uses area
+
+    # Get colors
+    if style and "colors" in style and "palette" in style.colors:
+        palette = list(style.colors.palette)
+        colors = []
+        for c in palette:
+            if isinstance(c, (list, tuple)) and len(c) >= 3:
+                if all(v <= 1.0 for v in c):
+                    colors.append(tuple(c))
+                else:
+                    colors.append(tuple(v / 255.0 for v in c))
+            else:
+                colors.append(c)
+    else:
+        colors = [c["color"] for c in plt.rcParams["axes.prop_cycle"]]
+
+    # Random generator for reproducible jitter
+    rng = np.random.default_rng(42)
+
+    results = []
+    for i, (arr, pos) in enumerate(zip(data, positions)):
+        arr = np.asarray(arr)
+
+        # Create jittered x positions using simplified beeswarm
+        x_offsets = _beeswarm_positions(arr, jitter, rng)
+        x_positions = pos + x_offsets
+
+        c = colors[i % len(colors)]
+        result = ax.scatter(
+            x_positions,
+            arr,
+            s=size_pt,
+            c=[c],
+            alpha=alpha,
+        )
+        results.append(result)
+
+    return results
+
+
+def _beeswarm_positions(
+    data: np.ndarray,
+    width: float,
+    rng: np.random.Generator,
+) -> np.ndarray:
+    """Calculate beeswarm-style x positions to minimize overlap.
+
+    Parameters
+    ----------
+    data : array
+        Y values of points.
+    width : float
+        Maximum jitter width.
+    rng : Generator
+        Random number generator.
+
+    Returns
+    -------
+    array
+        X offsets for each point.
+    """
+    n = len(data)
+    if n == 0:
+        return np.array([])
+
+    # Sort data and get order
+    order = np.argsort(data)
+    sorted_data = data[order]
+
+    # Group nearby points and offset them
+    x_offsets = np.zeros(n)
+
+    # Simple approach: bin by quantiles and spread within each bin
+    n_bins = max(1, int(np.sqrt(n)))
+    bin_edges = np.percentile(sorted_data, np.linspace(0, 100, n_bins + 1))
+
+    for i in range(n_bins):
+        mask = (sorted_data >= bin_edges[i]) & (sorted_data <= bin_edges[i + 1])
+        n_in_bin = mask.sum()
+        if n_in_bin > 0:
+            # Spread points evenly within bin width
+            offsets = np.linspace(-width / 2, width / 2, n_in_bin)
+            # Add small random noise
+            offsets += rng.uniform(-width * 0.1, width * 0.1, n_in_bin)
+            x_offsets[mask] = offsets
+
+    # Restore original order
+    result = np.zeros(n)
+    result[order] = x_offsets
+    return result
+
+
+__all__ = ["replay_joyplot_call", "replay_swarmplot_call"]

figrecipe/_reproducer/_seaborn.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Seaborn plot replay for figure reproduction."""
+
+from typing import Any
+
+from matplotlib.axes import Axes
+
+from .._recorder import CallRecord
+
+
+def replay_seaborn_call(ax: Axes, call: CallRecord) -> Any:
+    """Replay a seaborn call on an axes.
+
+    Parameters
+    ----------
+    ax : Axes
+        The matplotlib axes.
+    call : CallRecord
+        The seaborn call to replay.
+
+    Returns
+    -------
+    Any
+        Result of the seaborn call.
+    """
+    try:
+        import pandas as pd
+        import seaborn as sns
+    except ImportError:
+        import warnings
+
+        warnings.warn("seaborn/pandas required to replay seaborn calls")
+        return None
+
+    from ._core import _reconstruct_value
+
+    # Get the seaborn function name (remove "sns." prefix)
+    func_name = call.function[4:]  # Remove "sns."
+    func = getattr(sns, func_name, None)
+
+    if func is None:
+        import warnings
+
+        warnings.warn(f"Seaborn function {func_name} not found")
+        return None
+
+    # Reconstruct data from args
+    # Args contain column data with "param" field indicating the parameter name
+    data_dict = {}
+    param_mapping = {}  # Maps param name to column name
+
+    for arg_data in call.args:
+        param = arg_data.get("param")
+        name = arg_data.get("name")
+        value = _reconstruct_value(arg_data)
+
+        if param is not None:
+            # This is a DataFrame column
+            col_name = name if name else param
+            data_dict[col_name] = value
+            param_mapping[param] = col_name
+
+    # Build kwargs
+    kwargs = call.kwargs.copy()
+
+    # Remove internal keys
+    internal_keys = [k for k in kwargs.keys() if k.startswith("_")]
+    for key in internal_keys:
+        kwargs.pop(key, None)
+
+    # If we have data columns, create a DataFrame
+    if data_dict:
+        df = pd.DataFrame(data_dict)
+        kwargs["data"] = df
+
+        # Update column name references in kwargs
+        for param, col_name in param_mapping.items():
+            if param in ["x", "y", "hue", "size", "style", "row", "col"]:
+                kwargs[param] = col_name
+
+    # Add the axes
+    kwargs["ax"] = ax
+
+    # Convert certain list parameters back to tuples (YAML serializes tuples as lists)
+    # 'sizes' in seaborn expects a tuple (min, max) for range, not a list
+    if "sizes" in kwargs and isinstance(kwargs["sizes"], list):
+        kwargs["sizes"] = tuple(kwargs["sizes"])
+
+    # Call the seaborn function
+    try:
+        return func(**kwargs)
+    except Exception as e:
+        import warnings
+
+        warnings.warn(f"Failed to replay sns.{func_name}: {e}")
+        return None
+
+
+__all__ = ["replay_seaborn_call"]

figrecipe/_reproducer/_violin.py

@@ -0,0 +1,186 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Violin plot replay for figure reproduction."""
+
+from typing import Any, Dict
+
+import numpy as np
+from matplotlib.axes import Axes
+
+from .._recorder import CallRecord
+
+
+def replay_violinplot_call(ax: Axes, call: CallRecord) -> Any:
+    """Replay a violinplot call with inner option support.
+
+    Parameters
+    ----------
+    ax : Axes
+        The matplotlib axes.
+    call : CallRecord
+        The violinplot call to replay.
+
+    Returns
+    -------
+    Any
+        Result of the violinplot call.
+    """
+    # Import from _core module (will be available after full package setup)
+    from ._core import _reconstruct_kwargs, _reconstruct_value
+
+    # Reconstruct args
+    args = []
+    for arg_data in call.args:
+        value = _reconstruct_value(arg_data)
+        args.append(value)
+
+    # Get kwargs and reconstruct arrays
+    kwargs = _reconstruct_kwargs(call.kwargs)
+
+    # Extract inner option (not a matplotlib kwarg)
+    inner = kwargs.pop("inner", "box")
+
+    # Get display options
+    showmeans = kwargs.pop("showmeans", False)
+    showmedians = kwargs.pop("showmedians", True)
+    showextrema = kwargs.pop("showextrema", False)
+
+    # When using inner box/swarm, suppress default median/extrema lines
+    if inner in ("box", "swarm"):
+        showmedians = False
+        showextrema = False
+
+    # Call matplotlib's violinplot
+    try:
+        result = ax.violinplot(
+            *args,
+            showmeans=showmeans,
+            showmedians=showmedians,
+            showextrema=showextrema,
+            **kwargs,
+        )
+
+        # Get style settings for inner display
+        from ..styles import get_style
+
+        style = get_style()
+        violin_style = style.get("violinplot", {}) if style else {}
+
+        # Apply alpha from style to violin bodies
+        alpha = violin_style.get("alpha", 0.7)
+        if "bodies" in result:
+            for body in result["bodies"]:
+                body.set_alpha(alpha)
+
+        # Determine positions
+        dataset = args[0] if args else []
+        positions = kwargs.get("positions")
+        if positions is None:
+            positions = list(range(1, len(dataset) + 1))
+
+        # Overlay inner elements based on inner type
+        if inner == "box":
+            _add_violin_inner_box(ax, dataset, positions, violin_style)
+        elif inner == "swarm":
+            _add_violin_inner_swarm(ax, dataset, positions, violin_style)
+        elif inner == "stick":
+            _add_violin_inner_stick(ax, dataset, positions, violin_style)
+        elif inner == "point":
+            _add_violin_inner_point(ax, dataset, positions, violin_style)
+
+        return result
+    except Exception as e:
+        import warnings
+
+        warnings.warn(f"Failed to replay violinplot: {e}")
+        return None
+
+
+def _add_violin_inner_box(ax: Axes, dataset, positions, style: Dict[str, Any]) -> None:
+    """Add box plot inside violin for reproduction."""
+    from ..styles._style_applier import mm_to_pt
+
+    whisker_lw = mm_to_pt(style.get("whisker_mm", 0.2))
+    median_size = mm_to_pt(style.get("median_mm", 0.8))
+
+    for data, pos in zip(dataset, positions):
+        data = np.asarray(data)
+        q1, median, q3 = np.percentile(data, [25, 50, 75])
+        iqr = q3 - q1
+        whisker_low = max(data.min(), q1 - 1.5 * iqr)
+        whisker_high = min(data.max(), q3 + 1.5 * iqr)
+
+        # Draw box (Q1 to Q3)
+        ax.vlines(pos, q1, q3, colors="black", linewidths=whisker_lw, zorder=3)
+        # Draw whiskers
+        ax.vlines(
+            pos, whisker_low, q1, colors="black", linewidths=whisker_lw * 0.5, zorder=3
+        )
+        ax.vlines(
+            pos, q3, whisker_high, colors="black", linewidths=whisker_lw * 0.5, zorder=3
+        )
+        # Draw median as a white dot with black edge
+        ax.scatter(
+            [pos],
+            [median],
+            s=median_size**2,
+            c="white",
+            edgecolors="black",
+            linewidths=whisker_lw,
+            zorder=4,
+        )
+
+
+def _add_violin_inner_swarm(
+    ax: Axes, dataset, positions, style: Dict[str, Any]
+) -> None:
+    """Add swarm points inside violin for reproduction."""
+    from ..styles._style_applier import mm_to_pt
+
+    point_size = mm_to_pt(style.get("median_mm", 0.8))
+
+    for data, pos in zip(dataset, positions):
+        data = np.asarray(data)
+        n = len(data)
+        jitter = np.random.default_rng(42).uniform(-0.15, 0.15, n)
+        x_positions = pos + jitter
+        ax.scatter(x_positions, data, s=point_size**2, c="black", alpha=0.5, zorder=3)
+
+
+def _add_violin_inner_stick(
+    ax: Axes, dataset, positions, style: Dict[str, Any]
+) -> None:
+    """Add stick markers inside violin for reproduction."""
+    from ..styles._style_applier import mm_to_pt
+
+    lw = mm_to_pt(style.get("whisker_mm", 0.2))
+
+    for data, pos in zip(dataset, positions):
+        data = np.asarray(data)
+        for val in data:
+            ax.hlines(
+                val,
+                pos - 0.05,
+                pos + 0.05,
+                colors="black",
+                linewidths=lw * 0.5,
+                alpha=0.3,
+                zorder=3,
+            )
+
+
+def _add_violin_inner_point(
+    ax: Axes, dataset, positions, style: Dict[str, Any]
+) -> None:
+    """Add point markers inside violin for reproduction."""
+    from ..styles._style_applier import mm_to_pt
+
+    point_size = mm_to_pt(style.get("median_mm", 0.8)) * 0.5
+
+    for data, pos in zip(dataset, positions):
+        data = np.asarray(data)
+        x_positions = np.full_like(data, pos)
+        ax.scatter(x_positions, data, s=point_size**2, c="black", alpha=0.3, zorder=3)
+
+
+__all__ = ["replay_violinplot_call"]