@weirdfingers/baseboards 0.9.6 → 0.9.7

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

@@ -1,172 +0,0 @@
-"""
-Sora 2 image-to-video generator.
-
-OpenAI's state-of-the-art video generation model that creates richly detailed,
-dynamic clips with audio from natural language prompts and images.
-
-Based on Fal AI's fal-ai/sora-2/image-to-video model.
-See: https://fal.ai/models/fal-ai/sora-2/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 Sora2ImageToVideoInput(BaseModel):
-    """Input schema for Sora 2 image-to-video generation.
-
-    Artifact fields (image_url) are automatically detected via type
-    introspection and resolved from generation IDs to ImageArtifact objects.
-    """
-
-    prompt: str = Field(
-        description="The text prompt describing the video you want to generate",
-        min_length=1,
-        max_length=5000,
-    )
-    image_url: ImageArtifact = Field(description="The image to use as the first frame")
-    resolution: Literal["auto", "720p"] = Field(
-        default="auto",
-        description="Resolution of the generated video",
-    )
-    aspect_ratio: Literal["auto", "9:16", "16:9"] = Field(
-        default="auto",
-        description="Aspect ratio of the generated video",
-    )
-    duration: Literal[4, 8, 12] = Field(
-        default=4,
-        description="Duration of the generated video in seconds",
-    )
-
-
-class FalSora2ImageToVideoGenerator(BaseGenerator):
-    """Generator for creating videos from images using OpenAI's Sora 2."""
-
-    name = "fal-sora2-image-to-video"
-    description = "Fal: Sora 2 - Generate videos from images with audio"
-    artifact_type = "video"
-
-    def get_input_schema(self) -> type[Sora2ImageToVideoInput]:
-        """Return the input schema for this generator."""
-        return Sora2ImageToVideoInput
-
-    async def generate(
-        self, inputs: Sora2ImageToVideoInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Generate video using fal.ai sora-2/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 FalSora2ImageToVideoGenerator. "
-                "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_url], context)
-
-        # Prepare arguments for fal.ai API
-        arguments = {
-            "prompt": inputs.prompt,
-            "image_url": image_urls[0],
-            "resolution": inputs.resolution,
-            "aspect_ratio": inputs.aspect_ratio,
-            "duration": inputs.duration,
-        }
-
-        # Submit async job
-        handler = await fal_client.submit_async(
-            "fal-ai/sora-2/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": 1280, "height": 720, ...}}
-        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 metadata from response (if available)
-        width = video_data.get("width", 1280)
-        height = video_data.get("height", 720)
-        duration_seconds = video_data.get("duration", inputs.duration)
-        fps = video_data.get("fps", 30)
-
-        # Store video result
-        artifact = await context.store_video_result(
-            storage_url=video_url,
-            format="mp4",
-            width=width,
-            height=height,
-            duration=duration_seconds,
-            fps=fps,
-            output_index=0,
-        )
-
-        return GeneratorResult(outputs=[artifact])
-
-    async def estimate_cost(self, inputs: Sora2ImageToVideoInput) -> float:
-        """Estimate cost for this generation in USD.
-
-        Note: Pricing information not disclosed 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 likely cost more
-        base_cost = 0.20  # Placeholder estimate for 4s
-        duration_multiplier = inputs.duration / 4.0
-        return base_cost * duration_multiplier

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

@@ -1,175 +0,0 @@
-"""
-OpenAI Sora 2 Image-to-Video Pro generator.
-
-Image-to-video endpoint for Sora 2 Pro, OpenAI's state-of-the-art video model
-capable of creating richly detailed, dynamic clips with audio from natural
-language prompts and images.
-
-Based on Fal AI's fal-ai/sora-2/image-to-video/pro model.
-See: https://fal.ai/models/fal-ai/sora-2/image-to-video/pro
-"""
-
-import os
-from typing import Literal
-
-from pydantic import BaseModel, Field
-
-from ....artifacts import ImageArtifact
-from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
-
-
-class Sora2ImageToVideoProInput(BaseModel):
-    """Input schema for Sora 2 Image-to-Video Pro generation.
-
-    Artifact fields (image_url) are automatically detected via type
-    introspection and resolved from generation IDs to ImageArtifact objects.
-    """
-
-    prompt: str = Field(
-        description="The text prompt describing the video you want to generate",
-        min_length=1,
-        max_length=5000,
-    )
-    image_url: ImageArtifact = Field(description="The image to use as the first frame of the video")
-    resolution: Literal["auto", "720p", "1080p"] = Field(
-        default="auto",
-        description="Resolution of the generated video. 'auto' selects optimal resolution",
-    )
-    aspect_ratio: Literal["auto", "9:16", "16:9"] = Field(
-        default="auto",
-        description="Aspect ratio of the generated video. 'auto' uses the image's aspect ratio",
-    )
-    duration: Literal[4, 8, 12] = Field(
-        default=4,
-        description="Duration of the generated video in seconds",
-    )
-
-
-class FalSora2ImageToVideoProGenerator(BaseGenerator):
-    """Generator for creating videos from images using OpenAI Sora 2 Pro."""
-
-    name = "fal-sora-2-image-to-video-pro"
-    description = "Fal: Sora 2 Pro - Create dynamic videos with audio from images and text prompts"
-    artifact_type = "video"
-
-    def get_input_schema(self) -> type[Sora2ImageToVideoProInput]:
-        """Return the input schema for this generator."""
-        return Sora2ImageToVideoProInput
-
-    async def generate(
-        self, inputs: Sora2ImageToVideoProInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Generate video using fal.ai sora-2/image-to-video/pro."""
-        # Check for API key
-        if not os.getenv("FAL_KEY"):
-            raise ValueError("API configuration invalid. Missing FAL_KEY environment variable")
-
-        # Import fal_client
-        try:
-            import fal_client
-        except ImportError as e:
-            raise ImportError(
-                "fal.ai SDK is required for FalSora2ImageToVideoProGenerator. "
-                "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_url], context)
-
-        # Prepare arguments for fal.ai API
-        arguments = {
-            "prompt": inputs.prompt,
-            "image_url": image_urls[0],
-            "resolution": inputs.resolution,
-            "aspect_ratio": inputs.aspect_ratio,
-            "duration": inputs.duration,
-        }
-
-        # Submit async job
-        handler = await fal_client.submit_async(
-            "fal-ai/sora-2/image-to-video/pro",
-            arguments=arguments,
-        )
-
-        # Store external job ID
-        await context.set_external_job_id(handler.request_id)
-
-        # Stream progress updates
-        from .....progress.models import ProgressUpdate
-
-        event_count = 0
-        async for event in handler.iter_events(with_logs=True):
-            event_count += 1
-            # Sample every 3rd event to avoid spam
-            if event_count % 3 == 0:
-                # Extract logs if available
-                logs = getattr(event, "logs", None)
-                if logs:
-                    # Join log entries into a single message
-                    if isinstance(logs, list):
-                        message = " | ".join(str(log) for log in logs if log)
-                    else:
-                        message = str(logs)
-
-                    if message:
-                        await context.publish_progress(
-                            ProgressUpdate(
-                                job_id=handler.request_id,
-                                status="processing",
-                                progress=50.0,
-                                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")
-
-        # Extract video metadata from response
-        width = video_data.get("width", 1280)
-        height = video_data.get("height", 720)
-        duration_seconds = video_data.get("duration", inputs.duration)
-        fps = video_data.get("fps", 30)
-
-        # Store video result
-        artifact = await context.store_video_result(
-            storage_url=video_url,
-            format="mp4",
-            width=width,
-            height=height,
-            duration=duration_seconds,
-            fps=fps,
-            output_index=0,
-        )
-
-        return GeneratorResult(outputs=[artifact])
-
-    async def estimate_cost(self, inputs: Sora2ImageToVideoProInput) -> 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
-        # Cost likely increases with duration
-        base_cost = 0.50  # Placeholder estimate for 4s
-
-        # Adjust for duration
-        duration_multiplier = inputs.duration / 4  # 4s is base
-        return base_cost * duration_multiplier

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

@@ -1,163 +0,0 @@
-"""
-Sora 2 Pro text-to-video generator.
-
-OpenAI's state-of-the-art video model capable of creating richly detailed,
-dynamic clips with audio from natural language descriptions.
-
-Based on Fal AI's fal-ai/sora-2/text-to-video/pro model.
-See: https://fal.ai/models/fal-ai/sora-2/text-to-video/pro
-"""
-
-import os
-from typing import Literal
-
-from pydantic import BaseModel, Field
-
-from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
-
-
-class Sora2TextToVideoProInput(BaseModel):
-    """Input schema for Sora 2 Pro text-to-video generation."""
-
-    prompt: str = Field(
-        description="Describes the desired video",
-        min_length=1,
-        max_length=5000,
-    )
-    resolution: Literal["720p", "1080p"] = Field(
-        default="1080p",
-        description="Video resolution",
-    )
-    aspect_ratio: Literal["9:16", "16:9"] = Field(
-        default="16:9",
-        description="Video aspect ratio",
-    )
-    duration: Literal[4, 8, 12] = Field(
-        default=4,
-        description="Video duration in seconds",
-    )
-
-
-class FalSora2TextToVideoProGenerator(BaseGenerator):
-    """Generator for text-to-video using Sora 2 Pro."""
-
-    name = "fal-sora-2-text-to-video-pro"
-    description = "Fal: Sora 2 Pro - OpenAI's state-of-the-art text-to-video model with audio"
-    artifact_type = "video"
-
-    def get_input_schema(self) -> type[Sora2TextToVideoProInput]:
-        """Return the input schema for this generator."""
-        return Sora2TextToVideoProInput
-
-    async def generate(
-        self, inputs: Sora2TextToVideoProInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Generate video using fal.ai Sora 2 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 FalSora2TextToVideoProGenerator. "
-                "Install with: pip install weirdfingers-boards[generators-fal]"
-            ) from e
-
-        # Prepare arguments for fal.ai API
-        arguments = {
-            "prompt": inputs.prompt,
-            "resolution": inputs.resolution,
-            "aspect_ratio": inputs.aspect_ratio,
-            "duration": inputs.duration,
-        }
-
-        # Submit async job
-        handler = await fal_client.submit_async(
-            "fal-ai/sora-2/text-to-video/pro",
-            arguments=arguments,
-        )
-
-        # Store external job ID
-        await context.set_external_job_id(handler.request_id)
-
-        # Stream progress updates
-        from .....progress.models import ProgressUpdate
-
-        event_count = 0
-        async for event in handler.iter_events(with_logs=True):
-            event_count += 1
-            # Sample every 3rd event to avoid spam
-            if event_count % 3 == 0:
-                # Extract logs if available
-                logs = getattr(event, "logs", None)
-                if logs:
-                    # Join log entries into a single message
-                    if isinstance(logs, list):
-                        message = " | ".join(str(log) for log in logs if log)
-                    else:
-                        message = str(logs)
-
-                    if message:
-                        await context.publish_progress(
-                            ProgressUpdate(
-                                job_id=handler.request_id,
-                                status="processing",
-                                progress=50.0,  # Approximate mid-point progress
-                                phase="processing",
-                                message=message,
-                            )
-                        )
-
-        # Get final result
-        result = await handler.get()
-
-        # Extract video from result
-        # fal.ai returns: {"video": {"url": "...", "width": 1920, "height": 1080, ...}}
-        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 dimensions from response
-        width = video_data.get("width", 1920)
-        height = video_data.get("height", 1080)
-        fps = video_data.get("fps")
-        duration = video_data.get("duration", float(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: Sora2TextToVideoProInput) -> float:
-        """Estimate cost for Sora 2 Pro generation.
-
-        Pricing information not available in official documentation.
-        Estimated at $0.20-$0.80 per video based on duration and resolution.
-        Actual costs may vary.
-        """
-        # Base cost per second of video
-        # Higher resolution and longer duration increase cost
-        base_cost_per_second = 0.05
-
-        # Resolution multiplier
-        resolution_multiplier = 1.5 if inputs.resolution == "1080p" else 1.0
-
-        # Calculate total cost
-        total_cost = base_cost_per_second * inputs.duration * resolution_multiplier
-
-        return total_cost

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

@@ -1,167 +0,0 @@
-"""
-fal.ai sync-lipsync v2 video generator.
-
-Generates realistic lip-synchronization animations from audio and video inputs
-using fal.ai's sync-lipsync/v2 model. Supports advanced audio/video duration
-mismatch handling with multiple sync modes.
-
-Based on Fal AI's fal-ai/sync-lipsync/v2 model.
-See: https://fal.ai/models/fal-ai/sync-lipsync/v2
-"""
-
-import os
-from typing import Literal
-
-from pydantic import BaseModel, Field
-
-from ....artifacts import AudioArtifact, VideoArtifact
-from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
-
-
-class SyncLipsyncV2Input(BaseModel):
-    """Input schema for sync-lipsync v2.
-
-    Artifact fields are automatically detected via type introspection
-    and resolved from generation IDs to artifact objects.
-    """
-
-    video: VideoArtifact = Field(description="Input video for lip-sync animation")
-    audio: AudioArtifact = Field(description="Audio to synchronize with the video")
-    model: Literal["lipsync-2", "lipsync-2-pro"] = Field(
-        default="lipsync-2",
-        description="Model selection; pro version costs ~1.67x more",
-    )
-    sync_mode: Literal["cut_off", "loop", "bounce", "silence", "remap"] = Field(
-        default="cut_off",
-        description="Handling method when audio/video durations mismatch",
-    )
-
-
-class FalSyncLipsyncV2Generator(BaseGenerator):
-    """Generator for realistic lip-synchronization animations."""
-
-    name = "fal-sync-lipsync-v2"
-    description = "Fal: sync-lipsync v2 - Realistic lip-sync animation with audio"
-    artifact_type = "video"
-
-    def get_input_schema(self) -> type[SyncLipsyncV2Input]:
-        """Return the input schema for this generator."""
-        return SyncLipsyncV2Input
-
-    async def generate(
-        self, inputs: SyncLipsyncV2Input, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Generate lip-synced video using fal.ai sync-lipsync/v2."""
-        # 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 FalSyncLipsyncV2Generator. "
-                "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],
-            "model": inputs.model,
-            "sync_mode": inputs.sync_mode,
-        }
-
-        # Submit async job
-        handler = await fal_client.submit_async(
-            "fal-ai/sync-lipsync/v2",
-            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")
-        content_type = video_data.get("content_type", "video/mp4")
-        video_format = content_type.split("/")[-1] if "/" in content_type else "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: SyncLipsyncV2Input) -> float:
-        """Estimate cost for sync-lipsync v2 generation in USD.
-
-        Pricing not specified in documentation, using estimate based on
-        typical video processing costs. Pro model costs ~1.67x more.
-        """
-        # Base cost estimate per generation
-        base_cost = 0.05
-
-        # Pro model multiplier
-        if inputs.model == "lipsync-2-pro":
-            return base_cost * 1.67
-
-        return base_cost