codewave-openclaw-installer 1.0.2 → 2.1.1

package/skills/ppt-master/scripts/image_backends/backend_common.py

@@ -0,0 +1,244 @@
+#!/usr/bin/env python3
+"""
+Shared helpers for image generation backends.
+"""
+
+import io
+import os
+import time
+
+import requests
+
+try:
+    from PIL import Image as PILImage
+    HAS_PIL = True
+except ImportError:
+    HAS_PIL = False
+
+
+MAX_RETRIES = 3
+RETRY_BASE_DELAY = 10
+RETRY_BACKOFF = 2
+
+
+def resolve_output_path(prompt: str, output_dir: str = None,
+                        filename: str = None, ext: str = ".png") -> str:
+    """Compute the final output file path based on parameters."""
+    if filename:
+        file_name = os.path.splitext(filename)[0]
+    else:
+        safe = "".join(c for c in prompt if c.isalnum() or c in (" ", "_")).rstrip()
+        safe = safe.replace(" ", "_").lower()[:30]
+        file_name = safe or "generated_image"
+
+    full_name = f"{file_name}{ext}"
+    if output_dir:
+        os.makedirs(output_dir, exist_ok=True)
+        return os.path.join(output_dir, full_name)
+    return full_name
+
+
+CONTENT_TYPE_TO_EXT = {
+    "image/png": ".png",
+    "image/jpeg": ".jpg",
+    "image/jpg": ".jpg",
+    "image/webp": ".webp",
+    "image/gif": ".gif",
+    "image/bmp": ".bmp",
+    "image/tiff": ".tiff",
+}
+
+EXT_TO_PIL_FORMAT = {
+    ".png": "PNG",
+    ".jpg": "JPEG",
+    ".jpeg": "JPEG",
+    ".webp": "WEBP",
+    ".gif": "GIF",
+    ".bmp": "BMP",
+    ".tiff": "TIFF",
+    ".tif": "TIFF",
+}
+
+
+from typing import Optional
+
+def detect_image_extension(image_bytes: bytes, content_type: str = None) -> Optional[str]:
+    """Best-effort detection of the real image format."""
+    if content_type:
+        clean_type = content_type.split(";", 1)[0].strip().lower()
+        if clean_type in CONTENT_TYPE_TO_EXT:
+            return CONTENT_TYPE_TO_EXT[clean_type]
+
+    if image_bytes.startswith(b"\x89PNG\r\n\x1a\n"):
+        return ".png"
+    if image_bytes.startswith(b"\xff\xd8\xff"):
+        return ".jpg"
+    if image_bytes.startswith(b"GIF87a") or image_bytes.startswith(b"GIF89a"):
+        return ".gif"
+    if image_bytes.startswith(b"RIFF") and image_bytes[8:12] == b"WEBP":
+        return ".webp"
+    if image_bytes.startswith(b"BM"):
+        return ".bmp"
+    if image_bytes.startswith((b"II*\x00", b"MM\x00*")):
+        return ".tiff"
+    return None
+
+
+def _normalize_extension(ext: str) -> str:
+    """Normalize equivalent image extensions to a canonical form."""
+    ext = ext.lower()
+    if ext == ".jpeg":
+        return ".jpg"
+    if ext == ".tif":
+        return ".tiff"
+    return ext
+
+
+def save_image_bytes(image_bytes: bytes, path: str, content_type: str = None) -> str:
+    """
+    Save image bytes to disk while keeping the file extension and the real bytes aligned.
+
+    If the target extension differs from the actual bytes, transcode through Pillow when
+    available. Otherwise fail loudly instead of writing a misleading file.
+    """
+    target_ext = _normalize_extension(os.path.splitext(path)[1])
+    actual_ext = _normalize_extension(detect_image_extension(image_bytes, content_type) or "")
+
+    if not target_ext:
+        raise ValueError(f"Output path must include an image extension: {path}")
+
+    if actual_ext and target_ext == actual_ext:
+        with open(path, "wb") as f:
+            f.write(image_bytes)
+        print(f"  File saved to: {path}")
+        report_resolution(path)
+        return path
+
+    if not HAS_PIL:
+        actual_label = actual_ext or "unknown"
+        raise RuntimeError(
+            f"Image format mismatch for {path}: target extension is {target_ext}, "
+            f"but the actual image bytes are {actual_label}. "
+            "Install Pillow to enable automatic format conversion."
+        )
+
+    target_format = EXT_TO_PIL_FORMAT.get(target_ext)
+    if not target_format:
+        raise ValueError(f"Unsupported output image extension: {target_ext}")
+
+    image = PILImage.open(io.BytesIO(image_bytes))
+    if target_format == "JPEG" and image.mode in ("RGBA", "LA", "P"):
+        image = image.convert("RGB")
+    image.save(path, format=target_format)
+
+    if actual_ext and actual_ext != target_ext:
+        print(f"  Converted:    {actual_ext} -> {target_ext}")
+    print(f"  File saved to: {path}")
+    report_resolution(path)
+    return path
+
+
+def report_resolution(path: str) -> None:
+    """Try to report image resolution using PIL."""
+    if HAS_PIL:
+        try:
+            img = PILImage.open(path)
+            print(f"  Resolution:   {img.size[0]}x{img.size[1]}")
+        except Exception:
+            pass
+
+
+def normalize_image_size(image_size: str) -> str:
+    """Normalize image size input to standard format."""
+    s = image_size.strip()
+    upper = s.upper()
+    if upper in ("1K", "2K", "4K"):
+        return upper
+    if upper in ("512PX", "512"):
+        return "512px"
+    return s
+
+
+def is_rate_limit_error(exc: Exception) -> bool:
+    """Check whether the exception appears to be rate limiting."""
+    err_str = str(exc).lower()
+    return (
+        "429" in err_str
+        or "rate" in err_str
+        or "quota" in err_str
+        or "resource_exhausted" in err_str
+    )
+
+
+def retry_delay(attempt: int, rate_limited: bool) -> int:
+    """Return the retry delay for a given attempt."""
+    if rate_limited:
+        return RETRY_BASE_DELAY * (RETRY_BACKOFF ** attempt)
+    return 5
+
+
+def download_image(url: str, path: str, headers: dict = None, timeout: int = 180) -> str:
+    """Download an image URL and save it to disk."""
+    response = requests.get(url, headers=headers or {}, timeout=timeout)
+    response.raise_for_status()
+    return save_image_bytes(
+        response.content,
+        path,
+        content_type=response.headers.get("Content-Type"),
+    )
+
+
+def require_api_key(*candidates: str, message: str) -> str:
+    """Return the first non-empty env var from candidates or raise."""
+    for name in candidates:
+        value = os.environ.get(name)
+        if value:
+            return value
+    raise ValueError(message)
+
+
+def http_error(response: requests.Response, label: str) -> RuntimeError:
+    """Convert an HTTP response into a readable RuntimeError."""
+    body = response.text.strip()
+    if len(body) > 500:
+        body = body[:500] + "..."
+    return RuntimeError(f"{label} failed ({response.status_code}): {body}")
+
+
+def poll_json(
+    url: str,
+    headers: dict[str, str],
+    *,
+    interval_seconds: float = 2.0,
+    timeout_seconds: int = 300,
+    status_label: str = "status",
+    ready_values: Optional[list] = None,
+    failed_values: Optional[list] = None,
+) -> dict:
+    """Poll a JSON endpoint until it reports a ready or failed status."""
+    ready = {value.lower() for value in (ready_values or ["ready", "success", "succeeded"])}
+    failed = {value.lower() for value in (failed_values or ["error", "failed", "fail"])}
+
+    start = time.time()
+    while True:
+        response = requests.get(url, headers=headers, timeout=180)
+        response.raise_for_status()
+        payload = response.json()
+        raw_status = str(payload.get(status_label, "")).strip()
+        status = raw_status.lower()
+
+        if raw_status:
+            print(f"  Status:       {raw_status}")
+
+        if status in ready:
+            return payload
+
+        if status in failed:
+            raise RuntimeError(f"Remote generation failed: {payload}")
+
+        if time.time() - start > timeout_seconds:
+            raise RuntimeError(
+                f"Timed out after {timeout_seconds}s while polling {url}"
+            )
+
+        time.sleep(interval_seconds)

