scitex 2.10.2__py3-none-any.whl → 2.11.0__py3-none-any.whl

scitex/{fig → canvas}/editor/edit/bundle_resolver.py

@@ -3,27 +3,31 @@
 # Timestamp: "2025-12-14 (ywatanabe)"
 # File: /home/ywatanabe/proj/scitex-code/src/scitex/fig/editor/edit/bundle_resolver.py
 
-"""Bundle path resolution for .pltz and .figz formats."""
+"""Bundle path resolution for .plot and .figure formats."""
 
 import json as json_module
 import tempfile
 import zipfile
 from pathlib import Path
-from typing import Optional, Tuple, Dict, Any
+from typing import Any, Dict, Optional, Tuple
 
-__all__ = ["resolve_pltz_bundle", "resolve_figz_bundle", "resolve_layered_pltz_bundle"]
+__all__ = [
+    "resolve_plot_bundle",
+    "resolve_figure_bundle",
+    "resolve_layered_plot_bundle",
+]
 
 
-def resolve_figz_bundle(path: Path, panel_index: int = 0) -> Tuple:
+def resolve_figure_bundle(path: Path, panel_index: int = 0) -> Tuple:
     """
-    Resolve paths from a .figz bundle (multi-panel figure).
+    Resolve paths from a .figure bundle (multi-panel figure).
 
-    Uses in-memory zip reading for .pltz panels - no disk extraction.
+    Uses in-memory zip reading for .plot panels - no disk extraction.
 
     Parameters
     ----------
     path : Path
-        Path to .figz bundle (.figz or .figz.d)
+        Path to .figure bundle (.figure or .figure)
     panel_index : int, optional
         Index of panel to open (default: 0 for first panel)
 
@@ -33,41 +37,41 @@ def resolve_figz_bundle(path: Path, panel_index: int = 0) -> Tuple:
         (json_path, csv_path, png_path, hitmap_path, bundle_spec, panel_info)
     """
     spath = str(path)
-    figz_is_zip = False
+    figure_is_zip = False
 
     # Handle ZIP vs directory for figz
-    if spath.endswith('.figz') and not spath.endswith('.figz.d'):
-        figz_is_zip = True
+    if spath.endswith(".figure") and not spath.endswith(".figure"):
+        figure_is_zip = True
         if not path.exists():
-            raise FileNotFoundError(f"Figz bundle not found: {path}")
-        # For figz zip, extract to access nested pltz
-        temp_dir = tempfile.mkdtemp(prefix='scitex_edit_figz_')
-        with zipfile.ZipFile(path, 'r') as zf:
+            raise FileNotFoundError(f"Figure bundle not found: {path}")
+        # For figure zip, extract to access nested pltz
+        temp_dir = tempfile.mkdtemp(prefix="scitex_edit_figure_")
+        with zipfile.ZipFile(path, "r") as zf:
             zf.extractall(temp_dir)
         bundle_dir = Path(temp_dir)
         for item in bundle_dir.iterdir():
-            if item.is_dir() and str(item).endswith('.figz.d'):
+            if item.is_dir() and str(item).endswith(".figure"):
                 bundle_dir = item
                 break
     else:
         bundle_dir = Path(path)
         if not bundle_dir.exists():
-            raise FileNotFoundError(f"Figz bundle directory not found: {bundle_dir}")
+            raise FileNotFoundError(f"Figure bundle directory not found: {bundle_dir}")
 
-    # Find nested pltz bundles
+    # Find nested plot bundles
     panel_paths = []
     panel_is_zip = []
 
     for item in sorted(bundle_dir.iterdir(), key=lambda x: x.name):
-        if item.is_dir() and str(item).endswith('.pltz.d'):
+        if item.is_dir() and str(item).endswith(".plot"):
             panel_paths.append(str(item))
             panel_is_zip.append(False)
-        elif item.is_file() and str(item).endswith('.pltz'):
+        elif item.is_file() and str(item).endswith(".plot"):
             panel_paths.append(str(item))
             panel_is_zip.append(True)
 
     if not panel_paths:
-        raise FileNotFoundError(f"No .pltz panels found in figz bundle: {bundle_dir}")
+        raise FileNotFoundError(f"No .plot panels found in figure bundle: {bundle_dir}")
 
     # Validate panel index
     if panel_index < 0 or panel_index >= len(panel_paths):
