wan-cli 2026.4.5.0__py3-none-any.whl

wan_cli/__init__.py

@@ -0,0 +1 @@
+"""Wan CLI - AI Wan Video Generation via AceDataCloud API."""

wan_cli/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as python -m wan_cli."""
+
+from wan_cli.main import cli
+
+cli()

wan_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI commands for Wan CLI."""

wan_cli/commands/info.py

@@ -0,0 +1,52 @@
+"""Info and utility commands."""
+
+import click
+
+from wan_cli.core.config import settings
+from wan_cli.core.output import RESOLUTIONS, console, print_models
+
+
+@click.command()
+def models() -> None:
+    """List available Wan models."""
+    print_models()
+
+
+@click.command()
+def resolutions() -> None:
+    """List available resolutions."""
+    from rich.table import Table
+
+    table = Table(title="Available Resolutions")
+    table.add_column("Resolution", style="bold cyan")
+    table.add_column("Description")
+
+    descriptions = {
+        "480P": "Standard definition",
+        "720P": "High definition",
+        "1080P": "Full high definition",
+    }
+
+    for res in RESOLUTIONS:
+        table.add_row(res, descriptions.get(res, ""))
+
+    console.print(table)
+
+
+@click.command()
+def config() -> None:
+    """Show current configuration."""
+    from rich.table import Table
+
+    table = Table(title="Wan CLI Configuration")
+    table.add_column("Setting", style="bold cyan")
+    table.add_column("Value")
+
+    table.add_row("API Base URL", settings.api_base_url)
+    table.add_row(
+        "API Token", f"{settings.api_token[:8]}..." if settings.api_token else "[red]Not set[/red]"
+    )
+    table.add_row("Default Model", settings.default_model)
+    table.add_row("Request Timeout", f"{settings.request_timeout}s")
+
+    console.print(table)

wan_cli/commands/task.py

@@ -0,0 +1,142 @@
+"""Task management commands."""
+
+import time
+
+import click
+
+from wan_cli.core.client import get_client
+from wan_cli.core.exceptions import WanError
+from wan_cli.core.output import print_error, print_json, print_success, print_task_result
+
+
+@click.command()
+@click.argument("task_id")
+@click.option("--json", "output_json", is_flag=True, help="Output raw JSON.")
+@click.pass_context
+def task(
+    ctx: click.Context,
+    task_id: str,
+    output_json: bool,
+) -> None:
+    """Query a single task status.
+
+    TASK_ID is the task ID returned from generate commands.
+
+    Examples:
+
+      wan task abc123-def456
+    """
+    client = get_client(ctx.obj.get("token"))
+    try:
+        result = client.query_task(id=task_id, action="retrieve")
+        if output_json:
+            print_json(result)
+        else:
+            print_task_result(result)
+    except WanError as e:
+        print_error(e.message)
+        raise SystemExit(1) from e
+
+
+@click.command("tasks")
+@click.argument("task_ids", nargs=-1, required=True)
+@click.option("--json", "output_json", is_flag=True, help="Output raw JSON.")
+@click.pass_context
+def tasks_batch(
+    ctx: click.Context,
+    task_ids: tuple[str, ...],
+    output_json: bool,
+) -> None:
+    """Query multiple tasks at once.
+
+    TASK_IDS are space-separated task IDs.
+
+    Examples:
+
+      wan tasks abc123 def456 ghi789
+    """
+    client = get_client(ctx.obj.get("token"))
+    try:
+        result = client.query_task(ids=list(task_ids), action="retrieve_batch")
+        if output_json:
+            print_json(result)
+        else:
+            print_task_result(result)
+    except WanError as e:
+        print_error(e.message)
+        raise SystemExit(1) from e
+
+
+@click.command()
+@click.argument("task_id")
+@click.option(
+    "--interval",
+    type=int,
+    default=5,
+    help="Polling interval in seconds (default: 5).",
+)
+@click.option(
+    "--timeout",
+    "max_timeout",
+    type=int,
+    default=600,
+    help="Maximum wait time in seconds (default: 600).",
+)
+@click.option("--json", "output_json", is_flag=True, help="Output raw JSON.")
+@click.pass_context
+def wait(
+    ctx: click.Context,
+    task_id: str,
+    interval: int,
+    max_timeout: int,
+    output_json: bool,
+) -> None:
+    """Wait for a task to complete, polling periodically.
+
+    TASK_ID is the task ID to monitor.
+
+    Examples:
+
+      wan wait abc123
+
+      wan wait abc123 --interval 10 --timeout 300
+    """
+    client = get_client(ctx.obj.get("token"))
+    elapsed = 0
+
+    try:
+        while elapsed < max_timeout:
+            result = client.query_task(id=task_id, action="retrieve")
+            data = result.get("data", {})
+
+            # Check completion - handle both list and dict responses
+            if isinstance(data, list) and data:
+                item = data[0]
+            elif isinstance(data, dict):
+                item = data
+            else:
+                item = {}
+
+            state = item.get("state", item.get("status", ""))
+            if state in ("succeeded", "completed", "complete", "failed", "error"):
+                if output_json:
+                    print_json(result)
+                else:
+                    if state in ("failed", "error"):
+                        print_error(f"Task {task_id} failed.")
+                    else:
+                        print_success(f"Task {task_id} completed!")
+                    print_task_result(result)
+                return
+
+            if not output_json:
+                click.echo(f"Status: {state or 'pending'} (waited {elapsed}s)...", err=True)
+
+            time.sleep(interval)
+            elapsed += interval
+
+        print_error(f"Timeout: task {task_id} did not complete within {max_timeout}s")
+        raise SystemExit(1)
+    except WanError as e:
+        print_error(e.message)
+        raise SystemExit(1) from e

