scitex 2.13.0__py3-none-any.whl → 2.15.1__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/canvas/editor/_dearpygui/__init__.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-24 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/canvas/editor/_dearpygui/__init__.py
+
+"""
+DearPyGui editor package.
+
+Modular GPU-accelerated figure editor using DearPyGui.
+
+Modules:
+- _state: EditorState dataclass for all editor state
+- _utils: Utility functions (checkerboard, constants)
+- _rendering: Figure rendering and highlight drawing
+- _plotting: CSV data plotting
+- _selection: Element selection and hover detection
+- _handlers: Event handlers and callbacks
+- _panels: UI panel creation
+"""
+
+from ._editor import DearPyGuiEditor
+
+__all__ = ["DearPyGuiEditor"]
+
+
+# EOF

scitex/canvas/editor/_dearpygui/_editor.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-24 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/canvas/editor/_dearpygui/_editor.py
+
+"""
+DearPyGui-based figure editor with GPU-accelerated rendering.
+
+Thin orchestrator class that delegates to modular components.
+"""
+
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from ._state import EditorState
+
+
+class DearPyGuiEditor:
+    """
+    GPU-accelerated figure editor using DearPyGui.
+
+    Features:
+    - Modern immediate-mode GUI with GPU acceleration
+    - Real-time figure preview
+    - Property editors with sliders, color pickers, and input fields
+    - Click-to-select traces on preview
+    - Save to .manual.json
+    - SciTeX style defaults pre-filled
+    - Dark/light theme support
+    """
+
+    def __init__(
+        self,
+        json_path: Path,
+        metadata: Dict[str, Any],
+        csv_data: Optional[Any] = None,
+        png_path: Optional[Path] = None,
+        manual_overrides: Optional[Dict[str, Any]] = None,
+    ):
+        """Initialize the DearPyGui editor.
+
+        Parameters
+        ----------
+        json_path : Path
+            Path to the JSON metadata file
+        metadata : dict
+            Figure metadata dictionary
+        csv_data : pd.DataFrame, optional
+            CSV data for plotting
+        png_path : Path, optional
+            Path to the PNG file
+        manual_overrides : dict, optional
+            Manual override settings
+        """
+        self.state = EditorState.create(
+            json_path=json_path,
+            metadata=metadata,
+            csv_data=csv_data,
+            png_path=png_path,
+            manual_overrides=manual_overrides,
+        )
+
+        # Backward compatibility properties
+        self._texture_id = None
+
+    @property
+    def json_path(self) -> Path:
+        """Get JSON path."""
+        return self.state.json_path
+
+    @property
+    def metadata(self) -> Dict[str, Any]:
+        """Get metadata."""
+        return self.state.metadata
+
+    @property
+    def csv_data(self) -> Optional[Any]:
+        """Get CSV data."""
+        return self.state.csv_data
+
+    @property
+    def current_overrides(self) -> Dict[str, Any]:
+        """Get current overrides."""
+        return self.state.current_overrides
+
+    @current_overrides.setter
+    def current_overrides(self, value: Dict[str, Any]) -> None:
+        """Set current overrides."""
+        self.state.current_overrides = value
+
+    def run(self):
+        """Launch the DearPyGui editor."""
+        try:
+            import dearpygui.dearpygui as dpg
+        except ImportError:
+            raise ImportError(
+                "DearPyGui is required for this editor. "
+                "Install with: pip install dearpygui"
+            )
+
+        from ._panels import create_control_panel, create_preview_panel
+        from ._rendering import update_preview
+
+        dpg.create_context()
+
+        # Configure viewport
+        dpg.create_viewport(
+            title=f"SciTeX Editor ({self.state.backend_name}) - {self.state.json_path.name}",
+            width=1400,
+            height=900,
+        )
+
+        # Create texture registry for image preview
+        with dpg.texture_registry(show=False):
+            # Create initial texture with placeholder
+            width, height = 800, 600
+            texture_data = [0.2, 0.2, 0.2, 1.0] * (width * height)
+            self._texture_id = dpg.add_dynamic_texture(
+                width=width,
+                height=height,
+                default_value=texture_data,
+                tag="preview_texture",
+            )
+            self.state.texture_id = self._texture_id
+
+        # Create main window
+        with dpg.window(label="SciTeX Figure Editor", tag="main_window"):
+            with dpg.group(horizontal=True):
+                # Left panel: Preview
+                create_preview_panel(self.state, dpg)
+
+                # Right panel: Controls
+                create_control_panel(self.state, dpg)
+
+        # Set main window as primary
+        dpg.set_primary_window("main_window", True)
+
+        # Initial render
+        update_preview(self.state, dpg)
+
+        # Setup and show
+        dpg.setup_dearpygui()
+        dpg.show_viewport()
+        dpg.start_dearpygui()
+        dpg.destroy_context()
+
+
+# EOF