Upload 2 files

groq_tts.py

@@ -0,0 +1,187 @@
+"""
+TTS module - Groq Orpheus API for fast cloud-based speech synthesis.
+Uses the diana voice from canopylabs/orpheus-v1-english.
+No local GPU needed — calls Groq's API endpoint.
+"""
+import os
+import re
+import time
+import logging
+
+logger = logging.getLogger(__name__)
+
+TEMP_DIR = "/tmp/tts_output"
+SAMPLE_RATE = 24000
+
+# Groq Orpheus config
+MODEL = "canopylabs/orpheus-v1-english"
+VOICE = os.environ.get("GROQ_TTS_VOICE", "diana")
+RESPONSE_FORMAT = "wav"
+
+# Singleton
+_client = None
+_initialized = False
+
+
+def _ts():
+    return time.strftime("%H:%M:%S", time.gmtime()) + f".{int(time.time()*1000)%1000:03d}"
+
+
+def ensure_temp_dir():
+    os.makedirs(TEMP_DIR, exist_ok=True)
+    return TEMP_DIR
+
+
+def initialize():
+    """Initialize the Groq client."""
+    global _client, _initialized
+
+    if _initialized:
+        return
+
+    t0 = time.time()
+    logger.info(f"[{_ts()}] [TTS] Initializing Groq Orpheus TTS...")
+
+    from groq import Groq
+
+    api_key = os.environ.get("GROQ_API_KEY")
+    if not api_key:
+        logger.error(f"[{_ts()}] [TTS] GROQ_API_KEY not set!")
+        return
+
+    _client = Groq(api_key=api_key)
+    _initialized = True
+    logger.info(f"[{_ts()}] [TTS] ✓ Groq Orpheus ready in {time.time()-t0:.2f}s | voice: {VOICE} | model: {MODEL}")
+
+
+def _clean_text_for_tts(text):
+    """Remove tags and asterisk actions."""
+    text = re.sub(r'<[^>]+>', '', text)
+    text = re.sub(r'\*[^*]+\*', '', text)
+    text = re.sub(r'\s+', ' ', text).strip()
+    return text
+
+
+def generate_audio(text: str, output_filename: str = None) -> str:
+    """
+    Generate speech audio from text using Groq Orpheus API.
+    Returns path to wav file, or None on failure.
+    """
+    if not text or not text.strip():
+        return None
+
+    text = _clean_text_for_tts(text)
+    if not text:
+        return None
+
+    if not _initialized or _client is None:
+        logger.error(f"[{_ts()}] [TTS] Not initialized!")
+        return None
+
+    temp_dir = ensure_temp_dir()
+    if output_filename is None:
+        timestamp = int(time.time() * 1000)
+        output_filename = f"tts_{timestamp}"
+
+    if not output_filename.endswith('.wav'):
+        output_path = os.path.join(temp_dir, f"{output_filename}.wav")
+    else:
+        output_path = os.path.join(temp_dir, output_filename)
+
+    try:
+        t0 = time.time()
+        logger.info(f"[{_ts()}] [TTS] Generating: {text[:60]}...")
+
+        # Groq Orpheus has 200 char limit per request — split if needed
+        chunks = _split_text(text, max_chars=195)
+        all_audio = []
+
+        for i, chunk in enumerate(chunks):
+            t1 = time.time()
+            response = _client.audio.speech.create(
+                model=MODEL,
+                voice=VOICE,
+                input=chunk,
+                response_format=RESPONSE_FORMAT,
+            )
+
+            # Read the audio bytes
+            audio_bytes = response.read()
+            all_audio.append(audio_bytes)
+            logger.info(f"[{_ts()}] [TTS] Chunk {i+1}/{len(chunks)}: {len(chunk)} chars → {len(audio_bytes)/1024:.0f}KB in {time.time()-t1:.2f}s")
+
+        # If single chunk, write directly; if multiple, concatenate WAV data
+        if len(all_audio) == 1:
+            with open(output_path, "wb") as f:
+                f.write(all_audio[0])
+        else:
+            _concatenate_wav_files(all_audio, output_path)
+
+        file_size = os.path.getsize(output_path)
+        total = time.time() - t0
+
+        # Get duration
+        import wave
+        with wave.open(output_path, "rb") as wf:
+            duration = wf.getnframes() / wf.getframerate()
+
+        logger.info(
+            f"[{_ts()}] [TTS] Saved: {output_path} ({file_size/1024:.0f}KB) "
+            f"| audio: {duration:.1f}s | total: {total:.2f}s"
+        )
+        return output_path
+
+    except Exception as e:
+        logger.error(f"[{_ts()}] [TTS] Error: {e}", exc_info=True)
+        return None
+
+
+def _split_text(text: str, max_chars: int = 195) -> list:
+    """Split text into chunks under max_chars, breaking at sentence boundaries."""
+    if len(text) <= max_chars:
+        return [text]
+
+    chunks = []
+    sentences = re.split(r'(?<=[.!?])\s+', text)
+    current = ""
+
+    for sentence in sentences:
+        if len(sentence) > max_chars:
+            # Single sentence too long — split at comma or space
+            if current:
+                chunks.append(current.strip())
+                current = ""
+            words = sentence.split()
+            for word in words:
+                if len(current) + len(word) + 1 > max_chars:
+                    if current:
+                        chunks.append(current.strip())
+                    current = word
+                else:
+                    current = f"{current} {word}" if current else word
+        elif len(current) + len(sentence) + 1 > max_chars:
+            chunks.append(current.strip())
+            current = sentence
+        else:
+            current = f"{current} {sentence}" if current else sentence
+
+    if current.strip():
+        chunks.append(current.strip())
+
+    return chunks if chunks else [text]
+
+
+def _concatenate_wav_files(audio_chunks: list, output_path: str):
+    """Concatenate multiple WAV byte chunks into a single WAV file."""
+    import wave
+    import io
+
+    # Read first chunk to get params
+    with wave.open(io.BytesIO(audio_chunks[0]), "rb") as first:
+        params = first.getparams()
+
+    with wave.open(output_path, "wb") as out:
+        out.setparams(params)
+        for chunk_bytes in audio_chunks:
+            with wave.open(io.BytesIO(chunk_bytes), "rb") as chunk_wav:
+                out.writeframes(chunk_wav.readframes(chunk_wav.getnframes()))

orpheus_tts.py

@@ -476,4 +476,4 @@ def generate_audio(text: str, output_filename: str = None) -> str:
 
     except Exception as e:
         logger.error(f"[{_ts()}] [TTS] Error: {e}", exc_info=True)
-        return None
+        return None