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

scitex/io/_load_modules/_optuna.py

@@ -1,10 +1,17 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Time-stamp: "2024-11-14 07:55:45 (ywatanabe)"
 # File: ./scitex_repo/src/scitex/io/_load_modules/_optuna.py
 
 from ._yaml import _load_yaml
 
+try:
+    import optuna
+
+    OPTUNA_AVAILABLE = True
+except ImportError:
+    OPTUNA_AVAILABLE = False
+    optuna = None
+
 
 def load_yaml_as_an_optuna_dict(fpath_yaml, trial):
     """
@@ -31,7 +38,14 @@ def load_yaml_as_an_optuna_dict(fpath_yaml, trial):
         If the specified YAML file does not exist.
     ValueError
         If the YAML file contains invalid configuration for Optuna.
+    ImportError
+        If Optuna is not installed.
     """
+    if not OPTUNA_AVAILABLE:
+        raise ImportError(
+            "Optuna is not installed. Please install with: pip install optuna"
+        )
+
     _d = _load_yaml(fpath_yaml)
 
     for k, v in _d.items():
@@ -74,6 +88,8 @@ def load_study_rdb(study_name, rdb_raw_bytes_url):
     -------
     optuna.exceptions.StorageInvalidUsageError
         If there's an error loading the study from the storage.
+    ImportError
+        If Optuna is not installed.
 
     Example:
     --------
@@ -82,7 +98,10 @@ def load_study_rdb(study_name, rdb_raw_bytes_url):
     ...     rdb_raw_bytes_url="sqlite:///path/to/your/study.db"
     ... )
     """
-    import optuna
+    if not OPTUNA_AVAILABLE:
+        raise ImportError(
+            "Optuna is not installed. Please install with: pip install optuna"
+        )
 
     storage = optuna.storages.RDBStorage(url=rdb_raw_bytes_url)
     study = optuna.load_study(study_name=study_name, storage=storage)
@@ -90,65 +109,4 @@ def load_study_rdb(study_name, rdb_raw_bytes_url):
     return study
 
 
-def load_yaml_as_an_optuna_dict(fpath_yaml, trial):
-    """
-    Load a YAML file and convert it to an Optuna-compatible dictionary.
-
-    Parameters:
-    -----------
-    fpath_yaml : str
-        The path to the YAML file.
-    trial : optuna.trial.Trial
-        The Optuna trial object.
-
-    Returns:
-    --------
-    dict
-        A dictionary with Optuna-compatible parameter suggestions.
-    """
-    _d = _load_yaml(fpath_yaml)
-
-    for k, v in _d.items():
-        dist = v["distribution"]
-
-        if dist == "categorical":
-            _d[k] = trial.suggest_categorical(k, v["values"])
-
-        elif dist == "uniform":
-            _d[k] = trial.suggest_int(k, float(v["min"]), float(v["max"]))
-
-        elif dist == "loguniform":
-            _d[k] = trial.suggest_loguniform(k, float(v["min"]), float(v["max"]))
-
-        elif dist == "intloguniform":
-            _d[k] = trial.suggest_int(k, float(v["min"]), float(v["max"]), log=True)
-
-    return _d
-
-
-def load_study_rdb(study_name, rdb_raw_bytes_url):
-    """
-    Load an Optuna study from a RDB storage.
-
-    Parameters:
-    -----------
-    study_name : str
-        The name of the Optuna study.
-    rdb_raw_bytes_url : str
-        The URL of the RDB storage.
-
-    Returns:
-    --------
-    optuna.study.Study
-        The loaded Optuna study object.
-    """
-    import optuna
-
-    # rdb_raw_bytes_url = "sqlite:////tmp/fake/ywatanabe/_MicroNN_WindowSize-1.0-sec_MaxEpochs_100_2021-1216-1844/optuna_study_test_file#0.db"
-    storage = optuna.storages.RDBStorage(url=rdb_raw_bytes_url)
-    study = optuna.load_study(study_name=study_name, storage=storage)
-    print(f"\nLoaded: {rdb_raw_bytes_url}\n")
-    return study
-
-
 # EOF

scitex/io/_load_modules/_torch.py

@@ -1,13 +1,21 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Time-stamp: "2024-11-14 07:41:34 (ywatanabe)"
 # File: ./scitex_repo/src/scitex/io/_load_modules/_torch.py
 
+try:
+    import torch
+
+    TORCH_AVAILABLE = True
+except ImportError:
+    TORCH_AVAILABLE = False
+
 
 def _load_torch(lpath, **kwargs):
     """Load PyTorch model/checkpoint file."""
-    # Lazy import to avoid circular import issues
-    import torch
+    if not TORCH_AVAILABLE:
+        raise ImportError(
+            "PyTorch is not installed. Please install with: pip install torch"
+        )
 
     if not lpath.endswith((".pth", ".pt")):
         raise ValueError("File must have .pth or .pt extension")

scitex/io/_save_modules/_optuna_study_as_csv_and_pngs.py

@@ -1,11 +1,22 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Time-stamp: "2024-11-02 17:01:15 (ywatanabe)"
 # File: ./scitex_repo/src/scitex/io/_save_optuna_study_as_csv_and_pngs.py
 
+try:
+    import optuna
+
+    OPTUNA_AVAILABLE = True
+except ImportError:
+    OPTUNA_AVAILABLE = False
+    optuna = None
+
 
 def save_optuna_study_as_csv_and_pngs(study, sdir):
-    import optuna
+    if not OPTUNA_AVAILABLE:
+        raise ImportError(
+            "Optuna is not installed. Please install with: pip install optuna"
+        )
+
     from .._save import save
 
     ## Trials DataFrame

scitex/io/_save_modules/_torch.py

@@ -1,8 +1,14 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Timestamp: "2025-05-16 12:25:14 (ywatanabe)"
 # File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/io/_save_modules/_torch.py
 
+try:
+    import torch
+
+    TORCH_AVAILABLE = True
+except ImportError:
+    TORCH_AVAILABLE = False
+
 
 def _save_torch(obj, spath, **kwargs):
     """
@@ -21,7 +27,9 @@ def _save_torch(obj, spath, **kwargs):
     -------
     None
     """
-    # Lazy import to avoid circular import issues
-    import torch
+    if not TORCH_AVAILABLE:
+        raise ImportError(
+            "PyTorch is not installed. Please install with: pip install torch"
+        )
 
     torch.save(obj, spath, **kwargs)

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