class SNSPromptEngine:
    """플랫폼별 최적화 프롬프트 생성 엔진"""
    
    PLATFORM_CONFIGS = {
        "instagram": {
            "max_chars": 2200,
            "hashtag_count": "20-30개",
            "emoji_count": "5-10개",
            "tone": "감성적이고 친근한",
            "structure": "훅 → 본문 → 해시태그"
        },
        "twitter": {
            "max_chars": 280,
            "hashtag_count": "1-2개",
            "emoji_count": "1-3개",
            "tone": "간결하고 임팩트 있는",
            "structure": "핵심 메시지 → 해시태그"
        },
        "linkedin": {
            "max_chars": 3000,
            "hashtag_count": "3-5개",
            "emoji_count": "2-4개",
            "tone": "전문적이고 인사이트 있는",
            "structure": "훅 → 스토리 → 인사이트 → CTA"
        },
        "blog": {
            "max_chars": 5000,
            "hashtag_count": "없음",
            "emoji_count": "최소화",
            "tone": "정보 전달형, SEO 최적화",
            "structure": "제목 → 서론 → 본문 → 결론"
        }
    }
    
    def generate_prompt(self, platform: str, keyword: str, 
                        brand_info: dict, extra_context: str = "") -> str:
        config = self.PLATFORM_CONFIGS.get(platform, {})
        
        system_prompt = f"""당신은 {platform} 전문 SNS 콘텐츠 마케터입니다.
브랜드: {brand_info.get('name', '일반 브랜드')}
브랜드 톤앤매너: {brand_info.get('tone', '친근하고 전문적')}
타겟 오디언스: {brand_info.get('target', '20-35세 직장인')}

{platform} 콘텐츠 작성 규칙:
- 최대 글자수: {config.get('max_chars')}자
- 해시태그: {config.get('hashtag_count')}
- 이모지: {config.get('emoji_count')}
- 톤: {config.get('tone')}
- 구조: {config.get('structure')}

반드시 JSON 형식으로 응답하세요:
{{
  "content": "메인 콘텐츠",
  "hashtags": ["해시태그1", "해시태그2"],
  "hook": "첫 문장 훅",
  "cta": "행동 유도 문구"
}}"""
        
        user_prompt = f"""키워드: {keyword}
추가 맥락: {extra_context}

위 키워드로 {platform}에 최적화된 콘텐츠를 작성해주세요."""
        
        return system_prompt, user_prompt

import asyncio
from openai import AsyncOpenAI
import json

class AsyncContentGenerator:
    def __init__(self, api_key: str):
        self.client = AsyncOpenAI(api_key=api_key)
        self.prompt_engine = SNSPromptEngine()
    
    async def generate_single(self, platform: str, keyword: str, 
                               brand_info: dict) -> dict:
        """단일 플랫폼 콘텐츠 생성"""
        system_prompt, user_prompt = self.prompt_engine.generate_prompt(
            platform, keyword, brand_info
        )
        
        try:
            response = await self.client.chat.completions.create(
                model="gpt-4o-mini",
                messages=[
                    {"role": "system", "content": system_prompt},
                    {"role": "user", "content": user_prompt}
                ],
                response_format={"type": "json_object"},
                temperature=0.75,
                max_tokens=1000
            )
            
            content = json.loads(response.choices[0].message.content)
            return {
                "platform": platform,
                "status": "success",
                "data": content,
                "tokens_used": response.usage.total_tokens
            }
        except Exception as e:
            return {
                "platform": platform,
                "status": "error",
                "error": str(e)
            }
    
    async def generate_all_platforms(self, keyword: str, 
                                      brand_info: dict,
                                      platforms: list = None) -> dict:
        """모든 플랫폼 동시 병렬 생성"""
        if platforms is None:
            platforms = ["instagram", "twitter", "linkedin", "blog"]
        
        # 모든 플랫폼 동시 실행!
        tasks = [
            self.generate_single(platform, keyword, brand_info)
            for platform in platforms
        ]
        
        results = await asyncio.gather(*tasks, return_exceptions=True)
        
        return {
            result["platform"]: result 
            for result in results 
            if isinstance(result, dict)
        }

