scitex 2.14.0__py3-none-any.whl → 2.15.3__py3-none-any.whl

scitex/canvas/editor/flask_editor/_core/_editor.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-24 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/canvas/editor/flask_editor/_core/_editor.py
+
+"""Core WebEditor class for Flask-based figure editing."""
+
+import copy
+import threading
+import time
+import webbrowser
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from .._utils import check_port_available, kill_process_on_port
+
+__all__ = ["WebEditor"]
+
+
+class WebEditor:
+    """Browser-based figure editor using Flask.
+
+    Features:
+    - Displays existing PNG from plot bundle (no re-rendering)
+    - Hitmap-based element selection for precise clicking
+    - Property editors with sliders and color pickers
+    - Save to .manual.json
+    - SciTeX style defaults pre-filled
+    - Auto-finds available port if default is in use
+    """
+
+    def __init__(
+        self,
+        json_path: Path,
+        metadata: Dict[str, Any],
+        csv_data: Optional[Any] = None,
+        png_path: Optional[Path] = None,
+        hitmap_path: Optional[Path] = None,
+        manual_overrides: Optional[Dict[str, Any]] = None,
+        port: int = 5050,
+        panel_info: Optional[Dict[str, Any]] = None,
+    ):
+        self.json_path = Path(json_path)
+        self.metadata = metadata
+        self.csv_data = csv_data
+        self.png_path = Path(png_path) if png_path else None
+        self.hitmap_path = Path(hitmap_path) if hitmap_path else None
+        self.manual_overrides = manual_overrides or {}
+        self._requested_port = port
+        self.port = port
+        self.panel_info = panel_info
+
+        # Extract hit_regions from metadata
+        self.hit_regions = metadata.get("hit_regions", {})
+        self.color_map = self.hit_regions.get("color_map", {})
+
+        # Get SciTeX defaults and merge with metadata
+        from ..._defaults import extract_defaults_from_metadata, get_scitex_defaults
+
+        self.scitex_defaults = get_scitex_defaults()
+        self.metadata_defaults = extract_defaults_from_metadata(metadata)
+
+        # Start with defaults, then overlay manual overrides
+        self.current_overrides = copy.deepcopy(self.scitex_defaults)
+        self.current_overrides.update(self.metadata_defaults)
+        self.current_overrides.update(self.manual_overrides)
+
+        # Track initial state to detect modifications
+        self._initial_overrides = copy.deepcopy(self.current_overrides)
+        self._user_modified = False
+
+    def run(self):
+        """Launch the web editor."""
+        try:
+            from flask import Flask
+        except ImportError:
+            raise ImportError(
+                "Flask is required for web editor. Install: pip install flask"
+            )
+
+        # Handle port conflicts
+        self._setup_port()
+
+        # Configure Flask
+        import os
+
+        static_folder = os.path.join(
+            os.path.dirname(os.path.dirname(__file__)), "static"
+        )
+        app = Flask(__name__, static_folder=static_folder, static_url_path="/static")
+
+        # Register all routes
+        self._register_routes(app)
+
+        # Open browser after short delay
+        def open_browser():
+            time.sleep(0.5)
+            webbrowser.open(f"http://127.0.0.1:{self.port}")
+
+        threading.Thread(target=open_browser, daemon=True).start()
+
+        print(f"Starting SciTeX Figure Editor at http://127.0.0.1:{self.port}")
+        print("Press Ctrl+C to stop")
+
+        app.run(host="127.0.0.1", port=self.port, debug=False, use_reloader=False)
+
+    def _setup_port(self):
+        """Handle port conflicts."""
+        max_retries = 3
+        for attempt in range(max_retries):
+            if check_port_available(self._requested_port):
+                self.port = self._requested_port
+                break
+            print(
+                f"Port {self._requested_port} in use. Freeing... "
+                f"(attempt {attempt + 1}/{max_retries})"
+            )
+            kill_process_on_port(self._requested_port)
+            time.sleep(1.0)
+        else:
+            print(f"Warning: Port {self._requested_port} may still be in use")
+            self.port = self._requested_port
+
+    def _register_routes(self, app):
+        """Register all Flask routes."""
+        from ._routes_basic import (
+            create_colormap_route,
+            create_hitmap_route,
+            create_index_route,
+            create_preview_route,
+            create_shutdown_route,
+            create_stats_route,
+            create_update_route,
+        )
+        from ._routes_export import (
+            create_download_figz_route,
+            create_download_route,
+            create_export_route,
+        )
+        from ._routes_panels import (
+            create_panels_route,
+            create_switch_panel_route,
+        )
+        from ._routes_save import (
+            create_save_element_position_route,
+            create_save_layout_route,
+            create_save_route,
+        )
+
+        # Basic routes
+        create_index_route(app, self)
+        create_preview_route(app, self)
+        create_hitmap_route(app, self)
+        create_colormap_route(app, self)
+        create_update_route(app, self)
+        create_stats_route(app, self)
+        create_shutdown_route(app, self)
+
+        # Panel routes
+        create_panels_route(app, self)
+        create_switch_panel_route(app, self)
+
+        # Save routes
+        create_save_route(app, self)
+        create_save_layout_route(app, self)
+        create_save_element_position_route(app, self)
+
+        # Export routes
+        create_export_route(app, self)
+        create_download_route(app, self)
+        create_download_figz_route(app, self)
+
+
+# EOF

