@weirdfingers/baseboards 0.5.3 → 0.6.0

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

@@ -0,0 +1,244 @@
+"""
+fal.ai Qwen image editing generator.
+
+An image editing model specializing in text editing within images.
+Based on Fal AI's qwen-image-edit model.
+See: https://fal.ai/models/fal-ai/qwen-image-edit
+"""
+
+import os
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from ....artifacts import ImageArtifact
+from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
+
+
+class ImageSize(BaseModel):
+    """Custom image size with explicit width and height."""
+
+    width: int = Field(default=512, ge=1, le=14142, description="Image width in pixels")
+    height: int = Field(default=512, ge=1, le=14142, description="Image height in pixels")
+
+
+class QwenImageEditInput(BaseModel):
+    """Input schema for Qwen image editing.
+
+    Artifact fields (like image_url) are automatically detected via type
+    introspection and resolved from generation IDs to ImageArtifact objects.
+    """
+
+    prompt: str = Field(description="Text guidance for image editing")
+    image_url: ImageArtifact = Field(description="Source image to be edited")
+    num_images: int = Field(
+        default=1,
+        ge=1,
+        le=4,
+        description="Number of edited images to generate",
+    )
+    image_size: (
+        Literal[
+            "square_hd",
+            "square",
+            "portrait_4_3",
+            "portrait_16_9",
+            "landscape_4_3",
+            "landscape_16_9",
+        ]
+        | ImageSize
+        | None
+    ) = Field(
+        default=None,
+        description=(
+            "Output image dimensions. Can be a preset (e.g., 'square_hd') or "
+            "custom dimensions with width/height"
+        ),
+    )
+    acceleration: Literal["none", "regular", "high"] = Field(
+        default="regular",
+        description="Speed optimization level",
+    )
+    output_format: Literal["jpeg", "png"] = Field(
+        default="png",
+        description="Output image format",
+    )
+    guidance_scale: float = Field(
+        default=4.0,
+        ge=0.0,
+        le=20.0,
+        description="CFG intensity controlling prompt adherence (0-20)",
+    )
+    num_inference_steps: int = Field(
+        default=30,
+        ge=2,
+        le=50,
+        description="Number of processing iterations for quality",
+    )
+    seed: int | None = Field(
+        default=None,
+        description="Random seed for reproducibility (optional)",
+    )
+    negative_prompt: str = Field(
+        default=" ",
+        description="Undesired characteristics to avoid in the edited image",
+    )
+    sync_mode: bool = Field(
+        default=False,
+        description=(
+            "If True, returns data URI instead of stored media "
+            "(output won't be available in request history)"
+        ),
+    )
+    enable_safety_checker: bool = Field(
+        default=True,
+        description="Enable NSFW content filtering",
+    )
+
+
+class FalQwenImageEditGenerator(BaseGenerator):
+    """Qwen image editing generator using fal.ai."""
+
+    name = "fal-qwen-image-edit"
+    artifact_type = "image"
+    description = "Fal: Qwen Image Edit - AI-powered image editing with text editing capabilities"
+
+    def get_input_schema(self) -> type[QwenImageEditInput]:
+        return QwenImageEditInput
+
+    async def generate(
+        self, inputs: QwenImageEditInput, context: GeneratorExecutionContext
+    ) -> GeneratorResult:
+        """Edit images using fal.ai qwen-image-edit 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 FalQwenImageEditGenerator. "
+                "Install with: pip install weirdfingers-boards[generators-fal]"
+            ) from e
+
+        # Upload image artifact to Fal's public storage
+        # Fal API requires publicly accessible URLs
+        from ..utils import upload_artifacts_to_fal
+
+        image_urls = await upload_artifacts_to_fal([inputs.image_url], context)
+        image_url = image_urls[0]
+
+        # Prepare arguments for fal.ai API
+        arguments = {
+            "prompt": inputs.prompt,
+            "image_url": image_url,
+            "num_images": inputs.num_images,
+            "acceleration": inputs.acceleration,
+            "output_format": inputs.output_format,
+            "guidance_scale": inputs.guidance_scale,
+            "num_inference_steps": inputs.num_inference_steps,
+            "negative_prompt": inputs.negative_prompt,
+            "sync_mode": inputs.sync_mode,
+            "enable_safety_checker": inputs.enable_safety_checker,
+        }
+
+        # Add optional fields if provided
+        if inputs.image_size is not None:
+            # If ImageSize object, convert to dict; otherwise use string directly
+            if isinstance(inputs.image_size, ImageSize):
+                arguments["image_size"] = {
+                    "width": inputs.image_size.width,
+                    "height": inputs.image_size.height,
+                }
+            else:
+                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/qwen-image-edit",
+            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": ..., "content_type": "..."}, ...],
+        #   "prompt": "...",
+        #   "seed": ...,
+        #   "has_nsfw_concepts": [...]
+        # }
+        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_result = image_data.get("url")
+            # Extract dimensions from the response
+            width = image_data.get("width", 1024)
+            height = image_data.get("height", 1024)
+
+            if not image_url_result:
+                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_result,
+                format=inputs.output_format,
+                width=width,
+                height=height,
+                output_index=idx,
+            )
+            artifacts.append(artifact)
+
+        return GeneratorResult(outputs=artifacts)
+
+    async def estimate_cost(self, inputs: QwenImageEditInput) -> float:
+        """Estimate cost for Qwen image edit generation.
+
+        Based on typical Fal image editing model pricing.
+        Using $0.05 per image as a reasonable estimate.
+        """
+        per_image_cost = 0.05
+        return per_image_cost * inputs.num_images

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

@@ -1,17 +1,59 @@
 """Fal.ai video generators."""
 
+from .bytedance_seedance_v1_pro_text_to_video import (
+    FalBytedanceSeedanceV1ProTextToVideoGenerator,
+)
+from .creatify_lipsync import FalCreatifyLipsyncGenerator
+from .fal_bytedance_seedance_v1_pro_image_to_video import (
+    FalBytedanceSeedanceV1ProImageToVideoGenerator,
+)
+from .fal_minimax_hailuo_02_standard_text_to_video import (
+    FalMinimaxHailuo02StandardTextToVideoGenerator,
+)
+from .fal_pixverse_lipsync import FalPixverseLipsyncGenerator
+from .fal_sora_2_text_to_video import FalSora2TextToVideoGenerator
+from .infinitalk import FalInfinitalkGenerator
+from .kling_video_v2_5_turbo_pro_image_to_video import (
+    FalKlingVideoV25TurboProImageToVideoGenerator,
+)
 from .kling_video_v2_5_turbo_pro_text_to_video import (
     FalKlingVideoV25TurboProTextToVideoGenerator,
 )
+from .minimax_hailuo_2_3_pro_image_to_video import (
+    FalMinimaxHailuo23ProImageToVideoGenerator,
+)
+from .sora2_image_to_video import FalSora2ImageToVideoGenerator
+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_lipsync import FalVeedLipsyncGenerator
+from .veo3 import FalVeo3Generator
 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_pro_image_to_video import FalWanProImageToVideoGenerator
 
 __all__ = [
+    "FalInfinitalkGenerator",
+    "FalCreatifyLipsyncGenerator",
+    "FalBytedanceSeedanceV1ProImageToVideoGenerator",
+    "FalBytedanceSeedanceV1ProTextToVideoGenerator",
+    "FalKlingVideoV25TurboProImageToVideoGenerator",
     "FalKlingVideoV25TurboProTextToVideoGenerator",
+    "FalPixverseLipsyncGenerator",
+    "FalSora2TextToVideoProGenerator",
+    "FalSora2TextToVideoGenerator",
+    "FalMinimaxHailuo02StandardTextToVideoGenerator",
+    "FalMinimaxHailuo23ProImageToVideoGenerator",
+    "FalSora2ImageToVideoGenerator",
+    "FalSora2ImageToVideoProGenerator",
     "FalSyncLipsyncV2Generator",
+    "FalVeedLipsyncGenerator",
+    "FalSyncLipsyncV2ProGenerator",
+    "FalVeo3Generator",
     "FalVeo31FirstLastFrameToVideoGenerator",
     "FalVeo31ImageToVideoGenerator",
     "FalVeo31ReferenceToVideoGenerator",
+    "FalWanProImageToVideoGenerator",
 ]

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

@@ -0,0 +1,209 @@
+"""
+Bytedance Seedance 1.0 Pro text-to-video generator.
+
+A high quality video generation model developed by Bytedance that transforms
+text prompts into professional-grade videos with customizable parameters.
+
+Based on Fal AI's fal-ai/bytedance/seedance/v1/pro/text-to-video model.
+See: https://fal.ai/models/fal-ai/bytedance/seedance/v1/pro/text-to-video
+"""
+
+import os
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
+
+
+class BytedanceSeedanceV1ProTextToVideoInput(BaseModel):
+    """Input schema for Bytedance Seedance 1.0 Pro text-to-video generation."""
+
+    prompt: str = Field(
+        description="Text description of the desired video content",
+    )
+    aspect_ratio: Literal["21:9", "16:9", "4:3", "1:1", "3:4", "9:16"] = Field(
+        default="16:9",
+        description="Video aspect ratio",
+    )
+    resolution: Literal["480p", "720p", "1080p"] = Field(
+        default="1080p",
+        description="Video resolution quality",
+    )
+    duration: Literal["2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"] = Field(
+        default="5",
+        description="Video length in seconds (2-12)",
+    )
+    enable_safety_checker: bool = Field(
+        default=True,
+        description="Enable safety checker to filter unsafe content",
+    )
+    camera_fixed: bool = Field(
+        default=False,
+        description="Whether to fix camera position during generation",
+    )
+    seed: int | None = Field(
+        default=None,
+        description="Random seed for reproducibility; use -1 for randomization",
+    )
+
+
+class FalBytedanceSeedanceV1ProTextToVideoGenerator(BaseGenerator):
+    """Generator for text-to-video using Bytedance Seedance 1.0 Pro."""
+
+    name = "fal-bytedance-seedance-v1-pro-text-to-video"
+    description = "Fal: Bytedance Seedance 1.0 Pro - high quality text-to-video generation"
+    artifact_type = "video"
+
+    def get_input_schema(self) -> type[BytedanceSeedanceV1ProTextToVideoInput]:
+        """Return the input schema for this generator."""
+        return BytedanceSeedanceV1ProTextToVideoInput
+
+    async def generate(
+        self, inputs: BytedanceSeedanceV1ProTextToVideoInput, context: GeneratorExecutionContext
+    ) -> GeneratorResult:
+        """Generate video using fal.ai Bytedance Seedance 1.0 Pro model."""
+        # 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 FalBytedanceSeedanceV1ProTextToVideoGenerator. "
+                "Install with: pip install weirdfingers-boards[generators-fal]"
+            ) from e
+
+        # Prepare arguments for fal.ai API
+        arguments = {
+            "prompt": inputs.prompt,
+            "aspect_ratio": inputs.aspect_ratio,
+            "resolution": inputs.resolution,
+            "duration": inputs.duration,
+            "enable_safety_checker": inputs.enable_safety_checker,
+            "camera_fixed": inputs.camera_fixed,
+        }
+
+        # Add seed if provided
+        if inputs.seed is not None:
+            arguments["seed"] = inputs.seed
+
+        # Submit async job
+        handler = await fal_client.submit_async(
+            "fal-ai/bytedance/seedance/v1/pro/text-to-video",
+            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": "video/mp4", ...}, "seed": 123}
+        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")
+
+        # Calculate video dimensions based on aspect ratio and resolution
+        width, height = self._calculate_dimensions(inputs.aspect_ratio, inputs.resolution)
+
+        # Store video result
+        artifact = await context.store_video_result(
+            storage_url=video_url,
+            format="mp4",
+            width=width,
+            height=height,
+            duration=float(inputs.duration),
+            output_index=0,
+        )
+
+        return GeneratorResult(outputs=[artifact])
+
+    def _calculate_dimensions(self, aspect_ratio: str, resolution: str) -> tuple[int, int]:
+        """Calculate video dimensions based on aspect ratio and resolution.
+
+        Args:
+            aspect_ratio: Video aspect ratio (e.g., "16:9", "21:9")
+            resolution: Video resolution (e.g., "1080p", "720p", "480p")
+
+        Returns:
+            Tuple of (width, height) in pixels
+        """
+        # Base heights for each resolution
+        resolution_heights = {
+            "1080p": 1080,
+            "720p": 720,
+            "480p": 480,
+        }
+
+        # Parse aspect ratio
+        aspect_parts = aspect_ratio.split(":")
+        aspect_width = int(aspect_parts[0])
+        aspect_height = int(aspect_parts[1])
+
+        # Get base height for resolution
+        height = resolution_heights[resolution]
+
+        # Calculate width based on aspect ratio
+        width = int((height * aspect_width) / aspect_height)
+
+        return width, height
+
+    async def estimate_cost(self, inputs: BytedanceSeedanceV1ProTextToVideoInput) -> float:
+        """Estimate cost for Bytedance Seedance 1.0 Pro generation.
+
+        Pricing information not provided in official documentation.
+        Estimated at $0.12 per video based on typical video generation costs.
+        Cost may vary based on duration and resolution settings.
+        """
+        # Base cost per video
+        base_cost = 0.12
+
+        # Adjust for longer durations (higher cost for longer videos)
+        duration_seconds = int(inputs.duration)
+        duration_multiplier = 1.0 + ((duration_seconds - 5) * 0.05)  # +5% per second above 5s
+
+        # Adjust for higher resolutions
+        resolution_multiplier = {
+            "480p": 0.8,  # Lower quality, lower cost
+            "720p": 1.0,  # Standard
+            "1080p": 1.3,  # Higher quality, higher cost
+        }[inputs.resolution]
+
+        return base_cost * duration_multiplier * resolution_multiplier

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

@@ -0,0 +1,161 @@
+"""
+fal.ai creatify/lipsync video generator.
+
+Generates realistic lip-synchronization videos from audio and video inputs
+using Creatify's lipsync model on fal.ai. Optimized for speed, quality, and
+consistency.
+
+Based on Fal AI's creatify/lipsync model.
+See: https://fal.ai/models/creatify/lipsync
+"""
+
+import os
+
+from pydantic import BaseModel, Field
+
+from ....artifacts import AudioArtifact, VideoArtifact
+from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
+
+
+class CreatifyLipsyncInput(BaseModel):
+    """Input schema for creatify/lipsync.
+
+    Artifact fields are automatically detected via type introspection
+    and resolved from generation IDs to artifact objects.
+    """
+
+    video: VideoArtifact = Field(description="The video to use for lipsync")
+    audio: AudioArtifact = Field(description="The audio to use for lipsync")
+    loop: bool = Field(
+        default=True,
+        description="Repeats video if shorter than audio",
+    )
+
+
+class FalCreatifyLipsyncGenerator(BaseGenerator):
+    """Generator for realistic lip-synchronization videos."""
+
+    name = "fal-creatify-lipsync"
+    description = "Fal: Creatify Lipsync - Realistic lipsync video optimized for speed and quality"
+    artifact_type = "video"
+
+    def get_input_schema(self) -> type[CreatifyLipsyncInput]:
+        """Return the input schema for this generator."""
+        return CreatifyLipsyncInput
+
+    async def generate(
+        self, inputs: CreatifyLipsyncInput, context: GeneratorExecutionContext
+    ) -> GeneratorResult:
+        """Generate lip-synced video using creatify/lipsync."""
+        # 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 FalCreatifyLipsyncGenerator. "
+                "Install with: pip install weirdfingers-boards[generators-fal]"
+            ) from e
+
+        # Upload video and audio artifacts to Fal's public storage
+        # Fal API requires publicly accessible URLs
+        from ..utils import upload_artifacts_to_fal
+
+        # Upload video and audio separately
+        video_urls = await upload_artifacts_to_fal([inputs.video], context)
+        audio_urls = await upload_artifacts_to_fal([inputs.audio], context)
+
+        # Prepare arguments for fal.ai API
+        arguments = {
+            "video_url": video_urls[0],
+            "audio_url": audio_urls[0],
+            "loop": inputs.loop,
+        }
+
+        # Submit async job
+        handler = await fal_client.submit_async(
+            "creatify/lipsync",
+            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": "video/mp4", ...}}
+        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")
+        # Creatify lipsync always produces MP4 videos, so default to mp4
+        content_type = video_data.get("content_type", "video/mp4")
+        if content_type.startswith("video/"):
+            video_format = content_type.split("/")[-1]
+        else:
+            # If content_type is not a video mime type (e.g., application/octet-stream),
+            # default to mp4 since creatify/lipsync only produces mp4 videos
+            video_format = "mp4"
+
+        # Store the video result
+        # Note: The API doesn't return width/height/duration/fps, so we use defaults
+        # The actual dimensions will be the same as the input video
+        artifact = await context.store_video_result(
+            storage_url=video_url,
+            format=video_format,
+            width=inputs.video.width,
+            height=inputs.video.height,
+            duration=inputs.audio.duration,
+            fps=inputs.video.fps,
+            output_index=0,
+        )
+
+        return GeneratorResult(outputs=[artifact])
+
+    async def estimate_cost(self, inputs: CreatifyLipsyncInput) -> float:
+        """Estimate cost for creatify/lipsync generation in USD.
+
+        Pricing not specified in documentation, using estimate based on
+        typical video processing costs.
+        """
+        # Base cost estimate per generation
+        return 0.05