wan_cli/commands/video.py

@@ -0,0 +1,247 @@
+"""Video generation commands."""
+
+import click
+
+from wan_cli.core.client import get_client
+from wan_cli.core.exceptions import WanError
+from wan_cli.core.output import (
+    DEFAULT_MODEL,
+    DURATIONS,
+    RESOLUTIONS,
+    SHOT_TYPES,
+    WAN_MODELS,
+    print_error,
+    print_json,
+    print_video_result,
+)
+
+
+@click.command()
+@click.argument("prompt")
+@click.option(
+    "-m",
+    "--model",
+    type=click.Choice(WAN_MODELS),
+    default=DEFAULT_MODEL,
+    help="Wan model version.",
+)
+@click.option(
+    "-r",
+    "--resolution",
+    type=click.Choice(RESOLUTIONS),
+    default=None,
+    help="Output resolution (480P, 720P, 1080P).",
+)
+@click.option(
+    "--shot-type",
+    type=click.Choice(SHOT_TYPES),
+    default=None,
+    help="Shot type: single continuous shot or multi switching shots.",
+)
+@click.option(
+    "--duration",
+    type=click.Choice([str(d) for d in DURATIONS]),
+    default=None,
+    help="Duration in seconds (5, 10, 15).",
+)
+@click.option(
+    "--negative-prompt",
+    default=None,
+    help="Reverse prompt words describing content to exclude from the video.",
+)
+@click.option(
+    "--size",
+    default=None,
+    help="The size of the generated video.",
+)
+@click.option(
+    "--audio/--no-audio",
+    default=None,
+    help="Whether the generated video has sound.",
+)
+@click.option(
+    "--prompt-extend/--no-prompt-extend",
+    default=None,
+    help="Enable prompt intelligent rewriting.",
+)
+@click.option(
+    "--audio-url",
+    default=None,
+    help="URL of an audio file to use in the generated video.",
+)
+@click.option("--callback-url", default=None, help="Webhook callback URL.")
+@click.option("--json", "output_json", is_flag=True, help="Output raw JSON.")
+@click.pass_context
+def generate(
+    ctx: click.Context,
+    prompt: str,
+    model: str,
+    resolution: str | None,
+    shot_type: str | None,
+    duration: str | None,
+    negative_prompt: str | None,
+    size: str | None,
+    audio: bool | None,
+    prompt_extend: bool | None,
+    audio_url: str | None,
+    callback_url: str | None,
+    output_json: bool,
+) -> None:
+    """Generate a video from a text prompt.
+
+    PROMPT is a detailed description of what to generate.
+
+    Examples:
+
+      wan generate "Astronauts shuttle from space to volcano"
+
+      wan generate "A cat playing with yarn" -m wan2.6-t2v
+    """
+    client = get_client(ctx.obj.get("token"))
+    try:
+        payload: dict[str, object] = {
+            "action": "text2video",
+            "prompt": prompt,
+            "model": model,
+            "resolution": resolution,
+            "shot_type": shot_type,
+            "duration": int(duration) if duration is not None else None,
+            "negative_prompt": negative_prompt,
+            "size": size,
+            "audio": audio,
+            "prompt_extend": prompt_extend,
+            "audio_url": audio_url,
+            "callback_url": callback_url,
+        }
+
+        result = client.generate_video(**payload)  # type: ignore[arg-type]
+        if output_json:
+            print_json(result)
+        else:
+            print_video_result(result)
+    except WanError as e:
+        print_error(e.message)
+        raise SystemExit(1) from e
+
+
+@click.command("image-to-video")
+@click.argument("prompt")
+@click.option(
+    "-i",
+    "--image-url",
+    required=True,
+    help="URL of the start image (first frame of the generated video).",
+)
+@click.option(
+    "-m",
+    "--model",
+    type=click.Choice(WAN_MODELS),
+    default="wan2.6-i2v",
+    help="Wan model version.",
+)
+@click.option(
+    "-r",
+    "--resolution",
+    type=click.Choice(RESOLUTIONS),
+    default=None,
+    help="Output resolution (480P, 720P, 1080P).",
+)
+@click.option(
+    "--shot-type",
+    type=click.Choice(SHOT_TYPES),
+    default=None,
+    help="Shot type: single continuous shot or multi switching shots.",
+)
+@click.option(
+    "--duration",
+    type=click.Choice([str(d) for d in DURATIONS]),
+    default=None,
+    help="Duration in seconds (5, 10, 15).",
+)
+@click.option(
+    "--negative-prompt",
+    default=None,
+    help="Reverse prompt words describing content to exclude from the video.",
+)
+@click.option(
+    "--size",
+    default=None,
+    help="The size of the generated video.",
+)
+@click.option(
+    "--audio/--no-audio",
+    default=None,
+    help="Whether the generated video has sound.",
+)
+@click.option(
+    "--prompt-extend/--no-prompt-extend",
+    default=None,
+    help="Enable prompt intelligent rewriting.",
+)
+@click.option(
+    "--audio-url",
+    default=None,
+    help="URL of an audio file to use in the generated video.",
+)
+@click.option(
+    "--reference-video-urls",
+    default=None,
+    help="Reference video file URL for character/timbre extraction.",
+)
+@click.option("--callback-url", default=None, help="Webhook callback URL.")
+@click.option("--json", "output_json", is_flag=True, help="Output raw JSON.")
+@click.pass_context
+def image_to_video(
+    ctx: click.Context,
+    prompt: str,
+    image_url: str,
+    model: str,
+    resolution: str | None,
+    shot_type: str | None,
+    duration: str | None,
+    negative_prompt: str | None,
+    size: str | None,
+    audio: bool | None,
+    prompt_extend: bool | None,
+    audio_url: str | None,
+    reference_video_urls: str | None,
+    callback_url: str | None,
+    output_json: bool,
+) -> None:
+    """Generate a video from a reference image.
+
+    PROMPT describes the desired video. Provide an image URL as the first frame.
+
+    Examples:
+
+      wan image-to-video "Animate this scene" -i https://example.com/photo.jpg
+
+      wan image-to-video "Bring to life" -i https://cdn.acedata.cloud/r9vsv9.png -m wan2.6-i2v
+    """
+    client = get_client(ctx.obj.get("token"))
+    try:
+        payload: dict[str, object] = {
+            "action": "image2video",
+            "prompt": prompt,
+            "model": model,
+            "image_url": image_url,
+            "resolution": resolution,
+            "shot_type": shot_type,
+            "duration": int(duration) if duration is not None else None,
+            "negative_prompt": negative_prompt,
+            "size": size,
+            "audio": audio,
+            "prompt_extend": prompt_extend,
+            "audio_url": audio_url,
+            "reference_video_urls": reference_video_urls,
+            "callback_url": callback_url,
+        }
+
+        result = client.generate_video(**payload)  # type: ignore[arg-type]
+        if output_json:
+            print_json(result)
+        else:
+            print_video_result(result)
+    except WanError as e:
+        print_error(e.message)
+        raise SystemExit(1) from e

