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

scitex/{fts/_bundle → io/bundle}/_validation.py

@@ -3,7 +3,7 @@
 # File: /home/ywatanabe/proj/scitex-code/src/scitex/fsb/_bundle/_validation.py
 
 """
-FTS Multi-Level Validation System.
+SciTeX Multi-Level Validation System.
 
 Three validation levels:
 1. schema   - Always ON (init/load/save) - Fast, structural checks
@@ -11,12 +11,12 @@ Three validation levels:
 3. strict   - Explicit (CI/publication) - Full scientific rigor
 
 Usage:
-    result = fts.validate(level="schema")  # Fast, default at init
-    result = fts.validate(level="semantic")  # Cross-ref checks
-    result = fts.validate(level="strict")  # Full validation
+    result = bundle.validate(level="schema")  # Fast, default at init
+    result = bundle.validate(level="semantic")  # Cross-ref checks
+    result = bundle.validate(level="strict")  # Full validation
 
     if result.has_errors:
-        raise FTSValidationError(result)
+        raise BundleValidationError(result)
 """
 
 import json
@@ -39,7 +39,7 @@ ValidationLevel = Literal["schema", "semantic", "strict"]
 
 @dataclass
 class ValidationResult:
-    """Result of FTS validation.
+    """Result of bundle validation.
 
     Attributes
     ----------
@@ -170,8 +170,8 @@ def validate_schema(data: Dict[str, Any], schema_name: str) -> List[str]:
     return errors
 
 
-def validate_node(data: Dict[str, Any]) -> List[str]:
-    """Validate node.json data."""
+def validate_spec(data: Dict[str, Any]) -> List[str]:
+    """Validate spec.json data."""
     return validate_schema(data, "node")
 
 
