Texto a voz en Python con uv: crea audio a partir de texto

#!/usr/bin/env -S uv run --script
# /// script
# requires-python = ">=3.12"
# dependencies = [
#     "py3-tts",
#     "pygame",
#     "edge-tts",
# ]
# ///

import pyttsx3
import pygame
import tempfile
import os
import argparse
import sys
import platform
import subprocess
import warnings
import asyncio
from pathlib import Path
import edge_tts

def text_to_speech(text, output_file=None, play=True, save_mp3=None, method="auto", voice=None, rate=175):
    """
    Convert text to speech with options to play and/or save as MP3.

    Args:
        text (str): The text to convert to speech.
        output_file (str): Temporary WAV file path (optional).
        play (bool): Whether to play the audio.
        save_mp3 (str): Path to save the final MP3 file (optional).
        method (str): TTS method to use ("auto", "py3-tts", "edge-tts", "system").
        voice (str): Voice to use (for system method on macOS, or edge-tts voice name).
        rate (int): Speech rate in words per minute.
    """
    temp_dir = tempfile.gettempdir()
    temp_wav_file = os.path.join(temp_dir, "temp_speech.wav")
    temp_mp3_file = os.path.join(temp_dir, "temp_speech.mp3")

    success = False
    used_method = ""

    # --- Smart Method Selection ---
    if method == "auto":
        method_preference = []
        if platform.system() == "Darwin":
            method_preference.extend(["system", "py3-tts", "edge-tts"])
        else:
            method_preference.extend(["py3-tts", "edge-tts", "system"])
    else:
        method_preference = [method]

    # --- Attempt TTS Conversion ---
    for m in method_preference:
        print(f"🔧 Trying method: {m}...")
        if m == "py3-tts":
            success = try_py3_tts(text, temp_wav_file, rate)
        elif m == "edge-tts":
            success = try_edge_tts(text, temp_mp3_file, temp_wav_file, voice, rate)
        elif m == "system":
            if platform.system() == "Darwin":
                success = try_system_say(text, temp_wav_file, voice, rate)

        if success:
            used_method = m
            print(f"✅ Audio generated successfully using '{used_method}'!")
            break
        else:
            print(f"⚠️  Method '{m}' failed.")

    if not success:
        print("❌ All TTS methods failed! Unable to generate audio.")
        return False

    # --- Post-Processing: Play and Save ---
    try:
        if play:
            play_audio(temp_wav_file)

        if save_mp3:
            if os.path.exists(temp_wav_file):
                convert_to_mp3(temp_wav_file, save_mp3)
            elif os.path.exists(temp_mp3_file):
                # edge-tts already wrote MP3; copy it
                import shutil
                shutil.copy2(temp_mp3_file, save_mp3)
                print(f"💾 MP3 saved successfully: {save_mp3}")
            else:
                print(f"❌ Cannot save MP3. No audio file found.")

    except Exception as e:
        print(f"❌ Error during post-processing (play/save): {e}")
        return False
    finally:
        for f in [temp_wav_file, temp_mp3_file]:
            if os.path.exists(f):
                try:
                    os.remove(f)
                except OSError as e:
                    print(f"⚠️  Could not remove temporary file: {e}")

    return True

def try_py3_tts(text, output_file, rate=175):
    """Try to use py3-tts (maintained pyttsx3 fork) for TTS."""
    try:
        driver = None
        if platform.system() == 'Darwin':
            driver = 'nsss'
        elif platform.system() == 'Windows':
            driver = 'sapi5'
        # Linux: default espeak
        engine = pyttsx3.init(driverName=driver)

        engine.setProperty('rate', rate)
        engine.setProperty('volume', 0.9)

        engine.save_to_file(text, output_file)
        engine.runAndWait()

        if not os.path.exists(output_file) or os.path.getsize(output_file) == 0:
            raise RuntimeError("py3-tts completed but created an empty file.")

        return True
    except Exception as e:
        print(f"⚠️  py3-tts error: {e}")
        return False

def try_edge_tts(text, out_mp3, out_wav, voice=None, rate=175):
    """
    Use edge-tts (Microsoft Edge neural voices, free, no API key).
    Writes MP3 directly. Converts to WAV for playback if needed.
    """
    try:
        edge_voice = voice or "en-US-AvaNeural"
        # Convert WPM to edge-tts rate string (175 WPM ≈ +0%)
        rate_pct = int((rate - 175) / 175 * 100)
        rate_str = f"+{rate_pct}%" if rate_pct >= 0 else f"{rate_pct}%"

        async def _generate():
            communicate = edge_tts.Communicate(text, voice=edge_voice, rate=rate_str)
            await communicate.save(out_mp3)

        asyncio.run(_generate())

        if not os.path.exists(out_mp3) or os.path.getsize(out_mp3) == 0:
            raise RuntimeError("edge-tts completed but created an empty file.")

        # Convert MP3 to WAV for pygame playback
        convert_mp3_to_wav(out_mp3, out_wav)
        return True
    except Exception as e:
        print(f"⚠️  edge-tts error: {e}")
        return False

