Seedream 5.0 Pro: Review AI Gambar ByteDance untuk E-commerce

# Buat virtual environment dulu biar bersih
python -m venv seedream-env

# Aktifkan (Linux/Mac)
source seedream-env/bin/activate

# Aktifkan (Windows)
seedream-env\Scripts\activate

# Install dependencies
pip install requests Pillow python-dotenv

seedream-project/
├── .env
├── main.py
├── edit_image.py
├── batch_generate.py
├── utils/
│   ├── __init__.py
│   ├── api_client.py
│   └── image_helper.py
└── output/

# .env
SEEDREAM_API_KEY=your_api_key_here
SEEDREAM_BASE_URL=https://api.evolink.ai/v1
SEEDREAM_MODEL=doubao-seedream-5.0-pro

# utils/api_client.py
import os
import requests
import time
from dotenv import load_dotenv

load_dotenv()

class SeedreamClient:
    def __init__(self):
        self.api_key = os.getenv("SEEDREAM_API_KEY")
        self.base_url = os.getenv("SEEDREAM_BASE_URL")
        self.model = os.getenv("SEEDREAM_MODEL")
        
        if not self.api_key:
            raise ValueError("API key tidak ditemukan. Cek file .env")
        
        self.headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
    
    def generate_image(self, prompt, size="auto", quality="1K", 
                       image_urls=None, output_format="jpeg"):
        """
        Mengirim request ke Seedream 5.0 Pro API untuk generate atau edit gambar.
        
        Args:
            prompt: Deskripsi gambar dalam bahasa natural
            size: Rasio aspek atau dimensi custom (default: "auto")
            quality: Tier output "1K" atau "2K"
            image_urls: List URL gambar referensi (opsional)
            output_format: "jpeg" atau "png"
        
        Returns:
            Dict berisi task info dan status
        """
        payload = {
            "model": self.model,
            "prompt": prompt,
            "size": size,
            "quality": quality,
            "model_params": {
                "output_format": output_format
            }
        }
        
        if image_urls:
            payload["image_urls"] = image_urls
        
        response = requests.post(
            f"{self.base_url}/images/generations",
            headers=self.headers,
            json=payload,
            timeout=60
        )
        
        if response.status_code != 200:
            raise Exception(f"API Error: {response.status_code} - {response.text}")
        
        return response.json()
    
    def check_task_status(self, task_id):
        """
        Cek status task yang sudah disubmit.
        
        Returns:
            Dict berisi status, progress, dan result (jika completed)
        """
        response = requests.get(
            f"{self.base_url}/tasks/{task_id}",
            headers=self.headers,
            timeout=30
        )
        
        if response.status_code != 200:
            raise Exception(f"Status check error: {response.status_code}")
        
        return response.json()
    
    def wait_for_completion(self, task_id, timeout=120, poll_interval=3):
        """
        Polling task sampai completed atau timeout.
        
        Args:
            task_id: ID task dari response generate_image
            timeout: Maksimal waktu tunggu dalam detik
            poll_interval: Interval polling dalam detik
        
        Returns:
            Dict result jika completed
        """
        start_time = time.time()
        
        while time.time() - start_time < timeout:
            result = self.check_task_status(task_id)
            status = result.get("status")
            progress = result.get("progress", 0)
            
            print(f"Status: {status} | Progress: {progress}%")
            
            if status == "completed":
                return result
            elif status == "failed":
                raise Exception(f"Task failed: {result}")
            
            time.sleep(poll_interval)
        
        raise TimeoutError(f"Task {task_id} timeout setelah {timeout} detik")

# main.py
from utils.api_client import SeedreamClient

try:
    client = SeedreamClient()
    print("✅ Client berhasil diinisialisasi")
    print(f"Model: {client.model}")
    print(f"Base URL: {client.base_url}")
except ValueError as e:
    print(f"❌ Error: {e}")

✅ Client berhasil diinisialisasi
Model: doubao-seedream-5.0-pro
Base URL: https://api.evolink.ai/v1

❌ Error: API key tidak ditemukan. Cek file .env

# main.py
from utils.api_client import SeedreamClient
from utils.image_helper import download_image
import json