scitex/canvas/editor/flask_editor/_core/_export_helpers.py

@@ -0,0 +1,353 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-24 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/canvas/editor/flask_editor/_core/_export_helpers.py
+
+"""Export and compose helpers for figure bundles."""
+
+import io
+import json as json_module
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Dict, List
+
+if TYPE_CHECKING:
+    from .._core import WebEditor
+
+__all__ = ["export_composed_figure", "compose_panels_to_figure"]
+
+
+def export_composed_figure(
+    editor: "WebEditor",
+    formats: List[str] = None,
+    dpi: int = 150,
+) -> Dict[str, Any]:
+    """Compose and export figure to bundle.
+
+    Parameters
+    ----------
+    editor : WebEditor
+        The editor instance with panel_info.
+    formats : list of str
+        Output formats (default: ["png", "svg"]).
+    dpi : int
+        Resolution for raster output.
+
+    Returns
+    -------
+    dict
+        Result with 'success' and 'exported' keys.
+    """
+    if formats is None:
+        formats = ["png", "svg"]
+
+    import matplotlib
+
+    matplotlib.use("Agg")
+
+    import matplotlib.pyplot as plt
+
+    from scitex.io import ZipBundle
+
+    if not editor.panel_info:
+        return {"success": False, "error": "No panel info"}
+
+    bundle_path = editor.panel_info.get("bundle_path")
+    figure_dir = editor.panel_info.get("figure_dir")
+
+    if not bundle_path and not figure_dir:
+        return {"success": False, "error": "No bundle path"}
+
+    figure_name = (
+        Path(bundle_path).stem
+        if bundle_path
+        else (Path(figure_dir).stem.replace(".figure", "") if figure_dir else "figure")
+    )
+
+    # Read spec.json and layout.json
+    spec, layout_overrides = _read_spec_and_layout(
+        bundle_path, figure_dir, editor.panel_info
+    )
+
+    # Get figure dimensions
+    fig_width_mm, fig_height_mm = _get_figure_dimensions(spec)
+    fig_width_in = fig_width_mm / 25.4
+    fig_height_in = fig_height_mm / 25.4
+
+    fig = plt.figure(figsize=(fig_width_in, fig_height_in), dpi=dpi, facecolor="white")
+
+    # Compose panels
+    _compose_panels(
+        fig,
+        spec,
+        editor.panel_info,
+        layout_overrides,
+        fig_width_mm,
+        fig_height_mm,
+    )
+
+    exported = {}
+
+    # Save to bundle
+    if bundle_path:
+        with ZipBundle(bundle_path, mode="a") as bundle:
+            for fmt in formats:
+                buf = io.BytesIO()
+                fig.savefig(
+                    buf,
+                    format=fmt,
+                    dpi=dpi,
+                    bbox_inches="tight",
+                    facecolor="white",
+                    pad_inches=0.02,
+                )
+                buf.seek(0)
+                export_path = f"exports/{figure_name}.{fmt}"
+                bundle.write_bytes(export_path, buf.read())
+                exported[fmt] = export_path
+
+    plt.close(fig)
+    return {"success": True, "exported": exported}
+
+
+def compose_panels_to_figure(
+    editor: "WebEditor",
+    fmt: str = "png",
+    dpi: int = 150,
+) -> io.BytesIO:
+    """Compose panels into a figure and return as BytesIO.
+
+    Parameters
+    ----------
+    editor : WebEditor
+        The editor instance.
+    fmt : str
+        Output format.
+    dpi : int
+        Resolution.
+
+    Returns
+    -------
+    io.BytesIO
+        The composed figure as bytes.
+    """
+    import matplotlib
+
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+
+    bundle_path = editor.panel_info.get("bundle_path")
+    figure_dir = editor.panel_info.get("figure_dir")
+
+    spec, layout_overrides = _read_spec_and_layout(
+        bundle_path, figure_dir, editor.panel_info
+    )
+
+    fig_width_mm, fig_height_mm = _get_figure_dimensions(spec)
+    fig_width_in = fig_width_mm / 25.4
+    fig_height_in = fig_height_mm / 25.4
+
+    fig = plt.figure(
+        figsize=(fig_width_in, fig_height_in),
+        dpi=dpi,
+        facecolor="white",
+    )
+
+    _compose_panels(
+        fig,
+        spec,
+        editor.panel_info,
+        layout_overrides,
+        fig_width_mm,
+        fig_height_mm,
+    )
+
+    buf = io.BytesIO()
+    fig.savefig(
+        buf,
+        format=fmt if fmt != "jpg" else "jpeg",
+        dpi=dpi,
+        bbox_inches="tight",
+        facecolor="white",
+        pad_inches=0.02,
+    )
+    plt.close(fig)
+    buf.seek(0)
+    return buf
+
+
+def _read_spec_and_layout(bundle_path, figure_dir, panel_info):
+    """Read spec.json and layout.json from bundle or directory."""
+    from scitex.io import ZipBundle
+
+    spec = {}
+    layout_overrides = {}
+
+    if bundle_path:
+        try:
+            with ZipBundle(bundle_path, mode="r") as bundle:
+                spec = bundle.read_json("spec.json")
+                try:
+                    layout_overrides = bundle.read_json("layout.json")
+                except:
+                    pass
+        except:
+            pass
+    elif figure_dir:
+        spec_path = Path(figure_dir) / "spec.json"
+        if spec_path.exists():
+            with open(spec_path) as f:
+                spec = json_module.load(f)
+        layout_path = Path(figure_dir) / "layout.json"
+        if layout_path.exists():
+            with open(layout_path) as f:
+                layout_overrides = json_module.load(f)
+
+    # In-memory layout overrides take precedence
+    if panel_info and panel_info.get("layout"):
+        layout_overrides = panel_info.get("layout", {})
+
+    return spec, layout_overrides
+
+
+def _get_figure_dimensions(spec):
+    """Extract figure dimensions from spec."""
+    fig_width_mm = 180
+    fig_height_mm = 120
+
+    if "figure" in spec:
+        fig_info = spec.get("figure", {})
+        styles = fig_info.get("styles", {})
+        size = styles.get("size", {})
+        fig_width_mm = size.get("width_mm", 180)
+        fig_height_mm = size.get("height_mm", 120)
+
+    return fig_width_mm, fig_height_mm
+
+
+def _compose_panels(
+    fig, spec, panel_info, layout_overrides, fig_width_mm, fig_height_mm
+):
+    """Compose panels onto the figure."""
+    import zipfile
+
+    import numpy as np
+    from PIL import Image
+
+    from scitex.io import ZipBundle
+
+    panels_spec = spec.get("panels", [])
+    panel_paths = panel_info.get("panel_paths", [])
+    panel_is_zip = panel_info.get("panel_is_zip", [])
+
+    exclude_patterns = ["hitmap", "overview", "thumb", "preview"]
+
+    for panel_spec in panels_spec:
+        panel_id = panel_spec.get("id", "")
+        pos = panel_spec.get("position", {})
+        size = panel_spec.get("size", {})
+
+        # Skip auxiliary panels
+        panel_id_lower = panel_id.lower()
+        if any(
+            skip in panel_id_lower for skip in ["overview", "thumb", "preview", "aux"]
+        ):
+            continue
+
+        # Find panel path
+        panel_path, panel_name, is_zip = _find_panel_path(
+            panel_id, panel_paths, panel_is_zip
+        )
+        if not panel_path:
+            continue
+
+        # Get layout override
+        override = layout_overrides.get(panel_name, {})
+        override_pos = override.get("position", {})
+        override_size = override.get("size", {})
+
+        x_mm = override_pos.get("x_mm", pos.get("x_mm", 0))
+        y_mm = override_pos.get("y_mm", pos.get("y_mm", 0))
+        w_mm = override_size.get("width_mm", size.get("width_mm", 60))
+        h_mm = override_size.get("height_mm", size.get("height_mm", 40))
+
+        x_frac = x_mm / fig_width_mm
+        y_frac = 1 - (y_mm + h_mm) / fig_height_mm
+        w_frac = w_mm / fig_width_mm
+        h_frac = h_mm / fig_height_mm
+
+        # Load and place panel image
+        try:
+            if is_zip:
+                with ZipBundle(panel_path, mode="r") as plot_bundle:
+                    with zipfile.ZipFile(panel_path, "r") as zf:
+                        png_files = [
+                            n
+                            for n in zf.namelist()
+                            if n.endswith(".png")
+                            and "exports/" in n
+                            and not any(p in n.lower() for p in exclude_patterns)
+                        ]
+                        if png_files:
+                            preview_path = png_files[0]
+                            if ".plot/" in preview_path:
+                                preview_path = preview_path.split(".plot/")[-1]
+                            img_data = plot_bundle.read_bytes(preview_path)
+                            img = Image.open(io.BytesIO(img_data))
+                            ax = fig.add_axes([x_frac, y_frac, w_frac, h_frac])
+                            ax.imshow(np.array(img))
+                            ax.axis("off")
+            else:
+                plot_dir = Path(panel_path)
+                exports_dir = plot_dir / "exports"
+                if exports_dir.exists():
+                    for png_file in exports_dir.glob("*.png"):
+                        if not any(
+                            p in png_file.name.lower() for p in exclude_patterns
+                        ):
+                            img = Image.open(png_file)
+                            ax = fig.add_axes([x_frac, y_frac, w_frac, h_frac])
+                            ax.imshow(np.array(img))
+                            ax.axis("off")
+                            break
+        except Exception as e:
+            print(f"Could not load panel {panel_id}: {e}")
+
+        # Draw panel letter
+        if panel_id and len(panel_id) <= 2:
+            letter_x = x_frac + 0.01
+            letter_y = y_frac + h_frac - 0.02
+            fig.text(
+                letter_x,
+                letter_y,
+                panel_id,
+                fontsize=14,
+                fontweight="bold",
+                color="black",
+                ha="left",
+                va="top",
+                transform=fig.transFigure,
+                bbox=dict(
+                    boxstyle="square,pad=0.1",
+                    facecolor="white",
+                    edgecolor="none",
+                    alpha=0.8,
+                ),
+            )
+
+
+def _find_panel_path(panel_id, panel_paths, panel_is_zip):
+    """Find panel path matching the panel ID."""
+    for idx, pp in enumerate(panel_paths):
+        pp_name = Path(pp).stem.replace(".plot", "")
+        if (
+            pp_name == panel_id
+            or pp_name.startswith(f"panel_{panel_id}_")
+            or pp_name == f"panel_{panel_id}"
+            or f"_{panel_id}_" in pp_name
+        ):
+            panel_name = Path(pp).name
+            is_zip = panel_is_zip[idx] if idx < len(panel_is_zip) else False
+            return pp, panel_name, is_zip
+    return None, None, False
+
+
+# EOF

