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

scitex/fts/_fig/_editor/_cui/_panel_loader.py

@@ -0,0 +1,246 @@
+#!/usr/bin/env python3
+# 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 Any, Dict, Optional, Union
+
+__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
+    """
+
+    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.fts import FTS as 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."""
+
+    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) 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/fts/_fig/_editor/_cui/_path_resolver.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+# 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/fts/_fig/_editor/_defaults.py

@@ -0,0 +1,300 @@
+#!/usr/bin/env python3
+# File: ./src/scitex/vis/editor/_defaults.py
+"""Default style settings for SciTeX visual editor."""
+
+from scitex.plt.styles import get_default_dpi
+
+
+def get_scitex_defaults():
+    """
+    Get default style values based on SciTeX publication standards.
+
+    Returns
+    -------
+    dict
+        Dictionary of default style settings
+    """
+    return {
+        # Font sizes (from _configure_mpl.py)
+        "fontsize": 7,  # Base font size for publication
+        "title_fontsize": 8,  # Title size
+        "axis_fontsize": 7,  # Axis label size
+        "tick_fontsize": 7,  # Tick label size
+        "legend_fontsize": 6,  # Legend font size
+        # Line settings (in points, 1mm = 2.83465pt)
+        "linewidth": 0.57,  # Default line width (0.2mm)
+        # Tick settings
+        "n_ticks": 4,  # Number of ticks
+        "tick_length": 0.8,  # Tick length in mm
+        "tick_width": 0.2,  # Tick width in mm
+        "tick_direction": "out",  # Tick direction
+        # Axes settings
+        "axis_width": 0.2,  # Spine/axes line width in mm
+        "hide_top_spine": True,  # Hide top spine
+        "hide_right_spine": True,  # Hide right spine
+        # Grid settings
+        "grid": False,  # Grid off by default
+        "grid_linewidth": 0.6,
+        "grid_alpha": 0.3,
+        # Figure settings
+        "dpi": get_default_dpi(),  # From SCITEX_STYLE.yaml
+        "fig_size": [3.15, 2.68],  # Default figure size in inches
+        # Colors (SciTeX defaults)
+        "facecolor": "#ffffff",  # White background
+        "transparent": True,  # Transparent background
+        # Legend
+        "legend_visible": True,
+        "legend_frameon": False,
+        "legend_loc": "best",
+        # Font family
+        "font_family": "Arial",  # Sans-serif for publication
+        # Annotations
+        "annotations": [],
+    }
+
+
+def get_scitex_colors():
+    """
+    Get SciTeX color palette.
+
+    Returns
+    -------
+    dict
+        Dictionary of named colors with hex values
+    """
+    # Based on scitex.plt.color.PARAMS
+    return {
+        "blue": "#1f77b4",
+        "orange": "#ff7f0e",
+        "green": "#2ca02c",
+        "red": "#d62728",
+        "purple": "#9467bd",
+        "brown": "#8c564b",
+        "pink": "#e377c2",
+        "gray": "#7f7f7f",
+        "olive": "#bcbd22",
+        "cyan": "#17becf",
+        # Additional publication colors
+        "black": "#000000",
+        "white": "#ffffff",
+        "dark_gray": "#404040",
+        "light_gray": "#d0d0d0",
+    }
+
+
+def extract_defaults_from_metadata(metadata):
+    """
+    Extract style defaults from loaded figure metadata.
+
+    Parameters
+    ----------
+    metadata : dict
+        Figure metadata loaded from JSON
+
+    Returns
+    -------
+    dict
+        Dictionary of style values extracted from metadata
+    """
+    defaults = get_scitex_defaults()
+
+    if not metadata:
+        return defaults
+
+    # Extract from scitex section (new format)
+    scitex_meta = metadata.get("scitex", {})
+    style_mm = scitex_meta.get("style_mm", {})
+
+    # Font sizes from style_mm
+    if "axis_font_size_pt" in style_mm:
+        defaults["axis_fontsize"] = style_mm["axis_font_size_pt"]
+    if "tick_font_size_pt" in style_mm:
+        defaults["tick_fontsize"] = style_mm["tick_font_size_pt"]
+    if "title_font_size_pt" in style_mm:
+        defaults["title_fontsize"] = style_mm["title_font_size_pt"]
+    if "legend_font_size_pt" in style_mm:
+        defaults["legend_fontsize"] = style_mm["legend_font_size_pt"]
+
+    # Line/axis thickness from metadata (in mm)
+    if "trace_thickness_mm" in style_mm:
+        defaults["linewidth"] = style_mm["trace_thickness_mm"] * 2.83465  # mm to pt
+    if "axis_thickness_mm" in style_mm:
+        defaults["axis_width"] = style_mm["axis_thickness_mm"]
+    if "tick_length_mm" in style_mm:
+        defaults["tick_length"] = style_mm["tick_length_mm"]
+    if "tick_thickness_mm" in style_mm:
+        defaults["tick_width"] = style_mm["tick_thickness_mm"]
+    if "n_ticks" in style_mm:
+        defaults["n_ticks"] = style_mm["n_ticks"]
+
+    # Dimensions from metadata (support both old and new formats)
+    dimensions = metadata.get("dimensions", {})
+    if "dpi" in dimensions:
+        defaults["dpi"] = dimensions["dpi"]
+    if "figure_size_inch" in dimensions:
+        defaults["fig_size"] = dimensions["figure_size_inch"]
+
+    # New format: size.width_mm, size.height_mm, size.dpi
+    size = metadata.get("size", {})
+    if "dpi" in size:
+        defaults["dpi"] = size["dpi"]
+    if "width_mm" in size and "height_mm" in size:
+        # Convert mm to inches
+        width_inch = size["width_mm"] / 25.4
+        height_inch = size["height_mm"] / 25.4
+        defaults["fig_size"] = [width_inch, height_inch]
+
+    # Axis labels from metadata
+    if "xlabel" in metadata:
+        defaults["xlabel"] = metadata["xlabel"]
+    if "ylabel" in metadata:
+        defaults["ylabel"] = metadata["ylabel"]
+    if "title" in metadata:
+        defaults["title"] = metadata["title"]
+
+    # Try to extract from axes if present
+    axes = metadata.get("axes", {})
+    if isinstance(axes, dict):
+        # New format: {'x': {'label': ...}, 'y': {'label': ...}}
+        x_axis = axes.get("x", {})
+        y_axis = axes.get("y", {})
+        if "label" in x_axis:
+            unit = x_axis.get("unit", "")
+            label = x_axis["label"]
+            if unit:
+                defaults["xlabel"] = f"{label} [{unit}]"
+            else:
+                defaults["xlabel"] = label
+        if "label" in y_axis:
+            unit = y_axis.get("unit", "")
+            label = y_axis["label"]
+            if unit:
+                defaults["ylabel"] = f"{label} [{unit}]"
+            else:
+                defaults["ylabel"] = label
+        # Extract axis limits
+        if "lim" in x_axis:
+            defaults["xlim"] = x_axis["lim"]
+        if "lim" in y_axis:
+            defaults["ylim"] = y_axis["lim"]
+    elif isinstance(axes, list) and len(axes) > 0:
+        # Legacy format: list of axes
+        ax = axes[0]
+        if "xlabel" in ax:
+            defaults["xlabel"] = ax["xlabel"]
+        if "ylabel" in ax:
+            defaults["ylabel"] = ax["ylabel"]
+        if "title" in ax:
+            defaults["title"] = ax["title"]
+        if "grid" in ax:
+            defaults["grid"] = ax["grid"]
+        # Extract axis limits from list format
+        if "xlim" in ax:
+            defaults["xlim"] = ax["xlim"]
+        if "ylim" in ax:
+            defaults["ylim"] = ax["ylim"]
+
+    # Extract traces information - check multiple possible locations
+    traces = metadata.get("traces", [])
+
+    # Also check axes[].lines (pltz bundle format)
+    if not traces and isinstance(axes, list) and len(axes) > 0:
+        ax = axes[0]
+        lines = ax.get("lines", [])
+        if lines:
+            traces = lines
+
+    # Also check hit_regions.color_map for trace info
+    if not traces:
+        hit_regions = metadata.get("hit_regions", {})
+        color_map = hit_regions.get("color_map", {})
+        if color_map:
+            traces = []
+            for trace_id, trace_info in color_map.items():
+                traces.append(
+                    {
+                        "id": trace_id,
+                        "label": trace_info.get("label", f"Trace {trace_id}"),
+                        "type": trace_info.get("type", "line"),
+                    }
+                )
+
+    if traces:
+        defaults["traces"] = traces
+
+    # Extract legend information from multiple possible locations
+    legend = metadata.get("legend", {})
+
+    # Also check selectable_regions.axes[0].legend (pltz bundle format)
+    if not legend:
+        selectable = metadata.get("selectable_regions", {})
+        sel_axes = selectable.get("axes", [])
+        if sel_axes and len(sel_axes) > 0:
+            legend = sel_axes[0].get("legend", {})
+
+    if legend:
+        defaults["legend_visible"] = legend.get("visible", True)
+        defaults["legend_frameon"] = legend.get("frameon", False)
+        # Support both old format (loc) and new format (location)
+        loc = legend.get("location") or legend.get("loc", "best")
+        # Convert numeric legend loc to string (matplotlib accepts both but GUI needs string)
+        defaults["legend_loc"] = _normalize_legend_loc(loc)
+        # Extract fontsize if present
+        if "fontsize" in legend:
+            defaults["legend_fontsize"] = legend["fontsize"]
+        # Extract ncols if present
+        if "ncols" in legend:
+            defaults["legend_ncols"] = legend["ncols"]
+        # Extract title if present
+        if "title" in legend:
+            defaults["legend_title"] = legend["title"]
+
+        # Extract legend entries if present
+        entries = legend.get("entries", [])
+        if entries and not traces:
+            # Use legend entries as trace labels
+            defaults["traces"] = [
+                {"label": e.get("text", f"Trace {i}")} for i, e in enumerate(entries)
+            ]
+
+    return defaults
+
+
+def _normalize_legend_loc(loc):
+    """Convert legend location to string format for GUI compatibility.
+
+    Matplotlib accepts both numeric codes and string locations for legends.
+    This function ensures consistency by converting numeric codes to strings.
+
+    Parameters
+    ----------
+    loc : int or str
+        Legend location (numeric or string)
+
+    Returns
+    -------
+    str
+        String representation of legend location
+    """
+    if isinstance(loc, str):
+        return loc
+
+    # Numeric to string mapping (matplotlib legend location codes)
+    loc_map = {
+        0: "best",
+        1: "upper right",
+        2: "upper left",
+        3: "lower left",
+        4: "lower right",
+        5: "right",
+        6: "center left",
+        7: "center right",
+        8: "lower center",
+        9: "upper center",
+        10: "center",
+    }
+
+    return loc_map.get(loc, "best")
+
+
+# EOF

scitex/fts/_fig/_editor/_gui/__init__.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python3
+# Timestamp: 2025-12-20
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/fsb/_fig/_editor/_gui/__init__.py
+
+"""GUI-based FTS bundle editors (Flask only)."""
+
+from ._flask_editor import WebEditor
+
+__all__ = ["WebEditor"]
+
+# EOF

scitex/fts/_fig/_editor/_gui/_flask_editor/__init__.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+# File: ./src/scitex/vis/editor/flask_editor/__init__.py
+"""Flask-based web editor for SciTeX figures."""
+
+from ._core import WebEditor
+from ._plotter import plot_from_csv
+from ._renderer import render_preview_with_bboxes
+from ._utils import check_port_available, find_available_port, kill_process_on_port
+
+__all__ = [
+    "WebEditor",
+    "find_available_port",
+    "kill_process_on_port",
+    "check_port_available",
+    "render_preview_with_bboxes",
+    "plot_from_csv",
+]
+
+
+# EOF