@weirdfingers/baseboards 0.9.5 → 0.9.7

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

@@ -1,222 +0,0 @@
-"""
-ByteDance SeedDance v1 Pro image-to-video generator.
-
-A high quality video generation model developed by ByteDance that converts static
-images into dynamic videos based on textual descriptions.
-
-Based on Fal AI's fal-ai/bytedance/seedance/v1/pro/image-to-video model.
-See: https://fal.ai/models/fal-ai/bytedance/seedance/v1/pro/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 BytedanceSeedanceV1ProImageToVideoInput(BaseModel):
-    """Input schema for ByteDance SeedDance v1 Pro image-to-video generation.
-
-    Artifact fields (image, end_image) are automatically detected via type
-    introspection and resolved from generation IDs to ImageArtifact objects.
-    """
-
-    prompt: str = Field(description="Text description for video generation")
-    image: ImageArtifact = Field(description="Source image for conversion to video")
-    aspect_ratio: Literal["21:9", "16:9", "4:3", "1:1", "3:4", "9:16", "auto"] = Field(
-        default="auto",
-        description=(
-            "Aspect ratio of the generated video. 'auto' uses the aspect ratio from input image"
-        ),
-    )
-    resolution: Literal["480p", "720p", "1080p"] = Field(
-        default="1080p",
-        description="Resolution of the generated video",
-    )
-    duration: Literal["2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"] = Field(
-        default="5",
-        description="Duration of the generated video in seconds",
-    )
-    end_image: ImageArtifact | None = Field(
-        default=None,
-        description="Optional ending frame image for directional guidance",
-    )
-    camera_fixed: bool = Field(
-        default=False,
-        description="Lock camera position to prevent camera movement",
-    )
-    seed: int | None = Field(
-        default=None,
-        description="Random seed for reproducible results. Use -1 for random seed",
-    )
-    enable_safety_checker: bool = Field(
-        default=True,
-        description="Activate content filtering to ensure safe outputs",
-    )
-
-
-class FalBytedanceSeedanceV1ProImageToVideoGenerator(BaseGenerator):
-    """Generator for converting images to videos using ByteDance SeedDance v1 Pro."""
-
-    name = "fal-bytedance-seedance-v1-pro-image-to-video"
-    description = "Fal: SeedDance v1 Pro - High quality image-to-video generation by ByteDance"
-    artifact_type = "video"
-
-    def get_input_schema(self) -> type[BytedanceSeedanceV1ProImageToVideoInput]:
-        """Return the input schema for this generator."""
-        return BytedanceSeedanceV1ProImageToVideoInput
-
-    async def generate(
-        self, inputs: BytedanceSeedanceV1ProImageToVideoInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Generate video using fal.ai bytedance/seedance/v1/pro/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 FalBytedanceSeedanceV1ProImageToVideoGenerator. "
-                "Install with: pip install weirdfingers-boards[generators-fal]"
-            ) from e
-
-        # Upload image artifacts to Fal's public storage
-        # Fal API requires publicly accessible URLs
-        from ..utils import upload_artifacts_to_fal
-
-        image_urls = await upload_artifacts_to_fal([inputs.image], context)
-
-        # Prepare arguments for fal.ai API
-        arguments = {
-            "prompt": inputs.prompt,
-            "image_url": image_urls[0],
-            "aspect_ratio": inputs.aspect_ratio,
-            "resolution": inputs.resolution,
-            "duration": inputs.duration,
-            "camera_fixed": inputs.camera_fixed,
-            "enable_safety_checker": inputs.enable_safety_checker,
-        }
-
-        # Upload end image if provided
-        if inputs.end_image is not None:
-            end_image_urls = await upload_artifacts_to_fal([inputs.end_image], context)
-            arguments["end_image_url"] = end_image_urls[0]
-
-        # Add seed if provided
-        if inputs.seed is not None:
-            arguments["seed"] = inputs.seed
-
-        # Submit async job
-        handler = await fal_client.submit_async(
-            "fal-ai/bytedance/seedance/v1/pro/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": "...", ...}, "seed": 123}
-        video_data = result.get("video")
-        if not video_data:
-            raise ValueError("No video returned from fal.ai API")
-
-        video_url = video_data.get("url")
-        if not video_url:
-            raise ValueError("Video missing URL in fal.ai response")
-
-        # Determine video dimensions based on resolution
-        # Resolution mapping based on standard video dimensions
-        resolution_map = {
-            "480p": (854, 480),
-            "720p": (1280, 720),
-            "1080p": (1920, 1080),
-        }
-        width, height = resolution_map.get(inputs.resolution, (1920, 1080))
-
-        # Parse duration from string format
-        duration_seconds = int(inputs.duration)
-
-        # 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: BytedanceSeedanceV1ProImageToVideoInput) -> float:
-        """Estimate cost for this generation in USD.
-
-        Based on fal.ai pricing: approximately $0.74 per 1080p 5-second video.
-        Cost scales based on resolution and duration.
-
-        Formula: tokens(video) = (height x width x FPS x duration) / 1024
-        Pricing: $3.0 per 1 million video tokens for image-to-video
-        """
-        # Resolution mapping
-        resolution_map = {
-            "480p": (854, 480),
-            "720p": (1280, 720),
-            "1080p": (1920, 1080),
-        }
-        width, height = resolution_map.get(inputs.resolution, (1920, 1080))
-
-        # Parse duration
-        duration_seconds = int(inputs.duration)
-
-        # Assume 30 FPS for video generation
-        fps = 30
-
-        # Calculate video tokens
-        # Formula from fal.ai: tokens = (height * width * fps * duration) / 1024
-        tokens = (height * width * fps * duration_seconds) / 1024
-
-        # Price per million tokens for image-to-video
-        price_per_million_tokens = 3.0
-
-        # Calculate cost
-        cost = (tokens / 1_000_000) * price_per_million_tokens
-
-        return cost

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

@@ -1,152 +0,0 @@
-"""
-MiniMax Hailuo 02 [Standard] text-to-video generator.
-
-Advanced video generation model with 768p resolution that converts text prompts
-into video content. Supports 6 and 10 second durations with optional prompt optimization.
-
-Based on Fal AI's fal-ai/minimax/hailuo-02/standard/text-to-video model.
-See: https://fal.ai/models/fal-ai/minimax/hailuo-02/standard/text-to-video
-"""
-
-import os
-from typing import Literal
-
-from pydantic import BaseModel, Field
-
-from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
-
-
-class FalMinimaxHailuo02StandardTextToVideoInput(BaseModel):
-    """Input schema for MiniMax Hailuo 02 Standard text-to-video generation."""
-
-    prompt: str = Field(
-        description="Text description of the video to generate",
-        min_length=1,
-        max_length=2000,
-    )
-    duration: Literal["6", "10"] = Field(
-        default="6",
-        description="Video duration in seconds. Choose 6 or 10 seconds.",
-    )
-    prompt_optimizer: bool = Field(
-        default=True,
-        description="Enable the model's prompt optimization to enhance generation quality",
-    )
-
-
-class FalMinimaxHailuo02StandardTextToVideoGenerator(BaseGenerator):
-    """Generator for text-to-video using MiniMax Hailuo 02 Standard model."""
-
-    name = "fal-minimax-hailuo-02-standard-text-to-video"
-    description = "Fal: MiniMax Hailuo 02 [Standard] - Advanced 768p text-to-video generation"
-    artifact_type = "video"
-
-    def get_input_schema(self) -> type[FalMinimaxHailuo02StandardTextToVideoInput]:
-        """Return the input schema for this generator."""
-        return FalMinimaxHailuo02StandardTextToVideoInput
-
-    async def generate(
-        self,
-        inputs: FalMinimaxHailuo02StandardTextToVideoInput,
-        context: GeneratorExecutionContext,
-    ) -> GeneratorResult:
-        """Generate video using fal.ai MiniMax Hailuo 02 Standard 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 FalMinimaxHailuo02StandardTextToVideoGenerator. "
-                "Install with: pip install weirdfingers-boards[generators-fal]"
-            ) from e
-
-        # Prepare arguments for fal.ai API
-        arguments = {
-            "prompt": inputs.prompt,
-            "duration": inputs.duration,
-            "prompt_optimizer": inputs.prompt_optimizer,
-        }
-
-        # Submit async job
-        handler = await fal_client.submit_async(
-            "fal-ai/minimax/hailuo-02/standard/text-to-video",
-            arguments=arguments,
-        )
-
-        # Store external job ID
-        await context.set_external_job_id(handler.request_id)
-
-        # Stream progress updates
-        from .....progress.models import ProgressUpdate
-
-        event_count = 0
-        async for event in handler.iter_events(with_logs=True):
-            event_count += 1
-            # Sample every 3rd event to avoid spam
-            if event_count % 3 == 0:
-                # Extract logs if available
-                logs = getattr(event, "logs", None)
-                if logs:
-                    # Join log entries into a single message
-                    if isinstance(logs, list):
-                        message = " | ".join(str(log) for log in logs if log)
-                    else:
-                        message = str(logs)
-
-                    if message:
-                        await context.publish_progress(
-                            ProgressUpdate(
-                                job_id=handler.request_id,
-                                status="processing",
-                                progress=50.0,  # Approximate mid-point progress
-                                phase="processing",
-                                message=message,
-                            )
-                        )
-
-        # Get final result
-        result = await handler.get()
-
-        # Extract video from result
-        # fal.ai returns: {"video": {"url": "...", "content_type": "video/mp4", ...}}
-        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")
-
-        # Hailuo 02 Standard produces 768p resolution videos
-        # Using standard 16:9 aspect ratio dimensions for 768p
-        width = 1360
-        height = 768
-
-        # Store video result
-        artifact = await context.store_video_result(
-            storage_url=video_url,
-            format="mp4",
-            width=width,
-            height=height,
-            duration=float(inputs.duration),  # Convert "6" or "10" to float
-            output_index=0,
-        )
-
-        return GeneratorResult(outputs=[artifact])
-
-    async def estimate_cost(self, inputs: FalMinimaxHailuo02StandardTextToVideoInput) -> float:
-        """Estimate cost for MiniMax Hailuo 02 Standard generation.
-
-        Pricing information not provided in official documentation.
-        Estimated at $0.12 per video based on typical video generation costs.
-        Cost may vary based on duration settings.
-        """
-        # Approximate cost per video
-        # 10-second videos may cost more than 6-second videos
-        base_cost = 0.12
-        duration_multiplier = 1.67 if inputs.duration == "10" else 1.0
-        return base_cost * duration_multiplier

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

