异步 & 并发使用

图像、视频和音乐生成通常需要 30 秒到 3 分钟。SDK 提供三种并发模式，让你的应用在等待时保持响应。

# pip install jarvisclaw[async]
# 所有客户端都支持同步和异步两种使用模式。
# 选择适合你应用的风格。

非阻塞 (wait=False)

提交任务后立即获得句柄。之后轮询或阻塞等待结果 — 适用于需要在中间做其他工作的场景。

from jarvisclaw import ImageClient, VideoClient, AudioClient

image = ImageClient(private_key="0x...")

# ─── 非阻塞：立即返回，稍后轮询 ───
job = image.generate("未来都市风景", wait=False)
print(f"任务已提交: {job.raw['id']}")

# 图像生成期间做其他工作...
import time
time.sleep(10)

# 准备好后检查状态
result = image.status(job.raw["id"])
if result.url:
    print(f"完成: {result.url}")

# 视频同理
video = VideoClient(private_key="0x...")
job = video.generate("日落时的海浪", wait=False)
# ... 稍后 ...
result = video.status(job.id)

# 音乐返回 Future 风格的 MusicJob
audio = AudioClient(private_key="0x...")
music_job = audio.music("Lo-fi 嘻哈节拍", wait=False)
# ... 做其他工作 ...
result = music_job.result()  # 仅在需要结果时阻塞

asyncio（并发请求）

使用 jarvisclaw.aio 客户端配合 asyncio.gather 在单线程中并发运行多个请求。

import asyncio
from jarvisclaw.aio import ChatClient, ImageClient, VideoClient, AudioClient

async def main():
    # 所有异步客户端支持上下文管理器
    async with ChatClient(private_key="0x...") as chat, \
               ImageClient(private_key="0x...") as image:

        # 并发对话请求到不同模型
        responses = await asyncio.gather(
            chat.complete("2+2等于多少？", model="openai/gpt-5.4"),
            chat.complete("3+3等于多少？", model="anthropic/claude-sonnet-4.6"),
            chat.complete("4+4等于多少？", model="google/gemini-2.5-flash"),
        )
        for r in responses:
            print(r)

        # 并发图像生成
        images = await asyncio.gather(
            image.generate("太空中的猫"),
            image.generate("月球上的狗"),
            image.generate("水下的鸟"),
        )
        for img in images:
            print(img.url)

        # 流式输出 (async for)
        async for chunk in chat.stream("给我讲个故事"):
            print(chunk, end="")

asyncio.run(main())

ThreadPoolExecutor（简单并行）

在并行线程中运行同步客户端 — 无需了解 asyncio。适合批处理任务。

from concurrent.futures import ThreadPoolExecutor
from jarvisclaw import ImageClient

image = ImageClient(private_key="0x...")
prompts = ["一只猫", "一只狗", "一只鸟", "一条鱼", "一匹马"]

# 简单的线程并行（无需了解 asyncio）
with ThreadPoolExecutor(max_workers=5) as pool:
    futures = [pool.submit(image.generate, p) for p in prompts]
    for future in futures:
        result = future.result()
        print(result.url)

Go (goroutines)

Go 的 goroutine 原生支持并发 — 无需特殊的异步库。

package main

import (
    "context"
    "fmt"
    "sync"

    jarvisclaw "github.com/api-jarvisclaw/go-sdk/v2"
)

func main() {
    ctx := context.Background()
    image, _ := jarvisclaw.NewImageClient(jarvisclaw.WithPrivateKey("0x..."))

    prompts := []string{"一只猫", "一只狗", "一只鸟"}
    results := make([]*jarvisclaw.ImageResponse, len(prompts))

    // Go 的 goroutine 是原生异步 — 无需特殊库
    var wg sync.WaitGroup
    for i, p := range prompts {
        wg.Add(1)
        go func(i int, p string) {
            defer wg.Done()
            results[i], _ = image.Generate(ctx, p)
        }(i, p)
    }
    wg.Wait()

    for _, r := range results {
        fmt.Println(r.URL)
    }
}

TIP

异步扩展仅在 asyncio 模式下需要。安装命令：pip install jarvisclaw[async]