scitex 2.7.0__py3-none-any.whl → 2.8.1__py3-none-any.whl

scitex/fig/editor/edit/editor_launcher.py

@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-12-14 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/fig/editor/edit/editor_launcher.py
+
+"""Main edit function for launching visual editor."""
+
+from pathlib import Path
+from typing import Union, Literal
+
+from .backend_detector import print_available_backends, detect_best_backend
+from .path_resolver import resolve_figure_paths
+from .bundle_resolver import resolve_pltz_bundle, resolve_figz_bundle
+
+__all__ = ["edit"]
+
+
+def edit(
+    path: Union[str, Path],
+    backend: Literal["auto", "flask", "dearpygui", "qt", "tkinter", "mpl"] = "auto",
+    apply_manual: bool = True,
+    port: int = 5050,
+) -> None:
+    """
+    Launch interactive editor for figure style/annotation editing.
+
+    Parameters
+    ----------
+    path : str or Path
+        Path to figure file. Can be:
+        - .pltz.d directory bundle (recommended for hitmap selection)
+        - .pltz ZIP bundle
+        - .figz or .figz.d multi-panel bundle
+        - JSON file (figure.json or figure.manual.json)
+        - CSV file (figure.csv) - for data-only start
+        - PNG file (figure.png)
+    backend : str, optional
+        GUI backend to use (default: "auto"):
+        - "auto": Pick best available (flask -> dearpygui -> qt -> tkinter -> mpl)
+        - "flask": Browser-based editor (Flask, modern UI)
+        - "dearpygui": GPU-accelerated modern GUI
+        - "qt": Rich desktop editor (requires PyQt5/6 or PySide2/6)
+        - "tkinter": Built-in Python GUI
+        - "mpl": Minimal matplotlib interactive mode
+    apply_manual : bool, optional
+        If True, load .manual.json overrides if exists (default: True)
+    port : int, optional
+        Port number for web-based editors. Default: 5050.
+
+    Returns
+    -------
+    None
+        Editor runs in GUI event loop. Changes saved to .manual.json.
+    """
+    path = Path(path)
+    spath = str(path)
+    parent_str = str(path.parent) if path.is_file() else ""
+
+    # Panel info for multi-panel figures
+    panel_info = None
+
+    # Resolve paths based on input type
+    json_path, csv_path, png_path, hitmap_path, bundle_spec, panel_info = _resolve_paths(
+        path, spath, parent_str
+    )
+
+    if not json_path.exists():
+        raise FileNotFoundError(f"JSON file not found: {json_path}")
+
+    # Load data
+    import scitex as stx
+
+    metadata = bundle_spec if bundle_spec else stx.io.load(json_path)
+    csv_data = None
+    if csv_path and csv_path.exists():
+        csv_data = stx.io.load(csv_path)
+
+    # Load manual overrides if exists
+    manual_path = json_path.with_suffix(".manual.json")
+    manual_overrides = None
+    if apply_manual and manual_path.exists():
+        manual_data = stx.io.load(manual_path)
+        manual_overrides = manual_data.get("overrides", {})
+
+    # Resolve backend if "auto"
+    if backend == "auto":
+        backend = detect_best_backend()
+
+    # Print status
+    print_available_backends()
+    print(f"Launching {backend} editor for: {json_path}")
+
+    # Launch appropriate backend
+    _launch_backend(
+        backend=backend,
+        json_path=json_path,
+        metadata=metadata,
+        csv_data=csv_data,
+        png_path=png_path,
+        hitmap_path=hitmap_path,
+        manual_overrides=manual_overrides,
+        bundle_spec=bundle_spec,
+        panel_info=panel_info,
+        port=port,
+    )
+
+
+def _resolve_paths(path: Path, spath: str, parent_str: str) -> tuple:
+    """Resolve paths based on input type."""
+    panel_info = None
+    hitmap_path = None
+    bundle_spec = None
+
+    # Check if this is a .figz bundle (multi-panel figure)
+    if spath.endswith('.figz.d') or spath.endswith('.figz'):
+        json_path, csv_path, png_path, hitmap_path, bundle_spec, panel_info = resolve_figz_bundle(path)
+    # Check if this is a .pltz bundle
+    elif spath.endswith('.pltz.d') or spath.endswith('.pltz') or parent_str.endswith('.pltz.d'):
+        bundle_path = path.parent if parent_str.endswith('.pltz.d') else path
+        json_path, csv_path, png_path, hitmap_path, bundle_spec = resolve_pltz_bundle(bundle_path)
+    # Check if file is inside a .figz.d
+    elif parent_str.endswith('.figz.d') or (path.parent.parent and str(path.parent.parent).endswith('.figz.d')):
+        figz_path = path.parent if parent_str.endswith('.figz.d') else path.parent.parent
+        json_path, csv_path, png_path, hitmap_path, bundle_spec, panel_info = resolve_figz_bundle(figz_path)
+    else:
+        # Standard file paths
+        json_path, csv_path, png_path = resolve_figure_paths(path)
+
+    return json_path, csv_path, png_path, hitmap_path, bundle_spec, panel_info
+
+
+def _launch_backend(
+    backend: str,
+    json_path: Path,
+    metadata: dict,
+    csv_data,
+    png_path,
+    hitmap_path,
+    manual_overrides,
+    bundle_spec,
+    panel_info,
+    port: int,
+) -> None:
+    """Launch the specified editor backend."""
+    if backend == "flask":
+        _launch_flask(json_path, metadata, csv_data, png_path, hitmap_path, manual_overrides, port, panel_info)
+    elif backend == "dearpygui":
+        _launch_dearpygui(json_path, metadata, csv_data, png_path, manual_overrides)
+    elif backend == "qt":
+        _launch_qt(json_path, metadata, csv_data, png_path, manual_overrides, hitmap_path, bundle_spec)
+    elif backend == "tkinter":
+        _launch_tkinter(json_path, metadata, csv_data, manual_overrides)
+    elif backend == "mpl":
+        _launch_mpl(json_path, metadata, csv_data, manual_overrides)
+    else:
+        raise ValueError(
+            f"Unknown backend: {backend}. "
+            "Use 'auto', 'flask', 'dearpygui', 'qt', 'tkinter', or 'mpl'."
+        )
+
+
+def _launch_flask(json_path, metadata, csv_data, png_path, hitmap_path, manual_overrides, port, panel_info):
+    """Launch Flask web editor."""
+    try:
+        from .._flask_editor import WebEditor
+        editor = WebEditor(
+            json_path=json_path,
+            metadata=metadata,
+            csv_data=csv_data,
+            png_path=png_path,
+            hitmap_path=hitmap_path,
+            manual_overrides=manual_overrides,
+            port=port,
+            panel_info=panel_info,
+        )
+        editor.run()
+    except ImportError as e:
+        raise ImportError("Flask backend requires Flask. Install with: pip install flask") from e
+
+
+def _launch_dearpygui(json_path, metadata, csv_data, png_path, manual_overrides):
+    """Launch DearPyGui editor."""
+    try:
+        from .._dearpygui_editor import DearPyGuiEditor
+        editor = DearPyGuiEditor(
+            json_path=json_path,
+            metadata=metadata,
+            csv_data=csv_data,
+            png_path=png_path,
+            manual_overrides=manual_overrides,
+        )
+        editor.run()
+    except ImportError as e:
+        raise ImportError("DearPyGui backend requires dearpygui. Install with: pip install dearpygui") from e
+
+
+def _launch_qt(json_path, metadata, csv_data, png_path, manual_overrides, hitmap_path, bundle_spec):
+    """Launch Qt editor."""
+    try:
+        from .._qt_editor import QtEditor
+        editor = QtEditor(
+            json_path=json_path,
+            metadata=metadata,
+            csv_data=csv_data,
+            png_path=png_path,
+            manual_overrides=manual_overrides,
+            hitmap_path=hitmap_path,
+            bundle_spec=bundle_spec,
+        )
+        editor.run()
+    except ImportError as e:
+        raise ImportError("Qt backend requires PyQt5/PyQt6 or PySide2/PySide6. Install with: pip install PyQt6") from e
+
+
+def _launch_tkinter(json_path, metadata, csv_data, manual_overrides):
+    """Launch Tkinter editor."""
+    from .._tkinter_editor import TkinterEditor
+    editor = TkinterEditor(
+        json_path=json_path,
+        metadata=metadata,
+        csv_data=csv_data,
+        manual_overrides=manual_overrides,
+    )
+    editor.run()
+
+
+def _launch_mpl(json_path, metadata, csv_data, manual_overrides):
+    """Launch matplotlib editor."""
+    from .._mpl_editor import MplEditor
+    editor = MplEditor(
+        json_path=json_path,
+        metadata=metadata,
+        csv_data=csv_data,
+        manual_overrides=manual_overrides,
+    )
+    editor.run()
+
+
+# EOF