wan_cli/core/__init__.py

@@ -0,0 +1 @@
+"""Core modules for Wan CLI."""

wan_cli/core/client.py

@@ -0,0 +1,107 @@
+"""HTTP client for Wan API."""
+
+from typing import Any
+
+import httpx
+
+from wan_cli.core.config import settings
+from wan_cli.core.exceptions import (
+    WanAPIError,
+    WanAuthError,
+    WanTimeoutError,
+)
+
+
+class WanClient:
+    """HTTP client for AceDataCloud Wan API."""
+
+    def __init__(self, api_token: str | None = None, base_url: str | None = None):
+        self.api_token = api_token if api_token is not None else settings.api_token
+        self.base_url = base_url or settings.api_base_url
+        self.timeout = settings.request_timeout
+
+    def _get_headers(self) -> dict[str, str]:
+        """Get request headers with authentication."""
+        if not self.api_token:
+            raise WanAuthError("API token not configured")
+        return {
+            "accept": "application/json",
+            "authorization": f"Bearer {self.api_token}",
+            "content-type": "application/json",
+        }
+
+    def request(
+        self,
+        endpoint: str,
+        payload: dict[str, Any],
+        timeout: float | None = None,
+    ) -> dict[str, Any]:
+        """Make a POST request to the Wan API.
+
+        Args:
+            endpoint: API endpoint path
+            payload: Request body as dictionary
+            timeout: Optional timeout override
+
+        Returns:
+            API response as dictionary
+        """
+        url = f"{self.base_url}{endpoint}"
+        request_timeout = timeout or self.timeout
+
+        # Remove None values from payload
+        payload = {k: v for k, v in payload.items() if v is not None}
+
+        with httpx.Client() as http_client:
+            try:
+                response = http_client.post(
+                    url,
+                    json=payload,
+                    headers=self._get_headers(),
+                    timeout=request_timeout,
+                )
+
+                if response.status_code == 401:
+                    raise WanAuthError("Invalid API token")
+
+                if response.status_code == 403:
+                    raise WanAuthError("Access denied. Check your API permissions.")
+
+                response.raise_for_status()
+                return response.json()  # type: ignore[no-any-return]
+
+            except httpx.TimeoutException as e:
+                raise WanTimeoutError(
+                    f"Request to {endpoint} timed out after {request_timeout}s"
+                ) from e
+
+            except WanAuthError:
+                raise
+
+            except httpx.HTTPStatusError as e:
+                raise WanAPIError(
+                    message=e.response.text,
+                    code=f"http_{e.response.status_code}",
+                    status_code=e.response.status_code,
+                ) from e
+
+            except Exception as e:
+                if isinstance(e, (WanAPIError, WanTimeoutError)):
+                    raise
+                raise WanAPIError(message=str(e)) from e
+
+    # Convenience methods
+    def generate_video(self, **kwargs: Any) -> dict[str, Any]:
+        """Generate video using the main endpoint."""
+        return self.request("/wan/videos", kwargs)
+
+    def query_task(self, **kwargs: Any) -> dict[str, Any]:
+        """Query task status using the tasks endpoint."""
+        return self.request("/wan/tasks", kwargs)
+
+
+def get_client(token: str | None = None) -> WanClient:
+    """Get a WanClient instance, optionally overriding the token."""
+    if token:
+        return WanClient(api_token=token)
+    return WanClient()

