@weirdfingers/baseboards 0.9.5 → 0.9.7

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

@@ -1,159 +0,0 @@
-"""
-fal.ai Kling Video AI Avatar v2 Standard generator.
-
-Generates avatar videos by synthesizing realistic humans, animals, cartoons, or
-stylized characters. Takes an image and audio as inputs to create synchronized
-video output.
-
-Based on Fal AI's fal-ai/kling-video/ai-avatar/v2/standard model.
-See: https://fal.ai/models/fal-ai/kling-video/ai-avatar/v2/standard
-"""
-
-import os
-
-from pydantic import BaseModel, Field
-
-from ....artifacts import AudioArtifact, ImageArtifact
-from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
-
-
-class KlingVideoAiAvatarV2StandardInput(BaseModel):
-    """Input schema for Kling Video AI Avatar v2 Standard.
-
-    Artifact fields are automatically detected via type introspection
-    and resolved from generation IDs to artifact objects.
-    """
-
-    image: ImageArtifact = Field(description="The image to use as your avatar")
-    audio: AudioArtifact = Field(description="The audio file for lip-sync animation")
-    prompt: str | None = Field(
-        default=".", description="The prompt to use for the video generation"
-    )
-
-
-class FalKlingVideoAiAvatarV2StandardGenerator(BaseGenerator):
-    """Generator for AI-powered avatar video synthesis."""
-
-    name = "fal-kling-video-ai-avatar-v2-standard"
-    description = "Fal: Kling Video AI Avatar v2 Standard - Avatar video from image and audio"
-    artifact_type = "video"
-
-    def get_input_schema(self) -> type[KlingVideoAiAvatarV2StandardInput]:
-        """Return the input schema for this generator."""
-        return KlingVideoAiAvatarV2StandardInput
-
-    async def generate(
-        self, inputs: KlingVideoAiAvatarV2StandardInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Generate avatar video using fal.ai kling-video/ai-avatar/v2/standard."""
-        # 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 FalKlingVideoAiAvatarV2StandardGenerator. "
-                "Install with: pip install weirdfingers-boards[generators-fal]"
-            ) from e
-
-        # Upload image and audio artifacts to Fal's public storage
-        # Fal API requires publicly accessible URLs
-        from ..utils import upload_artifacts_to_fal
-
-        # Upload image and audio separately
-        image_urls = await upload_artifacts_to_fal([inputs.image], context)
-        audio_urls = await upload_artifacts_to_fal([inputs.audio], context)
-
-        # Prepare arguments for fal.ai API
-        arguments = {
-            "image_url": image_urls[0],
-            "audio_url": audio_urls[0],
-        }
-
-        # Add prompt only if provided and not the default empty value
-        if inputs.prompt and inputs.prompt != ".":
-            arguments["prompt"] = inputs.prompt
-
-        # Submit async job
-        handler = await fal_client.submit_async(
-            "fal-ai/kling-video/ai-avatar/v2/standard",
-            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": ...}, "duration": ...}
-        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"
-
-        # Extract duration from response (available in API response)
-        duration = result.get("duration")
-
-        # Store the video result
-        # Use input image dimensions as base dimensions (avatar video maintains aspect ratio)
-        artifact = await context.store_video_result(
-            storage_url=video_url,
-            format=video_format,
-            width=inputs.image.width,
-            height=inputs.image.height,
-            duration=duration,
-            fps=None,  # Not provided by API
-            output_index=0,
-        )
-
-        return GeneratorResult(outputs=[artifact])
-
-    async def estimate_cost(self, inputs: KlingVideoAiAvatarV2StandardInput) -> float:
-        """Estimate cost for Kling Video AI Avatar v2 Standard generation in USD.
-
-        Pricing not specified in documentation, using estimate based on
-        typical Kling video generation costs.
-        """
-        # Estimate per generation based on typical Kling pricing
-        return 0.10

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

@@ -1,175 +0,0 @@
-"""
-Kling v2.5 Turbo Pro image-to-video generator.
-
-Top-tier image-to-video generation with unparalleled motion fluidity, cinematic visuals,
-and exceptional prompt precision using Kling's v2.5 Turbo Pro model.
-
-Based on Fal AI's fal-ai/kling-video/v2.5-turbo/pro/image-to-video model.
-See: https://fal.ai/models/fal-ai/kling-video/v2.5-turbo/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 KlingVideoV25TurboProImageToVideoInput(BaseModel):
-    """Input schema for Kling v2.5 Turbo Pro 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="Text description of desired video content",
-        max_length=2500,
-    )
-    image_url: ImageArtifact = Field(
-        description="Source image for animation",
-    )
-    duration: Literal["5", "10"] = Field(
-        default="5",
-        description="Video length in seconds",
-    )
-    negative_prompt: str = Field(
-        default="blur, distort, and low quality",
-        description="Elements to exclude from output",
-        max_length=2500,
-    )
-    cfg_scale: float = Field(
-        default=0.5,
-        ge=0.0,
-        le=1.0,
-        description="Guidance strength controlling prompt adherence (0-1)",
-    )
-
-
-class FalKlingVideoV25TurboProImageToVideoGenerator(BaseGenerator):
-    """Generator for image-to-video using Kling v2.5 Turbo Pro."""
-
-    name = "fal-kling-video-v2-5-turbo-pro-image-to-video"
-    description = (
-        "Fal: Kling v2.5 Turbo Pro - top-tier image-to-video generation with cinematic visuals"
-    )
-    artifact_type = "video"
-
-    def get_input_schema(self) -> type[KlingVideoV25TurboProImageToVideoInput]:
-        """Return the input schema for this generator."""
-        return KlingVideoV25TurboProImageToVideoInput
-
-    async def generate(
-        self, inputs: KlingVideoV25TurboProImageToVideoInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Generate video using fal.ai Kling v2.5 Turbo Pro image-to-video 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 FalKlingVideoV25TurboProImageToVideoGenerator. "
-                "Install with: pip install weirdfingers-boards[generators-fal]"
-            ) from e
-
-        # Upload image artifact 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_url], context)
-
-        # Prepare arguments for fal.ai API
-        arguments = {
-            "prompt": inputs.prompt,
-            "image_url": image_urls[0],
-            "duration": inputs.duration,
-            "negative_prompt": inputs.negative_prompt,
-            "cfg_scale": inputs.cfg_scale,
-        }
-
-        # Submit async job
-        handler = await fal_client.submit_async(
-            "fal-ai/kling-video/v2.5-turbo/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,  # 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")
-
-        # Determine video dimensions based on input image
-        # Kling maintains the aspect ratio of the input image
-        # Use input image dimensions as reference
-        width = inputs.image_url.width
-        height = inputs.image_url.height
-
-        # Store video result
-        artifact = await context.store_video_result(
-            storage_url=video_url,
-            format="mp4",
-            width=width,
-            height=height,
-            duration=float(inputs.duration),  # Convert "5" or "10" to float
-            output_index=0,
-        )
-
-        return GeneratorResult(outputs=[artifact])
-
-    async def estimate_cost(self, inputs: KlingVideoV25TurboProImageToVideoInput) -> float:
-        """Estimate cost for Kling v2.5 Turbo Pro image-to-video generation.
-
-        Pricing information not provided in official documentation.
-        Estimated at $0.15 per video based on typical video generation costs.
-        Cost may vary based on duration and quality settings.
-        """
-        # Approximate cost per video
-        # 10-second videos may cost more than 5-second videos
-        base_cost = 0.15
-        duration_multiplier = 2.0 if inputs.duration == "10" else 1.0
-        return base_cost * duration_multiplier

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

@@ -1,168 +0,0 @@
-"""
-Kling v2.5 Turbo Pro text-to-video generator.
-
-Top-tier text-to-video generation with unparalleled motion fluidity, cinematic visuals,
-and exceptional prompt precision using Kling's v2.5 Turbo Pro model.
-
-Based on Fal AI's fal-ai/kling-video/v2.5-turbo/pro/text-to-video model.
-See: https://fal.ai/models/fal-ai/kling-video/v2.5-turbo/pro/text-to-video
-"""
-
-import os
-from typing import Literal
-
-from pydantic import BaseModel, Field
-
-from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
-
-
-class KlingVideoV25TurboProTextToVideoInput(BaseModel):
-    """Input schema for Kling v2.5 Turbo Pro text-to-video generation."""
-
-    prompt: str = Field(
-        description="Primary instruction for video generation",
-        max_length=2500,
-    )
-    duration: Literal["5", "10"] = Field(
-        default="5",
-        description="Video length in seconds",
-    )
-    aspect_ratio: Literal["16:9", "9:16", "1:1"] = Field(
-        default="16:9",
-        description="Frame dimensions",
-    )
-    negative_prompt: str = Field(
-        default="blur, distort, and low quality",
-        description="Elements to exclude from output",
-        max_length=2500,
-    )
-    cfg_scale: float = Field(
-        default=0.5,
-        ge=0.0,
-        le=1.0,
-        description="Guidance strength controlling prompt adherence (0-1)",
-    )
-
-
-class FalKlingVideoV25TurboProTextToVideoGenerator(BaseGenerator):
-    """Generator for text-to-video using Kling v2.5 Turbo Pro."""
-
-    name = "fal-kling-video-v2-5-turbo-pro-text-to-video"
-    description = (
-        "Fal: Kling v2.5 Turbo Pro - top-tier text-to-video generation with cinematic visuals"
-    )
-    artifact_type = "video"
-
-    def get_input_schema(self) -> type[KlingVideoV25TurboProTextToVideoInput]:
-        """Return the input schema for this generator."""
-        return KlingVideoV25TurboProTextToVideoInput
-
-    async def generate(
-        self, inputs: KlingVideoV25TurboProTextToVideoInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Generate video using fal.ai Kling v2.5 Turbo 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 FalKlingVideoV25TurboProTextToVideoGenerator. "
-                "Install with: pip install weirdfingers-boards[generators-fal]"
-            ) from e
-
-        # Prepare arguments for fal.ai API
-        arguments = {
-            "prompt": inputs.prompt,
-            "duration": inputs.duration,
-            "aspect_ratio": inputs.aspect_ratio,
-            "negative_prompt": inputs.negative_prompt,
-            "cfg_scale": inputs.cfg_scale,
-        }
-
-        # Submit async job
-        handler = await fal_client.submit_async(
-            "fal-ai/kling-video/v2.5-turbo/pro/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")
-
-        # Determine video dimensions based on aspect ratio
-        # Using HD quality resolutions
-        aspect_ratio_dimensions = {
-            "16:9": (1920, 1080),
-            "9:16": (1080, 1920),
-            "1:1": (1080, 1080),
-        }
-        width, height = aspect_ratio_dimensions.get(inputs.aspect_ratio, (1920, 1080))
-
-        # Store video result
-        artifact = await context.store_video_result(
-            storage_url=video_url,
-            format="mp4",
-            width=width,
-            height=height,
-            duration=float(inputs.duration),  # Convert "5" or "10" to float
-            output_index=0,
-        )
-
-        return GeneratorResult(outputs=[artifact])
-
-    async def estimate_cost(self, inputs: KlingVideoV25TurboProTextToVideoInput) -> float:
-        """Estimate cost for Kling v2.5 Turbo Pro generation.
-
-        Pricing information not provided in official documentation.
-        Estimated at $0.15 per video based on typical video generation costs.
-        Cost may vary based on duration and quality settings.
-        """
-        # Approximate cost per video
-        # 10-second videos may cost more than 5-second videos
-        base_cost = 0.15
-        duration_multiplier = 2.0 if inputs.duration == "10" else 1.0
-        return base_cost * duration_multiplier

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

@@ -1,153 +0,0 @@
-"""
-MiniMax Hailuo 2.3 Pro image-to-video generator.
-
-Advanced image-to-video generation model with 1080p resolution. Transforms static
-images into dynamic videos using text prompts to guide the creative output.
-
-Based on Fal AI's fal-ai/minimax/hailuo-2.3/pro/image-to-video model.
-See: https://fal.ai/models/fal-ai/minimax/hailuo-2.3/pro/image-to-video
-"""
-
-import os
-
-from pydantic import BaseModel, Field
-
-from ....artifacts import ImageArtifact
-from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
-
-
-class MinimaxHailuo23ProImageToVideoInput(BaseModel):
-    """Input schema for MiniMax Hailuo 2.3 Pro 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="Text prompt for video generation",
-        min_length=1,
-        max_length=2000,
-    )
-    image_url: ImageArtifact = Field(description="URL of the image to use as the first frame")
-    prompt_optimizer: bool = Field(
-        default=True,
-        description="Whether to use the model's prompt optimizer",
-    )
-
-
-class FalMinimaxHailuo23ProImageToVideoGenerator(BaseGenerator):
-    """Generator for creating videos from images using MiniMax Hailuo 2.3 Pro."""
-
-    name = "fal-minimax-hailuo-2-3-pro-image-to-video"
-    description = "Fal: MiniMax Hailuo 2.3 Pro - Image-to-video with 1080p resolution"
-    artifact_type = "video"
-
-    def get_input_schema(self) -> type[MinimaxHailuo23ProImageToVideoInput]:
-        """Return the input schema for this generator."""
-        return MinimaxHailuo23ProImageToVideoInput
-
-    async def generate(
-        self, inputs: MinimaxHailuo23ProImageToVideoInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Generate video using fal.ai minimax/hailuo-2.3/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 FalMinimaxHailuo23ProImageToVideoGenerator. "
-                "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],
-            "prompt_optimizer": inputs.prompt_optimizer,
-        }
-
-        # Submit async job
-        handler = await fal_client.submit_async(
-            "fal-ai/minimax/hailuo-2.3/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": "...", ...}}
-        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 the model's 1080p output
-        artifact = await context.store_video_result(
-            storage_url=video_url,
-            format="mp4",
-            width=1920,
-            height=1080,
-            duration=None,  # Duration not provided in response
-            output_index=0,
-        )
-
-        return GeneratorResult(outputs=[artifact])
-
-    async def estimate_cost(self, inputs: MinimaxHailuo23ProImageToVideoInput) -> 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
-        return 0.12  # Placeholder estimate for 1080p video generation