@weirdfingers/baseboards 0.9.6 → 0.9.7

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

@@ -1,98 +0,0 @@
-"""
-Shared utilities for Kie.ai generators.
-
-Provides helper functions for common operations across Kie generators.
-"""
-
-import asyncio
-import os
-
-import httpx
-
-from ...artifacts import AudioArtifact, DigitalArtifact, ImageArtifact, VideoArtifact
-from ...base import GeneratorExecutionContext
-
-
-async def upload_artifacts_to_kie[T: DigitalArtifact](
-    artifacts: list[ImageArtifact] | list[VideoArtifact] | list[AudioArtifact] | list[T],
-    context: GeneratorExecutionContext,
-) -> list[str]:
-    """
-    Upload artifacts to Kie.ai's temporary storage for use in API requests.
-
-    Kie.ai API endpoints require publicly accessible URLs for file inputs. Since our
-    storage URLs might be local or private (localhost, private S3 buckets, etc.),
-    we need to:
-    1. Resolve each artifact to a local file path
-    2. Upload to Kie.ai's public temporary storage
-    3. Get back publicly accessible URLs
-
-    Note: Files uploaded to Kie.ai storage expire after 3 days.
-
-    Args:
-        artifacts: List of artifacts (image, video, or audio) to upload
-        context: Generator execution context for artifact resolution
-
-    Returns:
-        List of publicly accessible URLs from Kie.ai storage
-
-    Raises:
-        ValueError: If KIE_API_KEY is not set
-        Any exceptions from file resolution or upload are propagated
-    """
-    api_key = os.getenv("KIE_API_KEY")
-    if not api_key:
-        raise ValueError("KIE_API_KEY environment variable is required for file uploads")
-
-    async def upload_single_artifact(artifact: DigitalArtifact) -> str:
-        """Upload a single artifact and return its public URL."""
-        # Resolve artifact to local file path (downloads if needed)
-        file_path_str = await context.resolve_artifact(artifact)
-
-        # Upload to Kie.ai's temporary storage
-        # Using file stream upload API
-        async with httpx.AsyncClient() as client:
-            with open(file_path_str, "rb") as f:
-                files = {"file": f}
-                # uploadPath is required by Kie.ai API - specifies the storage path
-                data = {"uploadPath": "boards/temp"}
-                response = await client.post(
-                    "https://kieai.redpandaai.co/api/file-stream-upload",
-                    files=files,
-                    data=data,
-                    headers={"Authorization": f"Bearer {api_key}"},
-                    timeout=120.0,  # 2 minute timeout for uploads
-                )
-
-            if response.status_code != 200:
-                raise ValueError(f"File upload failed: {response.status_code} {response.text}")
-
-            result = response.json()
-
-            if not result.get("success"):
-                raise ValueError(f"File upload failed: {result.get('msg')}")
-
-            # Extract the public URL from response data
-            data = result.get("data", {})
-
-            # The actual field name is 'downloadUrl' based on API response
-            file_url = data.get("downloadUrl")
-
-            if not file_url:
-                # Fallback to other possible field names
-                file_url = data.get("fileUrl") or data.get("file_url") or data.get("url")
-
-            if not file_url:
-                # If we still can't find the URL, provide detailed error message
-                raise ValueError(
-                    f"File upload succeeded but couldn't find URL in response. "
-                    f"Response data keys: {list(data.keys())}, "
-                    f"Full response: {result}"
-                )
-
-            return file_url
-
-    # Upload all artifacts in parallel for performance
-    urls = await asyncio.gather(*[upload_single_artifact(artifact) for artifact in artifacts])
-
-    return list(urls)

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

@@ -1,8 +0,0 @@
-"""Kie.ai video generators."""
-
-from .veo3 import KieVeo3Generator, KieVeo3Input
-
-__all__ = [
-    "KieVeo3Generator",
-    "KieVeo3Input",
-]

package/templates/api/src/boards/generators/implementations/kie/video/veo3.py

