Step 1: 프로젝트 초기 설정

먼저 프로젝트 폴더 구조를 만들자. 깔끔한 구조가 나중에 유지보수를 훨씬 쉽게 만들어줘.

blog_automation/
│
├── config/
│   ├── __init__.py
│   ├── settings.py          # 전역 설정
│   └── prompts.py           # AI 프롬프트 템플릿
│
├── modules/
│   ├── __init__.py
│   ├── topic_generator.py   # 주제 생성
│   ├── content_creator.py   # 콘텐츠 생성
│   ├── quality_checker.py   # 품질 검증
│   └── publisher.py         # 발행 관리
│
├── utils/
│   ├── __init__.py
│   ├── api_handler.py       # API 통신
│   ├── database.py          # DB 관리
│   └── logger.py            # 로깅
│
├── data/
│   ├── topics.json          # 주제 데이터
│   ├── published.json       # 발행 기록
│   └── templates/           # 글 템플릿
│
├── .env                     # 환경 변수 (API 키 등)
├── requirements.txt         # 필요한 패키지 목록
├── main.py                  # 메인 실행 파일
└── README.md               # 프로젝트 설명

이제 필요한 패키지들을 설치하자. 터미널을 열고 프로젝트 폴더로 이동한 다음:

# 가상환경 생성 (선택사항이지만 강력 추천!)
python -m venv venv

# 가상환경 활성화
# Windows:
venv\Scripts\activate
# Mac/Linux:
source venv/bin/activate

# 필요한 패키지 설치
pip install openai anthropic google-generativeai
pip install requests beautifulsoup4 lxml
pip install schedule python-dotenv
pip install selenium webdriver-manager
pip install Pillow  # 이미지 처리용
pip install python-slugify  # URL 슬러그 생성용

Step 2: 환경 설정 파일 만들기

먼저 .env 파일을 만들어서 API 키와 중요한 설정들을 저장하자:

# .env 파일
# OpenAI 설정
OPENAI_API_KEY=your_openai_api_key_here
OPENAI_MODEL=gpt-4-turbo-preview

# Anthropic Claude 설정
ANTHROPIC_API_KEY=your_anthropic_api_key_here
ANTHROPIC_MODEL=claude-3-sonnet-20240229

# Google Gemini 설정
GOOGLE_API_KEY=your_google_api_key_here
GOOGLE_MODEL=gemini-pro

# 블로그 설정 (티스토리 예시)
TISTORY_ACCESS_TOKEN=your_tistory_token_here
TISTORY_BLOG_NAME=your_blog_name

# 발행 설정
POSTS_PER_DAY=3
MIN_QUALITY_SCORE=70
AUTO_PUBLISH=true

# 데이터베이스 (SQLite 사용)
DATABASE_PATH=./data/blog_automation.db

다음은 config/settings.py 파일:

import os
from dotenv import load_dotenv

# .env 파일 로드
load_dotenv()

class Settings:
    """전역 설정 클래스"""
    
    # AI 설정
    OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
    OPENAI_MODEL = os.getenv('OPENAI_MODEL', 'gpt-4-turbo-preview')
    
    ANTHROPIC_API_KEY = os.getenv('ANTHROPIC_API_KEY')
    ANTHROPIC_MODEL = os.getenv('ANTHROPIC_MODEL', 'claude-3-sonnet-20240229')
    
    GOOGLE_API_KEY = os.getenv('GOOGLE_API_KEY')
    GOOGLE_MODEL = os.getenv('GOOGLE_MODEL', 'gemini-pro')
    
    # 블로그 설정
    TISTORY_ACCESS_TOKEN = os.getenv('TISTORY_ACCESS_TOKEN')
    TISTORY_BLOG_NAME = os.getenv('TISTORY_BLOG_NAME')
    
    # 발행 설정
    POSTS_PER_DAY = int(os.getenv('POSTS_PER_DAY', 3))
    MIN_QUALITY_SCORE = int(os.getenv('MIN_QUALITY_SCORE', 70))
    AUTO_PUBLISH = os.getenv('AUTO_PUBLISH', 'true').lower() == 'true'
    
    # 데이터베이스
    DATABASE_PATH = os.getenv('DATABASE_PATH', './data/blog_automation.db')
    
    # 글 작성 설정
    MIN_WORD_COUNT = 1500  # 최소 단어 수
    MAX_WORD_COUNT = 3000  # 최대 단어 수
    
    # 스케줄 설정
    PUBLISH_TIMES = ['09:00', '14:00', '19:00']  # 발행 시간대
    
    @classmethod
    def validate(cls):
        """필수 설정 값 검증"""
        required = [
            'OPENAI_API_KEY',
            'TISTORY_ACCESS_TOKEN',
            'TISTORY_BLOG_NAME'
        ]
        
        missing = []
        for key in required:
            if not getattr(cls, key):
                missing.append(key)
        
        if missing:
            raise ValueError(f"필수 설정이 누락되었습니다: {', '.join(missing)}")
        
        return True

# 설정 검증
Settings.validate()

Step 3: AI 프롬프트 템플릿 설계

좋은 프롬프트가 좋은 글을 만들어. 여러 상황에 맞는 템플릿을 준비해두자.
config/prompts.py 파일:

