@weirdfingers/baseboards 0.5.2 → 0.6.0

package/templates/api/src/boards/generators/implementations/fal/audio/elevenlabs_tts_eleven_v3.py

@@ -0,0 +1,209 @@
+"""
+fal.ai ElevenLabs Text-to-Speech Eleven-V3 generator.
+
+Generate high-quality speech from text using ElevenLabs' Eleven-V3 model,
+offering natural-sounding voices with customizable parameters for stability,
+similarity, style, and speed.
+
+Based on Fal AI's fal-ai/elevenlabs/tts/eleven-v3 model.
+See: https://fal.ai/models/fal-ai/elevenlabs/tts/eleven-v3
+"""
+
+import os
+
+from pydantic import BaseModel, Field
+
+from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
+
+
+class ElevenlabsTtsElevenV3Input(BaseModel):
+    """Input schema for ElevenLabs TTS Eleven-V3 generation.
+
+    The text is converted to speech using advanced AI voice synthesis with
+    customizable voice characteristics and optional word-level timestamps.
+    """
+
+    text: str = Field(
+        description="The text to convert to speech",
+        min_length=1,
+    )
+    voice: str = Field(
+        default="Rachel",
+        description=(
+            "Voice selection. Available voices: "
+            "Aria, Roger, Sarah, Laura, Charlie, George, Callum, River, Liam, "
+            "Charlotte, Alice, Matilda, Will, Jessica, Eric, Chris, Brian, "
+            "Daniel, Lily, Bill, Rachel"
+        ),
+    )
+    stability: float = Field(
+        default=0.5,
+        ge=0.0,
+        le=1.0,
+        description="Voice stability. Higher values result in more consistent output",
+    )
+    similarity_boost: float = Field(
+        default=0.75,
+        ge=0.0,
+        le=1.0,
+        description="Similarity boost for voice matching",
+    )
+    style: float = Field(
+        default=0.0,
+        ge=0.0,
+        le=1.0,
+        description="Style exaggeration. Higher values add more expressiveness",
+    )
+    speed: float = Field(
+        default=1.0,
+        ge=0.7,
+        le=1.2,
+        description="Speech rate adjustment. 1.0 is normal speed",
+    )
+    timestamps: bool = Field(
+        default=False,
+        description="Whether to return timestamps for each word",
+    )
+    previous_text: str | None = Field(
+        default=None,
+        description="Context from prior content for improved continuity",
+    )
+    next_text: str | None = Field(
+        default=None,
+        description="Context for upcoming content for improved continuity",
+    )
+    language_code: str | None = Field(
+        default=None,
+        description="ISO 639-1 language code (limited model support)",
+    )
+
+
+class FalElevenlabsTtsElevenV3Generator(BaseGenerator):
+    """ElevenLabs Text-to-Speech Eleven-V3 generator using fal.ai."""
+
+    name = "fal-elevenlabs-tts-eleven-v3"
+    artifact_type = "audio"
+    description = (
+        "Fal: ElevenLabs TTS Eleven-V3 - "
+        "High-quality text-to-speech with natural-sounding voices and customizable parameters"
+    )
+
+    def get_input_schema(self) -> type[ElevenlabsTtsElevenV3Input]:
+        return ElevenlabsTtsElevenV3Input
+
+    async def generate(
+        self, inputs: ElevenlabsTtsElevenV3Input, context: GeneratorExecutionContext
+    ) -> GeneratorResult:
+        """Generate audio using fal.ai ElevenLabs TTS Eleven-V3 model."""
+        # Check for API key (fal-client uses FAL_KEY environment variable)
+        if not os.getenv("FAL_KEY"):
+            raise ValueError("API configuration invalid. Missing FAL_KEY environment variable")
+
+        # Import fal_client
+        try:
+            import fal_client
+        except ImportError as e:
+            raise ImportError(
+                "fal.ai SDK is required for FalElevenlabsTtsElevenV3Generator. "
+                "Install with: pip install weirdfingers-boards[generators-fal]"
+            ) from e
+
+        # Prepare arguments for fal.ai API
+        arguments = {
+            "text": inputs.text,
+            "voice": inputs.voice,
+            "stability": inputs.stability,
+            "similarity_boost": inputs.similarity_boost,
+            "style": inputs.style,
+            "speed": inputs.speed,
+            "timestamps": inputs.timestamps,
+        }
+
+        # Add optional context parameters if provided
+        if inputs.previous_text is not None:
+            arguments["previous_text"] = inputs.previous_text
+        if inputs.next_text is not None:
+            arguments["next_text"] = inputs.next_text
+        if inputs.language_code is not None:
+            arguments["language_code"] = inputs.language_code
+
+        # Submit async job and get handler
+        handler = await fal_client.submit_async(
+            "fal-ai/elevenlabs/tts/eleven-v3",
+            arguments=arguments,
+        )
+
+        # Store the external job ID for tracking
+        await context.set_external_job_id(handler.request_id)
+
+        # Stream progress updates (sample every 3rd event to avoid spam)
+        from .....progress.models import ProgressUpdate
+
+        event_count = 0
+        async for event in handler.iter_events(with_logs=True):
+            event_count += 1
+
+            # Process every 3rd event to provide feedback without overwhelming
+            if event_count % 3 == 0:
+                # Extract logs if available
+                logs = getattr(event, "logs", None)
+                if logs:
+                    # Join log entries into a single message
+                    if isinstance(logs, list):
+                        message = " | ".join(str(log) for log in logs if log)
+                    else:
+                        message = str(logs)
+
+                    if message:
+                        await context.publish_progress(
+                            ProgressUpdate(
+                                job_id=handler.request_id,
+                                status="processing",
+                                progress=50.0,  # Approximate mid-point progress
+                                phase="processing",
+                                message=message,
+                            )
+                        )
+
+        # Get final result
+        result = await handler.get()
+
+        # Extract audio URL from result
+        # fal.ai returns: {"audio": {"url": "...", "content_type": "...", ...}}
+        audio_data = result.get("audio")
+        if audio_data is None:
+            raise ValueError("No audio data returned from fal.ai API")
+
+        audio_url = audio_data.get("url")
+        if not audio_url:
+            raise ValueError("Audio URL missing in fal.ai response")
+
+        # Determine format from content_type or default to mp3
+        content_type = audio_data.get("content_type", "audio/mpeg")
+        format_map = {
+            "audio/mpeg": "mp3",
+            "audio/mp3": "mp3",
+            "audio/wav": "wav",
+            "audio/ogg": "ogg",
+        }
+        audio_format = format_map.get(content_type, "mp3")
+
+        # Store audio result
+        artifact = await context.store_audio_result(
+            storage_url=audio_url,
+            format=audio_format,
+            output_index=0,
+        )
+
+        return GeneratorResult(outputs=[artifact])
+
+    async def estimate_cost(self, inputs: ElevenlabsTtsElevenV3Input) -> float:
+        """Estimate cost for ElevenLabs TTS Eleven-V3 generation.
+
+        ElevenLabs TTS Eleven-V3 costs $0.10 per 1000 characters.
+        """
+        # Calculate character count
+        char_count = len(inputs.text)
+
+        # Cost is $0.10 per 1000 characters
+        return (char_count / 1000.0) * 0.10

