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

scitex/ui/_backends/_emacs.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-13 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/ui/_backends/_emacs.py
+
+"""Emacs notification backend using emacsclient."""
+
+from __future__ import annotations
+
+import asyncio
+import shutil
+import subprocess
+from datetime import datetime
+from typing import Optional
+
+from ._types import BaseNotifyBackend, NotifyLevel, NotifyResult
+
+
+class EmacsBackend(BaseNotifyBackend):
+    """Notification via Emacs using emacsclient.
+
+    Displays notifications in Emacs minibuffer or as alerts.
+    Supports different display methods:
+    - popup: temporary popup buffer (default, most noticeable)
+    - minibuffer: message function
+    - alert: alert.el package
+    - notifications: notifications.el (desktop notifications from Emacs)
+    """
+
+    name = "emacs"
+
+    def __init__(self, method: str = "popup", timeout: float = 5.0):
+        """Initialize Emacs backend.
+
+        Parameters
+        ----------
+        method : str
+            Notification method: 'popup', 'minibuffer', 'alert', or 'notifications'
+        timeout : float
+            Display timeout for visual methods
+        """
+        self.method = method
+        self.timeout = timeout
+
+    def is_available(self) -> bool:
+        """Check if emacsclient is available."""
+        return shutil.which("emacsclient") is not None
+
+    def _escape_elisp_string(self, s: str) -> str:
+        """Escape a string for use in elisp."""
+        return s.replace("\\", "\\\\").replace('"', '\\"').replace("\n", "\\n")
+
+    def _get_face_for_level(self, level: NotifyLevel) -> str:
+        """Get Emacs face name for notification level."""
+        faces = {
+            NotifyLevel.INFO: "success",
+            NotifyLevel.WARNING: "warning",
+            NotifyLevel.ERROR: "error",
+            NotifyLevel.CRITICAL: "error",
+        }
+        return faces.get(level, "default")
+
+    async def send(
+        self,
+        message: str,
+        title: Optional[str] = None,
+        level: NotifyLevel = NotifyLevel.INFO,
+        **kwargs,
+    ) -> NotifyResult:
+        """Send notification via Emacs."""
+        try:
+            method = kwargs.get("method", self.method)
+            timeout = kwargs.get("timeout", self.timeout)
+
+            # Escape strings for elisp
+            msg_escaped = self._escape_elisp_string(message)
+            title_escaped = self._escape_elisp_string(title or "SciTeX")
+            face = self._get_face_for_level(level)
+
+            # Build elisp command based on method
+            if method == "popup":
+                # Popup buffer - most noticeable
+                level_colors = {
+                    NotifyLevel.INFO: "#98C379",  # green
+                    NotifyLevel.WARNING: "#E5C07B",  # yellow
+                    NotifyLevel.ERROR: "#E06C75",  # red
+                    NotifyLevel.CRITICAL: "#E06C75",  # red
+                }
+                color = level_colors.get(level, "#98C379")
+                elisp = f'''
+                (let* ((buf (get-buffer-create "*SciTeX Alert*"))
+                       (timeout {int(timeout)}))
+                  (with-current-buffer buf
+                    (erase-buffer)
+                    (insert (propertize "\\n  ╔══════════════════════════════════════╗\\n"
+                                        'face '(:foreground "{color}" :weight bold)))
+                    (insert (propertize "  ║  SciTeX Alert                        ║\\n"
+                                        'face '(:foreground "{color}" :weight bold)))
+                    (insert (propertize "  ╠══════════════════════════════════════╣\\n"
+                                        'face '(:foreground "{color}")))
+                    (insert (propertize (format "  ║  [%s] %s\\n" "{level.value.upper()}" "{msg_escaped}")
+                                        'face '(:foreground "{color}")))
+                    (insert (propertize "  ╚══════════════════════════════════════╝\\n"
+                                        'face '(:foreground "{color}")))
+                    (goto-char (point-min)))
+                  (display-buffer buf
+                    '((display-buffer-in-side-window)
+                      (side . bottom)
+                      (window-height . 8)))
+                  (run-at-time timeout nil
+                    (lambda ()
+                      (when-let ((win (get-buffer-window buf t)))
+                        (delete-window win))
+                      (kill-buffer buf)))
+                  (message "[SciTeX] %s" "{msg_escaped}"))
+                '''
+            elif method == "alert":
+                # Use alert.el package (if installed)
+                severity_map = {
+                    NotifyLevel.INFO: "normal",
+                    NotifyLevel.WARNING: "moderate",
+                    NotifyLevel.ERROR: "high",
+                    NotifyLevel.CRITICAL: "urgent",
+                }
+                severity = severity_map.get(level, "normal")
+                elisp = f'''
+                (if (fboundp 'alert)
+                    (alert "{msg_escaped}"
+                           :title "{title_escaped}"
+                           :severity '{severity}
+                           :timeout {int(timeout)})
+                  (message "[%s] %s: %s" "{level.value.upper()}" "{title_escaped}" "{msg_escaped}"))
+                '''
+            elif method == "notifications":
+                # Use notifications.el (requires D-Bus)
+                urgency_map = {
+                    NotifyLevel.INFO: "normal",
+                    NotifyLevel.WARNING: "normal",
+                    NotifyLevel.ERROR: "critical",
+                    NotifyLevel.CRITICAL: "critical",
+                }
+                urgency = urgency_map.get(level, "normal")
+                elisp = f'''
+                (if (fboundp 'notifications-notify)
+                    (notifications-notify
+                     :title "{title_escaped}"
+                     :body "{msg_escaped}"
+                     :urgency '{urgency}
+                     :timeout {int(timeout * 1000)})
+                  (message "[%s] %s: %s" "{level.value.upper()}" "{title_escaped}" "{msg_escaped}"))
+                '''
+            else:
+                # Default: minibuffer message with face
+                elisp = f"""
+                (let ((msg (propertize "[{level.value.upper()}] {title_escaped}: {msg_escaped}" 'face '{face})))
+                  (message "%s" msg))
+                """
+
+            # Clean up elisp (remove extra whitespace)
+            elisp = " ".join(elisp.split())
+
+            # Execute via emacsclient
+            cmd = ["emacsclient", "--eval", elisp]
+
+            loop = asyncio.get_event_loop()
+            result = await loop.run_in_executor(
+                None,
+                lambda: subprocess.run(
+                    cmd,
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
+                ),
+            )
+
+            if result.returncode == 0:
+                return NotifyResult(
+                    success=True,
+                    backend=self.name,
+                    message=message,
+                    timestamp=datetime.now().isoformat(),
+                    details={"method": method, "elisp_result": result.stdout.strip()},
+                )
+            else:
+                return NotifyResult(
+                    success=False,
+                    backend=self.name,
+                    message=message,
+                    timestamp=datetime.now().isoformat(),
+                    error=result.stderr.strip() or "emacsclient failed",
+                )
+
+        except subprocess.TimeoutExpired:
+            return NotifyResult(
+                success=False,
+                backend=self.name,
+                message=message,
+                timestamp=datetime.now().isoformat(),
+                error="emacsclient timed out",
+            )
+        except Exception as e:
+            return NotifyResult(
+                success=False,
+                backend=self.name,
+                message=message,
+                timestamp=datetime.now().isoformat(),
+                error=str(e),
+            )
+
+
+# EOF