class PromptTemplates:
    """AI 프롬프트 템플릿 모음"""
    
    # 기본 블로그 글 작성 프롬프트
    BLOG_POST_BASE = """
당신은 전문 블로그 작가입니다. 다음 주제로 독자들에게 유익하고 재미있는 블로그 글을 작성해주세요.

주제: {topic}
키워드: {keywords}
글 유형: {post_type}
목표 독자: {target_audience}

작성 가이드라인:
1. 친근하고 대화하는 듯한 톤으로 작성
2. 실용적인 정보와 구체적인 예시 포함
3. 적절한 소제목으로 구조화
4. SEO를 고려한 자연스러운 키워드 배치
5. 최소 {min_words}자 이상 작성

글의 구조:
- 흥미로운 도입부 (독자의 관심 끌기)
- 본문 (3-5개의 소제목으로 구성)
- 실용적인 팁이나 조언
- 행동을 유도하는 마무리

추가 요구사항:
{additional_requirements}
"""

    # 정보성 글 프롬프트
    INFORMATIVE_POST = """
다음 주제에 대한 상세하고 정확한 정보를 제공하는 글을 작성해주세요.

주제: {topic}

요구사항:
- 객관적이고 사실에 기반한 정보
- 최신 데이터와 통계 포함
- 전문 용어는 쉽게 풀어서 설명
- 단계별 설명이 필요한 경우 번호 매기기
- 관련 예시나 사례 연구 포함

글자 수: {min_words}자 이상
"""

    # 리뷰/비교 글 프롬프트
    REVIEW_POST = """
다음 제품/서비스에 대한 솔직하고 상세한 리뷰를 작성해주세요.

대상: {topic}
비교 대상: {comparison_items}

포함할 내용:
1. 개요 및 첫인상
2. 주요 특징 및 장점
3. 단점 및 개선점
4. 다른 제품과의 비교
5. 가격 대비 가치 평가
6. 추천 대상
7. 최종 평가 및 결론

작성 스타일:
- 균형 잡힌 시각 (장단점 모두 언급)
- 구체적인 사용 경험 기반
- 독자가 결정하는 데 도움이 되는 정보
"""

    # 튜토리얼/가이드 프롬프트
    TUTORIAL_POST = """
다음 주제에 대한 초보자도 따라할 수 있는 상세한 튜토리얼을 작성해주세요.

주제: {topic}
난이도: {difficulty_level}

구성:
1. 시작하기 전에 (필요한 준비물, 사전 지식)
2. 단계별 가이드 (각 단계마다 명확한 설명)
3. 주의사항 및 팁
4. 문제 해결 (자주 발생하는 오류와 해결법)
5. 다음 단계 (추가 학습 자료)

작성 원칙:
- 각 단계는 명확하고 따라하기 쉽게
- 스크린샷이나 코드 예시 위치 표시
- 초보자 관점에서 설명
- 실수하기 쉬운 부분 강조
"""

    # SEO 최적화 메타 데이터 생성
    META_GENERATION = """
다음 블로그 글에 대한 SEO 최적화된 메타 데이터를 생성해주세요.

글 제목: {title}
주요 내용: {content_summary}
타겟 키워드: {keywords}

생성할 항목:
1. 메타 제목 (50-60자, 키워드 포함)
2. 메타 설명 (150-160자, 클릭 유도)
3. URL 슬러그 (간결하고 키워드 포함)
4. 태그 5-7개 (관련성 높은 키워드)
5. 카테고리 추천

JSON 형식으로 출력해주세요.
"""

    @staticmethod
    def get_prompt(template_type, **kwargs):
        """
        프롬프트 템플릿을 가져와서 변수를 채워 반환
        
        Args:
            template_type: 템플릿 종류
            **kwargs: 템플릿에 들어갈 변수들
        
        Returns:
            완성된 프롬프트 문자열
        """
        templates = {
            'base': PromptTemplates.BLOG_POST_BASE,
            'informative': PromptTemplates.INFORMATIVE_POST,
            'review': PromptTemplates.REVIEW_POST,
            'tutorial': PromptTemplates.TUTORIAL_POST,
            'meta': PromptTemplates.META_GENERATION
        }
        
        template = templates.get(template_type)
        if not template:
            raise ValueError(f"알 수 없는 템플릿 타입: {template_type}")
        
        try:
            return template.format(**kwargs)
        except KeyError as e:
            raise ValueError(f"필수 변수가 누락되었습니다: {e}")

    @staticmethod
    def get_system_prompt():
        """시스템 프롬프트 (AI의 역할 정의)"""
        return """
당신은 10년 경력의 전문 블로그 작가입니다. 
다양한 주제에 대해 독자들이 이해하기 쉽고 실용적인 글을 작성하는 데 탁월합니다.
당신의 글은 항상:
- 독자 친화적이고 대화하는 듯한 톤
- 정확한 정보와 구체적인 예시
- 적절한 구조와 가독성
- SEO 최적화
- 독자에게 실질적인 가치 제공

한국어로 자연스럽고 유창하게 작성하며, 문화적 맥락을 잘 이해합니다.
"""

Step 4: 주제 생성기 구현

이제 실제로 블로그 주제를 자동으로 생성하는 모듈을 만들어보자.
modules/topic_generator.py:

import requests
import json
from datetime import datetime, timedelta
from typing import List, Dict
import random

