scitex 2.8.1__py3-none-any.whl → 2.10.0__py3-none-any.whl

scitex/ai/_gen_ai/_Perplexity.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Time-stamp: "2024-11-11 04:11:10 (ywatanabe)"
 # File: ./scitex_repo/src/scitex/ai/_gen_ai/_Perplexity.py
 
@@ -45,6 +44,12 @@ class Perplexity(BaseGenAI):
         chat_history: Optional[List[Dict[str, str]]] = None,
         max_tokens: Optional[int] = None,  # Added parameter
     ) -> None:
+        # Validate API key
+        if not api_key:
+            api_key = os.getenv("PERPLEXITY_API_KEY", "")
+            if not api_key:
+                raise ValueError("PERPLEXITY_API_KEY environment variable not set")
+
         # Set max_tokens based on model if not provided
         if max_tokens is None:
             max_tokens = 128_000 if "128k" in model else 32_000
@@ -54,6 +59,7 @@ class Perplexity(BaseGenAI):
             model=model,
             api_key=api_key,
             stream=stream,
+            seed=seed,
             n_keep=n_keep,
             temperature=temperature,
             provider="Perplexity",
@@ -61,6 +67,11 @@ class Perplexity(BaseGenAI):
             max_tokens=max_tokens,
         )
 
+    @property
+    def chat_history(self) -> List[Dict[str, str]]:
+        """Alias for history to maintain backward compatibility."""
+        return self.history
+
     def _init_client(self) -> OpenAI:
         return OpenAI(api_key=self.api_key, base_url="https://api.perplexity.ai")
         # return OpenAI(
@@ -95,7 +106,11 @@ class Perplexity(BaseGenAI):
         )
 
         for chunk in stream:
-            if chunk and chunk.choices[0].finish_reason == "stop":
+            # Handle empty chunks or chunks without choices
+            if not chunk or not chunk.choices:
+                continue
+
+            if chunk.choices[0].finish_reason == "stop":
                 print(chunk.choices)
                 try:
                     self.input_tokens += chunk.usage.prompt_tokens
@@ -103,10 +118,9 @@ class Perplexity(BaseGenAI):
                 except AttributeError:
                     pass
 
