Text to Speech

# Generate speech with SSML markup
ssml_text = """
<speak>
    <p>Welcome to <emphasis level="strong">TensorOne</emphasis>!</p>
    
    <p>Here's what we can do:</p>
    <break time="500ms"/>
    
    <p rate="slow">Generate high-quality speech</p>
    <p rate="fast">Process text lightning fast</p>
    <p pitch="high">With perfect voice control</p>
    
    <p>
        Visit us at <say-as interpret-as="characters">API</say-as> dot tensorone dot 
        <prosody pitch="low" rate="slow">A-I</prosody>
    </p>
</speak>
"""

ssml_result = requests.post(
    "https://api.tensorone.ai/v2/ai/text-to-speech",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "text": ssml_text,
        "voice": "neural-female-1",
        "language": "en",
        "enableSSML": True,
        "outputFormat": "wav"
    }
)

print(f"SSML Speech URL: {ssml_result.json()['audioUrl']}")

def batch_text_to_speech(texts, voice="neural-female-1"):
    results = []
    
    for i, text in enumerate(texts):
        response = requests.post(
            "https://api.tensorone.ai/v2/ai/text-to-speech",
            headers={"Authorization": "Bearer YOUR_API_KEY"},
            json={
                "text": text,
                "voice": voice,
                "language": "en",
                "outputFormat": "mp3"
            }
        )
        
        result = response.json()
        result['index'] = i
        result['original_text'] = text
        results.append(result)
    
    return results

# Generate multiple audio files
texts = [
    "Welcome to chapter one: Introduction to AI.",
    "Chapter two covers machine learning basics.",
    "In chapter three, we explore neural networks.",
    "Chapter four discusses practical applications."
]

batch_results = batch_text_to_speech(texts, "storyteller")

for result in batch_results:
    print(f"Chapter {result['index'] + 1}: {result['audioUrl']}")
    print(f"Duration: {result['duration']} seconds")
    
    # Download each file
    audio_response = requests.get(result['audioUrl'])
    filename = f"chapter_{result['index'] + 1}.mp3"
    with open(filename, 'wb') as f:
        f.write(audio_response.content)
    
    print(f"Saved: {filename}")

def multilingual_speech(text_translations):
    """
    Generate speech for multiple language versions of the same text
    text_translations: dict with language codes as keys, text as values
    """
    results = {}
    
    for lang_code, text in text_translations.items():
        response = requests.post(
            "https://api.tensorone.ai/v2/ai/text-to-speech",
            headers={"Authorization": "Bearer YOUR_API_KEY"},
            json={
                "text": text,
                "voice": "multilingual-female",
                "language": lang_code,
                "speed": 1.0,
                "emotion": "neutral",
                "outputFormat": "mp3"
            }
        )
        
        results[lang_code] = response.json()
    
    return results

# Generate the same message in multiple languages
translations = {
    "en": "Welcome to our platform! We're excited to have you here.",
    "es": "¡Bienvenido a nuestra plataforma! Estamos emocionados de tenerte aquí.",
    "fr": "Bienvenue sur notre plateforme ! Nous sommes ravis de vous avoir ici.",
    "de": "Willkommen auf unserer Plattform! Wir freuen uns, Sie hier zu haben.",
    "ja": "私たちのプラットフォームへようこそ！あなたがここにいることを嬉しく思います。"
}

multilingual_results = multilingual_speech(translations)

for lang, result in multilingual_results.items():
    print(f"{lang.upper()}: {result['audioUrl']}")
    
    # Download each language version
    audio_response = requests.get(result['audioUrl'])
    with open(f'welcome_{lang}.mp3', 'wb') as f:
        f.write(audio_response.content)

def custom_voice_speech(text, voice_settings):
    response = requests.post(
        "https://api.tensorone.ai/v2/ai/text-to-speech",
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        json={
            "text": text,
            "voice": voice_settings.get("voice", "neural-female-1"),
            "language": voice_settings.get("language", "en"),
            "speed": voice_settings.get("speed", 1.0),
            "pitch": voice_settings.get("pitch", 0.0),
            "volume": voice_settings.get("volume", 0.0),
            "emotion": voice_settings.get("emotion", "neutral"),
            "outputFormat": "wav",
            "sampleRate": 48000
        }
    )
    return response.json()