@@ -1,197 +0,0 @@
-"""
-PixVerse Lipsync video generator.
-
-Generates realistic lip-synchronization animations by synchronizing video with
-audio or text-to-speech. Supports optional audio input or TTS with customizable
-voice selection.
-
-Based on Fal AI's fal-ai/pixverse/lipsync model.
-See: https://fal.ai/models/fal-ai/pixverse/lipsync
-"""
-
-import os
-from typing import Literal
-
-from pydantic import BaseModel, Field
-
-from ....artifacts import AudioArtifact, VideoArtifact
-from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
-
-
-class PixverseLipsyncInput(BaseModel):
-    """Input schema for PixVerse Lipsync.
-
-    Artifact fields are automatically detected via type introspection
-    and resolved from generation IDs to artifact objects.
-    """
-
-    video_url: VideoArtifact = Field(description="Input video source for lip-sync animation")
-    audio_url: AudioArtifact | None = Field(
-        default=None, description="Input audio file; if omitted, TTS generates audio from text"
-    )
-    text: str | None = Field(
-        default=None,
-        description="Content for text-to-speech synthesis (used when audio_url not provided)",
-    )
-    voice_id: Literal[
-        "Emily",
-        "James",
-        "Isabella",
-        "Liam",
-        "Chloe",
-        "Adrian",
-        "Harper",
-        "Ava",
-        "Sophia",
-        "Julia",
-        "Mason",
-        "Jack",
-        "Oliver",
-        "Ethan",
-        "Auto",
-    ] = Field(default="Auto", description="Voice selection for text-to-speech")
-
-
-class FalPixverseLipsyncGenerator(BaseGenerator):
-    """Generator for PixVerse lip-sync animation."""
-
-    name = "fal-pixverse-lipsync"
-    description = "Fal: PixVerse Lipsync - Realistic lip-sync animation with audio or TTS"
-    artifact_type = "video"
-
-    def get_input_schema(self) -> type[PixverseLipsyncInput]:
-        """Return the input schema for this generator."""
-        return PixverseLipsyncInput
-
-    async def generate(
-        self, inputs: PixverseLipsyncInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Generate lip-synced video using fal.ai pixverse/lipsync."""
-        # Check for API key
-        if not os.getenv("FAL_KEY"):
-            raise ValueError("API configuration invalid. Missing FAL_KEY environment variable")
-
-        # Import fal_client
-        try:
-            import fal_client
-        except ImportError as e:
-            raise ImportError(
-                "fal.ai SDK is required for FalPixverseLipsyncGenerator. "
-                "Install with: pip install weirdfingers-boards[generators-fal]"
-            ) from e
-
-        # Upload video artifact to Fal's public storage
-        from ..utils import upload_artifacts_to_fal
-
-        video_urls = await upload_artifacts_to_fal([inputs.video_url], context)
-
-        # Prepare arguments for fal.ai API
-        arguments: dict = {
-            "video_url": video_urls[0],
-            "voice_id": inputs.voice_id,
-        }
-
-        # Add audio_url if provided, otherwise add text for TTS
-        if inputs.audio_url is not None:
-            audio_urls = await upload_artifacts_to_fal([inputs.audio_url], context)
-            arguments["audio_url"] = audio_urls[0]
-        elif inputs.text is not None:
-            arguments["text"] = inputs.text
-        else:
-            raise ValueError("Either audio_url or text must be provided for lip-sync generation")
-
-        # Submit async job
-        handler = await fal_client.submit_async(
-            "fal-ai/pixverse/lipsync",
-            arguments=arguments,
-        )
-
-        # Store external job ID
-        await context.set_external_job_id(handler.request_id)
-
-        # Stream progress updates
-        from .....progress.models import ProgressUpdate
-
-        event_count = 0
-        async for event in handler.iter_events(with_logs=True):
-            event_count += 1
-            # Sample every 3rd event to avoid spam
-            if event_count % 3 == 0:
-                # Extract logs if available
-                logs = getattr(event, "logs", None)
-                if logs:
-                    # Join log entries into a single message
-                    if isinstance(logs, list):
-                        message = " | ".join(str(log) for log in logs if log)
-                    else:
-                        message = str(logs)
-
-                    if message:
-                        await context.publish_progress(
-                            ProgressUpdate(
-                                job_id=handler.request_id,
-                                status="processing",
-                                progress=50.0,  # Approximate mid-point progress
-                                phase="processing",
-                                message=message,
-                            )
-                        )
-
-        # Get final result
-        result = await handler.get()
-
-        # Extract video from result
-        # fal.ai returns: {"video": {"url": "...", "content_type": "video/mp4", ...}}
-        video_data = result.get("video")
-
-        if not video_data:
-            raise ValueError("No video returned from fal.ai API")
-
-        video_url = video_data.get("url")
-        if not video_url:
-            raise ValueError("Video missing URL in fal.ai response")
-
-        # Extract format from content_type (e.g., "video/mp4" -> "mp4")
-        content_type = video_data.get("content_type", "video/mp4")
-        video_format = content_type.split("/")[-1] if "/" in content_type else "mp4"
-
-        # Determine output duration
-        # If audio provided, use its duration; otherwise use video duration
-        output_duration = (
-            inputs.audio_url.duration if inputs.audio_url is not None else inputs.video_url.duration
-        )
-
-        # Store the video result
-        # Use input video dimensions and fps as they remain unchanged
-        artifact = await context.store_video_result(
-            storage_url=video_url,
-            format=video_format,
-            width=inputs.video_url.width,
-            height=inputs.video_url.height,
-            duration=output_duration,
-            fps=inputs.video_url.fps,
-            output_index=0,
-        )
-
-        return GeneratorResult(outputs=[artifact])
-
-    async def estimate_cost(self, inputs: PixverseLipsyncInput) -> float:
-        """Estimate cost for PixVerse Lipsync generation in USD.
-
-        Pricing:
-        - $0.04 per second of output video
-        - $0.24 per 100 characters if using TTS (when text provided without audio)
-        """
-        # Base cost: $0.04 per second of video
-        # Use input video duration as estimate for output duration
-        video_duration_seconds = inputs.video_url.duration or 5.0  # Default to 5 seconds if unknown
-        video_cost = video_duration_seconds * 0.04
-
-        # Add TTS cost if using text instead of audio
-        tts_cost = 0.0
-        if inputs.audio_url is None and inputs.text is not None:
-            # $0.24 per 100 characters
-            text_length = len(inputs.text)
-            tts_cost = (text_length / 100.0) * 0.24
-
-        return video_cost + tts_cost