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

scitex/ui/_mcp/__init__.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-13 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/ui/_mcp/__init__.py
+
+"""MCP handlers and schemas for scitex.ui notification server."""
+
+from .handlers import (
+    available_backends_handler,
+    get_config_handler,
+    list_backends_handler,
+    notify_handler,
+)
+from .tool_schemas import get_tool_schemas
+
+__all__ = [
+    "get_tool_schemas",
+    "notify_handler",
+    "list_backends_handler",
+    "available_backends_handler",
+    "get_config_handler",
+]
+
+# EOF

scitex/ui/_mcp/handlers.py

@@ -0,0 +1,260 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-13 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/ui/_mcp/handlers.py
+
+"""MCP handlers for scitex-notify server."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Optional
+
+__all__ = [
+    "notify_handler",
+    "notify_by_level_handler",
+    "list_backends_handler",
+    "available_backends_handler",
+    "get_config_handler",
+]
+
+
+async def notify_handler(
+    message: str,
+    title: Optional[str] = None,
+    level: str = "info",
+    backend: Optional[str] = None,
+    backends: Optional[list[str]] = None,
+    timeout: float = 5.0,
+) -> dict:
+    """Send notification via specified backend(s)."""
+    from .._backends import BACKENDS, NotifyLevel, get_backend
+    from .._backends._config import get_config
+
+    try:
+        # Determine notification level
+        try:
+            notify_level = NotifyLevel(level.lower())
+        except ValueError:
+            notify_level = NotifyLevel.INFO
+
+        # Determine backends to use
+        config = get_config()
+        if backends:
+            backend_list = backends
+        elif backend:
+            backend_list = [backend]
+        else:
+            backend_list = [config.default_backend]
+
+        results = []
+        success_count = 0
+
+        for backend_name in backend_list:
+            try:
+                if backend_name not in BACKENDS:
+                    results.append(
+                        {
+                            "backend": backend_name,
+                            "success": False,
+                            "error": f"Unknown backend: {backend_name}",
+                        }
+                    )
+                    continue
+
+                b = get_backend(backend_name)
+                result = await b.send(
+                    message,
+                    title=title,
+                    level=notify_level,
+                    timeout=timeout,
+                )
+
+                results.append(
+                    {
+                        "backend": backend_name,
+                        "success": result.success,
+                        "error": result.error,
+                        "details": result.details,
+                    }
+                )
+
+                if result.success:
+                    success_count += 1
+
+            except Exception as e:
+                results.append(
+                    {
+                        "backend": backend_name,
+                        "success": False,
+                        "error": str(e),
+                    }
+                )
+
+        return {
+            "success": success_count > 0,
+            "message": message,
+            "title": title,
+            "level": level,
+            "backends_used": backend_list,
+            "results": results,
+            "success_count": success_count,
+            "total_count": len(backend_list),
+            "timestamp": datetime.now().isoformat(),
+        }
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "timestamp": datetime.now().isoformat(),
+        }
+
+
+async def notify_by_level_handler(
+    message: str,
+    title: Optional[str] = None,
+    level: str = "info",
+) -> dict:
+    """Send notification using backends configured for the level."""
+    from .._backends import NotifyLevel
+    from .._backends._config import get_config
+
+    try:
+        # Determine notification level
+        try:
+            notify_level = NotifyLevel(level.lower())
+        except ValueError:
+            notify_level = NotifyLevel.INFO
+
+        # Get backends configured for this level
+        config = get_config()
+        backend_list = config.get_available_backends_for_level(notify_level)
+
+        if not backend_list:
+            backend_list = [config.default_backend]
+
+        # Use notify_handler with determined backends
+        return await notify_handler(
+            message=message,
+            title=title,
+            level=level,
+            backends=backend_list,
+        )
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "timestamp": datetime.now().isoformat(),
+        }
+
+
+async def list_backends_handler() -> dict:
+    """List all notification backends with their status."""
+    from .._backends import BACKENDS
+    from .._backends._config import is_backend_available
+
+    try:
+        backends_info = []
+
+        for name, cls in BACKENDS.items():
+            try:
+                backend = cls()
+                is_available = backend.is_available()
+                pkg_available = is_backend_available(name)
+
+                backends_info.append(
+                    {
+                        "name": name,
+                        "available": is_available,
+                        "package_available": pkg_available,
+                        "class": cls.__name__,
+                    }
+                )
+            except Exception as e:
+                backends_info.append(
+                    {
+                        "name": name,
+                        "available": False,
+                        "error": str(e),
+                    }
+                )
+
+        return {
+            "success": True,
+            "backends": backends_info,
+            "total_count": len(backends_info),
+            "available_count": sum(1 for b in backends_info if b.get("available")),
+            "timestamp": datetime.now().isoformat(),
+        }
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "timestamp": datetime.now().isoformat(),
+        }
+
+
+async def available_backends_handler() -> dict:
+    """Get list of currently available backends."""
+    from .._backends import available_backends
+
+    try:
+        available = available_backends()
+
+        return {
+            "success": True,
+            "available_backends": available,
+            "count": len(available),
+            "timestamp": datetime.now().isoformat(),
+        }
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "timestamp": datetime.now().isoformat(),
+        }
+
+
+async def get_config_handler() -> dict:
+    """Get current notification configuration."""
+    from .._backends._config import UIConfig, get_config
+
+    try:
+        # Reset to get fresh config
+        UIConfig.reset()
+        config = get_config()
+
+        return {
+            "success": True,
+            "config": {
+                "default_backend": config.default_backend,
+                "backend_priority": config.backend_priority,
+                "available_priority": config.get_available_backend_priority(),
+                "first_available": config.get_first_available_backend(),
+                "level_backends": {
+                    "info": config._config.get("level_backends", {}).get("info", []),
+                    "warning": config._config.get("level_backends", {}).get(
+                        "warning", []
+                    ),
+                    "error": config._config.get("level_backends", {}).get("error", []),
+                    "critical": config._config.get("level_backends", {}).get(
+                        "critical", []
+                    ),
+                },
+                "timeouts": config._config.get("timeouts", {}),
+            },
+            "timestamp": datetime.now().isoformat(),
+        }
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "timestamp": datetime.now().isoformat(),
+        }
+
+
+# EOF

scitex/ui/_mcp/tool_schemas.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-13 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/ui/_mcp/tool_schemas.py
+
+"""Tool schemas for the scitex-notify MCP server."""
+
+from __future__ import annotations
+
+import mcp.types as types
+
+__all__ = ["get_tool_schemas"]
+
+
+def get_tool_schemas() -> list[types.Tool]:
+    """Return all tool schemas for the notification MCP server."""
+    return [
+        types.Tool(
+            name="notify",
+            description=(
+                "Send a notification via configured backends (audio, desktop, email, "
+                "matplotlib, playwright, webhook). Supports multi-backend delivery "
+                "and notification levels (info, warning, error, critical)."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "message": {
+                        "type": "string",
+                        "description": "The notification message to send",
+                    },
+                    "title": {
+                        "type": "string",
+                        "description": "Optional notification title",
+                    },
+                    "level": {
+                        "type": "string",
+                        "description": "Notification urgency level",
+                        "enum": ["info", "warning", "error", "critical"],
+                        "default": "info",
+                    },
+                    "backend": {
+                        "type": "string",
+                        "description": (
+                            "Backend to use (audio, desktop, email, matplotlib, "
+                            "playwright, webhook). If not specified, uses default from config."
+                        ),
+                    },
+                    "backends": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "Multiple backends to use simultaneously",
+                    },
+                    "timeout": {
+                        "type": "number",
+                        "description": "Timeout for visual backends (matplotlib, playwright)",
+                        "default": 5.0,
+                    },
+                },
+                "required": ["message"],
+            },
+        ),
+        types.Tool(
+            name="notify_by_level",
+            description=(
+                "Send notification using backends configured for a specific level. "
+                "Uses level_backends config (e.g., critical -> audio + desktop + email)."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "message": {
+                        "type": "string",
+                        "description": "The notification message to send",
+                    },
+                    "title": {
+                        "type": "string",
+                        "description": "Optional notification title",
+                    },
+                    "level": {
+                        "type": "string",
+                        "description": "Notification level (determines which backends to use)",
+                        "enum": ["info", "warning", "error", "critical"],
+                        "default": "info",
+                    },
+                },
+                "required": ["message"],
+            },
+        ),
+        types.Tool(
+            name="list_notification_backends",
+            description="List all notification backends and their status",
+            inputSchema={"type": "object", "properties": {}},
+        ),
+        types.Tool(
+            name="available_notification_backends",
+            description="Get list of currently available (working) notification backends",
+            inputSchema={"type": "object", "properties": {}},
+        ),
+        types.Tool(
+            name="get_notification_config",
+            description="Get current notification configuration (priority, level_backends, timeouts)",
+            inputSchema={"type": "object", "properties": {}},
+        ),
+    ]
+
+
+# EOF

scitex/ui/mcp_server.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-13 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/ui/mcp_server.py
+
+"""
+MCP Server for SciTeX Notifications - Multi-backend alert system.
+
+Supports: audio, desktop, email, matplotlib, playwright, webhook backends.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from datetime import datetime
+
+# Graceful MCP dependency handling
+try:
+    import mcp.types as types
+    from mcp.server import NotificationOptions, Server
+    from mcp.server.models import InitializationOptions
+    from mcp.server.stdio import stdio_server
+
+    MCP_AVAILABLE = True
+except ImportError:
+    MCP_AVAILABLE = False
+    types = None  # type: ignore
+    Server = None  # type: ignore
+    NotificationOptions = None  # type: ignore
+    InitializationOptions = None  # type: ignore
+    stdio_server = None  # type: ignore
+
+__all__ = ["NotifyServer", "main", "MCP_AVAILABLE"]
+
+
+class NotifyServer:
+    """MCP Server for multi-backend notifications."""
+
+    def __init__(self):
+        self.server = Server("scitex-ui")
+        self._notification_count: int = 0
+        self.setup_handlers()
+
+    def setup_handlers(self):
+        """Set up MCP server handlers."""
+        from ._mcp.handlers import (
+            available_backends_handler,
+            get_config_handler,
+            list_backends_handler,
+            notify_by_level_handler,
+            notify_handler,
+        )
+        from ._mcp.tool_schemas import get_tool_schemas
+
+        @self.server.list_tools()
+        async def handle_list_tools():
+            return get_tool_schemas()
+
+        @self.server.call_tool()
+        async def handle_call_tool(name: str, arguments: dict):
+            if name == "notify":
+                self._notification_count += 1
+                return await notify_handler(**arguments)
+            elif name == "notify_by_level":
+                self._notification_count += 1
+                return await notify_by_level_handler(**arguments)
+            elif name == "list_notification_backends":
+                return await list_backends_handler()
+            elif name == "available_notification_backends":
+                return await available_backends_handler()
+            elif name == "get_notification_config":
+                return await get_config_handler()
+            else:
+                raise ValueError(f"Unknown tool: {name}")
+
+        @self.server.list_resources()
+        async def handle_list_resources():
+            # Return notification statistics as a resource
+            return [
+                types.Resource(
+                    uri="notify://stats",
+                    name="Notification Statistics",
+                    description="Current notification session statistics",
+                    mimeType="application/json",
+                )
+            ]
+
+        @self.server.read_resource()
+        async def handle_read_resource(uri: str):
+            if uri == "notify://stats":
+                from ._backends import available_backends
+                from ._backends._config import get_config
+
+                config = get_config()
+                stats = {
+                    "total_notifications": self._notification_count,
+                    "available_backends": available_backends(),
+                    "default_backend": config.default_backend,
+                    "timestamp": datetime.now().isoformat(),
+                }
+                import json
+
+                return types.ResourceContent(
+                    uri=uri,
+                    mimeType="application/json",
+                    content=json.dumps(stats, indent=2),
+                )
+            raise ValueError(f"Unknown resource: {uri}")
+
+
+async def _run_server():
+    """Run the MCP server (internal)."""
+    server = NotifyServer()
+    async with stdio_server() as (read_stream, write_stream):
+        await server.server.run(
+            read_stream,
+            write_stream,
+            InitializationOptions(
+                server_name="scitex-ui",
+                server_version="0.1.0",
+                capabilities=server.server.get_capabilities(
+                    notification_options=NotificationOptions(),
+                    experimental_capabilities={},
+                ),
+            ),
+        )
+
+
+def main():
+    """Main entry point for the MCP server."""
+    if not MCP_AVAILABLE:
+        import sys
+
+        print("=" * 60)
+        print("MCP Server 'scitex-ui' requires the 'mcp' package.")
+        print()
+        print("Install with:")
+        print("  pip install mcp")
+        print()
+        print("Or install scitex with MCP support:")
+        print("  pip install scitex[mcp]")
+        print("=" * 60)
+        sys.exit(1)
+
+    asyncio.run(_run_server())
+
+
+if __name__ == "__main__":
+    main()
+
+
+# EOF

