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

figrecipe/_editor/_flask_app.py

@@ -51,11 +51,13 @@ class FigureEditor:
         recipe_path: Optional[Path] = None,
         style: Optional[Dict[str, Any]] = None,
         port: int = 5050,
+        host: str = "127.0.0.1",
         static_png_path: Optional[Path] = None,
         hitmap_base64: Optional[str] = None,
         color_map: Optional[Dict] = None,
         hot_reload: bool = False,
         working_dir: Optional[Path] = None,
+        desktop: bool = False,
     ):
         """
         Initialize figure editor.
@@ -80,10 +82,14 @@ class FigureEditor:
             Enable hot reload - server restarts on source file changes.
         working_dir : Path, optional
             Working directory for file switching (default: current directory).
+        desktop : bool, optional
+            Launch as native desktop window using pywebview.
         """
         self.fig = fig
+        self.desktop = desktop
         self.recipe_path = Path(recipe_path) if recipe_path else None
         self.port = port
+        self.host = host
         self.hot_reload = hot_reload
         self.working_dir = Path(working_dir) if working_dir else Path.cwd()
 
@@ -102,10 +108,7 @@ class FigureEditor:
             with open(static_png_path, "rb") as f:
                 self._initial_base64 = base64.b64encode(f.read()).decode("utf-8")
 
-        # Store original axes positions for restore functionality
-        self._initial_axes_positions = self._capture_axes_positions()
-
-        # Initialize style overrides system
+        # Initialize style overrides system (captures original positions into base_style)
         self._init_style_overrides(style)
 
         # Pre-generated hitmap and color_map
@@ -123,6 +126,8 @@ class FigureEditor:
                 self.style_overrides = existing
                 if programmatic_style:
                     self.style_overrides.programmatic_style = programmatic_style
+                # Ensure original positions are captured even when loading existing overrides
+                self._ensure_original_positions_in_base_style()
                 return
 
         # Get base style from global preset
@@ -149,6 +154,16 @@ class FigureEditor:
 
         self._style_name = style_name
 