class TopicGenerator:
    """블로그 주제 자동 생성 클래스"""
    
    def __init__(self):
        self.topics_db_path = './data/topics.json'
        self.published_db_path = './data/published.json'
        self.load_databases()
    
    def load_databases(self):
        """데이터베이스 파일 로드"""
        try:
            with open(self.topics_db_path, 'r', encoding='utf-8') as f:
                self.topics_db = json.load(f)
        except FileNotFoundError:
            self.topics_db = {'topics': [], 'last_updated': None}
        
        try:
            with open(self.published_db_path, 'r', encoding='utf-8') as f:
                self.published_db = json.load(f)
        except FileNotFoundError:
            self.published_db = {'posts': []}
    
    def save_databases(self):
        """데이터베이스 파일 저장"""
        with open(self.topics_db_path, 'w', encoding='utf-8') as f:
            json.dump(self.topics_db, f, ensure_ascii=False, indent=2)
        
        with open(self.published_db_path, 'w', encoding='utf-8') as f:
            json.dump(self.published_db, f, ensure_ascii=False, indent=2)
    
    def get_trending_keywords(self, category: str = None) -> List[str]:
        """
        트렌딩 키워드 수집
        실제로는 Google Trends API나 네이버 데이터랩 API 사용
        여기서는 예시로 간단히 구현
        """
        # 실제 구현 시에는 pytrends 라이브러리 사용
        # from pytrends.request import TrendReq
        
        # 예시 키워드 (실제로는 API에서 가져옴)
        trending_keywords = {
            'tech': ['AI 자동화', '챗GPT 활용법', '노코드 도구', '생산성 앱'],
            'lifestyle': ['미니멀리즘', '재테크', '자기계발', '건강 루틴'],
            'business': ['사이드 프로젝트', '온라인 비즈니스', '마케팅 전략'],
        }
        
        if category and category in trending_keywords:
            return trending_keywords[category]
        
        # 모든 카테고리에서 랜덤 선택
        all_keywords = []
        for keywords in trending_keywords.values():
            all_keywords.extend(keywords)
        
        return random.sample(all_keywords, min(5, len(all_keywords)))
    
    def analyze_keyword_potential(self, keyword: str) -> Dict:
        """
        키워드의 잠재력 분석
        - 검색량
        - 경쟁도
        - 수익성
        """
        # 실제로는 키워드 도구 API 사용
        # 여기서는 예시로 랜덤 점수 생성
        
        return {
            'keyword': keyword,
            'search_volume': random.randint(1000, 50000),
            'competition': random.uniform(0.3, 0.9),
            'cpc': random.uniform(100, 2000),  # 클릭당 비용 (원)
            'potential_score': random.uniform(60, 95)
        }
    
    def generate_topic_ideas(self, base_keyword: str, count: int = 10) -> List[Dict]:
        """
        기본 키워드를 바탕으로 다양한 주제 아이디어 생성
        """
        # 주제 변형 패턴
        patterns = [
            f"{base_keyword} 완벽 가이드",
            f"{base_keyword} 초보자를 위한 팁",
            f"{base_keyword}로 수익 내는 방법",
            f"{base_keyword} 추천 TOP 10",
            f"{base_keyword} 실전 활용법",
            f"{base_keyword} 장단점 비교",
            f"{base_keyword} 시작하기 전에 알아야 할 것들",
            f"2024년 {base_keyword} 트렌드",
            f"{base_keyword} 성공 사례 분석",
            f"{base_keyword} 자주 묻는 질문 FAQ"
        ]
        
        topics = []
        for pattern in patterns[:count]:
            topic = {
                'title': pattern,
                'keyword': base_keyword,
                'type': self._determine_post_type(pattern),
                'priority': random.uniform(0.5, 1.0),
                'created_at': datetime.now().isoformat(),
                'status': 'pending'
            }
            topics.append(topic)
        
        return topics
    
    def _determine_post_type(self, title: str) -> str:
        """제목을 보고 글 유형 판단"""
        if '가이드' in title or '방법' in title:
            return 'tutorial'
        elif '비교' in title or '추천' in title:
            return 'review'
        elif 'FAQ' in title or '질문' in title:
            return 'informative'
        else:
            return 'base'
    
    def is_topic_already_published(self, topic_title: str) -> bool:
        """이미 발행된 주제인지 확인"""
        for post in self.published_db['posts']:
            if post['title'] == topic_title:
                return True
        return False
    
    def get_next_topic(self) -> Dict:
        """
        다음에 작성할 주제 선택
        우선순위가 높고 아직 발행되지 않은 주제
        """
        available_topics = [
            topic for topic in self.topics_db['topics']
            if topic['status'] == 'pending' 
            and not self.is_topic_already_published(topic['title'])
        ]
        
        if not available_topics:
            # 새로운 주제 생성
            keywords = self.get_trending_keywords()
            for keyword in keywords:
                new_topics = self.generate_topic_ideas(keyword, count=3)
                self.topics_db['topics'].extend(new_topics)
            
            self.save_databases()
            available_topics = [t for t in self.topics_db['topics'] if t['status'] == 'pending']
        
        # 우선순위 순으로 정렬
        available_topics.sort(key=lambda x: x['priority'], reverse=True)
        
        return available_topics[0] if available_topics else None
    
    def mark_topic_as_used(self, topic_title: str):
        """주제를 사용됨으로 표시"""
        for topic in self.topics_db['topics']:
            if topic['title'] == topic_title:
                topic['status'] = 'used'
                topic['used_at'] = datetime.now().isoformat()
                break
        
        self.save_databases()
    
    def update_topic_database(self):
        """
        주제 데이터베이스 업데이트
        주기적으로 실행하여 새로운 트렌드 반영
        """
        print("📊 주제 데이터베이스 업데이트 중...")
        
        # 트렌딩 키워드 수집
        categories = ['tech', 'lifestyle', 'business']
        all_keywords = []
        
        for category in categories:
            keywords = self.get_trending_keywords(category)
            all_keywords.extend(keywords)
        
        # 각 키워드에 대한 주제 생성
        new_topics_count = 0
        for keyword in all_keywords:
            # 키워드 잠재력 분석
            analysis = self.analyze_keyword_potential(keyword)
            
            # 잠재력이 높은 키워드만 선택
            if analysis['potential_score'] > 70:
                topics = self.generate_topic_ideas(keyword, count=5)
                
                # 중복 체크 후 추가
                for topic in topics:
                    if not any(t['title'] == topic['title'] for t in self.topics_db['topics']):
                        topic['analysis'] = analysis
                        self.topics_db['topics'].append(topic)
                        new_topics_count += 1
        
        self.topics_db['last_updated'] = datetime.now().isoformat()
        self.save_databases()
        
        print(f"✅ {new_topics_count}개의 새로운 주제가 추가되었습니다!")
        return new_topics_count


