@weirdfingers/baseboards 0.9.6 → 0.9.7

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

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

@@ -1,187 +0,0 @@
-"""
-Google Veo 3.1 first-last frame to video generator.
-
-Generates videos by interpolating between first and last frame images using
-Google's Veo 3.1 technology via fal.ai.
-
-Based on Fal AI's fal-ai/veo3.1/first-last-frame-to-video model.
-See: https://fal.ai/models/fal-ai/veo3.1/first-last-frame-to-video
-"""
-
-import os
-from typing import Literal
-
-from pydantic import BaseModel, Field
-
-from ....artifacts import ImageArtifact
-from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
-
-
-class Veo31FirstLastFrameToVideoInput(BaseModel):
-    """Input schema for Veo 3.1 first-last frame to video generation.
-
-    Artifact fields (first_frame, last_frame) are automatically detected via type
-    introspection and resolved from generation IDs to ImageArtifact objects.
-    """
-
-    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["4s", "6s", "8s"] = Field(
-        default="8s",
-        description="Duration of the generated video in seconds",
-    )
-    aspect_ratio: Literal["auto", "9:16", "16:9", "1:1"] = Field(
-        default="auto",
-        description=(
-            "Aspect ratio of the generated video. 'auto' uses the aspect ratio from input images"
-        ),
-    )
-    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 FalVeo31FirstLastFrameToVideoGenerator(BaseGenerator):
-    """Generator for creating videos from first and last frame images using Google Veo 3.1."""
-
-    name = "fal-veo31-first-last-frame-to-video"
-    description = "Fal: Veo 3.1 - Generate videos by interpolating between first and last frames"
-    artifact_type = "video"
-
-    def get_input_schema(self) -> type[Veo31FirstLastFrameToVideoInput]:
-        """Return the input schema for this generator."""
-        return Veo31FirstLastFrameToVideoInput
-
-    async def generate(
-        self, inputs: Veo31FirstLastFrameToVideoInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Generate video using fal.ai veo3.1/first-last-frame-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 FalVeo31FirstLastFrameToVideoGenerator. "
-                "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
-
-        first_frame_urls = await upload_artifacts_to_fal([inputs.first_frame], context)
-        last_frame_urls = await upload_artifacts_to_fal([inputs.last_frame], context)
-
-        # Prepare arguments for fal.ai API
-        arguments = {
-            "first_frame_url": first_frame_urls[0],
-            "last_frame_url": last_frame_urls[0],
-            "prompt": inputs.prompt,
-            "duration": inputs.duration,
-            "aspect_ratio": inputs.aspect_ratio,
-            "resolution": inputs.resolution,
-            "generate_audio": inputs.generate_audio,
-        }
-
-        # Submit async job
-        handler = await fal_client.submit_async(
-            "fal-ai/veo3.1/first-last-frame-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: Veo31FirstLastFrameToVideoInput) -> 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
-        # 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 cost * 0.5
-        return cost

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

@@ -1,183 +0,0 @@
-"""
-Google Veo 3.1 image-to-video generator.
-
-Converts static images into animated videos based on text prompts using
-Google's Veo 3.1 technology via fal.ai.
-
-Based on Fal AI's fal-ai/veo3.1/image-to-video model.
-See: https://fal.ai/models/fal-ai/veo3.1/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 Veo31ImageToVideoInput(BaseModel):
-    """Input schema for Veo 3.1 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["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 in seconds",
-    )
-    generate_audio: bool = Field(
-        default=True,
-        description="Whether to generate audio for the video. Disabling uses 50% fewer credits",
-    )
-    resolution: Literal["720p", "1080p"] = Field(
-        default="720p",
-        description="Resolution of the generated video",
-    )
-
-
-class FalVeo31ImageToVideoGenerator(BaseGenerator):
-    """Generator for creating videos from static images using Google Veo 3.1."""
-
-    name = "fal-veo31-image-to-video"
-    description = "Fal: Veo 3.1 - Convert images to videos with text-guided animation"
-    artifact_type = "video"
-
-    def get_input_schema(self) -> type[Veo31ImageToVideoInput]:
-        """Return the input schema for this generator."""
-        return Veo31ImageToVideoInput
-
-    async def generate(
-        self, inputs: Veo31ImageToVideoInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Generate video using fal.ai veo3.1/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 FalVeo31ImageToVideoGenerator. "
-                "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/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
-        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 "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: Veo31ImageToVideoInput) -> 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