@weirdfingers/baseboards 0.9.6 → 0.9.7

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

@@ -1,158 +0,0 @@
-"""
-WAN-Pro 2.1 image-to-video generator.
-
-A premium image-to-video model that generates high-quality 1080p videos at 30fps
-with up to 6 seconds duration, converting static images into dynamic video content
-with exceptional motion diversity.
-
-Based on Fal AI's fal-ai/wan-pro/image-to-video model.
-See: https://fal.ai/models/fal-ai/wan-pro/image-to-video
-"""
-
-import os
-
-from pydantic import BaseModel, Field
-
-from ....artifacts import ImageArtifact
-from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
-
-
-class WanProImageToVideoInput(BaseModel):
-    """Input schema for WAN-Pro 2.1 image-to-video generation.
-
-    Artifact fields (image) are automatically detected via type introspection
-    and resolved from generation IDs to ImageArtifact objects.
-    """
-
-    image: ImageArtifact = Field(description="The image to generate the video from")
-    prompt: str = Field(description="Text prompt describing the desired video content and motion")
-    seed: int | None = Field(
-        default=None,
-        description="Random seed for reproducibility. If not specified, a random seed will be used",
-    )
-    enable_safety_checker: bool = Field(
-        default=True,
-        description="Whether to enable the safety checker for content moderation",
-    )
-
-
-class FalWanProImageToVideoGenerator(BaseGenerator):
-    """Generator for creating videos from static images using WAN-Pro 2.1."""
-
-    name = "fal-wan-pro-image-to-video"
-    description = "Fal: WAN-Pro 2.1 - Generate high-quality 1080p videos from static images"
-    artifact_type = "video"
-
-    def get_input_schema(self) -> type[WanProImageToVideoInput]:
-        """Return the input schema for this generator."""
-        return WanProImageToVideoInput
-
-    async def generate(
-        self, inputs: WanProImageToVideoInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Generate video using fal.ai wan-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 FalWanProImageToVideoGenerator. "
-                "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 = {
-            "image_url": image_urls[0],
-            "prompt": inputs.prompt,
-            "enable_safety_checker": inputs.enable_safety_checker,
-        }
-
-        # Only add seed if provided (allow API to use random if not specified)
-        if inputs.seed is not None:
-            arguments["seed"] = inputs.seed
-
-        # Submit async job
-        handler = await fal_client.submit_async(
-            "fal-ai/wan-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
-        # WAN-Pro generates 1080p videos at 30fps with up to 6 seconds duration
-        artifact = await context.store_video_result(
-            storage_url=video_url,
-            format="mp4",
-            width=1920,
-            height=1080,
-            duration=6,  # Maximum duration
-            fps=30,
-            output_index=0,
-        )
-
-        return GeneratorResult(outputs=[artifact])
-
-    async def estimate_cost(self, inputs: WanProImageToVideoInput) -> 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.10  # Placeholder estimate for premium image-to-video generation

package/templates/api/src/boards/generators/implementations/kie/__init__.py

@@ -1,11 +0,0 @@
-"""Kie.ai generator implementations."""
-
-from .image.nano_banana_edit import KieNanoBananaEditGenerator, NanoBananaEditInput
-from .video.veo3 import KieVeo3Generator, KieVeo3Input
-
-__all__ = [
-    "KieNanoBananaEditGenerator",
-    "NanoBananaEditInput",
-    "KieVeo3Generator",
-    "KieVeo3Input",
-]

package/templates/api/src/boards/generators/implementations/kie/base.py

@@ -1,316 +0,0 @@
-"""Base classes for Kie.ai generators.
-
-Provides common functionality shared across all Kie.ai generator implementations,
-including API key validation, HTTP client setup, response validation, and polling logic.
-
-Kie.ai supports two API patterns:
-- Market API: Unified endpoint for 30+ models using /api/v1/jobs endpoints
-- Dedicated API: Model-specific endpoints with custom paths
-"""
-
-import asyncio
-import os
-from abc import abstractmethod
-from typing import Any, ClassVar, Literal
-
-import httpx
-
-from ....progress.models import ProgressUpdate
-from ...base import BaseGenerator, GeneratorExecutionContext
-
-
-class KieBaseGenerator(BaseGenerator):
-    """Base class for all Kie.ai generators with common functionality.
-
-    Provides shared methods for API key management, HTTP requests,
-    response validation, and external job ID storage.
-
-    Subclasses must define:
-    - api_pattern: Either "market" or "dedicated"
-    - model_id: Model identifier (for market) or endpoint path (for dedicated)
-    """
-
-    # Subclasses must define these
-    api_pattern: ClassVar[Literal["market", "dedicated"]]
-    model_id: str
-
-    def _get_api_key(self) -> str:
-        """Get and validate KIE_API_KEY from environment.
-
-        Returns:
-            The API key string
-
-        Raises:
-            ValueError: If KIE_API_KEY is not set
-        """
-        api_key = os.getenv("KIE_API_KEY")
-        if not api_key:
-            raise ValueError("API configuration invalid. Missing KIE_API_KEY environment variable")
-        return api_key
-
-    def _validate_response(self, response: dict[str, Any]) -> None:
-        """Validate standard Kie.ai response structure.
-
-        All Kie.ai APIs return responses with a "code" field where 200 indicates success.
-
-        Args:
-            response: The JSON response from Kie.ai API
-
-        Raises:
-            ValueError: If the response code is not 200
-        """
-        if response.get("code") != 200:
-            error_msg = response.get("msg", "Unknown error")
-            raise ValueError(f"Kie.ai API error: {error_msg}")
-
-    async def _make_request(
-        self,
-        url: str,
-        method: Literal["GET", "POST"],
-        api_key: str,
-        json: dict[str, Any] | None = None,
-        timeout: float = 30.0,
-    ) -> dict[str, Any]:
-        """Make HTTP request to Kie.ai API with standard error handling.
-
-        Args:
-            url: Full URL to request
-            method: HTTP method (GET or POST)
-            api_key: API key for authorization
-            json: Request body for POST requests
-            timeout: Request timeout in seconds
-
-        Returns:
-            The validated JSON response
-
-        Raises:
-            ValueError: If the request fails or returns an error response
-        """
-        async with httpx.AsyncClient() as client:
-            if method == "POST":
-                response = await client.post(
-                    url,
-                    json=json,
-                    headers={
-                        "Authorization": f"Bearer {api_key}",
-                        "Content-Type": "application/json",
-                    },
-                    timeout=timeout,
-                )
-            else:
-                response = await client.get(
-                    url,
-                    headers={"Authorization": f"Bearer {api_key}"},
-                    timeout=timeout,
-                )
-
-            if response.status_code != 200:
-                raise ValueError(
-                    f"Kie.ai API request failed: {response.status_code} {response.text}"
-                )
-
-            result = response.json()
-            self._validate_response(result)
-            return result
-
-    @abstractmethod
-    async def _poll_for_completion(
-        self,
-        task_id: str,
-        api_key: str,
-        context: GeneratorExecutionContext,
-    ) -> dict[str, Any]:
-        """Poll for task completion.
-
-        Subclasses implement this based on their API pattern (Market vs Dedicated).
-
-        Args:
-            task_id: The task ID to poll
-            api_key: API key for authorization
-            context: Generator execution context for progress updates
-
-        Returns:
-            The completed task data containing results
-
-        Raises:
-            ValueError: If polling fails or task fails
-        """
-        pass
-
-
-class KieMarketAPIGenerator(KieBaseGenerator):
-    """Base class for Kie.ai Market API generators.
-
-    Market API is used for 30+ models through a unified endpoint.
-    - Submit: POST /api/v1/jobs/createTask with model parameter
-    - Status: GET /api/v1/jobs/recordInfo?taskId={id}
-    - Status field: "state" with values: "waiting", "pending", "processing", "success", "failed"
-    """
-
-    api_pattern: ClassVar[Literal["market"]] = "market"
-
-    async def _poll_for_completion(
-        self,
-        task_id: str,
-        api_key: str,
-        context: GeneratorExecutionContext,
-        max_polls: int = 120,
-        poll_interval: int = 10,
-    ) -> dict[str, Any]:
-        """Poll Market API for task completion using state field.
-
-        Args:
-            task_id: The task ID to poll
-            api_key: API key for authorization
-            context: Generator execution context for progress updates
-            max_polls: Maximum number of polling attempts (default: 120 = 20 minutes)
-            poll_interval: Seconds between polls (default: 10)
-
-        Returns:
-            The completed task data from the "data" field
-
-        Raises:
-            ValueError: If task fails or times out
-        """
-        status_url = f"https://api.kie.ai/api/v1/jobs/recordInfo?taskId={task_id}"
-
-        async with httpx.AsyncClient() as client:
-            for poll_count in range(max_polls):
-                # Don't sleep on first poll - check status immediately
-                if poll_count > 0:
-                    await asyncio.sleep(poll_interval)
-
-                status_response = await client.get(
-                    status_url,
-                    headers={"Authorization": f"Bearer {api_key}"},
-                    timeout=30.0,
-                )
-
-                if status_response.status_code != 200:
-                    raise ValueError(
-                        f"Status check failed: {status_response.status_code} {status_response.text}"
-                    )
-
-                status_result = status_response.json()
-                self._validate_response(status_result)
-
-                task_data = status_result.get("data", {})
-                state = task_data.get("state")
-
-                if state == "success":
-                    return task_data
-                elif state == "failed":
-                    error_msg = task_data.get("failMsg", "Unknown error")
-                    raise ValueError(f"Generation failed: {error_msg}")
-                elif state not in ["waiting", "pending", "processing", None]:
-                    raise ValueError(
-                        f"Unknown state '{state}' from Kie.ai API. Full response: {status_result}"
-                    )
-
-                # Publish progress
-                progress = min(90, (poll_count / max_polls) * 100)
-                await context.publish_progress(
-                    ProgressUpdate(
-                        job_id=task_id,
-                        status="processing",
-                        progress=progress,
-                        phase="processing",
-                    )
-                )
-            else:
-                timeout_minutes = (max_polls * poll_interval) / 60
-                raise ValueError(f"Generation timed out after {timeout_minutes} minutes")
-
-
-class KieDedicatedAPIGenerator(KieBaseGenerator):
-    """Base class for Kie.ai Dedicated API generators.
-
-    Dedicated APIs have model-specific endpoints with custom paths.
-    - Submit: POST /api/v1/{model}/generate (no model parameter in body)
-    - Status: GET /api/v1/{model}/record-info?taskId={id}
-    - Status field: "successFlag" with values: 0 (processing), 1 (success), 2/3 (failed)
-    """
-
-    api_pattern: ClassVar[Literal["dedicated"]] = "dedicated"
-
-    @abstractmethod
-    def _get_status_url(self, task_id: str) -> str:
-        """Get the status check URL for this specific dedicated API.
-
-        Each dedicated API has its own status endpoint path.
-
-        Args:
-            task_id: The task ID to check status for
-
-        Returns:
-            Full URL for status checking
-        """
-        pass
-
-    async def _poll_for_completion(
-        self,
-        task_id: str,
-        api_key: str,
-        context: GeneratorExecutionContext,
-        max_polls: int = 180,
-        poll_interval: int = 10,
-    ) -> dict[str, Any]:
-        """Poll Dedicated API for task completion using successFlag field.
-
-        Args:
-            task_id: The task ID to poll
-            api_key: API key for authorization
-            context: Generator execution context for progress updates
-            max_polls: Maximum number of polling attempts (default: 180 = 30 minutes)
-            poll_interval: Seconds between polls (default: 10)
-
-        Returns:
-            The completed task data from the "data" field
-
-        Raises:
-            ValueError: If task fails or times out
-        """
-        status_url = self._get_status_url(task_id)
-
-        async with httpx.AsyncClient() as client:
-            for poll_count in range(max_polls):
-                # Don't sleep on first poll - check status immediately
-                if poll_count > 0:
-                    await asyncio.sleep(poll_interval)
-
-                status_response = await client.get(
-                    status_url,
-                    headers={"Authorization": f"Bearer {api_key}"},
-                    timeout=30.0,
-                )
-
-                if status_response.status_code != 200:
-                    raise ValueError(
-                        f"Status check failed: {status_response.status_code} {status_response.text}"
-                    )
-
-                status_result = status_response.json()
-                self._validate_response(status_result)
-
-                task_data = status_result.get("data", {})
-                success_flag = task_data.get("successFlag")
-
-                if success_flag == 1:
-                    return task_data
-                elif success_flag in [2, 3]:
-                    error_msg = task_data.get("errorMsg", "Unknown error")
-                    raise ValueError(f"Generation failed: {error_msg}")
-
-                # Publish progress
-                progress = min(90, (poll_count / max_polls) * 100)
-                await context.publish_progress(
-                    ProgressUpdate(
-                        job_id=task_id,
-                        status="processing",
-                        progress=progress,
-                        phase="processing",
-                    )
-                )
-            else:
-                timeout_minutes = (max_polls * poll_interval) / 60
-                raise ValueError(f"Generation timed out after {timeout_minutes} minutes")

package/templates/api/src/boards/generators/implementations/kie/image/__init__.py

@@ -1,3 +0,0 @@
-from .nano_banana_edit import KieNanoBananaEditGenerator
-
-__all__ = ["KieNanoBananaEditGenerator"]

package/templates/api/src/boards/generators/implementations/kie/image/nano_banana_edit.py

@@ -1,190 +0,0 @@
-"""
-Kie.ai nano-banana image-to-image editing generator.
-
-Edit images using Kie.ai's google/nano-banana-edit model (powered by Google Gemini).
-Supports editing multiple input images with a text prompt.
-
-Based on Kie.ai's google/nano-banana-edit model.
-See: https://docs.kie.ai/market/google/nano-banana-edit
-"""
-
-from typing import Literal
-
-from pydantic import BaseModel, Field
-
-from ....artifacts import ImageArtifact
-from ....base import GeneratorExecutionContext, GeneratorResult
-from ..base import KieMarketAPIGenerator
-
-
-class NanoBananaEditInput(BaseModel):
-    """Input schema for nano-banana image editing.
-
-    Artifact fields (like image_sources) are automatically detected via type
-    introspection and resolved from generation IDs to ImageArtifact objects.
-    """
-
-    prompt: str = Field(
-        description="The prompt for image editing",
-        max_length=5000,
-    )
-    image_sources: list[ImageArtifact] = Field(
-        description="List of input images for editing (from previous generations)",
-        min_length=1,
-        max_length=10,
-    )
-    output_format: Literal["png", "jpeg"] = Field(
-        default="png",
-        description="Output image format",
-    )
-    image_size: Literal[
-        "1:1",
-        "9:16",
-        "16:9",
-        "3:4",
-        "4:3",
-        "3:2",
-        "2:3",
-        "5:4",
-        "4:5",
-        "21:9",
-        "auto",
-    ] = Field(
-        default="1:1",
-        description="Output image aspect ratio",
-    )
-
-
-class KieNanoBananaEditGenerator(KieMarketAPIGenerator):
-    """nano-banana image editing generator using Kie.ai Market API."""
-
-    name = "kie-nano-banana-edit"
-    artifact_type = "image"
-    description = "Kie.ai: Google nano-banana edit - AI-powered image editing with Gemini"
-
-    # Market API configuration
-    model_id = "google/nano-banana-edit"
-
-    def get_input_schema(self) -> type[NanoBananaEditInput]:
-        return NanoBananaEditInput
-
-    async def generate(
-        self, inputs: NanoBananaEditInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Edit images using Kie.ai google/nano-banana-edit model."""
-        # Get API key using base class method
-        api_key = self._get_api_key()
-
-        # Upload image artifacts to Kie.ai's public storage
-        # Kie.ai 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 Kie.ai's temporary storage first
-        from ..utils import upload_artifacts_to_kie
-
-        image_urls = await upload_artifacts_to_kie(inputs.image_sources, context)
-
-        # Prepare request body for Market API
-        body = {
-            "model": self.model_id,
-            "input": {
-                "prompt": inputs.prompt,
-                "image_urls": image_urls,
-                "output_format": inputs.output_format,
-                "image_size": inputs.image_size,
-            },
-        }
-
-        # Submit task using base class method
-        submit_url = "https://api.kie.ai/api/v1/jobs/createTask"
-        result = await self._make_request(submit_url, "POST", api_key, json=body)
-
-        # Extract task ID with safe dictionary access
-        data = result.get("data", {})
-        task_id = data.get("taskId")
-
-        if not task_id:
-            raise ValueError(f"No taskId returned from Kie.ai API. Response: {result}")
-
-        # Store external job ID
-        await context.set_external_job_id(task_id)
-
-        # Poll for completion using base class method
-        task_data = await self._poll_for_completion(task_id, api_key, context)
-
-        # Extract outputs from resultJson
-        result_json = task_data.get("resultJson")
-        if result_json:
-            import json
-
-            result_data = json.loads(result_json)
-        else:
-            result_data = task_data.get("result")
-
-        if not result_data:
-            raise ValueError("No result data returned from Kie.ai API")
-
-        # Extract image URLs from result
-        # The response structure may vary, but typically contains image URLs
-        # Based on the API pattern, result should contain the generated images
-        images = result_data.get("images", [])
-
-        if not images:
-            # Sometimes the result might directly contain URLs in different structure
-            # Try to extract from common patterns
-            if isinstance(result_data, dict):
-                # Check for common response patterns
-                if "resultUrls" in result_data:
-                    # Market API returns resultUrls as array of strings
-                    images = [{"url": url} for url in result_data["resultUrls"]]
-                elif "image_urls" in result_data:
-                    images = [{"url": url} for url in result_data["image_urls"]]
-                elif "url" in result_data:
-                    images = [{"url": result_data["url"]}]
-                else:
-                    raise ValueError(f"No images found in result: {result_data}")
-            else:
-                raise ValueError("No images returned from Kie.ai API")
-
-        # Store each image using output_index
-        artifacts = []
-        for idx, image_data in enumerate(images):
-            if isinstance(image_data, str):
-                image_url = image_data
-                width = 1024
-                height = 1024
-            elif isinstance(image_data, dict):
-                image_url = image_data.get("url")
-                # Extract dimensions if available, otherwise use sensible defaults
-                width = image_data.get("width", 1024)
-                height = image_data.get("height", 1024)
-            else:
-                raise ValueError(f"Unexpected image data format: {type(image_data)}")
-
-            if not image_url:
-                raise ValueError(f"Image {idx} missing URL in Kie.ai response")
-
-            # Store with appropriate output_index
-            artifact = await context.store_image_result(
-                storage_url=image_url,
-                format=inputs.output_format,
-                width=width,
-                height=height,
-                output_index=idx,
-            )
-            artifacts.append(artifact)
-
-        return GeneratorResult(outputs=artifacts)
-
-    async def estimate_cost(self, inputs: NanoBananaEditInput) -> float:
-        """Estimate cost for nano-banana edit generation.
-
-        nano-banana/edit uses Google Gemini for image editing.
-        Estimated at $0.025 per image (approximately 35% cheaper than Fal's $0.039).
-
-        Note: Actual pricing should be verified at https://kie.ai/pricing
-        """
-        # Cost per image - this is an estimate and should be updated with actual pricing
-        per_image_cost = 0.025
-        num_images = len(inputs.image_sources)
-        return per_image_cost * num_images