# 사용 예시
if __name__ == "__main__":
    generator = TopicGenerator()
    
    # 주제 데이터베이스 업데이트
    generator.update_topic_database()
    
    # 다음 주제 가져오기
    next_topic = generator.get_next_topic()
    print(f"\n다음 작성 주제: {next_topic['title']}")
    print(f"키워드: {next_topic['keyword']}")
    print(f"글 유형: {next_topic['type']}")
    print(f"우선순위: {next_topic['priority']:.2f}")

Step 5: 콘텐츠 생성기 구현

드디어 핵심! AI를 활용해서 실제 글을 작성하는 모듈이야.
modules/content_creator.py:

import openai
from anthropic import Anthropic
import google.generativeai as genai
from typing import Dict, Optional
import time
import json
from config.settings import Settings
from config.prompts import PromptTemplates

class ContentCreator:
    """AI를 활용한 콘텐츠 생성 클래스"""
    
    def __init__(self, ai_provider: str = 'openai'):
        """
        Args:
            ai_provider: 사용할 AI 제공자 ('openai', 'anthropic', 'google')
        """
        self.ai_provider = ai_provider
        self.setup_ai_client()
        self.prompt_templates = PromptTemplates()
    
    def setup_ai_client(self):
        """AI 클라이언트 초기화"""
        if self.ai_provider == 'openai':
            openai.api_key = Settings.OPENAI_API_KEY
            self.model = Settings.OPENAI_MODEL
            
        elif self.ai_provider == 'anthropic':
            self.client = Anthropic(api_key=Settings.ANTHROPIC_API_KEY)
            self.model = Settings.ANTHROPIC_MODEL
            
        elif self.ai_provider == 'google':
            genai.configure(api_key=Settings.GOOGLE_API_KEY)
            self.model = genai.GenerativeModel(Settings.GOOGLE_MODEL)
    
    def generate_content(self, topic: Dict, retry_count: int = 3) -> Optional[Dict]:
        """
        주제를 바탕으로 블로그 콘텐츠 생성
        
        Args:
            topic: 주제 정보 딕셔너리
            retry_count: 실패 시 재시도 횟수
        
        Returns:
            생성된 콘텐츠 딕셔너리 또는 None
        """
        print(f"✍️ '{topic['title']}' 주제로 글 작성 중...")
        
        for attempt in range(retry_count):
            try:
                # 프롬프트 생성
                prompt = self._create_prompt(topic)
                
                # AI 호출
                content = self._call_ai(prompt)
                
                if content:
                    # 메타 데이터 생성
                    meta_data = self._generate_metadata(topic, content)
                    
                    # 결과 구성
                    result = {
                        'title': topic['title'],
                        'content': content,
                        'meta': meta_data,
                        'topic': topic,
                        'created_at': time.strftime('%Y-%m-%d %H:%M:%S'),
                        'ai_provider': self.ai_provider,
                        'word_count': len(content)
                    }
                    
                    print(f"✅ 글 작성 완료! (총 {len(content)}자)")
                    return result
                
            except Exception as e:
                print(f"⚠️ 시도 {attempt + 1}/{retry_count} 실패: {str(e)}")
                if attempt < retry_count - 1:
                    time.sleep(2 ** attempt)  # 지수 백오프
                else:
                    print(f"❌ 글 생성 실패: {str(e)}")
                    return None
        
        return None
    
    def _create_prompt(self, topic: Dict) -> str:
        """주제에 맞는 프롬프트 생성"""
        post_type = topic.get('type', 'base')
        
        # 기본 파라미터
        params = {
            'topic': topic['title'],
            'keywords': topic.get('keyword', ''),
            'post_type': post_type,
            'target_audience': '일반 독자',
            'min_words': Settings.MIN_WORD_COUNT,
            'additional_requirements': ''
        }
        
        # 글 유형별 추가 요구사항
        if post_type == 'tutorial':
            params['difficulty_level'] = '초급-중급'
            return self.prompt_templates.get_prompt('tutorial', **params)
        
        elif post_type == 'review':
            params['comparison_items'] = '관련 제품/서비스'
            return self.prompt_templates.get_prompt('review', **params)
        
        elif post_type == 'informative':
            return self.prompt_templates.get_prompt('informative', **params)
        
        else:
            return self.prompt_templates.get_prompt('base', **params)
    
    def _call_ai(self, prompt: str) -> Optional[str]:
        """AI API 호출"""
        system_prompt = self.prompt_templates.get_system_prompt()
        
        if self.ai_provider == 'openai':
            response = openai.ChatCompletion.create(
                model=self.model,
                messages=[
                    {"role": "system", "content": system_prompt},
                    {"role": "user", "content": prompt}
                ],
                temperature=0.7,
                max_tokens=4000
            )
            return response.choices[0].message.content
        
        elif self.ai_provider == 'anthropic':
            response = self.client.messages.create(
                model=self.model,
                max_tokens=4000,
                system=system_prompt,
                messages=[
                    {"role": "user", "content": prompt}
                ]
            )
            return response.content[0].text
        
        elif self.ai_provider == 'google':
            full_prompt = f"{system_prompt}\n\n{prompt}"
            response = self.model.generate_content(full_prompt)
            return response.text
        
        return None
    
    def _generate_metadata(self, topic: Dict, content: str) -> Dict:
        """SEO 메타데이터 생성"""
        # 내용 요약 (첫 200자)
        content_summary = content[:200] + "..."
        
        meta_prompt = self.prompt_templates.get_prompt(
            'meta',
            title=topic['title'],
            content_summary=content_summary,
            keywords=topic.get('keyword', '')
        )
        
        try:
            meta_response = self._call_ai(meta_prompt)
            # JSON 파싱
            meta_data = json.loads(meta_response)
            return meta_data
        except:
            # 실패 시 기본 메타데이터
            return {
                'meta_title': topic['title'],
                'meta_description': content_summary,
                'slug': topic['title'].replace(' ', '-').lower(),
                'tags': [topic.get('keyword', '')],
                'category': '일반'
            }
    
    def enhance_content(self, content: str) -> str:
        """
        콘텐츠 개선 (이미지 위치 표시, 내부 링크 등)
        """
        enhanced = content
        
        # 이미지 삽입 위치 표시
        paragraphs = enhanced.split('\n\n')
        if len(paragraphs) > 3:
            # 중간 지점에 이미지 표시 추가
            mid_point = len(paragraphs) // 2
            paragraphs.insert(mid_point, "[이미지 삽입 위치]")
            enhanced = '\n\n'.join(paragraphs)
        
        # 내부 링크 기회 찾기 (간단한 예시)
        # 실제로는 더 정교한 로직 필요
        
        return enhanced
    
    def batch_generate(self, topics: list, max_concurrent: int = 3) -> list:
        """
        여러 주제에 대해 배치로 콘텐츠 생성
        
        Args:
            topics: 주제 리스트
            max_concurrent: 동시 처리 개수
        
        Returns:
            생성된 콘텐츠 리스트
        """
        results = []
        
        for i, topic in enumerate(topics):
            print(f"\n[{i+1}/{len(topics)}] 처리 중...")
            
            content = self.generate_content(topic)
            if content:
                results.append(content)
            
            # API 레이트 리밋 고려
            if i < len(topics) - 1:
                time.sleep(2)
        
        return results