# 실행 예시
async def main():
    generator = AsyncContentGenerator(api_key="your-api-key")
    
    brand_info = {
        "name": "코지카페",
        "tone": "따뜻하고 감성적",
        "target": "20-35세 커피 애호가"
    }
    
    results = await generator.generate_all_platforms(
        keyword="가을 신메뉴 호박라떼 출시",
        brand_info=brand_info
    )
    
    for platform, result in results.items():
        print(f"\n=== {platform.upper()} ===")
        if result["status"] == "success":
            print(result["data"]["content"])

asyncio.run(main())

import re
from typing import Optional

class ContentValidator:
    """생성된 콘텐츠 품질 검증기"""
    
    PLATFORM_RULES = {
        "instagram": {
            "max_chars": 2200,
            "min_hashtags": 10,
            "required_fields": ["content", "hashtags"]
        },
        "twitter": {
            "max_chars": 280,
            "min_hashtags": 1,
            "required_fields": ["content"]
        },
        "linkedin": {
            "max_chars": 3000,
            "min_hashtags": 3,
            "required_fields": ["content", "hashtags", "cta"]
        }
    }
    
    def validate(self, platform: str, content_data: dict) -> tuple[bool, list]:
        """
        Returns: (is_valid, error_messages)
        """
        errors = []
        rules = self.PLATFORM_RULES.get(platform, {})
        
        # 필수 필드 체크
        for field in rules.get("required_fields", []):
            if field not in content_data or not content_data[field]:
                errors.append(f"필수 필드 누락: {field}")
        
        # 글자수 체크
        content = content_data.get("content", "")
        max_chars = rules.get("max_chars", 9999)
        if len(content) > max_chars:
            errors.append(f"글자수 초과: {len(content)}/{max_chars}자")
        
        # 해시태그 수 체크
        hashtags = content_data.get("hashtags", [])
        min_hashtags = rules.get("min_hashtags", 0)
        if len(hashtags) < min_hashtags:
            errors.append(f"해시태그 부족: {len(hashtags)}/{min_hashtags}개")
        
        # 금지어 체크 (브랜드 안전성)
        banned_words = ["경쟁사명", "부정적표현"]  # 실제로는 DB에서 로드
        for word in banned_words:
            if word in content:
                errors.append(f"금지어 포함: {word}")
        
        return len(errors) == 0, errors


class RetryableGenerator:
    """재시도 로직이 포함된 콘텐츠 생성기"""
    
    def __init__(self, generator: AsyncContentGenerator, 
                 validator: ContentValidator, max_retries: int = 3):
        self.generator = generator
        self.validator = validator
        self.max_retries = max_retries
    
    async def generate_with_retry(self, platform: str, keyword: str,
                                   brand_info: dict) -> Optional[dict]:
        for attempt in range(self.max_retries):
            result = await self.generator.generate_single(
                platform, keyword, brand_info
            )
            
            if result["status"] == "error":
                print(f"API 오류 (시도 {attempt+1}): {result['error']}")
                await asyncio.sleep(2 ** attempt)  # 지수 백오프
                continue
            
            is_valid, errors = self.validator.validate(
                platform, result["data"]
            )
            
            if is_valid:
                return result
            else:
                print(f"검증 실패 (시도 {attempt+1}): {errors}")
                # 오류 내용을 프롬프트에 피드백해서 재생성
                brand_info["retry_feedback"] = f"이전 생성 오류: {errors}"
        
        return None  # 최대 재시도 초과

# celery_app.py
from celery import Celery
from celery.schedules import crontab

app = Celery('sns_automation', 
             broker='redis://localhost:6379/0',
             backend='redis://localhost:6379/1')