scitex/ui/_backends/_email.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-13 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/ui/_backends/_email.py
+
+"""Email notification backend."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from datetime import datetime
+from typing import Optional
+
+from ._types import BaseNotifyBackend, NotifyLevel, NotifyResult
+
+
+class EmailBackend(BaseNotifyBackend):
+    """Email notification via scitex.utils._email."""
+
+    name = "email"
+
+    def __init__(
+        self,
+        recipient: Optional[str] = None,
+        sender: Optional[str] = None,
+    ):
+        self.recipient = recipient or os.getenv("SCITEX_NOTIFY_EMAIL_TO")
+        self.sender = sender or os.getenv("SCITEX_NOTIFY_EMAIL_FROM")
+
+    def is_available(self) -> bool:
+        return bool(
+            os.getenv("SCITEX_SCHOLAR_EMAIL_NOREPLY")  # New name
+            or os.getenv("SCITEX_SCHOLAR_FROM_EMAIL_ADDRESS")  # Deprecated
+            or os.getenv("SCITEX_EMAIL_NOREPLY")  # Global
+            or os.getenv("SCITEX_EMAIL_AGENT")  # Fallback
+        ) and bool(
+            os.getenv("SCITEX_SCHOLAR_EMAIL_PASSWORD")  # New name
+            or os.getenv("SCITEX_SCHOLAR_FROM_EMAIL_PASSWORD")  # Deprecated
+            or os.getenv("SCITEX_EMAIL_PASSWORD")  # Fallback
+        )
+
+    async def send(
+        self,
+        message: str,
+        title: Optional[str] = None,
+        level: NotifyLevel = NotifyLevel.INFO,
+        **kwargs,
+    ) -> NotifyResult:
+        try:
+            from scitex.utils._notify import notify as email_notify
+
+            loop = asyncio.get_event_loop()
+            await loop.run_in_executor(
+                None,
+                lambda: email_notify(
+                    subject=title or f"[SciTeX] {level.value.upper()}",
+                    message=message,
+                    recipient_email=kwargs.get("recipient", self.recipient),
+                ),
+            )
+
+            return NotifyResult(
+                success=True,
+                backend=self.name,
+                message=message,
+                timestamp=datetime.now().isoformat(),
+            )
+        except Exception as e:
+            return NotifyResult(
+                success=False,
+                backend=self.name,
+                message=message,
+                timestamp=datetime.now().isoformat(),
+                error=str(e),
+            )
+
+
+# EOF

scitex/ui/_backends/_matplotlib.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-13 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/ui/_backends/_matplotlib.py
+
+"""Matplotlib visual notification backend."""
+
+from __future__ import annotations
+
+import asyncio
+from datetime import datetime
+from typing import Optional
+
+from ._types import BaseNotifyBackend, NotifyLevel, NotifyResult
+
+
+class MatplotlibBackend(BaseNotifyBackend):
+    """Visual notification via matplotlib popup window."""
+
+    name = "matplotlib"
+
+    def __init__(self, timeout: float = 5.0):
+        self.timeout = timeout
+
+    def is_available(self) -> bool:
+        try:
+            import matplotlib  # noqa: F401
+
+            return True
+        except ImportError:
+            return False
+
+    async def send(
+        self,
+        message: str,
+        title: Optional[str] = None,
+        level: NotifyLevel = NotifyLevel.INFO,
+        **kwargs,
+    ) -> NotifyResult:
+        try:
+            import matplotlib.pyplot as plt
+
+            # Color based on level
+            colors = {
+                NotifyLevel.INFO: "#2196F3",
+                NotifyLevel.WARNING: "#FF9800",
+                NotifyLevel.ERROR: "#F44336",
+                NotifyLevel.CRITICAL: "#9C27B0",
+            }
+            color = colors.get(level, "#2196F3")
+
+            # Create figure
+            fig, ax = plt.subplots(figsize=(6, 2))
+            ax.set_xlim(0, 1)
+            ax.set_ylim(0, 1)
+            ax.axis("off")
+
+            # Background
+            fig.patch.set_facecolor(color)
+
+            # Title and message
+            ax.text(
+                0.5,
+                0.7,
+                title or "SciTeX",
+                ha="center",
+                va="center",
+                fontsize=16,
+                fontweight="bold",
+                color="white",
+            )
+            ax.text(
+                0.5,
+                0.35,
+                message,
+                ha="center",
+                va="center",
+                fontsize=12,
+                color="white",
+                wrap=True,
+            )
+
+            # Show non-blocking
+            plt.ion()
+            plt.show(block=False)
+
+            # Force render
+            fig.canvas.draw()
+            fig.canvas.flush_events()
+
+            # Auto-close after timeout, keeping GUI responsive
+            timeout = kwargs.get("timeout", self.timeout)
+            elapsed = 0.0
+            interval = 0.1  # Check every 100ms
+            while elapsed < timeout:
+                await asyncio.sleep(interval)
+                fig.canvas.flush_events()
+                elapsed += interval
+
+            plt.close(fig)
+
+            return NotifyResult(
+                success=True,
+                backend=self.name,
+                message=message,
+                timestamp=datetime.now().isoformat(),
+                details={"timeout": timeout},
+            )
+        except Exception as e:
+            return NotifyResult(
+                success=False,
+                backend=self.name,
+                message=message,
+                timestamp=datetime.now().isoformat(),
+                error=str(e),
+            )
+
+
+# EOF

scitex/ui/_backends/_playwright.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-13 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/ui/_backends/_playwright.py
+
+"""Playwright browser notification backend."""
+
+from __future__ import annotations
+
+import asyncio
+from datetime import datetime
+from typing import Optional
+
+from ._types import BaseNotifyBackend, NotifyLevel, NotifyResult
+
+
+class PlaywrightBackend(BaseNotifyBackend):
+    """Browser notification via Playwright."""
+
+    name = "playwright"
+
+    def __init__(self, timeout: float = 5.0):
+        self.timeout = timeout
+
+    def is_available(self) -> bool:
+        try:
+            from playwright.async_api import async_playwright  # noqa: F401
+
+            return True
+        except ImportError:
+            return False
+
+    async def send(
+        self,
+        message: str,
+        title: Optional[str] = None,
+        level: NotifyLevel = NotifyLevel.INFO,
+        **kwargs,
+    ) -> NotifyResult:
+        try:
+            from playwright.async_api import async_playwright
+
+            # Color based on level
+            colors = {
+                NotifyLevel.INFO: "#2196F3",
+                NotifyLevel.WARNING: "#FF9800",
+                NotifyLevel.ERROR: "#F44336",
+                NotifyLevel.CRITICAL: "#9C27B0",
+            }
+            color = colors.get(level, "#2196F3")
+
+            # Escape HTML
+            title_safe = (title or "SciTeX").replace("<", "&lt;").replace(">", "&gt;")
+            message_safe = message.replace("<", "&lt;").replace(">", "&gt;")
+
+            html = f"""
+            <!DOCTYPE html>
+            <html>
+            <head>
+                <style>
+                    body {{
+                        margin: 0;
+                        padding: 20px;
+                        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+                        background: {color};
+                        color: white;
+                        display: flex;
+                        flex-direction: column;
+                        justify-content: center;
+                        height: calc(100vh - 40px);
+                    }}
+                    h1 {{ margin: 0 0 10px 0; font-size: 24px; }}
+                    p {{ margin: 0; font-size: 16px; opacity: 0.9; }}
+                </style>
+            </head>
+            <body>
+                <h1>{title_safe}</h1>
+                <p>{message_safe}</p>
+            </body>
+            </html>
+            """
+
+            async with async_playwright() as p:
+                browser = await p.chromium.launch(headless=False)
+                page = await browser.new_page()
+                await page.set_viewport_size({"width": 400, "height": 150})
+                await page.set_content(html)
+
+                timeout = kwargs.get("timeout", self.timeout)
+                await asyncio.sleep(timeout)
+                await browser.close()
+
+            return NotifyResult(
+                success=True,
+                backend=self.name,
+                message=message,
+                timestamp=datetime.now().isoformat(),
+                details={"timeout": timeout},
+            )
+        except Exception as e:
+            return NotifyResult(
+                success=False,
+                backend=self.name,
+                message=message,
+                timestamp=datetime.now().isoformat(),
+                error=str(e),
+            )
+
+
+# EOF

scitex/ui/_backends/_types.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-13 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/ui/_backends/_types.py
+
+"""Core types for notification backends."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional
+
+
+class NotifyLevel(Enum):
+    """Notification urgency levels."""
+
+    INFO = "info"
+    WARNING = "warning"
+    ERROR = "error"
+    CRITICAL = "critical"
+
+
+@dataclass
+class NotifyResult:
+    """Result of a notification attempt."""
+
+    success: bool
+    backend: str
+    message: str
+    timestamp: str
+    error: Optional[str] = None
+    details: Optional[dict] = None
+
+
+class BaseNotifyBackend(ABC):
+    """Base class for notification backends."""
+
+    name: str = "base"
+
+    @abstractmethod
+    async def send(
+        self,
+        message: str,
+        title: Optional[str] = None,
+        level: NotifyLevel = NotifyLevel.INFO,
+        **kwargs,
+    ) -> NotifyResult:
+        """Send a notification."""
+        pass
+
+    @abstractmethod
+    def is_available(self) -> bool:
+        """Check if this backend is available."""
+        pass
+
+
+# EOF