@@ -77,7 +81,7 @@ def resolve_figz_bundle(path: Path, panel_index: int = 0) -> Tuple:
     panel_name = Path(selected_panel_path).name
     print(f"Opening panel: {panel_name}")
     if len(panel_paths) > 1:
-        print(f"  (Figz contains {len(panel_paths)} panels)")
+        print(f"  (Figure contains {len(panel_paths)} panels)")
 
     # Build panel info
     panel_names = [Path(p).name for p in panel_paths]
@@ -86,19 +90,21 @@ def resolve_figz_bundle(path: Path, panel_index: int = 0) -> Tuple:
         "panel_paths": panel_paths,
         "panel_is_zip": panel_is_zip,
         "current_index": panel_index,
-        "figz_dir": str(bundle_dir),
-        "figz_is_zip": figz_is_zip,
-        "bundle_path": str(path) if figz_is_zip else None,  # Original figz zip path for export/download
+        "figure_dir": str(bundle_dir),
+        "figure_is_zip": figure_is_zip,
+        "bundle_path": (
+            str(path) if figure_is_zip else None
+        ),  # Original figure zip path for export/download
     }
 
     # Resolve the selected panel
-    result = resolve_pltz_bundle(Path(selected_panel_path))
+    result = resolve_plot_bundle(Path(selected_panel_path))
     return result + (panel_info,)
 
 
-def resolve_pltz_bundle(path: Path) -> Tuple:
+def resolve_plot_bundle(path: Path) -> Tuple:
     """
-    Resolve paths from a .pltz bundle (directory or ZIP).
+    Resolve paths from a .plot bundle (directory or ZIP).
 
     Supports both:
     - Legacy format (single {basename}.json)
@@ -107,7 +113,7 @@ def resolve_pltz_bundle(path: Path) -> Tuple:
     Parameters
     ----------
     path : Path
-        Path to .pltz bundle (.pltz or .pltz.d)
+        Path to .plot bundle (.plot or .plot)
 
     Returns
     -------
@@ -117,15 +123,15 @@ def resolve_pltz_bundle(path: Path) -> Tuple:
     spath = str(path)
 
     # Handle ZIP vs directory
-    if spath.endswith('.pltz') and not spath.endswith('.pltz.d'):
+    if spath.endswith(".plot") and not spath.endswith(".plot"):
         if not path.exists():
             raise FileNotFoundError(f"Bundle not found: {path}")
-        temp_dir = tempfile.mkdtemp(prefix='scitex_edit_')
-        with zipfile.ZipFile(path, 'r') as zf:
+        temp_dir = tempfile.mkdtemp(prefix="scitex_edit_")
+        with zipfile.ZipFile(path, "r") as zf:
             zf.extractall(temp_dir)
         bundle_dir = Path(temp_dir)
         for item in bundle_dir.iterdir():
-            if item.is_dir() and str(item).endswith('.pltz.d'):
+            if item.is_dir() and str(item).endswith(".plot"):
                 bundle_dir = item
                 break
     else:
@@ -136,7 +142,7 @@ def resolve_pltz_bundle(path: Path) -> Tuple:
     # Check if this is a layered bundle (v2.0)
     spec_path = bundle_dir / "spec.json"
     if spec_path.exists():
-        return resolve_layered_pltz_bundle(bundle_dir)
+        return resolve_layered_plot_bundle(bundle_dir)
 
     # === Legacy format ===
     json_path = None
@@ -148,15 +154,17 @@ def resolve_pltz_bundle(path: Path) -> Tuple:
 
     for f in bundle_dir.iterdir():
         name = f.name
-        if name.endswith('.json') and not name.endswith('.manual.json'):
+        if name.endswith(".json") and not name.endswith(".manual.json"):
             json_path = f
-        elif name.endswith('.csv'):
+        elif name.endswith(".csv"):
             csv_path = f
-        elif name.endswith('_hitmap.png'):
+        elif name.endswith("_hitmap.png"):
             hitmap_path = f
-        elif name.endswith('.svg') and '_hitmap' not in name:
+        elif name.endswith(".svg") and "_hitmap" not in name:
             svg_path = f
-        elif name.endswith('.png') and '_hitmap' not in name and '_overview' not in name:
+        elif (
+            name.endswith(".png") and "_hitmap" not in name and "_overview" not in name
+        ):
             png_path = f
 
     # Prefer SVG for display
@@ -164,7 +172,7 @@ def resolve_pltz_bundle(path: Path) -> Tuple:
         png_path = svg_path
 
     if json_path and json_path.exists():
-        with open(json_path, 'r') as f:
+        with open(json_path, "r") as f:
             bundle_spec = json_module.load(f)
 
     return (
@@ -176,12 +184,12 @@ def resolve_pltz_bundle(path: Path) -> Tuple:
     )
 
 
-def resolve_layered_pltz_bundle(bundle_dir: Path) -> Tuple:
+def resolve_layered_plot_bundle(bundle_dir: Path) -> Tuple:
     """