package/skills/ppt-master/scripts/image_backends/backend_fal.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+"""
+fal.ai image generation backend.
+
+Configuration keys:
+  FAL_KEY / FAL_API_KEY   (required)
+  FAL_BASE_URL            (optional)
+  FAL_MODEL               (optional)
+"""
+
+import os
+import time
+
+import requests
+
+from image_backends.backend_common import (
+    MAX_RETRIES,
+    download_image,
+    http_error,
+    is_rate_limit_error,
+    require_api_key,
+    resolve_output_path,
+    retry_delay,
+)
+
+
+VALID_ASPECT_RATIOS = ["1:1", "16:9", "9:16", "3:4", "4:3"]
+DEFAULT_ENDPOINT = "https://fal.run"
+DEFAULT_MODEL = "fal-ai/imagen3/fast"
+
+
+def _resolve_url(base_url: str, model: str) -> str:
+    """Resolve the full fal endpoint URL for a model."""
+    base = base_url.rstrip("/")
+    if base.endswith(model):
+        return base
+    return f"{base}/{model}"
+
+
+def _generate_image(api_key: str, prompt: str, negative_prompt: str = None,
+                    aspect_ratio: str = "1:1", image_size: str = "1K",
+                    output_dir: str = None, filename: str = None,
+                    model: str = DEFAULT_MODEL, base_url: str = DEFAULT_ENDPOINT) -> str:
+    """Generate one image with the fal.ai backend."""
+    del image_size
+
+    if aspect_ratio not in VALID_ASPECT_RATIOS:
+        raise ValueError(
+            f"Unsupported aspect ratio '{aspect_ratio}' for fal backend. "
+            f"Supported: {VALID_ASPECT_RATIOS}"
+        )
+
+    url = _resolve_url(base_url, model)
+    headers = {
+        "Authorization": f"Key {api_key}",
+        "Content-Type": "application/json",
+    }
+    payload = {
+        "prompt": prompt,
+        "aspect_ratio": aspect_ratio,
+        "num_images": 1,
+    }
+    if negative_prompt:
+        payload["negative_prompt"] = negative_prompt
+
+    print("[fal.ai]")
+    print(f"  Model:        {model}")
+    print(f"  Prompt:       {prompt[:120]}{'...' if len(prompt) > 120 else ''}")
+    print(f"  Aspect Ratio: {aspect_ratio}")
+    print()
+    print("  ⏳ Generating...", end="", flush=True)
+    start = time.time()
+    response = requests.post(url, headers=headers, json=payload, timeout=300)
+    elapsed = time.time() - start
+    print(f"\n  ✅ Response received ({elapsed:.1f}s)")
+
+    if response.status_code != 200:
+        raise http_error(response, "fal image generation")
+
+    data = response.json()
+    images = data.get("images") or []
+    image_url = images[0].get("url") if images else None
+    if not image_url:
+        raise RuntimeError(f"fal response missing image URL: {data}")
+
+    path = resolve_output_path(prompt, output_dir, filename, ".png")
+    return download_image(image_url, path)
+
+
+def generate(prompt: str, negative_prompt: str = None,
+             aspect_ratio: str = "1:1", image_size: str = "1K",
+             output_dir: str = None, filename: str = None,
+             model: str = None, max_retries: int = MAX_RETRIES) -> str:
+    """Generate an image with retries using the fal.ai backend."""
+    api_key = require_api_key(
+        "FAL_KEY",
+        "FAL_API_KEY",
+        message="No API key found. Set FAL_KEY or FAL_API_KEY in the current environment or the project-root .env.",
+    )
+    base_url = os.environ.get("FAL_BASE_URL") or DEFAULT_ENDPOINT
+    resolved_model = model or os.environ.get("FAL_MODEL") or DEFAULT_MODEL
+
+    last_error = None
+    for attempt in range(max_retries + 1):
+        try:
+            return _generate_image(
+                api_key=api_key,
+                prompt=prompt,
+                negative_prompt=negative_prompt,
+                aspect_ratio=aspect_ratio,
+                image_size=image_size,
+                output_dir=output_dir,
+                filename=filename,
+                model=resolved_model,
+                base_url=base_url,
+            )
+        except Exception as exc:
+            last_error = exc
+            if attempt >= max_retries:
+                break
+            limited = is_rate_limit_error(exc)
+            delay = retry_delay(attempt, rate_limited=limited)
+            label = "Rate limit hit" if limited else f"Error: {exc}"
+            print(f"\n  ⚠️  {label}. Retrying in {delay}s...")
+            time.sleep(delay)
+
+    raise RuntimeError(f"Failed after {max_retries + 1} attempts. Last error: {last_error}")