-            if chunk.choices:
-                current_text = chunk.choices[0].delta.content
-                if current_text:
-                    yield current_text
+            current_text = chunk.choices[0].delta.content
+            if current_text:
+                yield current_text
 
     def _get_available_models(self) -> List[str]:
         return [

scitex/audio/__init__.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Timestamp: "2025-12-11 (ywatanabe)"
 # File: /home/ywatanabe/proj/scitex-code/src/scitex/audio/__init__.py
 # ----------------------------------------
@@ -27,18 +26,26 @@ Usage:
     from scitex.audio import GoogleTTS, ElevenLabsTTS, SystemTTS
     tts = SystemTTS()
     tts.speak("Hello!")
+
+Installation:
+    pip install scitex[audio]
 """
 
 import subprocess
 from typing import List, Optional
 
+# Check for missing dependencies and warn user
+from scitex._install_guide import warn_module_deps
+
+_missing = warn_module_deps("audio")
+
 # Import from engines subpackage
 from .engines import (
     BaseTTS,
-    TTSBackend,
-    SystemTTS,
-    GoogleTTS,
     ElevenLabsTTS,
+    GoogleTTS,
+    SystemTTS,
+    TTSBackend,
 )
 
 
@@ -118,6 +125,7 @@ def check_wsl_audio() -> dict:
 
     return result
 
+
 # Keep legacy TTS import for backwards compatibility
 from ._tts import TTS
 
@@ -137,9 +145,8 @@ __all__ = [
     "FALLBACK_ORDER",
 ]
 
-# Fallback order: pyttsx3 (offline, free) -> gtts (free) -> elevenlabs (paid)
-# FALLBACK_ORDER = ["pyttsx3", "gtts", "elevenlabs"]
-FALLBACK_ORDER = ["gtts", "pyttsx3", "elevenlabs"]
+# Fallback order: elevenlabs (best quality) -> gtts (free) -> pyttsx3 (offline)
+FALLBACK_ORDER = ["elevenlabs", "gtts", "pyttsx3"]
 
 
 def available_backends() -> List[str]:
@@ -150,6 +157,7 @@ def available_backends() -> List[str]:
     if SystemTTS:
         try:
             import pyttsx3
+
             # Try to init to check if espeak is available
             engine = pyttsx3.init()
             engine.stop()
@@ -164,7 +172,11 @@ def available_backends() -> List[str]:
     # Check ElevenLabs (requires API key)
     if ElevenLabsTTS:
         import os
-        if os.environ.get("ELEVENLABS_API_KEY"):
+
+        api_key = os.environ.get("ELEVENLABS_API_KEY") or os.environ.get(
+            "ELEVENLABS_API_KEY_SCITEX_AUDIO"
+        )
+        if api_key:
             backends.append("elevenlabs")
 
     return backends
@@ -209,10 +221,7 @@ def get_tts(backend: Optional[str] = None, **kwargs) -> BaseTTS:
     elif backend == "elevenlabs" and ElevenLabsTTS:
         return ElevenLabsTTS(**kwargs)
     else:
-        raise ValueError(
-            f"Backend '{backend}' not available. "
-            f"Available: {backends}"
-        )
+        raise ValueError(f"Backend '{backend}' not available. Available: {backends}")
 
 
 def _try_speak_with_fallback(
@@ -340,9 +349,7 @@ def speak(
             **kwargs,
         )
         if result is None and errors:
-            raise RuntimeError(
-                f"All TTS backends failed:\n" + "\n".join(errors)
-            )
+            raise RuntimeError("All TTS backends failed:\n" + "\n".join(errors))
         return str(result) if result else None
 
     # Specific backend with fallback enabled
@@ -377,7 +384,9 @@ def speak(
 def start_mcp_server():
     """Start the MCP server for audio."""
     import asyncio
+
     from .mcp_server import main
+
     asyncio.run(main())
 
 

scitex/audio/_cross_process_lock.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+# Timestamp: "2025-12-27 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/audio/_cross_process_lock.py
+# ----------------------------------------
+
+"""
+Cross-process FIFO lock for audio playback.
+
+Ensures only one MCP server instance can play audio at a time,
+providing true FIFO ordering across all Claude Code sessions.
+"""
+
+from __future__ import annotations
+
+import fcntl
+import os
+import time
+from contextlib import contextmanager
+from pathlib import Path
+
+__all__ = ["AudioPlaybackLock", "acquire_audio_lock"]
+
+# Lock file location
+SCITEX_BASE_DIR = Path(os.getenv("SCITEX_DIR", Path.home() / ".scitex"))
+LOCK_FILE = SCITEX_BASE_DIR / "audio" / ".audio_playback.lock"
+
+
+class AudioPlaybackLock:
+    """Cross-process lock for sequential audio playback.
+
+    Uses fcntl.flock() for POSIX file locking to ensure
+    only one process can play audio at a time.
+    """
+
+    def __init__(self, lock_file: Path | None = None):
+        self.lock_file = lock_file or LOCK_FILE
+        self._fd: int | None = None
+        self._acquired = False
+
+    def _ensure_lock_dir(self):
+        """Ensure the lock file directory exists."""
+        self.lock_file.parent.mkdir(parents=True, exist_ok=True)
+
+    def acquire(self, timeout: float | None = None) -> bool:
+        """Acquire the audio playback lock.
+
+        Args:
+            timeout: Maximum time to wait in seconds.
+                     None means wait indefinitely.
+
+        Returns:
+            True if lock acquired, False if timeout.
+        """
+        self._ensure_lock_dir()
+
+        # Open or create the lock file
+        self._fd = os.open(
+            str(self.lock_file),
+            os.O_RDWR | os.O_CREAT,
+            0o644,
+        )
+
+        start_time = time.time()
+
+        while True:
+            try:
+                # Try to acquire exclusive lock (non-blocking)
+                fcntl.flock(self._fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                self._acquired = True
+
+                # Write PID to lock file for debugging
+                os.ftruncate(self._fd, 0)
+                os.lseek(self._fd, 0, os.SEEK_SET)
+                os.write(self._fd, f"{os.getpid()}\n".encode())
+
+                return True
+
+            except OSError:
+                # Lock is held by another process
+                if timeout is not None:
+                    elapsed = time.time() - start_time
+                    if elapsed >= timeout:
+                        self._cleanup()
+                        return False
+
+                # Wait a bit before retrying
+                time.sleep(0.1)
+
+    def release(self):
+        """Release the audio playback lock."""
+        if self._fd is not None and self._acquired:
+            try:
+                fcntl.flock(self._fd, fcntl.LOCK_UN)
+            except OSError:
+                pass
+            self._acquired = False
+        self._cleanup()
+
+    def _cleanup(self):
+        """Clean up file descriptor."""
+        if self._fd is not None:
+            try:
+                os.close(self._fd)
+            except OSError:
+                pass
+            self._fd = None
+
+    def __enter__(self):
+        self.acquire()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.release()
+        return False
+
+
+@contextmanager
+def acquire_audio_lock(timeout: float | None = 60.0):
+    """Context manager for acquiring the audio playback lock.
+
+    Args:
+        timeout: Maximum time to wait in seconds (default: 60s).
+
+    Yields:
+        True if lock was acquired.
+
+    Raises:
+        TimeoutError: If lock could not be acquired within timeout.
+    """
+    lock = AudioPlaybackLock()
+    try:
+        if not lock.acquire(timeout=timeout):
+            raise TimeoutError(f"Could not acquire audio lock within {timeout}s")
+        yield True
+    finally:
+        lock.release()
+
+
+# EOF

scitex/audio/_mcp_handlers.py

@@ -0,0 +1,256 @@
+#!/usr/bin/env python3
+# Timestamp: "2025-12-27 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/audio/_mcp_handlers.py
+# ----------------------------------------
+
+"""Utility handlers for the scitex-audio MCP server."""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+from datetime import datetime
+from pathlib import Path
+
+__all__ = [
+    "generate_audio_handler",
+    "list_backends_handler",
+    "list_voices_handler",
+    "play_audio_handler",
+    "list_audio_files_handler",
+    "clear_audio_cache_handler",
+    "check_audio_status_handler",
+]
+
+
+def _get_audio_dir() -> Path:
+    """Get the audio output directory."""
+    import os
+
+    base_dir = Path(os.getenv("SCITEX_DIR", Path.home() / ".scitex"))
+    audio_dir = base_dir / "audio"
+    audio_dir.mkdir(parents=True, exist_ok=True)
+    return audio_dir
+
+
+async def generate_audio_handler(
+    text: str,
+    backend: str | None = None,
+    voice: str | None = None,
+    output_path: str | None = None,
+    return_base64: bool = False,
+) -> dict:
+    """Generate audio file without playing."""
+    try:
+        from . import speak as tts_speak
+
+        loop = asyncio.get_event_loop()
+
+        if not output_path:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            output_path = str(_get_audio_dir() / f"tts_{timestamp}.mp3")
+
+        def do_generate():
+            return tts_speak(
+                text=text,
+                backend=backend,
+                voice=voice,
+                play=False,
+                output_path=output_path,
+                fallback=True,
+            )
+
+        result_path = await loop.run_in_executor(None, do_generate)
+
+        result = {
+            "success": True,
+            "path": str(result_path),
+            "text": text,
+            "backend": backend,
+            "timestamp": datetime.now().isoformat(),
+        }
+
+        if result_path.exists():
+            result["size_kb"] = round(result_path.stat().st_size / 1024, 2)
+
+        if return_base64 and result_path.exists():
+            with open(result_path, "rb") as f:
+                result["base64"] = base64.b64encode(f.read()).decode()
+
+        return result
+
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+async def list_backends_handler() -> dict:
+    """List available TTS backends."""
+    try:
+        from . import available_backends
+
+        backends = available_backends()
+
+        info = []
+        for b in ["gtts", "elevenlabs", "pyttsx3"]:
+            available = b in backends
+            desc = {
+                "gtts": "Google TTS - Free, requires internet",
+                "elevenlabs": "ElevenLabs - Paid, high quality",
+                "pyttsx3": "System TTS - Offline, uses espeak/SAPI5",
+            }
+            info.append(
+                {
+                    "name": b,
+                    "available": available,
+                    "description": desc.get(b, ""),
+                }
+            )
+
+        return {
+            "success": True,
+            "backends": info,
+            "available": backends,
+            "default": backends[0] if backends else None,
+        }
+
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+async def list_voices_handler(backend: str = "gtts") -> dict:
+    """List available voices for a backend."""
+    try:
+        from . import get_tts
+
+        loop = asyncio.get_event_loop()
+
+        def do_list():
+            tts = get_tts(backend)
+            return tts.get_voices()
+
+        voices = await loop.run_in_executor(None, do_list)
+
+        return {
+            "success": True,
+            "backend": backend,
+            "voices": voices,
+            "count": len(voices),
+        }
+
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+async def play_audio_handler(path: str) -> dict:
+    """Play an audio file."""
+    try:
+        from .engines.base import BaseTTS
+
+        path_obj = Path(path)
+        if not path_obj.exists():
+            return {"success": False, "error": f"File not found: {path}"}
+
+        loop = asyncio.get_event_loop()
+
+        def do_play():
+            BaseTTS._play_audio(None, path_obj)
+
+        await loop.run_in_executor(None, do_play)
+
+        return {
+            "success": True,
+            "played": str(path_obj),
+            "timestamp": datetime.now().isoformat(),
+        }
+
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+async def list_audio_files_handler(limit: int = 20) -> dict:
+    """List generated audio files."""
+    try:
+        audio_dir = _get_audio_dir()
+        if not audio_dir.exists():
+            return {"success": True, "files": [], "count": 0}
+
+        audio_files = sorted(
+            list(audio_dir.glob("*.mp3")) + list(audio_dir.glob("*.wav")),
+            key=lambda p: p.stat().st_mtime,
+            reverse=True,
+        )[:limit]
+
+        files = []
+        for f in audio_files:
+            files.append(
+                {
+                    "name": f.name,
+                    "path": str(f),
+                    "size_kb": round(f.stat().st_size / 1024, 2),
+                    "created": datetime.fromtimestamp(f.stat().st_mtime).isoformat(),
+                }
+            )
+
+        total_size = sum(f.stat().st_size for f in audio_dir.glob("*.*"))
+
+        return {
+            "success": True,
+            "files": files,
+            "count": len(files),
+            "total_size_mb": round(total_size / (1024 * 1024), 2),
+            "audio_dir": str(audio_dir),
+        }
+
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+async def clear_audio_cache_handler(max_age_hours: float = 24) -> dict:
+    """Clear audio cache."""
+    try:
+        audio_dir = _get_audio_dir()
+        if not audio_dir.exists():
+            return {"success": True, "deleted": 0}
+
+        deleted = 0
+        now = datetime.now()
+
+        for f in list(audio_dir.glob("*.mp3")) + list(audio_dir.glob("*.wav")):
+            try:
+                if max_age_hours == 0:
+                    f.unlink()
+                    deleted += 1
+                else:
+                    mtime = datetime.fromtimestamp(f.stat().st_mtime)
+                    age_hours = (now - mtime).total_seconds() / 3600
+                    if age_hours > max_age_hours:
+                        f.unlink()
+                        deleted += 1
+            except Exception:
+                pass
+
+        return {
+            "success": True,
+            "deleted": deleted,
+            "max_age_hours": max_age_hours,
+        }
+
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+async def check_audio_status_handler() -> dict:
+    """Check WSL audio connectivity and available playback methods."""
+    try:
+        from . import check_wsl_audio
+
+        status = check_wsl_audio()
+        status["success"] = True
+        status["timestamp"] = datetime.now().isoformat()
+        return status
+
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# EOF