# 스케줄 설정
app.conf.beat_schedule = {
    # 매일 오전 9시 인스타 게시
    'post-instagram-morning': {
        'task': 'tasks.generate_and_post',
        'schedule': crontab(hour=9, minute=0),
        'args': ('instagram', 'daily_morning')
    },
    # 매일 오후 6시 트위터 게시
    'post-twitter-evening': {
        'task': 'tasks.generate_and_post',
        'schedule': crontab(hour=18, minute=0),
        'args': ('twitter', 'daily_evening')
    },
    # 월요일 오전 8시 링크드인 주간 인사이트
    'post-linkedin-weekly': {
        'task': 'tasks.generate_and_post',
        'schedule': crontab(hour=8, minute=0, day_of_week=1),
        'args': ('linkedin', 'weekly_insight')
    }
}

# tasks.py
from celery_app import app
from content_generator import RetryableGenerator
from sns_publishers import InstagramPublisher, TwitterPublisher

@app.task(bind=True, max_retries=3)
def generate_and_post(self, platform: str, content_type: str):
    """콘텐츠 생성 + 게시 통합 태스크"""
    try:
        # 1. 오늘의 키워드 가져오기 (DB에서)
        keyword = get_todays_keyword(content_type)
        brand_info = get_brand_config()
        
        # 2. 콘텐츠 생성
        import asyncio
        result = asyncio.run(
            generator.generate_with_retry(platform, keyword, brand_info)
        )
        
        if not result:
            raise Exception("콘텐츠 생성 실패")
        
        # 3. SNS 게시
        publisher = get_publisher(platform)
        post_id = publisher.publish(result["data"])
        
        # 4. DB에 이력 저장
        save_post_history(platform, keyword, result, post_id)
        
        return {"status": "success", "post_id": post_id}
        
    except Exception as exc:
        raise self.retry(exc=exc, countdown=60 * (self.request.retries + 1))

# OpenAI Batch API 활용 (50% 비용 절감!)
# 대량 콘텐츠 생성 시 매우 효과적

import json
from openai import OpenAI

client = OpenAI(api_key="your-api-key")

# 배치 요청 파일 생성
batch_requests = []
keywords = ["봄 신상품", "여름 세일", "가을 신메뉴", "겨울 이벤트"]

for i, keyword in enumerate(keywords):
    batch_requests.append({
        "custom_id": f"request-{i}",
        "method": "POST",
        "url": "/v1/chat/completions",
        "body": {
            "model": "gpt-4o-mini",
            "messages": [
                {"role": "system", "content": "SNS 콘텐츠 전문가"},
                {"role": "user", "content": f"{keyword} 인스타 캡션 작성"}
            ],
            "max_tokens": 500
        }
    })

# JSONL 파일로 저장
with open("batch_requests.jsonl", "w", encoding="utf-8") as f:
    for req in batch_requests:
        f.write(json.dumps(req, ensure_ascii=False) + "\n")

# 배치 파일 업로드 및 실행
batch_file = client.files.create(
    file=open("batch_requests.jsonl", "rb"),
    purpose="batch"
)

batch = client.batches.create(
    input_file_id=batch_file.id,
    endpoint="/v1/chat/completions",
    completion_window="24h"
)

print(f"배치 ID: {batch.id}")
print("24시간 내 처리 완료, 비용 50% 절감!")

sns-auto-generator/
├── app/
│   ├── __init__.py
│   ├── main.py              # FastAPI 앱 진입점
│   ├── config.py            # 환경변수 설정
│   ├── models/
│   │   ├── content.py       # 콘텐츠 DB 모델
│   │   └── brand.py         # 브랜드 설정 모델
│   ├── services/
│   │   ├── generator.py     # 콘텐츠 생성 서비스
│   │   ├── validator.py     # 검증 서비스
│   │   ├── publisher.py     # SNS 게시 서비스
│   │   └── scheduler.py     # 스케줄링 서비스
│   ├── prompts/
│   │   ├── templates/       # 플랫폼별 프롬프트 템플릿
│   │   │   ├── instagram.txt
│   │   │   ├── twitter.txt
│   │   │   └── linkedin.txt
│   │   └── engine.py        # 프롬프트 엔진
│   ├── api/
│   │   ├── routes/
│   │   │   ├── generate.py  # 생성 API 엔드포인트
│   │   │   ├── schedule.py  # 스케줄 관리 API
│   │   │   └── analytics.py # 분석 API
│   │   └── middleware.py    # 인증, 레이트리밋
│   └── utils/
│       ├── cache.py         # Redis 캐시 유틸
│       └── cost_tracker.py  # 비용 추적
├── celery_worker.py         # Celery 워커
├── celery_beat.py           # Celery 스케줄러
├── requirements.txt
├── docker-compose.yml
└── .env

