scitex 2.14.0__py3-none-any.whl → 2.15.2__py3-none-any.whl

scitex/audio/mcp_server.py

@@ -10,13 +10,13 @@ Enables remote agents to connect and play audio on local speakers.
 
 Usage:
     scitex audio serve                           # stdio (default)
-    scitex audio serve -t http --port 8084       # HTTP transport
-    scitex audio serve -t sse --port 8084        # SSE transport
+    scitex audio serve -t http --port 31293      # HTTP transport
+    scitex audio serve -t sse --port 31293       # SSE transport
 
 For remote audio:
-    1. Run locally:  scitex audio serve -t http --port 8084
-    2. SSH tunnel:   ssh -R 8084:localhost:8084 remote-host
-    3. Remote agent connects to http://localhost:8084
+    1. Run locally:  scitex audio serve -t http --port 31293
+    2. SSH tunnel:   ssh -R 31293:localhost:31293 remote-host
+    3. Remote agent connects to http://localhost:31293
 """
 
 from __future__ import annotations
@@ -35,16 +35,19 @@ except ImportError:
     FASTMCP_AVAILABLE = False
     FastMCP = None  # type: ignore
 
-__all__ = ["mcp", "run_server", "main", "FASTMCP_AVAILABLE"]
+__all__ = ["mcp", "run_server", "run_relay_server", "main", "FASTMCP_AVAILABLE"]
+
+# Import branding
+from ._branding import (
+    get_mcp_instructions,
+    get_mcp_server_name,
+)
 
 # Initialize MCP server
 if FASTMCP_AVAILABLE:
     mcp = FastMCP(
-        name="scitex-audio",
-        instructions=(
-            "Text-to-Speech server with multiple backends (pyttsx3, gtts, elevenlabs). "
-            "Use speak() to convert text to speech. Supports cross-process FIFO queuing."
-        ),
+        name=get_mcp_server_name(),
+        instructions=get_mcp_instructions(),
     )
 else:
     mcp = None
@@ -61,6 +64,16 @@ def _get_audio_dir() -> Path:
 
 
 if FASTMCP_AVAILABLE:
+    import asyncio
+
+    def _run_async(coro):
+        """Run async handler synchronously for FastMCP tools."""
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+        return loop.run_until_complete(coro)
 
     @mcp.tool()
     def speak(
@@ -74,72 +87,92 @@ if FASTMCP_AVAILABLE:
         fallback: bool = True,
         agent_id: Optional[str] = None,
     ) -> str:
-        """Convert text to speech with fallback (pyttsx3 -> gtts -> elevenlabs).
+        """[audio] Convert text to speech with fallback (pyttsx3 -> gtts -> elevenlabs).
 
-        Args:
-            text: Text to convert to speech
-            backend: TTS backend (auto-selects with fallback if not specified)
-            voice: Voice/language (gtts: 'en','fr'; elevenlabs: 'rachel','adam')
-            rate: Speech rate in words per minute (pyttsx3 only, default 150)
-            speed: Speed multiplier for gtts (1.0=normal, 1.5=faster, 0.7=slower)
-            play: Play audio after generation (default True)
-            save: Save audio to file (default False)
-            fallback: Try next backend on failure (default True)
-            agent_id: Optional identifier for the agent making the request
+        NOTE: Plays on SERVER. For remote use, see speak_relay.
+        """
+        return audio_speak_local(
+            text=text, backend=backend, voice=voice, rate=rate,
+            speed=speed, play=play, save=save, fallback=fallback,
+            agent_id=agent_id,
+        )
 
-        Returns
-        -------
-            JSON string with success status and details
+    @mcp.tool()
+    def audio_speak_local(
+        text: str,
+        backend: Optional[str] = None,
+        voice: Optional[str] = None,
+        rate: int = 150,
+        speed: float = 1.5,
+        play: bool = True,
+        save: bool = False,
+        fallback: bool = True,
+        agent_id: Optional[str] = None,
+    ) -> str:
+        """[audio] Convert text to speech on the LOCAL/SERVER machine.
 
-        Examples
-        --------
-            speak("Hello world")
-            speak("Bonjour", backend="gtts", voice="fr")
-            speak("Fast speech", rate=200)
-        """
-        from . import speak as tts_speak
-        from ._cross_process_lock import AudioPlaybackLock
+        Use when running Claude Code directly on your local machine.
+        Audio plays where MCP server runs.
 
