┌─────────────────┐             ┌─────────────────────┐             ┌─────────────────────────┐
│ Клиентский      │             │ Шлюз ToAPIs         │             │ GPU-кластер ByteDance   │
│ сервис/бэкенд   │             │ (api.toapis.com)    │             │ (Движок Seedance 2.0)   │
└────────┬────────┘             └──────────┬──────────┘             └────────────┬────────────┘
         │                                 │                                     │
         │ 1. POST /v1/videos/generations  │                                     │
         │────────────────────────────────>│ 2. Авторизация и постановка в очередь│
         │                                 │────────────────────────────────────>│
         │ 3. HTTP 202: Возврат task_id    │                                     │
         │<────────────────────────────────│                                     │
         │                                 │                                     │
         │ 4. GET /v1/tasks/video-status   │                                     │
         │    (Опрос через 3 сек)          │                                     │
         │────────────────────────────────>│ 5. Запрос статуса очереди           │
         │                                 │────────────────────────────────────>│
         │ 6. Статус: "PROCESSING" (35%)   │<────────────────────────────────────│
         │<────────────────────────────────│                                     │
         │                                 │                                     │
         │ 7. GET /v1/tasks/video-status   │                                     │
         │    (Опрос через 3 сек)          │                                     │
         │────────────────────────────────>│ 8. Рендеринг завершен, публикация   │
         │                                 │────────────────────────────────────>│
         │ 9. Статус: "SUCCESS" + MP4 URL  │<────────────────────────────────────│
         │<────────────────────────────────│                                     │
         │                                 │                                     │
         │ 10. Сохранение MP4 в S3/Хранилище │                                   │
         │─────────────────────────────────┴─────────────────────────────────────┘

export TOAPIS_API_KEY="sk-toapis-your-active-api-key"

# Шаг 1: Отправка задачи на генерацию видео
curl -X POST "https://api.toapis.com/v1/videos/generations" \
  -H "Authorization: Bearer $TOAPIS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "doubao-seedance-2-0",
    "prompt": "Кинематографичная аэросъемка, древний шотландский замок на рассвете в тумане, золотые лучи сквозь дымку, 8k 24fps",
    "aspect_ratio": "16:9",
    "duration": 5,
    "quality": "standard"
  }'

{
  "code": 0,
  "message": "Task submitted successfully",
  "data": {
    "task_id": "task_seedance_9f81a7b03c4e4d8a",
    "status": "QUEUED",
    "created_at": 1761037200,
    "model": "doubao-seedance-2-0",
    "estimated_seconds": 32
  }
}

# Шаг 2: Проверка статуса по полученному task_id
curl -X GET "https://api.toapis.com/v1/tasks/video-status?task_id=task_seedance_9f81a7b03c4e4d8a" \
  -H "Authorization: Bearer $TOAPIS_API_KEY"

"""
Клиент Seedance 2.0 Video API для продакшена через шлюз ToAPIs.
Возможности:
- Типобезопасное формирование запроса
- Опрос статуса с защитой по таймауту
- Экспоненциальная задержка с джиттером для обработки ошибок 429
- Потоковое скачивание готового MP4 на локальный диск
"""

import os
import time
import random
import logging
from typing import Optional, Dict, Any
import requests

logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
logger = logging.getLogger("Seedance2Client")

class SeedanceAPIError(Exception):
    """Исключение операций API Seedance"""
    pass