# app/main.py
from fastapi import FastAPI, HTTPException, Depends
from pydantic import BaseModel
from typing import Optional
import asyncio

app = FastAPI(title="SNS 콘텐츠 자동생성 API", version="1.0.0")

class GenerateRequest(BaseModel):
    keyword: str
    platforms: list[str] = ["instagram", "twitter", "linkedin"]
    brand_id: str
    schedule_time: Optional[str] = None  # ISO 8601 형식
    auto_publish: bool = False

class GenerateResponse(BaseModel):
    job_id: str
    status: str
    contents: dict

@app.post("/api/v1/generate", response_model=GenerateResponse)
async def generate_content(request: GenerateRequest):
    """콘텐츠 생성 API"""
    
    # 브랜드 정보 로드
    brand_info = await get_brand_config(request.brand_id)
    if not brand_info:
        raise HTTPException(status_code=404, detail="브랜드를 찾을 수 없습니다")
    
    # 비동기 병렬 생성
    generator = AsyncContentGenerator(api_key=settings.OPENAI_API_KEY)
    results = await generator.generate_all_platforms(
        keyword=request.keyword,
        brand_info=brand_info,
        platforms=request.platforms
    )
    
    # DB 저장
    job_id = await save_generation_job(request, results)
    
    # 자동 게시 설정
    if request.auto_publish:
        if request.schedule_time:
            # 예약 게시
            schedule_publish.apply_async(
                args=[job_id],
                eta=parse_datetime(request.schedule_time)
            )
        else:
            # 즉시 게시
            publish_content.delay(job_id)
    
    return GenerateResponse(
        job_id=job_id,
        status="success",
        contents=results
    )

@app.get("/api/v1/jobs/{job_id}")
async def get_job_status(job_id: str):
    """생성 작업 상태 조회"""
    job = await get_job(job_id)
    if not job:
        raise HTTPException(status_code=404, detail="작업을 찾을 수 없습니다")
    return job

# docker-compose.yml
version: '3.8'

services:
  api:
    build: .
    ports:
      - "8000:8000"
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - DATABASE_URL=${DATABASE_URL}
      - REDIS_URL=redis://redis:6379
    depends_on:
      - redis
      - db
    command: uvicorn app.main:app --host 0.0.0.0 --port 8000

  celery_worker:
    build: .
    command: celery -A celery_worker worker --loglevel=info --concurrency=4
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - REDIS_URL=redis://redis:6379
    depends_on:
      - redis

  celery_beat:
    build: .
    command: celery -A celery_beat beat --loglevel=info
    depends_on:
      - redis

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

  db:
    image: postgres:15-alpine
    environment:
      - POSTGRES_DB=sns_automation
      - POSTGRES_USER=${DB_USER}
      - POSTGRES_PASSWORD=${DB_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

# 성과 추적 및 분석 모듈
class PerformanceTracker:
    """콘텐츠 성과 추적 및 AI 피드백 루프"""
    
    def track_post_performance(self, post_id: str, 
                                platform: str) -> dict:
        """게시물 성과 데이터 수집"""
        metrics = {}
        
        if platform == "instagram":
            # Instagram Insights API
            metrics = {
                "likes": self.get_instagram_likes(post_id),
                "comments": self.get_instagram_comments(post_id),
                "reach": self.get_instagram_reach(post_id),
                "saves": self.get_instagram_saves(post_id),
                "engagement_rate": self.calc_engagement_rate(metrics)
            }
        elif platform == "twitter":
            # Twitter Analytics API
            metrics = {
                "likes": self.get_twitter_likes(post_id),
                "retweets": self.get_twitter_retweets(post_id),
                "impressions": self.get_twitter_impressions(post_id),
                "clicks": self.get_twitter_clicks(post_id)
            }
        
        # DB에 성과 저장
        self.save_metrics(post_id, platform, metrics)
        return metrics
    
    def generate_performance_report(self, 
                                     date_range: tuple) -> dict:
        """기간별 성과 리포트 생성"""
        posts = self.get_posts_in_range(date_range)
        
        # GPT로 성과 분석 인사이트 생성
        client = OpenAI(api_key=API_KEY)
        analysis = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{
                "role": "user",
                "content": f"""
다음 SNS 콘텐츠 성과 데이터를 분석해줘:
{json.dumps(posts, ensure_ascii=False, indent=2)}

분석 항목:
1. 가장 높은 참여율을 보인 콘텐츠 패턴
2. 최적 게시 시간대
3. 효과적인 해시태그 조합
4. 다음 달 콘텐츠 전략 제안

JSON 형식으로 응답해줘.
"""
            }],
            response_format={"type": "json_object"}
        )
        
        return json.loads(analysis.choices[0].message.content)

