# Soumettre une tâche de génération d'image
curl -X POST https://api.evolink.ai/v1/images/generations \\
  -H "Authorization: Bearer YOUR_API_KEY" \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "gpt-4o-image",
    "prompt": "A cute cat running on the grass at sunset with warm lighting"
  }'

{
  "created": 1757156493,
  "id": "task-unified-1757156493-imcg5zqt",
  "model": "gpt-4o-image",
  "object": "image.generation.task",
  "progress": 0,
  "status": "pending",
  "task_info": {
    "can_cancel": true,
    "estimated_time": 100
  },
  "type": "image",
  "usage": {
    "billing_rule": "per_call",
    "credits_reserved": 252,
    "estimated_cost": 0.252,
    "user_group": "default"
  }
}

# Utiliser l'identifiant de tâche retourné pour consulter le statut
curl https://api.evolink.ai/v1/tasks/task-unified-1757156493-imcg5zqt \\
  -H "Authorization: Bearer YOUR_API_KEY"

{
  "created": 1757156493,
  "id": "task-unified-1757156493-imcg5zqt",
  "model": "gpt-4o-image",
  "object": "image.generation.task",
  "progress": 100,
  "results": [
    "https://tempfile.aiquickdraw.com/s/generated_image_url.png"
  ],
  "status": "completed",
  "task_info": {
    "can_cancel": false
  },
  "type": "image"
}

import requests
import time

# Génération de vidéo Veo3-Fast
def generate_video():
    # Soumettre une tâche de génération de vidéo
    response = requests.post(
        "https://api.evolink.ai/v1/videos/generations",
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        json={
            "model": "veo3-fast",
            "prompt": "A cat chasing butterflies in the garden, slow motion",
            "aspect_ratio": "16:9"
        }
    )

    task = response.json()
    task_id = task['id']

    print(f"Tâche vidéo créée : {task_id}")
    print(f"Temps d'achèvement estimé : {task['task_info']['estimated_time']} secondes")
    print(f"Coût estimé : ${task['usage']['estimated_cost']}")

    return task_id

# Surveiller la progression de la tâche
def monitor_task(task_id):
    while True:
        response = requests.get(
            f"https://api.evolink.ai/v1/tasks/{task_id}",
            headers={"Authorization": "Bearer YOUR_API_KEY"}
        )

        task = response.json()
        status = task['status']
        progress = task['progress']

        print(f"Statut : {status}, Progression : {progress}%")

        if status == "completed":
            return task['results'][0]  # URL de la vidéo dans le tableau results
        elif status == "failed":
            raise Exception(f"Tâche échouée : {task.get('error')}")

        time.sleep(10)  # Interroger toutes les 10 secondes

# Exemple d'utilisation
task_id = generate_video()
video_url = monitor_task(task_id)
print(f"Génération vidéo terminée : {video_url}")

import openai
import requests

class EvoLinkClient:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.evolink.ai"
        self.headers = {"Authorization": f"Bearer {api_key}"}

    def create_image(self, model, prompt, **kwargs):
        """Créer une tâche de génération d'image"""
        response = requests.post(
            f"{self.base_url}/v1/images/generations",
            headers=self.headers,
            json={"model": model, "prompt": prompt, **kwargs}
        )
        return response.json()

    def create_video(self, model, prompt, **kwargs):
        """Créer une tâche de génération de vidéo"""
        response = requests.post(
            f"{self.base_url}/v1/videos/generations",
            headers=self.headers,
            json={"model": model, "prompt": prompt, **kwargs}
        )
        return response.json()

    def get_task(self, task_id):
        """Obtenir le statut de la tâche"""
        response = requests.get(
            f"{self.base_url}/v1/tasks/{task_id}",
            headers=self.headers
        )
        return response.json()

    def wait_for_completion(self, task_id, timeout=300):
        """Attendre l'achèvement de la tâche"""
        import time
        start_time = time.time()

        while time.time() - start_time < timeout:
            task = self.get_task(task_id)

            if task['status'] == 'completed':
                return task
            elif task['status'] == 'failed':
                raise Exception(f"Tâche échouée : {task.get('error')}")

            time.sleep(5)

        raise TimeoutError("Délai d'exécution de la tâche dépassé")

# Exemple d'utilisation
client = EvoLinkClient("YOUR_API_KEY")

# Générer une image
task = client.create_image(
    model="gpt-4o-image",
    prompt="A modern intelligent office building"
)

result = client.wait_for_completion(task['id'])
print(f"URL de l'image : {result['results'][0]}")

class EvoLinkClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseURL = 'https://api.evolink.ai';
  }

  async createImage(model, prompt, options = {}) {
    const response = await fetch(`${this.baseURL}/v1/images/generations`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ model, prompt, ...options })
    });

    return response.json();
  }

  async getTask(taskId) {
    const response = await fetch(`${this.baseURL}/v1/tasks/${taskId}`, {
      headers: { 'Authorization': `Bearer ${this.apiKey}` }
    });

    return response.json();
  }

  async waitForCompletion(taskId, timeout = 300000) {
    const startTime = Date.now();

    while (Date.now() - startTime < timeout) {
      const task = await this.getTask(taskId);

      if (task.status === 'completed') {
        return task;
      } else if (task.status === 'failed') {
        throw new Error(`Tâche échouée : ${task.error}`);
      }

      await new Promise(resolve => setTimeout(resolve, 5000));
    }

    throw new Error("Délai d'exécution de la tâche dépassé");
  }
}

// Exemple d'utilisation
async function generateImage() {
  const client = new EvoLinkClient('YOUR_API_KEY');

  try {
    // Créer une tâche
    const task = await client.createImage(
      'doubao-seedream-4.0',
      'An abstract art painting with rich colors'
    );

    console.log('Tâche créée :', task.id);

    // Attendre l'achèvement
    const result = await client.waitForCompletion(task.id);
    console.log('Génération d\'image terminée :', result.results[0]);

  } catch (error) {
    console.error('Échec de la génération :', error.message);
  }
}

generateImage();

import requests
from typing import Optional
import time

class EvoLinkError(Exception):
    """Classe de base des exceptions API EvoLink"""
    pass

class RateLimitError(EvoLinkError):
    """Exception de limite de débit"""
    pass

class QuotaExhaustedError(EvoLinkError):
    """Exception de quota épuisé"""
    pass

def handle_api_call(func, *args, **kwargs):
    """Gestion unifiée des erreurs d'appel API"""
    max_retries = 3
    retry_delay = 1

    for attempt in range(max_retries):
        try:
            response = func(*args, **kwargs)

            if response.status_code == 200:
                return response.json()
            elif response.status_code == 429:
                # Limite de débit, attendre et réessayer
                wait_time = int(response.headers.get('Retry-After', retry_delay))
                print(f"Limite de débit atteinte, attente de {wait_time} secondes avant nouvelle tentative...")
                time.sleep(wait_time)
                retry_delay *= 2
                continue
            elif response.status_code == 402:
                raise QuotaExhaustedError("Solde du compte insuffisant, veuillez recharger")
            else:
                error_data = response.json()
                raise EvoLinkError(f"Échec de l'appel API : {error_data.get('error', {}).get('message')}")

        except requests.exceptions.RequestException as e:
            if attempt == max_retries - 1:
                raise EvoLinkError(f"Échec de la requête réseau : {str(e)}")
            time.sleep(retry_delay)
            retry_delay *= 2

    raise EvoLinkError("Nombre maximum de tentatives atteint")

# Exemple d'utilisation
try:
    result = handle_api_call(
        requests.post,
        "https://api.evolink.ai/v1/images/generations",
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        json={"model": "gpt-4o-image", "prompt": "Test image"}
    )
    print("Tâche créée avec succès :", result['id'])
except QuotaExhaustedError:
    print("Veuillez recharger dans la console : https://evolink.ai/dashboard/billing")
except EvoLinkError as e:
    print(f"Exception d'appel API : {e}")

import logging
from datetime import datetime

class EvoLinkMonitor:
    def __init__(self):
        # Configurer la journalisation
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('evolink_api.log'),
                logging.StreamHandler()
            ]
        )
        self.logger = logging.getLogger(__name__)

    def log_task_creation(self, task_id, model, cost):
        """Journaliser la création de tâche"""
        self.logger.info(f"Tâche créée | ID:{task_id} | Modèle:{model} | Coût:${cost}")

    def log_task_completion(self, task_id, duration, status):
        """Journaliser l'achèvement de tâche"""
        self.logger.info(f"Tâche terminée | ID:{task_id} | Durée:{duration}s | Statut:{status}")

    def log_error(self, error, context=""):
        """Journaliser les erreurs"""
        self.logger.error(f"Erreur API | {context} | {str(error)}")

# Exemple d'utilisation
monitor = EvoLinkMonitor()

# Utiliser dans les appels API
start_time = time.time()
try:
    task = client.create_image("gpt-4o-image", "Test prompt")
    monitor.log_task_creation(
        task['id'],
        task['model'],
        task['usage']['estimated_cost']
    )

    result = client.wait_for_completion(task['id'])
    duration = time.time() - start_time
    monitor.log_task_completion(task['id'], int(duration), "completed")

except Exception as e:
    monitor.log_error(e, f"Task ID: {task.get('id', 'unknown')}")