@weirdfingers/baseboards 0.6.2 → 0.8.0

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

@@ -0,0 +1,190 @@
+"""
+Google Veo 3.1 Fast text-to-video generator.
+
+A faster, more cost-effective variant of Google's Veo 3.1 video generation model,
+capable of generating high-quality videos from text prompts with optional audio synthesis.
+
+Based on Fal AI's fal-ai/veo3.1/fast model.
+See: https://fal.ai/models/fal-ai/veo3.1/fast
+"""
+
+import os
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
+
+
+class Veo31FastInput(BaseModel):
+    """Input schema for Google Veo 3.1 Fast text-to-video generation."""
+
+    prompt: str = Field(description="The text prompt describing the video you want to generate")
+    aspect_ratio: Literal["9:16", "16:9"] = Field(
+        default="16:9",
+        description="Aspect ratio of the generated video",
+    )
+    duration: Literal["4s", "6s", "8s"] = Field(
+        default="8s",
+        description="Duration of the generated video",
+    )
+    resolution: Literal["720p", "1080p"] = Field(
+        default="720p",
+        description="Resolution of the generated video",
+    )
+    generate_audio: bool = Field(
+        default=True,
+        description="Whether to generate audio for the video. If false, 33% less credits used",
+    )
+    enhance_prompt: bool = Field(
+        default=True,
+        description="Whether to enhance video generation",
+    )
+    auto_fix: bool = Field(
+        default=True,
+        description="Automatically attempt to fix prompts that fail content policy",
+    )
+    seed: int | None = Field(
+        default=None,
+        description="Seed value for reproducible generation",
+    )
+    negative_prompt: str | None = Field(
+        default=None,
+        description="Guidance text to exclude from generation",
+    )
+
+
+class FalVeo31FastGenerator(BaseGenerator):
+    """Generator for text-to-video using Google Veo 3.1 Fast."""
+
+    name = "fal-veo31-fast"
+    description = "Fal: Veo 3.1 Fast - Google's fast AI video generation model"
+    artifact_type = "video"
+
+    def get_input_schema(self) -> type[Veo31FastInput]:
+        """Return the input schema for this generator."""
+        return Veo31FastInput
+
+    async def generate(
+        self, inputs: Veo31FastInput, context: GeneratorExecutionContext
+    ) -> GeneratorResult:
+        """Generate video using fal.ai veo3.1/fast."""
+        # 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 FalVeo31FastGenerator. "
+                "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,
+            "duration": inputs.duration,
+            "resolution": inputs.resolution,
+            "generate_audio": inputs.generate_audio,
+            "enhance_prompt": inputs.enhance_prompt,
+            "auto_fix": inputs.auto_fix,
+        }
+
+        # Add optional parameters if provided
+        if inputs.seed is not None:
+            arguments["seed"] = inputs.seed
+        if inputs.negative_prompt is not None:
+            arguments["negative_prompt"] = inputs.negative_prompt
+
+        # Submit async job
+        handler = await fal_client.submit_async(
+            "fal-ai/veo3.1/fast",
+            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 video from result
+        # Expected structure: {"video": {"url": "...", "content_type": "...", ...}}
+        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")
+
+        # Determine video dimensions based on resolution and aspect ratio
+        if inputs.resolution == "720p":
+            if inputs.aspect_ratio == "16:9":
+                width, height = 1280, 720
+            else:  # 9:16
+                width, height = 720, 1280
+        else:  # 1080p
+            if inputs.aspect_ratio == "16:9":
+                width, height = 1920, 1080
+            else:  # 9:16
+                width, height = 1080, 1920
+
+        # Parse duration from "8s" format
+        duration_seconds = int(inputs.duration.rstrip("s"))
+
+        # Store video result
+        artifact = await context.store_video_result(
+            storage_url=video_url,
+            format="mp4",
+            width=width,
+            height=height,
+            duration=duration_seconds,
+            output_index=0,
+        )
+
+        return GeneratorResult(outputs=[artifact])
+
+    async def estimate_cost(self, inputs: Veo31FastInput) -> float:
+        """Estimate cost for this generation in USD.
+
+        Note: Pricing information not available in Fal documentation.
+        Using placeholder value that should be updated with actual pricing.
+        """
+        # TODO: Update with actual pricing from Fal when available
+        # Base cost, with 33% reduction if audio is disabled
+        base_cost = 0.10  # Placeholder estimate for fast variant
+        if not inputs.generate_audio:
+            return base_cost * 0.67  # 33% discount
+        return base_cost

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

@@ -0,0 +1,191 @@
+"""
+Google Veo 3.1 Fast image-to-video generator.
+
+Converts static images into animated videos based on text prompts using
+Google's Veo 3.1 Fast technology via fal.ai. This is a faster version
+with per-second pricing.
+
+Based on Fal AI's fal-ai/veo3.1/fast/image-to-video model.
+See: https://fal.ai/models/fal-ai/veo3.1/fast/image-to-video
+"""
+
+import os
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from ....artifacts import ImageArtifact
+from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
+
+
+class Veo31FastImageToVideoInput(BaseModel):
+    """Input schema for Veo 3.1 Fast image-to-video generation.
+
+    Artifact fields (image) are automatically detected via type introspection
+    and resolved from generation IDs to ImageArtifact objects.
+    """
+
+    prompt: str = Field(description="Text prompt describing the desired video content and motion")
+    image: ImageArtifact = Field(
+        description="Input image to animate. Should be 720p or higher in 16:9 or 9:16 aspect ratio"
+    )
+    aspect_ratio: Literal["auto", "9:16", "16:9"] = Field(
+        default="auto",
+        description="Aspect ratio of the generated video. "
+        "'auto' automatically detects from input image",
+    )
+    duration: Literal["4s", "6s", "8s"] = Field(
+        default="8s",
+        description="Duration of the generated video in seconds",
+    )
+    generate_audio: bool = Field(
+        default=True,
+        description="Whether to generate audio for the video. Disabling reduces cost by ~33%",
+    )
+    resolution: Literal["720p", "1080p"] = Field(
+        default="720p",
+        description="Resolution of the generated video",
+    )
+
+
+class FalVeo31FastImageToVideoGenerator(BaseGenerator):
+    """Generator for creating videos from static images using Google Veo 3.1 Fast."""
+
+    name = "fal-veo31-fast-image-to-video"
+    description = "Fal: Veo 3.1 Fast - Convert images to videos with text-guided animation"
+    artifact_type = "video"
+
+    def get_input_schema(self) -> type[Veo31FastImageToVideoInput]:
+        """Return the input schema for this generator."""
+        return Veo31FastImageToVideoInput
+
+    async def generate(
+        self, inputs: Veo31FastImageToVideoInput, context: GeneratorExecutionContext
+    ) -> GeneratorResult:
+        """Generate video using fal.ai veo3.1/fast/image-to-video."""
+        # 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 FalVeo31FastImageToVideoGenerator. "
+                "Install with: pip install weirdfingers-boards[generators-fal]"
+            ) from e
+
+        # Upload image artifact to Fal's public storage
+        # Fal API requires publicly accessible URLs, but our storage_url might be:
+        # - Localhost URLs (not publicly accessible)
+        # - Private S3 buckets (not publicly accessible)
+        # So we upload to Fal's temporary storage first
+        from ..utils import upload_artifacts_to_fal
+
+        image_urls = await upload_artifacts_to_fal([inputs.image], context)
+
+        # Prepare arguments for fal.ai API
+        arguments = {
+            "prompt": inputs.prompt,
+            "image_url": image_urls[0],
+            "aspect_ratio": inputs.aspect_ratio,
+            "duration": inputs.duration,
+            "generate_audio": inputs.generate_audio,
+            "resolution": inputs.resolution,
+        }
+
+        # Submit async job
+        handler = await fal_client.submit_async(
+            "fal-ai/veo3.1/fast/image-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,
+                                phase="processing",
+                                message=message,
+                            )
+                        )
+
+        # Get final result
+        result = await handler.get()
+
+        # Extract video from result
+        # Expected structure: {"video": {"url": "...", "content_type": "...", ...}}
+        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 resolution and aspect ratio
+        # For "auto" aspect ratio, assume 16:9 as the most common format
+        effective_aspect_ratio = inputs.aspect_ratio if inputs.aspect_ratio != "auto" else "16:9"
+
+        if inputs.resolution == "720p":
+            if effective_aspect_ratio == "16:9":
+                width, height = 1280, 720
+            else:  # 9:16
+                width, height = 720, 1280
+        else:  # 1080p
+            if effective_aspect_ratio == "16:9":
+                width, height = 1920, 1080
+            else:  # 9:16
+                width, height = 1080, 1920
+
+        # Parse duration from "Xs" format
+        duration_seconds = int(inputs.duration.rstrip("s"))
+
+        artifact = await context.store_video_result(
+            storage_url=video_url,
+            format="mp4",
+            width=width,
+            height=height,
+            duration=duration_seconds,
+            output_index=0,
+        )
+
+        return GeneratorResult(outputs=[artifact])
+
+    async def estimate_cost(self, inputs: Veo31FastImageToVideoInput) -> float:
+        """Estimate cost for this generation in USD.
+
+        Pricing: $0.10 per second (audio off) or $0.15 per second (audio on).
+        """
+        # Parse duration from "Xs" format
+        duration_seconds = int(inputs.duration.rstrip("s"))
+
+        # Per-second pricing
+        if inputs.generate_audio:
+            cost_per_second = 0.15
+        else:
+            cost_per_second = 0.10
+
+        return duration_seconds * cost_per_second

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