scitex/fig/editor/edit/manual_handler.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-12-14 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/fig/editor/edit/manual_handler.py
+
+"""Manual override handling for figure editor."""
+
+import hashlib
+from pathlib import Path
+
+__all__ = ["compute_file_hash", "save_manual_overrides"]
+
+
+def compute_file_hash(path: Path) -> str:
+    """Compute SHA256 hash of file contents."""
+    with open(path, "rb") as f:
+        return hashlib.sha256(f.read()).hexdigest()
+
+
+def save_manual_overrides(json_path: Path, overrides: dict) -> Path:
+    """
+    Save manual overrides to .manual.json file.
+
+    Parameters
+    ----------
+    json_path : Path
+        Path to base JSON file
+    overrides : dict
+        Override settings (styles, annotations, etc.)
+
+    Returns
+    -------
+    Path
+        Path to saved manual.json file
+    """
+    import scitex as stx
+
+    manual_path = json_path.with_suffix(".manual.json")
+
+    # Compute hash of base JSON for staleness detection
+    base_hash = compute_file_hash(json_path)
+
+    manual_data = {
+        "base_file": json_path.name,
+        "base_hash": base_hash,
+        "overrides": overrides,
+    }
+
+    stx.io.save(manual_data, manual_path)
+    return manual_path
+
+
+# EOF

