scitex 2.7.3__py3-none-any.whl → 2.10.0__py3-none-any.whl

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.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

scitex/fig/editor/flask_editor/_bbox.py

@@ -290,6 +290,29 @@ def extract_bboxes_multi(
         legend = ax.get_legend()
         if legend:
             get_element_bbox(legend, "legend", ax_id, ax)
+            # Add element_type for drag detection
+            if f"{ax_id}_legend" in bboxes:
+                bboxes[f"{ax_id}_legend"]["element_type"] = "legend"
+                bboxes[f"{ax_id}_legend"]["draggable"] = True
+
+        # Get panel letter (text annotations like A, B, C)
+        import re
+        panel_letter_pattern = re.compile(r'^[A-Z]\.?$|^\([A-Za-z]\)$')
+        for idx, text_artist in enumerate(ax.texts):
+            text_content = text_artist.get_text().strip()
+            if text_content and panel_letter_pattern.match(text_content):
+                name = f"panel_letter_{text_content.replace('.', '').replace('(', '').replace(')', '')}"
+                get_element_bbox(text_artist, name, ax_id, ax)
+                full_name = f"{ax_id}_{name}"
+                if full_name in bboxes:
+                    bboxes[full_name]["element_type"] = "panel_letter"
+                    bboxes[full_name]["draggable"] = True
+                    bboxes[full_name]["text"] = text_content
+                    # Get position in axes coordinates (0-1)
+                    pos = text_artist.get_position()
+                    transform = text_artist.get_transform()
+                    if transform == ax.transAxes:
+                        bboxes[full_name]["axes_position"] = {"x": pos[0], "y": pos[1]}
 
         # Get trace (line) bboxes
         _extract_trace_bboxes_for_axis(