# Create different character voices
character_voices = {
    "narrator": {
        "voice": "storyteller",
        "speed": 0.9,
        "pitch": -2.0,
        "emotion": "calm"
    },
    "hero": {
        "voice": "neural-male-1",
        "speed": 1.1,
        "pitch": 3.0,
        "emotion": "excited"
    },
    "villain": {
        "voice": "neural-male-2",
        "speed": 0.8,
        "pitch": -5.0,
        "emotion": "angry"
    }
}

story_text = "The brave knight approached the dark castle, ready for battle."

for character, settings in character_voices.items():
    result = custom_voice_speech(story_text, settings)
    print(f"{character.title()}: {result['audioUrl']}")

def speech_with_pronunciation(text, pronunciations):
    pronunciation_guide = [
        {"word": word, "pronunciation": pronunciation}
        for word, pronunciation in pronunciations.items()
    ]
    
    response = requests.post(
        "https://api.tensorone.ai/v2/ai/text-to-speech",
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        json={
            "text": text,
            "voice": "neural-female-1",
            "language": "en",
            "pronunciationGuide": pronunciation_guide,
            "outputFormat": "mp3"
        }
    )
    return response.json()

# Technical text with custom pronunciations
tech_text = "The TensorOne API uses OAuth authentication and RESTful endpoints."

custom_pronunciations = {
    "TensorOne": "TEN-sor-wun",
    "API": "A-P-I",
    "OAuth": "OH-auth",
    "RESTful": "REST-ful"
}

result = speech_with_pronunciation(tech_text, custom_pronunciations)
print(f"Technical Speech: {result['audioUrl']}")

def streaming_text_to_speech(text, voice="neural-female-1"):
    response = requests.post(
        "https://api.tensorone.ai/v2/ai/text-to-speech/stream",
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        json={
            "text": text,
            "voice": voice,
            "language": "en",
            "outputFormat": "mp3",
            "streamChunkSize": 1024  # Bytes per chunk
        },
        stream=True
    )
    
    # Save streamed audio
    with open('streamed_speech.mp3', 'wb') as f:
        for chunk in response.iter_content(chunk_size=1024):
            if chunk:
                f.write(chunk)
                print(".", end="", flush=True)  # Progress indicator
    
    print("\nStreaming complete!")

# Stream long text
long_text = """
This is a long text that will be converted to speech using streaming.
The audio will be generated and streamed back in real-time, allowing
for immediate playback even before the entire text is processed.
This is particularly useful for long documents, articles, or books
where waiting for the complete audio file would take too long.
"""

streaming_text_to_speech(long_text, "storyteller")

def enhanced_text_to_speech(text, effects=None):
    if effects is None:
        effects = {}
    
    response = requests.post(
        "https://api.tensorone.ai/v2/ai/text-to-speech/enhanced",
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        json={
            "text": text,
            "voice": "neural-female-1",
            "language": "en",
            "outputFormat": "wav",
            "audioEffects": {
                "reverb": effects.get("reverb", False),
                "echo": effects.get("echo", False),
                "normalize": effects.get("normalize", True),
                "noiseReduction": effects.get("noise_reduction", True),
                "compressor": effects.get("compressor", False)
            },
            "backgroundMusic": effects.get("background_music"),
            "fadeIn": effects.get("fade_in", 0.5),
            "fadeOut": effects.get("fade_out", 0.5)
        }
    )
    return response.json()

# Generate speech with audio effects
podcast_text = "Welcome to our weekly tech podcast. Today we'll discuss the latest in AI."

podcast_effects = {
    "reverb": True,
    "normalize": True,
    "noise_reduction": True,
    "compressor": True,
    "background_music": "ambient-tech",
    "fade_in": 1.0,
    "fade_out": 2.0
}

enhanced_result = enhanced_text_to_speech(podcast_text, podcast_effects)
print(f"Enhanced Speech: {enhanced_result['audioUrl']}")