@@ -1,161 +0,0 @@
-"""
-Kie.ai Veo 3.1 text-to-video and image-to-video generator.
-
-Generate high-quality videos from text prompts with optional image inputs
-using Kie.ai's Google Veo 3.1 model (Dedicated API).
-
-Based on Kie.ai's Veo 3.1 API.
-See: https://docs.kie.ai/veo3-api/generate-veo-3-video
-"""
-
-from typing import Any, Literal
-
-from pydantic import BaseModel, Field
-
-from ....artifacts import ImageArtifact
-from ....base import GeneratorExecutionContext, GeneratorResult
-from ..base import KieDedicatedAPIGenerator
-
-
-class KieVeo3Input(BaseModel):
-    """Input schema for Kie.ai Veo 3.1 video generation.
-
-    Supports both text-to-video and image-to-video modes.
-    Artifact fields (like image_sources) 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",
-        max_length=5000,
-    )
-    image_sources: list[ImageArtifact] | None = Field(
-        default=None,
-        description="Optional list of 1-2 input images for image-to-video generation",
-        min_length=1,
-        max_length=2,
-    )
-    aspect_ratio: Literal["16:9", "9:16", "Auto"] = Field(
-        default="16:9",
-        description="Aspect ratio of the generated video",
-    )
-    model: Literal["veo3", "veo3_fast"] = Field(
-        default="veo3",
-        description="Model variant to use (veo3 for quality, veo3_fast for speed)",
-    )
-
-
-class KieVeo3Generator(KieDedicatedAPIGenerator):
-    """Veo 3.1 video generator using Kie.ai Dedicated API."""
-
-    name = "kie-veo3"
-    artifact_type = "video"
-    description = "Kie.ai: Google Veo 3.1 - High-quality AI video generation"
-
-    # Dedicated API configuration
-    model_id = "veo3"
-
-    def get_input_schema(self) -> type[KieVeo3Input]:
-        return KieVeo3Input
-
-    def _get_status_url(self, task_id: str) -> str:
-        """Get the Veo3-specific status check URL."""
-        return f"https://api.kie.ai/api/v1/veo/record-info?taskId={task_id}"
-
-    async def generate(
-        self, inputs: KieVeo3Input, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Generate video using Kie.ai Veo 3.1 model."""
-        # Get API key using base class method
-        api_key = self._get_api_key()
-
-        # Prepare request body for Dedicated API
-        body: dict[str, Any] = {
-            "prompt": inputs.prompt,
-            "aspectRatio": inputs.aspect_ratio,
-            "model": inputs.model,
-        }
-
-        # Upload image artifacts if provided (for image-to-video mode)
-        if inputs.image_sources:
-            from ..utils import upload_artifacts_to_kie
-
-            image_urls = await upload_artifacts_to_kie(inputs.image_sources, context)
-            body["imageUrls"] = image_urls
-
-        # Submit task to Dedicated API endpoint using base class method
-        submit_url = "https://api.kie.ai/api/v1/veo/generate"
-        result = await self._make_request(submit_url, "POST", api_key, json=body)
-
-        # Extract task ID from Dedicated API response
-        # Try direct taskId first, then nested under 'data'
-        task_id = result.get("taskId")
-        if not task_id:
-            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
-        result_data = await self._poll_for_completion(task_id, api_key, context)
-
-        # Extract video URLs from response.resultUrls field
-        # Dedicated API nests the results inside a 'response' object
-        response_data = result_data.get("response")
-        if not response_data:
-            raise ValueError(f"No response field in result. Response: {result_data}")
-
-        result_urls = response_data.get("resultUrls")
-        if not result_urls or not isinstance(result_urls, list):
-            raise ValueError(f"No resultUrls in response. Response: {result_data}")
-
-        # Determine video dimensions based on aspect ratio
-        # Default to 1080p quality
-        if inputs.aspect_ratio == "16:9":
-            width, height = 1920, 1080
-        elif inputs.aspect_ratio == "9:16":
-            width, height = 1080, 1920
-        else:  # Auto
-            # Default to 16:9 for Auto
-            width, height = 1920, 1080
-
-        # Veo 3 generates ~8 second videos by default
-        duration = 8.0
-
-        # Store each video using output_index
-        artifacts = []
-        for idx, video_url in enumerate(result_urls):
-            if not video_url:
-                raise ValueError(f"Video {idx} missing URL in Kie.ai response")
-
-            artifact = await context.store_video_result(
-                storage_url=video_url,
-                format="mp4",
-                width=width,
-                height=height,
-                duration=duration,
-                output_index=idx,
-            )
-            artifacts.append(artifact)
-
-        return GeneratorResult(outputs=artifacts)
-
-    async def estimate_cost(self, inputs: KieVeo3Input) -> float:
-        """Estimate cost for Veo 3.1 video generation.
-
-        Veo 3.1 pricing is estimated based on typical video generation costs.
-        Actual pricing should be verified at https://kie.ai/pricing
-
-        Base cost estimates:
-        - veo3: $0.08 per video (standard quality)
-        - veo3_fast: $0.04 per video (faster generation)
-        """
-        # Cost varies by model
-        if inputs.model == "veo3_fast":
-            return 0.04
-        else:  # veo3
-            return 0.08

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

