@weirdfingers/baseboards 0.9.5 → 0.9.7

package/templates/api/src/boards/generators/implementations/fal/image/imagen4_preview_fast.py

@@ -1,179 +0,0 @@
-"""
-Google Imagen 4 fast text-to-image generator.
-
-Google's highest quality image generation model with support for multiple aspect ratios
-and batch generation.
-
-Based on Fal AI's fal-ai/imagen4/preview/fast model.
-See: https://fal.ai/models/fal-ai/imagen4/preview/fast
-"""
-
-import os
-from typing import Literal
-
-from pydantic import BaseModel, Field
-
-from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
-
-
-class Imagen4PreviewFastInput(BaseModel):
-    """Input schema for Google Imagen 4 fast image generation.
-
-    All parameters are simple types - no artifact inputs needed.
-    """
-
-    prompt: str = Field(description="The text prompt describing what you want to see")
-    negative_prompt: str = Field(
-        default="",
-        description="Discourage specific elements in generated images",
-    )
-    aspect_ratio: Literal["1:1", "16:9", "9:16", "3:4", "4:3"] = Field(
-        default="1:1",
-        description="Image aspect ratio",
-    )
-    num_images: int = Field(
-        default=1,
-        ge=1,
-        le=4,
-        description="Number of images to generate (1-4)",
-    )
-    seed: int | None = Field(
-        default=None,
-        description="Random seed for reproducible generation (optional)",
-    )
-
-
-class FalImagen4PreviewFastGenerator(BaseGenerator):
-    """Google Imagen 4 fast image generator using fal.ai."""
-
-    name = "fal-imagen4-preview-fast"
-    artifact_type = "image"
-    description = "Fal: Google Imagen 4 - highest quality text-to-image generation"
-
-    def get_input_schema(self) -> type[Imagen4PreviewFastInput]:
-        return Imagen4PreviewFastInput
-
-    async def generate(
-        self, inputs: Imagen4PreviewFastInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Generate images using Google Imagen 4 via fal.ai."""
-        # Check for API key (fal-client uses FAL_KEY environment variable)
-        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 FalImagen4PreviewFastGenerator. "
-                "Install with: pip install weirdfingers-boards[generators-fal]"
-            ) from e
-
-        # Prepare arguments for fal.ai API
-        arguments = {
-            "prompt": inputs.prompt,
-            "negative_prompt": inputs.negative_prompt,
-            "aspect_ratio": inputs.aspect_ratio,
-            "num_images": inputs.num_images,
-        }
-
-        # Add seed if provided
-        if inputs.seed is not None:
-            arguments["seed"] = inputs.seed
-
-        # Submit async job and get handler
-        handler = await fal_client.submit_async(
-            "fal-ai/imagen4/preview/fast",
-            arguments=arguments,
-        )
-
-        # Store the external job ID for tracking
-        await context.set_external_job_id(handler.request_id)
-
-        # Stream progress updates (sample every 3rd event to avoid spam)
-        from .....progress.models import ProgressUpdate
-
-        event_count = 0
-        async for event in handler.iter_events(with_logs=True):
-            event_count += 1
-
-            # Process every 3rd event to provide feedback without overwhelming
-            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 image URLs from result
-        # fal.ai returns: {"images": [{"url": "...", "content_type": "...", ...}, ...], "seed": ...}
-        images = result.get("images", [])
-        if not images:
-            raise ValueError("No images returned from fal.ai API")
-
-        # Store each image using output_index
-        artifacts = []
-        for idx, image_data in enumerate(images):
-            image_url = image_data.get("url")
-
-            if not image_url:
-                raise ValueError(f"Image {idx} missing URL in fal.ai response")
-
-            # Imagen 4 returns PNG images
-            # We don't have width/height in the response, so use defaults based on aspect ratio
-            # This is a simplification - actual dimensions may vary
-            width, height = self._get_dimensions_for_aspect_ratio(inputs.aspect_ratio)
-
-            # Store with appropriate output_index
-            artifact = await context.store_image_result(
-                storage_url=image_url,
-                format="png",
-                width=width,
-                height=height,
-                output_index=idx,
-            )
-            artifacts.append(artifact)
-
-        return GeneratorResult(outputs=artifacts)
-
-    def _get_dimensions_for_aspect_ratio(self, aspect_ratio: str) -> tuple[int, int]:
-        """Get approximate dimensions for a given aspect ratio.
-
-        Returns (width, height) tuple. Uses 1024 as base for 1:1 ratio.
-        """
-        aspect_map = {
-            "1:1": (1024, 1024),
-            "16:9": (1360, 768),
-            "9:16": (768, 1360),
-            "3:4": (896, 1152),
-            "4:3": (1152, 896),
-        }
-        return aspect_map.get(aspect_ratio, (1024, 1024))
-
-    async def estimate_cost(self, inputs: Imagen4PreviewFastInput) -> float:
-        """Estimate cost for Google Imagen 4 generation.
-
-        Pricing information was not available in the documentation.
-        Using estimated cost of $0.04 per image based on similar high-quality models.
-        """
-        # Estimated cost per image (actual pricing may vary)
-        cost_per_image = 0.04
-        return cost_per_image * inputs.num_images

package/templates/api/src/boards/generators/implementations/fal/image/nano_banana.py

@@ -1,183 +0,0 @@
-"""
-fal.ai nano-banana text-to-image generator.
-
-Fast image generation using fal.ai's nano-banana model with support for batch outputs.
-"""
-
-import os
-from typing import Literal
-
-from pydantic import BaseModel, Field
-
-from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
-
-
-class NanoBananaInput(BaseModel):
-    """Input schema for nano-banana image generation."""
-
-    prompt: str = Field(description="Text prompt for image generation")
-    image_size: Literal[
-        "square_hd",
-        "square",
-        "portrait_4_3",
-        "portrait_16_9",
-        "landscape_4_3",
-        "landscape_16_9",
-    ] = Field(
-        default="landscape_4_3",
-        description="Image aspect ratio and resolution",
-    )
-    num_inference_steps: int = Field(
-        default=4,
-        ge=1,
-        le=50,
-        description="Number of inference steps (more steps = higher quality but slower)",
-    )
-    guidance_scale: float = Field(
-        default=3.5,
-        ge=1.0,
-        le=20.0,
-        description="Guidance scale for prompt adherence",
-    )
-    num_images: int = Field(
-        default=1,
-        ge=1,
-        le=10,
-        description="Number of images to generate in batch",
-    )
-    enable_safety_checker: bool = Field(
-        default=True,
-        description="Enable safety checker to filter unsafe content",
-    )
-    seed: int | None = Field(
-        default=None,
-        description="Random seed for reproducibility (optional)",
-    )
-    sync_mode: bool = Field(
-        default=True,
-        description="Use synchronous mode (wait for completion)",
-    )
-    output_format: Literal["jpeg", "png"] = Field(
-        default="jpeg",
-        description="Output image format",
-    )
-
-
-class FalNanoBananaGenerator(BaseGenerator):
-    """nano-banana image generator using fal.ai."""
-
-    name = "fal-nano-banana"
-    artifact_type = "image"
-    description = "Fal: nano-banana - fast text-to-image generation with batch support"
-
-    def get_input_schema(self) -> type[NanoBananaInput]:
-        return NanoBananaInput
-
-    async def generate(
-        self, inputs: NanoBananaInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Generate images using fal.ai nano-banana model."""
-        # Check for API key (fal-client uses FAL_KEY environment variable)
-        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 NanoBananaGenerator. "
-                "Install with: pip install weirdfingers-boards[generators-fal]"
-            ) from e
-
-        # Prepare arguments for fal.ai API
-        arguments = {
-            "prompt": inputs.prompt,
-            "image_size": inputs.image_size,
-            "num_inference_steps": inputs.num_inference_steps,
-            "guidance_scale": inputs.guidance_scale,
-            "num_images": inputs.num_images,
-            "enable_safety_checker": inputs.enable_safety_checker,
-            "sync_mode": inputs.sync_mode,
-            "output_format": inputs.output_format,
-        }
-
-        # Add seed if provided
-        if inputs.seed is not None:
-            arguments["seed"] = inputs.seed
-
-        # Submit async job and get handler
-        handler = await fal_client.submit_async(
-            "fal-ai/nano-banana",
-            arguments=arguments,
-        )
-
-        # Store the external job ID for tracking
-        await context.set_external_job_id(handler.request_id)
-
-        # Stream progress updates (sample every 3rd event to avoid spam)
-        from .....progress.models import ProgressUpdate
-
-        event_count = 0
-        async for event in handler.iter_events(with_logs=True):
-            event_count += 1
-
-            # Process every 3rd event to provide feedback without overwhelming
-            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 image URLs from result
-        # fal.ai returns: {"images": [{"url": "...", "width": ..., "height": ...}, ...]}
-        images = result.get("images", [])
-        if not images:
-            raise ValueError("No images returned from fal.ai API")
-
-        # Store each image using output_index
-        artifacts = []
-        for idx, image_data in enumerate(images):
-            image_url = image_data.get("url")
-            width = image_data.get("width")
-            height = image_data.get("height")
-
-            if not image_url:
-                raise ValueError(f"Image {idx} missing URL in fal.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: NanoBananaInput) -> float:
-        """Estimate cost for nano-banana generation.
-
-        nano-banana typically costs around $0.003 per image.
-        """
-        return 0.003 * inputs.num_images  # $0.003 per image, scaled by batch size

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

@@ -1,212 +0,0 @@
-"""
-fal.ai nano-banana image-to-image editing generator.
-
-Edit images using fal.ai's nano-banana/edit model (powered by Gemini).
-Supports editing multiple input images with a text prompt.
-"""
-
-import os
-from typing import Literal
-
-from pydantic import BaseModel, Field
-
-from ....artifacts import ImageArtifact
-from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
-
-
-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")
-    image_sources: list[ImageArtifact] = Field(
-        description="List of input images for editing (from previous generations)",
-        min_length=1,
-    )
-    num_images: int = Field(
-        default=1,
-        ge=1,
-        le=10,
-        description="Number of images to generate",
-    )
-    output_format: Literal["jpeg", "png", "webp"] = Field(
-        default="jpeg",
-        description="Output image format",
-    )
-    sync_mode: bool = Field(
-        default=False,
-        description=(
-            "If True, the media will be returned as a data URI and the output "
-            "data won't be available in the request history"
-        ),
-    )
-    limit_generations: bool = Field(
-        default=False,
-        description=(
-            "Experimental parameter to limit the number of generations from each "
-            "round of prompting to 1. Set to True to disregard any instructions in "
-            "the prompt regarding the number of images to generate"
-        ),
-    )
-    aspect_ratio: (
-        Literal[
-            "21:9",
-            "1:1",
-            "4:3",
-            "3:2",
-            "2:3",
-            "5:4",
-            "4:5",
-            "3:4",
-            "16:9",
-            "9:16",
-        ]
-        | None
-    ) = Field(
-        default=None,
-        description=(
-            "Aspect ratio for generated images. Default is None, which takes one "
-            "of the input images' aspect ratio"
-        ),
-    )
-
-
-class FalNanoBananaEditGenerator(BaseGenerator):
-    """nano-banana image editing generator using fal.ai."""
-
-    name = "fal-nano-banana-edit"
-    artifact_type = "image"
-    description = "Fal: nano-banana edit - AI-powered image editing with Gemini"
-
-    def get_input_schema(self) -> type[NanoBananaEditInput]:
-        return NanoBananaEditInput
-
-    async def generate(
-        self, inputs: NanoBananaEditInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Edit images using fal.ai nano-banana/edit model."""
-        # Check for API key (fal-client uses FAL_KEY environment variable)
-        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 FalNanoBananaEditGenerator. "
-                "Install with: pip install weirdfingers-boards[generators-fal]"
-            ) from e
-
-        # Upload image artifacts 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_sources, context)
-
-        # Prepare arguments for fal.ai API
-        arguments = {
-            "prompt": inputs.prompt,
-            "image_urls": image_urls,
-            "num_images": inputs.num_images,
-            "output_format": inputs.output_format,
-            "sync_mode": inputs.sync_mode,
-            "limit_generations": inputs.limit_generations,
-        }
-
-        # Add aspect_ratio if provided
-        if inputs.aspect_ratio is not None:
-            arguments["aspect_ratio"] = inputs.aspect_ratio
-
-        # Submit async job and get handler
-        handler = await fal_client.submit_async(
-            "fal-ai/nano-banana/edit",
-            arguments=arguments,
-        )
-
-        # Store the external job ID for tracking
-        await context.set_external_job_id(handler.request_id)
-
-        # Stream progress updates (sample every 3rd event to avoid spam)
-        from .....progress.models import ProgressUpdate
-
-        event_count = 0
-        async for event in handler.iter_events(with_logs=True):
-            event_count += 1
-
-            # Process every 3rd event to provide feedback without overwhelming
-            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 image URLs and description from result
-        # fal.ai returns: {
-        #   "images": [{"url": "...", ...}, ...],
-        #   "description": "Text description from Gemini"
-        # }
-        images = result.get("images", [])
-
-        if not images:
-            raise ValueError("No images returned from fal.ai API")
-
-        # Store each image using output_index
-        artifacts = []
-        for idx, image_data in enumerate(images):
-            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)
-
-            if not image_url:
-                raise ValueError(f"Image {idx} missing URL in fal.ai response")
-
-            # Store with appropriate output_index
-            # Note: The Gemini description from the API response (result.get("description"))
-            # is not currently stored with the artifact. Consider extending ImageArtifact
-            # to support metadata in the future.
-            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 Gemini for image editing, which has variable costs
-        depending on input complexity. Using a conservative estimate.
-        """
-        # Base cost per edit operation + per-image multiplier
-        per_image_cost = 0.039
-        return per_image_cost * inputs.num_images