hailuo-cli 2026.7.31.0__py3-none-any.whl

hailuo_cli/__init__.py

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

hailuo_cli/__main__.py

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

hailuo_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""Commands package for Hailuo CLI."""

hailuo_cli/commands/info.py

@@ -0,0 +1,30 @@
+"""Info and utility commands."""
+
+import click
+
+from hailuo_cli.core.config import settings
+from hailuo_cli.core.output import console, print_models
+
+
+@click.command()
+def models() -> None:
+    """List available Hailuo models."""
+    print_models()
+
+
+@click.command()
+def config() -> None:
+    """Show current configuration."""
+    from rich.table import Table
+
+    table = Table(title="Hailuo 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("Request Timeout", f"{settings.request_timeout}s")
+
+    console.print(table)

hailuo_cli/commands/task.py

@@ -0,0 +1,160 @@
+"""Task management commands."""
+
+import time
+
+import click
+
+from hailuo_cli.core.client import get_client
+from hailuo_cli.core.exceptions import HailuoError
+from hailuo_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.
+
+    \b
+    Examples:
+      hailuo 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 HailuoError 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.
+
+    \b
+    Examples:
+      hailuo 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 HailuoError 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.
+
+    \b
+    Examples:
+      hailuo wait abc123
+      hailuo 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")
+
+            # Check for completion signals
+            data = result.get("data", result)
+            if isinstance(data, dict):
+                item = data
+            elif isinstance(data, list) and data:
+                item = data[0]
+            else:
+                item = result
+
+            state = item.get("state", item.get("status", ""))
+            video_url = item.get("video_url") or result.get("video_url")
+            error = item.get("error") or result.get("error")
+
+            if error:
+                if output_json:
+                    print_json(result)
+                else:
+                    print_error(f"Task {task_id} failed: {error}")
+                raise SystemExit(1)
+
+            if state in ("succeeded", "completed", "complete") or video_url:
+                if output_json:
+                    print_json(result)
+                else:
+                    print_success(f"Task {task_id} completed!")
+                    print_task_result(result)
+                return
+
+            if state in ("failed", "error"):
+                if output_json:
+                    print_json(result)
+                else:
+                    print_error(f"Task {task_id} failed.")
+                raise SystemExit(1)
+
+            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 HailuoError as e:
+        print_error(e.message)
+        raise SystemExit(1) from e

hailuo_cli/commands/video.py

@@ -0,0 +1,128 @@
+"""Video generation commands."""
+
+import click
+
+from hailuo_cli.core.client import get_client
+from hailuo_cli.core.exceptions import HailuoError
+from hailuo_cli.core.output import (
+    DEFAULT_MODEL,
+    HAILUO_MODELS,
+    print_error,
+    print_json,
+    print_video_result,
+)
+
+
+@click.command()
+@click.argument("prompt")
+@click.option(
+    "-m",
+    "--model",
+    type=click.Choice(HAILUO_MODELS),
+    default=DEFAULT_MODEL,
+    help="Hailuo model to use (default: minimax-t2v).",
+)
+@click.option("--callback-url", default=None, help="Webhook callback URL.")
+@click.option(
+    "--async",
+    "async_mode",
+    is_flag=True,
+    default=False,
+    help="Submit asynchronously; returns a task_id to poll instead of waiting.",
+)
+@click.option("--json", "output_json", is_flag=True, help="Output raw JSON.")
+@click.pass_context
+def generate(
+    ctx: click.Context,
+    prompt: str,
+    model: str,
+    callback_url: str | None,
+    async_mode: bool,
+    output_json: bool,
+) -> None:
+    """Generate a video from a text prompt.
+
+    PROMPT is a detailed description of what to generate.
+
+    \b
+    Examples:
+      hailuo generate "A cat playing in the snow"
+      hailuo generate "Ocean waves at sunset" --model minimax-t2v
+    """
+    client = get_client(ctx.obj.get("token"))
+    try:
+        payload: dict[str, object] = {
+            "action": "generate",
+            "prompt": prompt,
+            "model": model,
+            "callback_url": callback_url,
+            "async": async_mode,
+        }
+
+        result = client.generate_video(**payload)  # type: ignore[arg-type]
+        if output_json:
+            print_json(result)
+        else:
+            print_video_result(result)
+    except HailuoError as e:
+        print_error(e.message)
+        raise SystemExit(1) from e
+
+
+@click.command("image-to-video")
+@click.argument("prompt")
+@click.option("--image-url", required=True, help="URL of the first frame reference image.")
+@click.option(
+    "-m",
+    "--model",
+    type=click.Choice(["minimax-i2v", "minimax-t2v", "minimax-i2v-director"]),
+    default="minimax-i2v",
+    help="Hailuo image-to-video model (default: minimax-i2v).",
+)
+@click.option("--callback-url", default=None, help="Webhook callback URL.")
+@click.option(
+    "--async",
+    "async_mode",
+    is_flag=True,
+    default=False,
+    help="Submit asynchronously; returns a task_id to poll instead of waiting.",
+)
+@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,
+    callback_url: str | None,
+    async_mode: bool,
+    output_json: bool,
+) -> None:
+    """Generate a video from an image and text prompt.
+
+    PROMPT describes the desired video content.
+
+    \b
+    Examples:
+      hailuo image-to-video "Animate this scene" --image-url https://example.com/photo.jpg
+      hailuo image-to-video "Cinematic pan" --image-url img.jpg --model minimax-i2v-director
+    """
+    client = get_client(ctx.obj.get("token"))
+    try:
+        payload: dict[str, object] = {
+            "action": "generate",
+            "prompt": prompt,
+            "model": model,
+            "first_image_url": image_url,
+            "callback_url": callback_url,
+            "async": async_mode,
+        }
+
+        result = client.generate_video(**payload)  # type: ignore[arg-type]
+        if output_json:
+            print_json(result)
+        else:
+            print_video_result(result)
+    except HailuoError as e:
+        print_error(e.message)
+        raise SystemExit(1) from e

hailuo_cli/core/__init__.py

@@ -0,0 +1 @@
+"""Core package for Hailuo CLI."""

hailuo_cli/core/client.py

@@ -0,0 +1,107 @@
+"""HTTP client for Hailuo API."""
+
+from typing import Any
+
+import httpx
+
+from hailuo_cli.core.config import settings
+from hailuo_cli.core.exceptions import (
+    HailuoAPIError,
+    HailuoAuthError,
+    HailuoTimeoutError,
+)
+
+
+class HailuoClient:
+    """HTTP client for AceDataCloud Hailuo 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 HailuoAuthError("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 Hailuo 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 HailuoAuthError("Invalid API token")
+
+                if response.status_code == 403:
+                    raise HailuoAuthError("Access denied. Check your API permissions.")
+
+                response.raise_for_status()
+                return response.json()  # type: ignore[no-any-return]
+
+            except httpx.TimeoutException as e:
+                raise HailuoTimeoutError(
+                    f"Request to {endpoint} timed out after {request_timeout}s"
+                ) from e
+
+            except HailuoAuthError:
+                raise
+
+            except httpx.HTTPStatusError as e:
+                raise HailuoAPIError(
+                    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, HailuoAPIError | HailuoTimeoutError):
+                    raise
+                raise HailuoAPIError(message=str(e)) from e
+
+    # Convenience methods
+    def generate_video(self, **kwargs: Any) -> dict[str, Any]:
+        """Generate video using the videos endpoint."""
+        return self.request("/hailuo/videos", kwargs)
+
+    def query_task(self, **kwargs: Any) -> dict[str, Any]:
+        """Query task status using the tasks endpoint."""
+        return self.request("/hailuo/tasks", kwargs)
+
+
+def get_client(token: str | None = None) -> HailuoClient:
+    """Get a HailuoClient instance, optionally overriding the token."""
+    if token:
+        return HailuoClient(api_token=token)
+    return HailuoClient()

hailuo_cli/core/config.py

@@ -0,0 +1,39 @@
+"""Configuration management for Hailuo 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("HAILUO_REQUEST_TIMEOUT", "1800"))
+    )
+
+    @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()

hailuo_cli/core/exceptions.py

@@ -0,0 +1,37 @@
+"""Custom exceptions for Hailuo CLI."""
+
+
+class HailuoError(Exception):
+    """Base exception for Hailuo CLI."""
+
+    def __init__(self, message: str, code: str = "unknown"):
+        self.message = message
+        self.code = code
+        super().__init__(message)
+
+
+class HailuoAuthError(HailuoError):
+    """Authentication error."""
+
+    def __init__(self, message: str = "Authentication failed"):
+        super().__init__(message, code="auth_error")
+
+
+class HailuoAPIError(HailuoError):
+    """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 HailuoTimeoutError(HailuoError):
+    """Request timeout error."""
+
+    def __init__(self, message: str = "Request timed out"):
+        super().__init__(message, code="timeout_error")

hailuo_cli/core/output.py

@@ -0,0 +1,116 @@
+"""Rich terminal output formatting for Hailuo 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
+HAILUO_MODELS = [
+    "minimax-t2v",
+    "minimax-i2v",
+    "minimax-i2v-director",
+]
+
+DEFAULT_MODEL = "minimax-t2v"
+
+
+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]\u2713[/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")
+
+    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",
+        )
+    )
+
+    video_url = data.get("video_url")
+    if video_url:
+        console.print(f"[bold]Video URL:[/bold] {video_url}")
+    elif not data.get("task_id"):
+        console.print("[yellow]No video available yet. Use 'task' to check status.[/yellow]")
+    else:
+        console.print("[yellow]Video is being generated. Use 'task' to check status.[/yellow]")
+
+
+def print_task_result(data: dict[str, Any]) -> None:
+    """Print task query result in a rich format."""
+    # Handle single task response
+    if isinstance(data.get("data"), dict):
+        task_data = data["data"]
+        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", "created_at"]:
+            if task_data.get(key):
+                table.add_row(key.replace("_", " ").title(), str(task_data[key]))
+        console.print(table)
+        return
+
+    # Handle batch response
+    items = data.get("data", [])
+    if isinstance(items, list) and items:
+        for item in items:
+            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", "created_at"]:
+                if item.get(key):
+                    table.add_row(key.replace("_", " ").title(), str(item[key]))
+            console.print(table)
+            console.print()
+        return
+
+    # Handle direct top-level task fields
+    if data.get("task_id") or data.get("video_url"):
+        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 ["task_id", "video_url", "model", "status", "state"]:
+            val = data.get(key)
+            if val:
+                table.add_row(key.replace("_", " ").title(), str(val))
+        console.print(table)
+        return
+
+    console.print("[yellow]No data available.[/yellow]")
+
+
+def print_models() -> None:
+    """Print available Hailuo models."""
+    table = Table(title="Available Hailuo Models")
+    table.add_column("Model", style="bold cyan")
+    table.add_column("Type")
+    table.add_column("Notes")
+
+    table.add_row("minimax-t2v", "Text-to-Video", "Generate video from text prompt (default)")
+    table.add_row("minimax-i2v", "Image-to-Video", "Generate video from image + text")
+    table.add_row(
+        "minimax-i2v-director", "Image-to-Video", "Cinematic director mode with image reference"
+    )
+
+    console.print(table)
+    console.print(f"\n[dim]Default model: {DEFAULT_MODEL}[/dim]")

hailuo_cli/main.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""
+Hailuo CLI - AI Video Generation via AceDataCloud API.
+
+A command-line tool for generating AI videos using Hailuo (MiniMax)
+through the AceDataCloud platform.
+"""
+
+from importlib import metadata
+
+import click
+from dotenv import load_dotenv
+
+from hailuo_cli.commands.info import config, models
+from hailuo_cli.commands.task import task, tasks_batch, wait
+from hailuo_cli.commands.video import generate, image_to_video
+
+load_dotenv()
+
+
+def get_version() -> str:
+    """Get the package version."""
+    try:
+        return metadata.version("hailuo-cli")
+    except metadata.PackageNotFoundError:
+        return "dev"
+
+
+@click.group()
+@click.version_option(version=get_version(), prog_name="hailuo-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:
+    """Hailuo CLI - AI Video Generation powered by AceDataCloud.
+
+    Generate AI videos from the command line using Hailuo (MiniMax) models.
+
+    Get your API token at https://platform.acedata.cloud
+
+    \b
+    Examples:
+      hailuo generate "A cat playing in the snow"
+      hailuo image-to-video "Animate this" --image-url https://example.com/img.jpg
+      hailuo task abc123-def456
+      hailuo 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)
+
+
+if __name__ == "__main__":
+    cli()

hailuo_cli-2026.7.31.0.dist-info/METADATA

@@ -0,0 +1,162 @@
+Metadata-Version: 2.1
+Name: hailuo-cli
+Version: 2026.7.31.0
+Summary: CLI tool for Hailuo AI Video Generation via AceDataCloud API
+Project-URL: Homepage, https://github.com/AceDataCloud/HailuoCli
+Project-URL: Repository, https://github.com/AceDataCloud/HailuoCli
+Project-URL: Issues, https://github.com/AceDataCloud/HailuoCli/issues
+Project-URL: Changelog, https://github.com/AceDataCloud/HailuoCli/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,hailuo,minimax,video
+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: hailuo-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
+
+# Hailuo CLI
+
+A command-line tool for generating AI videos using [Hailuo (MiniMax)](https://platform.acedata.cloud) through the AceDataCloud platform.
+
+## Installation
+
+```bash
+pip install hailuo-cli
+```
+
+## Configuration
+
+```bash
+export ACEDATACLOUD_API_TOKEN=your_token
+```
+
+Or copy `.env.example` to `.env` and fill in your token.
+
+## Commands
+
+### Video Generation
+
+| Command | Description |
+|---------|-------------|
+| `hailuo generate <prompt>` | Generate a video from text (minimax-t2v) |
+| `hailuo image-to-video <prompt> --image-url <url>` | Generate video from image + text |
+
+### Task Management
+
+| Command | Description |
+|---------|-------------|
+| `hailuo task <task_id>` | Query a single task status |
+| `hailuo tasks <id1> <id2> [...]` | Query multiple tasks at once |
+| `hailuo wait <task_id>` | Wait for task completion with polling |
+
+### Utilities
+
+| Command | Description |
+|---------|-------------|
+| `hailuo models` | List available Hailuo models |
+| `hailuo 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)
+--callback-url  Webhook URL for async notifications
+```
+
+## Examples
+
+```bash
+# Generate a video from a text prompt
+hailuo generate "A cat playing in the snow"
+
+# Generate from image reference
+hailuo image-to-video "Animate the scene" --image-url https://example.com/photo.jpg
+
+# Use a specific model
+hailuo generate "Ocean waves" --model minimax-t2v
+
+# Director model with image reference
+hailuo image-to-video "Cinematic pan" --image-url img.jpg --model minimax-i2v-director
+
+# Check task status
+hailuo task abc123-def456
+
+# Wait for completion
+hailuo wait abc123 --timeout 300
+```
+
+## Docker
+
+```bash
+# Pull the image
+docker pull ghcr.io/acedatacloud/hailuo-cli:latest
+
+# Run a command
+docker run --rm -e ACEDATACLOUD_API_TOKEN=your_token \
+  ghcr.io/acedatacloud/hailuo-cli generate "A happy scene"
+
+# Or use docker-compose
+docker compose run --rm hailuo-cli generate "A happy scene"
+```
+
+## Project Structure
+
+```
+HailuoCli/
+├── hailuo_cli/             # Main package
+│   ├── __init__.py
+│   ├── __main__.py         # python -m hailuo_cli entry point
+│   ├── main.py             # CLI entry point
+│   ├── core/               # Core modules
+│   │   ├── client.py       # HTTP client for Hailuo 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 and utility commands
+└── tests/                  # Test suite
+```
+
+## License
+
+MIT License — see [LICENSE](LICENSE) for details.

hailuo_cli-2026.7.31.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+hailuo_cli/__init__.py,sha256=tfyP7ia1C4E4QR6UU8MJz438_v1sJ6h37RDpreKf2Sc,61
+hailuo_cli/__main__.py,sha256=iFzCKPwnD2OJCzyemVSV7CCrCHKZJTzExfJYRkhficU,85
+hailuo_cli/main.py,sha256=PMdxllo8wSYwMEqSiA5rpePkOp40tFMWhheCTlDP11g,1732
+hailuo_cli/commands/__init__.py,sha256=_1AM6pXttEBO3ZlftokfV_SBJ4ZqiCak2YCxaayKGNc,39
+hailuo_cli/commands/info.py,sha256=PI6HW8MZJhl4Oh11bAHKwjpIjad4FyCK_slPyUgf3n4,773
+hailuo_cli/commands/task.py,sha256=y8xqUZcKMcO64RMPBnX-D1RmBL0PdSq_zGnAKN_YI70,4311
+hailuo_cli/commands/video.py,sha256=v15XiXT0i_hpwJdaPCFSLSQLt1pMcBimTfJ3_oUJSL4,3587
+hailuo_cli/core/__init__.py,sha256=Ivx0Brt3XsJvJ-3Jj8Ix-CgwsxyMfui11PuBzJ2l8u8,35
+hailuo_cli/core/client.py,sha256=6UPNsmk_kq_lrIkiJWMZf1B84ee2FEJo8qGbGRekk2c,3516
+hailuo_cli/core/config.py,sha256=_9d-b8YC8cz6hkL0R3sDKESrxTvHqVm-VIOonCm-74E,1120
+hailuo_cli/core/exceptions.py,sha256=uh_M8fP1h9Evntk3J9ec3__Xz9UmSsWdgf4mmyHDONE,961
+hailuo_cli/core/output.py,sha256=Qs6-8hNdJ14aI85DayoUHkGhdfV1E-oHtewEdKtwRM8,3931
+hailuo_cli-2026.7.31.0.dist-info/METADATA,sha256=LSUlSfH5obcJurDEuNIneNnGfhw3s2sJ04Q6nKziY2M,5020
+hailuo_cli-2026.7.31.0.dist-info/WHEEL,sha256=TJPnKdtrSue7xZ_AVGkp9YXcvDrobsjBds1du3Nx6dc,87
+hailuo_cli-2026.7.31.0.dist-info/entry_points.txt,sha256=qLRpjcfXhQ_t-YmcQ--IVej3XYwEOoRnG0CWjf9NWJo,80
+hailuo_cli-2026.7.31.0.dist-info/licenses/LICENSE,sha256=bxZ4efJS6INmQdLVfyxLQXtLCEaj-ORFNew2MaGiZ8E,1069
+hailuo_cli-2026.7.31.0.dist-info/RECORD,,

hailuo_cli-2026.7.31.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

hailuo_cli-2026.7.31.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+hailuo = hailuo_cli.main:cli
+hailuo-cli = hailuo_cli.main:cli

hailuo_cli-2026.7.31.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.