@@ -1 +0,0 @@
-"""OpenAI provider generators."""

package/templates/api/src/boards/generators/implementations/openai/audio/__init__.py

@@ -1 +0,0 @@
-"""OpenAI audio generators."""

package/templates/api/src/boards/generators/implementations/openai/audio/whisper.py

@@ -1,69 +0,0 @@
-"""
-Whisper audio transcription using OpenAI API.
-
-Demonstrates audio processing generator that outputs text.
-"""
-
-from pydantic import BaseModel, Field
-
-from ....artifacts import AudioArtifact
-from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
-
-
-class WhisperInput(BaseModel):
-    """Input schema for Whisper transcription."""
-
-    audio_source: AudioArtifact = Field(description="Audio file to transcribe")
-    language: str = Field(default="en", description="Language code (e.g., 'en', 'es', 'fr')")
-    prompt: str = Field(default="", description="Optional prompt to guide transcription")
-
-
-class OpenAIWhisperGenerator(BaseGenerator):
-    """Whisper speech-to-text transcription using OpenAI API."""
-
-    name = "openai-whisper"
-    artifact_type = "text"
-    description = "OpenAI: Whisper - speech-to-text transcription"
-
-    def get_input_schema(self) -> type[WhisperInput]:
-        return WhisperInput
-
-    async def generate(
-        self, inputs: WhisperInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Transcribe audio using OpenAI Whisper."""
-        try:
-            from openai import AsyncOpenAI
-        except ImportError as e:
-            raise ImportError(
-                "OpenAI SDK is required for WhisperGenerator. "
-                "Install with: pip install weirdfingers-boards[generators-openai]"
-            ) from e
-
-        client = AsyncOpenAI()
-
-        # Resolve audio artifact to file path via context
-        audio_file_path = await context.resolve_artifact(inputs.audio_source)
-
-        # Use OpenAI SDK for transcription
-        with open(audio_file_path, "rb") as audio_file:
-            transcript = await client.audio.transcriptions.create(
-                model="whisper-1",
-                file=audio_file,
-                language=inputs.language,
-                prompt=inputs.prompt,
-            )
-
-        # Create text artifact
-        text_artifact = await context.store_text_result(
-            content=transcript.text,
-            format="plain",
-        )
-
-        return GeneratorResult(outputs=[text_artifact])
-
-    async def estimate_cost(self, inputs: WhisperInput) -> float:
-        """Estimate cost for Whisper transcription."""
-        # Whisper pricing is $0.006 per minute
-        duration_minutes = (inputs.audio_source.duration or 60) / 60
-        return duration_minutes * 0.006

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

@@ -1 +0,0 @@
-"""OpenAI image generators."""

package/templates/api/src/boards/generators/implementations/openai/image/dalle3.py

@@ -1,96 +0,0 @@
-"""
-DALL-E 3 generator using OpenAI API.
-
-Demonstrates integration with OpenAI's SDK for image generation.
-"""
-
-import os
-
-from pydantic import BaseModel, Field
-
-from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
-
-
-class DallE3Input(BaseModel):
-    """Input schema for DALL-E 3 image generation."""
-
-    prompt: str = Field(description="Text prompt for image generation")
-    size: str = Field(
-        default="1024x1024",
-        description="Image size",
-        pattern="^(1024x1024|1024x1792|1792x1024)$",
-    )
-    quality: str = Field(default="standard", description="Image quality", pattern="^(standard|hd)$")
-    style: str = Field(default="vivid", description="Image style", pattern="^(vivid|natural)$")
-
-
-class OpenAIDallE3Generator(BaseGenerator):
-    """DALL-E 3 image generator using OpenAI API."""
-
-    name = "openai-dall-e-3"
-    artifact_type = "image"
-    description = "OpenAI: DALL-E 3 - advanced text-to-image generation"
-
-    def get_input_schema(self) -> type[DallE3Input]:
-        return DallE3Input
-
-    async def generate(
-        self, inputs: DallE3Input, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Generate image using OpenAI DALL-E 3."""
-        # Check for API key
-        if not os.getenv("OPENAI_API_KEY"):
-            raise ValueError("API configuration invalid")
-
-        # Import SDK directly
-        try:
-            from openai import AsyncOpenAI
-        except ImportError as e:
-            raise ImportError(
-                "OpenAI SDK is required for DallE3Generator. "
-                "Install with: pip install weirdfingers-boards[generators-openai]"
-            ) from e
-
-        client = AsyncOpenAI()
-
-        # Use OpenAI SDK directly
-        response = await client.images.generate(
-            model="dall-e-3",
-            prompt=inputs.prompt,
-            size=inputs.size,  # pyright: ignore[reportArgumentType]
-            quality=inputs.quality,  # pyright: ignore[reportArgumentType]
-            style=inputs.style,  # pyright: ignore[reportArgumentType]
-            n=1,
-        )
-
-        # Get the generated image URL
-        if not response.data or not response.data[0].url:
-            raise ValueError("No image generated")
-        image_url = response.data[0].url
-
-        # Parse dimensions from size
-        width, height = map(int, inputs.size.split("x"))
-
-        # Store via context (downloads from OpenAI and uploads to our storage)
-        image_artifact = await context.store_image_result(
-            storage_url=image_url,
-            format="png",  # DALL-E 3 outputs PNG
-            width=width,
-            height=height,
-        )
-
-        return GeneratorResult(outputs=[image_artifact])
-
-    async def estimate_cost(self, inputs: DallE3Input) -> float:
-        """Estimate cost for DALL-E 3 generation."""
-        # DALL-E 3 pricing varies by quality and size
-        if inputs.quality == "hd":
-            if inputs.size in ["1024x1792", "1792x1024"]:
-                return 0.080  # HD, non-square
-            else:
-                return 0.080  # HD, square
-        else:  # standard quality
-            if inputs.size in ["1024x1792", "1792x1024"]:
-                return 0.040  # Standard, non-square
-            else:
-                return 0.040  # Standard, square

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

@@ -1 +0,0 @@
-"""Replicate provider generators."""

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

@@ -1 +0,0 @@
-"""Replicate image generators."""

package/templates/api/src/boards/generators/implementations/replicate/image/flux_pro.py

@@ -1,88 +0,0 @@
-"""
-FLUX.1.1 Pro generator using Replicate API.
-
-This demonstrates the simple pattern for creating generators:
-1. Define Pydantic input/output models
-2. Implement generation logic using provider SDK directly
-3. Register with the global registry
-"""
-
-import os
-from collections.abc import AsyncIterator
-
-from pydantic import BaseModel, Field
-
-from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
-
-
-class FluxProInput(BaseModel):
-    """Input schema for FLUX.1.1 Pro image generation."""
-
-    prompt: str = Field(description="Text prompt for image generation")
-    aspect_ratio: str = Field(
-        default="1:1",
-        description="Image aspect ratio",
-        pattern="^(1:1|16:9|21:9|2:3|3:2|4:5|5:4|9:16|9:21)$",
-    )
-    safety_tolerance: int = Field(default=2, ge=1, le=5, description="Safety tolerance level (1-5)")
-
-
-class ReplicateFluxProGenerator(BaseGenerator):
-    """FLUX.1.1 Pro image generator using Replicate."""
-
-    name = "replicate-flux-pro"
-    artifact_type = "image"
-    description = "Replicate: FLUX.1.1 [pro] by Black Forest Labs - high-quality image generation"
-
-    def get_input_schema(self) -> type[FluxProInput]:
-        return FluxProInput
-
-    async def generate(
-        self, inputs: FluxProInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Generate image using Replicate FLUX.1.1 Pro model."""
-        # Check for API key
-        if not os.getenv("REPLICATE_API_TOKEN"):
-            raise ValueError("API configuration invalid. Missing REPLICATE_API_TOKEN")
-
-        # Import SDK directly
-        try:
-            import replicate
-            from replicate.helpers import FileOutput
-        except ImportError as e:
-            raise ImportError(
-                "Replicate SDK is required for FluxProGenerator. "
-                "Install with: pip install weirdfingers-boards[generators-replicate]"
-            ) from e
-
-        # Use Replicate SDK directly
-        prediction: FileOutput | AsyncIterator[FileOutput] = await replicate.async_run(
-            "black-forest-labs/flux-1.1-pro",
-            input={
-                "prompt": inputs.prompt,
-                "aspect_ratio": inputs.aspect_ratio,
-                "safety_tolerance": inputs.safety_tolerance,
-            },
-        )
-
-        # If prediction is an async iterator, get the first item; else, use as is.
-        if isinstance(prediction, AsyncIterator):
-            file_output = await anext(prediction)
-        else:
-            file_output = prediction
-
-        output_url = file_output.url
-
-        image_artifact = await context.store_image_result(
-            storage_url=output_url,
-            format="png",
-            width=1024,
-            height=1024,
-        )
-
-        return GeneratorResult(outputs=[image_artifact])
-
-    async def estimate_cost(self, inputs: FluxProInput) -> float:
-        """Estimate cost for FLUX.1.1 Pro generation."""
-        # FLUX.1.1 Pro typically costs around $0.055 per generation
-        return 0.055

package/templates/api/src/boards/generators/implementations/replicate/video/__init__.py

@@ -1 +0,0 @@
-"""Replicate video generators."""

package/templates/api/src/boards/generators/implementations/replicate/video/lipsync.py

@@ -1,73 +0,0 @@
-"""
-Lipsync generator using Replicate API.
-
-This demonstrates how generators can use multiple artifact inputs
-with automatic artifact resolution.
-"""
-
-from pydantic import BaseModel, Field
-
-from ....artifacts import AudioArtifact, VideoArtifact
-from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
-
-
-class LipsyncInput(BaseModel):
-    """Input schema for lipsync generation."""
-
-    audio_source: AudioArtifact = Field(description="Audio track for lip sync")
-    video_source: VideoArtifact = Field(description="Video to sync lips in")
-    prompt: str | None = Field(None, description="Optional prompt for generation")
-
-
-class ReplicateLipsyncGenerator(BaseGenerator):
-    """Lipsync generator that syncs lips in video to audio."""
-
-    name = "replicate-lipsync"
-    artifact_type = "video"
-    description = "Replicate: Sync lips in video to match audio track"
-
-    def get_input_schema(self) -> type[LipsyncInput]:
-        return LipsyncInput
-
-    async def generate(
-        self, inputs: LipsyncInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Generate lip-synced video."""
-        # Import SDK directly
-        try:
-            import replicate  # type: ignore
-        except ImportError as e:
-            raise ImportError(
-                "Replicate SDK is required for LipsyncGenerator. "
-                "Install with: pip install weirdfingers-boards[generators-replicate]"
-            ) from e
-
-        # Resolve artifacts via context
-        audio_file = await context.resolve_artifact(inputs.audio_source)
-        video_file = await context.resolve_artifact(inputs.video_source)
-
-        # Use Replicate SDK directly with proper file handling
-        with open(audio_file, "rb") as audio_f, open(video_file, "rb") as video_f:
-            result = await replicate.async_run(
-                "cjwbw/wav2lip",
-                input={
-                    "audio": audio_f,
-                    "video": video_f,
-                },
-            )
-
-        # Store output and create artifact via context
-        video_artifact = await context.store_video_result(
-            storage_url=str(result),
-            format="mp4",
-            width=inputs.video_source.width,
-            height=inputs.video_source.height,
-            duration=inputs.audio_source.duration,
-        )
-
-        return GeneratorResult(outputs=[video_artifact])
-
-    async def estimate_cost(self, inputs: LipsyncInput) -> float:
-        """Estimate cost for lipsync generation."""
-        # Wav2Lip is typically free on Replicate, but let's add a small cost
-        return 0.01