@@ -201,7 +201,7 @@ def validate_data_info(data: Dict[str, Any]) -> List[str]:
 
 
 def validate_semantic(
-    node: Optional[Dict] = None,
+    spec: Optional[Dict] = None,
     encoding: Optional[Dict] = None,
     theme: Optional[Dict] = None,
     stats: Optional[Dict] = None,
@@ -256,7 +256,7 @@ def validate_semantic(
 
 
 def validate_strict(
-    node: Optional[Dict] = None,
+    spec: Optional[Dict] = None,
     encoding: Optional[Dict] = None,
     theme: Optional[Dict] = None,
     stats: Optional[Dict] = None,
@@ -274,7 +274,7 @@ def validate_strict(
     # Include all semantic errors
     errors.extend(
         validate_semantic(
-            node=node,
+            spec=spec,
             encoding=encoding,
             theme=theme,
             stats=stats,
@@ -288,18 +288,20 @@ def validate_strict(
         for col in columns:
             if col.get("dtype") in ["float64", "int64", "number"]:
                 if not col.get("unit"):
-                    errors.append(f"Column '{col.get('name')}' missing unit specification")
+                    errors.append(
+                        f"Column '{col.get('name')}' missing unit specification"
+                    )
 
     # Provenance must be present
     if data_info and not data_info.get("source"):
         errors.append("data_info.source (provenance) is required for publication")
 
-    # Node must have all metadata
-    if node:
-        if not node.get("name"):
-            errors.append("node.name is required for publication")
-        if not node.get("created_at"):
-            errors.append("node.created_at is required for publication")
+    # Spec must have all metadata
+    if spec:
+        if not spec.get("name"):
+            errors.append("spec.name is required for publication")
+        if not spec.get("created_at"):
+            errors.append("spec.created_at is required for publication")
 
     return errors
 

scitex/io/bundle/_zip.py

@@ -1,13 +1,12 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Timestamp: "2025-12-16 (ywatanabe)"
 # File: /home/ywatanabe/proj/scitex-code/src/scitex/io/bundle/_zip.py
 
 """
 SciTeX ZipBundle - In-memory zip archive handler with atomic writes.
 
-Provides efficient access to .figz, .pltz, .statsz bundles without extracting
-to disk. Supports:
+Provides efficient access to .figure.zip, .plot.zip, .stats.zip bundles without
+extracting to disk. Supports:
     - In-memory file reading
     - Atomic writes using temp files
     - Context manager protocol
@@ -41,19 +40,19 @@ class ZipBundle:
 
     Usage:
         # Reading
-        with ZipBundle("figure.figz") as bundle:
+        with ZipBundle("figure.figure.zip") as bundle:
             spec = bundle.read_json("spec.json")
             csv_data = bundle.read_csv("data.csv")
             png_bytes = bundle.read_bytes("exports/figure.png")
 
         # Writing
-        with ZipBundle("output.pltz", mode="w") as bundle:
+        with ZipBundle("output.plot.zip", mode="w") as bundle:
             bundle.write_json("spec.json", spec_dict)
             bundle.write_csv("data.csv", dataframe)
             bundle.write_bytes("exports/plot.png", png_bytes)
 
         # Modifying (read then write atomically)
-        with ZipBundle("figure.figz", mode="a") as bundle:
+        with ZipBundle("figure.figure.zip", mode="a") as bundle:
             spec = bundle.read_json("spec.json")
             spec["title"] = "Updated"
             bundle.write_json("spec.json", spec)
@@ -68,7 +67,7 @@ class ZipBundle:
         """Initialize ZipBundle.
 
         Args:
-            path: Path to zip file (.figz, .pltz, .statsz)
+            path: Path to zip file (.figure.zip, .plot.zip, .stats.zip)
             mode: 'r' for read, 'w' for write, 'a' for append/modify
             compression: ZIP compression method (default: ZIP_DEFLATED)
         """
@@ -100,18 +99,14 @@ class ZipBundle:
             self._zipfile = zipfile.ZipFile(self.path, "r")
         elif self.mode == "w":
             self._temp_path = Path(tempfile.mktemp(suffix=self.path.suffix))
-            self._zipfile = zipfile.ZipFile(
-                self._temp_path, "w", self.compression
-            )
+            self._zipfile = zipfile.ZipFile(self._temp_path, "w", self.compression)
         elif self.mode == "a":
             if self.path.exists():
                 with zipfile.ZipFile(self.path, "r") as zf:
                     for name in zf.namelist():
                         self._cache[name] = zf.read(name)
             self._temp_path = Path(tempfile.mktemp(suffix=self.path.suffix))
-            self._zipfile = zipfile.ZipFile(
-                self._temp_path, "w", self.compression
-            )
+            self._zipfile = zipfile.ZipFile(self._temp_path, "w", self.compression)
         else:
             raise ValueError(f"Invalid mode: {self.mode}")
 
@@ -282,9 +277,7 @@ class ZipBundle:
         """
         self.write_bytes(name, text.encode(encoding))
 
-    def write_json(
-        self, name: str, data: Dict[str, Any], indent: int = 2
-    ) -> None:
+    def write_json(self, name: str, data: Dict[str, Any], indent: int = 2) -> None:
         """Write dictionary as JSON file.
 
         Args:
@@ -359,7 +352,7 @@ def open(path: Union[str, Path], mode: str = "r") -> ZipBundle:
         ZipBundle instance (use as context manager).
 
     Example:
-        with open("figure.figz") as bundle:
+        with open("figure.figure.zip") as bundle:
             spec = bundle.spec
             data = bundle.data
     """
@@ -376,7 +369,7 @@ def create(
     """Create a new bundle with atomic write.
 
     Args:
-        path: Output path (.figz, .pltz, or .statsz).
+        path: Output path (.figure.zip, .plot.zip, or .stats.zip).
         spec: Bundle specification dictionary.
         data: Optional CSV data as DataFrame.
         style: Optional style dictionary.
@@ -387,7 +380,7 @@ def create(
 
     Example:
         create(
-            "plot.pltz",
+            "plot.plot.zip",
             spec={"schema": {"name": "scitex.plt", "version": "1.0"}},
             data=df,
             exports={"exports/plot.png": png_bytes},
@@ -415,15 +408,15 @@ def zip_directory(
     source_dir: Union[str, Path],
     output_path: Optional[Union[str, Path]] = None,
 ) -> Path:
-    """Convert a directory bundle (.pltz.d, .figz.d) to a ZIP bundle (.pltz, .figz).
+    """Convert a directory bundle (.plot, .figure) to a ZIP bundle (.plot.zip, .figure.zip).
 
     Creates a ZIP archive from an existing directory bundle, preserving
     the internal structure. The ZIP file is created atomically using a temp file.
 
     Args:
-        source_dir: Path to directory bundle (e.g., "panel_A.pltz.d", "figure.figz.d")
+        source_dir: Path to directory bundle (e.g., "panel_A.plot", "figure.figure")
         output_path: Optional output ZIP path. If not provided, derives from source_dir
-            by replacing .pltz.d -> .pltz or .figz.d -> .figz
+            by appending .zip (e.g., .plot -> .plot.zip)
 
     Returns:
         Path to created ZIP bundle.
@@ -433,11 +426,11 @@ def zip_directory(
         ValueError: If source is not a valid bundle directory.
 
     Example:
-        # Convert panel_A.pltz.d to panel_A.pltz
-        zip_path = zip_directory("panel_A.pltz.d")
+        # Convert panel_A.plot to panel_A.plot.zip
+        zip_path = zip_directory("panel_A.plot")
 
         # Convert with custom output path
-        zip_path = zip_directory("A.pltz.d", "output/A.pltz")
+        zip_path = zip_directory("A.plot", "output/A.plot.zip")
     """
     source_dir = Path(source_dir)
 
@@ -449,12 +442,9 @@ def zip_directory(
 
     if output_path is None:
         dir_name = source_dir.name
-        if dir_name.endswith(".pltz.d"):
-            zip_name = dir_name.replace(".pltz.d", ".pltz")
-        elif dir_name.endswith(".figz.d"):
-            zip_name = dir_name.replace(".figz.d", ".figz")
-        elif dir_name.endswith(".statsz.d"):
-            zip_name = dir_name.replace(".statsz.d", ".statsz")
+        # New format: .plot -> .plot.zip, .figure -> .figure.zip, .stats -> .stats.zip
+        if dir_name.endswith((".plot", ".figure", ".stats")):
+            zip_name = dir_name + ".zip"
         else:
             zip_name = dir_name + ".zip"
         output_path = source_dir.parent / zip_name

scitex/{fts/_kinds → io/bundle/kinds}/_plot/_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/{fts/_kinds → io/bundle/kinds}/_plot/_models/_Annotations.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # File: ./src/scitex/vis/model/annotations.py
-"""Annotation JSON model for scitex.fig."""
+"""Annotation JSON model for scitex.canvas."""
 
 from dataclasses import asdict, dataclass, field
 from typing import Any, Dict, Optional, Tuple

scitex/{fts/_kinds → io/bundle/kinds}/_plot/_models/_Axes.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # File: ./src/scitex/vis/model/axes.py
-"""Axes JSON model for scitex.fig."""
+"""Axes JSON model for scitex.canvas."""
 
 from dataclasses import asdict, dataclass, field
 from typing import Any, Dict, List, Optional

scitex/{fts/_kinds → io/bundle/kinds}/_plot/_models/_Figure.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # File: ./src/scitex/vis/model/figure.py
-"""Figure JSON model for scitex.fig."""
+"""Figure JSON model for scitex.canvas."""
 
 from dataclasses import asdict, dataclass, field
 from typing import Any, Dict, List, Optional

scitex/{fts/_fig → io/bundle/kinds/_plot}/_models/_Guides.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # File: ./src/scitex/vis/model/guides.py
-"""Guide elements (lines, spans) JSON model for scitex.fig."""
+"""Guide elements (lines, spans) JSON model for scitex.canvas."""
 
 from dataclasses import asdict, dataclass, field
 from typing import Any, Dict, Optional

scitex/{fts/_kinds → io/bundle/kinds}/_plot/_models/_Plot.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # File: ./src/scitex/vis/model/plot.py
-"""Plot JSON model for scitex.fig."""
+"""Plot JSON model for scitex.canvas."""
 
 from dataclasses import asdict, dataclass, field
 from typing import Any, Dict, List, Optional

scitex/{fts/_fig → io/bundle/kinds/_plot}/_models/_Styles.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 # File: ./src/scitex/vis/model/styles.py
 """
-Style dataclasses for scitex.fig objects.
+Style dataclasses for scitex.canvas objects.
 
 Separating style properties from data makes:
 - UI property panels easy to auto-generate

scitex/{fts/_kinds → io/bundle/kinds}/_plot/_utils/_plot_layout.py

@@ -12,7 +12,7 @@ Provides architectural drawing style visualizations with:
 - Before/after comparison for auto-crop
 
 Usage:
-    from scitex.fts._fig._utils import plot_layout, plot_auto_crop_comparison
+    from scitex.io.bundle._fig._utils import plot_layout, plot_auto_crop_comparison
 
     # Single layout visualization
     fig, ax = plot_layout(elements, canvas_size, title="My Figure")

scitex/{fts/_kinds → io/bundle/kinds}/_table/_latex/__init__.py

@@ -7,7 +7,7 @@
 This module provides LaTeX export capabilities for FTS figure and table bundles.
 
 Usage:
-    from scitex.fts._tables._latex import export_to_latex, launch_editor
+    from scitex.io.bundle._tables._latex import export_to_latex, launch_editor
 
     # Export a bundle to LaTeX
     result = export_to_latex(bundle)

scitex/{fts/_kinds → io/bundle/kinds}/_table/_latex/_editor/_app.py

@@ -17,7 +17,7 @@ from flask import Flask, jsonify, render_template_string, request
 from .._validator import ValidationResult, validate_latex
 
 if TYPE_CHECKING:
-    from scitex.fts import FTS
+    from scitex.io.bundle import FTS
 
 
 # HTML template with CodeMirror editor

scitex/{fts/_tables → io/bundle/kinds/_table}/_latex/_export.py

@@ -14,7 +14,7 @@ from ._table_exporter import TableExportOptions, export_table_to_latex, generate
 from ._validator import LaTeXError, ValidationResult, validate_latex
 
 if TYPE_CHECKING:
-    from scitex.fts import FTS
+    from scitex.io.bundle import FTS
 
 
 @dataclass

scitex/{fts/_kinds → io/bundle/kinds}/_table/_latex/_figure_exporter.py

@@ -11,7 +11,7 @@ from typing import TYPE_CHECKING, Optional
 from ._utils import escape_latex_minimal, sanitize_label
 
 if TYPE_CHECKING:
-    from scitex.fts import FTS
+    from scitex.io.bundle import FTS
 
 
 @dataclass

scitex/{fts/_kinds → io/bundle/kinds}/_table/_latex/_table_exporter.py

@@ -21,7 +21,7 @@ from ._utils import (
 )
 
 if TYPE_CHECKING:
-    from scitex.fts import FTS
+    from scitex.io.bundle import FTS
 
 
 # Column role to header mapping

scitex/io/bundle/schemas/__init__.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-07
+# File: src/scitex/io/bundle/schemas/__init__.py
+"""SciTeX Bundle Schemas.
+
+This module contains JSON schemas for bundle validation.
+"""
+
+from pathlib import Path
+
+__all__ = [
+    "SCHEMAS_DIR",
+    "NODE_SCHEMA",
+    "ENCODING_SCHEMA",
+    "THEME_SCHEMA",
+    "STATS_SCHEMA",
+    "DATA_INFO_SCHEMA",
+    "RENDER_MANIFEST_SCHEMA",
+]
+
+SCHEMAS_DIR = Path(__file__).parent
+
+NODE_SCHEMA = SCHEMAS_DIR / "node.schema.json"
+ENCODING_SCHEMA = SCHEMAS_DIR / "encoding.schema.json"
+THEME_SCHEMA = SCHEMAS_DIR / "theme.schema.json"
+STATS_SCHEMA = SCHEMAS_DIR / "stats.schema.json"
+DATA_INFO_SCHEMA = SCHEMAS_DIR / "data_info.schema.json"
+RENDER_MANIFEST_SCHEMA = SCHEMAS_DIR / "render_manifest.schema.json"
+
+# EOF

scitex/mcp_server.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-08
+# File: src/scitex/mcp_server.py
+# ----------------------------------------
+
+"""
+Unified MCP Server for SciTeX - All modules in one server.
+
+Aggregates tools from all SciTeX MCP modules with prefixed names:
+- audio_*: Text-to-speech
+- capture_*: Screenshot capture
+- scholar_*: Literature management
+- stats_*: Statistical analysis
+- template_*: Project scaffolding
+- plt_*: Publication plotting
+- canvas_*: Multi-panel figures
+- diagram_*: Diagram generation
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Callable
+
+import mcp.types as types
+from mcp.server import NotificationOptions, Server
+from mcp.server.models import InitializationOptions
+from mcp.server.stdio import stdio_server
+
+__all__ = ["UnifiedServer", "main"]
+
+# Module registry: (prefix, schema_getter, handler_module)
+MODULES = [
+    ("audio", "scitex.audio._mcp_tool_schemas", "scitex.audio._mcp_handlers"),
+    ("capture", "scitex.capture._mcp_tool_schemas", "scitex.capture._mcp_handlers"),
+    ("scholar", "scitex.scholar._mcp_tool_schemas", "scitex.scholar._mcp_handlers"),
+    ("stats", "scitex.stats._mcp_tool_schemas", "scitex.stats._mcp_handlers"),
+    ("template", "scitex.template._mcp_tool_schemas", "scitex.template._mcp_handlers"),
+    ("plt", "scitex.plt._mcp_tool_schemas", "scitex.plt._mcp_handlers"),
+    ("canvas", "scitex.canvas._mcp_tool_schemas", "scitex.canvas._mcp_handlers"),
+    ("diagram", "scitex.diagram._mcp_tool_schemas", "scitex.diagram._mcp_handlers"),
+]
+
+
+class UnifiedServer:
+    """Unified MCP Server aggregating all SciTeX modules."""
+
+    def __init__(self):
+        self.server = Server("scitex-mcp-server")
+        self.tools: list[types.Tool] = []
+        self.handlers: dict[str, Callable] = {}
+        self._load_modules()
+        self._setup_handlers()
+
+    def _load_modules(self):
+        """Load tool schemas and handlers from all modules."""
+        import importlib
+
+        for prefix, schema_module, handler_module in MODULES:
+            try:
+                # Load tool schemas
+                schema_mod = importlib.import_module(schema_module)
+                tools = schema_mod.get_tool_schemas()
+
+                # Load handlers
+                handler_mod = importlib.import_module(handler_module)
+
+                for tool in tools:
+                    # Create prefixed tool name
+                    prefixed_name = f"{prefix}_{tool.name}"
+
+                    # Create new tool with prefixed name
+                    prefixed_tool = types.Tool(
+                        name=prefixed_name,
+                        description=f"[{prefix}] {tool.description}",
+                        inputSchema=tool.inputSchema,
+                    )
+                    self.tools.append(prefixed_tool)
+
+                    # Map handler
+                    handler_name = f"{tool.name}_handler"
+                    if hasattr(handler_mod, handler_name):
+                        self.handlers[prefixed_name] = getattr(
+                            handler_mod, handler_name
+                        )
+
+            except ImportError as e:
+                # Module not available, skip it
+                print(f"Skipping {prefix} module: {e}")
+            except Exception as e:
+                print(f"Error loading {prefix} module: {e}")
+
+    def _setup_handlers(self):
+        """Set up MCP server handlers."""
+
+        @self.server.list_tools()
+        async def handle_list_tools():
+            return self.tools
+
+        @self.server.call_tool()
+        async def handle_call_tool(name: str, arguments: dict):
+            if name not in self.handlers:
+                return [
+                    types.TextContent(
+                        type="text",
+                        text=json.dumps(
+                            {"success": False, "error": f"Unknown tool: {name}"},
+                            indent=2,
+                        ),
+                    )
+                ]
+
+            return await self._wrap_result(self.handlers[name](**arguments))
+
+    async def _wrap_result(self, coro):
+        """Wrap handler result as MCP TextContent."""
+        try:
+            result = await coro
+            return [
+                types.TextContent(
+                    type="text",
+                    text=json.dumps(result, indent=2, default=str),
+                )
+            ]
+        except Exception as e:
+            return [
+                types.TextContent(
+                    type="text",
+                    text=json.dumps({"success": False, "error": str(e)}, indent=2),
+                )
+            ]
+
+
+async def main():
+    """Run the unified MCP server."""
+    server = UnifiedServer()
+    print(f"Loaded {len(server.tools)} tools from {len(MODULES)} modules")
+
+    async with stdio_server() as (read_stream, write_stream):
+        await server.server.run(
+            read_stream,
+            write_stream,
+            InitializationOptions(
+                server_name="scitex-mcp-server",
+                server_version="0.1.0",
+                capabilities=server.server.get_capabilities(
+                    notification_options=NotificationOptions(),
+                    experimental_capabilities={},
+                ),
+            ),
+        )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+
+
+# EOF

scitex/parallel/_run.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Time-stamp: "2024-11-14 23:12:20 (ywatanabe)"
 # File: ./scitex_repo/src/scitex/parallel/_run.py
 
@@ -65,13 +64,15 @@ def run(
     if not callable(func):
         raise ValueError("Func must be callable")
 
+    # Validate n_jobs before conversion: must be -1 or >= 1
+    if n_jobs < -1 or n_jobs == 0:
+        raise ValueError("n_jobs must be >= 1 or -1")
+
     cpu_count = multiprocessing.cpu_count()
-    n_jobs = cpu_count if n_jobs < 0 else n_jobs
+    n_jobs = cpu_count if n_jobs == -1 else n_jobs
 
     if n_jobs > cpu_count:
         warnings.warn(f"n_jobs ({n_jobs}) is greater than CPU count ({cpu_count})")
-    if n_jobs < 1:
-        raise ValueError("n_jobs must be >= 1 or -1")
 
     results = [None] * len(args_list)  # Pre-allocate list