@weirdfingers/baseboards 0.9.6 → 0.9.7

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

@@ -1,221 +0,0 @@
-"""
-fal.ai FLUX 2 Pro Edit generator.
-
-Production-grade multi-reference image editing that combines up to 9 reference
-images through a streamlined pipeline for professional image manipulation.
-Supports natural language precision, explicit image indexing with @ symbol,
-and zero-configuration workflow.
-
-Based on Fal AI's fal-ai/flux-2-pro/edit model.
-See: https://fal.ai/models/fal-ai/flux-2-pro/edit
-"""
-
-import os
-from typing import Literal
-
-from pydantic import BaseModel, Field
-
-from ....artifacts import ImageArtifact
-from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
-
-# Image size presets supported by the API
-ImageSizePreset = Literal[
-    "auto",
-    "square_hd",
-    "square",
-    "portrait_4_3",
-    "portrait_16_9",
-    "landscape_4_3",
-    "landscape_16_9",
-]
-
-
-class Flux2ProEditInput(BaseModel):
-    """Input schema for FLUX 2 Pro Edit.
-
-    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 to edit the images. Use @ symbol to reference "
-        "specific input images by index (e.g., '@1' for first image)."
-    )
-    image_sources: list[ImageArtifact] = Field(
-        description="List of input images for editing (up to 9 images, 9 MP total)",
-        min_length=1,
-        max_length=9,
-    )
-    image_size: ImageSizePreset | None = Field(
-        default="auto",
-        description="The size of the generated image. If 'auto', the size will be "
-        "determined by the model based on input images.",
-    )
-    output_format: Literal["jpeg", "png"] = Field(
-        default="jpeg",
-        description="The format of the generated image.",
-    )
-    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."
-        ),
-    )
-    safety_tolerance: Literal["1", "2", "3", "4", "5"] = Field(
-        default="2",
-        description=(
-            "The safety tolerance level for the generated image. "
-            "1 is most strict, 5 is most permissive."
-        ),
-    )
-    enable_safety_checker: bool = Field(
-        default=True,
-        description="Whether to enable the safety checker.",
-    )
-    seed: int | None = Field(
-        default=None,
-        description="The seed to use for the generation. Leave empty for random.",
-    )
-
-
-class FalFlux2ProEditGenerator(BaseGenerator):
-    """FLUX 2 Pro Edit image generator using fal.ai.
-
-    Production-grade multi-reference editing that combines up to 9 reference
-    images through a streamlined pipeline. Supports natural language precision
-    for describing complex edits without masks.
-    """
-
-    name = "fal-flux-2-pro-edit"
-    artifact_type = "image"
-    description = "Fal: FLUX 2 Pro Edit - Production-grade multi-reference image editing"
-
-    def get_input_schema(self) -> type[Flux2ProEditInput]:
-        return Flux2ProEditInput
-
-    async def generate(
-        self, inputs: Flux2ProEditInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Edit images using fal.ai FLUX 2 Pro 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 FalFlux2ProEditGenerator. "
-                "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: dict = {
-            "prompt": inputs.prompt,
-            "image_urls": image_urls,
-            "output_format": inputs.output_format,
-            "sync_mode": inputs.sync_mode,
-            "safety_tolerance": inputs.safety_tolerance,
-            "enable_safety_checker": inputs.enable_safety_checker,
-        }
-
-        # Add optional parameters
-        if inputs.image_size is not None:
-            arguments["image_size"] = inputs.image_size
-        if inputs.seed is not None:
-            arguments["seed"] = inputs.seed
-
-        # Submit async job and get handler
-        handler = await fal_client.submit_async(
-            "fal-ai/flux-2-pro/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 from result
-        # fal.ai returns: {
-        #   "images": [{"url": "...", "width": ..., "height": ..., ...}, ...],
-        #   "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")
-            # 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
-            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: Flux2ProEditInput) -> float:
-        """Estimate cost for FLUX 2 Pro Edit generation.
-
-        Pricing: $0.03 for first megapixel, $0.015 for additional megapixels.
-        Using base cost of $0.03 as default (1 MP output).
-        """
-        # Base cost per generation (1 megapixel default)
-        base_cost = 0.03
-        return base_cost

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

@@ -1,216 +0,0 @@
-"""
-fal.ai FLUX.1 [pro] Kontext image-to-image generator.
-
-Handles both text and reference images as inputs, enabling targeted local edits
-and complex transformations of entire scenes using fal.ai's flux-pro/kontext model.
-"""
-
-import os
-from typing import Literal
-
-from pydantic import BaseModel, Field
-
-from ....artifacts import ImageArtifact
-from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
-
-
-class FluxProKontextInput(BaseModel):
-    """Input schema for FLUX.1 [pro] Kontext image generation.
-
-    Artifact fields (like image_url) are automatically detected via type
-    introspection and resolved from generation IDs to ImageArtifact objects.
-    """
-
-    prompt: str = Field(
-        description="Text prompt for image editing (e.g., 'Put a donut next to the flour')"
-    )
-    image_url: ImageArtifact = Field(
-        description="Reference image for transformation (from previous generation)",
-    )
-    aspect_ratio: (
-        Literal[
-            "21:9",
-            "16:9",
-            "4:3",
-            "3:2",
-            "1:1",
-            "2:3",
-            "3:4",
-            "9:16",
-            "9:21",
-        ]
-        | None
-    ) = Field(
-        default=None,
-        description="Image aspect ratio (optional)",
-    )
-    num_images: int = Field(
-        default=1,
-        ge=1,
-        le=4,
-        description="Number of images to generate (1-4)",
-    )
-    output_format: Literal["jpeg", "png"] = 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"
-        ),
-    )
-    safety_tolerance: str = Field(
-        default="2",
-        description="Safety tolerance level (1-6 scale, higher is more permissive)",
-    )
-    guidance_scale: float = Field(
-        default=3.5,
-        ge=1.0,
-        le=20.0,
-        description="Guidance scale for image generation (1-20)",
-    )
-    seed: int | None = Field(
-        default=None,
-        description="Random seed for reproducible outputs (optional)",
-    )
-    enhance_prompt: bool = Field(
-        default=False,
-        description="Automatically enhance the prompt for better quality",
-    )
-
-
-class FalFluxProKontextGenerator(BaseGenerator):
-    """FLUX.1 [pro] Kontext image-to-image generator using fal.ai."""
-
-    name = "fal-flux-pro-kontext"
-    artifact_type = "image"
-    description = (
-        "Fal: FLUX.1 [pro] Kontext - Image-to-image editing with text and reference images"
-    )
-
-    def get_input_schema(self) -> type[FluxProKontextInput]:
-        return FluxProKontextInput
-
-    async def generate(
-        self, inputs: FluxProKontextInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Generate images using fal.ai flux-pro/kontext 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 FalFluxProKontextGenerator. "
-                "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)
-        image_url = image_urls[0]  # Extract single URL from list
-
-        # Prepare arguments for fal.ai API
-        arguments = {
-            "prompt": inputs.prompt,
-            "image_url": image_url,
-            "num_images": inputs.num_images,
-            "output_format": inputs.output_format,
-            "sync_mode": inputs.sync_mode,
-            "safety_tolerance": inputs.safety_tolerance,
-            "guidance_scale": inputs.guidance_scale,
-            "enhance_prompt": inputs.enhance_prompt,
-        }
-
-        # Add optional fields if provided
-        if inputs.aspect_ratio is not None:
-            arguments["aspect_ratio"] = inputs.aspect_ratio
-
-        if inputs.seed is not None:
-            arguments["seed"] = inputs.seed
-
-        # Submit async job and get handler
-        handler = await fal_client.submit_async(
-            "fal-ai/flux-pro/kontext",
-            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_result = image_data.get("url")
-            width = image_data.get("width", 1024)
-            height = image_data.get("height", 1024)
-
-            if not image_url_result:
-                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_result,
-                format=inputs.output_format,
-                width=width,
-                height=height,
-                output_index=idx,
-            )
-            artifacts.append(artifact)
-
-        return GeneratorResult(outputs=artifacts)
-
-    async def estimate_cost(self, inputs: FluxProKontextInput) -> float:
-        """Estimate cost for FLUX.1 [pro] Kontext generation.
-
-        FLUX.1 [pro] Kontext is a premium image-to-image model. Estimated cost
-        is approximately $0.055 per image based on similar Flux Pro models.
-        """
-        # Cost per image * number of images
-        cost_per_image = 0.055
-        return cost_per_image * inputs.num_images

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

@@ -1,197 +0,0 @@
-"""
-fal.ai FLUX1.1 [pro] ultra text-to-image generator.
-
-High-quality image generation using fal.ai's FLUX1.1 [pro] ultra model with support for
-batch outputs and advanced controls.
-"""
-
-import os
-from typing import Literal
-
-from pydantic import BaseModel, Field
-
-from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
-
-
-class FluxProUltraInput(BaseModel):
-    """Input schema for FLUX1.1 [pro] ultra image generation."""
-
-    prompt: str = Field(description="Text prompt for image generation")
-    aspect_ratio: Literal[
-        "21:9",
-        "16:9",
-        "4:3",
-        "3:2",
-        "1:1",
-        "2:3",
-        "3:4",
-        "9:16",
-        "9:21",
-    ] = Field(
-        default="16:9",
-        description="Image aspect ratio",
-    )
-    num_images: int = Field(
-        default=1,
-        ge=1,
-        le=4,
-        description="Number of images to generate in batch (max 4)",
-    )
-    enable_safety_checker: bool = Field(
-        default=True,
-        description="Enable safety checker to filter unsafe content",
-    )
-    safety_tolerance: int = Field(
-        default=2,
-        ge=1,
-        le=6,
-        description="Safety tolerance level (1 = most strict, 6 = most permissive)",
-    )
-    seed: int | None = Field(
-        default=None,
-        description="Random seed for reproducibility (optional)",
-    )
-    output_format: Literal["jpeg", "png"] = Field(
-        default="jpeg",
-        description="Output image format",
-    )
-    enhance_prompt: bool = Field(
-        default=False,
-        description="Whether to enhance the prompt for better results",
-    )
-    raw: bool = Field(
-        default=False,
-        description="Generate less processed, more natural-looking images",
-    )
-    sync_mode: bool = Field(
-        default=True,
-        description="Use synchronous mode (wait for completion)",
-    )
-
-
-class FalFluxProUltraGenerator(BaseGenerator):
-    """FLUX1.1 [pro] ultra image generator using fal.ai."""
-
-    name = "fal-flux-pro-ultra"
-    artifact_type = "image"
-    description = (
-        "Fal: FLUX1.1 [pro] ultra - high-quality text-to-image generation with advanced controls"
-    )
-
-    def get_input_schema(self) -> type[FluxProUltraInput]:
-        return FluxProUltraInput
-
-    async def generate(
-        self, inputs: FluxProUltraInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Generate images using fal.ai FLUX1.1 [pro] ultra 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 FalFluxProUltraGenerator. "
-                "Install with: pip install weirdfingers-boards[generators-fal]"
-            ) from e
-
-        # Prepare arguments for fal.ai API
-        arguments = {
-            "prompt": inputs.prompt,
-            "aspect_ratio": inputs.aspect_ratio,
-            "num_images": inputs.num_images,
-            "enable_safety_checker": inputs.enable_safety_checker,
-            "safety_tolerance": inputs.safety_tolerance,
-            "output_format": inputs.output_format,
-            "enhance_prompt": inputs.enhance_prompt,
-            "raw": inputs.raw,
-            "sync_mode": inputs.sync_mode,
-        }
-
-        # 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/flux-pro/v1.1-ultra",
-            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", 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
-            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: FluxProUltraInput) -> float:
-        """Estimate cost for FLUX1.1 [pro] ultra generation.
-
-        FLUX1.1 [pro] ultra billing is based on megapixels (rounded up).
-        The aspect ratios map to different resolutions, all roughly in the 2-4MP range.
-        Estimated at approximately $0.04 per image based on typical resolutions.
-        """
-        # Approximate cost per image (varies slightly by resolution/megapixels)
-        # Most aspect ratios result in 2-4 megapixels
-        cost_per_image = 0.04
-        return cost_per_image * inputs.num_images