@weirdfingers/baseboards 0.6.2 → 0.8.0

package/templates/api/src/boards/generators/implementations/fal/image/reve_text_to_image.py

@@ -0,0 +1,155 @@
+"""
+fal.ai Reve text-to-image generator.
+
+Reve's text-to-image model generates detailed visual output that closely follows
+your instructions, with strong aesthetic quality and accurate text rendering.
+
+Based on Fal AI's fal-ai/reve/text-to-image model.
+See: https://fal.ai/models/fal-ai/reve/text-to-image
+"""
+
+import os
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
+
+
+class ReveTextToImageInput(BaseModel):
+    """Input schema for Reve text-to-image generation."""
+
+    prompt: str = Field(
+        description="Text description of desired image",
+        min_length=1,
+        max_length=2560,
+    )
+    num_images: int = Field(
+        default=1,
+        ge=1,
+        le=4,
+        description="Number of images to generate",
+    )
+    aspect_ratio: Literal["16:9", "9:16", "3:2", "2:3", "4:3", "3:4", "1:1"] = Field(
+        default="3:2",
+        description="Desired image aspect ratio",
+    )
+    output_format: Literal["png", "jpeg", "webp"] = Field(
+        default="png",
+        description="Output image format",
+    )
+
+
+class FalReveTextToImageGenerator(BaseGenerator):
+    """Reve text-to-image generator using fal.ai."""
+
+    name = "fal-reve-text-to-image"
+    artifact_type = "image"
+    description = (
+        "Fal: Reve - detailed text-to-image with strong aesthetic quality "
+        "and accurate text rendering"
+    )
+
+    def get_input_schema(self) -> type[ReveTextToImageInput]:
+        return ReveTextToImageInput
+
+    async def generate(
+        self, inputs: ReveTextToImageInput, context: GeneratorExecutionContext
+    ) -> GeneratorResult:
+        """Generate images using fal.ai Reve text-to-image 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 FalReveTextToImageGenerator. "
+                "Install with: pip install weirdfingers-boards[generators-fal]"
+            ) from e
+
+        # Prepare arguments for fal.ai API
+        arguments = {
+            "prompt": inputs.prompt,
+            "num_images": inputs.num_images,
+            "aspect_ratio": inputs.aspect_ratio,
+            "output_format": inputs.output_format,
+        }
+
+        # Submit async job and get handler
+        handler = await fal_client.submit_async(
+            "fal-ai/reve/text-to-image",
+            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 image URLs from result
+        # fal.ai returns: {"images": [{"url": "...", "width": ..., "height": ...}, ...]}
+        images = result.get("images", [])
+        if not images:
+            raise ValueError("No images returned from fal.ai API")
+
+        # Store each image using output_index
+        artifacts = []
+        for idx, image_data in enumerate(images):
+            image_url = image_data.get("url")
+            width = image_data.get("width")
+            height = image_data.get("height")
+
+            if not image_url:
+                raise ValueError(f"Image {idx} missing URL in fal.ai response")
+
+            # Store with appropriate output_index
+            artifact = await context.store_image_result(
+                storage_url=image_url,
+                format=inputs.output_format,
+                width=width,
+                height=height,
+                output_index=idx,
+            )
+            artifacts.append(artifact)
+
+        return GeneratorResult(outputs=artifacts)
+
+    async def estimate_cost(self, inputs: ReveTextToImageInput) -> float:
+        """Estimate cost for Reve text-to-image generation.
+
+        Reve typically costs around $0.03 per image.
+        """
+        return 0.03 * inputs.num_images

package/templates/api/src/boards/generators/implementations/fal/image/seedream_v45_text_to_image.py

@@ -0,0 +1,180 @@
+"""
+Generate high-quality images using ByteDance's Seedream 4.5 text-to-image model.
+
+Based on Fal AI's fal-ai/bytedance/seedream/v4.5/text-to-image model.
+See: https://fal.ai/models/fal-ai/bytedance/seedream/v4.5/text-to-image
+"""
+
+import os
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
+
+
+class SeedreamV45TextToImageInput(BaseModel):
+    """Input schema for Seedream V4.5 text-to-image generation.
+
+    Seedream 4.5 is ByteDance's new-generation image creation model that integrates
+    image generation and editing capabilities into a unified architecture.
+    """
+
+    prompt: str = Field(description="The text prompt used to generate the image")
+    num_images: int = Field(
+        default=1,
+        ge=1,
+        le=6,
+        description="Number of images to generate",
+    )
+    image_size: (
+        Literal[
+            "square_hd",
+            "portrait_4_3",
+            "landscape_16_9",
+            "auto_2K",
+            "auto_4K",
+        ]
+        | None
+    ) = Field(
+        default=None,
+        description=(
+            "The size preset for the generated image. Options include "
+            "square_hd, portrait_4_3, landscape_16_9, auto_2K, auto_4K"
+        ),
+    )
+    seed: int | None = Field(
+        default=None,
+        description="Random seed for reproducibility",
+    )
+    enable_safety_checker: bool = Field(
+        default=True,
+        description="Enable or disable the safety checker",
+    )
+
+
+class FalSeedreamV45TextToImageGenerator(BaseGenerator):
+    """Generator for high-quality images using ByteDance's Seedream 4.5 model."""
+
+    name = "fal-seedream-v45-text-to-image"
+    artifact_type = "image"
+    description = "Fal: ByteDance Seedream 4.5 - high-quality text-to-image generation"
+
+    def get_input_schema(self) -> type[SeedreamV45TextToImageInput]:
+        """Return the input schema for this generator."""
+        return SeedreamV45TextToImageInput
+
+    async def generate(
+        self, inputs: SeedreamV45TextToImageInput, context: GeneratorExecutionContext
+    ) -> GeneratorResult:
+        """Generate images using fal.ai ByteDance Seedream 4.5 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 FalSeedreamV45TextToImageGenerator. "
+                "Install with: pip install weirdfingers-boards[generators-fal]"
+            ) from e
+
+        # Prepare arguments for fal.ai API
+        arguments: dict[str, object] = {
+            "prompt": inputs.prompt,
+            "num_images": inputs.num_images,
+            "enable_safety_checker": inputs.enable_safety_checker,
+        }
+
+        # Add optional parameters
+        if inputs.image_size is not None:
+            arguments["image_size"] = inputs.image_size
+
+        if inputs.seed is not None:
+            arguments["seed"] = inputs.seed
+
+        # Submit async job and get handler
+        handler = await fal_client.submit_async(
+            "fal-ai/bytedance/seedream/v4.5/text-to-image",
+            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 image data from result
+        # fal.ai seedream returns:
+        # {"images": [{"url": "...", "width": ..., "height": ..., ...}], "seed": ...}
+        images = result.get("images", [])
+        if not images:
+            raise ValueError("No images returned from fal.ai API")
+
+        # Store each image using output_index
+        artifacts = []
+        for idx, image_data in enumerate(images):
+            image_url = image_data.get("url")
+
+            if not image_url:
+                raise ValueError(f"Image {idx} missing URL in fal.ai response")
+
+            # Extract dimensions if available, use defaults otherwise
+            width = image_data.get("width", 2048)
+            height = image_data.get("height", 2048)
+
+            # Determine format from content_type (e.g., "image/png" -> "png")
+            content_type = image_data.get("content_type", "image/png")
+            format = content_type.split("/")[-1] if "/" in content_type else "png"
+
+            # Store with appropriate output_index
+            artifact = await context.store_image_result(
+                storage_url=image_url,
+                format=format,
+                width=width,
+                height=height,
+                output_index=idx,
+            )
+            artifacts.append(artifact)
+
+        return GeneratorResult(outputs=artifacts)
+
+    async def estimate_cost(self, inputs: SeedreamV45TextToImageInput) -> float:
+        """Estimate cost for Seedream V4.5 generation.
+
+        Seedream V4.5 pricing is approximately $0.03 per image generation.
+        Note: Actual pricing may vary. Check Fal AI documentation for current rates.
+        """
+        return 0.03 * inputs.num_images

package/templates/api/src/boards/generators/implementations/fal/video/__init__.py

@@ -13,6 +13,10 @@ from .fal_minimax_hailuo_02_standard_text_to_video import (
 from .fal_pixverse_lipsync import FalPixverseLipsyncGenerator
 from .fal_sora_2_text_to_video import FalSora2TextToVideoGenerator
 from .infinitalk import FalInfinitalkGenerator
+from .kling_video_ai_avatar_v2_pro import FalKlingVideoAiAvatarV2ProGenerator
+from .kling_video_ai_avatar_v2_standard import (
+    FalKlingVideoAiAvatarV2StandardGenerator,
+)
 from .kling_video_v2_5_turbo_pro_image_to_video import (
     FalKlingVideoV25TurboProImageToVideoGenerator,
 )
@@ -27,11 +31,17 @@ from .sora_2_image_to_video_pro import FalSora2ImageToVideoProGenerator
 from .sora_2_text_to_video_pro import FalSora2TextToVideoProGenerator
 from .sync_lipsync_v2 import FalSyncLipsyncV2Generator
 from .sync_lipsync_v2_pro import FalSyncLipsyncV2ProGenerator
+from .veed_fabric_1_0 import FalVeedFabric10Generator
 from .veed_lipsync import FalVeedLipsyncGenerator
 from .veo3 import FalVeo3Generator
+from .veo31 import FalVeo31Generator
+from .veo31_fast import FalVeo31FastGenerator
+from .veo31_fast_image_to_video import FalVeo31FastImageToVideoGenerator
 from .veo31_first_last_frame_to_video import FalVeo31FirstLastFrameToVideoGenerator
 from .veo31_image_to_video import FalVeo31ImageToVideoGenerator
 from .veo31_reference_to_video import FalVeo31ReferenceToVideoGenerator
+from .wan_25_preview_image_to_video import FalWan25PreviewImageToVideoGenerator
+from .wan_25_preview_text_to_video import FalWan25PreviewTextToVideoGenerator
 from .wan_pro_image_to_video import FalWanProImageToVideoGenerator
 
 __all__ = [
@@ -39,6 +49,8 @@ __all__ = [
     "FalCreatifyLipsyncGenerator",
     "FalBytedanceSeedanceV1ProImageToVideoGenerator",
     "FalBytedanceSeedanceV1ProTextToVideoGenerator",
+    "FalKlingVideoAiAvatarV2ProGenerator",
+    "FalKlingVideoAiAvatarV2StandardGenerator",
     "FalKlingVideoV25TurboProImageToVideoGenerator",
     "FalKlingVideoV25TurboProTextToVideoGenerator",
     "FalPixverseLipsyncGenerator",
@@ -49,11 +61,17 @@ __all__ = [
     "FalSora2ImageToVideoGenerator",
     "FalSora2ImageToVideoProGenerator",
     "FalSyncLipsyncV2Generator",
+    "FalVeedFabric10Generator",
     "FalVeedLipsyncGenerator",
     "FalSyncLipsyncV2ProGenerator",
     "FalVeo3Generator",
+    "FalVeo31Generator",
+    "FalVeo31FastGenerator",
+    "FalVeo31FastImageToVideoGenerator",
     "FalVeo31FirstLastFrameToVideoGenerator",
     "FalVeo31ImageToVideoGenerator",
     "FalVeo31ReferenceToVideoGenerator",
+    "FalWan25PreviewImageToVideoGenerator",
+    "FalWan25PreviewTextToVideoGenerator",
     "FalWanProImageToVideoGenerator",
 ]

package/templates/api/src/boards/generators/implementations/fal/video/kling_video_ai_avatar_v2_pro.py

@@ -0,0 +1,168 @@
+"""
+fal.ai Kling Video AI Avatar v2 Pro generator.
+
+Transforms static portrait images into synchronized talking avatar videos
+with audio-driven facial animation. Supports realistic humans, animals,
+cartoons, and stylized figures.
+
+Based on Fal AI's fal-ai/kling-video/ai-avatar/v2/pro model.
+See: https://fal.ai/models/fal-ai/kling-video/ai-avatar/v2/pro
+"""
+
+import os
+
+from pydantic import BaseModel, Field
+
+from ....artifacts import AudioArtifact, ImageArtifact
+from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
+
+
+class KlingVideoAiAvatarV2ProInput(BaseModel):
+    """Input schema for kling-video/ai-avatar/v2/pro.
+
+    Artifact fields are automatically detected via type introspection
+    and resolved from generation IDs to artifact objects.
+    """
+
+    image: ImageArtifact = Field(description="The image to use as your avatar")
+    audio: AudioArtifact = Field(description="The audio file for lip-sync animation")
+    prompt: str = Field(
+        default=".",
+        description="Optional prompt to refine animation details",
+    )
+
+
+class FalKlingVideoAiAvatarV2ProGenerator(BaseGenerator):
+    """Generator for AI avatar talking videos using Kling Video AI Avatar v2 Pro."""
+
+    name = "fal-kling-video-ai-avatar-v2-pro"
+    description = (
+        "Fal: Kling Video AI Avatar v2 Pro - "
+        "Transform portraits into talking avatar videos with audio-driven facial animation"
+    )
+    artifact_type = "video"
+
+    def get_input_schema(self) -> type[KlingVideoAiAvatarV2ProInput]:
+        """Return the input schema for this generator."""
+        return KlingVideoAiAvatarV2ProInput
+
+    async def generate(
+        self, inputs: KlingVideoAiAvatarV2ProInput, context: GeneratorExecutionContext
+    ) -> GeneratorResult:
+        """Generate talking avatar video using fal.ai kling-video/ai-avatar/v2/pro."""
+        # 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 FalKlingVideoAiAvatarV2ProGenerator. "
+                "Install with: pip install weirdfingers-boards[generators-fal]"
+            ) from e
+
+        # Upload image and audio artifacts to Fal's public storage
+        # Fal API requires publicly accessible URLs
+        from ..utils import upload_artifacts_to_fal
+
+        # Upload image and audio separately
+        image_urls = await upload_artifacts_to_fal([inputs.image], context)
+        audio_urls = await upload_artifacts_to_fal([inputs.audio], context)
+
+        # Prepare arguments for fal.ai API
+        arguments: dict[str, str] = {
+            "image_url": image_urls[0],
+            "audio_url": audio_urls[0],
+            "prompt": inputs.prompt,
+        }
+
+        # Submit async job
+        handler = await fal_client.submit_async(
+            "fal-ai/kling-video/ai-avatar/v2/pro",
+            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,  # Approximate mid-point progress
+                                phase="processing",
+                                message=message,
+                            )
+                        )
+
+        # Get final result
+        result = await handler.get()
+
+        # Extract video from result
+        # fal.ai returns: {"video": {"url": "...", "content_type": "..."}, "duration": ...}
+        video_data = result.get("video")
+
+        if not video_data:
+            raise ValueError("No video returned from fal.ai API")
+
+        video_url = video_data.get("url")
+        if not video_url:
+            raise ValueError("Video missing URL in fal.ai response")
+
+        # Extract format from content_type (e.g., "video/mp4" -> "mp4")
+        content_type = video_data.get("content_type", "video/mp4")
+        if content_type.startswith("video/"):
+            video_format = content_type.split("/")[-1]
+        else:
+            # Default to mp4 if content_type is not a video mime type
+            video_format = "mp4"
+
+        # Get duration from result if available
+        duration = result.get("duration")
+
+        # Store the video result
+        # Note: The API doesn't return width/height/fps, so we use reasonable defaults
+        artifact = await context.store_video_result(
+            storage_url=video_url,
+            format=video_format,
+            width=None,
+            height=None,
+            duration=duration,
+            fps=None,
+            output_index=0,
+        )
+
+        return GeneratorResult(outputs=[artifact])
+
+    async def estimate_cost(self, inputs: KlingVideoAiAvatarV2ProInput) -> float:
+        """Estimate cost for this generation in USD.
+
+        Pricing: $0.115 per second of generated video.
+        Cost depends on audio duration since the output video matches audio length.
+        """
+        # If audio duration is available, calculate based on that
+        if inputs.audio.duration is not None:
+            return 0.115 * inputs.audio.duration
+
+        # Default estimate for unknown duration (assume ~10 second video)
+        return 1.15