Nano Banana Pro로 광고 소재를 대량 생성하는 방법? 이커머스 템플릿 기반 광고 집행 4대 실전 전략

import openai
import asyncio
import aiohttp
import json
import os
from typing import List, Dict, Optional
from dataclasses import dataclass
from enum import Enum
import hashlib
from datetime import datetime

class Platform(Enum):
    """광고 플랫폼 열거형"""
    TAOBAO = {"name": "타오바오", "size": "800x800", "ratio": "1:1"}
    JD = {"name": "징동", "size": "800x800", "ratio": "1:1"}
    PINDUODUO = {"name": "핀둬둬", "size": "750x750", "ratio": "1:1"}
    WECHAT_MOMENTS = {"name": "위챗 모먼트", "size": "1280x720", "ratio": "16:9"}
    DOUYIN = {"name": "도우인(틱톡)", "size": "1080x1920", "ratio": "9:16"}
    XIAOHONGSHU = {"name": "샤오홍슈", "size": "1242x1660", "ratio": "3:4"}

@dataclass
class AdTemplate:
    """광고 템플릿 데이터 클래스"""
    name: str
    prompt_template: str
    style: str
    platform: Platform
    negative_prompt: Optional[str] = None

@dataclass
class ProductData:
    """제품 데이터 클래스"""
    sku: str
    name: str
    category: str
    selling_points: List[str]
    price: float
    discount: Optional[str] = None
    reference_images: List[str] = None

class NanoBananaProAdGenerator:
    """Nano Banana Pro 광고 소재 일괄 생성기"""

    def __init__(self, api_key: str, base_url: str = "https://api.apiyi.com/v1"):
        self.client = openai.OpenAI(api_key=api_key, base_url=base_url)
        self.cache_dir = "./ad_cache"
        self.output_dir = "./generated_ads"
        os.makedirs(self.cache_dir, exist_ok=True)
        os.makedirs(self.output_dir, exist_ok=True)

    def _generate_cache_key(self, product: ProductData, template: AdTemplate) -> str:
        """캐시 키 생성"""
        data = f"{product.sku}_{template.name}_{template.platform.name}"
        return hashlib.md5(data.encode()).hexdigest()

    def _check_cache(self, cache_key: str) -> Optional[str]:
        """캐시 확인"""
        cache_file = f"{self.cache_dir}/{cache_key}.json"
        if os.path.exists(cache_file):
            with open(cache_file, 'r', encoding='utf-8') as f:
                cache_data = json.load(f)
                return cache_data.get('image_url')
        return None

    def _save_cache(self, cache_key: str, image_url: str, metadata: Dict):
        """캐시 저장"""
        cache_file = f"{self.cache_dir}/{cache_key}.json"
        cache_data = {
            "image_url": image_url,
            "generated_at": datetime.now().isoformat(),
            "metadata": metadata
        }
        with open(cache_file, 'w', encoding='utf-8') as f:
            json.dump(cache_data, f, ensure_ascii=False, indent=2)

    def build_prompt(self, product: ProductData, template: AdTemplate) -> str:
        """프롬프트 구성"""
        selling_point = product.selling_points[0] if product.selling_points else "프리미엄 상품"
        discount_text = product.discount if product.discount else "판매 중"

        prompt = template.prompt_template.format(
            product_name=product.name,
            category=product.category,
            selling_point=selling_point,
            price=product.price,
            discount=discount_text,
            style=template.style,
            platform=template.platform.value["name"]
        )

        return prompt

    async def generate_single_ad(
        self,
        product: ProductData,
        template: AdTemplate,
        use_cache: bool = True
    ) -> Dict:
        """단일 광고 소재 생성"""

        # 캐시 확인
        cache_key = self._generate_cache_key(product, template)
        if use_cache:
            cached_url = self._check_cache(cache_key)
            if cached_url:
                return {
                    "success": True,
                    "from_cache": True,
                    "product_sku": product.sku,
                    "template": template.name,
                    "platform": template.platform.name,
                    "image_url": cached_url
                }

        # 프롬프트 생성
        prompt = self.build_prompt(product, template)

        try:
            # API 호출
            response = self.client.images.generate(
                model="nano-banana-pro",
                prompt=prompt,
                size=template.platform.value["size"],
                n=1,
                response_format="url"
            )

            image_url = response.data[0].url

            # 캐시 저장
            metadata = {
                "product": product.name,
                "sku": product.sku,
                "template": template.name,
                "platform": template.platform.name,
                "prompt": prompt
            }
            self._save_cache(cache_key, image_url, metadata)

            return {
                "success": True,
                "from_cache": False,
                "product_sku": product.sku,
                "template": template.name,
                "platform": template.platform.name,
                "image_url": image_url,
                "prompt": prompt
            }

        except Exception as e:
            return {
                "success": False,
                "product_sku": product.sku,
                "template": template.name,
                "platform": template.platform.name,
                "error": str(e)
            }

    async def batch_generate(
        self,
        products: List[ProductData],
        templates: List[AdTemplate],
        max_concurrent: int = 10,
        use_cache: bool = True
    ) -> List[Dict]:
        """광고 소재 일괄 생성"""

        tasks = []
        for product in products:
            for template in templates:
                tasks.append(self.generate_single_ad(product, template, use_cache))

        # 동시 실행 수 제어
        results = []
        for i in range(0, len(tasks), max_concurrent):
            batch = tasks[i:i + max_concurrent]
            batch_results = await asyncio.gather(*batch)
            results.extend(batch_results)

            # 진행 상황 표시
            print(f"진행률: {min(i + max_concurrent, len(tasks))}/{len(tasks)} 완료")

        return results

    def generate_report(self, results: List[Dict]) -> Dict:
        """생성 결과 보고서 작성"""
        total = len(results)
        success = sum(1 for r in results if r.get("success"))
        from_cache = sum(1 for r in results if r.get("from_cache"))
        failed = total - success

        # 플랫폼별 통계
        by_platform = {}
        for result in results:
            if result.get("success"):
                platform = result["platform"]
                if platform not in by_platform:
                    by_platform[platform] = 0
                by_platform[platform] += 1

        return {
            "total_tasks": total,
            "success_count": success,
            "from_cache_count": from_cache,
            "new_generated_count": success - from_cache,
            "failed_count": failed,
            "success_rate": f"{(success/total*100):.1f}%",
            "by_platform": by_platform
        }

