异步调用 API（旧线路已过时）

import requests
import time

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api2.laozhang.ai/v1"

# 步骤1: 创建视频任务（文生视频）
def create_video_task(prompt, size="1280x720", seconds="15"):
    """创建视频生成任务"""
    url = f"{BASE_URL}/videos"
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    data = {
        "model": "sora-2",
        "prompt": prompt,
        "size": size,
        "seconds": seconds
    }

    response = requests.post(url, headers=headers, json=data)
    response.raise_for_status()
    return response.json()

# 步骤1: 创建视频任务（图生视频）
def create_video_task_with_image(prompt, image_path, size="1280x720", seconds="10"):
    """创建图生视频任务"""
    url = f"{BASE_URL}/videos"
    headers = {"Authorization": f"Bearer {API_KEY}"}

    # 确保文件在请求时保持打开状态
    with open(image_path, 'rb') as image_file:
        files = {
            # 指定filename和MIME类型确保正确上传
            'input_reference': ('image.png', image_file, 'image/png')
        }
        data = {
            'model': 'sora-2',
            'prompt': prompt,
            'size': size,
            'seconds': seconds
        }

        # 在with块内发送请求，确保文件句柄有效
        response = requests.post(url, headers=headers, files=files, data=data)
        response.raise_for_status()
        return response.json()

# 步骤2: 轮询查询状态
def wait_for_video(video_id, poll_interval=5, timeout=600):
    """等待视频生成完成"""
    url = f"{BASE_URL}/videos/{video_id}"
    headers = {"Authorization": f"Bearer {API_KEY}"}
    start_time = time.time()

    while True:
        # 检查超时
        if time.time() - start_time > timeout:
            raise TimeoutError(f"视频生成超时（{timeout}秒）")

        # 查询状态
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        task = response.json()

        status = task["status"]
        progress = task.get("progress", 0)

        print(f"状态: {status}, 进度: {progress}%")

        if status == "completed":
            return task
        elif status == "failed":
            error = task.get("error", {})
            raise Exception(f"生成失败: {error.get('message', '未知错误')}")

        # 等待后重试
        time.sleep(poll_interval)

# 步骤3: 下载视频
def download_video(video_id, save_path="video.mp4"):
    """下载生成的视频"""
    url = f"{BASE_URL}/videos/{video_id}/content"
    headers = {"Authorization": f"Bearer {API_KEY}"}

    response = requests.get(url, headers=headers, stream=True)
    response.raise_for_status()

    with open(save_path, 'wb') as f:
        for chunk in response.iter_content(chunk_size=8192):
            if chunk:
                f.write(chunk)

    print(f"视频已保存到: {save_path}")

# 完整流程（文生视频）
def generate_video_async(prompt, size="1280x720", seconds="15"):
    """异步生成视频的完整流程"""
    print("1. 创建视频任务...")
    task = create_video_task(prompt, size, seconds)
    video_id = task["id"]
    print(f"   任务ID: {video_id}")

    print("\n2. 等待视频生成...")
    completed_task = wait_for_video(video_id)
    print(f"   生成完成！耗时: {completed_task['completed_at'] - completed_task['created_at']}秒")

    print("\n3. 下载视频...")
    download_video(video_id)
    print("\n✅ 完成！")

# 完整流程（图生视频）
def generate_video_from_image_async(image_path, prompt, size="1280x720", seconds="10"):
    """从本地图片生成视频的完整流程"""
    import os

    if not os.path.exists(image_path):
        print(f"错误：图片文件不存在 {image_path}")
        return None

    print(f"1. 上传图片并创建任务...（{image_path}）")
    task = create_video_task_with_image(prompt, image_path, size, seconds)
    video_id = task["id"]
    print(f"   任务ID: {video_id}")

    print("\n2. 等待视频生成...")
    completed_task = wait_for_video(video_id)
    print(f"   生成完成！耗时: {completed_task['completed_at'] - completed_task['created_at']}秒")

    print("\n3. 下载视频...")
    download_video(video_id, save_path=f"image_to_video_{video_id}.mp4")
    print("\n✅ 完成！")

    return video_id

# 使用示例
if __name__ == "__main__":
    # 文生视频
    generate_video_async(
        prompt="一只可爱的猫咪在阳光明媚的花园里玩球",
        size="1280x720",  # 横屏
        seconds="15"       # 15秒
    )

    # 图生视频
    generate_video_from_image_async(
        image_path="/path/to/your/image.png",
        prompt="让这张图片中的场景动起来，增加自然的动态效果",
        size="1280x720",  # 横屏
        seconds="10"       # 10秒
    )

const axios = require('axios');
const fs = require('fs');
const FormData = require('form-data');

const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'https://api2.laozhang.ai/v1';