wan_cli/core/config.py

@@ -0,0 +1,42 @@
+"""Configuration management for Wan CLI."""
+
+import os
+from dataclasses import dataclass, field
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+@dataclass
+class Settings:
+    """Application settings loaded from environment variables."""
+
+    api_base_url: str = field(
+        default_factory=lambda: os.environ.get(
+            "ACEDATACLOUD_API_BASE_URL", "https://api.acedata.cloud"
+        )
+    )
+    api_token: str = field(default_factory=lambda: os.environ.get("ACEDATACLOUD_API_TOKEN", ""))
+    request_timeout: float = field(
+        default_factory=lambda: float(os.environ.get("WAN_REQUEST_TIMEOUT", "1800"))
+    )
+    default_model: str = field(
+        default_factory=lambda: os.environ.get("WAN_DEFAULT_MODEL", "wan2.6-t2v")
+    )
+
+    @property
+    def is_configured(self) -> bool:
+        """Check if the API token is configured."""
+        return bool(self.api_token)
+
+    def validate(self) -> None:
+        """Validate configuration. Raises ValueError if API token is missing."""
+        if not self.api_token:
+            raise ValueError(
+                "API token not configured. "
+                "Set ACEDATACLOUD_API_TOKEN environment variable or use --token option."
+            )
+
+
+settings = Settings()

wan_cli/core/exceptions.py