def generate_product_image():
    client = SeedreamClient()
    
    prompt = """Produk shot sebuah earbuds wireless matte-black di atas 
    permukaan linen krem, top-down view, soft directional lighting dari 
    kiri atas, shadow lembut, background bersih, fotografi produk komersial, 
    ultra detail, 4K quality"""
    
    print("🚀 Mengirim request ke Seedream 5.0 Pro...")
    print(f"Prompt: {prompt[:80]}...")
    
    # Submit task
    response = client.generate_image(
        prompt=prompt,
        size="1:1",
        quality="1K",
        output_format="jpeg"
    )
    
    task_id = response.get("id")
    print(f"📝 Task ID: {task_id}")
    print(f"⏳ Estimasi waktu: {response.get('task_info', {}).get('estimated_time', 'N/A')} detik")
    
    # Tunggu completion
    result = client.wait_for_completion(task_id, timeout=120)
    
    # Ambil URL gambar hasil
    image_url = result.get("results", [None])[0]
    if image_url:
        print(f"✅ Gambar berhasil di-generate!")
        print(f"🔗 URL: {image_url}")
        print(f"📊 Credits used: {result.get('usage', {}).get('credits_used', 'N/A')}")
        
        # Download gambar
        local_path = download_image(image_url, "output/product_shot.jpg")
        print(f"💾 Gambar tersimpan di: {local_path}")
    else:
        print("❌ Tidak ada URL gambar dalam response")
    
    return result

if __name__ == "__main__":
    generate_product_image()

# utils/image_helper.py
import requests
import os

def download_image(url, filepath):
    """
    Download gambar dari URL dan simpan ke filepath.
    
    Args:
        url: URL gambar hasil generate
        filepath: Path tujuan penyimpanan
    
    Returns:
        Path file lokal
    """
    os.makedirs(os.path.dirname(filepath), exist_ok=True)
    
    response = requests.get(url, timeout=30)
    response.raise_for_status()
    
    with open(filepath, "wb") as f:
        f.write(response.content)
    
    return filepath

def get_image_info(filepath):
    """
    Ambil info dasar gambar (dimensi, ukuran file).
    """
    from PIL import Image
    
    img = Image.open(filepath)
    size_kb = os.path.getsize(filepath) / 1024
    
    return {
        "dimensions": img.size,
        "format": img.format,
        "size_kb": round(size_kb, 2)
    }

🚀 Mengirim request ke Seedream 5.0 Pro...
Prompt: Produk shot sebuah earbuds wireless matte-black di atas permukaan linen krem, top-d...
📝 Task ID: task-unified-1772000000-seedream5pro
⏳ Estimasi waktu: 30 detik
Status: processing | Progress: 0%
Status: processing | Progress: 45%
Status: processing | Progress: 80%
Status: completed | Progress: 100%
✅ Gambar berhasil di-generate!
🔗 URL: https://cdn.evolink.ai/images/generated-image.jpg
📊 Credits used: 2.601
💾 Gambar tersimpan di: output/product_shot.jpg

TimeoutError: Task task-unified-xxx timeout setelah 120 detik

# edit_image.py
from utils.api_client import SeedreamClient
from utils.image_helper import download_image

def edit_product_background():
    client = SeedreamClient()
    
    # URL gambar yang sudah kita generate di Step 3
    source_image_url = "https://cdn.evolink.ai/images/generated-image.jpg"
    
    edit_prompt = """Ganti permukaan linen di bawah earbuds dengan marmer Carrara 
    yang dipoles. Pertahankan posisi earbuds pixel-accurate. Pertahankan arah 
    lighting dari kiri atas. Update shadow agar natural di atas permukaan marmer."""
    
    print("🎨 Mengirim request edit ke Seedream 5.0 Pro...")
    print(f"Instruksi: {edit_prompt[:80]}...")
    
    response = client.generate_image(
        prompt=edit_prompt,
        size="1:1",
        quality="2K",
        image_urls=[source_image_url],
        output_format="png"  # PNG untuk edit karena lossless
    )
    
    task_id = response.get("id")
    print(f"📝 Task ID: {task_id}")
    
    # Tunggu completion — edit biasanya lebih cepat dari generate baru
    result = client.wait_for_completion(task_id, timeout=180)
    
    image_url = result.get("results", [None])[0]
    if image_url:
        print(f"✅ Edit berhasil!")
        print(f"🔗 URL: {image_url}")
        
        local_path = download_image(image_url, "output/product_edited.png")
        print(f"💾 Gambar tersimpan di: {local_path}")
        
        # Info credit usage
        usage = result.get("usage", {})
        print(f"📊 Credits used: {usage.get('credits_used', 'N/A')}")
        print(f"📷 Input images: {usage.get('input_images', 'N/A')}")
        print(f"📷 Billable input images: {usage.get('billable_input_images', 'N/A')}")
    
    return result

