ChatImg 0.1.0__py3-none-any.whl

chatimg/__init__.py

@@ -0,0 +1,5 @@
+"""ChatImg package."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

chatimg/cli.py

@@ -0,0 +1,9 @@
+"""CLI entrypoint for ChatImg."""
+
+from chatimg.image.cli import main
+
+__all__ = ["main"]
+
+
+if __name__ == "__main__":
+    main()

chatimg/config.py

@@ -0,0 +1,138 @@
+"""Typed environment configuration for ChatImg."""
+
+from chatenv import BaseEnvConfig, EnvField
+
+
+class ChatImgConfig(BaseEnvConfig):
+    """ChatImg ChatEnv configuration for image generation providers."""
+
+    _title = "ChatImg Configuration"
+    _aliases = ["chatimg", "image"]
+    _storage_dir = "ChatImg"
+
+    DASHSCOPE_API_KEY = EnvField(
+        "DASHSCOPE_API_KEY",
+        desc="Aliyun DashScope API key for Tongyi Wanxiang.",
+        is_sensitive=True,
+    )
+    HUGGINGFACE_HUB_TOKEN = EnvField(
+        "HUGGINGFACE_HUB_TOKEN",
+        desc="Hugging Face User Access Token.",
+        is_sensitive=True,
+    )
+    LIBLIB_MODEL_ID = EnvField(
+        "LIBLIB_MODEL_ID",
+        desc="Default LiblibAI model ID.",
+    )
+    LIBLIB_ACCESS_KEY = EnvField(
+        "LIBLIB_ACCESS_KEY",
+        desc="LiblibAI access key.",
+        is_sensitive=True,
+    )
+    LIBLIB_SECRET_KEY = EnvField(
+        "LIBLIB_SECRET_KEY",
+        desc="LiblibAI secret key.",
+        is_sensitive=True,
+    )
+    POLLINATIONS_API_KEY = EnvField(
+        "POLLINATIONS_API_KEY",
+        desc="Pollinations API key from enter.pollinations.ai.",
+        is_sensitive=True,
+    )
+    POLLINATIONS_MODEL_ID = EnvField(
+        "POLLINATIONS_MODEL_ID",
+        default="flux",
+        desc="Default Pollinations image model ID.",
+    )
+    SILICONFLOW_API_KEY = EnvField(
+        "SILICONFLOW_API_KEY",
+        desc="SiliconFlow API key.",
+        is_sensitive=True,
+    )
+    SILICONFLOW_MODEL_ID = EnvField(
+        "SILICONFLOW_MODEL_ID",
+        default="black-forest-labs/FLUX.1-schnell",
+        desc="Default SiliconFlow image model ID.",
+    )
+    OPENAI_ACCESS_TOKEN = EnvField(
+        "OPENAI_ACCESS_TOKEN",
+        desc="OpenAI/ChatGPT OAuth access token for Codex image generation.",
+        is_sensitive=True,
+    )
+    OPENAI_CODEX_ACCESS_TOKEN = EnvField(
+        "OPENAI_CODEX_ACCESS_TOKEN",
+        desc="Legacy Codex image OAuth access token alias.",
+        is_sensitive=True,
+    )
+    OPENAI_REFRESH_TOKEN = EnvField(
+        "OPENAI_REFRESH_TOKEN",
+        desc="OpenAI/ChatGPT OAuth refresh token for Codex image generation.",
+        is_sensitive=True,
+    )
+    OPENAI_CODEX_AUTH_JSON = EnvField(
+        "OPENAI_CODEX_AUTH_JSON",
+        default="~/.hermes/auth.json",
+        desc="Hermes auth.json path used as a Codex OAuth token fallback.",
+    )
+    OPENAI_OAUTH_BASE_URL = EnvField(
+        "OPENAI_OAUTH_BASE_URL",
+        default="https://auth.openai.com",
+        desc="OpenAI OAuth auth server base URL.",
+    )
+    OPENAI_ACCESS_TOKEN_EXPIRES_AT = EnvField(
+        "OPENAI_ACCESS_TOKEN_EXPIRES_AT",
+        desc="UTC ISO timestamp for OPENAI_ACCESS_TOKEN expiry.",
+    )
+    OPENAI_IMAGE_MODEL = EnvField(
+        "OPENAI_IMAGE_MODEL",
+        default="gpt-image-2-medium",
+        desc="Default Codex/OpenAI image model preset.",
+    )
+    OPENAI_IMAGE_ASPECT_RATIO = EnvField(
+        "OPENAI_IMAGE_ASPECT_RATIO",
+        default="square",
+        desc="Default Codex image aspect ratio.",
+    )
+    OPENAI_CODEX_HOST_MODEL = EnvField(
+        "OPENAI_CODEX_HOST_MODEL",
+        default="gpt-5.4",
+        desc="Codex host model used to invoke the image_generation tool.",
+    )
+    OPENAI_CODEX_BASE_URL = EnvField(
+        "OPENAI_CODEX_BASE_URL",
+        default="https://chatgpt.com/backend-api/codex",
+        desc="Codex Responses API base URL.",
+    )
+    OPENAI_CODEX_TIMEOUT = EnvField(
+        "OPENAI_CODEX_TIMEOUT",
+        default="300",
+        desc="Codex image request timeout in seconds.",
+    )
+
+    @classmethod
+    def test(cls) -> None:
+        """Validate schema registration without external side effects."""
+
+        print(f"Testing {cls._title}...")
+        print("Schema loaded; provider network checks are command-specific.")
+
+
+# Backward-compatible aliases for code migrated from ChatTool provider modules.
+ChatimgConfig = ChatImgConfig
+TongyiConfig = ChatImgConfig
+HuggingFaceConfig = ChatImgConfig
+LiblibConfig = ChatImgConfig
+PollinationsConfig = ChatImgConfig
+SiliconFlowConfig = ChatImgConfig
+OpenAIConfig = ChatImgConfig
+
+__all__ = [
+    "ChatImgConfig",
+    "ChatimgConfig",
+    "TongyiConfig",
+    "HuggingFaceConfig",
+    "LiblibConfig",
+    "PollinationsConfig",
+    "SiliconFlowConfig",
+    "OpenAIConfig",
+]

chatimg/image/__init__.py

@@ -0,0 +1,45 @@
+from .base import ImageGenerator
+from .tongyi import TongyiImageGenerator
+from .huggingface import HuggingFaceImageGenerator
+from .liblib import LiblibImageGenerator
+from .pollinations import PollinationsImageGenerator
+from .siliconflow import SiliconFlowImageGenerator
+from .codex import CodexImageGenerator
+
+__all__ = [
+    "ImageGenerator",
+    "TongyiImageGenerator",
+    "HuggingFaceImageGenerator",
+    "LiblibImageGenerator",
+    "PollinationsImageGenerator",
+    "SiliconFlowImageGenerator",
+    "CodexImageGenerator",
+]
+
+def create_generator(provider: str, **kwargs) -> ImageGenerator:
+    """
+    Factory function to create an image generator instance.
+
+    Args:
+        provider (str): 'tongyi', 'huggingface', 'liblib', 'pollinations',
+            'siliconflow', 'codex', or 'openai-codex'
+        **kwargs: Additional config (api_key, etc.)
+
+    Returns:
+        ImageGenerator: The initialized generator.
+    """
+    if provider == "tongyi":
+        return TongyiImageGenerator(**kwargs)
+    elif provider == "huggingface":
+        return HuggingFaceImageGenerator(**kwargs)
+    elif provider == "liblib":
+        return LiblibImageGenerator(**kwargs)
+    elif provider == "pollinations":
+        return PollinationsImageGenerator(**kwargs)
+    elif provider == "siliconflow":
+        return SiliconFlowImageGenerator(**kwargs)
+    elif provider in {"codex", "openai-codex"}:
+        return CodexImageGenerator(**kwargs)
+
+    else:
+        raise ValueError(f"Unknown provider: {provider}")

chatimg/image/base.py

@@ -0,0 +1,30 @@
+from abc import ABC, abstractmethod
+from typing import Optional, Any
+
+class ImageGenerator(ABC):
+    """
+    Abstract base class for all image generation tools.
+    """
+
+    @abstractmethod
+    def generate(self, prompt: str, **kwargs) -> Any:
+        """
+        Generate an image from the given prompt.
+
+        Args:
+            prompt (str): The text description for the image.
+            **kwargs: Additional parameters specific to the implementation (e.g. style, size).
+
+        Returns:
+            Any: The result object (e.g. image URL, bytes, or file path).
+        """
+        pass
+
+    def get_models(self) -> list:
+        """
+        Get available models for image generation.
+
+        Returns:
+            list: A list of available model IDs or objects.
+        """
+        return []

chatimg/image/cli.py

@@ -0,0 +1,422 @@
+from chatimg import __version__
+import click
+from chatstyle import (
+    CommandField,
+    CommandSchema,
+    add_interactive_option,
+    resolve_command_inputs,
+)
+from chatimg.image import create_generator
+from chatimg.image.helpers import (
+    download_binary,
+    echo_model_list,
+    resolve_generated_output_path,
+    save_binary,
+)
+
+
+PROMPT_SCHEMA = CommandSchema(
+    name="image-prompt",
+    fields=(CommandField("prompt", prompt="prompt", required=True),),
+)
+
+
+HF_GENERATE_SCHEMA = CommandSchema(
+    name="image-huggingface-generate",
+    fields=(
+        CommandField("prompt", prompt="prompt", required=True),
+    ),
+)
+
+
+@click.group()
+@click.version_option(__version__, prog_name="chatimg")
+def main() -> None:
+    """ChatImg image generation tools."""
+    pass
+
+
+@main.group()
+def liblib():
+    """LiblibAI tools."""
+    pass
+
+
+@liblib.command(name="generate")
+@click.argument("prompt", required=False)
+@click.option("--model-id", help="Model ID for generation (required).")
+@click.option("--output", "-o", help="Optional output file path to download the image.")
+@add_interactive_option
+def liblib_generate(prompt, model_id, output, interactive):
+    """Generate an image using LiblibAI."""
+    inputs = resolve_command_inputs(
+        schema=PROMPT_SCHEMA,
+        provided={"prompt": prompt},
+        interactive=interactive,
+        usage="Usage: chatimg liblib generate [PROMPT] [-i|-I]",
+    )
+    prompt = inputs["prompt"]
+
+    try:
+        generator = create_generator("liblib")
+        click.echo("Generating image with LiblibAI...")
+
+        kwargs = {}
+        if model_id:
+            kwargs["model_id"] = model_id
+
+        result = generator.generate(prompt, **kwargs)
+        click.echo(f"Image URL: {result}")
+
+        if output and result.startswith("http"):
+            download_binary(result, output)
+
+    except Exception as e:
+        raise click.ClickException(str(e)) from e
+
+
+@liblib.command(name="list-models")
+def liblib_list_models():
+    """List available models for LiblibAI."""
+    try:
+        generator = create_generator("liblib")
+        models = generator.get_models()
+        click.echo("Available models for LiblibAI:")
+        for model in models:
+            click.echo(
+                f"- {model.get('name', 'Unknown')} (ID: {model.get('id', 'Unknown')})"
+            )
+    except Exception as e:
+        raise click.ClickException(str(e)) from e
+
+
+@main.group()
+def huggingface():
+    """Hugging Face tools."""
+    pass
+
+
+@huggingface.command(name="generate")
+@click.argument("prompt", required=False)
+@click.option(
+    "--output",
+    "-o",
+    required=False,
+    help="Optional output file path. Defaults to ./generated/image_huggingface_<model>_<timestamp>.png for bytes results.",
+)
+@add_interactive_option
+def huggingface_generate(prompt, output, interactive):
+    """Generate an image using Hugging Face."""
+    inputs = resolve_command_inputs(
+        schema=HF_GENERATE_SCHEMA,
+        provided={"prompt": prompt},
+        interactive=interactive,
+        usage="Usage: chatimg huggingface generate [PROMPT] [-o PATH] [-i|-I]",
+    )
+    prompt = inputs["prompt"]
+
+    try:
+        from chatimg.image.huggingface import HuggingFaceImageGenerator
+
+        generator = create_generator("huggingface")
+        click.echo("Generating image with Hugging Face...")
+        result = generator.generate(prompt)
+
+        if isinstance(result, bytes):
+            output_path = resolve_generated_output_path(
+                output,
+                provider="huggingface",
+                model=HuggingFaceImageGenerator.DEFAULT_MODEL,
+            )
+            save_binary(result, output_path)
+            click.echo(f"Image saved to {output_path}")
+        else:
+            click.echo(f"Result: {result}")
+    except Exception as e:
+        raise click.ClickException(str(e)) from e
+
+
+@main.group()
+def tongyi():
+    """Tongyi Wanxiang tools."""
+    pass
+
+
+@tongyi.command(name="generate")
+@click.argument("prompt", required=False)
+@click.option("--style", default="<auto>", help="Image style.")
+@click.option("--size", default="1024*1024", help="Image size.")
+@click.option("--output", "-o", help="Optional output file path to download the image.")
+@add_interactive_option
+def tongyi_generate(prompt, style, size, output, interactive):
+    """Generate an image using Tongyi Wanxiang."""
+    inputs = resolve_command_inputs(
+        schema=PROMPT_SCHEMA,
+        provided={"prompt": prompt},
+        interactive=interactive,
+        usage="Usage: chatimg tongyi generate [PROMPT] [-i|-I]",
+    )
+    prompt = inputs["prompt"]
+
+    try:
+        generator = create_generator("tongyi")
+        click.echo("Generating image with Tongyi Wanxiang...")
+        result = generator.generate(prompt, style=style, size=size)
+
+        # Tongyi returns a list of dicts with 'url'
+        if isinstance(result, list):
+            for i, item in enumerate(result):
+                url = item.get("url")
+                click.echo(f"Image {i + 1}: {url}")
+                if output and url:
+                    download_binary(url, output)
+        else:
+            click.echo(f"Result: {result}")
+
+    except Exception as e:
+        raise click.ClickException(str(e)) from e
+
+
+@main.group()
+def pollinations():
+    """Pollinations.ai tools."""
+    pass
+
+
+@pollinations.command(name="generate")
+@click.argument("prompt", required=False)
+@click.option("--model", help="Model name (flux, turbo, etc).")
+@click.option("--width", default=1024, help="Image width.")
+@click.option("--height", default=1024, help="Image height.")
+@click.option("--output", "-o", help="Optional output file path to download the image.")
+@add_interactive_option
+def pollinations_generate(prompt, model, width, height, output, interactive):
+    """Generate an image using Pollinations.ai."""
+    inputs = resolve_command_inputs(
+        schema=PROMPT_SCHEMA,
+        provided={"prompt": prompt},
+        interactive=interactive,
+        usage="Usage: chatimg pollinations generate [PROMPT] [-i|-I]",
+    )
+    prompt = inputs["prompt"]
+
+    try:
+        from chatimg.config import PollinationsConfig
+        from chatimg.image import create_generator
+
+        model = model or PollinationsConfig.POLLINATIONS_MODEL_ID.value or "flux"
+        generator = create_generator("pollinations", model=model)
+        click.echo(f"Generating image with Pollinations.ai (model: {model})...")
+        result = generator.generate(prompt, width=width, height=height)
+
+        for i, url in enumerate(result):
+            click.echo(f"Image URL: {url}")
+
+            if output:
+                click.echo(f"Downloading to {output}...")
+                headers = {
+                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+                }
+                if PollinationsConfig.POLLINATIONS_API_KEY.value:
+                    headers["Authorization"] = (
+                        f"Bearer {PollinationsConfig.POLLINATIONS_API_KEY.value}"
+                    )
+
+                download_binary(url, output, headers=headers)
+
+    except Exception as e:
+        raise click.ClickException(str(e)) from e
+
+
+@pollinations.command(name="list-models")
+def pollinations_list_models():
+    """List available image models for Pollinations.ai."""
+    try:
+        from chatimg.image import create_generator
+
+        generator = create_generator("pollinations")
+        models = generator.get_models()
+        echo_model_list(models, "Available image models for Pollinations.ai:")
+    except Exception as e:
+        raise click.ClickException(str(e)) from e
+
+
+@main.group()
+def siliconflow():
+    """SiliconFlow tools."""
+    pass
+
+
+@main.group()
+def codex():
+    """ChatGPT/Codex OAuth image tools."""
+    pass
+
+
+@siliconflow.command(name="generate")
+@click.argument("prompt", required=False)
+@click.option("--model", help="Model name.")
+@click.option("--size", default="1024x1024", help="Image size (e.g., 1024x1024).")
+@click.option("--output", "-o", help="Optional output file path to download the image.")
+@add_interactive_option
+def siliconflow_generate(prompt, model, size, output, interactive):
+    """Generate an image using SiliconFlow API."""
+    inputs = resolve_command_inputs(
+        schema=PROMPT_SCHEMA,
+        provided={"prompt": prompt},
+        interactive=interactive,
+        usage="Usage: chatimg siliconflow generate [PROMPT] [-i|-I]",
+    )
+    prompt = inputs["prompt"]
+
+    try:
+        from chatimg.config import SiliconFlowConfig
+        from chatimg.image import create_generator
+
+        # Determine model
+        model = (
+            model
+            or SiliconFlowConfig.SILICONFLOW_MODEL_ID.value
+            or "black-forest-labs/FLUX.1-schnell"
+        )
+
+        generator = create_generator("siliconflow")
+        click.echo(f"Generating image with SiliconFlow (model: {model})...")
+
+        result = generator.generate(prompt, model=model, size=size)
+
+        for i, url in enumerate(result):
+            click.echo(f"Image URL: {url}")
+
+            if output:
+                click.echo(f"Downloading to {output}...")
+                download_binary(url, output)
+
+    except Exception as e:
+        raise click.ClickException(str(e)) from e
+
+
+@siliconflow.command(name="list-models")
+def siliconflow_list_models():
+    """List available image models for SiliconFlow."""
+    try:
+        from chatimg.image import create_generator
+
+        generator = create_generator("siliconflow")
+        models = generator.get_models()
+
+        # Filter for text-to-image models only if possible
+        image_models = []
+        for m in models:
+            # Check type or sub_type
+            is_image = m.get("type") == "image" or m.get("sub_type") == "text-to-image"
+            if is_image:
+                image_models.append(m)
+
+        if not image_models:
+            image_models = models
+
+        click.echo("Available image models for SiliconFlow:")
+        for model in image_models:
+            model_id = model.get("id")
+            # Check if it's a free model (no Pro/ prefix)
+            is_free = not model_id.startswith("Pro/")
+            price_info = "FREE" if is_free else "PAID"
+
+            click.echo(f"- {model_id} [{price_info}]")
+
+    except Exception as e:
+        raise click.ClickException(str(e)) from e
+
+
+@codex.command(name="generate")
+@click.argument("prompt", required=False)
+@click.option(
+    "--aspect-ratio",
+    type=click.Choice(["square", "landscape", "portrait"]),
+    help="Image aspect ratio.",
+)
+@click.option(
+    "--image-model",
+    type=click.Choice(
+        ["gpt-image-2-low", "gpt-image-2-medium", "gpt-image-2-high"]
+    ),
+    help="Codex image model preset.",
+)
+@click.option(
+    "--host-model",
+    help="Codex host model used to invoke the image_generation tool.",
+)
+@click.option(
+    "--base-url",
+    help="Override the Codex backend base URL. The OAuth token is sent to this host.",
+)
+@click.option(
+    "--timeout",
+    type=float,
+    help="Request timeout in seconds.",
+)
+@click.option(
+    "--output",
+    "-o",
+    help="Optional output file path. Defaults to ./generated/image_codex_<model>_<timestamp>.png",
+)
+@add_interactive_option
+def codex_generate(
+    prompt,
+    aspect_ratio,
+    image_model,
+    host_model,
+    base_url,
+    timeout,
+    output,
+    interactive,
+):
+    """Generate an image using the ChatGPT/Codex OAuth image bridge."""
+    inputs = resolve_command_inputs(
+        schema=PROMPT_SCHEMA,
+        provided={"prompt": prompt},
+        interactive=interactive,
+        usage="Usage: chatimg codex generate [PROMPT] [-i|-I]",
+    )
+    prompt = inputs["prompt"]
+
+    try:
+        generator = create_generator(
+            "codex",
+            base_url=base_url,
+            host_model=host_model,
+            image_model=image_model,
+            aspect_ratio=aspect_ratio,
+            timeout_seconds=timeout,
+        )
+        click.echo(
+            "Generating image with Codex "
+            f"(host: {generator.host_model}, image: {generator.image_model})..."
+        )
+        result = generator.generate(prompt)
+        output_path = resolve_generated_output_path(
+            output,
+            provider="codex",
+            model=generator.image_model,
+            prompt=prompt,
+        )
+        saved = save_binary(result, output_path)
+        click.echo(f"Image saved to {saved}")
+    except Exception as e:
+        raise click.ClickException(str(e)) from e
+
+
+@codex.command(name="list-models")
+def codex_list_models():
+    """List built-in Codex image model presets."""
+    try:
+        generator = create_generator("codex")
+        models = generator.get_models()
+        echo_model_list(models, "Available image models for Codex:")
+    except Exception as e:
+        raise click.ClickException(str(e)) from e
+
+
+if __name__ == "__main__":
+    main()