@@ -0,0 +1,37 @@
+"""Custom exceptions for Wan CLI."""
+
+
+class WanError(Exception):
+    """Base exception for Wan CLI."""
+
+    def __init__(self, message: str, code: str = "unknown"):
+        self.message = message
+        self.code = code
+        super().__init__(message)
+
+
+class WanAuthError(WanError):
+    """Authentication error."""
+
+    def __init__(self, message: str = "Authentication failed"):
+        super().__init__(message, code="auth_error")
+
+
+class WanAPIError(WanError):
+    """API error with HTTP status code."""
+
+    def __init__(
+        self,
+        message: str = "API request failed",
+        code: str = "api_error",
+        status_code: int | None = None,
+    ):
+        self.status_code = status_code
+        super().__init__(message, code)
+
+
+class WanTimeoutError(WanError):
+    """Request timeout error."""
+
+    def __init__(self, message: str = "Request timed out"):
+        super().__init__(message, code="timeout_error")

wan_cli/core/output.py

@@ -0,0 +1,147 @@
+"""Rich terminal output formatting for Wan CLI."""
+
+import json
+from typing import Any
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+console = Console()
+
+# Available models
+WAN_MODELS = [
+    "wan2.6-t2v",
+    "wan2.6-i2v",
+    "wan2.6-i2v-flash",
+    "wan2.6-r2v",
+]
+
+DEFAULT_MODEL = "wan2.6-t2v"
+
+# Available resolutions
+RESOLUTIONS = [
+    "480P",
+    "720P",
+    "1080P",
+]
+
+# Available shot types
+SHOT_TYPES = [
+    "single",
+    "multi",
+]
+
+# Available durations (seconds)
+DURATIONS = [5, 10, 15]
+
+
+def print_json(data: Any) -> None:
+    """Print data as formatted JSON."""
+    console.print(json.dumps(data, indent=2, ensure_ascii=False))
+
+
+def print_error(message: str) -> None:
+    """Print an error message."""
+    console.print(f"[bold red]Error:[/bold red] {message}")
+
+
+def print_success(message: str) -> None:
+    """Print a success message."""
+    console.print(f"[bold green]✓[/bold green] {message}")
+
+
+def print_video_result(data: dict[str, Any]) -> None:
+    """Print video generation result in a rich format."""
+    task_id = data.get("task_id", "N/A")
+    trace_id = data.get("trace_id", "N/A")
+    items = data.get("data", [])
+
+    console.print(
+        Panel(
+            f"[bold]Task ID:[/bold] {task_id}\n[bold]Trace ID:[/bold] {trace_id}",
+            title="[bold green]Video Result[/bold green]",
+            border_style="green",
+        )
+    )
+
+    if not items:
+        console.print("[yellow]No data available yet. Use 'task' to check status.[/yellow]")
+        return
+
+    if isinstance(items, list):
+        for i, item in enumerate(items, 1):
+            table = Table(show_header=False, box=None, padding=(0, 2))
+            table.add_column("Field", style="bold cyan", width=15)
+            table.add_column("Value")
+            table.add_row("Video", f"#{i}")
+            if item.get("video_url"):
+                table.add_row("URL", item["video_url"])
+            if item.get("state"):
+                table.add_row("State", item["state"])
+            if item.get("model_name"):
+                table.add_row("Model", item["model_name"])
+            if item.get("created_at"):
+                table.add_row("Created", item["created_at"])
+            console.print(table)
+            console.print()
+
+
+def print_task_result(data: dict[str, Any]) -> None:
+    """Print task query result in a rich format."""
+    tasks = data.get("data", [])
+
+    if isinstance(tasks, list):
+        for task_data in tasks:
+            table = Table(show_header=False, box=None, padding=(0, 2))
+            table.add_column("Field", style="bold cyan", width=15)
+            table.add_column("Value")
+
+            for key in ["id", "status", "state", "video_url", "model_name", "created_at"]:
+                if task_data.get(key):
+                    table.add_row(key.replace("_", " ").title(), str(task_data[key]))
+
+            console.print(table)
+            console.print()
+    elif isinstance(tasks, dict):
+        table = Table(show_header=False, box=None, padding=(0, 2))
+        table.add_column("Field", style="bold cyan", width=15)
+        table.add_column("Value")
+
+        for key in ["id", "status", "state", "video_url", "model_name", "created_at"]:
+            if tasks.get(key):
+                table.add_row(key.replace("_", " ").title(), str(tasks[key]))
+
+        console.print(table)
+
+
+def print_models() -> None:
+    """Print available Wan models."""
+    table = Table(title="Available Wan Models")
+    table.add_column("Model", style="bold cyan")
+    table.add_column("Type", style="bold")
+    table.add_column("Notes")
+
+    table.add_row(
+        "wan2.6-t2v",
+        "Text-to-Video",
+        "Text-to-video generation (default)",
+    )
+    table.add_row(
+        "wan2.6-i2v",
+        "Image-to-Video",
+        "Image-to-video generation",
+    )
+    table.add_row(
+        "wan2.6-i2v-flash",
+        "Image-to-Video Flash",
+        "Fast image-to-video generation",
+    )
+    table.add_row(
+        "wan2.6-r2v",
+        "Reference-to-Video",
+        "Reference video-to-video generation",
+    )
+
+    console.print(table)
+    console.print(f"\n[dim]Default model: {DEFAULT_MODEL}[/dim]")

