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

figrecipe/_editor/_routes_snapshot.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Routes for panel snapshot generation (isolated rendering)."""
+
+import base64
+import io
+import threading
+
+# Lock to prevent concurrent matplotlib figure access (not thread-safe)
+_figure_lock = threading.Lock()
+
+
+def register_snapshot_routes(app, editor):
+    """Register snapshot-related routes.
+
+    Parameters
+    ----------
+    app : Flask
+        Flask application instance.
+    editor : FigureEditor
+        Editor instance with figure state.
+    """
+
+    @app.route("/get_panel_snapshot/<int:ax_index>")
+    def get_panel_snapshot(ax_index):
+        """Render a single panel in isolation and return as base64 PNG.
+
+        This hides all other axes to produce a clean snapshot without
+        overlap artifacts from neighboring panels.
+
+        Parameters
+        ----------
+        ax_index : int
+            Index of the axis/panel to render.
+
+        Returns
+        -------
+        dict
+            JSON with success status and base64-encoded PNG image.
+        """
+        # DISABLED: Modifying figure visibility corrupts shared state
+        # TODO: Implement proper solution (deep copy figure or pre-render)
+        return {"success": False, "error": "Snapshot temporarily disabled"}
+
+        try:
+            # Use lock to prevent concurrent matplotlib access (not thread-safe)
+            with _figure_lock:
+                # Get matplotlib figure from RecordingFigure wrapper
+                mpl_fig = editor.fig.fig if hasattr(editor.fig, "fig") else editor.fig
+                axes = mpl_fig.get_axes()
+
+                if ax_index < 0 or ax_index >= len(axes):
+                    return {"success": False, "error": f"Invalid ax_index: {ax_index}"}
+
+                # Store original visibility states
+                original_visibility = [ax.get_visible() for ax in axes]
+
+                try:
+                    # Hide all axes except the target
+                    for i, ax in enumerate(axes):
+                        ax.set_visible(i == ax_index)
+
+                    # Render to buffer with transparent background
+                    # Use full figure size (no bbox_inches="tight" to preserve dimensions)
+                    buf = io.BytesIO()
+                    mpl_fig.savefig(
+                        buf,
+                        format="png",
+                        transparent=True,
+                        facecolor="none",
+                        edgecolor="none",
+                    )
+                    buf.seek(0)
+                    image_base64 = base64.b64encode(buf.read()).decode("utf-8")
+
+                    return {
+                        "success": True,
+                        "image": image_base64,
+                        "ax_index": ax_index,
+                    }
+
+                finally:
+                    # Restore original visibility
+                    for i, ax in enumerate(axes):
+                        ax.set_visible(original_visibility[i])
+
+        except Exception as e:
+            # Return JSON error instead of 500 to avoid console errors
+            return {"success": False, "error": str(e)}
+
+
+__all__ = ["register_snapshot_routes"]
+
+# EOF

figrecipe/_editor/_routes_style.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Style and theme Flask route handlers for the figure editor.
+"""
+
+from flask import jsonify, request
+
+from ._helpers import get_form_values_from_style, render_with_overrides
+
+
+def register_style_routes(app, editor):
+    """Register style/theme routes with the Flask app."""
+    from ._overrides import save_overrides
+
+    @app.route("/style")
+    def get_style():
+        """Get current style configuration."""
+        return jsonify(
+            {
+                "base_style": editor.style_overrides.base_style,
+                "programmatic_style": editor.style_overrides.programmatic_style,
+                "manual_overrides": editor.style_overrides.manual_overrides,
+                "effective_style": editor.get_effective_style(),
+                "has_overrides": editor.style_overrides.has_manual_overrides(),
+                "manual_timestamp": editor.style_overrides.manual_timestamp,
+            }
+        )
+
+    @app.route("/overrides")
+    def get_overrides():
+        """Get current manual overrides."""
+        return jsonify(editor.style_overrides.manual_overrides)
+
+    @app.route("/theme")
+    def get_theme():
+        """Get current theme YAML content for display."""
+        import io as yaml_io
+
+        from ruamel.yaml import YAML
+
+        style = editor.get_effective_style()
+        style_name = style.get("_name", "SCITEX")
+
+        yaml = YAML()
+        yaml.default_flow_style = False
+        yaml.indent(mapping=2, sequence=4, offset=2)
+        stream = yaml_io.StringIO()
+        yaml.dump(style, stream)
+        yaml_content = stream.getvalue()
+
+        return jsonify(
+            {
+                "name": style_name,
+                "content": yaml_content,
+            }
+        )
+
+    @app.route("/list_themes")
+    def list_themes():
+        """List available theme presets."""
+        from ..styles._style_loader import list_presets
+
+        presets = list_presets()
+        current = editor.get_effective_style().get("_name", "SCITEX")
+
+        return jsonify(
+            {
+                "themes": presets,
+                "current": current,
+            }
+        )
+
+    @app.route("/switch_theme", methods=["POST"])
+    def switch_theme():
+        """Switch to a different theme preset by reproducing the figure."""
+        from .._reproducer import reproduce_from_record
+        from ..styles._style_loader import load_preset
+
+        data = request.get_json() or {}
+        theme_name = data.get("theme")
+
+        if not theme_name:
+            return jsonify({"error": "No theme specified"}), 400
+
+        try:
+            new_style = load_preset(theme_name)
+
+            if new_style is None:
+                return jsonify({"error": f"Theme '{theme_name}' not found"}), 404
+
+            # Convert nested style to flat style dict with color_palette
+            flat_style = dict(new_style)
+            flat_style["_name"] = theme_name
+
+            # Extract color_palette from nested colors.palette
+            if "colors" in new_style and isinstance(new_style["colors"], dict):
+                colors_dict = new_style["colors"]
+                if "palette" in colors_dict and colors_dict["palette"] is not None:
+                    flat_style["color_palette"] = list(colors_dict["palette"])
+
+            editor.style_overrides.base_style = flat_style
+
+            if hasattr(editor.fig, "record") and editor.fig.record is not None:
+                editor.fig.record.style = flat_style
+                new_fig, _ = reproduce_from_record(editor.fig.record)
+                editor.fig = new_fig
+                # Keep the new style (don't restore old style)
+
+            mpl_fig = editor.fig.fig if hasattr(editor.fig, "fig") else editor.fig
+            behavior = new_style.get("behavior", {})
+            for ax in mpl_fig.get_axes():
+                # Handle all four spine directions
+                for side, default in [
+                    ("top", True),
+                    ("right", True),
+                    ("bottom", False),
+                    ("left", False),
+                ]:
+                    hide = behavior.get(f"hide_{side}_spine", default)
+                    ax.spines[side].set_visible(not hide)
+
+                if behavior.get("grid", False):
+                    ax.grid(True, alpha=0.3)
+                else:
+                    ax.grid(False)
+
+            base64_img, bboxes, img_size = render_with_overrides(
+                editor.fig,
+                editor.get_effective_style(),
+                editor.dark_mode,
+            )
+
+            form_values = get_form_values_from_style(editor.get_effective_style())
+
+            return jsonify(
+                {
+                    "success": True,
+                    "theme": theme_name,
+                    "image": base64_img,
+                    "bboxes": bboxes,
+                    "img_size": {"width": img_size[0], "height": img_size[1]},
+                    "values": form_values,
+                }
+            )
+
+        except Exception as e:
+            import traceback
+
+            traceback.print_exc()
+            return jsonify({"error": f"Failed to switch theme: {str(e)}"}), 500
+
+    @app.route("/save", methods=["POST"])
+    def save():
+        """Save style overrides (stored separately from recipe)."""
+        data = request.get_json() or {}
+        editor.style_overrides.update_manual_overrides(data.get("overrides", {}))
+
+        if editor.recipe_path:
+            path = save_overrides(editor.style_overrides, editor.recipe_path)
+            return jsonify(
+                {
+                    "success": True,
+                    "path": str(path),
+                    "has_overrides": editor.style_overrides.has_manual_overrides(),
+                    "timestamp": editor.style_overrides.manual_timestamp,
+                }
+            )
+
+        return jsonify(
+            {
+                "success": True,
+                "overrides": editor.overrides,
+                "has_overrides": editor.style_overrides.has_manual_overrides(),
+            }
+        )
+
+    @app.route("/restore", methods=["POST"])
+    def restore():
+        """Restore to original style (clear manual overrides and axes positions)."""
+        from ._bbox import extract_bboxes
+
+        # Clear all manual overrides (including position overrides)
+        editor.style_overrides.clear_manual_overrides()
+
+        # Restore original axes positions
+        editor.restore_axes_positions()
+
+        # Restore original annotation positions (panel labels, text)
+        editor.restore_annotation_positions()
+
+        if editor._initial_base64 and not editor.dark_mode:
+            base64_img = editor._initial_base64
+            import base64 as b64
+            import io
+
+            from PIL import Image
+
+            img_data = b64.b64decode(base64_img)
+            img = Image.open(io.BytesIO(img_data))
+            img_size = img.size
+            mpl_fig = editor.fig.fig if hasattr(editor.fig, "fig") else editor.fig
+            original_dpi = mpl_fig.dpi
+            try:
+                mpl_fig.set_dpi(150)
+                mpl_fig.canvas.draw()
+            except Exception:
+                # Ignore matplotlib/tkinter threading issues in background thread
+                pass
+            bboxes = extract_bboxes(mpl_fig, img_size[0], img_size[1])
+            try:
+                mpl_fig.set_dpi(original_dpi)
+            except Exception:
+                pass
+        else:
+            base64_img, bboxes, img_size = render_with_overrides(
+                editor.fig,
+                None,
+                editor.dark_mode,
+            )
+
+        return jsonify(
+            {
+                "success": True,
+                "image": base64_img,
+                "bboxes": bboxes,
+                "img_size": {"width": img_size[0], "height": img_size[1]},
+                "original_style": editor.style,
+            }
+        )
+
+    @app.route("/diff")
+    def get_diff():
+        """Get differences between original and manual overrides."""
+        return jsonify(
+            {
+                "diff": editor.style_overrides.get_diff(),
+                "has_overrides": editor.style_overrides.has_manual_overrides(),
+            }
+        )
+
+
+__all__ = ["register_style_routes"]