if __name__ == "__main__":
    edit_product_background()

🎨 Mengirim request edit ke Seedream 5.0 Pro...
Instruksi: Ganti permukaan linen di bawah earbuds dengan marmer Carrara yang dipoles. Pe...
📝 Task ID: task-unified-1772000123-seedream5pro
Status: processing | Progress: 0%
Status: processing | Progress: 50%
Status: completed | Progress: 100%
✅ Edit berhasil!
🔗 URL: https://cdn.evolink.ai/images/edited-image.png
💾 Gambar tersimpan di: output/product_edited.png
📊 Credits used: 2.774
📷 Input images: 1
📷 Billable input images: 1

# edit_image.py (tambahkan fungsi ini)

def chain_edits():
    client = SeedreamClient()
    
    # Edit 1: Ganti background
    edit_1_prompt = "Ganti background dengan marmer Carrara yang dipoles, pertahankan produk dan lighting"
    
    # Edit 2: Tambah elemen
    edit_2_prompt = "Tambahkan tanaman hijau kecil di sudut kanan atas, dengan shadow natural"
    
    # Edit 3: Adjust color grade
    edit_3_prompt = "Beri warm color grade, sedikit golden hour tone, pertahankan semua elemen"
    
    source_url = "https://cdn.evolink.ai/images/original.jpg"
    
    edits = [
        ("ganti_background", edit_1_prompt, "1K"),
        ("tambah_tanaman", edit_2_prompt, "1K"),
        ("color_grade", edit_3_prompt, "2K"),  # Final edit di 2K
    ]
    
    current_url = source_url
    
    for name, prompt, quality in edits:
        print(f"\n🔄 Edit: {name}")
        
        response = client.generate_image(
            prompt=prompt,
            size="1:1",
            quality=quality,
            image_urls=[current_url],
            output_format="png"
        )
        
        task_id = response.get("id")
        result = client.wait_for_completion(task_id, timeout=180)
        
        current_url = result.get("results", [None])[0]
        
        if current_url:
            filepath = f"output/chain_{name}.png"
            download_image(current_url, filepath)
            print(f"✅ {name} selesai → {filepath}")
        else:
            print(f"❌ {name} gagal")
            break
    
    print(f"\n🎉 Chain edit selesai! URL final: {current_url}")
    return current_url

# batch_generate.py
from utils.api_client import SeedreamClient
from utils.image_helper import download_image
import json

def brand_batch_generation():
    client = SeedreamClient()
    
    # Referensi: mood board brand
    brand_ref = "https://example.com/brand-moodboard.jpg"
    
    products = [
        {
            "name": "earbuds_matte_black",
            "prompt": """Same lighting and palette as reference, product shot 
            earbuds wireless matte-black di permukaan linen krem, top-down, 
            soft directional key dari kiri atas"""
        },
        {
            "name": "smartwatch_titanium",
            "prompt": """Same lighting and palette as reference, product shot 
            smartwatch titanium di permukaan linen krem, top-down, 
            soft directional key dari kiri atas"""
        },
        {
            "name": "speaker_cylindrical",
            "prompt": """Same lighting and palette as reference, product shot 
            speaker portable cylindrical fabric mesh di permukaan linen krem, 
            top-down, soft directional key dari kiri atas"""
        },
    ]
    
    # Generate dalam 3 rasio aspek
    aspect_ratios = ["1:1", "4:5", "16:9"]
    
    results = []
    
    for product in products:
        for ratio in aspect_ratios:
            task_name = f"{product['name']}_{ratio}"
            print(f"\n📸 Generate: {task_name}")
            
            response = client.generate_image(
                prompt=product["prompt"],
                size=ratio,
                quality="1K",  # Iterasi di 1K dulu
                image_urls=[brand_ref],
                output_format="jpeg"
            )
            
            task_id = response.get("id")
            result = client.wait_for_completion(task_id, timeout=120)
            
            image_url = result.get("results", [None])[0]
            
            if image_url:
                filepath = f"output/batch/{task_name}.jpg"
                download_image(image_url, filepath)
                print(f"✅ {task_name} → {filepath}")
                results.append({
                    "name": task_name,
                    "url": image_url,
                    "local": filepath,
                    "credits": result.get("usage", {}).get("credits_used")
                })
            else:
                print(f"❌ {task_name} gagal")
    
    # Summary
    print(f"\n📊 Batch selesai: {len(results)} gambar berhasil")
    total_credits = sum(r.get("credits", 0) or 0 for r in results)
    print(f"💰 Total credits: {total_credits}")
    
    # Save manifest
    with open("output/batch/manifest.json", "w") as f:
        json.dump(results, f, indent=2)
    
    return results