# 사용 예시
if __name__ == "__main__":
    from modules.topic_generator import TopicGenerator
    
    # 주제 가져오기
    topic_gen = TopicGenerator()
    topic = topic_gen.get_next_topic()
    
    # 콘텐츠 생성
    creator = ContentCreator(ai_provider='openai')
    content = creator.generate_content(topic)
    
    if content:
        print(f"\n생성된 글:")
        print(f"제목: {content['title']}")
        print(f"글자 수: {content['word_count']}")
        print(f"메타 제목: {content['meta']['meta_title']}")
        print(f"\n본문 미리보기:")
        print(content['content'][:500] + "...")

메인 실행 파일

main.py:

import schedule
import time
from datetime import datetime
import logging
from modules.topic_generator import TopicGenerator
from modules.content_creator import ContentCreator
from modules.quality_checker import QualityChecker
from modules.publisher import Publisher
from config.settings import Settings

# 로깅 설정
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('./data/automation.log'),
        logging.StreamHandler()
    ]
)

class BlogAutomationSystem:
    """블로그 자동화 통합 시스템"""
    
    def __init__(self):
        self.topic_generator = TopicGenerator()
        self.content_creator = ContentCreator(ai_provider='openai')
        self.quality_checker = QualityChecker()
        self.publisher = Publisher(platform='tistory')
        
        self.daily_post_count = 0
        self.max_daily_posts = Settings.POSTS_PER_DAY
        
        logging.info("🚀 블로그 자동화 시스템 초기화 완료")
    
    def create_and_publish_post(self):
        """글 생성 및 발행 전체 프로세스"""
        try:
            logging.info("=" * 50)
            logging.info("📝 새 글 작성 프로세스 시작")
            
            # 1. 주제 선택
            topic = self.topic_generator.get_next_topic()
            if not topic:
                logging.warning("⚠️ 사용 가능한 주제가 없습니다.")
                return False
            
            logging.info(f"📌 선택된 주제: {topic['title']}")
            
            # 2. 콘텐츠 생성
            content = self.content_creator.generate_content(topic)
            if not content:
                logging.error("❌ 콘텐츠 생성 실패")
                return False
            
            # 3. 품질 검증
            passed, quality_result = self.quality_checker.check_quality(content)
            
            if not passed:
                logging.warning(f"⚠️ 품질 기준 미달 (점수: {quality_result['total_score']})")
                
                # 재생성 시도
                if quality_result['total_score'] >= 60:
                    logging.info("🔄 콘텐츠 개선 후 재시도...")
                    # 여기서 AI에게 피드백을 주고 재생성 요청 가능
                    # 간단히 하기 위해 생략
                
                return False
            
            logging.info(f"✅ 품질 검증 통과 (점수: {quality_result['total_score']})")
            
            # 4. 발행
            if Settings.AUTO_PUBLISH:
                success = self.publisher.publish(content)
                
                if success:
                    # 주제를 사용됨으로 표시
                    self.topic_generator.mark_topic_as_used(topic['title'])
                    self.daily_post_count += 1
                    
                    logging.info(f"🎉 발행 완료! (오늘 {self.daily_post_count}/{self.max_daily_posts})")
                    return True
                else:
                    logging.error("❌ 발행 실패")
                    return False
            else:
                logging.info("💾 자동 발행 비활성화 - 콘텐츠 저장만 수행")
                # 콘텐츠를 파일로 저장
                self._save_content_to_file(content)
                return True
                
        except Exception as e:
            logging.error(f"❌ 오류 발생: {str(e)}", exc_info=True)
            return False
    
    def _save_content_to_file(self, content: Dict):
        """콘텐츠를 파일로 저장"""
        import json
        from datetime import datetime
        
        filename = f"./data/drafts/{datetime.now().strftime('%Y%m%d_%H%M%S')}_{content['title'][:20]}.json"
        
        with open(filename, 'w', encoding='utf-8') as f:
            json.dump(content, f, ensure_ascii=False, indent=2)
        
        logging.info(f"💾 콘텐츠 저장: {filename}")
    
    def daily_routine(self):
        """일일 루틴 실행"""
        logging.info("🌅 일일 루틴 시작")
        
        # 일일 카운터 리셋
        self.daily_post_count = 0
        
        # 주제 데이터베이스 업데이트 (주 1회)
        if datetime.now().weekday() == 6:  # 일요일
            logging.info("📊 주간 주제 데이터베이스 업데이트")
            self.topic_generator.update_topic_database()
        
        # 오늘 발행할 글 개수만큼 생성
        for i in range(self.max_daily_posts):
            logging.info(f"\n[{i+1}/{self.max_daily_posts}] 글 작성 시작")
            
            success = self.create_and_publish_post()
            
            if success:
                # 다음 글까지 대기 (1-2시간)
                wait_minutes = 60 + (i * 30)
                logging.info(f"⏰ {wait_minutes}분 후 다음 글 작성 예정")
                time.sleep(wait_minutes * 60)
            else:
                logging.warning("⚠️ 글 작성 실패 - 30분 후 재시도")
                time.sleep(30 * 60)
        
        logging.info("🌙 일일 루틴 완료")
    
    def run_scheduler(self):
        """스케줄러 실행"""
        logging.info("⏰ 스케줄러 시작")
        
        # 매일 오전 9시에 일일 루틴 실행
        schedule.every().day.at("09:00").do(self.daily_routine)
        
        # 매주 일요일 자정에 주제 업데이트
        schedule.every().sunday.at("00:00").do(
            self.topic_generator.update_topic_database
        )
        
        logging.info("📅 스케줄 등록 완료")
        logging.info("  - 매일 09:00: 일일 루틴")
        logging.info("  - 매주 일요일 00:00: 주제 업데이트")
        
        # 무한 루프로 스케줄 실행
        while True:
            schedule.run_pending()
            time.sleep(60)  # 1분마다 체크
    
    def run_once(self):
        """한 번만 실행 (테스트용)"""
        logging.info("🧪 테스트 모드: 1회 실행")
        self.create_and_publish_post()
    
    def generate_report(self):
        """성과 리포트 생성"""
        import json
        
        with open('./data/published.json', 'r', encoding='utf-8') as f:
            published_data = json.load(f)
        
        total_posts = len(published_data['posts'])
        
        if total_posts == 0:
            logging.info("📊 아직 발행된 글이 없습니다.")
            return
        
        # 최근 30일 통계
        from datetime import datetime, timedelta
        thirty_days_ago = datetime.now() - timedelta(days=30)
        
        recent_posts = [
            p for p in published_data['posts']
            if datetime.fromisoformat(p['published_at']) > thirty_days_ago
        ]
        
        logging.info("=" * 50)
        logging.info("📊 블로그 자동화 성과 리포트")
        logging.info("=" * 50)
        logging.info(f"총 발행 글 수: {total_posts}개")
        logging.info(f"최근 30일 발행: {len(recent_posts)}개")
        logging.info(f"일평균 발행: {len(recent_posts) / 30:.1f}개")
        
        # AI 제공자별 통계
        ai_stats = {}
        for post in published_data['posts']:
            provider = post.get('ai_provider', 'unknown')
            ai_stats[provider] = ai_stats.get(provider, 0) + 1
        
        logging.info("\nAI 제공자별 사용:")
        for provider, count in ai_stats.items():
            logging.info(f"  {provider}: {count}개 ({count/total_posts*100:.1f}%)")
        
        logging.info("=" * 50)