scitex/canvas/editor/flask_editor/_core/_routes_basic.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-24 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/canvas/editor/flask_editor/_core/_routes_basic.py
+
+"""Basic Flask routes for the editor."""
+
+import base64
+import json
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .._core import WebEditor
+
+__all__ = [
+    "create_index_route",
+    "create_preview_route",
+    "create_hitmap_route",
+    "create_colormap_route",
+    "create_update_route",
+    "create_stats_route",
+    "create_shutdown_route",
+]
+
+
+def create_index_route(app, editor: "WebEditor"):
+    """Create the index route."""
+    from flask import render_template_string
+
+    from ..templates import build_html_template
+
+    @app.route("/")
+    def index():
+        html_template = build_html_template()
+        json_path_str = str(editor.json_path.resolve())
+        figure_path = ""
+        panel_path = ""
+
+        if ".figure/" in json_path_str:
+            parts = json_path_str.split(".figure/")
+            figure_path = parts[0] + ".figure"
+            panel_path = parts[1] if len(parts) > 1 else ""
+        elif ".plot/" in json_path_str:
+            parts = json_path_str.split(".plot/")
+            figure_path = parts[0] + ".plot"
+            panel_path = parts[1] if len(parts) > 1 else ""
+        else:
+            figure_path = json_path_str
+
+        return render_template_string(
+            html_template,
+            filename=figure_path,
+            panel_path=panel_path,
+            overrides=json.dumps(editor.current_overrides),
+        )
+
+    return index
+
+
+def create_preview_route(app, editor: "WebEditor"):
+    """Create the preview route."""
+    from flask import jsonify, request
+
+    from .._renderer import render_preview_with_bboxes
+
+    @app.route("/preview")
+    def preview():
+        dark_mode = request.args.get("dark_mode", "false").lower() == "true"
+        img_data, bboxes, img_size = render_preview_with_bboxes(
+            editor.csv_data,
+            editor.current_overrides,
+            metadata=editor.metadata,
+            dark_mode=dark_mode,
+        )
+        return jsonify(
+            {
+                "image": img_data,
+                "bboxes": bboxes,
+                "img_size": img_size,
+                "has_hitmap": editor.hitmap_path is not None
+                and editor.hitmap_path.exists(),
+                "format": "png",
+                "panel_info": editor.panel_info,
+            }
+        )
+
+    return preview
+
+
+def create_hitmap_route(app, editor: "WebEditor"):
+    """Create the hitmap route."""
+    from flask import jsonify
+
+    @app.route("/hitmap")
+    def hitmap():
+        if editor.hitmap_path and editor.hitmap_path.exists():
+            with open(editor.hitmap_path, "rb") as f:
+                img_data = base64.b64encode(f.read()).decode("utf-8")
+            return jsonify(
+                {
+                    "image": img_data,
+                    "color_map": editor.color_map,
+                }
+            )
+        return jsonify({"error": "No hitmap available"}), 404
+
+    return hitmap
+
+
+def create_colormap_route(app, editor: "WebEditor"):
+    """Create the color_map route."""
+    from flask import jsonify
+
+    @app.route("/color_map")
+    def color_map():
+        return jsonify(
+            {
+                "color_map": editor.color_map,
+                "hit_regions": editor.hit_regions,
+            }
+        )
+
+    return color_map
+
+
+def create_update_route(app, editor: "WebEditor"):
+    """Create the update route."""
+    from flask import jsonify, request
+
+    from .._renderer import render_preview_with_bboxes
+
+    @app.route("/update", methods=["POST"])
+    def update():
+        data = request.json
+        editor.current_overrides.update(data.get("overrides", {}))
+        editor._user_modified = True
+        dark_mode = data.get("dark_mode", False)
+
+        img_data, bboxes, img_size = render_preview_with_bboxes(
+            editor.csv_data,
+            editor.current_overrides,
+            metadata=editor.metadata,
+            dark_mode=dark_mode,
+        )
+        return jsonify(
+            {
+                "image": img_data,
+                "bboxes": bboxes,
+                "img_size": img_size,
+                "status": "updated",
+            }
+        )
+
+    return update
+
+
+def create_stats_route(app, editor: "WebEditor"):
+    """Create the stats route."""
+    from flask import jsonify
+
+    @app.route("/stats")
+    def stats():
+        stats_data = editor.metadata.get("stats", [])
+        stats_summary = editor.metadata.get("stats_summary", None)
+        return jsonify(
+            {
+                "stats": stats_data,
+                "stats_summary": stats_summary,
+                "has_stats": len(stats_data) > 0,
+            }
+        )
+
+    return stats
+
+
+def create_shutdown_route(app, editor: "WebEditor"):
+    """Create the shutdown route."""
+    from flask import jsonify, request
+
+    @app.route("/shutdown", methods=["POST"])
+    def shutdown():
+        func = request.environ.get("werkzeug.server.shutdown")
+        if func is None:
+            raise RuntimeError("Not running with Werkzeug Server")
+        func()
+        return jsonify({"status": "shutdown"})
+
+    return shutdown
+
+
+# EOF