@weirdfingers/baseboards 0.9.5 → 0.9.7

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

@@ -1,172 +0,0 @@
-"""
-Google Veo 3.1 reference-to-video generator.
-
-Generates videos from multiple reference images to maintain consistent subject
-appearance while creating dynamic video content based on text prompts.
-
-Based on Fal AI's fal-ai/veo3.1/reference-to-video model.
-See: https://fal.ai/models/fal-ai/veo3.1/reference-to-video
-"""
-
-import os
-from typing import Literal
-
-from pydantic import BaseModel, Field
-
-from ....artifacts import ImageArtifact
-from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
-
-
-class Veo31ReferenceToVideoInput(BaseModel):
-    """Input schema for Veo 3.1 reference-to-video generation.
-
-    Artifact fields (image_urls) are automatically detected via type
-    introspection and resolved from generation IDs to ImageArtifact objects.
-    """
-
-    image_urls: list[ImageArtifact] = Field(
-        description="URLs of reference images for consistent subject appearance"
-    )
-    prompt: str = Field(description="Text description of desired video content")
-    duration: Literal["8s"] = Field(
-        default="8s",
-        description="Duration of the generated video in seconds (currently only 8s is supported)",
-    )
-    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. Disabling uses 50% fewer credits",
-    )
-
-
-class FalVeo31ReferenceToVideoGenerator(BaseGenerator):
-    """Generator for creating videos from reference images using Google Veo 3.1."""
-
-    name = "fal-veo31-reference-to-video"
-    description = "Fal: Veo 3.1 - Generate videos from reference images with consistent subjects"
-    artifact_type = "video"
-
-    def get_input_schema(self) -> type[Veo31ReferenceToVideoInput]:
-        """Return the input schema for this generator."""
-        return Veo31ReferenceToVideoInput
-
-    async def generate(
-        self, inputs: Veo31ReferenceToVideoInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Generate video using fal.ai veo3.1/reference-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 FalVeo31ReferenceToVideoGenerator. "
-                "Install with: pip install weirdfingers-boards[generators-fal]"
-            ) from e
-
-        # Upload image artifacts 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
-
-        reference_image_urls = await upload_artifacts_to_fal(inputs.image_urls, context)
-
-        # Prepare arguments for fal.ai API
-        arguments = {
-            "image_urls": reference_image_urls,
-            "prompt": inputs.prompt,
-            "duration": inputs.duration,
-            "resolution": inputs.resolution,
-            "generate_audio": inputs.generate_audio,
-        }
-
-        # Submit async job
-        handler = await fal_client.submit_async(
-            "fal-ai/veo3.1/reference-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")
-
-        # Store video result
-        # Note: Fal API doesn't provide video dimensions/duration in the response,
-        # so we'll use defaults based on input parameters
-        width = 1280 if inputs.resolution == "720p" else 1920
-        height = 720 if inputs.resolution == "720p" else 1080
-
-        # Parse duration from "8s" 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: Veo31ReferenceToVideoInput) -> 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 50% reduction if audio is disabled
-        base_cost = 0.15  # Placeholder estimate
-        if not inputs.generate_audio:
-            return base_cost * 0.5
-        return base_cost

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