scitex/utils/_email.py

@@ -1,20 +1,18 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Time-stamp: "2024-11-03 06:33:08 (ywatanabe)"
 # File: ./scitex_repo/src/scitex/utils/_email.py
 
+import mimetypes
 import os
+import re
 import smtplib
 from email import encoders
 from email.mime.base import MIMEBase as _MIMEBase
 from email.mime.multipart import MIMEMultipart as _MIMEMultipart
 from email.mime.text import MIMEText as _MIMEText
-import mimetypes
 
 from scitex.repro._gen_ID import gen_ID
 
-import re
-
 ansi_escape = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
 
 
@@ -87,7 +85,7 @@ def send_gmail(
             for path in attachment_paths:
                 _, ext = os.path.splitext(path)
                 if ext.lower() == ".log":
-                    with open(path, "r", encoding="utf-8") as file:
+                    with open(path, encoding="utf-8") as file:
                         content = file.read()
                         cleaned_content = ansi_escape.sub("", content)
                         part = _MIMEText(cleaned_content, "plain")
@@ -121,11 +119,11 @@ def send_gmail(
 
         if verbose:
             cc_info = f" (CC: {cc})" if cc else ""
-            message = f"Email was sent:\n"
+            message = "Email was sent:\n"
             message += f"    {sender_gmail} -> {recipient_email}{cc_info}\n"
             message += f"    (ID: {ID})\n"
             if attachment_paths:
-                message += f"    Attached:\n"
+                message += "    Attached:\n"
                 for ap in attachment_paths:
                     message += f"        {ap}\n"
             print(message)
@@ -140,4 +138,84 @@ def send_gmail(
         print(f"Email was not sent: {e}")
 
 
+async def send_email_async(
+    from_email: str,
+    to_email: str,
+    subject: str,
+    message: str,
+    html: bool = False,
+) -> bool:
+    """Send email asynchronously using configured SMTP.
+
+    Args:
+        from_email: Sender email address
+        to_email: Recipient email address
+        subject: Email subject
+        message: Email body (plain text or HTML)
+        html: If True, send as HTML email
+
+    Returns
+    -------
+        True if email was sent successfully, False otherwise
+    """
+    import asyncio
+    import logging
+
+    logger = logging.getLogger(__name__)
+
+    # Get SMTP credentials from environment
+    smtp_user = os.getenv("SCITEX_SCHOLAR_FROM_EMAIL_ADDRESS")
+    smtp_password = os.getenv("SCITEX_SCHOLAR_FROM_EMAIL_PASSWORD")
+    smtp_server = os.getenv(
+        "SCITEX_SCHOLAR_FROM_EMAIL_SMTP_SERVER", "mail1030.onamae.ne.jp"
+    )
+    smtp_port = int(os.getenv("SCITEX_SCHOLAR_FROM_EMAIL_SMTP_PORT", "587"))
+
+    # Check required credentials
+    if not smtp_user:
+        logger.warning(
+            "Email not sent: SCITEX_SCHOLAR_FROM_EMAIL_ADDRESS not set. "
+            "Configure SMTP credentials to enable email notifications."
+        )
+        return False
+
+    if not smtp_password:
+        logger.warning(
+            "Email not sent: SCITEX_SCHOLAR_FROM_EMAIL_PASSWORD not set. "
+            "Configure SMTP credentials to enable email notifications."
+        )
+        return False
+
+    if not to_email:
+        logger.warning("Email not sent: No recipient email address provided.")
+        return False
+
+    def _send_sync():
+        try:
+            server = smtplib.SMTP(smtp_server, smtp_port)
+            server.starttls()
+            server.login(smtp_user, smtp_password)
+
+            msg = _MIMEMultipart("alternative") if html else _MIMEMultipart()
+            msg["Subject"] = subject
+            msg["From"] = from_email
+            msg["To"] = to_email
+
+            if html:
+                msg.attach(_MIMEText(message, "html"))
+            else:
+                msg.attach(_MIMEText(message, "plain"))
+
+            server.send_message(msg)
+            server.quit()
+            return True
+        except Exception as e:
+            logger.error(f"Email send failed: {e}")
+            return False
+
+    # Run sync email in thread pool
+    loop = asyncio.get_event_loop()
+    return await loop.run_in_executor(None, _send_sync)
+
+
 # EOF