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

figrecipe/_editor/_routes_composition.py

@@ -0,0 +1,270 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Composition-related Flask routes for the figure editor.
+
+Provides API endpoints for:
+- Panel visibility (hide/show)
+- Panel alignment
+- Panel distribution
+- Smart alignment
+- Importing axes from external recipes
+"""
+
+from pathlib import Path
+
+from flask import jsonify, request
+
+from ._helpers import render_with_overrides
+
+
+def register_composition_routes(app, editor):
+    """Register composition routes with the Flask app."""
+
+    @app.route("/api/panel-visibility", methods=["POST"])
+    def set_panel_visibility():
+        """Toggle panel visibility.
+
+        Request JSON:
+            position: [row, col] - Panel position
+            visible: bool - Target visibility state
+
+        Returns:
+            success: bool
+            image: str - Updated preview as base64
+            bboxes: dict - Updated bounding boxes
+        """
+        from .._composition import hide_panel, show_panel
+
+        data = request.get_json() or {}
+        position = tuple(data.get("position", [0, 0]))
+        visible = data.get("visible", True)
+
+        try:
+            if visible:
+                show_panel(editor.fig, position)
+            else:
+                hide_panel(editor.fig, position)
+
+            base64_img, bboxes, img_size = render_with_overrides(
+                editor.fig,
+                editor.get_effective_style(),
+                editor.dark_mode,
+            )
+
+            return jsonify(
+                {
+                    "success": True,
+                    "image": base64_img,
+                    "bboxes": bboxes,
+                    "img_size": {"width": img_size[0], "height": img_size[1]},
+                }
+            )
+
+        except Exception as e:
+            return jsonify({"success": False, "error": str(e)}), 500
+
+    @app.route("/api/align-panels", methods=["POST"])
+    def align_panels_route():
+        """Align selected panels.
+
+        Request JSON:
+            panels: [[row, col], ...] - List of panel positions
+            mode: str - Alignment mode (left, right, top, bottom, etc.)
+            reference: [row, col] - Optional reference panel
+
+        Returns:
+            success: bool
+            image: str - Updated preview as base64
+            bboxes: dict - Updated bounding boxes
+        """
+        from .._composition import align_panels
+
+        data = request.get_json() or {}
+        panels = [tuple(p) for p in data.get("panels", [])]
+        mode = data.get("mode", "left")
+        reference = tuple(data.get("reference")) if data.get("reference") else None
+
+        try:
+            align_panels(editor.fig, panels, mode, reference)
+
+            base64_img, bboxes, img_size = render_with_overrides(
+                editor.fig,
+                editor.get_effective_style(),
+                editor.dark_mode,
+            )
+
+            return jsonify(
+                {
+                    "success": True,
+                    "image": base64_img,
+                    "bboxes": bboxes,
+                    "img_size": {"width": img_size[0], "height": img_size[1]},
+                }
+            )
+
+        except Exception as e:
+            return jsonify({"success": False, "error": str(e)}), 500
+
+    @app.route("/api/distribute-panels", methods=["POST"])
+    def distribute_panels_route():
+        """Distribute panels evenly.
+
+        Request JSON:
+            panels: [[row, col], ...] - List of panel positions
+            direction: str - 'horizontal' or 'vertical'
+            spacing_mm: float - Optional fixed spacing in mm
+
+        Returns:
+            success: bool
+            image: str - Updated preview as base64
+            bboxes: dict - Updated bounding boxes
+        """
+        from .._composition import distribute_panels
+
+        data = request.get_json() or {}
+        panels = [tuple(p) for p in data.get("panels", [])]
+        direction = data.get("direction", "horizontal")
+        spacing_mm = data.get("spacing_mm")
+
+        try:
+            distribute_panels(editor.fig, panels, direction, spacing_mm)
+
+            base64_img, bboxes, img_size = render_with_overrides(
+                editor.fig,
+                editor.get_effective_style(),
+                editor.dark_mode,
+            )
+
+            return jsonify(
+                {
+                    "success": True,
+                    "image": base64_img,
+                    "bboxes": bboxes,
+                    "img_size": {"width": img_size[0], "height": img_size[1]},
+                }
+            )
+
+        except Exception as e:
+            return jsonify({"success": False, "error": str(e)}), 500
+
+    @app.route("/api/smart-align", methods=["POST"])
+    def smart_align_route():
+        """Auto-align all panels based on grid structure.
+
+        Request JSON:
+            panels: [[row, col], ...] - Optional specific panels to align
+
+        Returns:
+            success: bool
+            image: str - Updated preview as base64
+            bboxes: dict - Updated bounding boxes
+        """
+        from .._composition import smart_align
+
+        data = request.get_json() or {}
+        panels = None
+        if data.get("panels"):
+            panels = [tuple(p) for p in data["panels"]]
+
+        try:
+            smart_align(editor.fig, panels)
+
+            base64_img, bboxes, img_size = render_with_overrides(
+                editor.fig,
+                editor.get_effective_style(),
+                editor.dark_mode,
+            )
+
+            return jsonify(
+                {
+                    "success": True,
+                    "image": base64_img,
+                    "bboxes": bboxes,
+                    "img_size": {"width": img_size[0], "height": img_size[1]},
+                }
+            )
+
+        except Exception as e:
+            return jsonify({"success": False, "error": str(e)}), 500
+
+    @app.route("/api/import-panel", methods=["POST"])
+    def import_panel():
+        """Import axes from another recipe into current figure.
+
+        Request JSON:
+            source: str - Path to source recipe file
+            source_axes: str - Axes key in source (default: 'ax_0_0')
+            target_position: [row, col] - Target panel position
+
+        Returns:
+            success: bool
+            image: str - Updated preview as base64
+            bboxes: dict - Updated bounding boxes
+        """
+        from .._composition import import_axes
+
+        data = request.get_json() or {}
+        source_path = data.get("source")
+        source_axes = data.get("source_axes", "ax_0_0")
+        target_position = tuple(data.get("target_position", [0, 0]))
+
+        if not source_path:
+            return jsonify({"success": False, "error": "No source path provided"}), 400
+
+        try:
+            # Resolve relative paths against working directory
+            working_dir = getattr(editor, "working_dir", Path.cwd())
+            source_path = Path(source_path)
+            if not source_path.is_absolute():
+                source_path = working_dir / source_path
+
+            import_axes(editor.fig, target_position, source_path, source_axes)
+
+            base64_img, bboxes, img_size = render_with_overrides(
+                editor.fig,
+                editor.get_effective_style(),
+                editor.dark_mode,
+            )
+
+            return jsonify(
+                {
+                    "success": True,
+                    "image": base64_img,
+                    "bboxes": bboxes,
+                    "img_size": {"width": img_size[0], "height": img_size[1]},
+                }
+            )
+
+        except Exception as e:
+            return jsonify({"success": False, "error": str(e)}), 500
+
+    @app.route("/api/panel-info")
+    def get_panel_info():
+        """Get information about all panels in the figure.
+
+        Returns:
+            panels: list of {position, visible, has_content}
+        """
+        panels = []
+        for ax_key, ax_record in editor.fig.record.axes.items():
+            parts = ax_key.split("_")
+            if len(parts) >= 3:
+                row, col = int(parts[1]), int(parts[2])
+            else:
+                row, col = 0, 0
+
+            panels.append(
+                {
+                    "key": ax_key,
+                    "position": [row, col],
+                    "visible": getattr(ax_record, "visible", True),
+                    "has_content": len(ax_record.calls) > 0,
+                    "call_count": len(ax_record.calls),
+                }
+            )
+
+        return jsonify({"panels": panels})
+
+
+__all__ = ["register_composition_routes"]

figrecipe/_editor/_routes_core.py

@@ -2,14 +2,23 @@
 # -*- coding: utf-8 -*-
 """
 Core Flask route handlers for the figure editor.