if __name__ == "__main__":
    brand_batch_generation()

# main.py (tambahkan fungsi)

def generate_infographic():
    client = SeedreamClient()
    
    prompt = """Buat infografis vertikal 4:5 tentang "Jenis-Jenis Kopi Indonesia". 
    Desain: modern, bersih, profesional, mudah dipahami. 
    Palet warna: krem hangat, cokelat tua, hijau zaitun, dan emas muted.
    
    Layout: 5 bagian vertikal yang terhubung dengan garis tipis:
    1. "Kopi Arabica" - ilustrasi biji kopi, deskripsi singkat, tingkat kafein
    2. "Kopi Robusta" - ilustrasi biji kopi, deskripsi singkat, tingkat kafein  
    3. "Kopi Liberica" - ilustrasi biji kopi, deskripsi singkat, tingkat kafein
    4. "Kopi Excelsa" - ilustrasi biji kopi, deskripsi singkat, tingkat kafein
    5. "Tips Brewing" - 3 tips singkat dengan ikon
    
    Gaya: editorial premium, tipografi jelas, white space cukup, 
    tidak ada teks acak atau paragraf fake. Semua teks harus readable 
    dan relevan."""
    
    print("📊 Generate infografis...")
    
    response = client.generate_image(
        prompt=prompt,
        size="4:5",
        quality="2K",  # 2K untuk infografis karena teks harus crisp
        output_format="png"  # PNG untuk teks yang sharp
    )
    
    task_id = response.get("id")
    result = client.wait_for_completion(task_id, timeout=180)
    
    image_url = result.get("results", [None])[0]
    if image_url:
        filepath = download_image(image_url, "output/infographic_kopi.png")
        print(f"✅ Infografis tersimpan: {filepath}")
        
        info = get_image_info(filepath)
        print(f"📐 Dimensi: {info['dimensions']}")
        print(f"📦 Ukuran: {info['size_kb']} KB")
    
    return result

# webhook_server.py
from flask import Flask, request, jsonify
import hmac
import hashlib
import os

app = Flask(__name__)

WEBHOOK_SECRET = os.getenv("WEBHOOK_SECRET", "your_webhook_secret")