figrecipe/_editor/_templates/__init__.py

@@ -8,13 +8,32 @@ single source of truth. No custom key mapping is needed since all keys
 now match the HTML input IDs directly.
 """
 
+import base64
 import json
+from datetime import datetime
+from pathlib import Path
 from typing import Any, Dict, Tuple
 
+import figrecipe
+
 from ._html import HTML_TEMPLATE
+from ._html_components import HTML_FILE_BROWSER
+from ._html_datatable import HTML_DATATABLE_PANEL
 from ._scripts import SCRIPTS
 from ._styles import STYLES
 
+# Server start time for debugging template reloads
+_SERVER_START_TIME = datetime.now().strftime("%H:%M:%S")
+
+# Load SciTeX icon as base64
+_SCITEX_ICON_PATH = (
+    Path(__file__).parent.parent / "static" / "icons" / "scitex-icon.png"
+)
+_SCITEX_ICON_BASE64 = ""
+if _SCITEX_ICON_PATH.exists():
+    with open(_SCITEX_ICON_PATH, "rb") as f:
+        _SCITEX_ICON_BASE64 = base64.b64encode(f.read()).decode("utf-8")
+
 
 def build_html_template(
     image_base64: str,
@@ -24,6 +43,10 @@ def build_html_template(
     overrides: Dict[str, Any],
     img_size: Tuple[int, int],
     style_name: str = "SCITEX",
+    hot_reload: bool = False,
+    dark_mode: bool = False,
+    figure_has_content: bool = True,
+    debug_mode: bool = False,
 ) -> str:
     """
     Build complete HTML template for figure editor.