# Rate Limit 처리 미들웨어
import time
from collections import deque

class RateLimiter:
    """OpenAI API Rate Limit 관리"""
    
    def __init__(self, rpm_limit: int = 500, tpm_limit: int = 200000):
        self.rpm_limit = rpm_limit
        self.tpm_limit = tpm_limit
        self.request_times = deque()
        self.token_usage = deque()
    
    def wait_if_needed(self, estimated_tokens: int = 1000):
        """필요시 대기 후 요청 허용"""
        now = time.time()
        
        # 1분 이전 기록 제거
        while self.request_times and now - self.request_times[0] > 60:
            self.request_times.popleft()
        
        # RPM 체크
        if len(self.request_times) >= self.rpm_limit:
            sleep_time = 60 - (now - self.request_times[0])
            if sleep_time > 0:
                print(f"Rate limit 대기: {sleep_time:.1f}초")
                time.sleep(sleep_time)
        
        self.request_times.append(time.time())

# 최소 구현 (MVP) - 이것만 있어도 동작해!
# pip install openai

from openai import OpenAI
import json

client = OpenAI(api_key="sk-your-api-key-here")

def generate_sns_content(keyword: str, platform: str) -> dict:
    """키워드 → SNS 콘텐츠 즉시 생성"""
    
    platform_rules = {
        "instagram": "감성적, 이모지 5개, 해시태그 20개, 2200자 이내",
        "twitter": "간결하게 280자 이내, 해시태그 2개",
        "linkedin": "전문적, 인사이트 포함, 해시태그 5개"
    }
    
    response = client.chat.completions.create(
        model="gpt-4o-mini",  # 가성비 최고!
        messages=[
            {
                "role": "system",
                "content": f"당신은 {platform} 전문 SNS 마케터입니다. 규칙: {platform_rules.get(platform, '')}"
            },
            {
                "role": "user", 
                "content": f"키워드 '{keyword}'로 {platform} 콘텐츠를 JSON으로 작성해줘. 형식: {{\"content\": \"...\", \"hashtags\": [...]}}"
            }
        ],
        response_format={"type": "json_object"},
        temperature=0.8
    )
    
    return json.loads(response.choices[0].message.content)

# 실행!
if __name__ == "__main__":
    keyword = input("키워드를 입력하세요: ")
    
    for platform in ["instagram", "twitter", "linkedin"]:
        print(f"\n{'='*40}")
        print(f"📱 {platform.upper()}")
        print('='*40)
        result = generate_sns_content(keyword, platform)
        print(result["content"])
        print("\n해시태그:", " ".join([f"#{tag}" for tag in result.get("hashtags", [])]))