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

scitex/audio/_relay.py

@@ -0,0 +1,225 @@
+#!/usr/bin/env python3
+"""Audio relay client for remote TTS playback.
+
+Forwards speak requests to a remote audio server via HTTP.
+This allows agents running on remote machines (e.g., NAS) to play
+audio through the user's local speakers.
+
+Usage:
+    from scitex.audio._relay import RelayClient
+
+    # Connect to local relay server
+    client = RelayClient("http://localhost:31293")
+
+    # Speak through relay
+    client.speak("Hello from remote!")
+
+Environment Variables:
+    SCITEX_AUDIO_RELAY_URL: Relay server URL
+    SCITEX_AUDIO_RELAY_HOST: Relay server host (builds URL with port)
+    SCITEX_AUDIO_RELAY_PORT: Relay server port (default: 31293)
+"""
+
+import json
+import urllib.error
+import urllib.request
+from typing import Any, Dict, Optional
+
+from ._branding import DEFAULT_PORT, get_relay_url
+
+
+class RelayClient:
+    """HTTP client for audio relay server.
+
+    Forwards TTS requests to a remote server running the audio MCP
+    in HTTP mode. Enables remote agents to play audio locally.
+
+    Example:
+        >>> client = RelayClient("http://localhost:31293")
+        >>> client.speak("Hello!")
+        {'success': True, 'text': 'Hello!', ...}
+    """
+
+    def __init__(
+        self,
+        base_url: Optional[str] = None,
+        timeout: int = 30,
+    ):
+        """Initialize relay client.
+
+        Args:
+            base_url: Relay server URL. Auto-detects from env if None.
+            timeout: Request timeout in seconds.
+        """
+        self.base_url = (
+            base_url or get_relay_url() or f"http://localhost:{DEFAULT_PORT}"
+        ).rstrip("/")
+        self.timeout = timeout
+
+    def _request(
+        self,
+        endpoint: str,
+        data: Optional[Dict[str, Any]] = None,
+        method: str = "POST",
+    ) -> Dict[str, Any]:
+        """Make HTTP request to relay server."""
+        url = f"{self.base_url}{endpoint}"
+
+        try:
+            if data is not None:
+                req_data = json.dumps(data).encode("utf-8")
+                req = urllib.request.Request(url, data=req_data, method=method)
+                req.add_header("Content-Type", "application/json")
+            else:
+                req = urllib.request.Request(url, method=method)
+
+            req.add_header("Accept", "application/json")
+
+            with urllib.request.urlopen(req, timeout=self.timeout) as response:
+                return json.loads(response.read().decode("utf-8"))
+
+        except urllib.error.HTTPError as e:
+            raise ConnectionError(f"Relay request failed: {e.code} {e.reason}") from e
+        except urllib.error.URLError as e:
+            raise ConnectionError(
+                f"Cannot connect to relay at {self.base_url}: {e.reason}"
+            ) from e
+
+    def health(self) -> Dict[str, Any]:
+        """Check relay server health."""
+        try:
+            # Try MCP health endpoint
+            return self._request("/health", method="GET")
+        except Exception:
+            # Relay may not have /health, try simple request
+            return {"status": "unknown", "url": self.base_url}
+
+    def is_available(self) -> bool:
+        """Check if relay server is reachable."""
+        try:
+            self.health()
+            return True
+        except Exception:
+            return False
+
+    def speak(
+        self,
+        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,
+    ) -> Dict[str, Any]:
+        """Forward speak request to relay server.
+
+        Args:
+            text: Text to speak
+            backend: TTS backend (auto if None)
+            voice: Voice/language
+            rate: Speech rate (pyttsx3)
+            speed: Speed multiplier (gtts)
+            play: Play audio
+            save: Save audio file
+            fallback: Try fallback backends
+            agent_id: Agent identifier
+
+        Returns
+        -------
+            Response dict with success status
+        """
+        data = {
+            "text": text,
+            "backend": backend,
+            "voice": voice,
+            "rate": rate,
+            "speed": speed,
+            "play": play,
+            "save": save,
+            "fallback": fallback,
+            "agent_id": agent_id,
+        }
+
+        # Remove None values
+        data = {k: v for k, v in data.items() if v is not None}
+
+        return self._request("/speak", data)
+
+    def list_backends(self) -> Dict[str, Any]:
+        """Get available backends from relay server."""
+        return self._request("/list_backends", method="GET")
+
+
+# Module-level client singleton
+_client: Optional[RelayClient] = None
+
+
+def get_relay_client(base_url: Optional[str] = None) -> RelayClient:
+    """Get or create relay client singleton."""
+    global _client
+    if _client is None or (base_url and _client.base_url != base_url):
+        _client = RelayClient(base_url)
+    return _client
+
+
+def reset_relay_client() -> None:
+    """Reset relay client singleton."""
+    global _client
+    _client = None
+
+
+def relay_speak(
+    text: str,
+    backend: Optional[str] = None,
+    voice: Optional[str] = None,
+    rate: int = 150,
+    speed: float = 1.5,
+    play: bool = True,
+    **kwargs,
+) -> Dict[str, Any]:
+    """Convenience function to speak via relay.
+
+    Args:
+        text: Text to speak
+        backend: TTS backend
+        voice: Voice/language
+        rate: Speech rate
+        speed: Speed multiplier
+        play: Play audio
+        **kwargs: Additional options
+
+    Returns
+    -------
+        Response dict
+    """
+    client = get_relay_client()
+    return client.speak(
+        text=text,
+        backend=backend,
+        voice=voice,
+        rate=rate,
+        speed=speed,
+        play=play,
+        **kwargs,
+    )
+
+
+def is_relay_available() -> bool:
+    """Check if relay server is available."""
+    try:
+        client = get_relay_client()
+        return client.is_available()
+    except Exception:
+        return False
+
+
+__all__ = [
+    "RelayClient",
+    "get_relay_client",
+    "reset_relay_client",
+    "relay_speak",
+    "is_relay_available",
+]

scitex/audio/engines/elevenlabs_engine.py

@@ -38,6 +38,10 @@ class ElevenLabsTTS(BaseTTS):
         "sam": "yoZ06aMxZJJ28mfd3POQ",
     }
 
+    # ElevenLabs API speed limits
+    MIN_SPEED = 0.7
+    MAX_SPEED = 1.2
+
     def __init__(
         self,
         api_key: Optional[str] = None,
@@ -58,7 +62,8 @@ class ElevenLabsTTS(BaseTTS):
         self.model_id = model_id
         self.stability = stability
         self.similarity_boost = similarity_boost
-        self.speed = speed
+        # Clamp speed to ElevenLabs API limits (0.7-1.2)
+        self.speed = max(self.MIN_SPEED, min(self.MAX_SPEED, speed))
         self._client = None
 
     @property

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