-Handles main page, preview, update, hitmap, and file switching routes.
+Handles main page, preview, update, and hitmap routes.
+File operations moved to _routes_files.py.
 """
 
+import os
+
 from flask import jsonify, render_template_string, request
 
+from . import _check_figure_has_content
 from ._helpers import render_with_overrides
 
 
+def _is_debug_mode() -> bool:
+    """Check if debug mode is enabled via FIGRECIPE_DEBUG_MODE env var."""
+    return os.environ.get("FIGRECIPE_DEBUG_MODE", "").lower() in ("1", "true", "yes")
+
+
 def register_core_routes(app, editor):
     """Register core routes with the Flask app."""
     from ._hitmap import generate_hitmap, hitmap_to_base64
@@ -26,6 +35,9 @@ def register_core_routes(app, editor):
 
         style_name = getattr(editor, "_style_name", "SCITEX")
 
+        # Check if figure has plot content
+        figure_has_content = _check_figure_has_content(editor.fig)
+
         html = build_html_template(
             image_base64=base64_img,
             bboxes=bboxes,
@@ -36,6 +48,8 @@ def register_core_routes(app, editor):
             style_name=style_name,
             hot_reload=editor.hot_reload,
             dark_mode=editor.dark_mode,
+            figure_has_content=figure_has_content,
+            debug_mode=_is_debug_mode(),
         )
 
         return render_template_string(html)
@@ -108,177 +122,5 @@ def register_core_routes(app, editor):
             }
         )
 
-    @app.route("/api/files")
-    def list_files():
-        """List available recipe files in working directory."""
-        from pathlib import Path
-
-        working_dir = getattr(editor, "working_dir", Path.cwd())
-        files = []
-
-        # Find all YAML recipe files
-        for pattern in ["*.yaml", "*.yml"]:
-            for f in working_dir.glob(pattern):
-                # Skip hidden files and overrides files
-                if f.name.startswith(".") or f.name.endswith(".overrides.yaml"):
-                    continue
-
-                # Check for associated PNG
-                png_path = f.with_suffix(".png")
-                has_png = png_path.exists()
-
-                files.append(
-                    {
-                        "path": str(f.relative_to(working_dir)),
-                        "name": f.stem,
-                        "has_image": has_png,
-                        "is_current": (
-                            editor.recipe_path
-                            and f.resolve() == editor.recipe_path.resolve()
-                        ),
-                    }
-                )
-
-        # Sort by name
-        files.sort(key=lambda x: x["name"].lower())
-
-        return jsonify(
-            {
-                "files": files,
-                "working_dir": str(working_dir),
-                "current_file": (
-                    str(editor.recipe_path.name) if editor.recipe_path else None
-                ),
-            }
-        )
-
-    @app.route("/api/switch", methods=["POST"])
-    def switch_file():
-        """Switch to a different recipe file."""
-        from pathlib import Path
-
-        from .._reproducer import reproduce
-
-        data = request.get_json() or {}
-        file_path = data.get("path")
-
-        if not file_path:
-            return jsonify({"error": "No file path provided"}), 400
-
-        working_dir = getattr(editor, "working_dir", Path.cwd())
-        full_path = working_dir / file_path
-
-        if not full_path.exists():
-            return jsonify({"error": f"File not found: {file_path}"}), 404
-
-        try:
-            # Reproduce the figure from the new recipe
-            fig, axes = reproduce(full_path)
-
-            # Wrap in RecordingFigure if needed
-            from .._wrappers._figure import RecordingFigure
-
-            if not isinstance(fig, RecordingFigure):
-                from .._recorder import FigureRecord, Recorder
-
-                wrapped_fig = RecordingFigure.__new__(RecordingFigure)
-                wrapped_fig._fig = fig
-                wrapped_fig._axes = [[ax] for ax in fig.axes]
-                wrapped_fig._recorder = Recorder()
-                wrapped_fig._recorder._figure_record = FigureRecord(
-                    figsize=tuple(fig.get_size_inches()),
-                    dpi=int(fig.dpi),
-                )
-                fig = wrapped_fig
-
-            # Update editor state
-            editor.fig = fig
-            editor.recipe_path = full_path
-            editor._hitmap_generated = False
-            editor._color_map = {}
-
-            # Re-init style overrides
-            editor._init_style_overrides(None)
-
-            # Regenerate hitmap
-            hitmap_img, editor._color_map = generate_hitmap(editor.fig)
-            editor._hitmap_base64 = hitmap_to_base64(hitmap_img)
-            editor._hitmap_generated = True
-
-            # Render new preview
-            base64_img, bboxes, img_size = render_with_overrides(
-                editor.fig,
-                editor.get_effective_style(),
-                editor.dark_mode,
-            )
-
-            return jsonify(
-                {
-                    "success": True,
-                    "image": base64_img,
-                    "bboxes": bboxes,
-                    "color_map": editor._color_map,
-                    "img_size": {"width": img_size[0], "height": img_size[1]},
-                    "file": file_path,
-                }
-            )
-
-        except Exception as e:
-            return jsonify({"error": str(e)}), 500
-
-    @app.route("/api/new", methods=["POST"])
-    def new_figure():
-        """Create a new blank figure."""
-        from .. import subplots
-
-        try:
-            # Create new blank figure
-            fig, ax = subplots()
-            ax.set_title("New Figure")
-            ax.text(
-                0.5,
-                0.5,
-                "Add plots using fr.edit(fig)",
-                ha="center",
-                va="center",
-                transform=ax.transAxes,
-                fontsize=12,
-                color="gray",
-            )
-
-            # Update editor state
-            editor.fig = fig
-            editor.recipe_path = None
-            editor._hitmap_generated = False
-            editor._color_map = {}
-
-            # Re-init style overrides
-            editor._init_style_overrides(None)
-
-            # Regenerate hitmap
-            hitmap_img, editor._color_map = generate_hitmap(editor.fig)
-            editor._hitmap_base64 = hitmap_to_base64(hitmap_img)
-            editor._hitmap_generated = True
-
-            # Render new preview
-            base64_img, bboxes, img_size = render_with_overrides(
-                editor.fig,
-                editor.get_effective_style(),
-                editor.dark_mode,
-            )
-
-            return jsonify(
-                {
-                    "success": True,
-                    "image": base64_img,
-                    "bboxes": bboxes,
-                    "color_map": editor._color_map,
-                    "img_size": {"width": img_size[0], "height": img_size[1]},
-                }
-            )
-
-        except Exception as e:
-            return jsonify({"error": str(e)}), 500
-
 
 __all__ = ["register_core_routes"]