@@ -47,6 +70,12 @@ def build_html_template(
         (width, height) of preview image.
     style_name : str
         Name of the applied style preset (e.g., "SCITEX", "MATPLOTLIB").
+    hot_reload : bool
+        Enable hot reload auto-reconnect JavaScript.
+    dark_mode : bool
+        Initial dark mode state from saved preferences.
+    figure_has_content : bool
+        Whether the figure has plot content (hides welcome overlay if True).
 
     Returns
     -------
@@ -57,10 +86,65 @@ def build_html_template(
     # Keys should already match HTML input IDs (YAML-compatible flattened)
     initial_values = {**style, **overrides}
 
+    # Hot reload JavaScript for auto-reconnect on server restart
+    hot_reload_script = ""
+    if hot_reload:
+        hot_reload_script = """
+// Hot Reload: Auto-reconnect when server restarts
+(function() {
+    let isReconnecting = false;
+    let pingInterval = null;
+
+    function showReloadBanner(show) {
+        let banner = document.getElementById('hot-reload-banner');
+        if (!banner && show) {
+            banner = document.createElement('div');
+            banner.id = 'hot-reload-banner';
+            banner.style.cssText = 'position:fixed;top:0;left:0;right:0;background:#f59e0b;' +
+                'color:#000;text-align:center;padding:8px;z-index:9999;font-weight:bold;';
+            banner.textContent = 'Server restarting... will reload automatically';
+            document.body.prepend(banner);
+        }
+        if (banner) {
+            banner.style.display = show ? 'block' : 'none';
+        }
+    }
+
+    function ping() {
+        fetch('/ping', {cache: 'no-store'})
+            .then(r => {
+                if (r.ok && isReconnecting) {
+                    // Server is back! Reload the page
+                    console.log('[Hot Reload] Server is back, reloading...');
+                    window.location.reload();
+                }
+            })
+            .catch(() => {
+                if (!isReconnecting) {
+                    console.log('[Hot Reload] Server disconnected, waiting for restart...');
+                    isReconnecting = true;
+                    showReloadBanner(true);
+                }
+            });
+    }
+
+    // Start pinging every 500ms
+    pingInterval = setInterval(ping, 500);
+    console.log('[Hot Reload] Enabled - watching for server restarts');
+})();
+"""
+
     # Inject data into template
     html = HTML_TEMPLATE
+    html = html.replace("<!-- FILE_BROWSER_PLACEHOLDER -->", HTML_FILE_BROWSER)
+
+    # Insert datatable panel before preview panel
+    html = html.replace(
+        "<!-- Preview Panel -->",
+        HTML_DATATABLE_PANEL + "\n        <!-- Preview Panel -->",
+    )
     html = html.replace("/* STYLES_PLACEHOLDER */", STYLES)
-    html = html.replace("/* SCRIPTS_PLACEHOLDER */", SCRIPTS)
+    html = html.replace("/* SCRIPTS_PLACEHOLDER */", SCRIPTS + hot_reload_script)
     html = html.replace("IMAGE_BASE64_PLACEHOLDER", image_base64)
     html = html.replace("BBOXES_PLACEHOLDER", json.dumps(bboxes))
     html = html.replace("COLOR_MAP_PLACEHOLDER", json.dumps(color_map))
@@ -68,6 +152,37 @@ def build_html_template(
     html = html.replace("IMG_WIDTH_PLACEHOLDER", str(img_size[0]))
     html = html.replace("IMG_HEIGHT_PLACEHOLDER", str(img_size[1]))
     html = html.replace("STYLE_NAME_PLACEHOLDER", style_name)
+    html = html.replace("SCITEX_ICON_PLACEHOLDER", _SCITEX_ICON_BASE64)
+
+    # Dark mode preference - set initial state
+    html = html.replace("DARK_MODE_THEME_PLACEHOLDER", "dark" if dark_mode else "light")
+
+    # Server start time for debugging
+    html = html.replace("SERVER_START_TIME_PLACEHOLDER", _SERVER_START_TIME)
+
+    # Version number
+    html = html.replace("VERSION_PLACEHOLDER", figrecipe.__version__)
+
+    # Welcome overlay - show only for empty figures
+    welcome_display = "none" if figure_has_content else "flex"
+    html = html.replace("WELCOME_DISPLAY_PLACEHOLDER", welcome_display)
+
+    # Debug mode - enables Element Inspector and Show All Bboxes
+    html = html.replace("DEBUG_MODE_PLACEHOLDER", "true" if debug_mode else "false")
+
+    # Debug shortcuts section - only shown when debug mode is enabled
+    debug_shortcuts_html = ""
+    if debug_mode:
+        debug_shortcuts_html = """<div class="shortcut-section debug-shortcuts"><h4>Debug <span class="debug-badge">DEBUG MODE</span></h4>
+                            <div class="shortcut-row"><span class="shortcut-keys"><kbd>Alt</kbd>+<kbd>I</kbd></span><span class="shortcut-desc">Element Inspector</span></div>
+                            <div class="shortcut-row"><span class="shortcut-keys"><kbd>Alt</kbd>+<kbd>B</kbd></span><span class="shortcut-desc">Show All Bboxes</span></div>
+                            <div class="shortcut-row"><span class="shortcut-keys"><kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>I</kbd></span><span class="shortcut-desc">Debug Snapshot</span></div></div>"""
+    html = html.replace("DEBUG_SHORTCUTS_PLACEHOLDER", debug_shortcuts_html)
+
+    # Debug meta (server start time) - only shown in debug mode
+    html = html.replace(
+        "DEBUG_META_DISPLAY_PLACEHOLDER", "" if debug_mode else 'style="display:none"'
+    )
 
     return html