-    Resolve paths from a layered .pltz bundle (v2.0 format).
+    Resolve paths from a layered .plot bundle (v2.0 format).
 
     Layered format structure:
-        plot.pltz.d/
+        plot.plot/
             spec.json           # Semantic
             style.json          # Appearance
             {basename}.csv      # Data
@@ -191,16 +199,16 @@ def resolve_layered_pltz_bundle(bundle_dir: Path) -> Tuple:
     Parameters
     ----------
     bundle_dir : Path
-        Path to .pltz.d bundle directory.
+        Path to .plot bundle directory.
 
     Returns
     -------
     tuple
         (json_path, csv_path, png_path, hitmap_path, bundle_spec)
     """
-    from scitex.plt.io import load_layered_pltz_bundle
+    from scitex.plt.io import load_layered_plot_bundle
 
-    bundle_data = load_layered_pltz_bundle(bundle_dir)
+    bundle_data = load_layered_plot_bundle(bundle_dir)
     spec_path = bundle_dir / "spec.json"
     csv_path = None
     png_path = None
@@ -216,11 +224,11 @@ def resolve_layered_pltz_bundle(bundle_dir: Path) -> Tuple:
     if exports_dir.exists():
         for f in exports_dir.iterdir():
             name = f.name
-            if name.endswith('_hitmap.png'):
+            if name.endswith("_hitmap.png"):
                 hitmap_path = f
-            elif name.endswith('.svg') and '_hitmap' not in name:
+            elif name.endswith(".svg") and "_hitmap" not in name:
                 png_path = f
-            elif name.endswith('.png') and '_hitmap' not in name and png_path is None:
+            elif name.endswith(".png") and "_hitmap" not in name and png_path is None:
                 png_path = f
 
     bundle_spec = bundle_data.get("merged", {})

scitex/{fig → canvas}/editor/edit/editor_launcher.py

@@ -6,11 +6,11 @@
 """Main edit function for launching visual editor."""
 
 from pathlib import Path
-from typing import Union, Literal
+from typing import Literal, Union
 
-from .backend_detector import print_available_backends, detect_best_backend
+from .backend_detector import detect_best_backend, print_available_backends
+from .bundle_resolver import resolve_figure_bundle, resolve_plot_bundle
 from .path_resolver import resolve_figure_paths
-from .bundle_resolver import resolve_pltz_bundle, resolve_figz_bundle
 
 __all__ = ["edit"]
 
@@ -28,9 +28,9 @@ def edit(
     ----------
     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
+        - .plot directory bundle (recommended for hitmap selection)
+        - .plot ZIP bundle
+        - .figure multi-panel bundle
         - JSON file (figure.json or figure.manual.json)
         - CSV file (figure.csv) - for data-only start
         - PNG file (figure.png)
@@ -60,8 +60,8 @@ def edit(
     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
+    json_path, csv_path, png_path, hitmap_path, bundle_spec, panel_info = (
+        _resolve_paths(path, spath, parent_str)
     )
 
     if not json_path.exists():
@@ -111,17 +111,31 @@ def _resolve_paths(path: Path, spath: str, parent_str: str) -> tuple:
     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)
+    # Check if this is a .figure bundle (multi-panel figure)
+    if spath.endswith(".figure") or spath.endswith(".figure"):
+        json_path, csv_path, png_path, hitmap_path, bundle_spec, panel_info = (
+            resolve_figure_bundle(path)
+        )
+    # Check if this is a .plot bundle
+    elif (
+        spath.endswith(".plot")
+        or spath.endswith(".plot")
+        or parent_str.endswith(".plot")
+    ):
+        bundle_path = path.parent if parent_str.endswith(".plot") else path
+        json_path, csv_path, png_path, hitmap_path, bundle_spec = resolve_plot_bundle(
+            bundle_path
+        )
+    # Check if file is inside a .figure
+    elif parent_str.endswith(".figure") or (
+        path.parent.parent and str(path.parent.parent).endswith(".figure")
+    ):
+        figure_path = (
+            path.parent if parent_str.endswith(".figure") else path.parent.parent
+        )
+        json_path, csv_path, png_path, hitmap_path, bundle_spec, panel_info = (
+            resolve_figure_bundle(figure_path)
+        )
     else:
         # Standard file paths
         json_path, csv_path, png_path = resolve_figure_paths(path)
@@ -143,11 +157,28 @@ def _launch_backend(
 ) -> 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)
+        _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)
+        _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":
@@ -159,10 +190,20 @@ def _launch_backend(
         )
 
 
-def _launch_flask(json_path, metadata, csv_data, png_path, hitmap_path, manual_overrides, port, panel_info):
+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,
@@ -175,13 +216,16 @@ def _launch_flask(json_path, metadata, csv_data, png_path, hitmap_path, manual_o
         )
         editor.run()
     except ImportError as e:
-        raise ImportError("Flask backend requires Flask. Install with: pip install flask") from 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,
@@ -191,13 +235,18 @@ def _launch_dearpygui(json_path, metadata, csv_data, png_path, manual_overrides)
         )
         editor.run()
     except ImportError as e:
-        raise ImportError("DearPyGui backend requires dearpygui. Install with: pip install dearpygui") from 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):
+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,
@@ -209,12 +258,15 @@ def _launch_qt(json_path, metadata, csv_data, png_path, manual_overrides, hitmap
         )
         editor.run()
     except ImportError as e:
-        raise ImportError("Qt backend requires PyQt5/PyQt6 or PySide2/PySide6. Install with: pip install PyQt6") from 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,
@@ -227,6 +279,7 @@ def _launch_tkinter(json_path, metadata, csv_data, manual_overrides):
 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,

scitex/{fts/_fig/_editor/_cui/_panel_loader.py → canvas/editor/edit/panel_loader.py}

@@ -16,14 +16,14 @@ 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.
+    Load panel data from either a .plot directory or a .plot.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
+        Path to .plot directory or .plot.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.
@@ -41,7 +41,7 @@ def load_panel_data(
     # Auto-detect if not specified
     if is_zip is None:
         spath = str(panel_path)
-        if spath.endswith(".pltz") and not spath.endswith(".pltz.d"):
+        if spath.endswith(".plot.zip"):
             is_zip = panel_path.is_file()
         else:
             is_zip = False
@@ -53,10 +53,10 @@ def load_panel_data(
 
 
 def _load_from_zip(panel_path: Path) -> Optional[Dict[str, Any]]:
-    """Load panel data from a .pltz zip file."""
+    """Load panel data from a .plot.zip file."""
     from PIL import Image
 
-    from scitex.fts import FTS as ZipBundle
+    from scitex.io.bundle import ZipBundle
 
     if not panel_path.exists():
         return None
@@ -134,7 +134,7 @@ def _load_from_zip(panel_path: Path) -> Optional[Dict[str, Any]]:
 
 
 def _load_from_directory(panel_path: Path) -> Optional[Dict[str, Any]]:
-    """Load panel data from a .pltz.d directory."""
+    """Load panel data from a .plot directory."""
 
     panel_dir = panel_path
     if not panel_dir.exists():
@@ -151,9 +151,9 @@ def _load_from_directory(panel_path: Path) -> Optional[Dict[str, Any]]:
 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
+    from scitex.plt.io import load_layered_plot_bundle
 
-    bundle_data = load_layered_pltz_bundle(panel_dir)
+    bundle_data = load_layered_plot_bundle(panel_dir)
     metadata = bundle_data.get("merged", {})
 
     # Find CSV

scitex/{fts/_fig/_editor/_gui/_flask_editor → canvas/editor/flask_editor}/_bbox.py

@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+# -*- coding: utf-8 -*-
 # File: ./src/scitex/vis/editor/flask_editor/bbox.py
 """Bounding box extraction for figure elements.
 
@@ -1002,7 +1003,7 @@ def extract_bboxes_from_metadata(
                 "ax_id": ax_id,
             }
 
-    # Extract from traces array (pltz spec format)
+    # Extract from traces array (plot spec format)
     traces = metadata.get("traces", [])
     if isinstance(traces, list):
         for i, trace in enumerate(traces):