codewave-openclaw-installer 1.0.2 → 2.1.0

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

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+"""
+Zhipu GLM-Image generation backend.
+
+Configuration keys:
+  ZHIPU_API_KEY / BIGMODEL_API_KEY   (required)
+  ZHIPU_BASE_URL                     (optional)
+  ZHIPU_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://open.bigmodel.cn/api/paas/v4/images/generations"
+DEFAULT_MODEL = "glm-image"
+
+ASPECT_RATIO_SIZE_MAP = {
+    "512px": {
+        "1:1": "1024x1024",
+        "2:3": "768x1152",
+        "3:2": "1152x768",
+        "3:4": "864x1152",
+        "4:3": "1152x864",
+        "4:5": "1024x1280",
+        "5:4": "1280x1024",
+        "9:16": "720x1440",
+        "16:9": "1440x720",
+        "21:9": "1536x640",
+    },
+    "1K": {
+        "1:1": "1280x1280",
+        "2:3": "960x1440",
+        "3:2": "1440x960",
+        "3:4": "1024x1365",
+        "4:3": "1365x1024",
+        "4:5": "1024x1280",
+        "5:4": "1280x1024",
+        "9:16": "768x1344",
+        "16:9": "1344x768",
+        "21:9": "1536x640",
+    },
+    "2K": {
+        "1:1": "1440x1440",
+        "2:3": "1152x1728",
+        "3:2": "1728x1152",
+        "3:4": "1152x1536",
+        "4:3": "1536x1152",
+        "4:5": "1280x1600",
+        "5:4": "1600x1280",
+        "9:16": "720x1440",
+        "16:9": "1440x720",
+        "21:9": "1792x768",
+    },
+    "4K": {
+        "1:1": "1440x1440",
+        "2:3": "1152x1728",
+        "3:2": "1728x1152",
+        "3:4": "1152x1536",
+        "4:3": "1536x1152",
+        "4:5": "1280x1600",
+        "5:4": "1600x1280",
+        "9:16": "720x1440",
+        "16:9": "1440x720",
+        "21:9": "1792x768",
+    },
+}
+
+
+def _resolve_url(base_url: str) -> str:
+    """Resolve the Zhipu generation endpoint."""
+    base = base_url.rstrip("/")
+    if base.endswith("/images/generations"):
+        return base
+    return base + "/api/paas/v4/images/generations"
+
+
+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 Zhipu 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 Zhipu backend."""
+    size = _resolve_size(aspect_ratio, image_size)
+    url = _resolve_url(base_url)
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+    }
+
+    final_prompt = prompt
+    if negative_prompt:
+        final_prompt += f"\n\nAvoid the following: {negative_prompt}"
+
+    payload = {
+        "model": model,
+        "prompt": final_prompt,
+        "size": size,
+    }
+
+    print("[Zhipu GLM-Image]")
+    print(f"  Model:        {model}")
+    print(f"  Prompt:       {final_prompt[:120]}{'...' if len(final_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, "Zhipu image generation")
+
+    data = response.json()
+    items = data.get("data") or []
+    image_url = items[0].get("url") if items else None
+    if not image_url:
+        raise RuntimeError(f"Zhipu 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 Zhipu backend."""
+    api_key = require_api_key(
+        "ZHIPU_API_KEY",
+        "BIGMODEL_API_KEY",
+        message="No API key found. Set ZHIPU_API_KEY or BIGMODEL_API_KEY in the current environment or the project-root .env.",
+    )
+    base_url = os.environ.get("ZHIPU_BASE_URL") or DEFAULT_ENDPOINT
+    resolved_model = model or os.environ.get("ZHIPU_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_gen.py

@@ -0,0 +1,412 @@
+#!/usr/bin/env python3
+"""
+Unified Image Generation Tool
+
+Dispatches to the appropriate backend based on explicit provider configuration.
+
+Backend selection (`IMAGE_BACKEND` in `.env` or the current process environment):
+  IMAGE_BACKEND=gemini     -> Gemini backend (google-genai SDK)
+  IMAGE_BACKEND=openai     -> OpenAI-compatible backend (openai SDK)
+  IMAGE_BACKEND=stability  -> Stability AI backend
+  IMAGE_BACKEND=bfl        -> Black Forest Labs FLUX backend
+  IMAGE_BACKEND=ideogram   -> Ideogram backend
+  IMAGE_BACKEND=qwen       -> Alibaba Qwen image backend
+  IMAGE_BACKEND=zhipu      -> Zhipu GLM-Image backend
+  IMAGE_BACKEND=volcengine -> Volcengine Seedream backend
+  IMAGE_BACKEND=siliconflow -> SiliconFlow backend
+  IMAGE_BACKEND=fal        -> fal.ai backend
+  IMAGE_BACKEND=replicate  -> Replicate backend
+
+Configuration source:
+  1. Current process environment variables
+  2. Project-root `.env` as a fallback layer
+
+Supported keys:
+  IMAGE_BACKEND    (required) backend name
+
+  Provider-specific keys are used for credentials and overrides, for example:
+    GEMINI_API_KEY / GEMINI_MODEL / GEMINI_BASE_URL
+    OPENAI_API_KEY / OPENAI_MODEL / OPENAI_BASE_URL
+    QWEN_API_KEY / QWEN_MODEL / QWEN_BASE_URL
+    ZHIPU_API_KEY / ZHIPU_MODEL / ZHIPU_BASE_URL
+
+Usage:
+  python3 image_gen.py "prompt" --aspect_ratio 16:9 --image_size 1K -o images/
+  python3 image_gen.py --list-backends
+"""
+
+import os
+import sys
+import argparse
+from pathlib import Path
+
+ENV_PATH = Path(__file__).resolve().parents[3] / ".env"
+IMAGE_ENV_PREFIXES = (
+    "IMAGE_",
+    "GEMINI_",
+    "OPENAI_",
+    "STABILITY_",
+    "BFL_",
+    "IDEOGRAM_",
+    "QWEN_",
+    "DASHSCOPE_",
+    "ZHIPU_",
+    "BIGMODEL_",
+    "VOLCENGINE_",
+    "ARK_",
+    "SILICONFLOW_",
+    "FAL_",
+    "REPLICATE_",
+)
+DEPRECATED_IMAGE_KEYS = {
+    "IMAGE_API_KEY",
+    "IMAGE_MODEL",
+    "IMAGE_BASE_URL",
+}
+
+# All aspect ratios accepted by the unified CLI
+# (each backend validates its own subset internally)
+ALL_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"
+]
+
+ALL_IMAGE_SIZES = ["512px", "1K", "2K", "4K"]
+
+BACKEND_REGISTRY = {
+    "aigw_gemini": {
+        "module": "backend_aigw_gemini",
+        "tier": "core",
+        "label": "AIGW Gemini (NetEase)",
+        "default_model": "gemini-2.5-flash-image-preview",
+        "key_hint": "AIGW_GEMINI_API_KEY / OPENAI_API_KEY",
+        "aliases": ["aigw-gemini", "netease_gemini"],
+    },
+    "gemini": {
+        "module": "backend_gemini",
+        "tier": "core",
+        "label": "Google Gemini",
+        "default_model": "gemini-3.1-flash-image-preview",
+        "key_hint": "GEMINI_API_KEY",
+        "aliases": ["google"],
+    },
+    "openai": {
+        "module": "backend_openai",
+        "tier": "core",
+        "label": "OpenAI / OpenAI-compatible",
+        "default_model": "gpt-image-1",
+        "key_hint": "OPENAI_API_KEY",
+        "aliases": ["openai-compatible", "openai_compatible"],
+    },
+    "qwen": {
+        "module": "backend_qwen",
+        "tier": "core",
+        "label": "Alibaba Qwen Image",
+        "default_model": "qwen-image-2.0-pro",
+        "key_hint": "QWEN_API_KEY / DASHSCOPE_API_KEY",
+        "aliases": ["alibaba", "dashscope"],
+    },
+    "zhipu": {
+        "module": "backend_zhipu",
+        "tier": "core",
+        "label": "Zhipu GLM-Image",
+        "default_model": "glm-image",
+        "key_hint": "ZHIPU_API_KEY / BIGMODEL_API_KEY",
+        "aliases": ["bigmodel", "glm", "glm-image"],
+    },
+    "volcengine": {
+        "module": "backend_volcengine",
+        "tier": "core",
+        "label": "Volcengine Seedream",
+        "default_model": "doubao-seedream-4-5-251128",
+        "key_hint": "VOLCENGINE_API_KEY / ARK_API_KEY",
+        "aliases": ["ark", "doubao", "seedream"],
+    },
+    "stability": {
+        "module": "backend_stability",
+        "tier": "extended",
+        "label": "Stability AI",
+        "default_model": "stable-image-core",
+        "key_hint": "STABILITY_API_KEY",
+        "aliases": ["stabilityai", "stability-ai"],
+    },
+    "bfl": {
+        "module": "backend_bfl",
+        "tier": "extended",
+        "label": "Black Forest Labs FLUX",
+        "default_model": "flux-pro-1.1-ultra",
+        "key_hint": "BFL_API_KEY",
+        "aliases": ["flux", "black-forest-labs", "black_forest_labs"],
+    },
+    "ideogram": {
+        "module": "backend_ideogram",
+        "tier": "extended",
+        "label": "Ideogram",
+        "default_model": "ideogram-v3",
+        "key_hint": "IDEOGRAM_API_KEY",
+    },
+    "siliconflow": {
+        "module": "backend_siliconflow",
+        "tier": "experimental",
+        "label": "SiliconFlow",
+        "default_model": "Qwen/Qwen-Image",
+        "key_hint": "SILICONFLOW_API_KEY",
+        "aliases": ["silicon"],
+    },
+    "fal": {
+        "module": "backend_fal",
+        "tier": "experimental",
+        "label": "fal.ai",
+        "default_model": "fal-ai/imagen3/fast",
+        "key_hint": "FAL_KEY / FAL_API_KEY",
+        "aliases": ["fal-ai"],
+    },
+    "replicate": {
+        "module": "backend_replicate",
+        "tier": "experimental",
+        "label": "Replicate",
+        "default_model": "black-forest-labs/flux-1.1-pro",
+        "key_hint": "REPLICATE_API_TOKEN / REPLICATE_API_KEY",
+    },
+}
+
+TIER_ORDER = {"core": 0, "extended": 1, "experimental": 2}
+SUPPORTED_BACKENDS = tuple(sorted(BACKEND_REGISTRY))
+
+
+def _is_image_env_key(name: str) -> bool:
+    """Return whether an env var name belongs to image generation config."""
+    return name.startswith(IMAGE_ENV_PREFIXES)
+
+
+def _strip_env_quotes(value: str) -> str:
+    """Strip matching surrounding quotes from a `.env` value."""
+    if len(value) >= 2 and value[0] == value[-1] and value[0] in ("'", '"'):
+        return value[1:-1]
+    return value
+
+
+def _load_image_env_file() -> None:
+    """
+    Load image generation config from the project-root `.env` as a fallback layer.
+
+    Existing process environment variables win over `.env`.
+    """
+    if not ENV_PATH.exists():
+        return
+
+    with ENV_PATH.open("r", encoding="utf-8") as fh:
+        for lineno, raw_line in enumerate(fh, start=1):
+            line = raw_line.strip()
+            if not line or line.startswith("#"):
+                continue
+
+            if line.startswith("export "):
+                line = line[7:].lstrip()
+
+            if "=" not in line:
+                raise ValueError(
+                    f"Invalid line in {ENV_PATH}:{lineno}. Expected KEY=VALUE."
+                )
+
+            key, value = line.split("=", 1)
+            key = key.strip()
+            if not key:
+                raise ValueError(
+                    f"Invalid line in {ENV_PATH}:{lineno}. Missing variable name."
+                )
+
+            if not _is_image_env_key(key):
+                continue
+
+            if key in DEPRECATED_IMAGE_KEYS:
+                replacement = {
+                    "IMAGE_API_KEY": "GEMINI_API_KEY / OPENAI_API_KEY / QWEN_API_KEY / ZHIPU_API_KEY / ...",
+                    "IMAGE_MODEL": "GEMINI_MODEL / OPENAI_MODEL / QWEN_MODEL / ZHIPU_MODEL / ...",
+                    "IMAGE_BASE_URL": "GEMINI_BASE_URL / OPENAI_BASE_URL / QWEN_BASE_URL / ZHIPU_BASE_URL / ...",
+                }[key]
+                raise ValueError(
+                    f"Unsupported key in {ENV_PATH}:{lineno}: {key}\n"
+                    "Global image config keys have been removed.\n"
+                    f"Use IMAGE_BACKEND plus provider-specific keys instead, such as {replacement}."
+                )
+
+            os.environ.setdefault(key, _strip_env_quotes(value.strip()))
+
+
+def _validate_runtime_config() -> None:
+    """Reject deprecated global image variables from any configuration source."""
+    for key in DEPRECATED_IMAGE_KEYS:
+        if key not in os.environ:
+            continue
+        replacement = {
+            "IMAGE_API_KEY": "GEMINI_API_KEY / OPENAI_API_KEY / QWEN_API_KEY / ZHIPU_API_KEY / ...",
+            "IMAGE_MODEL": "GEMINI_MODEL / OPENAI_MODEL / QWEN_MODEL / ZHIPU_MODEL / ...",
+            "IMAGE_BASE_URL": "GEMINI_BASE_URL / OPENAI_BASE_URL / QWEN_BASE_URL / ZHIPU_BASE_URL / ...",
+        }[key]
+        raise ValueError(
+            f"Unsupported image config key: {key}\n"
+            "Global image config keys have been removed.\n"
+            f"Use IMAGE_BACKEND plus provider-specific keys instead, such as {replacement}."
+        )
+
+
+def _build_backend_aliases() -> dict[str, str]:
+    """Build a lookup from aliases to canonical backend names."""
+    aliases = {}
+    for canonical_name, config in BACKEND_REGISTRY.items():
+        aliases[canonical_name] = canonical_name
+        for alias in config.get("aliases", []):
+            aliases[alias] = canonical_name
+    return aliases
+
+
+BACKEND_ALIASES = _build_backend_aliases()
+
+
+def _load_backend(canonical_name: str) -> tuple[object, str]:
+    """Import and return the configured backend module."""
+    module_name = f"image_backends.{BACKEND_REGISTRY[canonical_name]['module']}"
+    module = __import__(module_name, fromlist=["*"])
+    return module, canonical_name
+
+
+def _print_backend_list() -> None:
+    """Print supported backends grouped by support tier."""
+    print("Supported image backends:\n")
+    tiers = ("core", "extended", "experimental")
+    for tier in tiers:
+        print(f"{tier.upper()}:")
+        for name, info in sorted(
+            BACKEND_REGISTRY.items(),
+            key=lambda item: (TIER_ORDER[item[1]["tier"]], item[0]),
+        ):
+            if info["tier"] != tier:
+                continue
+            print(
+                f"  {name:<12} {info['label']} | default={info['default_model']} | keys={info['key_hint']}"
+            )
+        print()
+    print("Recommendation: prefer CORE backends for everyday PPT generation.")
+    print(f"Config fallback file: {ENV_PATH}")
+
+
+def _resolve_backend() -> tuple[object, str]:
+    """
+    Determine which backend to use from explicit configuration.
+
+    Returns:
+        A backend module with a generate() function.
+    """
+    backend_name = os.environ.get("IMAGE_BACKEND", "").strip().lower()
+    if backend_name:
+        canonical = BACKEND_ALIASES.get(backend_name)
+        if not canonical:
+            supported = ", ".join(SUPPORTED_BACKENDS)
+            print(f"Error: Unknown IMAGE_BACKEND='{backend_name}'. Supported: {supported}")
+            sys.exit(1)
+        return _load_backend(canonical)
+
+    supported = ", ".join(SUPPORTED_BACKENDS)
+    print(
+        "Error: No image backend configured.\n"
+        "\n"
+        "Set IMAGE_BACKEND explicitly in one of these places:\n"
+        f"  1. Current process environment\n"
+        f"  2. {ENV_PATH}\n"
+        "\n"
+        f"Supported backends: {supported}\n"
+        "\n"
+        "Example:\n"
+        "  IMAGE_BACKEND=gemini\n"
+        "  GEMINI_API_KEY=your-key\n"
+    )
+    sys.exit(1)
+
+
+def main() -> None:
+    """Run the CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description="Generate images using AI image model providers."
+    )
+    parser.add_argument(
+        "prompt", nargs="?", default="a beautiful landscape",
+        help="The text prompt for image generation."
+    )
+    parser.add_argument(
+        "--negative_prompt", "-n", default=None,
+        help="Negative prompt to specify what to avoid."
+    )
+    parser.add_argument(
+        "--aspect_ratio", default="1:1", choices=ALL_ASPECT_RATIOS,
+        help=f"Aspect ratio. Default: 1:1."
+    )
+    parser.add_argument(
+        "--image_size", default="1K",
+        help=f"Image size. Choices: {ALL_IMAGE_SIZES}. Default: 1K. (case-insensitive)"
+    )
+    parser.add_argument(
+        "--output", "-o", default=None,
+        help="Output directory. Default: current directory."
+    )
+    parser.add_argument(
+        "--filename", "-f", default=None,
+        help="Output filename (without extension). Overrides auto-naming."
+    )
+    parser.add_argument(
+        "--model", "-m", default=None,
+        help="Model name. Default depends on backend."
+    )
+    parser.add_argument(
+        "--backend", "-b", default=None, choices=SUPPORTED_BACKENDS,
+        help="Override IMAGE_BACKEND env var."
+    )
+    parser.add_argument(
+        "--list-backends", action="store_true",
+        help="List available backends grouped by support tier and exit."
+    )
+
+    args = parser.parse_args()
+
+    if args.list_backends:
+        _print_backend_list()
+        return
+
+    try:
+        _load_image_env_file()
+        _validate_runtime_config()
+    except ValueError as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+    # CLI --backend overrides the value loaded from .env
+    if args.backend:
+        os.environ["IMAGE_BACKEND"] = args.backend
+
+    backend, backend_name = _resolve_backend()
+    print(f"Using backend: {backend_name}\n")
+
+    try:
+        backend.generate(
+            prompt=args.prompt,
+            negative_prompt=args.negative_prompt,
+            aspect_ratio=args.aspect_ratio,
+            image_size=args.image_size,
+            output_dir=args.output,
+            filename=args.filename,
+            model=args.model,
+        )
+    except (ValueError, FileNotFoundError) as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+    except RuntimeError as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+    except KeyboardInterrupt:
+        print("\n\nInterrupted by user.")
+        sys.exit(130)
+
+
+if __name__ == "__main__":
+    main()