def main():
    """메인 함수"""
    import sys
    
    system = BlogAutomationSystem()
    
    # 명령행 인자 처리
    if len(sys.argv) > 1:
        command = sys.argv[1]
        
        if command == 'once':
            # 1회 실행
            system.run_once()
        
        elif command == 'daily':
            # 일일 루틴 실행
            system.daily_routine()
        
        elif command == 'report':
            # 리포트 생성
            system.generate_report()
        
        elif command == 'update-topics':
            # 주제 업데이트만
            system.topic_generator.update_topic_database()
        
        else:
            print("사용법: python main.py [once|daily|report|update-topics]")
    
    else:
        # 기본: 스케줄러 실행
        system.run_scheduler()


if __name__ == "__main__":
    main()

systemd 서비스 등록 (Linux)

서버에서 자동으로 시작되고 재시작되도록 설정하자.
/etc/systemd/system/blog-automation.service:

[Unit]
Description=Blog Automation System
After=network.target

[Service]
Type=simple
User=ubuntu
WorkingDirectory=/home/ubuntu/blog_automation
Environment="PATH=/home/ubuntu/blog_automation/venv/bin"
ExecStart=/home/ubuntu/blog_automation/venv/bin/python main.py
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

서비스 등록 및 시작:

# 서비스 등록
sudo systemctl daemon-reload
sudo systemctl enable blog-automation