package/templates/api/src/boards/generators/implementations/fal/audio/fal_elevenlabs_tts_turbo_v2_5.py

@@ -0,0 +1,206 @@
+"""
+fal.ai ElevenLabs TTS Turbo v2.5 text-to-speech generator.
+
+Generate high-speed text-to-speech audio using ElevenLabs TTS Turbo v2.5.
+Converts written text into spoken audio with customizable voice, speed, and prosody parameters.
+
+Based on Fal AI's fal-ai/elevenlabs/tts/turbo-v2.5 model.
+See: https://fal.ai/models/fal-ai/elevenlabs/tts/turbo-v2.5
+"""
+
+import os
+
+from pydantic import BaseModel, Field
+
+from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
+
+
+class FalElevenlabsTtsTurboV25Input(BaseModel):
+    """Input schema for ElevenLabs TTS Turbo v2.5 generation.
+
+    Artifact fields are automatically detected via type introspection
+    and resolved from generation IDs to artifact objects.
+    """
+
+    text: str = Field(
+        description="The text to convert to speech",
+        min_length=1,
+    )
+
+    voice: str = Field(
+        default="Rachel",
+        description=(
+            "Voice selection from predefined options (Aria, Roger, Sarah, Laura, Rachel, etc.)"
+        ),
+    )
+
+    stability: float = Field(
+        default=0.5,
+        ge=0.0,
+        le=1.0,
+        description="Voice stability (0-1)",
+    )
+
+    similarity_boost: float = Field(
+        default=0.75,
+        ge=0.0,
+        le=1.0,
+        description="Voice similarity control (0-1)",
+    )
+
+    style: float = Field(
+        default=0.0,
+        ge=0.0,
+        le=1.0,
+        description="Style exaggeration (0-1)",
+    )
+
+    speed: float = Field(
+        default=1.0,
+        ge=0.7,
+        le=1.2,
+        description="Speech tempo adjustment (0.7-1.2x)",
+    )
+
+    timestamps: bool = Field(
+        default=False,
+        description="Include word-level timing data in output",
+    )
+
+    language_code: str | None = Field(
+        default=None,
+        description="ISO 639-1 language code for language enforcement (Turbo v2.5 only)",
+    )
+
+    previous_text: str | None = Field(
+        default=None,
+        description="Prior context for speech continuity when concatenating generations",
+    )
+
+    next_text: str | None = Field(
+        default=None,
+        description="Subsequent context for speech continuity when concatenating generations",
+    )
+
+
+class FalElevenlabsTtsTurboV25Generator(BaseGenerator):
+    """Generator for high-speed text-to-speech using ElevenLabs TTS Turbo v2.5."""
+
+    name = "fal-elevenlabs-tts-turbo-v2-5"
+    description = (
+        "Fal: ElevenLabs TTS Turbo v2.5 - "
+        "High-speed text-to-speech with customizable voices and prosody"
+    )
+    artifact_type = "audio"
+
+    def get_input_schema(self) -> type[FalElevenlabsTtsTurboV25Input]:
+        """Return the input schema for this generator."""
+        return FalElevenlabsTtsTurboV25Input
+
+    async def generate(
+        self, inputs: FalElevenlabsTtsTurboV25Input, context: GeneratorExecutionContext
+    ) -> GeneratorResult:
+        """Generate audio using fal.ai ElevenLabs TTS Turbo v2.5."""
+        # Check for API key
+        if not os.getenv("FAL_KEY"):
+            raise ValueError("API configuration invalid. Missing FAL_KEY environment variable")
+
+        # Import fal_client
+        try:
+            import fal_client
+        except ImportError as e:
+            raise ImportError(
+                "fal.ai SDK is required for FalElevenlabsTtsTurboV25Generator. "
+                "Install with: pip install weirdfingers-boards[generators-fal]"
+            ) from e
+
+        # Prepare arguments for fal.ai API
+        arguments = {
+            "text": inputs.text,
+            "voice": inputs.voice,
+            "stability": inputs.stability,
+            "similarity_boost": inputs.similarity_boost,
+            "style": inputs.style,
+            "speed": inputs.speed,
+            "timestamps": inputs.timestamps,
+        }
+
+        # Add optional fields only if provided
+        if inputs.language_code is not None:
+            arguments["language_code"] = inputs.language_code
+        if inputs.previous_text is not None:
+            arguments["previous_text"] = inputs.previous_text
+        if inputs.next_text is not None:
+            arguments["next_text"] = inputs.next_text
+
+        # Submit async job
+        handler = await fal_client.submit_async(
+            "fal-ai/elevenlabs/tts/turbo-v2.5",
+            arguments=arguments,
+        )
+
+        # Store external job ID
+        await context.set_external_job_id(handler.request_id)
+
+        # Stream progress updates
+        from .....progress.models import ProgressUpdate
+
+        event_count = 0
+        async for event in handler.iter_events(with_logs=True):
+            event_count += 1
+            # Sample every 3rd event to avoid spam
+            if event_count % 3 == 0:
+                # Extract logs if available
+                logs = getattr(event, "logs", None)
+                if logs:
+                    # Join log entries into a single message
+                    if isinstance(logs, list):
+                        message = " | ".join(str(log) for log in logs if log)
+                    else:
+                        message = str(logs)
+
+                    if message:
+                        await context.publish_progress(
+                            ProgressUpdate(
+                                job_id=handler.request_id,
+                                status="processing",
+                                progress=50.0,
+                                phase="processing",
+                                message=message,
+                            )
+                        )
+
+        # Get final result
+        result = await handler.get()
+
+        # Extract audio URL from result
+        # fal.ai returns: {"audio": {"url": "...", "content_type": "...", ...}}
+        audio_data = result.get("audio")
+        if audio_data is None:
+            raise ValueError("No audio data returned from fal.ai API")
+
+        audio_url = audio_data.get("url")
+        if not audio_url:
+            raise ValueError("Audio URL missing in fal.ai response")
+
+        # Store audio result
+        artifact = await context.store_audio_result(
+            storage_url=audio_url,
+            format="mp3",  # ElevenLabs TTS returns MP3 format
+            output_index=0,
+        )
+
+        return GeneratorResult(outputs=[artifact])
+
+    async def estimate_cost(self, inputs: FalElevenlabsTtsTurboV25Input) -> float:
+        """Estimate cost for ElevenLabs TTS Turbo v2.5 generation.
+
+        ElevenLabs TTS Turbo v2.5 pricing is typically based on character count.
+        Using a conservative estimate of $0.001 per character for turbo models.
+        """
+        # Calculate character count
+        char_count = len(inputs.text)
+
+        # Estimated cost: $0.001 per character (adjust based on actual pricing)
+        # This is a placeholder - actual pricing should be verified
+        return char_count * 0.001