# 사용 예시
async def main():
    # 생성기 초기화
    generator = NanoBananaProAdGenerator(
        api_key="your_api_key_here"
    )

    # 광고 템플릿 정의
    templates = [
        AdTemplate(
            name="메인 이미지 템플릿",
            prompt_template="""이커머스 메인 이미지 디자인:
제품: {product_name}
카테고리: {category}
핵심 셀링포인트: {selling_point}
가격: ₩{price}
프로모션 태그: {discount}

디자인 스타일: {style}
플랫폼: {platform}

디자인 요구사항:
1. 제품이 중앙에 위치하며, 비중은 60-70% 정도로 구성
2. 흰색 또는 밝은 톤의 깔끔한 배경
3. 왼쪽 상단에 빨간색 프로모션 태그 배치
4. 오른쪽 하단에 가격 표시
5. 전문적인 상업 사진의 질감 구현

{platform} 플랫폼에 적합한 고품질 이커머스 메인 이미지.""",
            style="미니멀 현대적",
            platform=Platform.TAOBAO
        ),
        AdTemplate(
            name="소셜 미디어용 템플릿",
            prompt_template="""소셜 미디어 광고 디자인:
제품: {product_name}
셀링 포인트: {selling_point}
혜택: {discount}

디자인 스타일: {style}, 일상적인 장면
텍스트: 제품명 및 셀링 포인트 카피

디자인 요구사항:
1. 실제 라이프스타일 장면에서 제품 사용 모습 노출
2. 따뜻하고 자연스러운 분위기
3. 상단에 제품명 표시
4. 하단에 핵심 셀링 포인트 표시
5. {platform} 플랫폼 공유에 최적화된 구성

사실감이 뛰어나고 시선을 사로잡는 디자인.""",
            style="싱그럽고 자연스러운",
            platform=Platform.XIAOHONGSHU
        )
    ]

    # 제품 데이터 준비
    products = [
        ProductData(
            sku="BT-001",
            name="블루투스 이어폰 Pro Max",
            category="디지털 액세서리",
            selling_points=["액티브 노이즈 캔슬링", "40시간 배터리", "HiFi 음질"],
            price=299000,
            discount="한정 50% 할인"
        ),
        ProductData(
            sku="WB-002",
            name="비즈니스 보온병",
            category="생활용품",
            selling_points=["24시간 보온", "316 스테인리스", "누수 방지 설계"],
            price=59000,
            discount="1+1 이벤트"
        )
    ]

    # 일괄 생성 시작
    print("광고 소재 일괄 생성을 시작합니다...")
    results = await generator.batch_generate(
        products=products,
        templates=templates,
        max_concurrent=5,
        use_cache=True
    )

    # 보고서 생성
    report = generator.generate_report(results)

    print("\n" + "="*50)
    print("생성 보고서")
    print("="*50)
    print(f"총 작업 수: {report['total_tasks']}")
    print(f"성공: {report['success_count']} ({report['success_rate']})")
    print(f"캐시 사용: {report['from_cache_count']}")
    print(f"신규 생성: {report['new_generated_count']}")
    print(f"실패: {report['failed_count']}")
    print(f"\n플랫폼별 통계:")
    for platform, count in report['by_platform'].items():
        print(f"  {platform}: {count} 장")

    # 결과 저장
    with open("generation_results.json", "w", encoding="utf-8") as f:
        json.dump(results, f, ensure_ascii=False, indent=2)

    print(f"\n상세 결과가 generation_results.json에 저장되었습니다.")

if __name__ == "__main__":
    asyncio.run(main())