def try_system_say(text, output_file, voice=None, rate=175):
    """Use the native 'say' command on macOS to generate a WAV file."""
    if platform.system() != "Darwin":
        return False

    try:
        cmd = ['say']
        if voice:
            cmd.extend(['-v', voice])
        cmd.extend(['-r', str(rate)])
        cmd.append(text)
        cmd.extend(['-o', output_file, '--file-format=WAVE', '--data-format=LEI16@22050'])

        subprocess.run(cmd, check=True, capture_output=True, text=True)
        return True
    except FileNotFoundError:
        print("⚠️  'say' command not found on this system.")
        return False
    except subprocess.CalledProcessError as e:
        print(f"⚠️  System 'say' command failed: {e.stderr}")
        return False

def convert_mp3_to_wav(mp3_file, wav_file):
    """Convert MP3 to WAV using ffmpeg."""
    try:
        cmd = [
            'ffmpeg', '-i', mp3_file,
            '-acodec', 'pcm_s16le', '-ac', '1', '-ar', '22050',
            '-y', wav_file
        ]
        subprocess.run(cmd, check=True, capture_output=True, text=True)
    except FileNotFoundError:
        print("❌ 'ffmpeg' not found. Install it for MP3/WAV conversion.")
        print("💡 macOS: brew install ffmpeg | Linux: sudo apt install ffmpeg")
        raise
    except subprocess.CalledProcessError as e:
        print(f"❌ ffmpeg failed to convert MP3 to WAV: {e.stderr}")
        raise

def convert_to_mp3(wav_file, mp3_file):
    """Convert WAV file to MP3 using ffmpeg."""
    try:
        cmd = [
            'ffmpeg', '-i', wav_file,
            '-acodec', 'libmp3lame', '-q:a', '2',
            '-y', mp3_file
        ]
        subprocess.run(cmd, check=True, capture_output=True, text=True)
        print(f"💾 MP3 saved successfully: {mp3_file}")
    except FileNotFoundError:
        print("❌ 'ffmpeg' not found. Install it for MP3 export.")
        print("💡 macOS: brew install ffmpeg | Linux: sudo apt install ffmpeg")
        raise
    except subprocess.CalledProcessError as e:
        print(f"❌ ffmpeg failed to convert WAV to MP3: {e.stderr}")
        raise

def play_audio(file_path):
    """Play an audio file using pygame, with a system fallback."""
    print(f"🔊 Playing audio from: {file_path}")
    try:
        pygame.mixer.pre_init(frequency=22050, size=-16, channels=1, buffer=512)
        pygame.mixer.init()
        pygame.mixer.music.load(file_path)
        pygame.mixer.music.play()

        print("🎵 Playing... (Press Ctrl+C to stop)")
        while pygame.mixer.music.get_busy():
            pygame.time.wait(100)
        print("✅ Playback finished!")

    except pygame.error as e:
        print(f"⚠️  Pygame playback error: {e}")
        print("🔧 Falling back to system audio player...")
        try_system_playback(file_path)
    except KeyboardInterrupt:
        pygame.mixer.music.stop()
        print("\n⏹️  Playback stopped by user.")
    finally:
        pygame.mixer.quit()

