scitex 2.7.0__py3-none-any.whl → 2.7.3__py3-none-any.whl

scitex/audio/engines/elevenlabs_engine.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-12-11 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/audio/engines/elevenlabs_engine.py
+# ----------------------------------------
+
+"""
+ElevenLabs TTS backend - High quality, requires API key and payment.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import List, Optional
+
+from .base import BaseTTS
+
+__all__ = ["ElevenLabsTTS"]
+
+
+class ElevenLabsTTS(BaseTTS):
+    """ElevenLabs TTS backend.
+
+    High-quality voices but requires API key and has usage costs.
+
+    Environment:
+        ELEVENLABS_API_KEY: Your ElevenLabs API key
+    """
+
+    VOICES = {
+        "rachel": "21m00Tcm4TlvDq8ikWAM",
+        "adam": "pNInz6obpgDQGcFmaJgB",
+        "antoni": "ErXwobaYiN019PkySvjV",
+        "bella": "EXAVITQu4vr4xnSDxMaL",
+        "domi": "AZnzlk1XvdvUeBnXmlld",
+        "elli": "MF3mGyEYCl7XYWbV9V6O",
+        "josh": "TxGEqnHWrfWFTfGW9XjX",
+        "sam": "yoZ06aMxZJJ28mfd3POQ",
+    }
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        voice: str = "rachel",
+        model_id: str = "eleven_multilingual_v2",
+        stability: float = 0.5,
+        similarity_boost: float = 0.75,
+        speed: float = 1.0,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.api_key = api_key or os.environ.get("ELEVENLABS_API_KEY")
+        self.voice = voice
+        self.model_id = model_id
+        self.stability = stability
+        self.similarity_boost = similarity_boost
+        self.speed = speed
+        self._client = None
+
+    @property
+    def name(self) -> str:
+        return "elevenlabs"
+
+    @property
+    def requires_api_key(self) -> bool:
+        return True
+
+    @property
+    def requires_internet(self) -> bool:
+        return True
+
+    @property
+    def client(self):
+        """Lazy-load ElevenLabs client."""
+        if self._client is None:
+            try:
+                from elevenlabs.client import ElevenLabs
+
+                self._client = ElevenLabs(api_key=self.api_key)
+            except ImportError:
+                raise ImportError(
+                    "elevenlabs package not installed. "
+                    "Install with: pip install elevenlabs"
+                )
+        return self._client
+
+    def _get_voice_id(self, voice: Optional[str] = None) -> str:
+        """Get voice ID from name or return as-is if already an ID."""
+        v = voice or self.voice
+        normalized = v.lower()
+        return self.VOICES.get(normalized, v)
+
+    def synthesize(self, text: str, output_path: str) -> Path:
+        """Synthesize text using ElevenLabs API."""
+        voice_id = self._get_voice_id(self.config.get("voice"))
+
+        audio = self.client.text_to_speech.convert(
+            text=text,
+            voice_id=voice_id,
+            model_id=self.model_id,
+            voice_settings={
+                "stability": self.stability,
+                "similarity_boost": self.similarity_boost,
+                "speed": self.speed,
+            },
+            output_format="mp3_44100_128",
+        )
+
+        out_path = Path(output_path)
+        with open(out_path, "wb") as f:
+            for chunk in audio:
+                f.write(chunk)
+
+        return out_path
+
+    def get_voices(self) -> List[dict]:
+        """Get available voices."""
+        # Start with preset voices
+        voices = [
+            {"name": name, "id": vid, "type": "preset"}
+            for name, vid in self.VOICES.items()
+        ]
+
+        # Try to get custom voices
+        try:
+            response = self.client.voices.get_all()
+            for v in response.voices:
+                voices.append(
+                    {
+                        "name": v.name,
+                        "id": v.voice_id,
+                        "type": "custom",
+                        "labels": v.labels,
+                    }
+                )
+        except Exception:
+            pass
+
+        return voices
+
+
+# EOF

scitex/audio/engines/gtts_engine.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-12-11 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/audio/engines/gtts_engine.py
+# ----------------------------------------
+
+"""
+Google Text-to-Speech (gTTS) backend - Free, requires internet.
+"""
+
+from __future__ import annotations
+
+import io
+from pathlib import Path
+from typing import List, Optional
+
+from .base import BaseTTS
+
+__all__ = ["GoogleTTS"]
+
+
+class GoogleTTS(BaseTTS):
+    """Google Text-to-Speech backend using gTTS.
+
+    Free to use, requires internet connection.
+    Good quality voices with multi-language support.
+    Supports speed control via pydub (requires ffmpeg).
+
+    Install: pip install gTTS pydub
+    """
+
+    # Supported languages (subset of most common)
+    LANGUAGES = {
+        "en": "English",
+        "es": "Spanish",
+        "fr": "French",
+        "de": "German",
+        "it": "Italian",
+        "pt": "Portuguese",
+        "ru": "Russian",
+        "ja": "Japanese",
+        "ko": "Korean",
+        "zh-CN": "Chinese (Simplified)",
+        "zh-TW": "Chinese (Traditional)",
+        "ar": "Arabic",
+        "hi": "Hindi",
+        "nl": "Dutch",
+        "pl": "Polish",
+        "sv": "Swedish",
+        "tr": "Turkish",
+        "vi": "Vietnamese",
+    }
+
+    def __init__(
+        self,
+        lang: str = "en",
+        slow: bool = False,
+        speed: float = 1.5,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.lang = lang
+        self.slow = slow
+        self.speed = speed  # 1.0 = normal, >1.0 = faster, <1.0 = slower
+
+    @property
+    def name(self) -> str:
+        return "gtts"
+
+    @property
+    def requires_internet(self) -> bool:
+        return True
+
+    def synthesize(self, text: str, output_path: str) -> Path:
+        """Synthesize text using Google TTS with optional speed control."""
+        try:
+            from gtts import gTTS
+        except ImportError:
+            raise ImportError(
+                "gTTS package not installed. Install with: pip install gTTS"
+            )
+
+        # Get language from config or use default
+        lang = self.config.get("voice", self.lang)
+        if lang in self.LANGUAGES:
+            pass  # Valid language code
+        elif lang.lower() in [l.lower() for l in self.LANGUAGES.values()]:
+            # Convert language name to code
+            for code, name in self.LANGUAGES.items():
+                if name.lower() == lang.lower():
+                    lang = code
+                    break
+
+        # Get speed from config or use instance default
+        speed = self.config.get("speed", self.speed)
+
+        out_path = Path(output_path)
+
+        if speed != 1.0:
+            # Use pydub for speed control
+            audio_data = self._synthesize_with_speed(text, lang, speed)
+            audio_data.export(str(out_path), format="mp3")
+        else:
+            # Direct save without speed modification
+            tts = gTTS(text=text, lang=lang, slow=self.slow)
+            tts.save(str(out_path))
+
+        return out_path
+
+    def _synthesize_with_speed(self, text: str, lang: str, speed: float):
+        """Synthesize with speed control using pydub.
+
+        Args:
+            text: Text to synthesize.
+            lang: Language code.
+            speed: Speed multiplier (>1.0 faster, <1.0 slower).
+
+        Returns:
+            AudioSegment with adjusted speed.
+        """
+        try:
+            from gtts import gTTS
+            from pydub import AudioSegment
+        except ImportError as e:
+            raise ImportError(
+                "pydub package required for speed control. "
+                "Install with: pip install pydub"
+            ) from e
+
+        # Generate speech to memory buffer
+        with io.BytesIO() as buffer:
+            gTTS(text=text, lang=lang, slow=self.slow).write_to_fp(buffer)
+            buffer.seek(0)
+            sound = AudioSegment.from_file(buffer, format="mp3")
+
+        # Apply speed adjustment
+        if speed > 1.0:
+            # speedup() for faster playback
+            sound = sound.speedup(
+                playback_speed=speed,
+                chunk_size=150,
+                crossfade=25
+            )
+        elif speed < 1.0:
+            # For slower playback, adjust frame rate
+            new_frame_rate = int(sound.frame_rate * speed)
+            sound = sound._spawn(
+                sound.raw_data,
+                overrides={"frame_rate": new_frame_rate}
+            ).set_frame_rate(sound.frame_rate)
+
+        return sound
+
+    def get_voices(self) -> List[dict]:
+        """Get available languages as 'voices'."""
+        return [
+            {"name": name, "id": code, "type": "language"}
+            for code, name in self.LANGUAGES.items()
+        ]
+
+
+# EOF

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