scitex 2.10.3__py3-none-any.whl → 2.13.0__py3-none-any.whl

scitex/canvas/_mcp_tool_schemas.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-08
+# File: src/scitex/canvas/_mcp_tool_schemas.py
+# ----------------------------------------
+
+"""
+MCP Tool schemas for SciTeX canvas module.
+
+Defines tools for multi-panel figure composition:
+- create_canvas: Create paper figure workspace
+- add_panel: Add subplot to canvas
+- list_panels: List panels in canvas
+- export_canvas: Render final figure
+- list_canvases: List available canvases
+"""
+
+from __future__ import annotations
+
+import mcp.types as types
+
+
+def get_tool_schemas() -> list[types.Tool]:
+    """Return list of available MCP tools for canvas operations."""
+    return [
+        # Create canvas
+        types.Tool(
+            name="create_canvas",
+            description="Create a new paper figure canvas workspace for multi-panel composition",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "parent_dir": {
+                        "type": "string",
+                        "description": "Parent directory for the canvas",
+                    },
+                    "canvas_name": {
+                        "type": "string",
+                        "description": "Name for the canvas (e.g., 'fig1', 'Figure_2')",
+                    },
+                    "width_mm": {
+                        "type": "number",
+                        "description": "Canvas width in millimeters (default: 180 for double column)",
+                        "default": 180,
+                    },
+                    "height_mm": {
+                        "type": "number",
+                        "description": "Canvas height in millimeters (default: 120)",
+                        "default": 120,
+                    },
+                },
+                "required": ["parent_dir", "canvas_name"],
+            },
+        ),
+        # Add panel
+        types.Tool(
+            name="add_panel",
+            description="Add a panel (subplot) to an existing canvas from an image or plot file",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "parent_dir": {
+                        "type": "string",
+                        "description": "Parent directory containing the canvas",
+                    },
+                    "canvas_name": {
+                        "type": "string",
+                        "description": "Canvas name",
+                    },
+                    "panel_name": {
+                        "type": "string",
+                        "description": "Name for this panel (e.g., 'panel_a', 'timecourse')",
+                    },
+                    "source": {
+                        "type": "string",
+                        "description": "Path to source file (PNG, JPG, SVG, or SciTeX plot)",
+                    },
+                    "x_mm": {
+                        "type": "number",
+                        "description": "X position in millimeters from left edge",
+                        "default": 0,
+                    },
+                    "y_mm": {
+                        "type": "number",
+                        "description": "Y position in millimeters from top edge",
+                        "default": 0,
+                    },
+                    "width_mm": {
+                        "type": "number",
+                        "description": "Panel width in millimeters",
+                        "default": 50,
+                    },
+                    "height_mm": {
+                        "type": "number",
+                        "description": "Panel height in millimeters",
+                        "default": 50,
+                    },
+                    "label": {
+                        "type": "string",
+                        "description": "Panel label (e.g., 'A', 'B', 'C')",
+                    },
+                },
+                "required": ["parent_dir", "canvas_name", "panel_name", "source"],
+            },
+        ),
+        # List panels
+        types.Tool(
+            name="list_panels",
+            description="List all panels in a canvas with their properties",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "parent_dir": {
+                        "type": "string",
+                        "description": "Parent directory containing the canvas",
+                    },
+                    "canvas_name": {
+                        "type": "string",
+                        "description": "Canvas name",
+                    },
+                },
+                "required": ["parent_dir", "canvas_name"],
+            },
+        ),
+        # Remove panel
+        types.Tool(
+            name="remove_panel",
+            description="Remove a panel from a canvas",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "parent_dir": {
+                        "type": "string",
+                        "description": "Parent directory containing the canvas",
+                    },
+                    "canvas_name": {
+                        "type": "string",
+                        "description": "Canvas name",
+                    },
+                    "panel_name": {
+                        "type": "string",
+                        "description": "Name of the panel to remove",
+                    },
+                },
+                "required": ["parent_dir", "canvas_name", "panel_name"],
+            },
+        ),
+        # Export canvas
+        types.Tool(
+            name="export_canvas",
+            description="Export/render canvas to PNG, PDF, or SVG format",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "parent_dir": {
+                        "type": "string",
+                        "description": "Parent directory containing the canvas",
+                    },
+                    "canvas_name": {
+                        "type": "string",
+                        "description": "Canvas name",
+                    },
+                    "output_path": {
+                        "type": "string",
+                        "description": "Output file path (format determined by extension)",
+                    },
+                    "format": {
+                        "type": "string",
+                        "description": "Output format (auto-detected from path if not specified)",
+                        "enum": ["png", "pdf", "svg"],
+                    },
+                    "dpi": {
+                        "type": "integer",
+                        "description": "Output DPI for raster formats (default: 300)",
+                        "default": 300,
+                    },
+                },
+                "required": ["parent_dir", "canvas_name"],
+            },
+        ),
+        # List canvases
+        types.Tool(
+            name="list_canvases",
+            description="List all canvases in a directory",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "parent_dir": {
+                        "type": "string",
+                        "description": "Directory to search for canvases",
+                    },
+                },
+                "required": ["parent_dir"],
+            },
+        ),
+        # Canvas exists
+        types.Tool(
+            name="canvas_exists",
+            description="Check if a canvas exists",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "parent_dir": {
+                        "type": "string",
+                        "description": "Parent directory",
+                    },
+                    "canvas_name": {
+                        "type": "string",
+                        "description": "Canvas name to check",
+                    },
+                },
+                "required": ["parent_dir", "canvas_name"],
+            },
+        ),
+    ]
+
+
+__all__ = ["get_tool_schemas"]
+
+# EOF

scitex/{fig → canvas}/backend/_parser.py