@@ -1,212 +0,0 @@
-"""
-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

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

@@ -1,208 +0,0 @@
-"""
-Wan 2.5 Preview text-to-video generator.
-
-A text-to-video generation model that converts text prompts into video content,
-supporting both Chinese and English inputs up to 800 characters.
-
-Based on Fal AI's fal-ai/wan-25-preview/text-to-video model.
-See: https://fal.ai/models/fal-ai/wan-25-preview/text-to-video
-"""
-
-import os
-from typing import Literal
-
-from pydantic import BaseModel, Field
-
-from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
-
-
-class Wan25PreviewTextToVideoInput(BaseModel):
-    """Input schema for Wan 2.5 Preview text-to-video generation.
-
-    Artifact fields are automatically detected via type introspection
-    and resolved from generation IDs to artifact objects.
-    """
-
-    prompt: str = Field(
-        description="Text prompt for video generation. Supports Chinese and English.",
-        min_length=1,
-        max_length=800,
-    )
-    aspect_ratio: Literal["16:9", "9:16", "1:1"] = Field(
-        default="16:9",
-        description="Aspect ratio of the generated video",
-    )
-    resolution: Literal["480p", "720p", "1080p"] = Field(
-        default="1080p",
-        description="Resolution of the generated video",
-    )
-    duration: Literal[5, 10] = Field(
-        default=5,
-        description="Duration of the generated video in seconds",
-    )
-    audio_url: str | None = Field(
-        default=None,
-        description="URL of background audio (WAV/MP3). Must be 3-30 seconds and max 15MB. "
-        "Audio longer than video is truncated; shorter audio results in silent sections.",
-    )
-    seed: int | None = Field(
-        default=None,
-        description="Random seed for reproducibility",
-    )
-    enable_safety_checker: bool = Field(
-        default=True,
-        description="Whether to enable safety filtering",
-    )
-    negative_prompt: str | None = Field(
-        default=None,
-        description="Content to avoid in generation",
-        max_length=500,
-    )
-    enable_prompt_expansion: bool = Field(
-        default=True,
-        description="Whether to expand short prompts for improved results. "
-        "Increases processing time but improves quality for short prompts.",
-    )
-
-
-class FalWan25PreviewTextToVideoGenerator(BaseGenerator):
-    """Generator for text-to-video using Wan 2.5 Preview."""
-
-    name = "fal-wan-25-preview-text-to-video"
-    description = (
-        "Fal: Wan 2.5 Preview - Text-to-video generation supporting "
-        "Chinese/English prompts up to 800 characters"
-    )
-    artifact_type = "video"
-
-    def get_input_schema(self) -> type[Wan25PreviewTextToVideoInput]:
-        """Return the input schema for this generator."""
-        return Wan25PreviewTextToVideoInput
-
-    async def generate(
-        self, inputs: Wan25PreviewTextToVideoInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Generate video using fal.ai Wan 2.5 Preview 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 FalWan25PreviewTextToVideoGenerator. "
-                "Install with: pip install weirdfingers-boards[generators-fal]"
-            ) from e
-
-        # Prepare arguments for fal.ai API
-        arguments: dict = {
-            "prompt": inputs.prompt,
-            "aspect_ratio": inputs.aspect_ratio,
-            "resolution": inputs.resolution,
-            "duration": inputs.duration,
-            "enable_safety_checker": inputs.enable_safety_checker,
-            "enable_prompt_expansion": inputs.enable_prompt_expansion,
-        }
-
-        # Add optional parameters
-        if inputs.audio_url is not None:
-            arguments["audio_url"] = inputs.audio_url
-        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/wan-25-preview/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
-        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 video metadata from response or use defaults
-        width = video_data.get("width")
-        height = video_data.get("height")
-        duration = video_data.get("duration")
-        fps = video_data.get("fps")
-
-        # If dimensions not provided, determine based on aspect ratio and resolution
-        if width is None or height is None:
-            resolution_dimensions = {
-                "480p": {"16:9": (854, 480), "9:16": (480, 854), "1:1": (480, 480)},
-                "720p": {"16:9": (1280, 720), "9:16": (720, 1280), "1:1": (720, 720)},
-                "1080p": {"16:9": (1920, 1080), "9:16": (1080, 1920), "1:1": (1080, 1080)},
-            }
-            dims = resolution_dimensions.get(inputs.resolution, {}).get(
-                inputs.aspect_ratio, (1920, 1080)
-            )
-            width, height = dims
-
-        # Store video result
-        artifact = await context.store_video_result(
-            storage_url=video_url,
-            format="mp4",
-            width=width,
-            height=height,
-            duration=float(duration) if duration else float(inputs.duration),
-            fps=fps,
-            output_index=0,
-        )
-
-        return GeneratorResult(outputs=[artifact])
-
-    async def estimate_cost(self, inputs: Wan25PreviewTextToVideoInput) -> float:
-        """Estimate cost for Wan 2.5 Preview generation.
-
-        Pricing information not provided in official documentation.
-        Estimated at $0.10 per 5-second video based on typical video generation costs.
-        Cost scales with duration.
-        """
-        # Base cost per 5-second video
-        base_cost = 0.10
-        # Scale by duration: 5s = 1x, 10s = 2x
-        duration_multiplier = inputs.duration / 5
-        return base_cost * duration_multiplier