-        output_path = None
-        if save:
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            output_path = str(_get_audio_dir() / f"tts_{timestamp}.mp3")
+        Args:
+            text: Text to convert to speech
+            backend: TTS backend (pyttsx3, gtts, elevenlabs)
+            voice: Voice/language
+            rate: Speech rate (pyttsx3 only)
+            speed: Speed multiplier (gtts)
+            play: Play audio (default True)
+            save: Save to file (default False)
+            fallback: Try next backend on failure
+            agent_id: Agent identifier
+        """
+        from ._mcp.speak_handlers import speak_local_handler
 
-        try:
-            # Acquire cross-process lock to ensure FIFO across all instances
-            lock = AudioPlaybackLock()
-            lock.acquire(timeout=120.0)
-            try:
-                tts_speak(
-                    text=text,
-                    backend=backend,
-                    voice=voice,
-                    play=play,
-                    output_path=output_path,
-                    fallback=fallback,
-                    rate=rate,
-                    speed=speed,
-                )
-            finally:
-                lock.release()
+        result = _run_async(speak_local_handler(
+            text=text, backend=backend, voice=voice, rate=rate,
+            speed=speed, play=play, save=save, fallback=fallback,
+            agent_id=agent_id,
+        ))
+        return json.dumps(result, indent=2)
 
-            response = {
-                "success": True,
-                "text": text,
-                "backend": backend,
-                "voice": voice,
-                "played": play,
-                "agent_id": agent_id,
-                "timestamp": datetime.now().isoformat(),
-            }
+    @mcp.tool()
+    def audio_speak_relay(
+        text: str,
+        backend: Optional[str] = None,
+        voice: Optional[str] = None,
+        rate: int = 150,
+        speed: float = 1.5,
+        play: bool = True,
+        save: bool = False,
+        fallback: bool = True,
+        agent_id: Optional[str] = None,
+    ) -> str:
+        """[audio] Convert text to speech via RELAY server (remote playback).
 
-            if output_path:
-                response["saved_to"] = output_path
+        Use when running on remote server (e.g., NAS) and want audio
+        on your local machine. REQUIRES relay server running locally.
 
-            return json.dumps(response, indent=2)
+        Args:
+            text: Text to convert to speech
+            backend: TTS backend (pyttsx3, gtts, elevenlabs)
+            voice: Voice/language
+            rate: Speech rate (pyttsx3 only)
+            speed: Speed multiplier (gtts)
+            play: Play audio (default True)
+            save: Save to file (default False)
+            fallback: Try next backend on failure
+            agent_id: Agent identifier
+
+        Returns:
+            Success with playback info, or error with setup instructions
+        """
+        from ._mcp.speak_handlers import speak_relay_handler
 
-        except Exception as e:
-            return json.dumps({"success": False, "error": str(e)}, indent=2)
+        result = _run_async(speak_relay_handler(
+            text=text, backend=backend, voice=voice, rate=rate,
+            speed=speed, play=play, save=save, fallback=fallback,
+            agent_id=agent_id,
+        ))
+        return json.dumps(result, indent=2)
 
     @mcp.tool()
     def list_backends() -> str:
@@ -244,21 +277,28 @@ if FASTMCP_AVAILABLE:
 
 def run_server(
     transport: str = "stdio",
-    host: str = "0.0.0.0",
-    port: int = 8084,
+    host: Optional[str] = None,
+    port: Optional[int] = None,
 ) -> None:
     """Run the MCP server.
 
     Args:
         transport: Transport protocol ("stdio", "sse", or "http")