# 서비스 시작
sudo systemctl start blog-automation

# 상태 확인
sudo systemctl status blog-automation

# 로그 확인
sudo journalctl -u blog-automation -f

성과 지표 추적

추적해야 할 핵심 지표들:

자동 최적화 시스템

성과 데이터를 바탕으로 자동으로 개선하는 시스템을 추가할 수 있어:

class PerformanceOptimizer:
    """성과 기반 자동 최적화"""
    
    def __init__(self):
        self.performance_data = self.load_performance_data()
    
    def analyze_best_practices(self):
        """성과 좋은 글의 패턴 분석"""
        top_posts = sorted(
            self.performance_data,
            key=lambda x: x['views'],
            reverse=True
        )[:20]
        
        # 공통 패턴 추출
        patterns = {
            'avg_title_length': sum(len(p['title']) for p in top_posts) / len(top_posts),
            'common_keywords': self._extract_common_keywords(top_posts),
            'optimal_word_count': sum(p['word_count'] for p in top_posts) / len(top_posts),
            'best_publish_hours': self._find_best_hours(top_posts)
        }
        
        return patterns
    
    def adjust_settings(self, patterns):
        """설정 자동 조정"""
        # 최적 단어 수 반영
        Settings.MIN_WORD_COUNT = int(patterns['optimal_word_count'] * 0.9)
        Settings.MAX_WORD_COUNT = int(patterns['optimal_word_count'] * 1.1)
        
        # 최적 발행 시간 반영
        Settings.PUBLISH_TIMES = patterns['best_publish_hours']
        
        logging.info("⚙️ 설정 자동 조정 완료")
        logging.info(f"  목표 단어 수: {Settings.MIN_WORD_COUNT}-{Settings.MAX_WORD_COUNT}")
        logging.info(f"  발행 시간: {Settings.PUBLISH_TIMES}")

1. 이미지 자동 생성 및 삽입

글만 있으면 심심하잖아? 이미지를 자동으로 생성해서 넣어보자!

from openai import OpenAI
import requests
from PIL import Image
from io import BytesIO

class ImageGenerator:
    """AI 이미지 생성 및 관리"""
    
    def __init__(self):
        self.client = OpenAI(api_key=Settings.OPENAI_API_KEY)
    
    def generate_featured_image(self, title: str, description: str) -> str:
        """
        대표 이미지 생성 (DALL-E 3 사용)
        
        Returns:
            이미지 URL
        """
        prompt = f"""
        Create a professional blog featured image for:
        Title: {title}
        Description: {description}
        
        Style: Modern, clean, professional
        No text in image
        """
        
        response = self.client.images.generate(
            model="dall-e-3",
            prompt=prompt,
            size="1792x1024",
            quality="standard",
            n=1
        )
        
        image_url = response.data[0].url
        
        # 이미지 다운로드 및 저장
        local_path = self._download_and_save(image_url, title)
        
        return local_path
    
    def _download_and_save(self, url: str, title: str) -> str:
        """이미지 다운로드 및 로컬 저장"""
        response = requests.get(url)
        img = Image.open(BytesIO(response.content))
        
        # 파일명 생성
        filename = f"./data/images/{slugify(title)}.png"
        img.save(filename)
        
        return filename
    
    def find_stock_images(self, keyword: str, count: int = 3) -> list:
        """
        무료 스톡 이미지 검색 (Unsplash API)
        """
        url = "https://api.unsplash.com/search/photos"
        params = {
            'query': keyword,
            'per_page': count,
            'client_id': 'your_unsplash_access_key'
        }
        
        response = requests.get(url, params=params)
        data = response.json()
        
        images = []
        for photo in data['results']:
            images.append({
                'url': photo['urls']['regular'],
                'alt': photo['alt_description'],
                'credit': photo['user']['name']
            })
        
        return images