scitex/fig/editor/edit/panel_loader.py

@@ -0,0 +1,232 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-12-14 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/fig/editor/edit/panel_loader.py
+
+"""Panel data loading for figure editor."""
+
+import io
+import json as json_module
+from pathlib import Path
+from typing import Optional, Union, Dict, Any
+
+__all__ = ["load_panel_data"]
+
+
+def load_panel_data(panel_path: Union[Path, str], is_zip: bool = None) -> Optional[Dict[str, Any]]:
+    """
+    Load panel data from either a .pltz.d directory or a .pltz zip file.
+
+    Handles both formats transparently using in-memory reading for zips.
+
+    Parameters
+    ----------
+    panel_path : Path or str
+        Path to .pltz.d directory or .pltz zip file
+    is_zip : bool, optional
+        If True, treat as zip file. If False, treat as directory.
+        If None, auto-detect based on path suffix and existence.
+
+    Returns
+    -------
+    dict or None
+        Dictionary with keys: metadata, csv_data, png_bytes, hitmap_bytes, img_size
+        For directories, also includes: json_path, png_path, hitmap_path
+        Returns None if panel cannot be loaded
+    """
+    from PIL import Image
+
+    panel_path = Path(panel_path)
+
+    # Auto-detect if not specified
+    if is_zip is None:
+        spath = str(panel_path)
+        if spath.endswith('.pltz') and not spath.endswith('.pltz.d'):
+            is_zip = panel_path.is_file()
+        else:
+            is_zip = False
+
+    if is_zip:
+        return _load_from_zip(panel_path)
+    else:
+        return _load_from_directory(panel_path)
+
+
+def _load_from_zip(panel_path: Path) -> Optional[Dict[str, Any]]:
+    """Load panel data from a .pltz zip file."""
+    from PIL import Image
+    from scitex.io._zip_bundle import ZipBundle
+
+    if not panel_path.exists():
+        return None
+
+    try:
+        with ZipBundle(panel_path, mode="r") as zb:
+            # Load spec.json for metadata
+            try:
+                metadata = zb.read_json("spec.json")
+            except FileNotFoundError:
+                metadata = {}
+
+            # Load style.json if exists
+            try:
+                style = zb.read_json("style.json")
+                metadata["style"] = style
+            except FileNotFoundError:
+                pass
+
+            # Find and read PNG
+            png_bytes = None
+            for name in zb.namelist():
+                if name.endswith('.png') and '_hitmap' not in name and '_overview' not in name:
+                    if 'exports/' in name:
+                        png_bytes = zb.read_bytes(name)
+                        break
+
+            # If no PNG in exports/, try root level
+            if not png_bytes:
+                for name in zb.namelist():
+                    if name.endswith('.png') and '_hitmap' not in name and '_overview' not in name:
+                        png_bytes = zb.read_bytes(name)
+                        break
+
+            # Get image size
+            img_size = None
+            if png_bytes:
+                img = Image.open(io.BytesIO(png_bytes))
+                img_size = {"width": img.size[0], "height": img.size[1]}
+                img.close()
+
+            # Find and read hitmap
+            hitmap_bytes = None
+            for name in zb.namelist():
+                if '_hitmap.png' in name:
+                    hitmap_bytes = zb.read_bytes(name)
+                    break
+
+            # Load geometry_px.json if available
+            geometry_data = None
+            try:
+                geometry_data = zb.read_json("cache/geometry_px.json")
+            except FileNotFoundError:
+                pass
+
+            return {
+                "metadata": metadata,
+                "png_bytes": png_bytes,
+                "hitmap_bytes": hitmap_bytes,
+                "img_size": img_size,
+                "geometry_data": geometry_data,
+                "is_zip": True,
+            }
+    except Exception as e:
+        print(f"Error loading panel zip {panel_path}: {e}")
+        return None
+
+
+def _load_from_directory(panel_path: Path) -> Optional[Dict[str, Any]]:
+    """Load panel data from a .pltz.d directory."""
+    import scitex as stx
+
+    panel_dir = panel_path
+    if not panel_dir.exists():
+        return None
+
+    # Check for layered vs legacy format
+    spec_path = panel_dir / "spec.json"
+    if spec_path.exists():
+        return _load_layered_directory(panel_dir)
+    else:
+        return _load_legacy_directory(panel_dir)
+
+
+def _load_layered_directory(panel_dir: Path) -> Dict[str, Any]:
+    """Load panel data from layered format directory."""
+    import scitex as stx
+    from scitex.plt.io import load_layered_pltz_bundle
+
+    bundle_data = load_layered_pltz_bundle(panel_dir)
+    metadata = bundle_data.get("merged", {})
+
+    # Find CSV
+    csv_data = None
+    for f in panel_dir.glob("*.csv"):
+        csv_data = stx.io.load(f)
+        break
+
+    # Find exports - prefer PNG over SVG (PIL can't open SVG)
+    png_path = None
+    svg_path = None
+    hitmap_path = None
+    exports_dir = panel_dir / "exports"
+    if exports_dir.exists():
+        for f in exports_dir.iterdir():
+            name = f.name
+            if name.endswith('_hitmap.png'):
+                hitmap_path = f
+            elif name.endswith('.png') and '_hitmap' not in name and '_overview' not in name:
+                png_path = f
+            elif name.endswith('.svg') and '_hitmap' not in name and svg_path is None:
+                svg_path = f
+
+    if png_path is None:
+        png_path = svg_path
+
+    # Load geometry_px.json if available
+    geometry_data = None
+    geometry_path = panel_dir / "cache" / "geometry_px.json"
+    if geometry_path.exists():
+        with open(geometry_path) as f:
+            geometry_data = json_module.load(f)
+
+    return {
+        "json_path": panel_dir / "spec.json",
+        "metadata": metadata,
+        "csv_data": csv_data,
+        "png_path": png_path,
+        "hitmap_path": hitmap_path,
+        "geometry_data": geometry_data,
+        "is_zip": False,
+    }
+
+
+def _load_legacy_directory(panel_dir: Path) -> Optional[Dict[str, Any]]:
+    """Load panel data from legacy format directory."""
+    import scitex as stx
+
+    json_path = None
+    csv_data = None
+    png_path = None
+    hitmap_path = None
+
+    for f in panel_dir.iterdir():
+        name = f.name
+        if name.endswith('.json') and not name.endswith('.manual.json'):
+            json_path = f
+        elif name.endswith('.csv'):
+            csv_data = stx.io.load(f)
+        elif name.endswith('_hitmap.png'):
+            hitmap_path = f
+        elif name.endswith('.svg') and '_hitmap' not in name:
+            png_path = f
+        elif name.endswith('.png') and '_hitmap' not in name and '_overview' not in name:
+            if png_path is None:
+                png_path = f
+
+    if json_path is None:
+        return None
+
+    with open(json_path, 'r') as f:
+        metadata = json_module.load(f)
+
+    return {
+        "json_path": json_path,
+        "metadata": metadata,
+        "csv_data": csv_data,
+        "png_path": png_path,
+        "hitmap_path": hitmap_path,
+        "is_zip": False,
+    }
+
+
+# EOF