// 创建视频任务（文生视频）
async function createVideoTask(prompt, size = '1280x720', seconds = '15') {
  const response = await axios.post(`${BASE_URL}/videos`, {
    model: 'sora-2',
    prompt,
    size,
    seconds
  }, {
    headers: { 'Authorization': `Bearer ${API_KEY}` }
  });

  return response.data;
}

// 创建视频任务（图生视频）
async function createVideoTaskWithImage(prompt, imagePath, size = '1280x720', seconds = '10') {
  const formData = new FormData();
  formData.append('model', 'sora-2');
  formData.append('prompt', prompt);
  formData.append('size', size);
  formData.append('seconds', seconds);
  formData.append('input_reference', fs.createReadStream(imagePath));

  const response = await axios.post(`${BASE_URL}/videos`, formData, {
    headers: {
      'Authorization': `Bearer ${API_KEY}`,
      ...formData.getHeaders()
    }
  });

  return response.data;
}

// 轮询查询状态
async function waitForVideo(videoId, pollInterval = 5000, timeout = 600000) {
  const startTime = Date.now();

  while (true) {
    // 检查超时
    if (Date.now() - startTime > timeout) {
      throw new Error(`视频生成超时（${timeout/1000}秒）`);
    }

    // 查询状态
    const response = await axios.get(`${BASE_URL}/videos/${videoId}`, {
      headers: { 'Authorization': `Bearer ${API_KEY}` }
    });

    const task = response.data;
    const { status, progress = 0 } = task;

    console.log(`状态: ${status}, 进度: ${progress}%`);

    if (status === 'completed') {
      return task;
    } else if (status === 'failed') {
      const error = task.error || {};
      throw new Error(`生成失败: ${error.message || '未知错误'}`);
    }

    // 等待后重试
    await new Promise(resolve => setTimeout(resolve, pollInterval));
  }
}

// 下载视频
async function downloadVideo(videoId, savePath = 'video.mp4') {
  const response = await axios.get(
    `${BASE_URL}/videos/${videoId}/content`,
    {
      headers: { 'Authorization': `Bearer ${API_KEY}` },
      responseType: 'stream'
    }
  );

  const writer = fs.createWriteStream(savePath);
  response.data.pipe(writer);

  return new Promise((resolve, reject) => {
    writer.on('finish', () => {
      console.log(`视频已保存到: ${savePath}`);
      resolve();
    });
    writer.on('error', reject);
  });
}

// 完整流程（文生视频）
async function generateVideoAsync(prompt, size = '1280x720', seconds = '15') {
  try {
    console.log('1. 创建视频任务...');
    const task = await createVideoTask(prompt, size, seconds);
    const videoId = task.id;
    console.log(`   任务ID: ${videoId}`);

    console.log('\n2. 等待视频生成...');
    const completedTask = await waitForVideo(videoId);
    const duration = completedTask.completed_at - completedTask.created_at;
    console.log(`   生成完成！耗时: ${duration}秒`);

    console.log('\n3. 下载视频...');
    await downloadVideo(videoId);
    console.log('\n✅ 完成！');

  } catch (error) {
    console.error('错误:', error.message);
  }
}

// 完整流程（图生视频）
async function generateVideoFromImageAsync(imagePath, prompt, size = '1280x720', seconds = '10') {
  try {
    if (!fs.existsSync(imagePath)) {
      console.error(`错误：图片文件不存在 ${imagePath}`);
      return null;
    }

    console.log(`1. 上传图片并创建任务...（${imagePath}）`);
    const task = await createVideoTaskWithImage(prompt, imagePath, size, seconds);
    const videoId = task.id;
    console.log(`   任务ID: ${videoId}`);

    console.log('\n2. 等待视频生成...');
    const completedTask = await waitForVideo(videoId);
    const duration = completedTask.completed_at - completedTask.created_at;
    console.log(`   生成完成！耗时: ${duration}秒`);

    console.log('\n3. 下载视频...');
    await downloadVideo(videoId, `image_to_video_${videoId}.mp4`);
    console.log('\n✅ 完成！');

    return videoId;

  } catch (error) {
    console.error('错误:', error.message);
    return null;
  }
}

// 使用示例
// 文生视频
generateVideoAsync(
  '一只可爱的猫咪在阳光明媚的花园里玩球',
  '1280x720',  // 横屏
  '15'         // 15秒
);

// 图生视频
generateVideoFromImageAsync(
  '/path/to/your/image.png',
  '让这张图片中的场景动起来，增加自然的动态效果',
  '1280x720',  // 横屏
  '10'         // 10秒
);

{
  "error": {
    "message": "错误描述",
    "type": "invalid_request_error",
    "code": "invalid_parameter"
  }
}