+        # Capture original annotation positions into base_style for restore
+        annotation_positions = self._capture_annotation_positions()
+        for key, pos_data in annotation_positions.items():
+            base_style[f"_original_{key}"] = pos_data
+
+        # Capture original axes positions into base_style for restore
+        axes_positions = self._capture_axes_positions()
+        for ax_idx, pos in axes_positions.items():
+            base_style[f"_original_axes_position_{ax_idx}"] = pos
+
         self.style_overrides = create_overrides_from_style(
             base_style=base_style,
             programmatic_style=programmatic_style or {},
@@ -173,6 +188,24 @@ class FigureEditor:
         """Get the final merged style."""
         return self.style_overrides.get_effective_style()
 
+    def _ensure_original_positions_in_base_style(self) -> None:
+        """Ensure original positions are captured in base_style (for existing overrides)."""
+        base_style = self.style_overrides.base_style
+
+        # Add annotation positions if not present
+        annotation_positions = self._capture_annotation_positions()
+        for key, pos_data in annotation_positions.items():
+            base_key = f"_original_{key}"
+            if base_key not in base_style:
+                base_style[base_key] = pos_data
+
+        # Add axes positions if not present
+        axes_positions = self._capture_axes_positions()
+        for ax_idx, pos in axes_positions.items():
+            base_key = f"_original_axes_position_{ax_idx}"
+            if base_key not in base_style:
+                base_style[base_key] = pos
+
     def _capture_axes_positions(self) -> Dict[int, list]:
         """Capture current axes positions (matplotlib coords: [left, bottom, width, height])."""
         mpl_fig = self.fig.fig if hasattr(self.fig, "fig") else self.fig
@@ -184,16 +217,46 @@ class FigureEditor:
         return positions
 
     def restore_axes_positions(self) -> None:
-        """Restore axes to their original positions."""
-        if not self._initial_axes_positions:
-            return
+        """Restore axes to their original positions from base_style."""
+        base_style = self.style_overrides.base_style
         mpl_fig = self.fig.fig if hasattr(self.fig, "fig") else self.fig
         axes = mpl_fig.get_axes()
         for i, ax in enumerate(axes):
-            if i in self._initial_axes_positions:
-                pos = self._initial_axes_positions[i]
+            key = f"_original_axes_position_{i}"
+            if key in base_style:
+                pos = base_style[key]
                 ax.set_position(pos)
 
+    def _capture_annotation_positions(self) -> Dict[str, dict]:
+        """Capture current annotation (text) positions for each axis."""
+        mpl_fig = self.fig.fig if hasattr(self.fig, "fig") else self.fig
+        axes = mpl_fig.get_axes()
+        positions = {}
+        for ax_idx, ax in enumerate(axes):
+            for text_idx, text_obj in enumerate(ax.texts):
+                key = f"ax{ax_idx}_text{text_idx}"
+                pos = text_obj.get_position()
+                positions[key] = {
+                    "position": [
+                        float(pos[0]),
+                        float(pos[1]),
+                    ],  # Convert to float for JSON
+                    "transform_is_axes": bool(text_obj.get_transform() == ax.transAxes),
+                }
+        return positions
+
+    def restore_annotation_positions(self) -> None:
+        """Restore annotations to their original positions from base_style."""
+        base_style = self.style_overrides.base_style
+        mpl_fig = self.fig.fig if hasattr(self.fig, "fig") else self.fig
+        axes = mpl_fig.get_axes()
+        for ax_idx, ax in enumerate(axes):
+            for text_idx, text_obj in enumerate(ax.texts):
+                key = f"_original_ax{ax_idx}_text{text_idx}"
+                if key in base_style:
+                    orig = base_style[key]
+                    text_obj.set_position(tuple(orig["position"]))
+
     def run(self, open_browser: bool = True) -> Dict[str, Any]:
         """
         Run the editor server.
@@ -210,25 +273,52 @@ class FigureEditor:
         """
         from flask import Flask
 
+        from ._routes_annotation import register_annotation_routes
         from ._routes_axis import register_axis_routes
+
+        # DISABLED: Snapshot feature corrupts figure state via visibility changes
+        # from ._routes_snapshot import register_snapshot_routes
+        from ._routes_captions import register_caption_routes
         from ._routes_core import register_core_routes
+        from ._routes_datatable import register_datatable_routes
         from ._routes_element import register_element_routes
+        from ._routes_files import register_file_routes
+        from ._routes_image import register_image_routes
         from ._routes_style import register_style_routes
 
         # Defer hitmap generation until first request (lazy loading)
         self._hitmap_generated = self._hitmap_base64 is not None
 
-        # Create Flask app
-        app = Flask(__name__)
+        # Create Flask app with static folder for assets (click sounds, etc.)
+        static_folder = Path(__file__).parent / "static"
+        app = Flask(
+            __name__, static_folder=str(static_folder), static_url_path="/static"
+        )
 
         # Register all routes
         register_core_routes(app, self)
+        register_file_routes(app, self)
         register_style_routes(app, self)
         register_axis_routes(app, self)
         register_element_routes(app, self)
+        register_image_routes(app, self)
+        register_datatable_routes(app, self)
+        register_annotation_routes(app, self)
+        register_caption_routes(app, self)
+        # DISABLED: register_snapshot_routes(app, self)
 
         # Start server
-        url = f"http://127.0.0.1:{self.port}"
+        url = f"http://{self.host}:{self.port}"
+
+        if self.desktop:
+            # Desktop mode using pywebview
+            return self._run_desktop(app, url)
+        else:
+            # Browser mode
+            return self._run_browser(app, url, open_browser)
+
+    def _run_browser(self, app, url: str, open_browser: bool) -> Dict[str, Any]:
+        """Run editor in browser mode."""
         print(f"Figure Editor running at {url}")
 
         if self.hot_reload:
@@ -239,11 +329,8 @@ class FigureEditor:
             webbrowser.open(url)
 
         try:
-            # Use Flask's built-in reloader when hot_reload is enabled
-            # Note: debug and use_reloader are always False when working with
-            # multiple coding agents to avoid file watching conflicts
             app.run(
-                host="127.0.0.1",
+                host=self.host,
                 port=self.port,
                 debug=False,
                 use_reloader=False,
@@ -254,5 +341,59 @@ class FigureEditor:
 
         return self.overrides
 
+    def _run_desktop(self, app, url: str) -> Dict[str, Any]:
+        """Run editor as native desktop window using pywebview."""
+        try:
+            import webview
+        except ImportError:
+            raise ImportError(
+                "pywebview is required for desktop mode. "
+                "Install with: pip install figrecipe[desktop]"
+            )
+
+        import threading
+
+        print("Figure Editor (Desktop Mode)")
+        print("Close the window to stop and return overrides")
+
+        # Start Flask in a background thread
+        def run_flask():
+            import logging
+
+            # Suppress Flask logging in desktop mode
+            log = logging.getLogger("werkzeug")
+            log.setLevel(logging.ERROR)
+            app.run(
+                host=self.host,
+                port=self.port,
+                debug=False,
+                use_reloader=False,
+                threaded=True,
+            )
+
+        flask_thread = threading.Thread(target=run_flask, daemon=True)
+        flask_thread.start()
+
+        # Wait briefly for Flask to start
+        import time
+
+        time.sleep(0.5)
+
+        # Create native window (variable needed for pywebview lifecycle)
+        _window = webview.create_window(
+            title="FigRecipe Editor",
+            url=url,
+            width=1400,
+            height=900,
+            resizable=True,
+            min_size=(800, 600),
+        )
+
+        # Start webview (blocks until window is closed)
+        webview.start()
+
+        print("\nEditor closed")
+        return self.overrides
+
 
 __all__ = ["FigureEditor"]

figrecipe/_editor/_helpers.py

@@ -68,7 +68,7 @@ def get_form_values_from_style(style: Dict[str, Any]) -> Dict[str, Any]:
     if "output" in style:
         values["output_dpi"] = style["output"].get("dpi", 300)
 
-    # Behavior
+    # Behavior - spine visibility for all four sides
     if "behavior" in style:
         values["behavior_hide_top_spine"] = style["behavior"].get(
             "hide_top_spine", True
@@ -76,6 +76,12 @@ def get_form_values_from_style(style: Dict[str, Any]) -> Dict[str, Any]:
         values["behavior_hide_right_spine"] = style["behavior"].get(
             "hide_right_spine", True
         )
+        values["behavior_hide_bottom_spine"] = style["behavior"].get(
+            "hide_bottom_spine", False
+        )
+        values["behavior_hide_left_spine"] = style["behavior"].get(
+            "hide_left_spine", False
+        )
         values["behavior_grid"] = style["behavior"].get("grid", False)
 
     # Legend
@@ -163,26 +169,29 @@ def render_with_overrides(
         warnings.filterwarnings("ignore", "constrained_layout not applied")
         warnings.filterwarnings("ignore", category=UserWarning)
         try:
-            new_fig.savefig(buf, format="png", dpi=150, bbox_inches="tight")
+            # Standard render - layout handled by figure settings
+            # Use transparent background if specified in overrides
+            transparent = (
+                overrides.get("output_transparent", True) if overrides else True
+            )
+            new_fig.savefig(buf, format="png", dpi=150, transparent=transparent)
         except Exception:
-            # Fall back to saving without bbox_inches="tight"
-            # Catches matplotlib internal exceptions (e.g., Done from _get_renderer)
             buf = io.BytesIO()
-            # Reset canvas and draw method to clean state
             new_fig.set_canvas(FigureCanvasAgg(new_fig))
             if original_draw is not None:
                 new_fig.draw = original_draw
             try:
-                new_fig.savefig(buf, format="png", dpi=150)
+                transparent = (
+                    overrides.get("output_transparent", True) if overrides else True
+                )
+                new_fig.savefig(buf, format="png", dpi=150, transparent=transparent)
             except Exception:
-                # Last resort: create empty placeholder
                 from PIL import Image as PILImage
 
                 placeholder = PILImage.new("RGB", (400, 300), color=(240, 240, 240))
                 placeholder.save(buf, format="PNG")
                 buf.seek(0)
         finally:
-            # Always restore original draw method to prevent corruption
             if original_draw is not None and hasattr(new_fig, "draw"):
                 try:
                     new_fig.draw = original_draw

figrecipe/_editor/_hitmap/_detect.py

@@ -5,18 +5,20 @@
 from typing import Any, Dict
 
 
-def detect_plot_types(fig) -> Dict[int, Dict[str, Any]]:
+def detect_plot_types(fig, debug: bool = False) -> Dict[int, Dict[str, Any]]:
     """Detect plot types from recorded calls in figure.
 
     Parameters
     ----------
     fig : Figure
         The figure to analyze.
+    debug : bool
+        If True, print debug information.
 
     Returns
     -------
     dict
-        Mapping from ax_index to plot type info.
+        Mapping from ax_index (matching fig.get_axes() order) to plot type info.
     """
     # Get figure record if available
     if hasattr(fig, "record"):
@@ -24,48 +26,103 @@ def detect_plot_types(fig) -> Dict[int, Dict[str, Any]]:
     elif hasattr(fig, "fig") and hasattr(fig.fig, "_record"):
         record = fig.fig._record
     else:
+        if debug:
+            print("[detect_plot_types] No record found")
         return {}
 
+    # Get the actual matplotlib figure and its axes
+    mpl_fig = fig.fig if hasattr(fig, "fig") else fig
+    axes_list = mpl_fig.get_axes()
+
     result = {}
 
     # Process each axes in the record
     if hasattr(record, "axes"):
-        # First pass: collect all ax_keys to determine grid dimensions
-        ax_keys = list(record.axes.keys())
-        max_row, max_col = 0, 0
-        for ax_key in ax_keys:
-            try:
-                parts = ax_key.split("_")
-                row, col = int(parts[1]), int(parts[2])
-                max_row = max(max_row, row)
-                max_col = max(max_col, col)
-            except (ValueError, IndexError):
-                pass
-        ncols = max_col + 1
-
+        # Build mapping from ax_key to ax_record's plot info
+        ax_key_to_info = {}
         for ax_key, ax_record in record.axes.items():
-            # Extract ax_index from key (e.g., "ax_0_0" -> 0, "ax_2_2" -> 8 for 3x3)
-            try:
-                parts = ax_key.split("_")
-                row, col = int(parts[1]), int(parts[2])
-                ax_idx = row * ncols + col
-            except (ValueError, IndexError):
-                ax_idx = 0
-
-            if ax_idx not in result:
-                result[ax_idx] = {"types": set(), "call_ids": {}}
-
-            # Collect all call types and their IDs
+            info = {"types": set(), "call_ids": {}}
+
             if hasattr(ax_record, "calls"):
                 for call in ax_record.calls:
                     func_name = call.function
                     call_id = call.id
 
-                    result[ax_idx]["types"].add(func_name)
-
-                    if func_name not in result[ax_idx]["call_ids"]:
-                        result[ax_idx]["call_ids"][func_name] = []
-                    result[ax_idx]["call_ids"][func_name].append(call_id)
+                    info["types"].add(func_name)
+
+                    if func_name not in info["call_ids"]:
+                        info["call_ids"][func_name] = []
+                    info["call_ids"][func_name].append(call_id)
+
+            ax_key_to_info[ax_key] = info
+
+        # Map ax_keys to current axes positions using position matching
+        # This handles the case where panels have been dragged to new positions
+        ax_keys_sorted = sorted(record.axes.keys())
+
+        # Debug: Check which ax_keys have position_override
+        overrides = {
+            k: getattr(record.axes[k], "position_override", None)
+            for k in ax_keys_sorted
+            if hasattr(record.axes[k], "position_override")
+            and record.axes[k].position_override
+        }
+        if overrides:
+            print(f"[detect_plot_types] Position overrides: {overrides}")
+
+        for ax_idx, ax in enumerate(axes_list):
+            # Try to find the matching ax_record by comparing positions
+            # or fall back to index-based matching
+            matched = False
+            ax_pos = ax.get_position()
+
+            for ax_key in ax_keys_sorted:
+                ax_record = record.axes[ax_key]
+                # Check if there's a position_override that matches
+                # Must check ALL 4 coordinates to avoid false matches
+                if (
+                    hasattr(ax_record, "position_override")
+                    and ax_record.position_override
+                ):
+                    rec_pos = ax_record.position_override
+                    # Position override is [x0, y0, width, height]
+                    if len(rec_pos) >= 4:
+                        if (
+                            abs(rec_pos[0] - ax_pos.x0) < 0.01
+                            and abs(rec_pos[1] - ax_pos.y0) < 0.01
+                            and abs(rec_pos[2] - ax_pos.width) < 0.01
+                            and abs(rec_pos[3] - ax_pos.height) < 0.01
+                        ):
+                            print(
+                                f"[detect_plot_types] ax_idx={ax_idx} matched {ax_key} "
+                                f"via position_override"
+                            )
+                            result[ax_idx] = ax_key_to_info.get(
+                                ax_key, {"types": set(), "call_ids": {}}
+                            )
+                            matched = True
+                            break
+                    else:
+                        # Fallback for old format with only x0, y0
+                        if (
+                            abs(rec_pos[0] - ax_pos.x0) < 0.01
+                            and abs(rec_pos[1] - ax_pos.y0) < 0.01
+                        ):
+                            result[ax_idx] = ax_key_to_info.get(
+                                ax_key, {"types": set(), "call_ids": {}}
+                            )
+                            matched = True
+                            break
+
+            # Fall back to index-based matching if position match failed
+            if not matched and ax_idx < len(ax_keys_sorted):
+                ax_key = ax_keys_sorted[ax_idx]
+                info = ax_key_to_info.get(ax_key, {"types": set(), "call_ids": {}})
+                print(
+                    f"[detect_plot_types] ax_idx={ax_idx} fallback to {ax_key}, "
+                    f"types={info.get('types', set())}"
+                )
+                result[ax_idx] = info
 
     return result
 

figrecipe/_editor/_hitmap_main.py

@@ -81,7 +81,7 @@ def generate_hitmap(
     element_id = 1
 
     # Detect plot types from record
-    plot_types = detect_plot_types(fig)
+    plot_types = detect_plot_types(fig, debug=False)
 
     # Get all axes (handle RecordingFigure wrapper)
     if hasattr(fig, "fig"):
@@ -135,10 +135,10 @@ def generate_hitmap(
         ax.set_facecolor(normalize_color(BACKGROUND_COLOR))
 
     # Render to buffer
+    # IMPORTANT: Do NOT use bbox_inches="tight" - it causes dimension changes
+    # between renders when elements change (e.g., color). Must match main render.
     buf = io.BytesIO()
-    fig.savefig(
-        buf, format="png", dpi=dpi, facecolor=fig.get_facecolor(), bbox_inches="tight"
-    )
+    fig.savefig(buf, format="png", dpi=dpi, facecolor=fig.get_facecolor())
     buf.seek(0)
 
     # Load as PIL Image

figrecipe/_editor/_overrides.py

@@ -58,12 +58,15 @@ class StyleOverrides:
         Returns
         -------
         dict
-            Merged style dictionary.
+            Merged style dictionary including call_overrides.
         """
         result = {}
         result.update(self.base_style)
         result.update(self.programmatic_style)
         result.update(self.manual_overrides)
+        # Include call_overrides for apply_overrides to use
+        if self.call_overrides:
+            result["call_overrides"] = self.call_overrides
         return result
 
     def get_original_style(self) -> Dict[str, Any]: