scitex 2.15.5__py3-none-any.whl → 2.16.1__py3-none-any.whl

scitex/audio/engines/_pyttsx3_engine.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-12-11 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/audio/engines/pyttsx3_engine.py
+# ----------------------------------------
+
+"""
+System TTS backend using pyttsx3 - Offline, uses system voices.
+
+Requirements:
+    - pip install pyttsx3
+    - Linux: sudo apt install espeak-ng libespeak1
+    - Windows: Uses SAPI5 (built-in)
+    - macOS: Uses NSSpeechSynthesizer (built-in)
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import List, Optional
+
+from ._base import BaseTTS
+
+__all__ = ["SystemTTS"]
+
+
+class SystemTTS(BaseTTS):
+    """System TTS backend using pyttsx3.
+
+    Works offline using system's built-in TTS engine.
+    Quality varies by platform and available voices.
+
+    Platforms:
+        - Linux: espeak/espeak-ng
+        - Windows: SAPI5
+        - macOS: NSSpeechSynthesizer
+    """
+
+    def __init__(
+        self,
+        rate: int = 150,  # Words per minute
+        volume: float = 1.0,  # 0.0 to 1.0
+        voice: Optional[str] = None,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.rate = rate
+        self.volume = volume
+        self.voice = voice
+        self._engine = None
+
+    @property
+    def name(self) -> str:
+        return "pyttsx3"
+
+    @property
+    def engine(self):
+        """Lazy-load pyttsx3 engine."""
+        if self._engine is None:
+            try:
+                import pyttsx3
+
+                self._engine = pyttsx3.init()
+                self._engine.setProperty("rate", self.rate)
+                self._engine.setProperty("volume", self.volume)
+
+                if self.voice:
+                    self._set_voice(self.voice)
+            except ImportError:
+                raise ImportError(
+                    "pyttsx3 package not installed. "
+                    "Install with: pip install pyttsx3\n"
+                    "Linux also requires: sudo apt install espeak-ng libespeak1"
+                )
+            except RuntimeError as e:
+                if "eSpeak" in str(e):
+                    raise RuntimeError(
+                        "espeak not installed. "
+                        "Install with: sudo apt install espeak-ng libespeak1"
+                    )
+                raise
+        return self._engine
+
+    def _set_voice(self, voice_name: str):
+        """Set voice by name or ID."""
+        voices = self.engine.getProperty("voices")
+        for v in voices:
+            if voice_name.lower() in v.name.lower() or voice_name == v.id:
+                self.engine.setProperty("voice", v.id)
+                return
+        # If not found, keep default
+
+    def synthesize(self, text: str, output_path: str) -> Path:
+        """Synthesize text using system TTS."""
+        # Set voice if specified in config
+        voice = self.config.get("voice")
+        if voice:
+            self._set_voice(voice)
+
+        out_path = Path(output_path)
+
+        # pyttsx3 can save to file
+        self.engine.save_to_file(text, str(out_path))
+        self.engine.runAndWait()
+
+        return out_path
+
+    def speak_direct(self, text: str):
+        """Speak directly without saving to file (faster)."""
+        voice = self.config.get("voice")
+        if voice:
+            self._set_voice(voice)
+
+        self.engine.say(text)
+        self.engine.runAndWait()
+
+    def get_voices(self) -> List[dict]:
+        """Get available system voices."""
+        voices = self.engine.getProperty("voices")
+        return [
+            {
+                "name": v.name,
+                "id": v.id,
+                "type": "system",
+                "languages": getattr(v, "languages", []),
+            }
+            for v in voices
+        ]
+
+
+# EOF

scitex/audio/mcp_server.py

@@ -76,7 +76,7 @@ if FASTMCP_AVAILABLE:
         return loop.run_until_complete(coro)
 
     @mcp.tool()
-    def speak(
+    def audio_speak(
         text: str,
         backend: Optional[str] = None,
         voice: Optional[str] = None,
@@ -86,93 +86,118 @@ if FASTMCP_AVAILABLE:
         save: bool = False,
         fallback: bool = True,
         agent_id: Optional[str] = None,
+        signature: bool = False,
     ) -> str:
         """[audio] Convert text to speech with fallback (pyttsx3 -> gtts -> elevenlabs).
 
-        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,
-        )
+        Smart routing: Automatically uses relay when local audio unavailable.
 
-    @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.
+        Routing logic (mode=auto, default):
+        - If local audio sink is SUSPENDED and relay available -> uses relay
+        - If local audio available -> uses local
+        - If neither available -> returns error with instructions
 
-        Use when running Claude Code directly on your local machine.
-        Audio plays where MCP server runs.
+        Environment variables:
+        - SCITEX_AUDIO_MODE: 'local', 'remote', or 'auto' (default: auto)
+        - SCITEX_AUDIO_RELAY_URL: Relay server URL for remote playback
 
         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)
+            speed: Speed multiplier for gtts (default 1.5)
             play: Play audio (default True)
             save: Save to file (default False)
             fallback: Try next backend on failure
-            agent_id: Agent identifier
+            agent_id: Agent identifier for tracking
+            signature: Prepend hostname/project/branch to text
         """
-        from ._mcp.speak_handlers import speak_local_handler
-
-        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)
+        from ._cross_process_lock import AudioPlaybackLock
+        from ._speak import speak as tts_speak
 
-    @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).
-
-        Use when running on remote server (e.g., NAS) and want audio
-        on your local machine. REQUIRES relay server running locally.
-
-        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
+        try:
+            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")
+
+            # Prepend signature if requested
+            final_text = text
+            sig = None
+            if signature:
+                import os
+                import socket
+                import subprocess
+
+                hostname = socket.gethostname()
+                cwd = os.getcwd()
+                project = os.path.basename(cwd)
+                branch = None
+                try:
+                    result = subprocess.run(
+                        ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+                        capture_output=True, text=True, cwd=cwd, timeout=5,
+                    )
+                    if result.returncode == 0:
+                        branch = result.stdout.strip()
+                except Exception:
+                    pass
+                parts = [f"Hostname: {hostname}", f"Project: {project}"]
+                if branch:
+                    parts.append(f"Branch: {branch}")
+                sig = ". ".join(parts) + ". "
+                final_text = sig + text
+
+            # Acquire cross-process lock for FIFO audio playback
+            lock = AudioPlaybackLock()
+            lock.acquire(timeout=120.0)
+            try:
+                speak_result = tts_speak(
+                    text=final_text,
+                    backend=backend,
+                    voice=voice,
+                    rate=rate,
+                    speed=speed,
+                    play=play,
+                    output_path=output_path,
+                    fallback=fallback,
+                    # mode=None uses SCITEX_AUDIO_MODE env (default: auto)
+                )
+            finally:
+                lock.release()
+
+            result = {
+                "success": speak_result.get("success", False),
+                "text": text,
+                "backend": speak_result.get("backend", backend),
+                "played": speak_result.get("played", False),
+                "play_requested": play,
+                "mode": speak_result.get("mode", "unknown"),
+                "agent_id": agent_id,
+                "timestamp": datetime.now().isoformat(),
+            }
+
+            if signature:
+                result["signature"] = sig
+                result["full_text"] = final_text
+            if speak_result.get("path"):
+                result["path"] = str(speak_result["path"])
+            if speak_result.get("error"):
+                result["error"] = speak_result["error"]
+            if speak_result.get("routing"):
+                result["routing"] = speak_result["routing"]
+            if speak_result.get("local_state"):
+                result["local_state"] = speak_result["local_state"]
+
+            return json.dumps(result, 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)
+        except Exception as e:
+            return json.dumps({
+                "success": False,
+                "error": str(e),
+                "text": text,
+            }, indent=2)
 
     @mcp.tool()
     def list_backends() -> str:
@@ -256,8 +281,8 @@ if FASTMCP_AVAILABLE:
             else:
                 text = f"Working in {dir_name}"
 
-            # Speak the announcement using the speak tool
-            speak_result = speak(text=text)
+            # Speak the announcement using the unified audio_speak tool
+            speak_result = audio_speak(text=text)
 
             return json.dumps(
                 {

scitex/bridge/_stats_plt.py

@@ -210,7 +210,7 @@ def _parse_stat_annotation(text: str) -> Optional[StatResult]:
 
     def _create_stat_dict(test_type, statistic_name, statistic_value, p_value):
         """Create a simple stat result dict."""
-        from scitex.stats.utils import p2stars
+        from scitex.stats._utils import p2stars
 
         return {
             "test_type": test_type,

scitex/capture/__init__.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 """
 scitex.capture - AI's Camera
 A lightweight, intuitive screen capture library optimized for WSL and Windows.
@@ -27,18 +26,18 @@ Usage:
     capture.stop()
 """
 
-from .utils import capture, start_monitor, stop_monitor
+from .capture import CaptureManager as _CaptureManager  # Internal class
 from .gif import (
-    create_gif_from_session,
     create_gif_from_files,
-    create_gif_from_pattern,
     create_gif_from_latest_session,
+    create_gif_from_pattern,
+    create_gif_from_session,
 )
 from .session import session
-from .capture import CaptureManager
+from .utils import capture, start_monitor, stop_monitor
 
 # Global manager for monitor enumeration
-_manager = CaptureManager()
+_manager = _CaptureManager()
 
 
 def get_info():

scitex/cli/__init__.py

@@ -56,4 +56,61 @@ def print_help_recursive(ctx, group: click.Group) -> None:
                         click.echo(sub_cmd.get_help(sub_sub_ctx))
 
 
-__all__ = ["cli", "print_help_recursive"]
+def format_python_signature(func, multiline: bool = True, indent: str = "  ") -> tuple:
+    """Format Python function signature with colors matching mcp list-tools.
+
+    Returns (name_colored, signature_colored)
+    """
+    import inspect
+
+    try:
+        sig = inspect.signature(func)
+    except (ValueError, TypeError):
+        return click.style(func.__name__, fg="green", bold=True), ""
+
+    params = []
+    for name, param in sig.parameters.items():
+        # Get type annotation
+        if param.annotation != inspect.Parameter.empty:
+            ann = param.annotation
+            type_str = ann.__name__ if hasattr(ann, "__name__") else str(ann)
+            type_str = type_str.replace("typing.", "")
+        else:
+            type_str = None
+
+        # Get default value
+        if param.default != inspect.Parameter.empty:
+            default = param.default
+            def_str = repr(default) if len(repr(default)) < 20 else "..."
+            if type_str:
+                p = f"{click.style(name, fg='white', bold=True)}: {click.style(type_str, fg='cyan')} = {click.style(def_str, fg='yellow')}"
+            else:
+                p = f"{click.style(name, fg='white', bold=True)} = {click.style(def_str, fg='yellow')}"
+        else:
+            if type_str:
+                p = f"{click.style(name, fg='white', bold=True)}: {click.style(type_str, fg='cyan')}"
+            else:
+                p = click.style(name, fg="white", bold=True)
+        params.append(p)
+
+    # Return type
+    ret_str = ""
+    if sig.return_annotation != inspect.Parameter.empty:
+        ret = sig.return_annotation
+        ret_name = ret.__name__ if hasattr(ret, "__name__") else str(ret)
+        ret_name = ret_name.replace("typing.", "")
+        ret_str = f" -> {click.style(ret_name, fg='magenta')}"
+
+    name_s = click.style(func.__name__, fg="green", bold=True)
+
+    if multiline and len(params) > 2:
+        param_indent = indent + "    "
+        params_str = ",\n".join(f"{param_indent}{p}" for p in params)
+        sig_s = f"(\n{params_str}\n{indent}){ret_str}"
+    else:
+        sig_s = f"({', '.join(params)}){ret_str}"
+
+    return name_s, sig_s
+
+
+__all__ = ["cli", "print_help_recursive", "format_python_signature"]

scitex/cli/audio.py

@@ -70,6 +70,13 @@ def speak(text, backend, voice, output, no_play, rate, speed, no_fallback):
       scitex audio speak "Fast speech" --backend pyttsx3 --rate 200
       scitex audio speak "Slow speech" --backend gtts --speed 0.8
     """
+    import logging
+    import warnings
+
+    # Suppress noisy warnings
+    warnings.filterwarnings("ignore", category=DeprecationWarning)
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+
     try:
         from scitex.audio import speak as tts_speak
 
@@ -92,10 +99,17 @@ def speak(text, backend, voice, output, no_play, rate, speed, no_fallback):
 
         result = tts_speak(**kwargs)
 
-        if output and result:
-            click.secho(f"Audio saved: {result}", fg="green")
-        elif not no_play:
-            click.secho("Speech completed", fg="green")
+        if output and result.get("path"):
+            click.secho(f"Audio saved: {result['path']}", fg="green")
+
+        if not no_play:
+            if result.get("played"):
+                click.secho("Speech completed (audio played)", fg="green")
+            else:
+                click.secho(
+                    "Warning: Audio generated but playback failed (no speaker?)",
+                    fg="yellow",
+                )
 
     except Exception as e:
         click.secho(f"Error: {e}", fg="red", err=True)
@@ -368,26 +382,24 @@ def doctor():
 
 
 @mcp.command("list-tools")
-def list_tools():
-    """
-    List available MCP tools
+@click.option(
+    "-v", "--verbose", count=True, help="Verbosity: -v sig, -vv +desc, -vvv full"
+)
+@click.option("-c", "--compact", is_flag=True, help="Compact signatures (single line)")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+@click.pass_context
+def list_tools(ctx, verbose, compact, as_json):
+    """List available audio MCP tools (delegates to main MCP with -m audio)."""
+    from scitex.cli.mcp import list_tools as main_list_tools
 
-    \b
-    Example:
-      scitex audio mcp list-tools
-    """
-    click.secho("Audio MCP Tools", fg="cyan", bold=True)
-    click.echo()
-    tools = [
-        ("audio_speak", "Convert text to speech and play audio"),
-        ("audio_generate_audio", "Generate audio file without playing"),
-        ("audio_list_backends", "List available TTS backends"),
-        ("audio_list_voices", "List available voices for a backend"),
-        ("audio_play_audio", "Play an audio file"),
-        ("audio_check_audio_status", "Check audio system status"),
-    ]
-    for name, desc in tools:
-        click.echo(f"  {name}: {desc}")
+    # Invoke main list-tools with audio module filter
+    ctx.invoke(
+        main_list_tools,
+        verbose=verbose,
+        compact=compact,
+        module="audio",
+        as_json=as_json,
+    )
 
 
 @audio.command()
@@ -446,5 +458,23 @@ def relay(host, port):
         sys.exit(1)
 
 
+@audio.command("list-python-apis")
+@click.option("-v", "--verbose", count=True, help="Verbosity: -v +doc, -vv full doc")
+@click.option("-d", "--max-depth", type=int, default=5, help="Max recursion depth")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+@click.pass_context
+def list_python_apis(ctx, verbose, max_depth, as_json):
+    """List Python APIs (alias for: scitex introspect api scitex.audio)."""
+    from scitex.cli.introspect import api
+
+    ctx.invoke(
+        api,
+        dotted_path="scitex.audio",
+        verbose=verbose,
+        max_depth=max_depth,
+        as_json=as_json,
+    )
+
+
 if __name__ == "__main__":
     audio()

scitex/cli/capture.py

@@ -434,5 +434,23 @@ def list_tools():
         click.echo(f"  {name}: {desc}")
 
 
+@capture.command("list-python-apis")
+@click.option("-v", "--verbose", count=True, help="Verbosity: -v +doc, -vv full doc")
+@click.option("-d", "--max-depth", type=int, default=5, help="Max recursion depth")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+@click.pass_context
+def list_python_apis(ctx, verbose, max_depth, as_json):
+    """List Python APIs (alias for: scitex introspect api scitex.capture)."""
+    from scitex.cli.introspect import api
+
+    ctx.invoke(
+        api,
+        dotted_path="scitex.capture",
+        verbose=verbose,
+        max_depth=max_depth,
+        as_json=as_json,
+    )
+
+
 if __name__ == "__main__":
     capture()

scitex/cli/dataset.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""
+SciTeX Dataset CLI - Thin wrapper delegating to scitex-dataset package.
+
+All commands are delegated to scitex-dataset CLI for maintainability.
+"""
+
+import subprocess
+import sys
+
+import click
+
+# Check if scitex-dataset package is available
+try:
+    import scitex_dataset  # noqa: F401
+
+    HAS_DATASET_PKG = True
+except ImportError:
+    HAS_DATASET_PKG = False
+
+
+def _require_dataset_pkg():
+    """Check if scitex-dataset package is available."""
+    if not HAS_DATASET_PKG:
+        click.secho(
+            "scitex-dataset package not installed. "
+            "Install with: pip install scitex-dataset",
+            fg="red",
+            err=True,
+        )
+        sys.exit(1)
+
+
+@click.command(
+    context_settings={
+        "help_option_names": ["-h", "--help"],
+        "ignore_unknown_options": True,
+        "allow_extra_args": True,
+        "allow_interspersed_args": False,
+    },
+)
+@click.argument("args", nargs=-1, type=click.UNPROCESSED)
+@click.pass_context
+def dataset(ctx, args):
+    r"""
+    Scientific dataset discovery (delegates to scitex-dataset).
+
+    \b
+    Commands (from scitex-dataset):
+      openneuro   Fetch datasets from OpenNeuro (BIDS neuroimaging)
+      dandi       Fetch datasets from DANDI Archive (NWB)
+      physionet   Fetch datasets from PhysioNet (EEG/ECG)
+      db          Local database for fast searching
+      mcp         MCP server commands
+
+    \b
+    Examples:
+      scitex dataset openneuro -n 100 -o datasets.json
+      scitex dataset dandi -v
+      scitex dataset db build
+      scitex dataset db search "alzheimer EEG"
+      scitex dataset mcp list-tools
+
+    \b
+    For full help:
+      scitex dataset --help
+      scitex-dataset --help
+    """
+    _require_dataset_pkg()
+
+    # Delegate to scitex-dataset CLI
+    cmd = ["scitex-dataset"] + list(args)
+    sys.exit(subprocess.call(cmd))
+
+
+# EOF