2. 소셜 미디어 자동 공유

글을 발행하면 자동으로 SNS에도 공유하자!

import tweepy  # Twitter
from facebook import GraphAPI  # Facebook

class SocialMediaManager:
    """소셜 미디어 자동 공유"""
    
    def __init__(self):
        self.setup_twitter()
        self.setup_facebook()
    
    def setup_twitter(self):
        """트위터 API 설정"""
        auth = tweepy.OAuthHandler(
            'consumer_key',
            'consumer_secret'
        )
        auth.set_access_token(
            'access_token',
            'access_token_secret'
        )
        self.twitter = tweepy.API(auth)
    
    def setup_facebook(self):
        """페이스북 API 설정"""
        self.facebook = GraphAPI(access_token='your_access_token')
    
    def share_to_twitter(self, post: Dict):
        """트위터에 공유"""
        # 트윗 작성 (280자 제한)
        tweet_text = f"{post['title']}\n\n{post['meta']['meta_description'][:100]}...\n\n{post['url']}"
        
        # 해시태그 추가
        tags = ' '.join(f"#{tag}" for tag in post['meta']['tags'][:3])
        tweet_text += f"\n\n{tags}"
        
        try:
            self.twitter.update_status(tweet_text)
            print("✅ 트위터 공유 완료")
        except Exception as e:
            print(f"❌ 트위터 공유 실패: {e}")
    
    def share_to_facebook(self, post: Dict):
        """페이스북 페이지에 공유"""
        try:
            self.facebook.put_object(
                parent_object='me',
                connection_name='feed',
                message=post['meta']['meta_description'],
                link=post['url']
            )
            print("✅ 페이스북 공유 완료")
        except Exception as e:
            print(f"❌ 페이스북 공유 실패: {e}")

3. 성과 대시보드

웹 대시보드를 만들어서 실시간으로 성과를 모니터링하자!

from flask import Flask, render_template, jsonify
import json
from datetime import datetime, timedelta

app = Flask(__name__)

@app.route('/')
def dashboard():
    """메인 대시보드"""
    return render_template('dashboard.html')

@app.route('/api/stats')
def get_stats():
    """통계 데이터 API"""
    with open('./data/published.json', 'r') as f:
        data = json.load(f)
    
    # 최근 30일 통계
    thirty_days_ago = datetime.now() - timedelta(days=30)
    recent_posts = [
        p for p in data['posts']
        if datetime.fromisoformat(p['published_at']) > thirty_days_ago
    ]
    
    stats = {
        'total_posts': len(data['posts']),
        'recent_posts': len(recent_posts),
        'avg_daily': len(recent_posts) / 30,
        'total_words': sum(p['word_count'] for p in data['posts']),
        'ai_usage': {
            'openai': sum(1 for p in data['posts'] if p['ai_provider'] == 'openai'),
            'anthropic': sum(1 for p in data['posts'] if p['ai_provider'] == 'anthropic'),
            'google': sum(1 for p in data['posts'] if p['ai_provider'] == 'google')
        }
    }
    
    return jsonify(stats)

@app.route('/api/recent-posts')
def get_recent_posts():
    """최근 발행 글 목록"""
    with open('./data/published.json', 'r') as f:
        data = json.load(f)
    
    recent = sorted(
        data['posts'],
        key=lambda x: x['published_at'],
        reverse=True
    )[:10]
    
    return jsonify(recent)

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

간단한 HTML 대시보드 (templates/dashboard.html):

<!DOCTYPE html>
<html>
<head>
    <title>블로그 자동화 대시보드</title>
    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
    <style>
        body { font-family: Arial; padding: 20px; }
        .stat-box { 
            display: inline-block; 
            padding: 20px; 
            margin: 10px;
            background: #f0f0f0;
            border-radius: 8px;
        }
        .stat-value { font-size: 2em; font-weight: bold; }
    </style>
</head>
<body>
    <h1>📊 블로그 자동화 대시보드</h1>
    
    <div id="stats"></div>
    
    <h2>최근 발행 글</h2>
    <div id="recent-posts"></div>
    
    <script>
        // 통계 로드
        fetch('/api/stats')
            .then(r => r.json())
            .then(data => {
                document.getElementById('stats').innerHTML = `
                    <div class="stat-box">
                        <div>총 발행 글</div>
                        <div class="stat-value">${data.total_posts}</div>
                    </div>
                    <div class="stat-box">
                        <div>최근 30일</div>
                        <div class="stat-value">${data.recent_posts}</div>
                    </div>
                    <div class="stat-box">
                        <div>일평균</div>
                        <div class="stat-value">${data.avg_daily.toFixed(1)}</div>
                    </div>
                `;
            });
        
        // 최근 글 로드
        fetch('/api/recent-posts')
            .then(r => r.json())
            .then(posts => {
                const html = posts.map(p => `
                    <div style="padding: 10px; border-bottom: 1px solid #ddd;">
                        <strong>${p.title}</strong><br>
                        <small>${p.published_at} | ${p.word_count}자 | ${p.ai_provider}</small>
                    </div>
                `).join('');
                document.getElementById('recent-posts').innerHTML = html;
            });
    </script>
</body>
</html>