kling-pro-cli 2026.6.30.0__py3-none-any.whl

kling_cli/__init__.py

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

kling_cli/__main__.py

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

kling_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""Kling CLI commands package."""

kling_cli/commands/info.py

@@ -0,0 +1,53 @@
+"""Info and utility commands."""
+
+import click
+
+from kling_cli.core.config import settings
+from kling_cli.core.output import ASPECT_RATIOS, console, print_models
+
+
+@click.command()
+def models() -> None:
+    """List available Kling models."""
+    print_models()
+
+
+@click.command("aspect-ratios")
+def aspect_ratios() -> None:
+    """List available aspect ratios."""
+    from rich.table import Table
+
+    table = Table(title="Available Aspect Ratios")
+    table.add_column("Ratio", style="bold cyan")
+    table.add_column("Orientation")
+
+    for ratio in ASPECT_RATIOS:
+        w, h = ratio.split(":")
+        if int(w) > int(h):
+            orientation = "Landscape"
+        elif int(w) < int(h):
+            orientation = "Portrait"
+        else:
+            orientation = "Square"
+        table.add_row(ratio, orientation)
+
+    console.print(table)
+
+
+@click.command()
+def config() -> None:
+    """Show current configuration."""
+    from rich.table import Table
+
+    table = Table(title="Kling 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)

kling_cli/commands/lipsync.py

@@ -0,0 +1,176 @@
+"""Lip-sync and talking-photo generation commands."""
+
+import click
+
+from kling_cli.core.client import get_client
+from kling_cli.core.exceptions import KlingError
+from kling_cli.core.output import print_error, print_json, print_video_result
+
+TALKING_PHOTO_MODELS = [
+    "kling-v1",
+    "kling-v1-6",
+    "kling-v2-master",
+    "kling-v2-1-master",
+    "kling-v2-5-turbo",
+    "kling-v2-6",
+]
+
+
+def _validate_duration(
+    _ctx: click.Context, _param: click.Parameter, value: int | None
+) -> int | None:
+    """Validate talking-photo duration."""
+    if value is None or value in {5, 10}:
+        return value
+    raise click.BadParameter("Must be 5 or 10.")
+
+
+@click.command("lip-sync")
+@click.option("--video-id", default=None, help="Kling source video ID.")
+@click.option("--video-url", default=None, help="Kling source video URL.")
+@click.option(
+    "--mode",
+    required=True,
+    type=click.Choice(["audio2video", "text2video"]),
+    help="Lip-sync mode.",
+)
+@click.option("--audio-url", default=None, help="Audio URL for audio2video mode.")
+@click.option(
+    "--audio-type",
+    type=click.Choice(["url", "file"]),
+    default=None,
+    help="Audio source type.",
+)
+@click.option("--audio-file", default=None, help="Path or content string for audio2video mode.")
+@click.option("--text", default=None, help="Text for text2video mode.")
+@click.option("--voice-id", default=None, help="Voice ID for text2video mode.")
+@click.option(
+    "--voice-language",
+    type=click.Choice(["zh", "en"]),
+    default=None,
+    help="Voice language for text2video mode.",
+)
+@click.option(
+    "--voice-speed",
+    default=None,
+    type=float,
+    help="Voice speed multiplier for text2video mode (1.0 = normal).",
+)
+@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 lip_sync(
+    ctx: click.Context,
+    video_id: str | None,
+    video_url: str | None,
+    mode: str,
+    audio_url: str | None,
+    audio_type: str | None,
+    audio_file: str | None,
+    text: str | None,
+    voice_id: str | None,
+    voice_language: str | None,
+    voice_speed: float | None,
+    callback_url: str | None,
+    async_mode: bool,
+    output_json: bool,
+) -> None:
+    """Generate a lip-sync video."""
+    client = get_client(ctx.obj.get("token"))
+    try:
+        result = client.lip_sync(
+            video_id=video_id,
+            video_url=video_url,
+            mode=mode,
+            audio_url=audio_url,
+            audio_type=audio_type,
+            audio_file=audio_file,
+            text=text,
+            voice_id=voice_id,
+            voice_language=voice_language,
+            voice_speed=voice_speed,
+            callback_url=callback_url,
+            **({"async": True} if async_mode else {}),
+        )
+        if output_json:
+            print_json(result)
+        else:
+            print_video_result(result)
+    except KlingError as e:
+        print_error(e.message)
+        raise SystemExit(1) from e
+
+
+@click.command("talking-photo")
+@click.option("--image-url", required=True, help="Source image URL.")
+@click.option("--audio-url", required=True, help="Source audio URL.")
+@click.option("--prompt", default=None, help="Prompt for talking photo generation.")
+@click.option(
+    "-m",
+    "--model",
+    type=click.Choice(TALKING_PHOTO_MODELS),
+    default=None,
+    help="Model to use for generation.",
+)
+@click.option(
+    "--duration",
+    type=int,
+    callback=_validate_duration,
+    default=None,
+    help="Video duration in seconds.",
+)
+@click.option(
+    "--mode",
+    type=click.Choice(["std", "pro"]),
+    default=None,
+    help="Generation mode: std or pro.",
+)
+@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 talking_photo(
+    ctx: click.Context,
+    image_url: str,
+    audio_url: str,
+    prompt: str | None,
+    model: str | None,
+    duration: int | None,
+    mode: str | None,
+    callback_url: str | None,
+    async_mode: bool,
+    output_json: bool,
+) -> None:
+    """Generate a talking-photo video."""
+    client = get_client(ctx.obj.get("token"))
+    try:
+        result = client.talking_photo(
+            image_url=image_url,
+            audio_url=audio_url,
+            prompt=prompt,
+            model=model,
+            duration=duration,
+            mode=mode,
+            callback_url=callback_url,
+            **({"async": True} if async_mode else {}),
+        )
+        if output_json:
+            print_json(result)
+        else:
+            print_video_result(result)
+    except KlingError as e:
+        print_error(e.message)
+        raise SystemExit(1) from e

kling_cli/commands/motion.py

@@ -0,0 +1,103 @@
+"""Motion generation command."""
+
+import click
+
+from kling_cli.core.client import get_client
+from kling_cli.core.exceptions import KlingError
+from kling_cli.core.output import (
+    DEFAULT_MODE,
+    KLING_MODES,
+    print_error,
+    print_json,
+    print_video_result,
+)
+
+
+@click.command()
+@click.option(
+    "--image-url",
+    required=True,
+    help="Reference image URL. Characters, backgrounds and elements in the generated video "
+    "are based on this image.",
+)
+@click.option(
+    "--video-url",
+    required=True,
+    help="Reference video URL. Character movements in the generated video are consistent "
+    "with those in this reference video.",
+)
+@click.option(
+    "--character-orientation",
+    default=None,
+    type=click.Choice(["image", "video"]),
+    help="Orientation of characters in the generated video: consistent with the image or video.",
+)
+@click.option(
+    "--mode",
+    type=click.Choice(KLING_MODES),
+    default=DEFAULT_MODE,
+    help="Generation mode: std (High performance) or pro (High quality).",
+)
+@click.option(
+    "--keep-original-sound/--no-keep-original-sound",
+    default=True,
+    help="Whether to keep the original sound from the reference video (default: keep).",
+)
+@click.option("--prompt", default=None, help="Text prompt (positive and/or negative descriptions).")
+@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(
+    "--timeout", default=None, type=int, help="Timeout in seconds for the API to return data."
+)
+@click.option("--json", "output_json", is_flag=True, help="Output raw JSON.")
+@click.pass_context
+def motion(
+    ctx: click.Context,
+    image_url: str,
+    video_url: str,
+    character_orientation: str | None,
+    mode: str,
+    keep_original_sound: bool,
+    prompt: str | None,
+    callback_url: str | None,
+    async_mode: bool,
+    timeout: int | None,
+    output_json: bool,
+) -> None:
+    """Generate a motion video from a reference image and reference video.
+
+    The generated video's characters and elements are based on the reference image,
+    while the movements are based on the reference video.
+
+    Examples:
+
+      kling motion --image-url https://example.com/img.jpg --video-url https://example.com/ref.mp4
+
+      kling motion --image-url img.jpg --video-url ref.mp4 --prompt "A dancer performing"
+    """
+    client = get_client(ctx.obj.get("token"))
+    try:
+        result = client.generate_motion(
+            image_url=image_url,
+            video_url=video_url,
+            character_orientation=character_orientation,
+            mode=mode,
+            keep_original_sound="yes" if keep_original_sound else "no",
+            prompt=prompt,
+            callback_url=callback_url,
+            **({"async": True} if async_mode else {}),
+            timeout=timeout,
+        )
+        if output_json:
+            print_json(result)
+        else:
+            print_video_result(result)
+    except KlingError as e:
+        print_error(e.message)
+        raise SystemExit(1) from e

kling_cli/commands/task.py

@@ -0,0 +1,142 @@
+"""Task management commands."""
+
+import time
+
+import click
+
+from kling_cli.core.client import get_client
+from kling_cli.core.exceptions import KlingError
+from kling_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:
+
+      kling 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 KlingError 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:
+
+      kling 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 KlingError 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:
+
+      kling wait abc123
+
+      kling 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", "succeed", "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 KlingError as e:
+        print_error(e.message)
+        raise SystemExit(1) from e