def try_system_playback(file_path):
    """Fallback audio playback using system commands."""
    try:
        system = platform.system()
        if system == "Darwin":
            subprocess.run(['afplay', file_path], check=True)
        elif system == "Linux":
            for player in ['paplay', 'aplay', 'mpg123', 'mplayer']:
                if subprocess.run(['which', player], capture_output=True).returncode == 0:
                    subprocess.run([player, file_path], check=True,
                                   stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
                    return
            print("⚠️  No suitable command-line audio player found on Linux.")
        elif system == "Windows":
            os.startfile(file_path)
        else:
            print(f"⚠️  System playback not supported on platform: {system}")
    except Exception as e:
        print(f"⚠️  System playback failed: {e}")
        print(f"💡 You can play the file manually: {file_path}")

def list_voices():
    """List available voices for the current platform."""
    system = platform.system()

    if system == "Darwin":
        try:
            result = subprocess.run(['say', '-v', '?'], capture_output=True, text=True, check=True)
            print("Available macOS voices (say command):")
            print("-" * 50)
            print(result.stdout)
        except Exception as e:
            print(f"❌ Error listing macOS voices: {e}")

    # List py3-tts engine voices
    try:
        driver = None
        if system == 'Darwin':
            driver = 'nsss'
        elif system == 'Windows':
            driver = 'sapi5'
        engine = pyttsx3.init(driverName=driver)
        voices = engine.getProperty('voices')
        if voices:
            print(f"\nAvailable py3-tts voices ({system}):")
            print("-" * 50)
            for v in voices:
                print(f"  {v.id}  —  {v.name}")
    except Exception as e:
        print(f"⚠️  Could not list py3-tts voices: {e}")

    # List edge-tts voices
    print("\nTo list edge-tts voices (300+ online neural voices), run:")
    print("  edge-tts --list-voices")

def main():
    parser = argparse.ArgumentParser(description="Python text-to-speech with uv")
    parser.add_argument("text", nargs="?", help="Text to convert to speech. Omit for interactive mode.")
    parser.add_argument("-f", "--file", help="Read text from a file.")
    parser.add_argument("-s", "--save", help="Save output as an MP3 file.")
    parser.add_argument("-n", "--no-play", action="store_true", help="Do not play the audio.")
    parser.add_argument("-r", "--rate", type=int, default=175, help="Speech rate in WPM (default: 175).")
    parser.add_argument("-m", "--method", choices=["auto", "py3-tts", "edge-tts", "system"],
                        default="auto", help="TTS engine to use.")
    parser.add_argument("--voice", help="Voice name (macOS: Alex, Samantha; edge-tts: en-US-AvaNeural).")
    parser.add_argument("--list-voices", action="store_true", help="List available voices and exit.")

    args = parser.parse_args()

    if args.list_voices:
        list_voices()
        return 0

    text_to_process = ""
    if args.file:
        try:
            with open(args.file, 'r', encoding='utf-8') as f:
                text_to_process = f.read().strip()
        except FileNotFoundError:
            print(f"❌ Error: File not found at '{args.file}'")
            return 1
    elif args.text:
        text_to_process = args.text
    else:
        try:
            print("🎙️  Entering interactive TTS mode. Type text and press Enter.")
            print("   (Type 'quit' or 'exit' to close)")
            while True:
                line = input("> ")
                if line.lower() in ['quit', 'exit', 'q']:
                    break
                if line:
                    text_to_speech(
                        text=line,
                        play=not args.no_play,
                        save_mp3=None,
                        method=args.method,
                        voice=args.voice,
                        rate=args.rate
                    )
            return 0
        except (EOFError, KeyboardInterrupt):
            print("\nExiting interactive mode.")
            return 0

    if not text_to_process:
        print("❌ Error: No text provided. Use a command-line argument, a file, or run in interactive mode.")
        return 1

    print(f"\n📝 Text: {text_to_process[:80]}{'...' if len(text_to_process) > 80 else ''}")
    print(f"⚙️  Rate: {args.rate} WPM, Method: {args.method}, Play: {not args.no_play}")

    success = text_to_speech(
        text=text_to_process,
        play=not args.no_play,
        save_mp3=args.save,
        method=args.method,
        voice=args.voice,
        rate=args.rate
    )

    return 0 if success else 1

if __name__ == "__main__":
    if "-n" not in sys.argv and "--no-play" not in sys.argv:
        try:
            os.environ['PYGAME_HIDE_SUPPORT_PROMPT'] = "1"
            import pygame
            pygame.init()
            pygame.quit()
        except ImportError:
            print("⚠️ Pygame not found, playback will rely on system commands.")

    sys.exit(main())

# Simple text-to-speech
uv run tts.py "Hello, world!"

# Read from a file
uv run tts.py -f document.txt

# Save as MP3 without playing (headless-friendly)
uv run tts.py "Save this text" -s output.mp3 -n

# Interactive mode
uv run tts.py

uv run tts.py "test" -s test.mp3 -n && ls -la test.mp3

# List all available voices (macOS say + py3-tts + edge-tts hint)
uv run tts.py --list-voices

# Use a specific macOS voice
uv run tts.py "Hello world" --voice "Samantha"

# Use an edge-tts neural voice
uv run tts.py "Hello world" -m edge-tts --voice "en-GB-SoniaNeural"

# Adjust speech rate
uv run tts.py "Hello world" -r 100   # slower
uv run tts.py "Hello world" -r 250   # faster

# Force a specific engine
uv run tts.py "Hello world" -m system --voice "Samantha" -r 160
uv run tts.py "Hello world" -m edge-tts --voice "en-US-AvaNeural"

# CLI usage (install separately or let uv handle it)
edge-tts --text "Hello from edge-tts" --write-media hello.mp3 --write-subtitles hello.srt

# List 300+ available neural voices
edge-tts --list-voices

# Pick a specific voice and rate
edge-tts --text "Good morning" --voice "en-GB-SoniaNeural" --rate "+10%" --write-media morning.mp3

# Convert an entire document to MP3
uv run tts.py -f book.txt -s audiobook.mp3 --voice "Samantha" -r 160 -n

# Multiple chapters
uv run tts.py -f chapter1.txt -s chapter1.mp3 --voice "Alex" -r 150 -n
uv run tts.py -f chapter2.txt -s chapter2.mp3 --voice "Alex" -r 150 -n

# Compare voices for the same text
uv run tts.py "The quick brown fox jumps over the lazy dog" --voice "Alex" -s alex.mp3 -n
uv run tts.py "The quick brown fox jumps over the lazy dog" --voice "Samantha" -s samantha.mp3 -n
uv run tts.py "The quick brown fox jumps over the lazy dog" -m edge-tts --voice "en-US-AvaNeural" -s ava.mp3 -n

uv run tts.py --voice "Samantha" -r 140

🎙️  Entering interactive TTS mode. Type text and press Enter.
   (Type 'quit' or 'exit' to close)
> Hello, how are you today?
🔧 Trying method: system...
✅ Audio generated successfully using 'system'!
🔊 Playing audio...
> quit

def try_custom_engine(text, output_file, rate=175):
    """Add your custom TTS engine here."""
    try:
        # Your custom implementation
        return True
    except Exception as e:
        print(f"⚠️  Custom engine failed: {e}")
        return False

# Add to the method_preference list in text_to_speech()

def try_edge_tts_multilang(text, out_mp3, out_wav, lang='en', voice=None, rate=175):
    """Edge-tts with explicit language selection."""
    import edge_tts
    import asyncio

    # Pick a voice for the target language
    voice_map = {
        'en': 'en-US-AvaNeural',
        'fr': 'fr-FR-DeniseNeural',
        'de': 'de-DE-KatjaNeural',
        'es': 'es-ES-ElviraNeural',
        'ja': 'ja-JP-NanamiNeural',
        'zh': 'zh-CN-XiaoxiaoNeural',
    }
    edge_voice = voice or voice_map.get(lang, 'en-US-AvaNeural')

    async def _generate():
        communicate = edge_tts.Communicate(text, voice=edge_voice)
        await communicate.save(out_mp3)

    asyncio.run(_generate())
    # Convert to WAV for playback if needed
    convert_mp3_to_wav(out_mp3, out_wav)

# Podcast intros
uv run tts.py "Welcome to our podcast" --voice "Alex" -s intro.mp3 -n

# Voice-overs
uv run tts.py -f script.txt -s voiceover.mp3 --voice "Samantha" -r 160 -n

# Read web content aloud
uv run tts.py "$(curl -s https://example.com | grep -o '<p>[^<]*' | sed 's/<p>//')" --voice "Alex"

# Convert emails to speech
uv run tts.py -f email.txt --voice "Samantha" -r 140

# Practice pronunciation
uv run tts.py "Hello, my name is John" --voice "Alex" -r 120
uv run tts.py "Bonjour, je m'appelle Jean" -m edge-tts --voice "fr-FR-DeniseNeural"

import subprocess

def speak_agent_response(text):
    subprocess.run(["uv", "run", "tts.py", text, "-m", "edge-tts",
                    "--voice", "en-US-AvaNeural", "-s", "response.mp3", "-n"])

# VPS cron job alerts (headless, file-only)
uv run tts.py "Backup completed successfully" -s /var/log/alerts/backup.mp3 -n

# 1. Confirm uv is installed
uv --version
# Expected: uv 0.12.x or newer

# 2. Confirm ffmpeg for MP3 export
ffmpeg -version
# Expected: version info printed

# 3. macOS: confirm voices available
say -v '?'
# Expected: list of voices (quote the ?)

# 4. Linux: confirm espeak-ng
espeak-ng --version
# Expected: version info printed

# 5. Quick smoke test
uv run tts.py "test" -s test.mp3 -n && ls -la test.mp3
# Expected: non-empty MP3 file

# macOS
brew install ffmpeg
# Ubuntu/Debian
sudo apt install ffmpeg
# Windows: download from https://ffmpeg.org/ and add to PATH

pip install pyobjc>=9.0.1

uv run tts.py "Hello" -s output.mp3 -n

# batch_tts.py
import subprocess

texts = [
    "Hello world",
    "This is a test",
    "Goodbye world"
]

for i, text in enumerate(texts, 1):
    subprocess.run([
        "uv", "run", "tts.py", text,
        "-s", f"output_{i}.mp3",
        "--voice", "Samantha",
        "-r", "150",
        "-n"
    ])

# integration_example.py
import subprocess

def speak_text(text, voice="Alex", rate=175):
    """Wrapper function for the TTS script."""
    subprocess.run([
        "uv", "run", "tts.py", text,
        "--voice", voice,
        "-r", str(rate)
    ])

speak_text("Hello from my application!")

# Lock dependencies (creates tts.py.lock)
uv lock --script tts.py

# Now uv run will use the locked versions
uv run tts.py "Hello"