@@ -27,9 +27,9 @@ class Veo31FirstLastFrameToVideoInput(BaseModel):
     first_frame: ImageArtifact = Field(description="The first frame of the video (input image)")
     last_frame: ImageArtifact = Field(description="The last frame of the video (input image)")
     prompt: str = Field(description="Text prompt describing the desired video content and motion")
-    duration: Literal["8s"] = Field(
+    duration: Literal["4s", "6s", "8s"] = Field(
         default="8s",
-        description="Duration of the generated video in seconds (currently only 8s is supported)",
+        description="Duration of the generated video in seconds",
     )
     aspect_ratio: Literal["auto", "9:16", "16:9", "1:1"] = Field(
         default="auto",
@@ -173,8 +173,15 @@ class FalVeo31FirstLastFrameToVideoGenerator(BaseGenerator):
         Using placeholder value that should be updated with actual pricing.
         """
         # TODO: Update with actual pricing from Fal when available
-        # Base cost, with 50% reduction if audio is disabled
-        base_cost = 0.15  # Placeholder estimate
+        # Parse duration from "8s" format
+        duration_seconds = int(inputs.duration.rstrip("s"))
+
+        # Base cost per 8 seconds, scaled by actual duration
+        base_cost_8s = 0.15  # Placeholder estimate for 8s
+        duration_multiplier = duration_seconds / 8.0
+        cost = base_cost_8s * duration_multiplier
+
+        # 50% reduction if audio is disabled
         if not inputs.generate_audio:
-            return base_cost * 0.5
-        return base_cost
+            return cost * 0.5
+        return cost

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

@@ -0,0 +1,212 @@
+"""
+WAN 2.5 Preview image-to-video generator.
+
+An image-to-video generation model that creates dynamic video content from static
+images using text prompts to guide motion and camera movement. Supports durations
+of 5 or 10 seconds at 480p, 720p, or 1080p resolution.
+
+Based on Fal AI's fal-ai/wan-25-preview/image-to-video model.
+See: https://fal.ai/models/fal-ai/wan-25-preview/image-to-video
+"""
+
+import os
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from ....artifacts import ImageArtifact
+from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
+
+
+class Wan25PreviewImageToVideoInput(BaseModel):
+    """Input schema for WAN 2.5 Preview image-to-video generation.
+
+    Artifact fields (image) are automatically detected via type introspection
+    and resolved from generation IDs to ImageArtifact objects.
+    """
+
+    image: ImageArtifact = Field(
+        description="The image to use as the first frame for video generation"
+    )
+    prompt: str = Field(
+        description="The text prompt describing the desired video motion. Max 800 characters.",
+        max_length=800,
+    )
+    duration: Literal["5", "10"] = Field(
+        default="5",
+        description="Duration of the generated video in seconds",
+    )
+    resolution: Literal["480p", "720p", "1080p"] = Field(
+        default="1080p",
+        description="Resolution of the generated video",
+    )
+    audio_url: str | None = Field(
+        default=None,
+        description=(
+            "URL of a WAV or MP3 audio file (3-30 seconds, max 15MB) for background music. "
+            "Audio is truncated or padded to match video duration."
+        ),
+    )
+    seed: int | None = Field(
+        default=None,
+        description=(
+            "Random seed for reproducibility. If not specified, a random seed will be used."
+        ),
+    )
+    negative_prompt: str | None = Field(
+        default=None,
+        description="Content to avoid in the generated video. Max 500 characters.",
+        max_length=500,
+    )
+    enable_prompt_expansion: bool = Field(
+        default=True,
+        description="Enable LLM-based prompt rewriting to improve results",
+    )
+    enable_safety_checker: bool = Field(
+        default=True,
+        description="Enable content safety filtering",
+    )
+
+
+class FalWan25PreviewImageToVideoGenerator(BaseGenerator):
+    """Generator for creating videos from static images using WAN 2.5 Preview."""
+
+    name = "fal-wan-25-preview-image-to-video"
+    description = "Fal: WAN 2.5 Preview - Generate videos from images with motion guidance"
+    artifact_type = "video"
+
+    def get_input_schema(self) -> type[Wan25PreviewImageToVideoInput]:
+        """Return the input schema for this generator."""
+        return Wan25PreviewImageToVideoInput
+
+    async def generate(
+        self, inputs: Wan25PreviewImageToVideoInput, context: GeneratorExecutionContext
+    ) -> GeneratorResult:
+        """Generate video using fal.ai wan-25-preview/image-to-video."""
+        # 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 FalWan25PreviewImageToVideoGenerator. "
+                "Install with: pip install weirdfingers-boards[generators-fal]"
+            ) from e
+
+        # Upload image artifact to Fal's public storage
+        from ..utils import upload_artifacts_to_fal
+
+        image_urls = await upload_artifacts_to_fal([inputs.image], context)
+
+        # Prepare arguments for fal.ai API
+        arguments: dict = {
+            "image_url": image_urls[0],
+            "prompt": inputs.prompt,
+            "duration": inputs.duration,
+            "resolution": inputs.resolution,
+            "enable_prompt_expansion": inputs.enable_prompt_expansion,
+            "enable_safety_checker": inputs.enable_safety_checker,
+        }
+
+        # Only add optional parameters if provided
+        if inputs.seed is not None:
+            arguments["seed"] = inputs.seed
+
+        if inputs.negative_prompt is not None:
+            arguments["negative_prompt"] = inputs.negative_prompt
+
+        if inputs.audio_url is not None:
+            arguments["audio_url"] = inputs.audio_url
+
+        # Submit async job
+        handler = await fal_client.submit_async(
+            "fal-ai/wan-25-preview/image-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,
+                                phase="processing",
+                                message=message,
+                            )
+                        )
+
+        # Get final result
+        result = await handler.get()
+
+        # Extract video from result
+        # Expected structure: {"video": {"url": "...", "width": ..., "height": ..., ...}}
+        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")
+
+        # Get video dimensions based on resolution setting
+        resolution_map = {
+            "480p": (854, 480),
+            "720p": (1280, 720),
+            "1080p": (1920, 1080),
+        }
+        default_width, default_height = resolution_map.get(inputs.resolution, (1920, 1080))
+
+        # Use actual dimensions from response if available, otherwise use defaults
+        width = video_data.get("width", default_width)
+        height = video_data.get("height", default_height)
+        fps = video_data.get("fps", 30)
+        duration = video_data.get("duration", int(inputs.duration))
+
+        # Store video result
+        artifact = await context.store_video_result(
+            storage_url=video_url,
+            format="mp4",
+            width=width,
+            height=height,
+            duration=duration,
+            fps=fps,
+            output_index=0,
+        )
+
+        return GeneratorResult(outputs=[artifact])
+
+    async def estimate_cost(self, inputs: Wan25PreviewImageToVideoInput) -> float:
+        """Estimate cost for this generation in USD.
+
+        Note: Pricing information not available in Fal documentation.
+        Using placeholder value that should be updated with actual pricing.
+        """
+        # TODO: Update with actual pricing from Fal when available
+        # Estimate based on duration - longer videos cost more
+        base_cost = 0.10
+        if inputs.duration == "10":
+            return base_cost * 2.0  # 10 second videos cost more
+        return base_cost