@@ -161,7 +161,7 @@ def validate_figure_json(fig_json: Dict[str, Any]) -> bool:
 
     Examples
     --------
-    >>> from scitex.fig.backend import validate_figure_json
+    >>> from scitex.canvas.backend import validate_figure_json
     >>> fig_json = {"width_mm": 180, "height_mm": 120, "axes": []}
     >>> validate_figure_json(fig_json)
     True

scitex/{fig → canvas}/canvas.py

@@ -1,16 +1,15 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Timestamp: 2025-12-08
 # File: ./src/scitex/vis/canvas.py
 """
-Canvas class for scitex.fig.
+Canvas class for scitex.canvas.
 
 Provides object-oriented interface to canvas operations.
 """
 
-from pathlib import Path
-from typing import Dict, Any, Union, List, Optional
 from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Union
 
 
 class Canvas:
@@ -35,8 +34,8 @@ class Canvas:
     >>> # Create canvas
     >>> canvas = stx.vis.Canvas("fig1", width_mm=180, height_mm=120)
     >>> # Add panels
-    >>> canvas.add_panel("panel_a", "plot.png", position=(10, 10), size=(80, 50), label="A")
-    >>> canvas.add_panel("panel_b", "chart.png", position=(100, 10), size=(80, 50), label="B")
+    >>> canvas.add_panel("panel_a", "plot.png", xy_mm=(10, 10), size_mm=(80, 50), label="A")
+    >>> canvas.add_panel("panel_b", "chart.png", xy_mm=(100, 10), size_mm=(80, 50), label="B")
     >>> # Save (auto-exports PNG/PDF/SVG)
     >>> stx.io.save(canvas, "/output/fig1.canvas")
     """
@@ -82,8 +81,8 @@ class Canvas:
         self,
         panel_name: str,
         source: Union[str, Path],
-        position: tuple = (0, 0),
-        size: tuple = (50, 50),
+        xy_mm: tuple = (0, 0),
+        size_mm: tuple = (50, 50),
         label: str = "",
         **kwargs,
     ) -> "Canvas":
@@ -96,10 +95,10 @@ class Canvas:
             Name for the panel
         source : str or Path
             Path to source file (PNG, JPG, SVG)
-        position : tuple
-            (x_mm, y_mm) position on canvas
-        size : tuple
-            (width_mm, height_mm) panel size
+        xy_mm : tuple
+            (x_mm, y_mm) position on canvas in millimeters
+        size_mm : tuple
+            (width_mm, height_mm) panel size in millimeters
         label : str
             Panel label (A, B, C...)
         **kwargs
@@ -120,8 +119,8 @@ class Canvas:
         panel_entry = {
             "name": panel_name,
             "type": panel_type,
-            "position": {"x_mm": position[0], "y_mm": position[1]},
-            "size": {"width_mm": size[0], "height_mm": size[1]},
+            "position": {"x_mm": xy_mm[0], "y_mm": xy_mm[1]},
+            "size": {"width_mm": size_mm[0], "height_mm": size_mm[1]},
             "z_index": len(self._panels),
             "rotation_deg": kwargs.get("rotation_deg", 0),
             "opacity": kwargs.get("opacity", 1.0),

scitex/{fts/_fig/_editor → canvas/editor}/_defaults.py

@@ -197,7 +197,7 @@ def extract_defaults_from_metadata(metadata):
     # Extract traces information - check multiple possible locations
     traces = metadata.get("traces", [])
 
-    # Also check axes[].lines (pltz bundle format)
+    # Also check axes[].lines (plot bundle format)
     if not traces and isinstance(axes, list) and len(axes) > 0:
         ax = axes[0]
         lines = ax.get("lines", [])
@@ -225,7 +225,7 @@ def extract_defaults_from_metadata(metadata):
     # Extract legend information from multiple possible locations
     legend = metadata.get("legend", {})
 
-    # Also check selectable_regions.axes[0].legend (pltz bundle format)
+    # Also check selectable_regions.axes[0].legend (plot bundle format)
     if not legend:
         selectable = metadata.get("selectable_regions", {})
         sel_axes = selectable.get("axes", [])

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

@@ -8,24 +8,21 @@
 This module provides the main edit() function and supporting utilities for:
 - Backend detection and selection (flask, dearpygui, qt, tkinter, mpl)
 - Path resolution for figure files (.json, .csv, .png)
-- Bundle resolution for .pltz and .figz formats
+- Bundle resolution for .plot and .figure formats
 - Panel data loading for multi-panel figures
 - Manual override handling (.manual.json)
 """
 
-from .editor_launcher import edit
-from .backend_detector import (
-    detect_best_backend,
-    print_available_backends,
-)
-from .path_resolver import resolve_figure_paths
+from .backend_detector import detect_best_backend, print_available_backends
 from .bundle_resolver import (
-    resolve_pltz_bundle,
-    resolve_figz_bundle,
-    resolve_layered_pltz_bundle,
+    resolve_figure_bundle,
+    resolve_layered_plot_bundle,
+    resolve_plot_bundle,
 )
-from .panel_loader import load_panel_data
+from .editor_launcher import edit
 from .manual_handler import compute_file_hash, save_manual_overrides
+from .panel_loader import load_panel_data
+from .path_resolver import resolve_figure_paths
 
 __all__ = [
     # Main entry point
@@ -36,9 +33,9 @@ __all__ = [
     # Path resolution
     "resolve_figure_paths",
     # Bundle resolution
-    "resolve_pltz_bundle",
-    "resolve_figz_bundle",
-    "resolve_layered_pltz_bundle",
+    "resolve_plot_bundle",
+    "resolve_figure_bundle",
+    "resolve_layered_plot_bundle",
     # Panel loading
     "load_panel_data",
     # Manual overrides

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", {})