scitex/ui/_backends/_webhook.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-13 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/ui/_backends/_webhook.py
+
+"""Webhook notification backend for Slack, Discord, etc."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import urllib.request
+from datetime import datetime
+from typing import Optional
+
+from ._types import BaseNotifyBackend, NotifyLevel, NotifyResult
+
+
+class WebhookBackend(BaseNotifyBackend):
+    """Webhook notification for Slack, Discord, etc."""
+
+    name = "webhook"
+
+    def __init__(self, url: Optional[str] = None):
+        self.url = url or os.getenv("SCITEX_NOTIFY_WEBHOOK_URL")
+
+    def is_available(self) -> bool:
+        return bool(self.url)
+
+    async def send(
+        self,
+        message: str,
+        title: Optional[str] = None,
+        level: NotifyLevel = NotifyLevel.INFO,
+        **kwargs,
+    ) -> NotifyResult:
+        try:
+            url = kwargs.get("url", self.url)
+            if not url:
+                raise ValueError("No webhook URL configured")
+
+            # Format for Slack/Discord compatibility
+            payload = {
+                "text": f"*{title or 'SciTeX'}*\n{message}",
+                "content": f"**{title or 'SciTeX'}**\n{message}",
+            }
+
+            data = json.dumps(payload).encode("utf-8")
+            req = urllib.request.Request(
+                url,
+                data=data,
+                headers={"Content-Type": "application/json"},
+            )
+
+            loop = asyncio.get_event_loop()
+            await loop.run_in_executor(
+                None,
+                lambda: urllib.request.urlopen(req, timeout=10),
+            )
+
+            return NotifyResult(
+                success=True,
+                backend=self.name,
+                message=message,
+                timestamp=datetime.now().isoformat(),
+            )
+        except Exception as e:
+            return NotifyResult(
+                success=False,
+                backend=self.name,
+                message=message,
+                timestamp=datetime.now().isoformat(),
+                error=str(e),
+            )
+
+
+# EOF

scitex/ui/_backends.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-13 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/ui/_backends.py
+
+"""Re-export from _backends package for backward compatibility."""
+
+from ._backends import (
+    BACKENDS,
+    AudioBackend,
+    BaseNotifyBackend,
+    DesktopBackend,
+    EmailBackend,
+    MatplotlibBackend,
+    NotifyLevel,
+    NotifyResult,
+    PlaywrightBackend,
+    WebhookBackend,
+    available_backends,
+    get_backend,
+)
+
+__all__ = [
+    "NotifyLevel",
+    "NotifyResult",
+    "BaseNotifyBackend",
+    "AudioBackend",
+    "EmailBackend",
+    "DesktopBackend",
+    "WebhookBackend",
+    "MatplotlibBackend",
+    "PlaywrightBackend",
+    "BACKENDS",
+    "get_backend",
+    "available_backends",
+]
+
+# EOF