codewave-openclaw-installer 1.0.2 → 2.1.1

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

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+"""
+Ideogram image generation backend.
+
+Configuration keys:
+  IDEOGRAM_API_KEY   (required)
+  IDEOGRAM_BASE_URL  (optional)
+  IDEOGRAM_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,
+)
+
+
+ASPECT_RATIO_MAP = {
+    "1:1": "1x1",
+    "1:4": "1x4",
+    "2:3": "2x3",
+    "3:2": "3x2",
+    "3:4": "3x4",
+    "4:1": "4x1",
+    "4:3": "4x3",
+    "4:5": "4x5",
+    "5:4": "5x4",
+    "9:16": "9x16",
+    "16:9": "16x9",
+    "21:9": "21x9",
+}
+
+DEFAULT_BASE_URL = "https://api.ideogram.ai"
+DEFAULT_MODEL = "ideogram-v3"
+MODEL_ALIASES = {"ideogram-v3", "v3"}
+
+IMAGE_SIZE_TO_SPEED = {
+    "512px": "TURBO",
+    "1K": "DEFAULT",
+    "2K": "QUALITY",
+    "4K": "QUALITY",
+}
+
+
+def _resolve_url(base_url: str) -> str:
+    """Resolve the Ideogram generation endpoint."""
+    base = base_url.rstrip("/")
+    if base.endswith("/generate"):
+        return base
+    return base + "/v1/ideogram-v3/generate"
+
+
+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_BASE_URL) -> str:
+    """Generate one image with the Ideogram backend."""
+    normalized_model = model.strip().lower()
+    if normalized_model not in MODEL_ALIASES:
+        raise ValueError(
+            f"Unsupported Ideogram model '{model}'. Supported: {sorted(MODEL_ALIASES)}"
+        )
+
+    mapped_ratio = ASPECT_RATIO_MAP.get(aspect_ratio)
+    if not mapped_ratio:
+        raise ValueError(
+            f"Unsupported aspect ratio '{aspect_ratio}' for Ideogram backend. "
+            f"Supported: {sorted(ASPECT_RATIO_MAP)}"
+        )
+
+    rendering_speed = IMAGE_SIZE_TO_SPEED.get(image_size, "DEFAULT")
+    url = _resolve_url(base_url)
+    headers = {"Api-Key": api_key}
+    files = {
+        "prompt": (None, prompt),
+        "aspect_ratio": (None, mapped_ratio),
+        "rendering_speed": (None, rendering_speed),
+    }
+    if negative_prompt:
+        files["negative_prompt"] = (None, negative_prompt)
+
+    print("[Ideogram]")
+    print(f"  Model:        {normalized_model}")
+    print(f"  Prompt:       {prompt[:120]}{'...' if len(prompt) > 120 else ''}")
+    print(f"  Aspect Ratio: {aspect_ratio} -> {mapped_ratio}")
+    print(f"  Render Speed: {rendering_speed}")
+    print()
+    print("  ⏳ Generating...", end="", flush=True)
+    start = time.time()
+    response = requests.post(url, headers=headers, files=files, timeout=300)
+    elapsed = time.time() - start
+    print(f"\n  ✅ Response received ({elapsed:.1f}s)")
+
+    if response.status_code != 200:
+        raise http_error(response, "Ideogram generation")
+
+    payload = response.json()
+    data = payload.get("data") or []
+    image_url = data[0].get("url") if data else None
+    if not image_url:
+        raise RuntimeError(f"Ideogram response missing image URL: {payload}")
+
+    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 Ideogram backend."""
+    api_key = require_api_key(
+        "IDEOGRAM_API_KEY",
+        message="No API key found. Set IDEOGRAM_API_KEY in the current environment or the project-root .env.",
+    )
+    base_url = os.environ.get("IDEOGRAM_BASE_URL") or DEFAULT_BASE_URL
+    resolved_model = model or os.environ.get("IDEOGRAM_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_openai.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+"""
+OpenAI Compatible Image Generation Backend
+
+Generates images via OpenAI-compatible APIs (OpenAI, local models like Qwen-Image, etc.).
+Used by image_gen.py as a backend module.
+
+Configuration keys:
+  OPENAI_API_KEY   (required) API key
+  OPENAI_BASE_URL  (optional) Custom API endpoint (e.g. http://127.0.0.1:3000/v1)
+  OPENAI_MODEL     (optional) Model name (default: gpt-image-1)
+
+Dependencies:
+  pip install openai Pillow
+"""
+
+import base64
+import os
+import time
+import threading
+
+from openai import OpenAI
+from image_backends.backend_common import (
+    MAX_RETRIES,
+    is_rate_limit_error,
+    normalize_image_size,
+    resolve_output_path,
+    retry_delay,
+    save_image_bytes,
+)
+
+
+# ╔══════════════════════════════════════════════════════════════════╗
+# ║  Constants                                                      ║
+# ╚══════════════════════════════════════════════════════════════════╝
+
+# Aspect ratio -> OpenAI size mapping
+# Covers common PPT/social media ratios
+# Note: AIGW (NetEase) only supports: 1024x1024, 1024x1536, 1536x1024, auto
+ASPECT_RATIO_TO_SIZE = {
+    "1:1":  "1024x1024",
+    "16:9": "1536x1024",   # AIGW compatible
+    "9:16": "1024x1536",   # AIGW compatible
+    "3:2":  "1536x1024",   # AIGW compatible
+    "2:3":  "1024x1536",   # AIGW compatible
+    "4:3":  "1536x1024",   # AIGW compatible
+    "3:4":  "1024x1536",   # AIGW compatible
+    "4:5":  "1024x1536",   # AIGW compatible
+    "5:4":  "1536x1024",   # AIGW compatible
+    "21:9": "1536x1024",   # AIGW compatible
+}
+
+VALID_ASPECT_RATIOS = list(ASPECT_RATIO_TO_SIZE.keys())
+
+# image_size -> quality mapping
+IMAGE_SIZE_TO_QUALITY = {
+    "512px": "low",
+    "1K":    "auto",
+    "2K":    "high",
+    "4K":    "high",
+}
+
+DEFAULT_MODEL = "gpt-image-1"
+
+
+# ╔══════════════════════════════════════════════════════════════════╗
+# ║  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 OpenAI-compatible API.
+
+    Maps aspect_ratio to OpenAI's size parameter, and image_size to quality.
+
+    Returns:
+        Path of the saved image file
+
+    Raises:
+        RuntimeError: When generation fails
+    """
+    client = OpenAI(api_key=api_key, base_url=base_url)
+
+    # Build prompt (OpenAI has no native negative_prompt, append to prompt)
+    final_prompt = prompt
+    if negative_prompt:
+        final_prompt += f"\n\nAvoid the following: {negative_prompt}"
+
+    # Map parameters
+    size = ASPECT_RATIO_TO_SIZE.get(aspect_ratio, "1024x1024")
+    quality = IMAGE_SIZE_TO_QUALITY.get(image_size, "auto")
+
+    mode_label = f"Proxy: {base_url}" if base_url else "OpenAI API"
+    print(f"[OpenAI - {mode_label}]")
+    print(f"  Model:        {model}")
+    print(f"  Prompt:       {final_prompt[:120]}{'...' if len(final_prompt) > 120 else ''}")
+    print(f"  Size:         {size} (from aspect_ratio={aspect_ratio})")
+    print(f"  Quality:      {quality} (from image_size={image_size})")
+    print()
+
+    start_time = time.time()
+    print(f"  ⏳ Generating...", end="", flush=True)
+
+    # Heartbeat thread
+    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()
+
+    # Build request parameters
+    request_params = {
+        "prompt": final_prompt,
+        "model": model,
+        "size": size,
+        "quality": quality,
+        "n": 1,
+    }
+    
+    # Only add response_format for official OpenAI API (not for proxies like AIGW)
+    if not base_url or "openai.com" in base_url:
+        request_params["response_format"] = "b64_json"
+    
+    try:
+        resp = client.images.generate(**request_params)
+    finally:
+        heartbeat_stop.set()
+        hb_thread.join(timeout=1)
+
+    elapsed = time.time() - start_time
+    print(f"\n  ✅ Image generated ({elapsed:.1f}s)")
+
+    if resp is not None and resp.data:
+        path = resolve_output_path(prompt, output_dir, filename, ".png")
+        
+        # Handle both base64 and URL responses
+        image_item = resp.data[0]
+        if hasattr(image_item, 'b64_json') and image_item.b64_json:
+            image_data = base64.b64decode(image_item.b64_json)
+        elif hasattr(image_item, 'url') and image_item.url:
+            # Download from URL
+            import requests
+            image_response = requests.get(image_item.url, timeout=60)
+            image_response.raise_for_status()
+            image_data = image_response.content
+        else:
+            raise RuntimeError("No image data or URL in response")
+        
+        return save_image_bytes(image_data, path)
+
+    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:
+    """
+    OpenAI-compatible image generation with automatic retry.
+
+    Reads credentials from the current process environment or the project-root `.env`:
+      OPENAI_API_KEY
+      OPENAI_BASE_URL
+      OPENAI_MODEL (optional override)
+
+    Args:
+        prompt: Positive prompt text
+        negative_prompt: Negative prompt text (appended to prompt as "Avoid...")
+        aspect_ratio: Aspect ratio, mapped to OpenAI size
+        image_size: Image size, mapped to OpenAI quality
+        output_dir: Output directory
+        filename: Output filename (without extension)
+        model: Model name (default: gpt-image-1)
+        max_retries: Maximum number of retries
+
+    Returns:
+        Path of the saved image file
+    """
+    api_key = os.environ.get("OPENAI_API_KEY")
+    base_url = os.environ.get("OPENAI_BASE_URL")
+
+    if not api_key:
+        raise ValueError(
+            "No API key found. Set OPENAI_API_KEY in the current environment or the project-root .env."
+        )
+
+    if model is None:
+        model = os.environ.get("OPENAI_MODEL") or DEFAULT_MODEL
+
+    image_size = normalize_image_size(image_size)
+
+    if aspect_ratio not in ASPECT_RATIO_TO_SIZE:
+        supported = list(ASPECT_RATIO_TO_SIZE.keys())
+        raise ValueError(
+            f"Unsupported aspect ratio '{aspect_ratio}' for OpenAI backend. "
+            f"Supported: {supported}"
+        )
+
+    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}")

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

@@ -0,0 +1,197 @@
+#!/usr/bin/env python3
+"""
+Alibaba Cloud Qwen image generation backend.
+
+Configuration keys:
+  QWEN_API_KEY / DASHSCOPE_API_KEY   (required)
+  QWEN_BASE_URL                      (optional)
+  QWEN_MODEL                         (optional)
+"""
+
+import os
+import time
+
+import requests
+
+from image_backends.backend_common import (
+    MAX_RETRIES,
+    download_image,
+    http_error,
+    is_rate_limit_error,
+    normalize_image_size,
+    require_api_key,
+    resolve_output_path,
+    retry_delay,
+)
+
+
+DEFAULT_ENDPOINT = "https://dashscope-intl.aliyuncs.com/api/v1/services/aigc/multimodal-generation/generation"
+DEFAULT_MODEL = "qwen-image-2.0-pro"
+
+ASPECT_RATIO_SIZE_MAP = {
+    "512px": {
+        "1:1": "1024*1024",
+        "2:3": "768*1152",
+        "3:2": "1152*768",
+        "3:4": "864*1152",
+        "4:3": "1152*864",
+        "4:5": "896*1120",
+        "5:4": "1120*896",
+        "9:16": "720*1280",
+        "16:9": "1280*720",
+        "21:9": "1344*576",
+    },
+    "1K": {
+        "1:1": "1536*1536",
+        "2:3": "1024*1536",
+        "3:2": "1536*1024",
+        "3:4": "1152*1536",
+        "4:3": "1536*1152",
+        "4:5": "1216*1536",
+        "5:4": "1536*1216",
+        "9:16": "896*1600",
+        "16:9": "1600*896",
+        "21:9": "1792*768",
+    },
+    "2K": {
+        "1:1": "2048*2048",
+        "2:3": "1536*2048",
+        "3:2": "2048*1536",
+        "3:4": "1728*2368",
+        "4:3": "2368*1728",
+        "4:5": "1792*2240",
+        "5:4": "2240*1792",
+        "9:16": "1536*2688",
+        "16:9": "2688*1536",
+        "21:9": "2688*1152",
+    },
+    "4K": {
+        "1:1": "2048*2048",
+        "2:3": "1536*2048",
+        "3:2": "2048*1536",
+        "3:4": "1728*2368",
+        "4:3": "2368*1728",
+        "4:5": "1792*2240",
+        "5:4": "2240*1792",
+        "9:16": "1536*2688",
+        "16:9": "2688*1536",
+        "21:9": "2688*1152",
+    },
+}
+
+
+def _resolve_url(base_url: str) -> str:
+    """Resolve the Qwen generation endpoint."""
+    base = base_url.rstrip("/")
+    if base.endswith("/generation"):
+        return base
+    return base + "/api/v1/services/aigc/multimodal-generation/generation"
+
+
+def _resolve_size(aspect_ratio: str, image_size: str) -> str:
+    """Resolve the target resolution for a ratio and logical size preset."""
+    normalized = normalize_image_size(image_size)
+    size = (ASPECT_RATIO_SIZE_MAP.get(normalized) or {}).get(aspect_ratio)
+    if not size:
+        supported = sorted(ASPECT_RATIO_SIZE_MAP["1K"])
+        raise ValueError(
+            f"Unsupported aspect ratio '{aspect_ratio}' for Qwen backend. "
+            f"Supported: {supported}"
+        )
+    return size
+
+
+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 Qwen backend."""
+    size = _resolve_size(aspect_ratio, image_size)
+    url = _resolve_url(base_url)
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+    }
+    payload = {
+        "model": model,
+        "input": {
+            "messages": [
+                {
+                    "role": "user",
+                    "content": [{"text": prompt}],
+                }
+            ]
+        },
+        "parameters": {
+            "size": size,
+            "prompt_extend": True,
+            "watermark": False,
+        },
+    }
+    if negative_prompt:
+        payload["parameters"]["negative_prompt"] = negative_prompt
+
+    print("[Alibaba Qwen Image]")
+    print(f"  Model:        {model}")
+    print(f"  Prompt:       {prompt[:120]}{'...' if len(prompt) > 120 else ''}")
+    print(f"  Aspect Ratio: {aspect_ratio}")
+    print(f"  Resolution:   {size}")
+    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, "Qwen image generation")
+
+    data = response.json()
+    choices = ((data.get("output") or {}).get("choices") or [])
+    contents = (((choices[0] if choices else {}).get("message") or {}).get("content") or [])
+    image_url = contents[0].get("image") if contents else None
+    if not image_url:
+        raise RuntimeError(f"Qwen 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 Qwen backend."""
+    api_key = require_api_key(
+        "QWEN_API_KEY",
+        "DASHSCOPE_API_KEY",
+        message="No API key found. Set QWEN_API_KEY or DASHSCOPE_API_KEY in the current environment or the project-root .env.",
+    )
+    base_url = os.environ.get("QWEN_BASE_URL") or DEFAULT_ENDPOINT
+    resolved_model = model or os.environ.get("QWEN_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}")