wan_cli/main.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""
+Wan CLI - AI Wan Video Generation via AceDataCloud API.
+
+A command-line tool for generating AI videos using Tongyi Wansiang
+through the AceDataCloud platform.
+"""
+
+from importlib import metadata
+
+import click
+from dotenv import load_dotenv
+
+from wan_cli.commands.info import config, models, resolutions
+from wan_cli.commands.task import task, tasks_batch, wait
+from wan_cli.commands.video import generate, image_to_video
+
+load_dotenv()
+
+
+def get_version() -> str:
+    """Get the package version."""
+    try:
+        return metadata.version("wan-cli")
+    except metadata.PackageNotFoundError:
+        return "dev"
+
+
+@click.group()
+@click.version_option(version=get_version(), prog_name="wan-cli")
+@click.option(
+    "--token",
+    envvar="ACEDATACLOUD_API_TOKEN",
+    help="API token (or set ACEDATACLOUD_API_TOKEN env var).",
+)
+@click.pass_context
+def cli(ctx: click.Context, token: str | None) -> None:
+    """Wan CLI - AI Video Generation powered by AceDataCloud.
+
+    Generate AI videos from the command line using Tongyi Wansiang.
+
+    Get your API token at https://platform.acedata.cloud
+
+    \b
+    Examples:
+      wan generate "Astronauts shuttle from space to volcano"
+      wan image-to-video "Animate this scene" -i https://example.com/photo.jpg
+      wan task abc123-def456
+      wan wait abc123 --interval 5
+
+    Set your token:
+      export ACEDATACLOUD_API_TOKEN=your_token
+    """
+    ctx.ensure_object(dict)
+    ctx.obj["token"] = token
+
+
+# Register commands
+cli.add_command(generate)
+cli.add_command(image_to_video)
+cli.add_command(task)
+cli.add_command(tasks_batch)
+cli.add_command(wait)
+cli.add_command(models)
+cli.add_command(config)
+cli.add_command(resolutions)
+
+
+if __name__ == "__main__":
+    cli()

wan_cli-2026.4.5.0.dist-info/METADATA

@@ -0,0 +1,240 @@
+Metadata-Version: 2.1
+Name: wan-cli
+Version: 2026.4.5.0
+Summary: CLI tool for Tongyi Wansiang AI Video Generation via AceDataCloud API
+Project-URL: Homepage, https://github.com/AceDataCloud/WanCli
+Project-URL: Repository, https://github.com/AceDataCloud/WanCli
+Project-URL: Issues, https://github.com/AceDataCloud/WanCli/issues
+Project-URL: Changelog, https://github.com/AceDataCloud/WanCli/blob/main/CHANGELOG.md
+Author-email: AceDataCloud <support@acedata.cloud>
+Maintainer-email: AceDataCloud <support@acedata.cloud>
+License: MIT
+License-File: LICENSE
+Keywords: acedata,ai,cli,command-line,generation,video,wan,wansiang
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: click>=8.1.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: all
+Requires-Dist: wan-cli[dev,release,test]; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10.0; extra == 'dev'
+Requires-Dist: pre-commit>=3.7.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Provides-Extra: release
+Requires-Dist: build>=1.2.0; extra == 'release'
+Requires-Dist: twine>=6.1.0; extra == 'release'
+Provides-Extra: test
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'test'
+Requires-Dist: pytest-cov>=5.0.0; extra == 'test'
+Requires-Dist: pytest>=8.0.0; extra == 'test'
+Requires-Dist: respx>=0.21.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# Wan CLI
+
+[![PyPI version](https://img.shields.io/pypi/v/wan-cli.svg)](https://pypi.org/project/wan-cli/)
+[![PyPI downloads](https://img.shields.io/pypi/dm/wan-cli.svg)](https://pypi.org/project/wan-cli/)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A command-line tool for AI video generation using [Tongyi Wansiang](https://platform.acedata.cloud/) through the [AceDataCloud API](https://platform.acedata.cloud/).
+
+Generate AI videos directly from your terminal — no MCP client required.
+
+## Features
+
+- **Video Generation** — Generate videos from text prompts with multiple models
+- **Image-to-Video** — Create videos from reference images
+- **Multiple Models** — wan2.6-t2v, wan2.6-i2v, wan2.6-i2v-flash, wan2.6-r2v
+- **Task Management** — Query tasks, batch query, wait with polling
+- **Rich Output** — Beautiful terminal tables and panels via Rich
+- **JSON Mode** — Machine-readable output with `--json` for piping
+
+## Quick Start
+
+### 1. Get API Token
+
+Get your API token from [AceDataCloud Platform](https://platform.acedata.cloud/):
+
+1. Sign up or log in
+2. Navigate to the Wan API page
+3. Click "Acquire" to get your token
+
+### 2. Install
+
+```bash
+# Install with pip
+pip install wan-cli
+
+# Or with uv (recommended)
+uv pip install wan-cli
+
+# Or from source
+git clone https://github.com/AceDataCloud/WanCli.git
+cd WanCli
+pip install -e .
+```
+
+### 3. Configure
+
+```bash
+# Set your API token
+export ACEDATACLOUD_API_TOKEN=your_token_here
+
+# Or use .env file
+cp .env.example .env
+# Edit .env with your token
+```
+
+### 4. Use
+
+```bash
+# Generate a video from text
+wan generate "Astronauts shuttle from space to volcano"
+
+# Generate from reference image
+wan image-to-video "Animate this scene" -i https://example.com/photo.jpg
+
+# Check task status
+wan task <task-id>
+
+# Wait for completion
+wan wait <task-id> --interval 5
+
+# List available models
+wan models
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `wan generate <prompt>` | Generate a video from a text prompt |
+| `wan image-to-video <prompt> -i <url>` | Generate a video from a reference image |
+| `wan task <task_id>` | Query a single task status |
+| `wan tasks <id1> <id2>...` | Query multiple tasks at once |
+| `wan wait <task_id>` | Wait for task completion with polling |
+| `wan models` | List available Wan models |
+| `wan resolutions` | List available resolutions |
+| `wan config` | Show current configuration |
+
+
+## Global Options
+
+```
+--token TEXT    API token (or set ACEDATACLOUD_API_TOKEN env var)
+--version       Show version
+--help          Show help message
+```
+
+Most commands support:
+
+```
+--json                        Output raw JSON (for piping/scripting)
+--model TEXT                  Wan model version (default: wan2.6-t2v)
+--resolution TEXT             Output resolution: 480P, 720P, 1080P
+--duration TEXT               Duration in seconds: 5, 10, 15
+--shot-type TEXT              Shot type: single, multi
+--audio/--no-audio            Whether the video has sound
+--prompt-extend/--no-prompt-extend  Enable prompt intelligent rewriting
+```
+
+## Available Models
+
+| Model | Type | Notes |
+|-------|------|-------|
+| `wan2.6-t2v` | Text-to-Video | Text-to-video generation (default) |
+| `wan2.6-i2v` | Image-to-Video | Image-to-video generation |
+| `wan2.6-i2v-flash` | Image-to-Video Flash | Fast image-to-video generation |
+| `wan2.6-r2v` | Reference-to-Video | Reference video-to-video generation |
+
+
+## Configuration
+
+### Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `ACEDATACLOUD_API_TOKEN` | API token from AceDataCloud | *Required* |
+| `ACEDATACLOUD_API_BASE_URL` | API base URL | `https://api.acedata.cloud` |
+| `WAN_DEFAULT_MODEL` | Default model | `wan2.6-t2v` |
+| `WAN_REQUEST_TIMEOUT` | Timeout in seconds | `1800` |
+
+## Development
+
+### Setup Development Environment
+
+```bash
+git clone https://github.com/AceDataCloud/WanCli.git
+cd WanCli
+python -m venv .venv
+source .venv/bin/activate
+pip install -e ".[dev,test]"
+```
+
+### Run Tests
+
+```bash
+pytest
+pytest --cov=wan_cli
+pytest tests/test_integration.py -m integration
+```
+
+### Code Quality
+
+```bash
+ruff format .
+ruff check .
+mypy wan_cli
+```
+
+## Docker
+
+```bash
+docker pull ghcr.io/acedatacloud/wan-cli:latest
+docker run --rm -e ACEDATACLOUD_API_TOKEN=your_token \
+  ghcr.io/acedatacloud/wan-cli generate "Astronauts shuttle from space to volcano"
+```
+
+## Project Structure
+
+```
+WanCli/
+├── wan_cli/                # Main package
+│   ├── __init__.py
+│   ├── __main__.py            # python -m wan_cli entry point
+│   ├── main.py                # CLI entry point
+│   ├── core/                  # Core modules
+│   │   ├── client.py          # HTTP client for Wan API
+│   │   ├── config.py          # Configuration management
+│   │   ├── exceptions.py      # Custom exceptions
+│   │   └── output.py          # Rich terminal formatting
+│   └── commands/              # CLI command groups
+│       ├── video.py           # Video generation commands
+│       ├── task.py            # Task management commands
+│       └── info.py            # Info & utility commands
+├── tests/                     # Test suite
+├── Dockerfile                 # Container image
+├── deploy/                    # Kubernetes deployment configs
+├── .env.example               # Environment template
+├── pyproject.toml             # Project configuration
+└── README.md
+```
+
+## License
+
+This project is licensed under the MIT License — see the [LICENSE](LICENSE) file for details.

wan_cli-2026.4.5.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+wan_cli/__init__.py,sha256=nHLkZapgmJKNo-QvREDqooX3crOEkOpnMcb5mwQQzag,62
+wan_cli/__main__.py,sha256=NyDlpzzSVkOk1qeIBJNZ3CfvbSep1EHkoDze4-VN_Qk,79
+wan_cli/main.py,sha256=opT-V4PX5gGHrpVgvhmBGzJ4FxLHH1LaammowOkwLWg,1750
+wan_cli/commands/__init__.py,sha256=Ek6-G6X1l1Kielt8A9AGNn-97cA38Pe_JYFOh5oHnJM,32
+wan_cli/commands/info.py,sha256=VmfiTWNAi1jm6SxbNvTNicPKZhqfBtiz6G3Bx1OSpMg,1342
+wan_cli/commands/task.py,sha256=15S2g_mEDbrI06jXKQQ3XnJ9I18VRcGKqcYUCOlLnj0,3822
+wan_cli/commands/video.py,sha256=TtmjanhX9ktFms-cpeTUC79-ZAJfBN7ruI82S5V01V4,6549
+wan_cli/core/__init__.py,sha256=4cMiAtLO3dwtXDz84rIuf_cvHumiOGzP_A4erTeOZy8,32
+wan_cli/core/client.py,sha256=d36EURx2PxIG67sHA-FGLCus0kUT3L2GSCjKeiz1kus,3443
+wan_cli/core/config.py,sha256=v7fuzBFsYpQm5lKlOnwK4KgAkyf2gpB3tSC7Cu_IZcQ,1234
+wan_cli/core/exceptions.py,sha256=4kJ7Vyy4o9AYOM2_CF_OYTnAqm45Ipdcia1WQxxrbW0,934
+wan_cli/core/output.py,sha256=BvOlB-D67ckfDpCQHh7oRfx4Ap29CEaiUliMPLCGzEo,4185
+wan_cli-2026.4.5.0.dist-info/METADATA,sha256=t6n1LBjvNNce5bRSFx5loDUdAMunr1NyAEp4gLqMxD0,7747
+wan_cli-2026.4.5.0.dist-info/WHEEL,sha256=TJPnKdtrSue7xZ_AVGkp9YXcvDrobsjBds1du3Nx6dc,87
+wan_cli-2026.4.5.0.dist-info/entry_points.txt,sha256=1UwUc_zV-y_LbAbSGvVwCQUk0VbucYvk1QlhJGxYXjY,68
+wan_cli-2026.4.5.0.dist-info/licenses/LICENSE,sha256=bxZ4efJS6INmQdLVfyxLQXtLCEaj-ORFNew2MaGiZ8E,1069
+wan_cli-2026.4.5.0.dist-info/RECORD,,

wan_cli-2026.4.5.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.21.1
+Root-Is-Purelib: true
+Tag: py3-none-any

wan_cli-2026.4.5.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+wan = wan_cli.main:cli
+wan-cli = wan_cli.main:cli

wan_cli-2026.4.5.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AceDataCloud
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.