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

figrecipe/_wrappers/_axes_helpers.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Helper functions for RecordingAxes."""
+
+from typing import Any, Dict, Optional
+
+
+def args_have_fmt_color(args: tuple) -> bool:
+    """Check if args contain a matplotlib fmt string with color specifier."""
+    color_codes = set("bgrcmykw")
+    for arg in args:
+        if isinstance(arg, str) and len(arg) >= 1 and len(arg) <= 4:
+            if arg[0] in color_codes:
+                return True
+    return False
+
+
+def extract_color_from_result(method_name: str, result) -> Optional[str]:
+    """Extract actual color used from plot result."""
+    try:
+        if method_name == "plot":
+            if result and hasattr(result[0], "get_color"):
+                return result[0].get_color()
+        elif method_name == "scatter":
+            if hasattr(result, "get_facecolor"):
+                fc = result.get_facecolor()
+                if len(fc) > 0:
+                    import matplotlib.colors as mcolors
+
+                    return mcolors.to_hex(fc[0])
+        elif method_name in ("bar", "barh"):
+            if hasattr(result, "patches") and result.patches:
+                fc = result.patches[0].get_facecolor()
+                import matplotlib.colors as mcolors
+
+                return mcolors.to_hex(fc)
+        elif method_name == "step":
+            if result and hasattr(result[0], "get_color"):
+                return result[0].get_color()
+        elif method_name == "fill_between":
+            if hasattr(result, "get_facecolor"):
+                fc = result.get_facecolor()
+                if len(fc) > 0:
+                    import matplotlib.colors as mcolors
+
+                    return mcolors.to_hex(fc[0])
+    except Exception:
+        pass
+    return None
+
+
+def process_result_refs_in_args(
+    args: tuple,
+    method_name: str,
+    result_refs: Dict[int, str],
+    referencing_methods: set,
+) -> tuple:
+    """Process args to replace matplotlib objects with references."""
+    if method_name not in referencing_methods:
+        return args
+
+    import builtins
+
+    processed = []
+    for arg in args:
+        obj_id = builtins.id(arg)
+        if obj_id in result_refs:
+            processed.append({"__ref__": result_refs[obj_id]})
+        else:
+            processed.append(arg)
+    return tuple(processed)
+
+
+def record_call_with_color_capture(
+    recorder,
+    position: tuple,
+    method_name: str,
+    args: tuple,
+    kwargs: dict,
+    result,
+    call_id: Optional[str],
+    result_refs: Dict[int, str],
+    referencing_methods: set,
+    referenceable_methods: set,
+) -> Any:
+    """Record a call with color capture and result reference handling."""
+    recorded_kwargs = kwargs.copy()
+
+    # Capture colors for methods using color cycle
+    if method_name in ("plot", "scatter", "bar", "barh", "step", "fill_between"):
+        has_fmt_color = args_have_fmt_color(args)
+        if (
+            "color" not in recorded_kwargs
+            and "c" not in recorded_kwargs
+            and not has_fmt_color
+        ):
+            actual_color = extract_color_from_result(method_name, result)
+            if actual_color is not None:
+                recorded_kwargs["color"] = actual_color
+
+        if method_name == "fill_between" and "edgecolor" not in recorded_kwargs:
+            if hasattr(result, "get_edgecolor"):
+                ec = result.get_edgecolor()
+                if len(ec) == 0:
+                    recorded_kwargs["edgecolor"] = "none"
+
+    # Process args for result references
+    processed_args = process_result_refs_in_args(
+        args, method_name, result_refs, referencing_methods
+    )
+
+    call_record = recorder.record_call(
+        ax_position=position,
+        method_name=method_name,
+        args=processed_args,
+        kwargs=recorded_kwargs,
+        call_id=call_id,
+    )
+
+    # Store result reference if applicable
+    if method_name in referenceable_methods:
+        import builtins
+
+        result_refs[builtins.id(result)] = call_record.id
+
+    return call_record
+
+
+__all__ = [
+    "args_have_fmt_color",
+    "extract_color_from_result",
+    "process_result_refs_in_args",
+    "record_call_with_color_capture",
+]
+
+# EOF

figrecipe/_wrappers/_axes_plots.py

@@ -0,0 +1,418 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Custom plotting methods for RecordingAxes."""
+
+from typing import TYPE_CHECKING, Any, List, Optional
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from matplotlib.axes import Axes
+
+    from .._recorder import Recorder
+
+
+def pie_plot(
+    ax: "Axes",
+    x,
+    recorder: "Recorder",
+    position: tuple,
+    track: bool,
+    call_id: Optional[str],
+    **kwargs,
+) -> tuple:
+    """Pie chart with automatic SCITEX styling."""
+    from ..styles import get_style
+
+    # Get style settings before calling pie
+    style = get_style()
+    pie_style = style.get("pie", {}) if style else {}
+
+    # Apply wedge edge styling via wedgeprops if not already specified
+    kwargs = _apply_pie_wedgeprops(kwargs, pie_style)
+
+    # Call matplotlib's pie
+    result = ax.pie(x, **kwargs)
+
+    # Apply additional style settings
+    if style:
+        _apply_pie_text_style(ax, pie_style, style)
+        _apply_pie_axes_visibility(ax, pie_style)
+
+    # Record the call if tracking is enabled
+    if track:
+        recorder.record_call(
+            ax_position=position,
+            method_name="pie",
+            args=(x,),
+            kwargs=kwargs,
+            call_id=call_id,
+        )
+
+    return result
+
+
+def _apply_pie_wedgeprops(kwargs: dict, pie_style: dict) -> dict:
+    """Apply wedge properties to pie kwargs."""
+    from .._utils._units import mm_to_pt
+
+    edge_color = pie_style.get("edge_color", "black")
+    edge_mm = pie_style.get("edge_mm", 0.2)
+    edge_lw = mm_to_pt(edge_mm)
+
+    if "wedgeprops" not in kwargs:
+        kwargs["wedgeprops"] = {"edgecolor": edge_color, "linewidth": edge_lw}
+    elif "edgecolor" not in kwargs.get("wedgeprops", {}):
+        kwargs["wedgeprops"]["edgecolor"] = edge_color
+        kwargs["wedgeprops"]["linewidth"] = edge_lw
+
+    return kwargs
+
+
+def _apply_pie_text_style(ax: "Axes", pie_style: dict, style) -> None:
+    """Apply text styling to pie chart."""
+    from ..styles._style_applier import check_font
+
+    text_pt = pie_style.get("text_pt", 6)
+    font_family = check_font(style.get("fonts", {}).get("family", "Arial"))
+
+    # Get text color from rcParams for dark mode support
+    import matplotlib.pyplot as mpl_plt
+
+    text_color = mpl_plt.rcParams.get("text.color", "black")
+
+    for text in ax.texts:
+        text.set_fontsize(text_pt)
+        text.set_fontfamily(font_family)
+        text.set_color(text_color)
+
+
+def _apply_pie_axes_visibility(ax: "Axes", pie_style: dict) -> None:
+    """Apply axes visibility settings for pie chart."""
+    show_axes = pie_style.get("show_axes", False)
+    if not show_axes:
+        ax.set_xticks([])
+        ax.set_yticks([])
+        ax.set_xticklabels([])
+        ax.set_yticklabels([])
+        for spine in ax.spines.values():
+            spine.set_visible(False)
+
+
+def imshow_plot(
+    ax: "Axes",
+    X,
+    recorder: "Recorder",
+    position: tuple,
+    track: bool,
+    call_id: Optional[str],
+    **kwargs,
+):
+    """Display image with automatic SCITEX styling."""
+    from ..styles import get_style
+
+    # Call matplotlib's imshow
+    result = ax.imshow(X, **kwargs)
+
+    # Get style settings
+    style = get_style()
+    if style:
+        imshow_style = style.get("imshow", {})
+        show_axes = imshow_style.get("show_axes", True)
+        show_labels = imshow_style.get("show_labels", True)
+
+        if not show_axes:
+            ax.set_xticks([])
+            ax.set_yticks([])
+            ax.set_xticklabels([])
+            ax.set_yticklabels([])
+            for spine in ax.spines.values():
+                spine.set_visible(False)
+
+        if not show_labels:
+            ax.set_xlabel("")
+            ax.set_ylabel("")
+
+    # Record the call if tracking is enabled
+    if track:
+        recorder.record_call(
+            ax_position=position,
+            method_name="imshow",
+            args=(X,),
+            kwargs=kwargs,
+            call_id=call_id,
+        )
+
+    return result
+
+
+def violinplot_plot(
+    ax: "Axes",
+    dataset,
+    positions,
+    recorder: "Recorder",
+    position: tuple,
+    track: bool,
+    call_id: Optional[str],
+    inner: Optional[str],
+    **kwargs,
+) -> dict:
+    """Violin plot with support for inner display options."""
+    from ..styles import get_style
+
+    # Get style settings
+    style = get_style()
+    violin_style = style.get("violinplot", {}) if style else {}
+
+    # Determine inner type
+    if inner is None:
+        inner = violin_style.get("inner", "box")
+
+    # Get violin display options from style
+    showmeans = kwargs.pop("showmeans", violin_style.get("showmeans", False))
+    showmedians = kwargs.pop("showmedians", violin_style.get("showmedians", True))
+    showextrema = kwargs.pop("showextrema", violin_style.get("showextrema", False))
+
+    # Call matplotlib's violinplot
+    result = ax.violinplot(
+        dataset,
+        positions=positions,
+        showmeans=showmeans,
+        showmedians=showmedians if inner not in ("box", "swarm") else False,
+        showextrema=showextrema if inner not in ("box", "swarm") else False,
+        **kwargs,
+    )
+
+    # 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)
+
+    # Overlay inner elements
+    if positions is None:
+        positions = list(range(1, len(dataset) + 1))
+
+    _add_violin_inner_elements(ax, dataset, positions, inner, violin_style)
+
+    # Record the call if tracking is enabled
+    if track:
+        recorded_kwargs = kwargs.copy()
+        recorded_kwargs["inner"] = inner
+        recorded_kwargs["showmeans"] = showmeans
+        recorded_kwargs["showmedians"] = showmedians
+        recorded_kwargs["showextrema"] = showextrema
+
+        recorder.record_call(
+            ax_position=position,
+            method_name="violinplot",
+            args=(dataset,),
+            kwargs=recorded_kwargs,
+            call_id=call_id,
+        )
+
+    return result
+
+
+def _add_violin_inner_elements(
+    ax: "Axes", dataset, positions, inner: str, violin_style: dict
+) -> None:
+    """Add inner elements to violin plot."""
+    from ._violin_helpers import (
+        add_violin_inner_box,
+        add_violin_inner_point,
+        add_violin_inner_stick,
+        add_violin_inner_swarm,
+    )
+
+    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)
+
+
+def joyplot_plot(
+    ax: "Axes",
+    recording_axes,
+    arrays,
+    recorder: "Recorder",
+    position: tuple,
+    track: bool,
+    call_id: Optional[str],
+    overlap: float,
+    fill_alpha: float,
+    line_alpha: float,
+    colors,
+    labels,
+    **kwargs,
+):
+    """Create a joyplot (ridgeline plot)."""
+    from .._utils._units import mm_to_pt
+    from ..styles import get_style
+
+    # Convert dict to list of arrays
+    if isinstance(arrays, dict):
+        if labels is None:
+            labels = list(arrays.keys())
+        arrays = list(arrays.values())
+
+    n_ridges = len(arrays)
+
+    from ._plot_helpers import compute_joyplot_kdes, get_colors_from_style
+
+    # Get colors from style or use default cycle
+    colors = get_colors_from_style(n_ridges, colors)
+
+    # 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
+    kdes, max_density = compute_joyplot_kdes(arrays, 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
+    style = get_style()
+    lw = mm_to_pt(0.2)
+    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)
+        scaled_density = (
+            kdes[i] / max_density * ridge_height if max_density > 0 else kdes[i]
+        )
+
+        ax.fill_between(
+            x,
+            baseline,
+            baseline + scaled_density,
+            facecolor=color,
+            edgecolor="none",
+            alpha=fill_alpha,
+        )
+        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 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([])
+
+    # Record the call if tracking is enabled
+    if track:
+        recorder.record_call(
+            ax_position=position,
+            method_name="joyplot",
+            args=(arrays,),
+            kwargs={
+                "overlap": overlap,
+                "fill_alpha": fill_alpha,
+                "line_alpha": line_alpha,
+                "labels": labels,
+            },
+            call_id=call_id,
+        )
+
+    return recording_axes
+
+
+def swarmplot_plot(
+    ax: "Axes",
+    data,
+    positions,
+    recorder: "Recorder",
+    position: tuple,
+    track: bool,
+    call_id: Optional[str],
+    size: Optional[float],
+    color,
+    alpha: float,
+    jitter: float,
+    **kwargs,
+) -> List[Any]:
+    """Create a swarm plot (beeswarm plot)."""
+    from .._utils._units import mm_to_pt
+    from ..styles import get_style
+
+    # Get style
+    style = get_style()
+
+    # Default marker size from style
+    if size is None:
+        if style and "markers" in style:
+            size = style.markers.get("scatter_mm", 0.8)
+        else:
+            size = 0.8
+    size_pt = mm_to_pt(size) ** 2
+
+    from ._plot_helpers import beeswarm_positions, get_colors_from_style
+
+    # Get colors
+    colors = get_colors_from_style(len(data), color)
+
+    # Default positions
+    if positions is None:
+        positions = list(range(1, len(data) + 1))
+
+    # 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)
+        x_jitter = beeswarm_positions(arr, jitter, rng)
+        x_positions = pos + x_jitter
+        c = colors[i % len(colors)]
+        result = ax.scatter(x_positions, arr, s=size_pt, c=[c], alpha=alpha, **kwargs)
+        results.append(result)
+
+    # Record the call if tracking is enabled
+    if track:
+        recorder.record_call(
+            ax_position=position,
+            method_name="swarmplot",
+            args=(data,),
+            kwargs={
+                "positions": positions,
+                "size": size,
+                "alpha": alpha,
+                "jitter": jitter,
+            },
+            call_id=call_id,
+        )
+
+    return results
+
+
+__all__ = [
+    "pie_plot",
+    "imshow_plot",
+    "violinplot_plot",
+    "joyplot_plot",
+    "swarmplot_plot",
+]
+
+# EOF