package/skills/ppt-master/scripts/image_backends/backend_gemini.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+"""
+Gemini Image Generation Backend
+
+Generates images via the Google GenAI API (Gemini).
+Used by image_gen.py as a backend module.
+
+Configuration keys:
+  GEMINI_API_KEY   (required)
+  GEMINI_BASE_URL  (optional) Custom API endpoint for proxy services
+  GEMINI_MODEL     (optional) Override default model
+
+Dependencies:
+  pip install google-genai Pillow
+"""
+
+import os
+import time
+import threading
+from google import genai
+from google.genai import types
+from image_backends.backend_common import (
+    MAX_RETRIES,
+    is_rate_limit_error,
+    normalize_image_size,
+    resolve_output_path,
+    retry_delay,
+    save_image_bytes,
+)
+
+
+# ╔══════════════════════════════���═══════════════════════════════════╗
+# ║  Constants                                                      ║
+# ╚═══════════��═════════════════════════════��════════════════════════╝
+
+VALID_ASPECT_RATIOS = [
+    "1:1", "1:4", "1:8",
+    "2:3", "3:2", "3:4", "4:1", "4:3",
+    "4:5", "5:4", "8:1", "9:16", "16:9", "21:9"
+]
+
+VALID_IMAGE_SIZES = ["512px", "1K", "2K", "4K"]
+
+DEFAULT_MODEL = "gemini-3.1-flash-image-preview"
+
+
+# ╔══════���═══════════════════════════════════════════════��═══════════╗
+# ║  Image Generation                                               ║
+# ╚══════════════════════════════════════════════════════════════════╝
+
+def _generate_image(api_key: str, prompt: str, negative_prompt: str = None,
+                    aspect_ratio: str = "1:1", image_size: str = "1K",
+                    output_dir: str = None, filename: str = None,
+                    model: str = DEFAULT_MODEL, base_url: str = None) -> str:
+    """
+    Image generation via Gemini API (streaming).
+
+    Returns:
+        Path of the saved image file
+
+    Raises:
+        RuntimeError: When generation fails
+    """
+    if base_url:
+        client = genai.Client(api_key=api_key, http_options={'base_url': base_url})
+    else:
+        client = genai.Client(api_key=api_key)
+
+    final_prompt = prompt
+    if negative_prompt:
+        final_prompt += f"\n\nNegative prompt: {negative_prompt}"
+
+    config_kwargs = {
+        "response_modalities": ["IMAGE"],
+        "image_config": types.ImageConfig(
+            aspect_ratio=aspect_ratio,
+        ),
+    }
+    # Only add image_size for gemini-3.x models (gemini-2.5 doesn't support it)
+    if "gemini-3" in model.lower():
+        config_kwargs["image_config"].image_size = image_size
+    # Only add thinking_config for gemini-3.x models
+    if "gemini-3" in model.lower() and "flash" in model.lower():
+        config_kwargs["thinking_config"] = types.ThinkingConfig(
+            thinking_level="MINIMAL",
+        )
+    config = types.GenerateContentConfig(**config_kwargs)
+
+    mode_label = "Proxy Mode" if base_url else "Official Mode"
+    print(f"[Gemini - {mode_label}]")
+    if base_url:
+        print(f"  Base URL:     {base_url}")
+    print(f"  Model:        {model}")
+    print(f"  Prompt:       {final_prompt[:120]}{'...' if len(final_prompt) > 120 else ''}")
+    print(f"  Aspect Ratio: {aspect_ratio}")
+    print(f"  Image Size:   {image_size}")
+    print()
+
+    start_time = time.time()
+    print(f"  ⏳ Generating...", end="", flush=True)
+
+    heartbeat_stop = threading.Event()
+
+    def _heartbeat():
+        while not heartbeat_stop.is_set():
+            heartbeat_stop.wait(5)
+            if not heartbeat_stop.is_set():
+                elapsed = time.time() - start_time
+                print(f" {elapsed:.0f}s...", end="", flush=True)
+
+    hb_thread = threading.Thread(target=_heartbeat, daemon=True)
+    hb_thread.start()
+
+    last_image_data = None
+    chunk_count = 0
+    total_bytes = 0
+
+    for chunk in client.models.generate_content_stream(
+        model=model,
+        contents=[final_prompt],
+        config=config,
+    ):
+        elapsed = time.time() - start_time
+
+        if chunk.parts is None:
+            continue
+
+        for part in chunk.parts:
+            if part.text is not None:
+                print(f"\n  Model says: {part.text}", end="", flush=True)
+            elif part.inline_data is not None:
+                chunk_count += 1
+                data_size = len(part.inline_data.data) if part.inline_data.data else 0
+                total_bytes += data_size
+                size_str = f"{data_size / 1024:.0f}KB" if data_size < 1048576 else f"{data_size / 1048576:.1f}MB"
+                print(f"\n  📦 Chunk #{chunk_count} received ({size_str}, {elapsed:.1f}s)", end="", flush=True)
+                last_image_data = part
+
+    heartbeat_stop.set()
+    hb_thread.join(timeout=1)
+
+    elapsed = time.time() - start_time
+    print(f"\n  ✅ Stream complete ({elapsed:.1f}s, {chunk_count} chunk(s), {total_bytes / 1024:.0f}KB total)")
+
+    if last_image_data is not None and last_image_data.inline_data is not None:
+        if chunk_count > 1:
+            print(f"  Keeping the final chunk (highest quality).")
+        path = resolve_output_path(prompt, output_dir, filename, ".png")
+        return save_image_bytes(
+            last_image_data.inline_data.data,
+            path,
+            content_type=getattr(last_image_data.inline_data, "mime_type", None),
+        )
+
+    raise RuntimeError("No image was generated. The server may have refused the request.")
+
+
+# ╔���═══════════════════════════════════���═════════════════════════════╗
+# ║  Public Entry Point                                             ║
+# ╚═════════════���═══════════════════════════���════════════════════════╝
+
+def generate(prompt: str, negative_prompt: str = None,
+             aspect_ratio: str = "1:1", image_size: str = "1K",
+             output_dir: str = None, filename: str = None,
+             model: str = None, max_retries: int = MAX_RETRIES) -> str:
+    """
+    Gemini image generation with automatic retry.
+
+    Reads credentials from the current process environment or the project-root `.env`:
+      GEMINI_API_KEY
+      GEMINI_BASE_URL
+      GEMINI_MODEL (optional override)
+
+    Args:
+        prompt: Positive prompt text
+        negative_prompt: Negative prompt text
+        aspect_ratio: Aspect ratio (e.g. "16:9", "1:1")
+        image_size: Image size ("512px", "1K", "2K", "4K", case-insensitive)
+        output_dir: Output directory
+        filename: Output filename (without extension)
+        model: Model name (default: gemini-3.1-flash-image-preview)
+        max_retries: Maximum number of retries
+
+    Returns:
+        Path of the saved image file
+    """
+    api_key = os.environ.get("GEMINI_API_KEY")
+    base_url = os.environ.get("GEMINI_BASE_URL")
+
+    if not api_key:
+        raise ValueError(
+            "No API key found. Set GEMINI_API_KEY in the current environment or the project-root .env."
+        )
+
+    if model is None:
+        model = os.environ.get("GEMINI_MODEL") or DEFAULT_MODEL
+
+    image_size = normalize_image_size(image_size)
+
+    if aspect_ratio not in VALID_ASPECT_RATIOS:
+        raise ValueError(f"Invalid aspect ratio '{aspect_ratio}'. Valid: {VALID_ASPECT_RATIOS}")
+
+    if image_size not in VALID_IMAGE_SIZES:
+        raise ValueError(f"Invalid image size '{image_size}'. Valid: {VALID_IMAGE_SIZES}")
+
+    last_error = None
+    for attempt in range(max_retries + 1):
+        try:
+            return _generate_image(api_key, prompt, negative_prompt,
+                                   aspect_ratio, image_size, output_dir,
+                                   filename, model, base_url)
+        except Exception as e:
+            last_error = e
+            if attempt < max_retries and is_rate_limit_error(e):
+                delay = retry_delay(attempt, rate_limited=True)
+                print(f"\n  ⚠️  Rate limit hit (attempt {attempt + 1}/{max_retries + 1}). "
+                      f"Waiting {delay}s before retry...")
+                time.sleep(delay)
+            elif attempt < max_retries:
+                delay = retry_delay(attempt, rate_limited=False)
+                print(f"\n  ⚠️  Error (attempt {attempt + 1}/{max_retries + 1}): {e}. "
+                      f"Retrying in {delay}s...")
+                time.sleep(delay)
+            else:
+                break
+
+    raise RuntimeError(f"Failed after {max_retries + 1} attempts. Last error: {last_error}")