scitex/fig/editor/edit/path_resolver.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-12-14 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/fig/editor/edit/path_resolver.py
+
+"""Basic path resolution for figure files."""
+
+from pathlib import Path
+from typing import Optional, Tuple
+
+__all__ = ["resolve_figure_paths"]
+
+
+def resolve_figure_paths(path: Path) -> Tuple[Path, Optional[Path], Optional[Path]]:
+    """
+    Resolve JSON, CSV, and PNG paths from any input file path.
+
+    Handles two patterns:
+    1. Flat (sibling): path/to/figure.{json,csv,png}
+    2. Organized (subdirs): path/to/{json,csv,png}/figure.{ext}
+
+    Parameters
+    ----------
+    path : Path
+        Input path (can be JSON, CSV, or PNG)
+
+    Returns
+    -------
+    tuple
+        (json_path, csv_path, png_path) - csv_path/png_path may be None if not found
+    """
+    path = Path(path)
+    stem = path.stem
+    parent = path.parent
+
+    # Check if this is organized pattern (parent is json/, csv/, png/)
+    if parent.name in ("json", "csv", "png"):
+        base_dir = parent.parent
+        json_path = base_dir / "json" / f"{stem}.json"
+        csv_path = base_dir / "csv" / f"{stem}.csv"
+        png_path = base_dir / "png" / f"{stem}.png"
+    else:
+        # Flat pattern - sibling files
+        json_path = parent / f"{stem}.json"
+        csv_path = parent / f"{stem}.csv"
+        png_path = parent / f"{stem}.png"
+
+    # If input was .manual.json, get base json
+    if stem.endswith(".manual"):
+        base_stem = stem[:-7]  # Remove '.manual'
+        if parent.name == "json":
+            json_path = parent / f"{base_stem}.json"
+            csv_path = parent.parent / "csv" / f"{base_stem}.csv"
+            png_path = parent.parent / "png" / f"{base_stem}.png"
+        else:
+            json_path = parent / f"{base_stem}.json"
+            csv_path = parent / f"{base_stem}.csv"
+            png_path = parent / f"{base_stem}.png"
+
+    return (
+        json_path,
+        csv_path if csv_path.exists() else None,
+        png_path if png_path.exists() else None,
+    )
+
+
+# EOF