def verify_signature(payload, signature):
    """Verifikasi signature webhook untuk keamanan."""
    expected = hmac.new(
        WEBHOOK_SECRET.encode(),
        payload,
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(expected, signature)

@app.route("/webhooks/seedream", methods=["POST"])
def handle_webhook():
    payload = request.get_data()
    signature = request.headers.get("X-Webhook-Signature", "")
    
    if not verify_signature(payload, signature):
        return jsonify({"error": "Invalid signature"}), 401
    
    data = request.json
    status = data.get("status")
    task_id = data.get("id")
    
    print(f"📬 Webhook received: Task {task_id} → {status}")
    
    if status == "completed":
        results = data.get("results", [])
        usage = data.get("usage", {})
        
        print(f"✅ Task completed!")
        print(f"📷 Images: {len(results)}")
        print(f"💰 Credits: {usage.get('credits_used', 'N/A')}")
        
        # TODO: Process results — download, save to DB, notify team, etc.
        for i, url in enumerate(results):
            print(f"   Image {i+1}: {url}")
        
        # Contoh: simpan ke database
        # save_to_database(task_id, results, usage)
        
    elif status == "failed":
        error = data.get("error", "Unknown error")
        print(f"❌ Task failed: {error}")
        # TODO: Alert team, retry logic, etc.
    
    return jsonify({"received": True}), 200

if __name__ == "__main__":
    app.run(port=5000, debug=True)

# async_submit.py
from utils.api_client import SeedreamClient

def submit_with_callback():
    client = SeedreamClient()
    
    prompt = "Hero image produk untuk landing page, earbuds matte black di marble surface"
    
    # Override generate_image untuk include callback
    import requests
    import os
    
    payload = {
        "model": client.model,
        "prompt": prompt,
        "size": "16:9",
        "quality": "2K",
        "model_params": {"output_format": "jpeg"},
        "callback_url": "https://your-domain.com/webhooks/seedream"
    }
    
    response = requests.post(
        f"{client.base_url}/images/generations",
        headers=client.headers,
        json=payload,
        timeout=60
    )
    
    data = response.json()
    print(f"📝 Task submitted: {data.get('id')}")
    print(f"⏳ Estimasi: {data.get('task_info', {}).get('estimated_time')} detik")
    print(f"🔔 Webhook akan dipanggil saat selesai")
    
    return data

if __name__ == "__main__":
    submit_with_callback()

# cost_optimizer.py

# Strategi: iterasi di 1K, finalize di 2K
def smart_generation_workflow(client, prompt, reference_urls=None):
    """
    Workflow hemat credit: iterasi di 1K, finalize di 2K.
    """
    # Tahap 1: Generate 3 varian di 1K untuk pilih yang terbaik
    variants = []
    for i in range(3):
        response = client.generate_image(
            prompt=prompt,
            size="1:1",
            quality="1K",  # Hemat credit
            image_urls=reference_urls,
            output_format="jpeg"
        )
        result = client.wait_for_completion(response.get("id"))
        variants.append(result)
    
    # Cost 3 varian 1K: ~$0.117
    print(f"3 varian 1K selesai. Total cost: ~$0.117")
    
    # TODO: Pilih varian terbaik (manual atau automated scoring)
    best_variant_idx = 0  # Misal pilih yang pertama
    best_url = variants[best_variant_idx].get("results", [None])[0]
    
    # Tahap 2: Final edit di 2K
    final_response = client.generate_image(
        prompt=f"Upscale dan refine: {prompt}",
        size="1:1",
        quality="2K",  # Kualitas final
        image_urls=[best_url] + (reference_urls or []),
        output_format="png"
    )
    
    final_result = client.wait_for_completion(final_response.get("id"), timeout=180)
    
    # Cost final 2K: ~$0.077
    total_cost = 0.117 + 0.077
    print(f"Total cost workflow: ~${total_cost:.3f}")
    
    return final_result

# ecommerce_pipeline.py
from utils.api_client import SeedreamClient
from utils.image_helper import download_image
import json
import time

class EcommercePipeline:
    def __init__(self):
        self.client = SeedreamClient()
        self.brand_ref = None  # Akan di-set di tahap 1
    
    def setup_brand_reference(self, moodboard_url):
        """Tahap 1: Set reference brand."""
        self.brand_ref = moodboard_url
        print(f"🎨 Brand reference: {moodboard_url}")
    
    def batch_generate_skus(self, sku_list):
        """Tahap 2: Generate semua SKU di 1K."""
        results = []
        
        for sku in sku_list:
            prompt = f"""Same lighting and palette as reference. 
            Product shot {sku['product_name']}, {sku['material']}, 
            {sku['color']}. Top-down view, soft directional lighting dari kiri atas, 
            permukaan linen krem, background bersih, fotografi produk komersial."""
            
            response = self.client.generate_image(
                prompt=prompt,
                size="1:1",  # Square untuk marketplace
                quality="1K",
                image_urls=[self.brand_ref] if self.brand_ref else None,
                output_format="jpeg"
            )
            
            task_id = response.get("id")
            result = self.client.wait_for_completion(task_id, timeout=120)
            
            image_url = result.get("results", [None])[0]
            
            if image_url:
                filepath = f"output/ecommerce/{sku['sku_id']}.jpg"
                download_image(image_url, filepath)
                
                results.append({
                    "sku_id": sku["sku_id"],
                    "name": sku["product_name"],
                    "image_url": image_url,
                    "local_path": filepath,
                    "credits": result.get("usage", {}).get("credits_used")
                })
                print(f"✅ {sku['sku_id']}: {sku['product_name']}")
            
            # Rate limit: jeda 1 detik antar request
            time.sleep(1)
        
        return results
    
    def finalize_best_shots(self, batch_results, selected_indices):
        """Tahap 3: Finalize pilihan di 2K."""
        finalized = []
        
        for idx in selected_indices:
            item = batch_results[idx]
            
            # Edit: refine dan upscale ke 2K
            edit_prompt = f"""Refine dan tingkatkan kualitas gambar produk ini. 
            Pertahankan posisi dan identitas produk. Tingkatkan detail teksture 
            dan lighting. Output premium quality."""
            
            response = self.client.generate_image(
                prompt=edit_prompt,
                size="1:1",
                quality="2K",
                image_urls=[item["image_url"]],
                output_format="png"
            )
            
            result = self.client.wait_for_completion(
                response.get("id"), timeout=180
            )
            
            final_url = result.get("results", [None])[0]
            if final_url:
                filepath = f"output/ecommerce/final_{item['sku_id']}.png"
                download_image(final_url, filepath)
                finalized.append({
                    **item,
                    "final_url": final_url,
                    "final_path": filepath
                })
                print(f"✅ Finalized: {item['sku_id']}")
        
        return finalized

# Contoh penggunaan
if __name__ == "__main__":
    pipeline = EcommercePipeline()
    
    # Tahap 1: Set reference
    pipeline.setup_brand_reference("https://example.com/brand-moodboard.jpg")
    
    # Tahap 2: Batch generate (contoh 5 SKU)
    skus = [
        {"sku_id": "KAOS-001", "product_name": "kaos oversize", "material": "katun", "color": "hitam"},
        {"sku_id": "KAOS-002", "product_name": "kaos oversize", "material": "katun", "color": "putih"},
        {"sku_id": "HOOD-001", "product_name": "hoodie", "material": "fleece", "color": "navy"},
        {"sku_id": "CEL-001", "product_name": "celana jogger", "material": "twill", "color": "krem"},
        {"sku_id": "JKT-001", "product_name": "jaket bomber", "material": "parasut", "color": "olive"},
    ]
    
    batch = pipeline.batch_generate_skus(skus)
    
    # Tahap 3: Finalize semua
    selected = list(range(len(batch)))  # Pilih semua
    finals = pipeline.finalize_best_shots(batch, selected)
    
    # Summary
    print(f"\n📊 Pipeline selesai!")
    print(f"Total SKU: {len(skus)}")
    print(f"Batch 1K: {len(batch)} gambar")
    print(f"Final 2K: {len(finals)} gambar")

{"error": "Invalid API key"}

# Cek apakah API key ter-load
python -c "from dotenv import load_dotenv; load_dotenv(); import os; print(os.getenv('SEEDREAM_API_KEY'))"

{"error": "Rate limit exceeded"}

import time

def rate_limited_generate(client, prompt, max_per_minute=10, **kwargs):
    """Generate dengan rate limiting."""
    min_interval = 60 / max_per_minute  # 6 detik antar request untuk 10/min
    
    # TODO: Track last request time globally atau per-class
    time.sleep(min_interval)
    
    return client.generate_image(prompt=prompt, **kwargs)

{"error": "Internal server error"}

import time

def retry_with_backoff(func, max_retries=3, initial_delay=5):
    """Retry function dengan exponential backoff."""
    for attempt in range(max_retries):
        try:
            return func()
        except Exception as e:
            if attempt == max_retries - 1:
                raise
            
            delay = initial_delay * (2 ** attempt)
            print(f"⚠️ Attempt {attempt+1} failed: {e}")
            print(f"⏳ Retrying in {delay} seconds...")
            time.sleep(delay)

{"status": "failed", "error": "Content policy violation"}

def safe_download(client, task_id, filepath, max_wait=120):
    """Submit, wait, dan download dalam satu fungsi."""
    result = client.wait_for_completion(task_id, timeout=max_wait)
    
    image_url = result.get("results", [None])[0]
    if not image_url:
        raise Exception("No image URL in result")
    
    # Download SEGERA — URL expired dalam 24 jam
    download_image(image_url, filepath)
    
    # Simpan metadata
    metadata = {
        "task_id": task_id,
        "url": image_url,
        "local_path": filepath,
        "usage": result.get("usage"),
        "timestamp": time.time()
    }
    
    with open(f"{filepath}.meta.json", "w") as f:
        json.dump(metadata, f, indent=2)
    
    return filepath

def prompt_versioning(client, base_prompt, seeds=[41, 42, 43]):
    """Generate varian dengan seed berbeda untuk A/B testing."""
    variants = []
    
    for seed in seeds:
        # Catatan: parameter seed mungkin belum tersedia di semua platform
        # Cek dokumentasi platform masing-masing
        response = client.generate_image(
            prompt=base_prompt,
            size="1:1",
            quality="1K"
        )
        
        result = client.wait_for_completion(response.get("id"))
        variants.append({
            "seed": seed,
            "result": result
        })
    
    return variants

from PIL import Image
import numpy as np

def check_image_quality(filepath):
    """Cek kualitas dasar gambar hasil."""
    img = Image.open(filepath)
    arr = np.array(img)
    
    checks = {
        "dimensions": img.size,
        "is_grayscale": len(arr.shape) == 2 or arr.shape[2] == 1,
        "mean_brightness": float(arr.mean()),
        "std_brightness": float(arr.std()),
        "is_too_dark": float(arr.mean()) < 30,
        "is_too_bright": float(arr.mean()) > 225,
    }
    
    issues = []
    if checks["is_too_dark"]:
        issues.append("Gambar terlalu gelap")
    if checks["is_too_bright"]:
        issues.append("Gambar terlalu terang")
    if checks["std_brightness"] < 10:
        issues.append("Kontras terlalu rendah")
    
    return {"checks": checks, "issues": issues}

PROMPT_TEMPLATES = {
    "product_hero_square": {
        "template": "Product shot {product}, {material}, {color}. "
                    "Top-down view, soft directional lighting dari kiri atas, "
                    "permukaan {surface}, background bersih, "
                    "fotografi produk komersial, ultra detail.",
        "params": ["product", "material", "color", "surface"]
    },
    "lifestyle_context": {
        "template": "Lifestyle shot {product} di {setting}. "
                    "Model {model_desc} menggunakan {product}. "
                    "Natural lighting, candid feel, "
                    "editorial photography style.",
        "params": ["product", "setting", "model_desc"]
    },
    "infographic_educational": {
        "template": "Infografis vertikal 4:5 tentang {topic}. "
                    "Desain modern, bersih, profesional. "
                    "Palet: {palette}. Layout: {layout_desc}. "
                    "Tidak ada teks acak atau paragraf fake.",
        "params": ["topic", "palette", "layout_desc"]
    }
}

def build_prompt(template_name, **kwargs):
    """Build prompt dari template."""
    template = PROMPT_TEMPLATES.get(template_name)
    if not template:
        raise ValueError(f"Template '{template_name}' tidak ditemukan")
    
    return template["template"].format(**kwargs)

# upload_to_s3.py
import boto3
import os

def upload_to_s3(filepath, bucket_name, s3_key=None):
    """Upload gambar hasil ke S3 untuk storage permanen."""
    s3 = boto3.client(
        "s3",
        aws_access_key_id=os.getenv("AWS_ACCESS_KEY"),
        aws_secret_access_key=os.getenv("AWS_SECRET_KEY"),
        region_name=os.getenv("AWS_REGION", "ap-southeast-1")
    )
    
    if not s3_key:
        s3_key = f"seedream-output/{os.path.basename(filepath)}"
    
    s3.upload_file(filepath, bucket_name, s3_key)
    
    url = f"https://{bucket_name}.s3.{os.getenv('AWS_REGION')}.amazonaws.com/{s3_key}"
    print(f"☁️ Uploaded to S3: {url}")
    
    return url

# db_logger.py
import sqlite3
import json
from datetime import datetime

def log_generation(filepath, prompt, task_id, credits_used, status="completed"):
    """Log setiap generate ke SQLite untuk tracking."""
    conn = sqlite3.connect("seedream_log.db")
    cursor = conn.cursor()
    
    cursor.execute("""
        CREATE TABLE IF NOT EXISTS generations (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            timestamp TEXT,
            filepath TEXT,
            prompt TEXT,
            task_id TEXT,
            credits_used REAL,
            status TEXT
        )
    """)
    
    cursor.execute(
        "INSERT INTO generations VALUES (NULL, ?, ?, ?, ?, ?, ?)",
        (datetime.now().isoformat(), filepath, prompt, task_id, credits_used, status)
    )
    
    conn.commit()
    conn.close()
    print(f"📝 Logged to database: {task_id}")

# slack_notify.py
import requests
import os

def notify_slack(message, webhook_url=None):
    """Kirim notifikasi ke Slack saat generate selesai."""
    webhook_url = webhook_url or os.getenv("SLACK_WEBHOOK_URL")
    
    if not webhook_url:
        print("⚠️ SLACK_WEBHOOK_URL tidak di-set")
        return
    
    payload = {"text": message}
    response = requests.post(webhook_url, json=payload)
    
    if response.status_code == 200:
        print("✅ Notifikasi Slack terkirim")
    else:
        print(f"❌ Slack error: {response.status_code}")