-        host: Host for HTTP/SSE transport
-        port: Port for HTTP/SSE transport
+        host: Host for HTTP/SSE transport (default from branding)
+        port: Port for HTTP/SSE transport (default from branding)
     """
+    from ._branding import DEFAULT_HOST, DEFAULT_PORT
+
+    host = host or DEFAULT_HOST
+    port = port or DEFAULT_PORT
+
     if not FASTMCP_AVAILABLE:
         import sys
 
+        from ._branding import BRAND_NAME
+
         print("=" * 60)
-        print("MCP Server 'scitex-audio' requires the 'fastmcp' package.")
+        print(f"MCP Server '{BRAND_NAME}' requires the 'fastmcp' package.")
         print()
         print("Install with:")
         print("  pip install fastmcp")
@@ -268,19 +308,132 @@ def run_server(
         print("=" * 60)
         sys.exit(1)
 
+    from ._branding import BRAND_NAME
+
     if transport == "stdio":
         mcp.run(transport="stdio")
     elif transport == "sse":
-        print(f"Starting scitex-audio MCP server (SSE) on {host}:{port}")
+        print(f"Starting {BRAND_NAME} MCP server (SSE) on {host}:{port}")
         mcp.run(transport="sse", host=host, port=port)
     elif transport == "http":
-        print(f"Starting scitex-audio MCP server (HTTP) on {host}:{port}")
+        print(f"Starting {BRAND_NAME} MCP server (HTTP) on {host}:{port}")
         print(f"Connect via: http://{host}:{port}/mcp")
         mcp.run(transport="streamable-http", host=host, port=port)
     else:
         raise ValueError(f"Unknown transport: {transport}")
 
 
+def run_relay_server(host: Optional[str] = None, port: Optional[int] = None) -> None:
+    """Run HTTP relay server for remote audio playback.
+
+    This exposes simple REST endpoints that remote agents can connect to.
+    Unlike the MCP server, this uses standard HTTP POST/GET.
+
+    Endpoints:
+        POST /speak - Speak text
+        GET /health - Health check
+        GET /list_backends - List available backends
+    """
+    from ._branding import BRAND_NAME, DEFAULT_HOST, DEFAULT_PORT
+
+    host = host or DEFAULT_HOST
+    port = port or DEFAULT_PORT
+
+    try:
+        from http.server import BaseHTTPRequestHandler, HTTPServer
+    except ImportError as e:
+        raise RuntimeError(f"HTTP server not available: {e}") from e
+
+    class RelayHandler(BaseHTTPRequestHandler):
+        """HTTP handler for audio relay requests."""
+
+        def _send_json(self, data: dict, status: int = 200) -> None:
+            """Send JSON response."""
+            import json
+
+            body = json.dumps(data, indent=2).encode("utf-8")
+            self.send_response(status)
+            self.send_header("Content-Type", "application/json")
+            self.send_header("Content-Length", str(len(body)))
+            self.send_header("Access-Control-Allow-Origin", "*")
+            self.end_headers()
+            self.wfile.write(body)
+
+        def do_OPTIONS(self) -> None:
+            """Handle CORS preflight."""
+            self.send_response(200)
+            self.send_header("Access-Control-Allow-Origin", "*")
+            self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+            self.send_header("Access-Control-Allow-Headers", "Content-Type")
+            self.end_headers()
+
+        def do_GET(self) -> None:
+            """Handle GET requests."""
+            import json
+
+            if self.path == "/health":
+                self._send_json({"status": "healthy", "server": BRAND_NAME})
+            elif self.path == "/list_backends":
+                result = list_backends()
+                self._send_json(json.loads(result))
+            else:
+                self._send_json({"error": "Not found"}, 404)
+
+        def do_POST(self) -> None:
+            """Handle POST requests."""
+            import json
+
+            if self.path == "/speak":
+                content_length = int(self.headers.get("Content-Length", 0))
+                body = self.rfile.read(content_length)
+                try:
+                    data = json.loads(body.decode("utf-8"))
+                    # Import speak directly from audio module (not MCP tool)
+                    from . import speak as tts_speak
+                    from ._cross_process_lock import AudioPlaybackLock
+
+                    # Acquire lock for FIFO
+                    lock = AudioPlaybackLock()
+                    lock.acquire(timeout=120.0)
+                    try:
+                        tts_speak(
+                            text=data.get("text", ""),
+                            backend=data.get("backend"),
+                            voice=data.get("voice"),
+                            rate=data.get("rate", 150),
+                            speed=data.get("speed", 1.5),
+                            play=data.get("play", True),
+                            fallback=data.get("fallback", True),
+                            mode="local",
+                        )
+                    finally:
+                        lock.release()
+
+                    self._send_json({
+                        "success": True,
+                        "text": data.get("text", ""),
+                        "played": True,
+                        "timestamp": datetime.now().isoformat(),
+                    })
+                except Exception as e:
+                    self._send_json({"success": False, "error": str(e)}, 500)
+            else:
+                self._send_json({"error": "Not found"}, 404)
+
+        def log_message(self, format: str, *args) -> None:
+            """Suppress default logging."""
+            pass
+
+    print(f"Starting {BRAND_NAME} relay server on {host}:{port}")
+    print("Endpoints: POST /speak, GET /health, GET /list_backends")
+    server = HTTPServer((host, port), RelayHandler)
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        print("\nShutting down relay server")
+        server.shutdown()
+
+
 def main():
     """Entry point for scitex-audio-mcp command."""
     run_server(transport="stdio")

scitex/canvas/README.md

@@ -1,7 +1,7 @@
 <!-- ---
 !-- Timestamp: 2025-12-08
 !-- Author: ywatanabe
-!-- File: /home/ywatanabe/proj/scitex-code/src/scitex/vis/README.md
+!-- File: /home/ywatanabe/proj/scitex-python/src/scitex/vis/README.md
 !-- --- -->
 
 # scitex.vis - Canvas-Based Figure Composition

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