class SeedanceClient:
    def __init__(self, api_key: Optional[str] = None, base_url: str = "https://api.toapis.com/v1"):
        self.api_key = api_key or os.getenv("TOAPIS_API_KEY")
        if not self.api_key:
            raise ValueError("API-ключ не найден. Установите переменную TOAPIS_API_KEY.")
        self.base_url = base_url.rstrip("/")
        self.headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json",
            "User-Agent": "ToAPIs-Seedance-SDK/2.0"
        }

    def submit_video_task(
        self,
        prompt: str,
        aspect_ratio: str = "16:9",
        duration: int = 5,
        quality: str = "standard",
        seed: Optional[int] = None,
        image_url: Optional[str] = None
    ) -> str:
        """Отправка задачи на генерацию, возвращает task_id"""
        url = f"{self.base_url}/videos/generations"
        payload: Dict[str, Any] = {
            "model": "doubao-seedance-2-0",
            "prompt": prompt,
            "aspect_ratio": aspect_ratio,
            "duration": duration,
            "quality": quality
        }
        if seed is not None:
            payload["seed"] = seed
        if image_url:
            payload["image_url"] = image_url

        logger.info(f"Отправка задачи Seedance 2.0: формат={aspect_ratio}, время={duration}с...")
        response = requests.post(url, json=payload, headers=self.headers, timeout=30)
        
        if response.status_code == 429:
            raise SeedanceAPIError("Превышен лимит запросов (429). Включите очередь ожидания.")
        response.raise_for_status()
        
        data = response.json()
        task_id = data.get("data", {}).get("task_id")
        if not task_id:
            raise SeedanceAPIError(f"Некорректная структура ответа: {data}")
            
        logger.info(f"Задача принята в очередь. Task ID: {task_id}")
        return task_id

    def poll_until_complete(
        self,
        task_id: str,
        initial_interval: float = 3.0,
        max_timeout: float = 180.0
    ) -> str:
        """Опрос статуса до SUCCESS/FAILED с возвратом URL видео"""
        url = f"{self.base_url}/tasks/video-status"
        params = {"task_id": task_id}
        start_time = time.time()
        current_interval = initial_interval

        while time.time() - start_time < max_timeout:
            time.sleep(current_interval)
            elapsed = int(time.time() - start_time)

            try:
                res = requests.get(url, params=params, headers=self.headers, timeout=15)
            except requests.RequestException as req_err:
                logger.warning(f"Сетевой сбой при опросе задачи {task_id}: {req_err}. Повтор...")
                continue

            if res.status_code == 429:
                backoff = current_interval * 1.5 + random.uniform(0.5, 1.5)
                logger.warning(f"Получен HTTP 429. Ожидание {backoff:.1f}с...")
                time.sleep(backoff)
                continue

            if res.status_code != 200:
                logger.warning(f"Ошибка проверки статуса (HTTP {res.status_code}): {res.text}")
                continue

            body = res.json().get("data", {})
            status = body.get("status")
            progress = body.get("progress", 0)
            logger.info(f"[{elapsed}с прошло] Статус: {status} ({progress}%)")

            if status == "SUCCESS":
                video_url = body.get("video_url")
                if not video_url:
                    raise SeedanceAPIError("Статус SUCCESS, но video_url отсутствует.")
                logger.info(f"Видео готово за {elapsed}с! URL: {video_url}")
                return video_url
            elif status in ("FAILED", "CANCELED"):
                error_msg = body.get("error_message", "Неизвестная ошибка рендеринга")
                raise SeedanceAPIError(f"Задача {task_id} прервана: {error_msg}")

        raise TimeoutError(f"Время ожидания задачи {task_id} превысило лимит ({max_timeout}с).")

    def download_video(self, video_url: str, output_path: str) -> None:
        """Скачивание потока MP4 и сохранение на диск"""
        logger.info(f"Скачивание видео из CDN в {output_path}...")
        with requests.get(video_url, stream=True, timeout=60) as r:
            r.raise_for_status()
            with open(output_path, "wb") as f:
                for chunk in r.iter_content(chunk_size=8192):
                    f.write(chunk)
        logger.info(f"Файл успешно сохранен: {output_path} ({os.path.getsize(output_path)} байт)")

if __name__ == "__main__":
    client = SeedanceClient()
    prompt = "Макросъемка крупным планом: расплавленная медь заливается в стальную форму шестеренки, брызги искр, полумрак мастерской, 1080p 30fps"
    
    try:
        t_id = client.submit_video_task(prompt=prompt, aspect_ratio="16:9", duration=5)
        url = client.poll_until_complete(t_id)
        client.download_video(url, "seedance_gear_russia.mp4")
    except Exception as exc:
        logger.error(f"Ошибка выполнения: {exc}")