package/templates/api/src/boards/generators/implementations/fal/audio/fal_minimax_speech_26_hd.py

@@ -0,0 +1,237 @@
+"""
+Text-to-speech generation using Minimax Speech 2.6-HD.
+
+Based on Fal AI's fal-ai/minimax/speech-2.6-hd model.
+See: https://fal.ai/models/fal-ai/minimax/speech-2.6-hd
+"""
+
+import os
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
+
+
+class VoiceSetting(BaseModel):
+    """Voice settings for speech synthesis."""
+
+    voice_id: str = Field(
+        default="Wise_Woman",
+        description="Voice ID from predefined voices (e.g., Wise_Woman, Young_Man, etc.)",
+    )
+    speed: float = Field(
+        default=1.0,
+        ge=0.5,
+        le=2.0,
+        description="Speech speed multiplier (0.5-2.0)",
+    )
+    vol: float = Field(
+        default=1.0,
+        ge=0.01,
+        le=10.0,
+        description="Volume level (0.01-10)",
+    )
+    pitch: int = Field(
+        default=0,
+        ge=-12,
+        le=12,
+        description="Pitch adjustment in semitones (-12 to 12)",
+    )
+    emotion: str | None = Field(
+        default=None,
+        description=(
+            "Emotion for speech (happy, sad, angry, fearful, disgusted, surprised, neutral)"
+        ),
+    )
+    english_normalization: bool = Field(
+        default=False,
+        description="Enable English text normalization",
+    )
+
+
+class AudioSetting(BaseModel):
+    """Audio output settings."""
+
+    format: Literal["mp3", "pcm", "flac"] = Field(
+        default="mp3",
+        description="Output audio format",
+    )
+    sample_rate: Literal[8000, 16000, 22050, 24000, 32000, 44100] = Field(
+        default=32000,
+        description="Sample rate in Hz",
+    )
+    channel: Literal[1, 2] = Field(
+        default=1,
+        description="Number of audio channels (1=mono, 2=stereo)",
+    )
+    bitrate: Literal[32000, 64000, 128000, 256000] = Field(
+        default=128000,
+        description="Audio bitrate in bits per second",
+    )
+
+
+class NormalizationSetting(BaseModel):
+    """Audio normalization settings."""
+
+    enabled: bool = Field(
+        default=True,
+        description="Enable audio normalization",
+    )
+    target_loudness: float = Field(
+        default=-18.0,
+        ge=-70.0,
+        le=-10.0,
+        description="Target loudness in LUFS (-70 to -10)",
+    )
+    target_range: float = Field(
+        default=8.0,
+        ge=0.0,
+        le=20.0,
+        description="Target loudness range in LU (0-20)",
+    )
+    target_peak: float = Field(
+        default=-0.5,
+        ge=-3.0,
+        le=0.0,
+        description="Target peak level in dBTP (-3 to 0)",
+    )
+
+
+class FalMinimaxSpeech26HdInput(BaseModel):
+    """Input schema for Fal Minimax Speech 2.6-HD generator."""
+
+    prompt: str = Field(
+        description=(
+            "Text to convert to speech. Paragraph breaks should be marked with newline characters."
+        ),
+        min_length=1,
+        max_length=10000,
+    )
+    language_boost: str | None = Field(
+        default=None,
+        description=(
+            "Language boost option. Supports: Chinese, English, Arabic, Russian, Spanish, "
+            "French, Portuguese, German, Turkish, Dutch, Ukrainian, Vietnamese, Indonesian, "
+            "Japanese, Italian, Korean, Thai, Polish, Romanian, Greek, Czech, Finnish, Hindi, "
+            "Bulgarian, Danish, Hebrew, Malay, Slovak, Swedish, Croatian, Hungarian, "
+            "Norwegian, Slovenian, Catalan, Nynorsk, Afrikaans"
+        ),
+    )
+    output_format: Literal["hex", "url"] = Field(
+        default="url",
+        description=(
+            "Output format for audio data (url returns a downloadable link, hex returns raw data)"
+        ),
+    )
+    voice_setting: VoiceSetting = Field(
+        default_factory=VoiceSetting,
+        description="Voice customization settings",
+    )
+    audio_setting: AudioSetting = Field(
+        default_factory=AudioSetting,
+        description="Audio output format settings",
+    )
+    normalization_setting: NormalizationSetting = Field(
+        default_factory=NormalizationSetting,
+        description="Audio normalization settings",
+    )
+
+
+class FalMinimaxSpeech26HdGenerator(BaseGenerator):
+    """Generator for text-to-speech using Minimax Speech 2.6-HD."""
+
+    name = "fal-minimax-speech-26-hd"
+    description = (
+        "High-quality text-to-speech generation with extensive voice customization options"
+    )
+    artifact_type = "audio"
+
+    def get_input_schema(self) -> type[FalMinimaxSpeech26HdInput]:
+        """Return the input schema for this generator."""
+        return FalMinimaxSpeech26HdInput
+
+    async def generate(
+        self, inputs: FalMinimaxSpeech26HdInput, context: GeneratorExecutionContext
+    ) -> GeneratorResult:
+        """Generate audio using fal.ai minimax/speech-2.6-hd."""
+        # Check for API key
+        if not os.getenv("FAL_KEY"):
+            raise ValueError("API configuration invalid. Missing FAL_KEY environment variable")
+
+        # Import fal_client
+        try:
+            import fal_client
+        except ImportError as e:
+            raise ImportError(
+                "fal.ai SDK is required for FalMinimaxSpeech26HdGenerator. "
+                "Install with: pip install weirdfingers-boards[generators-fal]"
+            ) from e
+
+        # Prepare arguments for fal.ai API
+        arguments: dict = {
+            "prompt": inputs.prompt,
+            "output_format": inputs.output_format,
+            "voice_setting": inputs.voice_setting.model_dump(exclude_none=True),
+            "audio_setting": inputs.audio_setting.model_dump(),
+            "normalization_setting": inputs.normalization_setting.model_dump(),
+        }
+
+        # Only add language_boost if specified
+        if inputs.language_boost:
+            arguments["language_boost"] = inputs.language_boost
+
+        # Submit async job
+        handler = await fal_client.submit_async(
+            "fal-ai/minimax/speech-2.6-hd",
+            arguments=arguments,
+        )
+
+        # Store external job ID
+        await context.set_external_job_id(handler.request_id)
+
+        # Stream progress updates
+        from .....progress.models import ProgressUpdate
+
+        event_count = 0
+        async for _event in handler.iter_events(with_logs=True):
+            event_count += 1
+            # Sample every 3rd event to avoid spam
+            if event_count % 3 == 0:
+                await context.publish_progress(
+                    ProgressUpdate(
+                        job_id=handler.request_id,
+                        status="processing",
+                        progress=50.0,
+                        phase="processing",
+                    )
+                )
+
+        # Get final result
+        result = await handler.get()
+
+        # Extract audio output
+        audio_data = result.get("audio")
+        if audio_data is None:
+            raise ValueError("No audio data returned from API")
+
+        if not isinstance(audio_data, dict):
+            raise ValueError(f"Unexpected audio data type: {type(audio_data)}")
+
+        audio_url = audio_data.get("url")
+        if not audio_url:
+            raise ValueError("Audio URL missing")
+
+        artifact = await context.store_audio_result(
+            storage_url=audio_url,
+            format=inputs.audio_setting.format,
+            output_index=0,
+        )
+
+        return GeneratorResult(outputs=[artifact])
+
+    async def estimate_cost(self, inputs: FalMinimaxSpeech26HdInput) -> float:
+        """Estimate cost for this generation in USD."""
+        # Minimax Speech 2.6-HD pricing (estimated at $0.015 per generation)
+        # This is a reasonable estimate for TTS models
+        return 0.015

package/templates/api/src/boards/generators/implementations/fal/audio/minimax_speech_2_6_turbo.py

@@ -73,7 +73,7 @@ class MinimaxSpeech26TurboInput(BaseModel):
 
     prompt: str = Field(
         description=(
-            "Text to convert to speech " "(supports pause markers <#x#> with 0.01-99.99 seconds)"
+            "Text to convert to speech (supports pause markers <#x#> with 0.01-99.99 seconds)"
         ),
         min_length=1,
         max_length=10000,