figrecipe/_wrappers/_axes_seaborn.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Seaborn recording support for RecordingAxes."""
+
+from typing import TYPE_CHECKING, Any, Dict, Optional
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from .._recorder import Recorder
+
+
+def record_seaborn_call(
+    recorder: "Recorder",
+    position: tuple,
+    func_name: str,
+    args: tuple,
+    kwargs: Dict[str, Any],
+    data_arrays: Dict[str, np.ndarray],
+    call_id: Optional[str] = None,
+) -> None:
+    """Record a seaborn plotting call.
+
+    Parameters
+    ----------
+    recorder : Recorder
+        The recorder instance.
+    position : tuple
+        (row, col) position of axes.
+    func_name : str
+        Name of the seaborn function (e.g., 'scatterplot').
+    args : tuple
+        Processed positional arguments.
+    kwargs : dict
+        Processed keyword arguments.
+    data_arrays : dict
+        Dictionary of array data extracted from DataFrame/arrays.
+    call_id : str, optional
+        Custom ID for this call.
+    """
+    from .._recorder import CallRecord
+
+    # Generate call ID if not provided
+    if call_id is None:
+        call_id = recorder._generate_call_id(f"sns_{func_name}")
+
+    # Process data arrays into args format
+    processed_args = _process_seaborn_args(args, data_arrays)
+
+    # Process DataFrame column data
+    _add_column_data_to_args(processed_args, data_arrays)
+
+    # Process kwarg arrays
+    processed_kwargs = _process_seaborn_kwargs(kwargs, data_arrays)
+
+    # Create call record
+    record = CallRecord(
+        id=call_id,
+        function=f"sns.{func_name}",
+        args=processed_args,
+        kwargs=processed_kwargs,
+        ax_position=position,
+    )
+
+    # Add to axes record
+    ax_record = recorder.figure_record.get_or_create_axes(*position)
+    ax_record.add_call(record)
+
+
+def _process_seaborn_args(args: tuple, data_arrays: Dict[str, np.ndarray]) -> list:
+    """Process seaborn positional arguments."""
+    from .._utils._numpy_io import should_store_inline, to_serializable
+
+    processed_args = []
+    for i, arg in enumerate(args):
+        if arg == "__ARRAY__":
+            key = f"_arg_{i}"
+            if key in data_arrays:
+                arr = data_arrays[key]
+                if should_store_inline(arr):
+                    processed_args.append(
+                        {
+                            "name": f"arg{i}",
+                            "data": to_serializable(arr),
+                            "dtype": str(arr.dtype),
+                        }
+                    )
+                else:
+                    processed_args.append(
+                        {
+                            "name": f"arg{i}",
+                            "data": "__FILE__",
+                            "dtype": str(arr.dtype),
+                            "_array": arr,
+                        }
+                    )
+        else:
+            processed_args.append({"name": f"arg{i}", "data": arg})
+
+    return processed_args
+
+
+def _add_column_data_to_args(
+    processed_args: list, data_arrays: Dict[str, np.ndarray]
+) -> None:
+    """Add DataFrame column data to processed args."""
+    from .._utils._numpy_io import should_store_inline, to_serializable
+
+    for key, arr in data_arrays.items():
+        if key.startswith("_col_"):
+            param_name = key[5:]  # Remove "_col_" prefix
+            col_name = data_arrays.get(f"_colname_{param_name}", param_name)
+            if should_store_inline(arr):
+                processed_args.append(
+                    {
+                        "name": col_name,
+                        "param": param_name,
+                        "data": to_serializable(arr),
+                        "dtype": str(arr.dtype),
+                    }
+                )
+            else:
+                processed_args.append(
+                    {
+                        "name": col_name,
+                        "param": param_name,
+                        "data": "__FILE__",
+                        "dtype": str(arr.dtype),
+                        "_array": arr,
+                    }
+                )
+
+
+def _process_seaborn_kwargs(
+    kwargs: Dict[str, Any], data_arrays: Dict[str, np.ndarray]
+) -> Dict[str, Any]:
+    """Process seaborn keyword arguments."""
+    from .._utils._numpy_io import should_store_inline, to_serializable
+
+    processed_kwargs = dict(kwargs)
+    for key, value in kwargs.items():
+        if value == "__ARRAY__":
+            arr_key = f"_kwarg_{key}"
+            if arr_key in data_arrays:
+                arr = data_arrays[arr_key]
+                if should_store_inline(arr):
+                    processed_kwargs[key] = to_serializable(arr)
+                else:
+                    processed_kwargs[key] = "__FILE__"
+                    processed_kwargs[f"_array_{key}"] = arr
+
+    return processed_kwargs
+
+
+__all__ = ["record_seaborn_call"]
+
+# EOF