import axios, { AxiosInstance } from 'axios';

export interface SeedanceGenerateOptions {
  prompt: string;
  aspectRatio?: '16:9' | '9:16' | '1:1' | '4:3' | '21:9';
  duration?: 5 | 10;
  quality?: 'standard' | 'high';
  seed?: number;
  imageUrl?: string;
  webhookUrl?: string;
}

export interface TaskStatusResponse {
  taskId: string;
  status: 'QUEUED' | 'PROCESSING' | 'SUCCESS' | 'FAILED';
  progress?: number;
  videoUrl?: string;
  errorMessage?: string;
}

export class SeedanceVideoService {
  private client: AxiosInstance;

  constructor(apiKey?: string, baseURL = 'https://api.toapis.com/v1') {
    const token = apiKey || process.env.TOAPIS_API_KEY;
    if (!token) {
      throw new Error('Переменная окружения TOAPIS_API_KEY не задана.');
    }

    this.client = axios.create({
      baseURL,
      headers: {
        Authorization: `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
      timeout: 20000,
    });
  }

  /**
   * Отправка задачи генерации видео
   */
  async submitTask(options: SeedanceGenerateOptions): Promise<string> {
    const payload = {
      model: 'doubao-seedance-2-0',
      prompt: options.prompt,
      aspect_ratio: options.aspectRatio || '16:9',
      duration: options.duration || 5,
      quality: options.quality || 'standard',
      seed: options.seed,
      image_url: options.imageUrl,
      webhook_url: options.webhookUrl,
    };

    const res = await this.client.post('/videos/generations', payload);
    const taskId = res.data?.data?.task_id;
    if (!taskId) {
      throw new Error('В ответе шлюза отсутствует task_id.');
    }
    return taskId;
  }

  /**
   * Опрос статуса до завершения
   */
  async waitForCompletion(
    taskId: string,
    intervalMs = 3000,
    maxWaitMs = 180000
  ): Promise<string> {
    const startTime = Date.now();

    while (Date.now() - startTime < maxWaitMs) {
      await new Promise((resolve) => setTimeout(resolve, intervalMs));

      const res = await this.client.get('/tasks/video-status', {
        params: { task_id: taskId },
      });

      const data = res.data?.data;
      const status = data?.status;

      if (status === 'SUCCESS') {
        return data.video_url;
      }
      if (status === 'FAILED') {
        throw new Error(`Ошибка рендеринга: ${data.error_message || 'Неизвестная ошибка'}`);
      }
    }

    throw new Error(`Задача ${taskId} превысила лимит ожидания (${maxWaitMs / 1000}с).`);
  }
}

┌─────────────────────────────────────────────────────────────────────────────────┐
│ Сравнительная таблица: Polling vs Webhook                                       │
├──────────────────┬─────────────────────────────┬────────────────────────────────┤
│ Критерий         │ Опрос статуса (/status)     │ Webhook-колбэк (POST /hook)    │
├──────────────────┼─────────────────────────────┼────────────────────────────────┤
│ Оптимальный объем│ Менее 500 видео / день      │ Более 500 видео / день         │
│ Нагрузка на сеть │ Высокая (10-20 HTTP-запросов)│ Минимальная (1 push-событие)   │
│ Нагрузка на шлюз │ Возрастает при пиках QPS    │ Нулевая нагрузка опроса        │
│ Требования к сети│ Работает за NAT / Localhost │ Требуется публичный HTTPS-адрес│
│ Восстановление   │ Встроенный цикл повторов    │ Требуется очередь ошибок (DLQ) │
└──────────────────┴─────────────────────────────┴────────────────────────────────┘

FALLBACK_CASCADE = [
    {"model": "doubao-seedance-2-0", "timeout_sec": 45},
    {"model": "kling-3-omni", "timeout_sec": 60},
    {"model": "minimax-h3", "timeout_sec": 45}
]