scitex 2.10.3__py3-none-any.whl → 2.13.0__py3-none-any.whl

scitex/fig/editor/flask_editor/_renderer.py

@@ -1,813 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# File: ./src/scitex/vis/editor/flask_editor/renderer.py
-"""Figure rendering for Flask editor - supports single and multi-axis figures."""
-
-from typing import Dict, Any, Tuple, Optional, List
-import base64
-import io
-
-import matplotlib
-
-matplotlib.use("Agg")
-import matplotlib.pyplot as plt
-from matplotlib.ticker import MaxNLocator
-from PIL import Image
-import numpy as np
-
-from ._plotter import plot_from_csv, plot_from_recipe
-from ._bbox import extract_bboxes, extract_bboxes_multi
-from scitex.plt.styles import get_default_dpi
-
-# mm to pt conversion factor
-MM_TO_PT = 2.83465
-
-
-def render_preview_with_bboxes(
-    csv_data, overrides: Dict[str, Any], axis_fontsize: int = 7,
-    metadata: Optional[Dict[str, Any]] = None,
-    dark_mode: bool = False,
-) -> Tuple[str, Dict[str, Any], Dict[str, int]]:
-    """Render figure and return base64 PNG along with element bounding boxes.
-
-    Args:
-        csv_data: DataFrame containing CSV data
-        overrides: Dictionary with override settings
-        axis_fontsize: Default font size for axis labels
-        metadata: Optional JSON metadata (new schema with axes dict)
-        dark_mode: Whether to render with dark mode colors (light text/spines)
-
-    Returns:
-        tuple: (base64_image_data, bboxes_dict, image_size)
-    """
-    # Check if this is a multi-axis figure (new schema)
-    if metadata and "axes" in metadata and isinstance(metadata.get("axes"), dict):
-        return render_multi_axis_preview(csv_data, overrides, metadata, dark_mode)
-
-    # Fall back to single-axis rendering
-    return render_single_axis_preview(csv_data, overrides, axis_fontsize, dark_mode)
-
-
-def render_single_axis_preview(
-    csv_data, overrides: Dict[str, Any], axis_fontsize: int = 7,
-    dark_mode: bool = False,
-) -> Tuple[str, Dict[str, Any], Dict[str, int]]:
-    """Render single-axis figure (legacy mode)."""
-    o = overrides
-
-    # Dimensions
-    dpi = o.get("dpi", get_default_dpi())
-    fig_size = o.get("fig_size", [3.15, 2.68])
-
-    # Font sizes
-    axis_fontsize = o.get("axis_fontsize", 7)
-    tick_fontsize = o.get("tick_fontsize", 7)
-    title_fontsize = o.get("title_fontsize", 8)
-
-    # Line/axis thickness
-    linewidth_pt = o.get("linewidth", 0.57)
-    axis_width_pt = o.get("axis_width", 0.2) * MM_TO_PT
-    tick_length_pt = o.get("tick_length", 0.8) * MM_TO_PT
-    tick_width_pt = o.get("tick_width", 0.2) * MM_TO_PT
-    tick_direction = o.get("tick_direction", "out")
-    x_n_ticks = o.get("x_n_ticks", o.get("n_ticks", 4))
-    y_n_ticks = o.get("y_n_ticks", o.get("n_ticks", 4))
-    hide_x_ticks = o.get("hide_x_ticks", False)
-    hide_y_ticks = o.get("hide_y_ticks", False)
-
-    transparent = o.get("transparent", True)
-
-    # Create figure
-    fig, ax = plt.subplots(figsize=fig_size, dpi=dpi)
-    _apply_background(fig, ax, o, transparent)
-
-    # Plot from CSV data
-    if csv_data is not None:
-        plot_from_csv(ax, csv_data, overrides, linewidth=linewidth_pt)
-    else:
-        ax.text(
-            0.5,
-            0.5,
-            "No plot data available\n(CSV not found)",
-            ha="center",
-            va="center",
-            transform=ax.transAxes,
-            fontsize=axis_fontsize,
-        )
-
-    # Apply labels
-    _apply_labels(ax, o, title_fontsize, axis_fontsize)
-
-    # Tick styling
-    _apply_tick_styling(
-        ax,
-        tick_fontsize,
-        tick_length_pt,
-        tick_width_pt,
-        tick_direction,
-        x_n_ticks,
-        y_n_ticks,
-        hide_x_ticks,
-        hide_y_ticks,
-    )
-
-    # Apply grid, limits, spines
-    _apply_style(ax, o, axis_width_pt)
-
-    # Apply annotations
-    _apply_annotations(ax, o, axis_fontsize)
-
-    # Apply caption (below figure)
-    caption_artist = _apply_caption(fig, o)
-
-    # Apply dark mode styling if requested
-    if dark_mode:
-        _apply_dark_theme(ax)
-        # Also style caption if present
-        if caption_artist:
-            caption_artist.set_color(DARK_THEME_TEXT_COLOR)
-
-    fig.tight_layout()
-
-    # Get element bounding boxes BEFORE saving (need renderer)
-    fig.canvas.draw()
-    renderer = fig.canvas.get_renderer()
-
-    # Save to buffer first to get actual image size
-    buf = io.BytesIO()
-    fig.savefig(
-        buf, format="png", dpi=dpi, bbox_inches="tight", transparent=transparent
-    )
-    buf.seek(0)
-
-    # Get actual saved image dimensions
-    img = Image.open(buf)
-    img_width, img_height = img.size
-    buf.seek(0)
-
-    # Get bboxes
-    bboxes = extract_bboxes(fig, ax, renderer, img_width, img_height)
-
-    img_data = base64.b64encode(buf.read()).decode("utf-8")
-    plt.close(fig)
-
-    return img_data, bboxes, {"width": img_width, "height": img_height}
-
-
-def render_multi_axis_preview(
-    csv_data, overrides: Dict[str, Any], metadata: Dict[str, Any],
-    dark_mode: bool = False,
-) -> Tuple[str, Dict[str, Any], Dict[str, int]]:
-    """Render multi-axis figure from new schema (scitex.plt.figure.recipe).
-
-    Args:
-        csv_data: DataFrame containing CSV data
-        overrides: Dictionary with override settings
-        metadata: JSON metadata with axes dict
-        dark_mode: Whether to render with dark mode colors
-
-    Returns:
-        tuple: (base64_image_data, bboxes_dict, image_size)
-    """
-    o = overrides
-    axes_spec = metadata.get("axes", {})
-    fig_spec = metadata.get("figure", {})
-
-    # Get grid dimensions from axes positions
-    nrows, ncols = _get_grid_dimensions(axes_spec)
-
-    # Figure dimensions
-    dpi = fig_spec.get("dpi", o.get("dpi", get_default_dpi()))
-    size_mm = fig_spec.get("size_mm", [176, 106])
-    # Convert mm to inches (1 inch = 25.4 mm)
-    fig_size = (size_mm[0] / 25.4, size_mm[1] / 25.4)
-
-    # Font sizes (from overrides)
-    axis_fontsize = o.get("axis_fontsize", 7)
-    tick_fontsize = o.get("tick_fontsize", 7)
-    title_fontsize = o.get("title_fontsize", 8)
-
-    # Line/axis thickness
-    linewidth_pt = o.get("linewidth", 0.57)
-    axis_width_pt = o.get("axis_width", 0.2) * MM_TO_PT
-    tick_length_pt = o.get("tick_length", 0.8) * MM_TO_PT
-    tick_width_pt = o.get("tick_width", 0.2) * MM_TO_PT
-    tick_direction = o.get("tick_direction", "out")
-    x_n_ticks = o.get("x_n_ticks", o.get("n_ticks", 4))
-    y_n_ticks = o.get("y_n_ticks", o.get("n_ticks", 4))
-
-    transparent = o.get("transparent", True)
-
-    # Create multi-axis figure
-    fig, axes_array = plt.subplots(nrows, ncols, figsize=fig_size, dpi=dpi)
-
-    # Handle 1D or 2D array
-    if nrows == 1 and ncols == 1:
-        axes_array = np.array([[axes_array]])
-    elif nrows == 1:
-        axes_array = axes_array.reshape(1, -1)
-    elif ncols == 1:
-        axes_array = axes_array.reshape(-1, 1)
-
-    # Apply background to figure
-    if transparent:
-        fig.patch.set_facecolor("none")
-    elif o.get("facecolor"):
-        fig.patch.set_facecolor(o["facecolor"])
-
-    # Build mapping from axis ID to row/col
-    ax_to_rowcol = _build_ax_to_rowcol_map(axes_spec)
-
-    # Map axes by their ID
-    axes_map = {}
-    for ax_id, ax_spec in axes_spec.items():
-        row, col = ax_to_rowcol.get(ax_id, (0, 0))
-        ax = axes_array[row, col]
-        axes_map[ax_id] = ax
-
-        # Apply background
-        if transparent:
-            ax.patch.set_facecolor("none")
-        elif o.get("facecolor"):
-            ax.patch.set_facecolor(o["facecolor"])
-
-        # Plot data - check which schema format
-        if csv_data is not None:
-            calls = ax_spec.get("calls", [])
-            if calls:
-                # Recipe schema with explicit calls
-                plot_from_recipe(ax, csv_data, ax_spec, overrides, linewidth_pt, ax_id=ax_id)
-            else:
-                # Editable schema - plot from CSV column names
-                csv_row, csv_col = row, col  # Use computed row/col for CSV lookup
-                _plot_from_editable_csv(ax, csv_data, ax_id, csv_row, csv_col, overrides, linewidth_pt, metadata)
-
-        # Get panel-specific overrides (e.g., ax_00_panel)
-        panel_key = f"{ax_id}_panel"
-        element_overrides = o.get("element_overrides", {})
-        panel_overrides = element_overrides.get(panel_key, {})
-
-        # Apply axis labels from spec, with panel overrides taking precedence
-        xaxis = ax_spec.get("xaxis", {})
-        yaxis = ax_spec.get("yaxis", {})
-
-        # Panel title (from overrides or spec)
-        panel_title = panel_overrides.get("title")
-        if panel_title:
-            ax.set_title(panel_title, fontsize=title_fontsize)
-
-        # X/Y labels (panel overrides take precedence over spec)
-        xlabel = panel_overrides.get("xlabel") or xaxis.get("label")
-        ylabel = panel_overrides.get("ylabel") or yaxis.get("label")
-
-        if xlabel:
-            ax.set_xlabel(xlabel, fontsize=axis_fontsize)
-        if ylabel:
-            ax.set_ylabel(ylabel, fontsize=axis_fontsize)
-
-        # Apply axis limits
-        if xaxis.get("lim"):
-            ax.set_xlim(xaxis["lim"])
-        if yaxis.get("lim"):
-            ax.set_ylim(yaxis["lim"])
-
-        # Tick styling
-        _apply_tick_styling(
-            ax,
-            tick_fontsize,
-            tick_length_pt,
-            tick_width_pt,
-            tick_direction,
-            x_n_ticks,
-            y_n_ticks,
-            False,  # hide_x_ticks
-            False,  # hide_y_ticks
-        )
-
-        # Apply spines
-        if o.get("hide_top_spine", True):
-            ax.spines["top"].set_visible(False)
-        if o.get("hide_right_spine", True):
-            ax.spines["right"].set_visible(False)
-        for spine in ax.spines.values():
-            spine.set_linewidth(axis_width_pt)
-
-        # Apply dark mode to this axis
-        if dark_mode:
-            _apply_dark_theme(ax)
-
-    # Apply caption (below figure) - use global overrides
-    caption_artist = _apply_caption(fig, o)
-    if dark_mode and caption_artist:
-        caption_artist.set_color(DARK_THEME_TEXT_COLOR)
-
-    fig.tight_layout()
-
-    # Get element bounding boxes
-    fig.canvas.draw()
-    renderer = fig.canvas.get_renderer()
-
-    # Save to buffer
-    buf = io.BytesIO()
-    fig.savefig(
-        buf, format="png", dpi=dpi, bbox_inches="tight", transparent=transparent
-    )
-    buf.seek(0)
-
-    # Get actual saved image dimensions
-    img = Image.open(buf)
-    img_width, img_height = img.size
-    buf.seek(0)
-
-    # Get bboxes for all axes
-    bboxes = extract_bboxes_multi(fig, axes_map, renderer, img_width, img_height)
-
-    img_data = base64.b64encode(buf.read()).decode("utf-8")
-    plt.close(fig)
-
-    return img_data, bboxes, {"width": img_width, "height": img_height}
-
-
-def _get_grid_dimensions(axes_spec: Dict[str, Any]) -> Tuple[int, int]:
-    """Get grid dimensions from axes specifications.
-
-    Handles both:
-    - New recipe schema with grid_position
-    - Editable schema - infer grid from positions (y-position groups = rows)
-    """
-    # Check if any axis has grid_position
-    has_grid_pos = any(ax_spec.get("grid_position") for ax_spec in axes_spec.values())
-
-    if has_grid_pos:
-        max_row = 0
-        max_col = 0
-        for ax_id, ax_spec in axes_spec.items():
-            pos = ax_spec.get("grid_position", {})
-            max_row = max(max_row, pos.get("row", 0))
-            max_col = max(max_col, pos.get("col", 0))
-        return max_row + 1, max_col + 1
-
-    # Editable schema: infer grid from positions
-    # Group by y-position to determine rows
-    if not axes_spec:
-        return 1, 1
-
-    positions = []
-    for ax_id, ax_spec in axes_spec.items():
-        pos = ax_spec.get("position", [0, 0, 0, 0])
-        if len(pos) >= 2:
-            positions.append((ax_id, pos[0], pos[1]))  # (id, x, y)
-
-    if not positions:
-        return 1, 1
-
-    # Cluster by y-position (tolerance for floating point)
-    y_values = sorted(set(round(p[2], 2) for p in positions), reverse=True)
-    n_rows = len(y_values)
-
-    # Count columns in first row
-    first_row_y = y_values[0]
-    n_cols = sum(1 for p in positions if abs(p[2] - first_row_y) < 0.1)
-
-    return n_rows, n_cols
-
-
-def _build_ax_to_rowcol_map(axes_spec: Dict[str, Any]) -> Dict[str, Tuple[int, int]]:
-    """Build mapping from axis ID to (row, col) based on positions."""
-    if not axes_spec:
-        return {}
-
-    # Check if any axis has grid_position
-    has_grid_pos = any(ax_spec.get("grid_position") for ax_spec in axes_spec.values())
-
-    if has_grid_pos:
-        result = {}
-        for ax_id, ax_spec in axes_spec.items():
-            pos = ax_spec.get("grid_position", {})
-            result[ax_id] = (pos.get("row", 0), pos.get("col", 0))
-        return result
-
-    # Editable schema: compute from positions
-    positions = []
-    for ax_id, ax_spec in axes_spec.items():
-        pos = ax_spec.get("position", [0, 0, 0, 0])
-        if len(pos) >= 2:
-            positions.append((ax_id, pos[0], pos[1]))  # (id, x, y)
-
-    if not positions:
-        return {ax_id: (0, 0) for ax_id in axes_spec}
-
-    # Get unique y-values (rows) - higher y = lower row number (top of figure)
-    y_values = sorted(set(round(p[2], 2) for p in positions), reverse=True)
-    y_to_row = {y: i for i, y in enumerate(y_values)}
-
-    # For each row, sort by x to get column
-    result = {}
-    for row_idx, row_y in enumerate(y_values):
-        row_axes = [(ax_id, x) for ax_id, x, y in positions if abs(y - row_y) < 0.1]
-        row_axes.sort(key=lambda t: t[1])  # Sort by x
-        for col_idx, (ax_id, _) in enumerate(row_axes):
-            result[ax_id] = (row_idx, col_idx)
-
-    return result
-
-
-def _get_row_col_from_ax_id(ax_id: str, ax_map: Optional[Dict[str, Tuple[int, int]]] = None) -> Tuple[int, int]:
-    """Extract row and col from axis ID using the mapping."""
-    if ax_map and ax_id in ax_map:
-        return ax_map[ax_id]
-    # Fallback: try parsing ax_XY format
-    import re
-    match = re.match(r'ax_(\d)(\d)', ax_id)
-    if match:
-        return int(match.group(1)), int(match.group(2))
-    return 0, 0
-
-
-def _plot_from_editable_csv(
-    ax, csv_data, ax_id: str, row: int, col: int,
-    overrides: Dict[str, Any], linewidth: float,
-    metadata: Optional[Dict[str, Any]] = None,
-):
-    """Plot data from editable schema CSV format.
-
-    CSV columns follow pattern: ax-row-X-col-Y_trace-id-NAME_variable-VAR
-    """
-    import re
-    df = csv_data
-    elements = metadata.get("elements", {}) if metadata else {}
-
-    # Find columns for this axis (by row/col)
-    pattern = f"ax-row-{row}-col-{col}_"
-    ax_cols = [c for c in df.columns if c.startswith(pattern)]
-
-    if not ax_cols:
-        return
-
-    # Group columns by trace-id
-    traces = {}
-    for col_name in ax_cols:
-        # Parse: ax-row-X-col-Y_trace-id-NAME_variable-VAR
-        match = re.match(rf'{pattern}trace-id-(.+?)_variable-(.+)', col_name)
-        if match:
-            trace_id = match.group(1)
-            var_name = match.group(2)
-            if trace_id not in traces:
-                traces[trace_id] = {}
-            traces[trace_id][var_name] = col_name
-
-    # Get element overrides from overrides dict
-    element_overrides = overrides.get("element_overrides", {})
-
-    # Plot each trace
-    trace_idx = 0
-    for trace_id, vars_dict in traces.items():
-        # Find element info from metadata
-        element_key = f"{ax_id}_line_{trace_idx:02d}"
-        element_info = elements.get(element_key, {})
-        label = element_info.get("label", trace_id)
-
-        # Get user overrides for this trace
-        override_key = f"{ax_id}_trace_{trace_idx}"
-        trace_overrides = element_overrides.get(override_key, {})
-
-        # Determine plot type based on variables present
-        # Check more specific patterns first, then fall back to x/y
-
-        if 'y_lower' in vars_dict and 'y_middle' in vars_dict and 'y_upper' in vars_dict:
-            # Shaded line plot (fill_between + line)
-            x_col = vars_dict.get('x')
-            if x_col:
-                x = df[x_col].dropna().values
-                y_lower = df[vars_dict['y_lower']].dropna().values
-                y_middle = df[vars_dict['y_middle']].dropna().values
-                y_upper = df[vars_dict['y_upper']].dropna().values
-
-                min_len = min(len(x), len(y_lower), len(y_middle), len(y_upper))
-                if min_len > 0:
-                    ax.fill_between(x[:min_len], y_lower[:min_len], y_upper[:min_len], alpha=0.3)
-                    ax.plot(x[:min_len], y_middle[:min_len], linewidth=linewidth)
-            trace_idx += 1
-
-        elif 'row' in vars_dict and 'col' in vars_dict and 'value' in vars_dict:
-            # Heatmap / imshow
-            rows_data = df[vars_dict['row']].dropna().values
-            cols_data = df[vars_dict['col']].dropna().values
-            values = df[vars_dict['value']].dropna().values
-            if len(rows_data) > 0:
-                n_rows = int(rows_data.max()) + 1
-                n_cols = int(cols_data.max()) + 1
-                data = np.zeros((n_rows, n_cols))
-                for r, c, v in zip(rows_data.astype(int), cols_data.astype(int), values):
-                    data[r, c] = v
-                ax.imshow(data, aspect='auto', origin='lower')
-
-        elif 'y1' in vars_dict and 'y2' in vars_dict:
-            # fill_between (CI band)
-            x_col = vars_dict.get('x')
-            if x_col:
-                x = df[x_col].dropna().values
-                y1 = df[vars_dict['y1']].dropna().values
-                y2 = df[vars_dict['y2']].dropna().values
-                min_len = min(len(x), len(y1), len(y2))
-                if min_len > 0:
-                    ax.fill_between(x[:min_len], y1[:min_len], y2[:min_len], alpha=0.3)
-
-        elif 'yerr' in vars_dict and 'y' in vars_dict:
-            # Error bars with bar chart
-            x_col = vars_dict.get('x')
-            y_col = vars_dict.get('y')
-            if x_col and y_col:
-                x = df[x_col].dropna().values
-                y = df[y_col].dropna().values
-                yerr = df[vars_dict['yerr']].dropna().values
-                min_len = min(len(x), len(y), len(yerr))
-                if min_len > 0:
-                    ax.bar(x[:min_len], y[:min_len], yerr=yerr[:min_len])
-
-        elif 'group' in vars_dict and 'value' in vars_dict:
-            # Violin/strip plot - plot as scatter for now
-            groups = df[vars_dict['group']].dropna().values
-            values = df[vars_dict['value']].dropna().values
-            if len(groups) > 0 and len(values) > 0:
-                min_len = min(len(groups), len(values))
-                # Convert string groups to numeric positions
-                unique_groups = list(dict.fromkeys(groups[:min_len]))  # Preserve order
-                group_to_x = {g: i for i, g in enumerate(unique_groups)}
-                x_positions = np.array([group_to_x.get(g, 0) for g in groups[:min_len]])
-                # Add jitter for strip plot effect
-                jitter = np.random.uniform(-0.1, 0.1, min_len)
-                ax.scatter(x_positions + jitter, values[:min_len], alpha=0.6, s=20)
-                # Set tick labels
-                ax.set_xticks(range(len(unique_groups)))
-                ax.set_xticklabels(unique_groups, fontsize=6)
-
-        elif 'width' in vars_dict and 'height' in vars_dict:
-            # Rectangle - skip for now
-            pass
-
-        elif 'type' in vars_dict:
-            # Skip type-only entries (like stim markers)
-            pass
-
-        elif 'content' in vars_dict:
-            # Text annotation - skip for preview
-            pass
-
-        elif 'x' in vars_dict and 'y' in vars_dict:
-            # Default: line or scatter plot
-            x_col = vars_dict['x']
-            y_col = vars_dict['y']
-            x = df[x_col].dropna().values
-            y = df[y_col].dropna().values
-            if len(x) > 0 and len(y) > 0:
-                min_len = min(len(x), len(y))
-                # Apply overrides
-                color = trace_overrides.get("color")
-                lw = trace_overrides.get("linewidth", linewidth)
-                ls = trace_overrides.get("linestyle", "-")
-                marker = trace_overrides.get("marker")
-                alpha = trace_overrides.get("alpha", 1.0)
-
-                kwargs = {"linewidth": lw, "linestyle": ls, "alpha": alpha}
-                if color:
-                    kwargs["color"] = color
-                if marker:
-                    kwargs["marker"] = marker
-                if label and label != trace_id:
-                    kwargs["label"] = label
-
-                # Check if this looks like scatter data (trace-id contains 'scatter' or 'strip')
-                if 'scatter' in trace_id.lower() or 'strip' in trace_id.lower():
-                    scatter_kwargs = {"alpha": alpha, "s": 20}
-                    if color:
-                        scatter_kwargs["c"] = color
-                    ax.scatter(x[:min_len], y[:min_len], **scatter_kwargs)
-                else:
-                    ax.plot(x[:min_len], y[:min_len], **kwargs)
-            trace_idx += 1
-
-
-def _apply_background(fig, ax, o, transparent):
-    """Apply background settings to figure."""
-    if transparent:
-        fig.patch.set_facecolor("none")
-        ax.patch.set_facecolor("none")
-    elif o.get("facecolor"):
-        fig.patch.set_facecolor(o["facecolor"])
-        ax.patch.set_facecolor(o["facecolor"])
-
-
-def _apply_labels(ax, o, title_fontsize, axis_fontsize):
-    """Apply title and axis labels."""
-    # Show title only if enabled (default True)
-    if o.get("show_title", True) and o.get("title"):
-        ax.set_title(o["title"], fontsize=title_fontsize)
-    if o.get("xlabel"):
-        ax.set_xlabel(o["xlabel"], fontsize=axis_fontsize)
-    if o.get("ylabel"):
-        ax.set_ylabel(o["ylabel"], fontsize=axis_fontsize)
-
-
-def _apply_caption(fig, o, caption_fontsize=7):
-    """Apply caption below the figure."""
-    if not o.get("show_caption", False) or not o.get("caption"):
-        return None
-
-    caption_text = o.get("caption", "")
-    fontsize = o.get("caption_fontsize", caption_fontsize)
-
-    # Place caption below the figure
-    # Using fig.text with y position slightly below 0
-    caption_artist = fig.text(
-        0.5, -0.02,  # Centered, below the figure
-        caption_text,
-        ha="center",
-        va="top",
-        fontsize=fontsize,
-        wrap=True,
-        transform=fig.transFigure,
-    )
-    return caption_artist
-
-
-def _apply_tick_styling(
-    ax,
-    tick_fontsize,
-    tick_length_pt,
-    tick_width_pt,
-    tick_direction,
-    x_n_ticks,
-    y_n_ticks,
-    hide_x_ticks,
-    hide_y_ticks,
-):
-    """Apply tick styling to axes."""
-    ax.tick_params(
-        axis="both",
-        labelsize=tick_fontsize,
-        length=tick_length_pt,
-        width=tick_width_pt,
-        direction=tick_direction,
-    )
-
-    if hide_x_ticks:
-        ax.xaxis.set_ticks([])
-        ax.xaxis.set_ticklabels([])
-    else:
-        ax.xaxis.set_major_locator(MaxNLocator(nbins=x_n_ticks))
-    if hide_y_ticks:
-        ax.yaxis.set_ticks([])
-        ax.yaxis.set_ticklabels([])
-    else:
-        ax.yaxis.set_major_locator(MaxNLocator(nbins=y_n_ticks))
-
-
-def _apply_style(ax, o, axis_width_pt):
-    """Apply grid, axis limits, and spine settings."""
-    if o.get("grid"):
-        ax.grid(True, linewidth=axis_width_pt, alpha=0.3)
-
-    if o.get("xlim"):
-        ax.set_xlim(o["xlim"])
-    if o.get("ylim"):
-        ax.set_ylim(o["ylim"])
-
-    if o.get("hide_top_spine", True):
-        ax.spines["top"].set_visible(False)
-    if o.get("hide_right_spine", True):
-        ax.spines["right"].set_visible(False)
-
-    for spine in ax.spines.values():
-        spine.set_linewidth(axis_width_pt)
-
-
-def _apply_annotations(ax, o, axis_fontsize):
-    """Apply text annotations to figure."""
-    for annot in o.get("annotations", []):
-        if annot.get("type") == "text":
-            ax.text(
-                annot.get("x", 0.5),
-                annot.get("y", 0.5),
-                annot.get("text", ""),
-                transform=ax.transAxes,
-                fontsize=annot.get("fontsize", axis_fontsize),
-            )
-
-
-def render_panel_preview(
-    panel_dir,
-    dark_mode: bool = False,
-) -> Tuple[Optional[str], Optional[Dict[str, Any]], Optional[Dict[str, int]]]:
-    """Render a panel from its pltz bundle directory with dark mode support.
-
-    Args:
-        panel_dir: Path to the .pltz.d panel directory
-        dark_mode: Whether to render with dark mode colors
-
-    Returns:
-        tuple: (base64_image_data, bboxes_dict, image_size) or (None, None, None) on error
-    """
-    from pathlib import Path
-    import json
-    import pandas as pd
-
-    panel_dir = Path(panel_dir)
-
-    try:
-        # Load spec.json
-        spec_path = panel_dir / "spec.json"
-        if not spec_path.exists():
-            # Try legacy format
-            for f in panel_dir.glob("*.json"):
-                if f.name != "style.json":
-                    spec_path = f
-                    break
-
-        if not spec_path.exists():
-            return None, None, None
-
-        with open(spec_path, "r") as f:
-            metadata = json.load(f)
-
-        # Load CSV data
-        csv_data = None
-        csv_path = panel_dir / "data.csv"
-        if not csv_path.exists():
-            for f in panel_dir.glob("*.csv"):
-                csv_path = f
-                break
-
-        if csv_path.exists():
-            csv_data = pd.read_csv(csv_path)
-
-        # Load style.json for overrides
-        style_path = panel_dir / "style.json"
-        overrides = {}
-        if style_path.exists():
-            with open(style_path, "r") as f:
-                style = json.load(f)
-            # Convert style to overrides format
-            size = style.get("size", {})
-            if size:
-                width_mm = size.get("width_mm", 80)
-                height_mm = size.get("height_mm", 68)
-                overrides["fig_size"] = [width_mm / 25.4, height_mm / 25.4]
-            overrides["transparent"] = True
-
-        # Render with dark mode
-        return render_preview_with_bboxes(
-            csv_data, overrides,
-            metadata=metadata,
-            dark_mode=dark_mode,
-        )
-
-    except Exception as e:
-        import traceback
-        print(f"Error rendering panel {panel_dir}: {e}")
-        traceback.print_exc()
-        return None, None, None
-
-
-# Dark mode theme colors
-DARK_THEME_TEXT_COLOR = "#e8e8e8"  # Light gray for visibility on dark background
-DARK_THEME_SPINE_COLOR = "#e8e8e8"
-DARK_THEME_TICK_COLOR = "#e8e8e8"
-
-
-def _apply_dark_theme(ax):
-    """Apply dark mode colors to axes for visibility on dark backgrounds.
-
-    Changes title, labels, tick labels, spines, and legend text to light colors.
-    """
-    # Title
-    title = ax.get_title()
-    if title:
-        ax.title.set_color(DARK_THEME_TEXT_COLOR)
-
-    # Axis labels
-    ax.xaxis.label.set_color(DARK_THEME_TEXT_COLOR)
-    ax.yaxis.label.set_color(DARK_THEME_TEXT_COLOR)
-
-    # Tick labels
-    ax.tick_params(axis="both", colors=DARK_THEME_TICK_COLOR, labelcolor=DARK_THEME_TEXT_COLOR)
-
-    # Spines
-    for spine in ax.spines.values():
-        spine.set_color(DARK_THEME_SPINE_COLOR)
-
-    # Legend (if exists)
-    legend = ax.get_legend()
-    if legend:
-        for text in legend.get_texts():
-            text.set_color(DARK_THEME_TEXT_COLOR)
-        # Legend title
-        legend_title = legend.get_title()
-        if legend_title:
-            legend_title.set_color(DARK_THEME_TEXT_COLOR)
-        # Legend frame (make transparent or dark)
-        legend.get_frame().set_facecolor("none")
-        legend.get_frame().set_edgecolor(DARK_THEME_SPINE_COLOR)
-
-
-# EOF